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);
}

 protected ClassMapping[] getIndependentElementMappings(boolean traverse) 
{
        
        return field.getElementMapping().getIndependentTypeMappings();
}

 protected ForeignKey getJoinForeignKey(ClassMapping elem) 
{
        return field.getElementMapping().getForeignKey(elem);
}

 public  void initialize() 
{
        Column order = field.getOrderColumn();
        _orderInsert = field.getOrderColumnIO().isInsertable(order, false);
        _orderUpdate = field.getOrderColumnIO().isUpdatable(order, false);
        ValueMapping elem = field.getElementMapping();
        Log log = field.getRepository().getLog();
        if (field.getMappedBy() == null
            && elem.getUseClassCriteria() && log.isWarnEnabled()) {
            ForeignKey fk = elem.getForeignKey();
            if (elem.getColumnIO().isAnyUpdatable(fk, false))
                log.warn(_loc.get("class-crit-owner", field));
        }
}

 public  void insert(OpenJPAStateManager sm,
    JDBCStore store,
    RowManager rm) throws SQLException 
{
        if (field.getMappedBy() == null || _orderInsert || _orderUpdate)
            insert(sm, rm, sm.fetchObject(field.getIndex()));
}

 protected Joins join(Joins joins,
    ClassMapping elem) 
{
        ValueMapping vm = field.getElementMapping();
        ForeignKey fk = vm.getForeignKey(elem);
        ClassMapping owner = field.getDefiningMapping();
        while (fk.getPrimaryKeyTable() != owner.getTable()) {
            joins = owner.joinSuperclass(joins, false);
            owner = owner.getJoinablePCSuperclassMapping(); 
            if (owner == null)
                throw new InternalException();
        }
        return joins.joinRelation(field.getName(), fk, elem, 
            vm.getSelectSubclasses(), true, true);
}

 public Joins join(Joins joins,
    boolean forceOuter) 
{
        ValueMapping elem = field.getElementMapping();
        ClassMapping[] clss = elem.getIndependentTypeMappings();
        if (clss.length != 1)
            throw RelationStrategies.unjoinable(elem);
        if (forceOuter)
            return joins.outerJoinRelation(field.getName(), 
                elem.getForeignKey(clss[0]), clss[0],
                elem.getSelectSubclasses(), true, true);
        return joins.joinRelation(field.getName(), elem.getForeignKey(clss[0]),
            clss[0], elem.getSelectSubclasses(), true, true);
}

 protected Joins joinElementRelation(Joins joins,
    ClassMapping elem) 
{
        return joinRelation(joins, false, false);
}

 protected Object loadElement(OpenJPAStateManager sm,
    JDBCStore store,
    JDBCFetchConfiguration fetch,
    Result res,
    Joins joins) throws SQLException 
{
        ClassMapping elem = res.getBaseMapping();
        if (elem == null)
            elem = field.getElementMapping().getIndependentTypeMappings()[0];
        return res.load(elem, store, fetch, joins);
}

 public  void map(boolean adapt) 
{
        field.getValueInfo().assertNoSchemaComponents(field, !adapt);
        field.getKeyMapping().getValueInfo().assertNoSchemaComponents
            (field.getKey(), !adapt);
        ValueMapping elem = field.getElementMapping();
        if (elem.getTypeCode() != JavaTypes.PC || elem.isEmbeddedPC()
            || !elem.getTypeMapping().isMapped())
            throw new MetaDataException(_loc.get("not-elem-relation", field));
        // check for named inverse
        FieldMapping mapped = field.getMappedByMapping();
        FieldMappingInfo finfo = field.getMappingInfo();
        ValueMappingInfo vinfo = elem.getValueInfo();
        boolean criteria = vinfo.getUseClassCriteria();
        if (mapped != null) {
            mapped.resolve(mapped.MODE_META | mapped.MODE_MAPPING);
            if (!(mapped.getStrategy() instanceof RelationFieldStrategy))
                throw new MetaDataException(_loc.get("not-inv-relation",
                    field, mapped));
            vinfo.assertNoSchemaComponents(elem, !adapt);
            elem.setForeignKey(mapped.getForeignKey
                (field.getDefiningMapping()));
            elem.setColumns(mapped.getDefiningMapping().
                getPrimaryKeyColumns());
            elem.setJoinDirection(ValueMapping.JOIN_EXPECTED_INVERSE);
            elem.setUseClassCriteria(criteria);
            field.setOrderColumn(finfo.getOrderColumn(field,
                mapped.getForeignKey().getTable(), adapt));
            field.setOrderColumnIO(finfo.getColumnIO());
            return;
        }
        // map inverse foreign key in related table
        ForeignKey fk = vinfo.getInverseTypeJoin(elem, field.getName(), adapt);
        elem.setForeignKey(fk);
        elem.setColumnIO(vinfo.getColumnIO());
        elem.setColumns(elem.getTypeMapping().getPrimaryKeyColumns());
        elem.setJoinDirection(ValueMapping.JOIN_EXPECTED_INVERSE);
        elem.setUseClassCriteria(criteria);
        elem.mapConstraints(field.getName(), adapt);
        field.setOrderColumn(finfo.getOrderColumn(field, fk.getTable(),
            adapt));
        field.setOrderColumnIO(finfo.getColumnIO());
}

 protected  void selectElement(Select sel,
    ClassMapping elem,
    JDBCStore store,
    JDBCFetchConfiguration fetch,
    int eagerMode,
    Joins joins) 
{
        sel.select(elem, field.getElementMapping().getSelectSubclasses(),
            store, fetch, eagerMode, joins);
}

 public Object toDataStoreValue(Object val,
    JDBCStore store) 
{
        ClassMapping cm = field.getElementMapping().getTypeMapping();
        return cm.toDataStoreValue(val, cm.getPrimaryKeyColumns(), store);
}

 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();
        }
        // if no fine-grained change tracking then just delete and reinsert
        if (ct == null || !ct.isTracking()) {
            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 (field.getOrderColumn() != null)
            ct.setNextSequence(seq);
}