public void map(boolean adapt) { // if a superclass maps the discriminator value, so should we. // otherwise assume it's calculated ClassMapping sup = disc.getClassMapping(). getJoinablePCSuperclassMapping(); for (; sup != null; sup = sup.getJoinablePCSuperclassMapping()) { if (sup.getDiscriminator().getValue() != null || sup.getDiscriminator().getStrategy() instanceof ValueMapDiscriminatorStrategy) { disc.setValue(disc.getMappingInfo().getValue(disc, adapt)); break; } } }
public void selectColumns(Select sel, ExpContext ctx, ExpState state, boolean pks) { InstanceofExpState istate = (InstanceofExpState) state; if (istate.discrim != null) sel.select(istate.discrim.getColumns(), istate.joins); }
/** * Create discriminator metadata for the given class. */ protected Discriminator newDiscriminator(ClassMapping cls) { return new Discriminator(cls); }
public void installStrategy(Discriminator discrim) { discrim.clearMapping(); discrim.setStrategy(NoneDiscriminatorStrategy.getInstance(), null); } }
public void loadSubclasses(JDBCStore store) throws SQLException, ClassNotFoundException { disc.getClassMapping().getPCSuperclassMapping(). getDiscriminator().loadSubclasses(store); disc.setSubclassesLoaded(true); }
public Class getClass(JDBCStore store, ClassMapping base, Result res) throws SQLException, ClassNotFoundException { return disc.getClassMapping().getPCSuperclassMapping(). getDiscriminator().getClass(store, base, res); }
public Object getStrategy(Discriminator disc, boolean adapt) { ClassMapping cls = disc.getClassMapping(); if ((adapt || defaultMissingInfo()) && cls.getJoinablePCSuperclassMapping() == null && disc.getMappingInfo().getValue() == null) return _discStrategy; return null; }
public void installStrategy(Discriminator discrim) { DiscriminatorStrategy strat = repos.namedStrategy(discrim); if (strat == null) strat = repos.defaultStrategy(discrim, true); try { discrim.setStrategy(strat, Boolean.TRUE); } catch (MetaDataException mde) { // if this is a custom strategy, don't attempt to override if (isCustomStrategy(strat)) throw mde; repos.getLog().warn(_loc.get("fatal-change", discrim, mde.getMessage())); // retain old discriminator version, if any String val = discrim.getMappingInfo().getValue(); discrim.clearMapping(); discrim.getMappingInfo().setValue(val); discrim.setStrategy(repos.defaultStrategy(discrim, true), Boolean.TRUE); } }
public void map(boolean adapt) { Object val = disc.getMappingInfo().getValue(disc, adapt); if (val == null && !Modifier.isAbstract(disc.getClassMapping(). getDescribedType().getModifiers())) throw new MetaDataException(_loc.get("no-discrim-value", disc.getClassMapping())); // we set the value before mapping to use to calculate the template // column's java type disc.setValue(val); super.map(adapt); } }
public void insert(OpenJPAStateManager sm, JDBCStore store, RowManager rm) throws SQLException { Row row = rm.getRow(disc.getClassMapping().getTable(), Row.ACTION_INSERT, sm, true); Object cls = getDiscriminatorValue((ClassMapping) sm.getMetaData()); if (disc.getColumnIO().isInsertable(0, cls == null)) row.setObject(disc.getColumns()[0], cls); }
protected Object getDiscriminatorValue(ClassMapping cls) { Object val = cls.getDiscriminator().getValue(); return (val == Discriminator.NULL) ? null : val; }
private boolean getJoinedSupers(Select sel, ClassMapping mapping, int subs, boolean outer) { loadSubclasses(mapping); Joins joins = (outer) ? sel.newOuterJoins() : null; boolean includeSubs = false; if (subs == Select.SUBS_JOINABLE || subs == Select.SUBS_ANY_JOINABLE) { includeSubs = true; } return mapping.getDiscriminator().addClassConditions(sel, includeSubs, joins); }
public void insert(OpenJPAStateManager sm, JDBCStore store, RowManager rm) throws SQLException { assertStrategy().insert(sm, store, rm); }
/** * Return the columns set for this discriminator, based on the given * templates. */ public Column[] getColumns(Discriminator discrim, Column[] tmplates, boolean adapt) { Table table = discrim.getClassMapping().getTable(); discrim.getMappingRepository().getMappingDefaults().populateColumns (discrim, table, tmplates); return createColumns(discrim, null, tmplates, table, adapt); }
public Class getClass(JDBCStore store, ClassMapping base, Result res) throws SQLException, ClassNotFoundException { if (isFinal || !useDiscrimColumn(base, res) || (base.getPCSuperclass() == null && base.getJoinablePCSubclassMappings().length == 0)) { return base.getDescribedType(); } Object cls = res.getObject(disc.getColumns()[0], disc.getJavaType(), null); return getClass(cls, store); }
res.startDataRequest(mapping.getDiscriminator()); try { type = mapping.getDiscriminator().getClass(this, mapping, res); } finally {
/** * Recursive method to delete the given instance, base class last. */ protected void delete(OpenJPAStateManager sm, ClassMapping mapping, RowManager rowMgr, JDBCStore store, Collection customs) throws SQLException { Boolean custom = mapping.isCustomDelete(sm, store); if (!Boolean.FALSE.equals(custom)) mapping.customDelete(sm, store); if (Boolean.TRUE.equals(custom)) return; FieldMapping[] fields = mapping.getDefinedFieldMappings(); for (int i = 0; i < fields.length; i++) if (!bufferCustomDelete(fields[i], sm, store, customs)) fields[i].delete(sm, store, rowMgr); ClassMapping sup = mapping.getJoinablePCSuperclassMapping(); if (sup == null) { Version vers = mapping.getVersion(); if (!bufferCustomDelete(vers, sm, store, customs)) vers.delete(sm, store, rowMgr); Discriminator dsc = mapping.getDiscriminator(); if (!bufferCustomDelete(dsc, sm, store, customs)) dsc.delete(sm, store, rowMgr); } mapping.delete(sm, store, rowMgr); if (sup != null) delete(sm, sup, rowMgr, store, customs); }
public void setDiscriminator(Discriminator owner) { disc = owner; ClassMapping cls = disc.getClassMapping(); isFinal = Modifier.isFinal(cls.getDescribedType().getModifiers()); }
else if (cls.getDiscriminator() != null && !StringUtils.equals("none", cls.getDiscriminator().getStrategy().getAlias())) { type = cls.getDiscriminator().getClass(store, cls, res); ((OpenJPAId) oid).setManagedInstanceType(type, true); } catch (Exception e) {
public Object getStrategy(Discriminator disc, boolean adapt) { ClassMapping cls = disc.getClassMapping(); if ((adapt || defaultMissingInfo()) && cls.getJoinablePCSuperclassMapping() == null && disc.getMappingInfo().getValue() == null) return _discStrategy; return null; }