public int getJavaType() { if (_javaType == -1) { ClassMapping superMapping = _mapping.getPCSuperclassMapping(); if (superMapping != null && superMapping.getDiscriminator() != null) { _javaType = superMapping.getDiscriminator().getJavaType(); } } return _javaType; } }
public FetchInfo(ClassMapping type) { FieldMapping[] fms = type.getFieldMappings(); eager = new BitSet(fms.length); excludes = new BitSet(fms.length); for (int i = 0; i < fms.length; i++) if (!fms[i].isPrimaryKey()) excludes.set(i); } }
public void insert(OpenJPAStateManager sm, JDBCStore store, RowManager rm) throws SQLException { Row row = rm.getRow(cls.getTable(), Row.ACTION_INSERT, sm, true); row.setPrimaryKey(cls.getColumnIO(), sm); row.setForeignKey(cls.getJoinForeignKey(), cls.getColumnIO(), sm); }
/** * Return whether we can reach the given subclass via joins. */ private boolean isSubJoinable(ClassMapping sub) { if (sub == null) return false; if (sub == this) return true; return isSubJoinable(sub.getJoinablePCSuperclassMapping()); }
public boolean hasClassConditions(ClassMapping base, boolean subclasses) { // if selecting the first mapped class and all subclasses, no need // to limit the query if (isFinal || (base.getJoinablePCSuperclassMapping() == null && subclasses)) return false; // if no subclasses or superclass, no need for conditions ClassMapping[] subs = base.getJoinablePCSubclassMappings(); if (subs.length == 0 && base.getJoinablePCSuperclassMapping() == null) return false; return true; }
private String getKey(ClassMapping mapping, boolean db) { if (_ignore) { while (mapping.getMappedPCSuperclassMapping() != null) mapping = mapping.getMappedPCSuperclassMapping(); } else { while (mapping.getPCSuperclass() != null) mapping = mapping.getPCSuperclassMapping(); } if (_aliases) return mapping.getTypeAlias(); return mapping.getDescribedType().getName(); }
public boolean checkVersion(OpenJPAStateManager sm, JDBCStore store, boolean updateVersion) throws SQLException { return vers.getClassMapping().getPCSuperclassMapping().getVersion(). checkVersion(sm, store, updateVersion); }
public void map(boolean adapt) { ClassMapping cls = disc.getClassMapping(); if (cls.getJoinablePCSuperclassMapping() != null || cls.getEmbeddingMetaData() != null) throw new MetaDataException(_loc.get("not-base-disc", cls)); DiscriminatorMappingInfo info = disc.getMappingInfo(); info.assertNoSchemaComponents(disc, true); // make sure outer joins are supported DBDictionary dict = cls.getMappingRepository().getDBDictionary(); if (dict.joinSyntax == JoinSyntaxes.SYNTAX_TRADITIONAL) throw new MetaDataException(_loc.get("outer-join-support", cls)); }
public int orderByPrimaryKey(ClassMapping mapping, boolean asc, Joins joins, boolean select) { ClassMapping pks = mapping; while (!pks.isPrimaryKeyObjectId(true)) pks = pks.getJoinablePCSuperclassMapping(); Column[] cols = pks.getPrimaryKeyColumns(); recordOrderColumns(cols, asc); return sel.orderByPrimaryKey(mapping, asc, joins, select, isUnion()); }
public void insert(OpenJPAStateManager sm, JDBCStore store, RowManager rm) throws SQLException { Row row = rm.getRow(cls.getTable(), Row.ACTION_INSERT, sm, true); if (cls.getIdentityType() == cls.ID_DATASTORE) row.setPrimaryKey(cls.getColumnIO(), sm); }
public void order(Select sel, ClassMapping elem, Joins joins) { FieldMapping fm = elem.getFieldMapping(_fm.getIndex()); sel.orderBy(fm.getColumns(), _asc, joins, false); } }
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); }
/** * Throw the proper exception if the given handler-controlled value * represents an unjoinable relation. */ public static void assertJoinable(ValueMapping vm) { ClassMapping rel = vm.getTypeMapping(); if (rel != null && (rel.getTable() == null || !rel.getTable().equals(vm.getFieldMapping().getTable()))) throw RelationStrategies.unjoinable(vm); } }
/** * Return the base table for the given instance. */ private static Table getBaseTable(OpenJPAStateManager sm) { ClassMapping cls = (ClassMapping) sm.getMetaData(); while (cls.getJoinablePCSuperclassMapping() != null) cls = cls.getJoinablePCSuperclassMapping(); return cls.getTable(); }
/** * Update {@link MappingInfo} with our current mapping information. */ public void syncMappingInfo() { if (getEmbeddingMetaData() == null) _info.syncWith(this); else { _info.clear(); FieldMapping[] fields = getFieldMappings(); for (int i = 0; i < fields.length; i++) fields[i].syncMappingInfo(); } }
private FinderQuery<ClassMapping, SelectExecutor, Result> markUncachable(ClassMapping mapping, String reason) { lock(); try { String cls = mapping.getDescribedType().getName(); boolean excludedByUser = _uncachables.get(cls) == EXLUDED_BY_USER; if (!excludedByUser) _uncachables.put(cls, reason); return _delegate.remove(mapping); } finally { unlock(); } }
boolean isSecondaryColumn(Column col, OpenJPAStateManager sm) { ClassMapping mapping = (ClassMapping)sm.getMetaData(); while (mapping != null) { if (mapping.getTable() == col.getTable()) return false; else mapping = mapping.getPCSuperclassMapping(); } return true; } }
public void map(boolean adapt) { ClassMapping cls = vers.getClassMapping(); if (cls.getJoinablePCSuperclassMapping() != null || cls.getEmbeddingMetaData() != null) throw new MetaDataException(_loc.get("not-base-vers", cls)); vers.getMappingInfo().assertNoSchemaComponents(vers, true); }
/** * Return whether the given name matches the given mapping. */ private static boolean isClassMappingName(String name, ClassMapping cls) { if (cls == null) return false; if (name.equals(cls.getDescribedType().getName()) || name.equals(ClassUtil.getClassName(cls.getDescribedType()))) return true; return isClassMappingName(name, cls.getPCSuperclassMapping()); }
/** * Convenience method to perform cast from * {@link ClassMetaData#getEmbeddingMetaData} */ public ValueMapping getEmbeddingMapping() { return (ValueMapping) getEmbeddingMetaData(); }