public void delete(OpenJPAStateManager sm, JDBCStore store, RowManager rm) throws SQLException {
if (field.getMappedBy() != null) return;
// if nullable, null any existing inverse columns that refer to this obj
ValueMapping elem = field.getElementMapping();
ColumnIO io = elem.getColumnIO();
ForeignKey fk = elem.getForeignKey();
if (!elem.getUseClassCriteria() && io.isAnyUpdatable(fk, true)) {
assertInversable();
Row row = rm.getAllRows(fk.getTable(), Row.ACTION_UPDATE);
row.setForeignKey(fk, io, null);
row.whereForeignKey(fk, sm);
rm.flushAllRows(row);
return;
}
if (!sm.getLoaded().get(field.getIndex())) return;
// update fk on each field value row
ClassMapping rel = field.getElementMapping().getTypeMapping();
StoreContext ctx = store.getContext();
Collection objs = toCollection(sm.fetchObject(field.getIndex()));
if (objs != null && !objs.isEmpty())
for (Iterator itr = objs.iterator(); itr.hasNext(); )
updateInverse(ctx, itr.next(), rel, rm, sm, 0);
}
private void insert(OpenJPAStateManager sm, RowManager rm, Object vals) throws SQLException {
if (field.getMappedBy() != null && !_orderInsert && !_orderUpdate) return;
Collection coll = toCollection(vals);
if (coll == null || coll.isEmpty()) return;
ClassMapping rel = field.getElementMapping().getTypeMapping();
int idx = 0;
for (Iterator itr = coll.iterator(); itr.hasNext(); idx++)
updateInverse(sm.getContext(), itr.next(), rel, rm, sm, idx);
}
/** This method updates the inverse columns of a 1-M related object with the given oid. */
private void updateInverse(
StoreContext ctx,
Object inverse,
ClassMapping rel,
RowManager rm,
OpenJPAStateManager sm,
int idx)
throws SQLException {
OpenJPAStateManager invsm = RelationStrategies.getStateManager(inverse, ctx);
if (invsm == null) return;
ValueMapping elem = field.getElementMapping();
ForeignKey fk = elem.getForeignKey();
ColumnIO io = elem.getColumnIO();
Column order = field.getOrderColumn();
int action;
boolean writeable;
boolean orderWriteable;
if (invsm.isNew() && !invsm.isFlushed()) {
// no need to null inverse columns of new instance
if (sm == null || sm.isDeleted()) return;
writeable = io.isAnyInsertable(fk, false);
orderWriteable = _orderInsert;
action = Row.ACTION_INSERT;
} else if (invsm.isDeleted()) {
// no need to null inverse columns of deleted instance
if (invsm.isFlushed() || sm == null || !sm.isDeleted()) return;
writeable = true;
orderWriteable = false;
action = Row.ACTION_DELETE;
} else {
if (sm != null && sm.isDeleted()) sm = null;
writeable = io.isAnyUpdatable(fk, sm == null);
orderWriteable = field.getOrderColumnIO().isUpdatable(order, sm == null);
action = Row.ACTION_UPDATE;
}
if (!writeable && !orderWriteable) return;
assertInversable();
// if this is an update, this might be the only mod to the row, so
// make sure the where condition is set
Row row = rm.getRow(fk.getTable(), action, invsm, true);
if (action == Row.ACTION_UPDATE) row.wherePrimaryKey(invsm);
// update the inverse pointer with our oid value
if (writeable) row.setForeignKey(fk, io, sm);
if (orderWriteable) row.setInt(order, idx);
}
public Row getRow(Table table, int action, OpenJPAStateManager sm, boolean create) {
if (sm == null) return null;
// check if request matches cached version
if (_key != null
&& _key.table == table
&& _key.sm == sm
&& _row != null
&& _row.getAction() == action) return _row;
Map<Key, PrimaryRow> map;
if (action == Row.ACTION_DELETE) {
if (_deletes == null && create) _deletes = new LinkedHashMap<Key, PrimaryRow>();
map = _deletes;
} else if (action == Row.ACTION_INSERT) {
if (_inserts == null && create) _inserts = new LinkedHashMap<Key, PrimaryRow>();
map = _inserts;
} else {
if (_updates == null && create) _updates = new LinkedHashMap<Key, PrimaryRow>();
map = _updates;
}
if (map == null) return null;
_key = new Key(table, sm);
_row = map.get(_key);
if (_row == null && create) {
_row = new PrimaryRow(table, action, sm);
map.put(_key, _row);
if (_primaryOrder != null) {
_row.setIndex(_primaryOrder.size());
_primaryOrder.add(_row);
}
if (!_auto && action == Row.ACTION_INSERT) _auto = table.getAutoAssignedColumns().length > 0;
}
if (_row != null) _row.setFailedObject(sm.getManagedInstance());
return _row;
}
public void update(OpenJPAStateManager sm, JDBCStore store, RowManager rm) throws SQLException {
if (field.getMappedBy() != null && !_orderInsert && !_orderUpdate) return;
Object obj = sm.fetchObject(field.getIndex());
ChangeTracker ct = null;
if (obj instanceof Proxy) {
Proxy proxy = (Proxy) obj;
if (Proxies.isOwner(proxy, sm, field.getIndex())) ct = proxy.getChangeTracker();
}
Column order = field.getOrderColumn();
// if no fine-grained change tracking then just delete and reinsert
// if no fine-grained change tracking or if an item was removed
// from an ordered collection, delete and reinsert
if (ct == null || !ct.isTracking() || (order != null && !ct.getRemoved().isEmpty())) {
delete(sm, store, rm);
insert(sm, rm, obj);
return;
}
// null inverse columns for deletes and update them with our oid for
// inserts
ClassMapping rel = field.getElementMapping().getTypeMapping();
StoreContext ctx = store.getContext();
if (field.getMappedBy() == null) {
Collection rem = ct.getRemoved();
for (Iterator itr = rem.iterator(); itr.hasNext(); )
updateInverse(ctx, itr.next(), rel, rm, null, 0);
}
Collection add = ct.getAdded();
int seq = ct.getNextSequence();
for (Iterator itr = add.iterator(); itr.hasNext(); seq++)
updateInverse(ctx, itr.next(), rel, rm, sm, seq);
if (order != null) ct.setNextSequence(seq);
}
public int hashCode() {
return ((table == null) ? 0 : table.hashCode())
+ ((sm == null) ? 0 : sm.hashCode()) % Integer.MAX_VALUE;
}
public void insert(OpenJPAStateManager sm, JDBCStore store, RowManager rm) throws SQLException {
if (field.getMappedBy() == null || _orderInsert || _orderUpdate)
insert(sm, rm, sm.fetchObject(field.getIndex()));
}