/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openjpa.jdbc.sql;
import java.sql.SQLException;
import org.apache.commons.lang.ObjectUtils;
import org.apache.openjpa.jdbc.meta.ClassMapping;
import org.apache.openjpa.jdbc.meta.RelationId;
import org.apache.openjpa.jdbc.schema.Column;
import org.apache.openjpa.jdbc.schema.ColumnIO;
import org.apache.openjpa.jdbc.schema.ForeignKey;
import org.apache.openjpa.jdbc.schema.Table;
import org.apache.openjpa.kernel.OpenJPAStateManager;
import org.apache.openjpa.lib.util.Localizer;
import org.apache.openjpa.util.InvalidStateException;
/**
* Primary table row that tracks foreign keys and auto-inc columns.
*
* @author Abe White
* @nojavadoc
*/
public class PrimaryRow
extends RowImpl {
// VALID flag in superclass uses 2 << 0
private static final byte PK_SET = 2 << 1;
private static final byte PK_WHERE = 2 << 2;
private static final byte DEPENDENT = 2 << 4;
private static final Localizer _loc = Localizer.forPackage
(PrimaryRow.class);
private OpenJPAStateManager _pk = null;
private ColumnIO _pkIO = null;
private OpenJPAStateManager[] _fkSet = null;
private ColumnIO[] _fkIO = null;
private OpenJPAStateManager[] _fkWhere = null;
private OpenJPAStateManager[] _relSet = null;
private RelationId[] _callbacks = null;
private Object _failed = null;
private int _idx = -1;
/**
* Constructor; supply table and action.
*/
public PrimaryRow(Table table, int action, OpenJPAStateManager owner) {
this(table.getColumns(), action, owner);
}
protected PrimaryRow(Column[] cols, int action, OpenJPAStateManager owner) {
super(cols, action);
_pk = owner;
}
/**
* Mark this row as dependent on some other row.
*/
public boolean isDependent() {
return (flags & DEPENDENT) > 0;
}
/**
* Mark this row as dependent on some other row.
*/
public void setDependent(boolean dependent) {
if (dependent)
flags |= DEPENDENT;
else
flags &= ~DEPENDENT;
}
/**
* The index of this row in ordered row list.
*/
public int getIndex() {
return _idx;
}
/**
* The index of this row in ordered row list.
*/
public void setIndex(int idx) {
_idx = idx;
}
public Object getFailedObject() {
return _failed;
}
public void setFailedObject(Object failed) {
_failed = failed;
}
public OpenJPAStateManager getPrimaryKey() {
return _pk;
}
public void setPrimaryKey(OpenJPAStateManager sm)
throws SQLException {
setPrimaryKey(null, sm);
}
public void setPrimaryKey(ColumnIO io, OpenJPAStateManager sm) {
_pk = sm;
flags |= PK_SET;
_pkIO = io;
// force valid
setValid(true);
}
public void wherePrimaryKey(OpenJPAStateManager sm)
throws SQLException {
_pk = sm;
flags |= PK_WHERE;
// force valid
if (getAction() == ACTION_DELETE)
setValid(true);
}
/**
* Return the I/O information for the given set foreign key.
*/
public ColumnIO getForeignKeyIO(ForeignKey fk) {
return (_fkIO == null) ? null : _fkIO[fk.getIndex()];
}
/**
* Return the value for the given foreign key. Values not needed for
* constraint analyses are not recorded.
*/
public OpenJPAStateManager getForeignKeySet(ForeignKey fk) {
return (_fkSet == null) ? null : _fkSet[fk.getIndex()];
}
/**
* Return the value for the given foreign key. Values not needed for
* constraint analyses are not recorded.
*/
public OpenJPAStateManager getForeignKeyWhere(ForeignKey fk) {
return (_fkWhere == null) ? null : _fkWhere[fk.getIndex()];
}
public void setForeignKey(ForeignKey fk, OpenJPAStateManager sm)
throws SQLException {
setForeignKey(fk, null, sm);
}
public void setForeignKey(ForeignKey fk, ColumnIO io,
OpenJPAStateManager sm)
throws SQLException {
if (!delayForeignKey(fk, sm, true))
super.setForeignKey(fk, io, sm);
else
recordForeignKey(fk, io, sm, true);
}
public void whereForeignKey(ForeignKey fk, OpenJPAStateManager sm)
throws SQLException {
if (!delayForeignKey(fk, sm, false))
super.whereForeignKey(fk, sm);
else
recordForeignKey(fk, null, sm, false);
}
public void clearForeignKey(ForeignKey fk)
throws SQLException {
super.clearForeignKey(fk);
if (_fkSet != null)
_fkSet[fk.getIndex()] = null;
if (_fkIO != null)
_fkIO[fk.getIndex()] = null;
}
/**
* If this is a delete, delay foreign keys to other deleted objects if the
* key is restricted or cascade. If this is an update or insert, delay
* foreign keys to other inserts if the key is not logical. If the foreign
* key is to a new record and the columns are auto-inc, record it.
*/
private boolean delayForeignKey(ForeignKey fk, OpenJPAStateManager sm,
boolean set) {
if (sm == null)
return false;
if (getAction() == ACTION_DELETE)
return sm.isDeleted() && !fk.isDeferred()
&& (fk.getDeleteAction() == ForeignKey.ACTION_RESTRICT ||
fk.getDeleteAction() == ForeignKey.ACTION_CASCADE);
if (!sm.isNew() || sm.isFlushed())
return false;
if (!fk.isDeferred() && !fk.isLogical())
return true;
if (fk.isPrimaryKeyAutoAssigned())
return true;
return false;
}
/**
* Record a delayed foreign key.
*/
private void recordForeignKey(ForeignKey fk, ColumnIO io,
OpenJPAStateManager sm, boolean set) {
if (set) {
// force valid
if (canSetAny(io, fk.getColumns().length
+ fk.getConstantColumns().length, false))
setValid(true);
if (_fkSet == null)
_fkSet = new OpenJPAStateManager[getTable().
getForeignKeys().length];
_fkSet[fk.getIndex()] = sm;
if (_fkIO != null)
_fkIO[fk.getIndex()] = io;
else if (io != null && ((getAction() == ACTION_INSERT
&& !io.isAllInsertable(fk, false))
|| (getAction() != ACTION_INSERT
&& !io.isAllUpdatable(fk, false)))) {
_fkIO = new ColumnIO[_fkSet.length];
_fkIO[fk.getIndex()] = io;
}
} else {
// force valid
if (getAction() == ACTION_DELETE)
setValid(true);
if (_fkWhere == null)
_fkWhere = new OpenJPAStateManager[getTable().
getForeignKeys().length];
_fkWhere[fk.getIndex()] = sm;
}
}
/**
* Return the recorded value for the given relation id column. Only
* values that are dependent on a new, unflushed auto-assigned instance
* are recorded.
*/
public OpenJPAStateManager getRelationIdSet(Column col) {
return (_relSet == null) ? null : _relSet[getRelationIdIndex(col)];
}
/**
* Return the recorded callbacks for the given relation id column. Only
* values that are dependent on a new, unflushed auto-assigned instance
* are recorded.
*/
public RelationId getRelationIdCallback(Column col) {
return (_callbacks == null) ? null
: _callbacks[getRelationIdIndex(col)];
}
public void setRelationId(Column col, OpenJPAStateManager sm,
RelationId rel)
throws SQLException {
if (sm == null || sm.getObjectId() != null || !sm.isNew()
|| sm.isFlushed() || !isPrimaryKeyAutoAssigned(sm))
super.setRelationId(col, sm, rel);
else {
if (_relSet == null) {
Column[] cols = getTable().getRelationIdColumns();
_relSet = new OpenJPAStateManager[cols.length];
_callbacks = new RelationId[cols.length];
}
int idx = getRelationIdIndex(col);
_relSet[idx] = sm;
_callbacks[idx] = rel;
}
}
public void clearRelationId(Column col)
throws SQLException {
super.clearRelationId(col);
if (_relSet != null) {
int idx = getRelationIdIndex(col);
_relSet[idx] = null;
_callbacks[idx] = null;
}
}
/**
* Return the index into our relation id array of the value for the
* given column.
*/
private int getRelationIdIndex(Column col) {
Column[] cols = getTable().getRelationIdColumns();
for (int i = 0; i < cols.length; i++)
if (cols[i] == col)
return i;
return -1;
}
/**
* Return true if any primary key columns of the given instance are
* auto-assigned.
*/
private static boolean isPrimaryKeyAutoAssigned(OpenJPAStateManager sm) {
ClassMapping cls = (ClassMapping) sm.getMetaData();
while (cls.getJoinablePCSuperclassMapping() != null)
cls = cls.getJoinablePCSuperclassMapping();
Column[] cols = cls.getPrimaryKeyColumns();
for (int i = 0; i < cols.length; i++)
if (cols[i].isAutoAssigned())
return true;
return false;
}
protected void setObject(Column col, Object val, int metaType,
boolean overrideDefault)
throws SQLException {
// make sure we're not setting two different values
// unless the given column is an implicit relationship and value
// changes from logical default to non-default
Object prev = getSet(col);
if (prev != null) {
if (prev == NULL)
prev = null;
if (!rowValueEquals(prev, val)) {
if (isDefaultValue(prev) || allowsUpdate(col, prev, val)) {
super.setObject(col, val, metaType, overrideDefault);
} else if (!isDefaultValue(prev)) {
throw new InvalidStateException(_loc.get("diff-values",
new Object[]{ col.getFullDBIdentifier().getName(),
(prev == null) ? null : prev.getClass(), prev,
(val == null) ? null : val.getClass(), val })).
setFatal(true);
} else {
// since not allow to update and the new value is 0 or null,
// just return.
return;
}
}
}
super.setObject(col, val, metaType, overrideDefault);
}
/**
* Allow the given column value to be updated only if old or current value
* is a default value or was not set and the column is not a primary key.
*/
boolean allowsUpdate(Column col, Object old, Object cur) {
return ((!col.isPrimaryKey() && col.isImplicitRelation()) ||
col.isUni1MFK()) && (isDefaultValue(old));
}
boolean isDefaultValue(Object val) {
return val == null || val == NULL
|| (val instanceof Number && ((Number)val).longValue() == 0);
}
/**
* Return true if the two values should be considered equal.
*/
private static boolean rowValueEquals(Object o1, Object o2) {
if (ObjectUtils.equals(o1, o2))
return true;
// check for numeric equality (bug #1151)
return o1 instanceof Number && o2 instanceof Number
&& ((Number) o1).doubleValue() == ((Number) o2).doubleValue();
}
protected String generateSQL(DBDictionary dict) {
try {
if ((flags & PK_SET) > 0)
super.setPrimaryKey(_pkIO, _pk);
if ((flags & PK_WHERE) > 0)
super.wherePrimaryKey(_pk);
if (_fkSet != null) {
ForeignKey[] fks = getTable().getForeignKeys();
ColumnIO io;
for (int i = 0; i < _fkSet.length; i++) {
if (_fkSet[i] != null) {
io = (_fkIO == null) ? null : _fkIO[i];
super.setForeignKey(fks[i], io, _fkSet[i]);
}
}
}
if (_relSet != null) {
Column[] cols = getTable().getRelationIdColumns();
for (int i = 0; i < _relSet.length; i++)
if (_relSet[i] != null)
super.setRelationId(cols[i], _relSet[i], _callbacks[i]);
}
if (_fkWhere != null) {
ForeignKey[] fks = getTable().getForeignKeys();
for (int i = 0; i < _fkWhere.length; i++)
if (_fkWhere[i] != null)
super.whereForeignKey(fks[i], _fkWhere[i]);
}
}
catch (SQLException se) {
throw SQLExceptions.getStore(se, dict);
}
return super.generateSQL(dict);
}
protected RowImpl newInstance(Column[] cols, int action) {
return new PrimaryRow(cols, action, _pk);
}
public void copyInto(RowImpl row, boolean whereOnly) {
super.copyInto(row, whereOnly);
if (!(row instanceof PrimaryRow))
return;
PrimaryRow prow = (PrimaryRow) row;
prow._pk = _pk;
prow._pkIO = _pkIO;
if ((flags & PK_WHERE) > 0)
prow.flags |= PK_WHERE;
if (!whereOnly && (flags & PK_SET) > 0)
prow.flags |= PK_SET;
if (_fkWhere != null) {
if (prow._fkWhere == null)
prow._fkWhere = new OpenJPAStateManager[_fkWhere.length];
System.arraycopy(_fkWhere, 0, prow._fkWhere, 0, _fkWhere.length);
}
if (!whereOnly && _fkSet != null) {
if (prow._fkSet == null)
prow._fkSet = new OpenJPAStateManager[_fkSet.length];
System.arraycopy(_fkSet, 0, prow._fkSet, 0, _fkSet.length);
if (_fkIO != null) {
if (prow._fkIO == null)
prow._fkIO = new ColumnIO[_fkIO.length];
System.arraycopy(_fkIO, 0, prow._fkIO, 0, _fkIO.length);
}
}
if (!whereOnly && _relSet != null) {
if (prow._relSet == null) {
prow._relSet = new OpenJPAStateManager[_relSet.length];
prow._callbacks = new RelationId[_callbacks.length];
}
System.arraycopy(_relSet, 0, prow._relSet, 0, _relSet.length);
System.arraycopy(_callbacks, 0, prow._callbacks, 0,
_callbacks.length);
}
}
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append("PrimaryRow[");
switch (getAction()) {
case ACTION_UPDATE: buf.append("UPDATE"); break;
case ACTION_INSERT: buf.append("INSERT"); break;
case ACTION_DELETE: buf.append("DELETE"); break;
default: buf.append("UNKNOWN");
}
buf.append(" ").append(getTable().getName()).append("]: ");
buf.append(_pk);
return buf.toString();
}
}