public void loaded(AbstractClassMetaData cmd) { if (cmd.getIdentityType() == IdentityType.DATASTORE && !cmd.isEmbeddedOnly()) { // Datastore id not supported throw new InvalidClassMetaDataException("LDAP.DatastoreID", cmd.getFullClassName()); } } }
private AbstractMemberMetaData getFieldMetaData(String fieldName) { return cmd.getMetaDataForMember(fieldName); }
protected MemberColumnMapping getColumnMapping(int fieldNumber) { List<AbstractMemberMetaData> embMmds = new ArrayList<AbstractMemberMetaData>(mmds); embMmds.add(cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber)); return table.getMemberColumnMappingForEmbeddedMember(embMmds); }
private List<AbstractMemberMetaData> findAllFields() { List<AbstractMemberMetaData> allFields = new ArrayList<AbstractMemberMetaData>(); // Load up fields from this class AbstractMemberMetaData[] membersInThisClass = cmd.getManagedMembers(); if (membersInThisClass != null) allFields.addAll(Arrays.asList(membersInThisClass)); // Load up fields from MappedSuperclasses in class hierarchy AbstractClassMetaData superClassMD = cmd.getSuperAbstractClassMetaData(); while (superClassMD != null && superClassMD.getInheritanceMetaData().getStrategy() == InheritanceStrategy.SUBCLASS_TABLE) { AbstractMemberMetaData[] membersInSuperClass = superClassMD.getManagedMembers(); if (membersInSuperClass != null) allFields.addAll(Arrays.asList(membersInSuperClass)); superClassMD = superClassMD.getSuperAbstractClassMetaData(); } return allFields; }
public static boolean hasEncodedPKField(AbstractClassMetaData acmd) { if (acmd.getIdentityType() == IdentityType.DATASTORE) { IdentityMetaData idmd = acmd.getIdentityMetaData(); return idmd.hasExtension(DatastoreManager.ENCODED_PK); } else { int pkFieldNumber = acmd.getPKMemberPositions()[0]; // TODO Cater for composite PKs return isEncodedPKField(acmd, pkFieldNumber); } }
public static Object getObjectUsingNondurableIdForDBObject(final DBObject dbObject, final AbstractClassMetaData cmd, final ExecutionContext ec, boolean ignoreCache, final int[] fpMembers) Table table = ec.getStoreManager().getStoreDataForClass(cmd.getFullClassName()).getTable(); SCOID oid = new SCOID(cmd.getFullClassName()); final FetchFieldManager fm = new FetchFieldManager(ec, dbObject, cmd, table); // TODO Use the constructor with op so we always wrap SCOs Class type = ec.getClassLoaderResolver().classForName(cmd.getFullClassName()); Object pc = ec.findObject(oid, new FieldValues() ObjectProvider op = ec.findObjectProvider(pc); if (cmd.isVersioned()) VersionMetaData vermd = cmd.getVersionMetaDataForClass(); if (vermd.getFieldName() != null) version = op.provideField(cmd.getMetaDataForMember(vermd.getFieldName()).getAbsoluteFieldNumber());
protected static Object getObjectUsingApplicationIdForResult(final Result result, final AbstractClassMetaData cmd, final ExecutionContext ec, boolean ignoreCache, final int[] fpMembers, String tableName, StoreManager storeMgr, Table table) if (cmd.hasDiscriminatorStrategy()) String columnName = HBaseUtils.getQualifierNameForColumn(table.getSurrogateColumn(SurrogateColumnType.DISCRIMINATOR)); Object discValue = new String(result.getValue(familyName.getBytes(), columnName.getBytes())); Object cmdDiscValue = cmd.getDiscriminatorValue(); if (cmd.getDiscriminatorStrategy() != DiscriminatorStrategy.NONE && !cmdDiscValue.equals(discValue)) Class type = ec.getClassLoaderResolver().classForName(cmd.getFullClassName()); Object id = IdentityUtils.getApplicationIdentityForResultSetRow(ec, cmd, null, false, fm); Object pc = ec.findObject(id, ObjectProvider op = ec.findObjectProvider(pc); if (cmd.isVersioned()) VersionMetaData vermd = cmd.getVersionMetaDataForClass(); if (vermd.getFieldName() != null) AbstractMemberMetaData verMmd = cmd.getMetaDataForMember(vermd.getFieldName()); version = op.provideField(verMmd.getAbsoluteFieldNumber());
StoreData sd = storeMgr.getStoreDataForClass(cmd.getFullClassName()); if (sd == null) storeMgr.manageClasses(ec.getClassLoaderResolver(), new String[]{cmd.getFullClassName()}); sd = storeMgr.getStoreDataForClass(cmd.getFullClassName()); if (cmd.isVersioned()) VersionMetaData vermd = cmd.getVersionMetaDataForClass(); ec.getLockManager().performOptimisticVersionCheck(op, vermd!=null ? vermd.getVersionStrategy() : null, datastoreVersion); op.provideFields(cmd.getAllMemberPositions(), new DeleteFieldManager(op, true));
public String toString() { return "ComponentInfo : [class=" + cmd.getFullClassName() + " table=" + table + "]"; } }
public IdentityType getIdentityType() { return cmd.getIdentityType(); }
public void fetchNonLoadedFields(ObjectProvider op) { op.replaceNonLoadedFields(acmd.getAllMemberPositions(), fm); } public FetchPlan getFetchPlanForLoading()
this.table = storeManager.getTable(acmd); if (this.table == null) { throw new NucleusUserException("Entity does not exist in Force.com datastore: " + acmd.getEntityName()); pkIndexToSkip = acmd.getPKMemberPositions()[0]; if (acmd.getVersionMetaData() != null && pkValue != null) { versionIndexToSkip = acmd.getAbsolutePositionOfMember(acmd.getVersionMetaData().getFieldName()); Object version = objectProvider.provideField(versionIndexToSkip); if (version == null && storeManager.isEnableOptimisticTransactions()) { throw new NucleusUserException("Version field must be set to non-null value, field: " + acmd.getVersionMetaData().getFieldName() + " object id:" + sobject.getId());
protected boolean isPK(int fieldNumber) { int[] pkPositions = cmd.getPKMemberPositions(); return pkPositions != null && pkPositions[0] == fieldNumber; } }
public Set<SingularAttribute<? super X, ?>> getIdClassAttributes() { Set<SingularAttribute<? super X, ?>> pks = new HashSet<SingularAttribute<? super X,?>>(); int[] pkPositions = cmd.getPKMemberPositions(); for (int i=0;i<pkPositions.length;i++) { AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(pkPositions[i]); SingularAttribute pkAttr = (SingularAttribute) attributes.get(mmd.getName()); pks.add(pkAttr); } return pks; }
/** * Method that adds the specified class to be managed by this table. * Will provide mapping of all persistent fields to their underlying columns, map all necessary * identity fields, and manage all "unmapped" columns that have no associated field. * where the columns are defined for each mapping. * @param theCmd ClassMetaData for the class to be managed * @param clr The ClassLoaderResolver */ public void manageClass(AbstractClassMetaData theCmd, ClassLoaderResolver clr) { if (NucleusLogger.DATASTORE_SCHEMA.isDebugEnabled()) { NucleusLogger.DATASTORE_SCHEMA.debug(Localiser.msg("057024", toString(), theCmd.getFullClassName(), theCmd.getInheritanceMetaData().getStrategy().toString())); } managingClassCurrent = theCmd.getFullClassName(); managedClassMetaData.add(theCmd); // Manage all fields of this class and all fields of superclasses that this is overriding manageMembers(theCmd, clr, theCmd.getManagedMembers()); manageMembers(theCmd, clr, theCmd.getOverriddenMembers()); // Manage all "unmapped" columns (that have no field) manageUnmappedColumns(theCmd, clr); managingClassCurrent = null; if (runCallbacksAfterManageClass) { // We need to run the callbacks now that this class is fully managed runCallBacks(clr); runCallbacksAfterManageClass = false; } }
private Object fetchEmbeddedObject(AbstractMemberMetaData ammd) { if (objectProvider == null) return null; AbstractClassMetaData cmd = storeManager.getMetaDataManager().getMetaDataForClass(ammd.getType(), ec.getClassLoaderResolver()); Object obj = null; try { obj = ec.getClassLoaderResolver().classForName(cmd.getFullClassName(), true).newInstance(); for (AbstractMemberMetaData eammd : ammd.getEmbeddedMetaData().getMemberMetaData()) { PersistenceUtils.setFieldValue(ammd.getType(), cmd, cmd.getAbsolutePositionOfMember(eammd.getName()), obj, fetchObjectField(eammd, null)); } ec.findObjectProviderForEmbedded(obj, objectProvider, ammd); } catch (Exception e) { throw new NucleusUserException(e.getMessage(), e); } return obj; } }
public void manageClass(AbstractClassMetaData cmd) { // We demand DiscriminatorMetaData, because in cases where an object of the // top class in the inheritance hierarchy will be persisted and the subclasses // are not yet known to datanucleus, we already need to know about the discriminator // property. At this point here the exception can be too late, if an object of // the top class has been persisted already. But at least the developer is // now informed, that he should add the DiscriminatorMetaData. if (getDiscriminatorMetaData() == null) { throw new NucleusUserException("Descriminator meta data for " + cmd.getFullClassName() + " is missing. Please specify at least the discriminator column."); } // Go through the fields for this class and add columns for them for (AbstractMemberMetaData fmd : cmd.getManagedMembers()) { addFieldMapping(cmd, fmd); } this.managedClassMetaData.add(cmd); }
public IdentifiableType<? super X> getSupertype() { AbstractClassMetaData superCmd = cmd.getSuperAbstractClassMetaData(); Class superCls = ((MetamodelImpl)model).getClassLoaderResolver().classForName(superCmd.getFullClassName()); return (IdentifiableType<? super X>)model.managedType(superCls); }
private static String getForceApiRelationshipName(AbstractMemberMetaData ammd, Map<String, String> extensions, OMFContext omf) { AbstractClassMetaData acmd = PersistenceUtils.getMemberElementClassMetaData(ammd, omf.getClassLoaderResolver(null), omf.getMetaDataManager()); AbstractMemberMetaData mmd = acmd.getMetaDataForMember(ammd.getMappedBy()); if (mmd == null) { // The mappedBy field does not exist throw new NucleusUserException("Cannot access mappedBy field " + ammd.getMappedBy() + " on entity " + acmd.getName() + " at " + ammd.getFullFieldName()); } String tableName = acmd.getEntityName(); String fieldNameNoSuffix = getFieldName(mmd, extensions); extensions = getForceExtensions(mmd); String childRelationshipName = extensions.get("childRelationshipName"); String relationshipName = childRelationshipName != null ? childRelationshipName : String.format("%s_%ss", fieldNameNoSuffix, tableName); if (relationshipName.length() > 40) { relationshipName = relationshipName.substring(0, 40); } return relationshipName; }
Table table = storeMgr.getStoreDataForClass(cmd.getFullClassName()).getTable(); VersionMetaData vermd = cmd.getVersionMetaDataForClass();