/** * Clear the association from owner to all elements. Observes the necessary dependent field settings * with respect to whether it should delete the element when doing so. * @param op ObjectProvider for the container. */ public void clear(ObjectProvider op) { Collection dependentElements = null; if (ownerMemberMetaData.getArray().isDependentElement()) { // Retain the dependent elements that need deleting after clearing dependentElements = new HashSet(); Iterator iter = iterator(op); while (iter.hasNext()) { Object elem = iter.next(); if (op.getExecutionContext().getApiAdapter().isPersistable(elem)) { dependentElements.add(elem); } } } clearInternal(op); if (dependentElements != null && dependentElements.size() > 0) { op.getExecutionContext().deleteObjects(dependentElements.toArray()); } }
/** * Method to extract the value of the persistable from a ResultSet. * @param ec The ExecutionContext * @param resultSet The ResultSet * @param exprIndex The parameter positions in the result set to use. * @param ownerOP ObjectProvider for the owning object * @param fieldNumber Absolute number of field in owner object * @return The (deserialised) persistable object */ public Object getObject(ExecutionContext ec, ResultSet resultSet, int[] exprIndex, ObjectProvider ownerOP, int fieldNumber) { Object obj = getDatastoreMapping(0).getObject(resultSet, exprIndex[0]); if (obj != null) { // Assign a StateManager to the serialised object if none present ObjectProvider embSM = ec.findObjectProvider(obj); if (embSM == null || ec.getApiAdapter().getExecutionContext(obj) == null) { ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, obj, false, ownerOP, fieldNumber); } } return obj; } }
/** * Accessor for the generic compilation that this criteria query equates to. * @return The generic compilation */ public QueryCompilation getCompilation() { if (compilation == null) { // Not yet compiled, so compile it compilation = compile(ec.getMetaDataManager(), ec.getClassLoaderResolver()); } return compilation; }
public void transactionPreCommit() { // insert while (!objectsToPersist.isEmpty()) { HashSet<Object> insert = new HashSet<Object>(objectsToPersist); for (Object pc : insert) { ec.findObjectProvider(pc, true); } objectsToPersist.removeAll(insert); } // delete ec.deleteObjects(objectsToDelete.toArray()); }
/** * Mutator for the timeout to use for datastore reads. * @param timeout Datastore read timeout interval (millisecs) */ public void setDatastoreReadTimeoutMillis(Integer timeout) { assertIsOpen(); if (!ec.getStoreManager().getSupportedOptions().contains(StoreManager.OPTION_DATASTORE_TIMEOUT)) { throw new JDOUnsupportedOptionException("This datastore doesn't support read timeouts"); } ec.setProperty(PropertyNames.PROPERTY_DATASTORE_READ_TIMEOUT, timeout); }
protected static Object getObjectUsingDatastoreIdForDBObject(final PropertyContainer propObj, final AbstractClassMetaData cmd, final ExecutionContext ec, boolean ignoreCache, final int[] fpMembers) StoreData sd = ec.getStoreManager().getStoreDataForClass(cmd.getFullClassName()); if (sd == null) ec.getStoreManager().manageClasses(ec.getClassLoaderResolver(), cmd.getFullClassName()); sd = ec.getStoreManager().getStoreDataForClass(cmd.getFullClassName()); Object id = ec.getNucleusContext().getIdentityManager().getDatastoreId(cmd.getFullClassName(), idKey); Class type = ec.getClassLoaderResolver().classForName(cmd.getFullClassName()); Object pc = ec.findObject(id, false, false, type.getName()); ObjectProvider op = ec.findObjectProvider(pc); if (op.getAssociatedValue(Neo4jStoreManager.OBJECT_PROVIDER_PROPCONTAINER) == null)
ClassLoaderResolver clr = ec.getClassLoaderResolver(); AbstractMemberMetaData lastMmd = mmds.get(mmds.size()-1); EmbeddedMetaData embmd = mmds.get(0).getEmbeddedMetaData(); ObjectProvider[] ownerOPs = ec.getOwnersForEmbeddedObjectProvider(op); if (ownerOPs != null && ownerOPs.length == 1 && value != ownerOPs[0].getObject()) if (relationType != RelationType.NONE && MetaDataUtils.getInstance().isMemberEmbedded(ec.getMetaDataManager(), clr, mmd, relationType, lastMmd)) AbstractClassMetaData embcmd = ec.getMetaDataManager().getMetaDataForClass(embcls, clr); if (embcmd != null) if (value != null) embSM = ec.findObjectProviderForEmbedded(value, op, mmd); embSM = ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, embcmd, op, fieldNumber);
public void storeObjectField(int fieldNumber, Object value) ClassLoaderResolver clr = ec.getClassLoaderResolver(); AbstractMemberMetaData mmd = op.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); if (!isStorable(mmd)) if (relationType != RelationType.NONE && MetaDataUtils.getInstance().isMemberEmbedded(ec.getMetaDataManager(), clr, mmd, relationType, null)) if (!ec.getApiAdapter().isDetached(value) && !ec.getApiAdapter().isPersistent(value)) AbstractClassMetaData embCmd = ec.getMetaDataManager().getMetaDataForClass(mmd.getType(), clr); int[] embMmdPosns = embCmd.getAllMemberPositions(); List<AbstractMemberMetaData> embMmds = new ArrayList<AbstractMemberMetaData>(); ObjectProvider embOP = ec.findObjectProviderForEmbedded(value, op, mmd); StoreEmbeddedFieldManager storeEmbFM = new StoreEmbeddedFieldManager(embOP, row, insert, embMmds, table); embOP.provideFields(embMmdPosns, storeEmbFM);
/** * Deletes a persistent object from the database. * The delete can take place in several steps, one delete per table that it is stored in. * e.g When deleting an object that uses "new-table" inheritance for each level of the inheritance tree * then will get an DELETE for each table. When deleting an object that uses "complete-table" * inheritance then will get a single DELETE for its table. * @param op The ObjectProvider of the object to be deleted. * @throws NucleusDataStoreException when an error occurs in the datastore communication */ public void deleteObject(ObjectProvider op) { // Check if read-only so update not permitted assertReadOnlyForUpdateOfObject(op); ExecutionContext ec = op.getExecutionContext(); if (ec.getStatistics() != null) { ec.getStatistics().incrementDeleteCount(); } ClassLoaderResolver clr = op.getExecutionContext().getClassLoaderResolver(); DatastoreClass dc = getDatastoreClass(op.getClassMetaData().getFullClassName(), clr); deleteObjectFromTable(dc, op, clr); }
/** * Method to return the ObjectProvider for an embedded PC object (element, key, value). * It creates one if the element is not currently managed. * @param op ObjectProvider of the owner * @param obj The embedded PC object * @param ownerMmd The meta data for the owner field * @param pcType Object type for the embedded object (see ObjectProvider EMBEDDED_PC etc) * @return The ObjectProvider */ public ObjectProvider getObjectProviderForEmbeddedPCObject(ObjectProvider op, Object obj, AbstractMemberMetaData ownerMmd, short pcType) { ExecutionContext ec = op.getExecutionContext(); ObjectProvider objOP = ec.findObjectProvider(obj); if (objOP == null) { objOP = ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, obj, false, op, ownerMmd.getAbsoluteFieldNumber()); } objOP.setPcObjectType(pcType); return objOP; }
JavaQueryInMemoryEvaluator resultMapper = new JPQLInMemoryEvaluator(this, candidates, compilation, parameters, ec.getClassLoaderResolver()); Collection results = resultMapper.execute(true, true, true, true, true); ec.deleteObjects(results.toArray()); return Long.valueOf(results.size());
JavaTypeMapping referenceMapping = mapping.getStoreManager().getDatastoreClass(fieldType.getName(), ec.getClassLoaderResolver()).getIdMapping(); oid = referenceMapping.getDatastoreMapping(0).getObject(rs, resultIndexes[0]); oid = ec.getNucleusContext().getIdentityManager().getDatastoreId(mapping.getType(), oid); if (NucleusLogger.PERSISTENCE.isDebugEnabled()) ApiAdapter api = ec.getApiAdapter(); if (api.isPersistable(oid)) //why check this? return oid == null ? null : ec.findObject(oid, false, true, null);
/** * Utility to validate a key is ok for reading. * @param op ObjectProvider for the map. * @param key The key to check. * @return Whether it is validated. */ protected boolean validateKeyForReading(ObjectProvider op, Object key) { validateKeyType(op.getExecutionContext().getClassLoaderResolver(), key); if (!keysAreEmbedded && !keysAreSerialised) { ExecutionContext ec = op.getExecutionContext(); if (key!=null && (!ec.getApiAdapter().isPersistent(key) || ec != ec.getApiAdapter().getExecutionContext(key)) && !ec.getApiAdapter().isDetached(key)) { return false; } } return true; }
/** * Utility method to process the passed persistable object. * We know that this object has no ObjectProvider when it comes in here. * @param fieldNumber Absolute field number * @param pc The persistable object */ protected void processPersistable(int fieldNumber, Object pc) { ExecutionContext ec = op.getExecutionContext(); ObjectProvider theSM = null; // No ObjectProvider but object returned to us by NeoDatis so we know it is persistent // Connect a ObjectProvider in P_CLEAN state with all fields loaded AbstractClassMetaData acmd = ec.getMetaDataManager().getMetaDataForClass(pc.getClass(), ec.getClassLoaderResolver()); Object id = NeoDatisUtils.getIdentityForObject(pc, acmd, ec, odb); theSM = ec.getNucleusContext().getObjectProviderFactory().newForPersistentClean(ec, id, pc); // Recurse to all fields of this object since just assigned its ObjectProvider theSM.provideFields(theSM.getClassMetaData().getAllMemberPositions(), new AssignObjectProviderFieldManager(theSM, odb)); }
public static Delete getDeleteForObject(ObjectProvider op, Table schemaTable) throws IOException { byte[] rowKey = (byte[]) op.getAssociatedValue("HBASE_ROW_KEY"); if (rowKey == null) { AbstractClassMetaData cmd = op.getClassMetaData(); final Object[] pkValues = findKeyObjects(op, cmd, schemaTable); ExecutionContext ec = op.getExecutionContext(); if (ec.getStatistics() != null) { // Add to statistics ec.getStatistics().incrementNumReads(); } rowKey = getRowKeyForPkValue(pkValues, ec.getNucleusContext()); } return new Delete(rowKey); }
if (ec.getApiAdapter().isPersistable(obj)) ObjectProvider paramOP = ec.findObjectProvider(obj); AbstractClassMetaData paramCmd = ec.getMetaDataManager().getMetaDataForClass(obj.getClass(), clr); AbstractMemberMetaData paramFieldMmd = paramCmd.getMetaDataForMember(fieldName); if (paramOP != null)
protected Object performExecute(Map parameters) AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(candidateClass, ec.getClassLoaderResolver()); Properties options = new Properties(); options.put(ConnectionFactoryImpl.STORE_JSON_URL, ((JsonPersistenceHandler)getStoreManager().getPersistenceHandler()).getURLPathForQuery(cmd)); parameters, ec.getClassLoaderResolver()); Collection results = resultMapper.execute(true, true, true, true, true); ec.deleteObjects(results.toArray()); return Long.valueOf(results.size());
Table table = ec.getStoreManager().getStoreDataForClass(cmd.getFullClassName()).getTable(); if (cmd.hasDiscriminatorStrategy()) String clsName = ec.getMetaDataManager().getClassNameFromDiscriminatorValue(discValue, cmd.getDiscriminatorMetaData()); if (!cmd.getFullClassName().equals(clsName) && clsName != null) cmd = ec.getMetaDataManager().getMetaDataForClass(clsName, ec.getClassLoaderResolver());
if (!ec.getApiAdapter().isDeleted(element)) ObjectProvider elementOP = ec.findObjectProvider(element); if (elementOP != null) ownerHolderOP = ec.findObjectProviderForEmbedded(holderValueAtField, ownerHolderOP, otherMmd); if (ec.isFlushing())
/** * Accessor for the ObjectProvider of the embedded PC object when provided with the owner object. * @param ownerOP ObjectProvider of the owner * @return ObjectProvider of the embedded object */ private ObjectProvider getObjectProviderForEmbeddedObject(ObjectProvider ownerOP) { AbstractMemberMetaData theMmd = getRealMemberMetaData(); Object value = ownerOP.provideField(theMmd.getAbsoluteFieldNumber()); // Owner (non-embedded) PC TypeManager typeManager = ownerOP.getExecutionContext().getTypeManager(); value = mmd.isSingleCollection() ? typeManager.getContainerAdapter(value).iterator().next() : value; if (value == null) { return null; } ExecutionContext ec = ownerOP.getExecutionContext(); ObjectProvider thisOP = ec.findObjectProvider(value); if (thisOP == null) { // Assign a ObjectProvider to manage our embedded object thisOP = ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, value, false, ownerOP, theMmd.getAbsoluteFieldNumber()); thisOP.setPcObjectType(objectType); } return thisOP; } }