public IdentityType getIdentityType() { return cmd.getIdentityType(); }
public IdentityType getIdentityType() { org.datanucleus.metadata.IdentityType idType = getInternal().getIdentityType(); if (idType == org.datanucleus.metadata.IdentityType.APPLICATION) { return IdentityType.APPLICATION; } else if (idType == org.datanucleus.metadata.IdentityType.DATASTORE) { return IdentityType.DATASTORE; } else { return IdentityType.NONDURABLE; } }
void evictAllOfClass(String className) { AbstractClassMetaData cmd = nucleusCtx.getMetaDataManager().getMetaDataForClass(className, nucleusCtx.getClassLoaderResolver(null)); Iterator keyIter = cache.getKeys().iterator(); while (keyIter.hasNext()) { Object key = keyIter.next(); if (cmd.getIdentityType() == IdentityType.APPLICATION) { String targetClassName = IdentityUtils.getTargetClassNameForIdentity(key); if (className.equals(targetClassName)) { keyIter.remove(); } } else if (cmd.getIdentityType() == IdentityType.DATASTORE) { String targetClassName = IdentityUtils.getTargetClassNameForIdentity(key); if (className.equals(targetClassName)) { keyIter.remove(); } } } }
public void loaded(AbstractClassMetaData cmd) { if (cmd.getIdentityType() == IdentityType.DATASTORE && !cmd.isEmbeddedOnly()) { // Datastore id not supported throw new InvalidClassMetaDataException("LDAP.DatastoreID", cmd.getFullClassName()); } } }
public void loaded(AbstractClassMetaData cmd) { if (cmd.getIdentityType() == IdentityType.DATASTORE && !cmd.isEmbeddedOnly()) { // Datastore id not supported throw new InvalidClassMetaDataException("XML.DatastoreID", cmd.getFullClassName()); } } }
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); } }
protected String getTypeNameForField(AbstractMemberMetaData mmd) { AbstractClassMetaData fieldCmd = classEnhancer.getMetaDataManager().getMetaDataForClass(mmd.getType(), classEnhancer.getClassLoaderResolver()); String fieldTypeName = mmd.getTypeName(); if (fieldCmd != null && fieldCmd.getIdentityType() == IdentityType.APPLICATION) { fieldTypeName = fieldCmd.getObjectidClass(); } return fieldTypeName; }
/** * Convenience method to return the (DataNucleus) identity for an object. * @param obj The object * @param acmd MetaData for the object * @param ec execution context * @param odb ODB to use * @return The DataNucleus identity */ public static Object getIdentityForObject(Object obj, AbstractClassMetaData acmd, ExecutionContext ec, ODB odb) { if (acmd.getIdentityType() == IdentityType.DATASTORE) { long datastoreId = odb.getObjectId(obj).getObjectId(); return ec.getNucleusContext().getIdentityManager().getDatastoreId(datastoreId); } else if (acmd.getIdentityType() == IdentityType.APPLICATION) { return ec.getNucleusContext().getIdentityManager().getApplicationId(obj, acmd); } else { // Nondurable identity return null; } } }
/** * Method to transition to commit state. * @param sm StateManager. * @param tx the Transaction been committed. * @return new LifeCycle state. **/ public LifeCycleState transitionCommit(StateManager sm, Transaction tx) { sm.clearSavedFields(); if (tx.getRetainValues()) { return changeState(sm, P_NONTRANS); } else { if (sm.getClassMetaData().getIdentityType() != IdentityType.NONDURABLE) { sm.clearNonPrimaryKeyFields(); } return changeState(sm, HOLLOW); } }
/** * Method to transition to commit state. * @param sm StateManager. * @param tx the Transaction been committed. * @return new LifeCycle state. **/ public LifeCycleState transitionCommit(StateManager sm, Transaction tx) { sm.clearSavedFields(); if (tx.getRetainValues()) { return changeState(sm, P_NONTRANS); } else { if (sm.getClassMetaData().getIdentityType() != IdentityType.NONDURABLE) { sm.clearNonPrimaryKeyFields(); } //sm.restoreFields(); return changeState(sm, HOLLOW); } }
/** * Method to transition to commit state. * @param sm StateManager. * @param tx the Transaction been committed. * @return new LifeCycle state. **/ public LifeCycleState transitionCommit(StateManager sm, Transaction tx) { sm.clearSavedFields(); if (tx.getRetainValues()) { return changeState(sm, P_NONTRANS); } else { if (sm.getClassMetaData().getIdentityType() != IdentityType.NONDURABLE) { sm.clearNonPrimaryKeyFields(); } return changeState(sm, HOLLOW); } }
/** * This method is called when an entity is loaded during startup. There is * some basic validation that happens here as well as the caching of objects * (@Entity classes). Registration of fields happens in the {@link ForceMetaDataManager} * * @param cmd the class metadata to load */ @Override public void loaded(AbstractClassMetaData cmd) { if (cmd.getIdentityType() == IdentityType.DATASTORE && !cmd.isEmbeddedOnly()) { throw new InvalidMetaDataException(LOCALISER, "force.DatastoreID", cmd.getFullClassName()); } /** * Annotations do not work at field level. We hack that in here for now. */ updateAnnotations(cmd); /** * Validate that the annotations and extensions are supported */ validateExtensions(cmd); /** * Load object schema and register it --creation happens in the ForceMetaDataManager */ registerObjectSchema(cmd); }
/** * This method is called when an entity is loaded during startup. There is * some basic validation that happens here as well as the caching of objects * (@Entity classes). Registration of fields happens in the {@link ForceMetaDataManager} * * @param cmd the class metadata to load */ @Override public void loaded(AbstractClassMetaData cmd) { if (cmd.getIdentityType() == IdentityType.DATASTORE && !cmd.isEmbeddedOnly()) { throw new InvalidMetaDataException(LOCALISER, "force.DatastoreID", cmd.getFullClassName()); } /** * Annotations do not work at field level. We hack that in here for now. */ updateAnnotations(cmd); /** * Validate that the annotations and extensions are supported */ validateExtensions(cmd); /** * Load object schema and register it --creation happens in the ForceMetaDataManager */ registerObjectSchema(cmd); }
/** * Method to transition to rollback state. * @param sm StateManager. * @param tx The transaction * @return new LifeCycle state. **/ public LifeCycleState transitionRollback(StateManager sm, Transaction tx) { if (tx.getRestoreValues()) { sm.restoreFields(); return changeState(sm, P_NONTRANS); } else { if (sm.getClassMetaData().getIdentityType() != IdentityType.NONDURABLE) { sm.clearNonPrimaryKeyFields(); } sm.clearSavedFields(); return changeState(sm, HOLLOW); } }
/** * Method to transition to rollback state. * @param sm StateManager. * @param tx The Transaction * @return new LifeCycle state. **/ public LifeCycleState transitionRollback(StateManager sm, Transaction tx) { if (tx.getRestoreValues()) { sm.restoreFields(); return changeState(sm, P_NONTRANS); } else { if (sm.getClassMetaData().getIdentityType() != IdentityType.NONDURABLE) { sm.clearNonPrimaryKeyFields(); } sm.clearSavedFields(); return changeState(sm, HOLLOW); } }
public static Key getKeyForObject(Object pc, ExecutionContext ec) { AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(pc.getClass(), ec.getClassLoaderResolver()); if (cmd.getIdentityType() == IdentityType.DATASTORE) { OID oid = (OID)ec.getApiAdapter().getIdForObject(pc); if (oid == null) { // Not yet persistent, so return null return null; } Object keyValue = oid.getKeyValue(); return EntityUtils.getPkAsKey(keyValue, cmd, ec); } else { // TODO Cater for composite identity Object internalPk = ec.getApiAdapter().getTargetKeyForSingleFieldIdentity(ec.getApiAdapter().getIdForObject(pc)); if (internalPk == null) { // Not yet persistent, so return null return null; } return EntityUtils.getPkAsKey(internalPk, ec.getMetaDataManager().getMetaDataForClass(pc.getClass(), ec.getClassLoaderResolver()), ec); } }
public static Key getPrimaryKeyAsKey(ApiAdapter apiAdapter, ObjectProvider op) { if (op.getClassMetaData().getIdentityType() == IdentityType.DATASTORE) { OID oid = (OID)op.getInternalObjectId(); Object keyValue = oid.getKeyValue(); return getPrimaryKeyAsKey(keyValue, op.getExecutionContext(), op.getClassMetaData()); } else { Object primaryKey = apiAdapter.getTargetKeyForSingleFieldIdentity(op.getInternalObjectId()); return getPrimaryKeyAsKey(primaryKey, op.getExecutionContext(), op.getClassMetaData()); } }
public void locateObject(ObjectProvider op) { final AbstractClassMetaData cmd = op.getClassMetaData(); if (cmd.getIdentityType() == IdentityType.APPLICATION || cmd.getIdentityType() == IdentityType.DATASTORE) { ExecutionContext ec = op.getExecutionContext(); ManagedConnection mconn = storeMgr.getConnectionManager().getConnection(ec); try { StoreData sd = storeMgr.getStoreDataForClass(cmd.getFullClassName()); if (sd == null) { storeMgr.manageClasses(op.getExecutionContext().getClassLoaderResolver(), cmd.getFullClassName()); } GraphDatabaseService db = (GraphDatabaseService)mconn.getConnection(); PropertyContainer propObj = Neo4jUtils.getPropertyContainerForObjectProvider(db, op); if (propObj == null) { throw new NucleusObjectNotFoundException("Object not found for id=" + op.getInternalObjectId()); } } finally { mconn.release(); } } }
public static Key getPkAsKey(ObjectProvider op) { if (op.getClassMetaData().getIdentityType() == IdentityType.DATASTORE) { OID oid = (OID)op.getInternalObjectId(); Object keyValue = oid.getKeyValue(); return EntityUtils.getPkAsKey(keyValue, op.getClassMetaData(), op.getExecutionContext()); } else { // TODO Support composite PK Object pk = op.getExecutionContext().getApiAdapter().getTargetKeyForSingleFieldIdentity(op.getInternalObjectId()); if (pk == null) { throw new IllegalStateException("Primary key for object of type " + op.getClassMetaData().getName() + " is null."); } return EntityUtils.getPkAsKey(pk, op.getClassMetaData(), op.getExecutionContext()); } }
/** * Method to transition to read-field state. * @param op ObjectProvider. * @param isLoaded if the field was previously loaded * @return new LifeCycle state. */ public LifeCycleState transitionReadField(ObjectProvider op, boolean isLoaded) { Transaction tx = op.getExecutionContext().getTransaction(); if (!tx.isActive() && !tx.getNontransactionalRead()) { throw new TransactionNotReadableException(Localiser.msg("027000"), op.getInternalObjectId()); } else if (!tx.isActive() && op.getClassMetaData().getIdentityType() == IdentityType.NONDURABLE) { if (!isLoaded) { // JDO2 spec 5.4.4 throw new NucleusUserException("Not able to read fields of nondurable object when in HOLLOW state"); } } if (!tx.getOptimistic() && tx.isActive()) { return changeState(op, P_CLEAN); } return changeState(op, P_NONTRANS); }