public boolean isId() { return mmd.isPrimaryKey(); }
public void provideMappingsForMembers(MappingConsumer consumer, AbstractMemberMetaData[] mmds, boolean includeSecondaryTables) { for (AbstractMemberMetaData aFieldMetaData : mmds) { JavaTypeMapping fieldMapping = fieldMappingsMap.get(aFieldMetaData); if (fieldMapping != null) { if (!aFieldMetaData.isPrimaryKey()) { consumer.consumeMapping(fieldMapping, aFieldMetaData); } } } }
public boolean getPrimaryKey() { return getInternal().isPrimaryKey(); }
boolean isPrimaryKey(String propertyName) { return elementCmd.getMetaDataForMember(propertyName).isPrimaryKey(); }
public void provideNonPrimaryKeyMappings(MappingConsumer consumer, boolean isEmbedded) { consumer.preConsumeMapping(highestFieldNumber + 1); Set<Map.Entry<AbstractMemberMetaData, JavaTypeMapping>> entries = isEmbedded ? embeddedFieldMappingsMap.entrySet() : fieldMappingsMap.entrySet(); for (Map.Entry<AbstractMemberMetaData, JavaTypeMapping> entry : entries) { if (entry.getValue() != null) { if (!entry.getKey().isPrimaryKey() || isEmbedded) { consumer.consumeMapping(entry.getValue(), entry.getKey()); } } } }
@Override protected Class getOverrideMappingClass(Class mappingClass, AbstractMemberMetaData fmd, int roleForField) { if (roleForField == FieldRole.ROLE_FIELD && fmd.isPrimaryKey() && mappingClass.equals( SerialisedMapping.class) && fmd.getType().equals(Key.class)) { // Do I fully comprehend what I'm doing here? No. But I do know that // this change enables us to have relations where the pk of the child is of type // Key, and that's a good thing. return KeyMapping.class; } else if (mappingClass.equals(EmbeddedPCMapping.class)) { // As of DataNuc 1.1.3, Embedded fields in JPA don't have their // EmbeddedMetaData set. Our embedded field logic requires this, // so in order to preserve this invariant we instantiate our own // subclass of EmbeddedPCMapping that always has EmbeddedMetaData // set. return DatastoreEmbeddedPCMapping.class; } return mappingClass; }
/** * Provide the mappings to the consumer for all non primary-key fields * mapped to this table. * @param consumer Consumer for the mappings */ final public void provideNonPrimaryKeyMappings(MappingConsumer consumer) { consumer.preConsumeMapping(highestMemberNumber + 1); Iterator<Map.Entry<AbstractMemberMetaData, JavaTypeMapping>> memberMapEntryIter = memberMappingsMap.entrySet().iterator(); while (memberMapEntryIter.hasNext()) { Map.Entry<AbstractMemberMetaData, JavaTypeMapping> memberMapEntry = memberMapEntryIter.next(); AbstractMemberMetaData mmd = memberMapEntry.getKey(); JavaTypeMapping memberMapping = memberMapEntry.getValue(); if (memberMapping != null) { if (!mmd.isPrimaryKey()) { consumer.consumeMapping(memberMapping, mmd); } } } }
/** * Provide the mappings to the consumer for all specified members. * @param consumer Consumer for the mappings * @param mmds MetaData for the members to provide mappings for * @param includeSecondaryTables Whether to provide members in secondary tables */ public void provideMappingsForMembers(MappingConsumer consumer, AbstractMemberMetaData[] mmds, boolean includeSecondaryTables) { consumer.preConsumeMapping(highestMemberNumber + 1); for (int i = 0; i < mmds.length; i++) { JavaTypeMapping fieldMapping = memberMappingsMap.get(mmds[i]); if (fieldMapping != null) { if (!mmds[i].isPrimaryKey()) { consumer.consumeMapping(fieldMapping, mmds[i]); } } } }
else if (embeddedMmd.isPrimaryKey()) if (!fieldName.equals(embeddedMetaData.getOwnerMember()) && !embeddedMmd.isPrimaryKey())
if (ammd.getAbstractClassMetaData().getNoOfPrimaryKeyMembers() == 1 && ammd.isPrimaryKey())
if (fmd.isPrimaryKey()) { } else if (m instanceof PersistableMapping || m instanceof ReferenceMapping) { if (m.getNumberOfDatastoreMappings() == 0) {
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public AbstractClassMetaData getMetaDataForClass(Class cls, PackageMetaData pmd, ClassLoaderResolver clr) { AbstractClassMetaData cmd = super.getMetaDataForClass(cls, pmd, clr); if (cmd == null) { return null; } if (!cls.isAnnotationPresent(CTE.class)) { return cmd; } if (isDataNucleus4) { cmd.setIdentityType(IdentityType.NONDURABLE); cmd.addExtension("view-definition", "--"); for (int i = 0; i < cmd.getNoOfMembers(); i++) { AbstractMemberMetaData mmd = cmd.getMetaDataForMemberAtRelativePosition(i); if (mmd.isPrimaryKey()) { mmd.setPrimaryKey(false); } } } else { cmd.setIdentityType(IdentityType.APPLICATION); cmd.addExtension("view-definition", "--"); } return cmd; }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public AbstractClassMetaData getMetaDataForClass(Class cls, PackageMetaData pmd, ClassLoaderResolver clr) { AbstractClassMetaData cmd = super.getMetaDataForClass(cls, pmd, clr); if (cmd == null) { return null; } if (!cls.isAnnotationPresent(CTE.class)) { return cmd; } if (isDataNucleus4) { cmd.setIdentityType(IdentityType.NONDURABLE); cmd.addExtension("view-definition", "--"); for (int i = 0; i < cmd.getNoOfMembers(); i++) { AbstractMemberMetaData mmd = cmd.getMetaDataForMemberAtRelativePosition(i); if (mmd.isPrimaryKey()) { mmd.setPrimaryKey(false); } } } else { cmd.setIdentityType(IdentityType.APPLICATION); cmd.addExtension("view-definition", "--"); } return cmd; }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public AbstractClassMetaData getMetaDataForClass(Class cls, PackageMetaData pmd, ClassLoaderResolver clr) { AbstractClassMetaData cmd = super.getMetaDataForClass(cls, pmd, clr); if (cmd == null) { return null; } if (!cls.isAnnotationPresent(CTE.class)) { return cmd; } if (isDataNucleus4) { cmd.setIdentityType(IdentityType.NONDURABLE); cmd.addExtension("view-definition", "--"); for (int i = 0; i < cmd.getNoOfMembers(); i++) { AbstractMemberMetaData mmd = cmd.getMetaDataForMemberAtRelativePosition(i); if (mmd.isPrimaryKey()) { mmd.setPrimaryKey(false); } } } else { cmd.setIdentityType(IdentityType.APPLICATION); cmd.addExtension("view-definition", "--"); } return cmd; }
else if (embeddedMmd.isPrimaryKey()) int embFieldNum = embeddedCmd.getAbsolutePositionOfMember(fieldName); if (!fieldName.equals(embeddedMetaData.getOwnerMember()) && !embeddedMmd.isPrimaryKey())
throw noMetaDataException(primaryExpr.getId(), acmd.getFullClassName()); if (!ammd.isPrimaryKey()) { keysOnly = false;
private void applyUniqueFieldValueConstraints(Configuration config) { AbstractStoreManager sm = (AbstractStoreManager) storeMgr; MetaDataManager mdm = sm.getMetaDataManager(); Collection<String> classesWithMetaData = mdm.getClassesWithMetaData(); for (String className : classesWithMetaData) { ClassLoaderResolver clr = storeMgr.getNucleusContext().getClassLoaderResolver(getClass().getClassLoader()); AbstractClassMetaData cmd = mdm.getMetaDataForClass(className, clr); String fullClassName = cmd.getFullClassName(); AbstractMemberMetaData[] fmds = cmd.getManagedMembers(); for (AbstractMemberMetaData memberMetaData : fmds) { if (memberMetaData.isPrimaryKey()) { String fieldName = memberMetaData.getName(); config.objectClass(fullClassName).objectField(fieldName).indexed(true); config.add(new UniqueFieldValueConstraint(fullClassName, fieldName)); } } } }
/** * Get the value of a managed field/property in the provided object. * @param ec execution context * @param mmd metadata for the field/property * @param object the pc object * @return The field value */ public static Object getValueForMemberOfObject(ExecutionContext ec, AbstractMemberMetaData mmd, Object object) { if (ec == null) { // Transient or detached maybe return ClassUtils.getValueOfFieldByReflection(object, mmd.getName()); // TODO What if this is a property? } ObjectProvider sm = ec.findObjectProvider(object); if (!mmd.isPrimaryKey()) { // Make sure the field is loaded sm.isLoaded(mmd.getAbsoluteFieldNumber()); } FieldManager fm = new SingleValueFieldManager(); sm.provideFields(new int[] {mmd.getAbsoluteFieldNumber()}, fm); return fm.fetchObjectField(mmd.getAbsoluteFieldNumber()); }
if (fmd.isPrimaryKey()) { prop.setAsPrimaryKey();
/** * @param qd The QueryData * @param orderExpr The OrderExpression * @return The name of the sort property that was added to the primary datastore query. */ String getSortProperty(QueryData qd, OrderExpression orderExpr) { PrimaryExpression left = (PrimaryExpression) orderExpr.getLeft(); AbstractClassMetaData acmd = qd.acmd; List<String> tuples = getTuples(left, qd.compilation.getCandidateAlias()); if (isJoin(left.getLeft(), tuples)) { // Change the class meta data to the meta-data for the joined class acmd = getJoinClassMetaData(left.getLeft(), tuples, qd); } AbstractMemberMetaData ammd = getMemberMetaDataForTuples(acmd, tuples); if (ammd == null) { throw noMetaDataException(left.getId(), acmd.getFullClassName()); } if (MetaDataUtils.isParentPKField(ammd)) { throw new UnsupportedDatastoreFeatureException("Cannot sort by parent."); } else { String sortProp; if (ammd.isPrimaryKey()) { sortProp = Entity.KEY_RESERVED_PROPERTY; } else { sortProp = determinePropertyName(ammd); } return sortProp; } }