/** * Method to set the ObjectProvider that processing applies to. * This is typically called just before processing the current persistable object on the current row. * @param op The ObjectProvider that we are applying to. */ public void setObjectProvider(ObjectProvider op) { this.op = op; this.cmd = op.getClassMetaData(); }
/** * Convenience method to check if the given object is mapped hierarchical. * @param sm ObjectProvider * @return true if is hierarchical mapped */ public static boolean isHierarchicalMappedAtChild(ObjectProvider sm) { LocationInfo locationInfo = getLocationInfo(sm.getClassMetaData()); return locationInfo.parentFieldName != null; }
protected Attribute getAttributeForField(int fieldNumber) { AbstractMemberMetaData mmd = op.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); String name = LDAPUtils.getAttributeNameForField(mmd); return result.get(name); }
/** * Method to set that the specified object is inserted down to the defined datastore class. * When the object is fully inserted (the table is the primary table for this object type) * it is removed from the map of objects being inserted. * @param op ObjectProvider for the object * @param table Table to which it is now inserted */ public void setObjectIsInsertedToLevel(ObjectProvider op, DatastoreClass table) { insertedDatastoreClassByObjectProvider.put(op, table); if (table.managesClass(op.getClassMetaData().getFullClassName())) { // Full insertion has just completed so update activity state in StateManager op.changeActivityState(ActivityState.INSERTING_CALLBACKS); insertedDatastoreClassByObjectProvider.remove(op); } }
public void storeBooleanField(int fieldNumber, boolean value) { AbstractMemberMetaData mmd = op.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); String name = LDAPUtils.getAttributeNameForField(mmd); // Apache Directory 1.5+ seems to require uppercase for booleans attributes.put(new BasicAttribute(name, ("" + value).toUpperCase())); }
/** * This seems to return the field number in the element of the relation when it is a bidirectional relation. * @param op ObjectProvider for the owner. * @return The field number in the element for this relation */ protected int getFieldNumberInElementForBidirectional(ObjectProvider op) { if (ownerMemberMetaData.getMappedBy() == null) { // Unidirectional return -1; } // This gives a different result when using persistent interfaces. // For example with the JDO2 TCK, org.apache.jdo.tck.pc.company.PIDepartmentImpl.employees will return 3, // yet the ownerMemberMetaData.getRelatedMetaData returns 8 since the generated implementation will have all fields in a single MetaData (numbering from 0), // whereas in a normal inheritance tree there will be multiple MetaData (the root starting from 0) // TODO Support DOT notation in mappedBy return op.getClassMetaData().getAbsolutePositionOfMember(ownerMemberMetaData.getMappedBy()); }
protected void storeStringValue(int fieldNumber, String stringValue) { if (stringValue != null && stringValue.length() == 0) { // this deletes existing value stringValue = null; } AbstractMemberMetaData mmd = op.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); String name = LDAPUtils.getAttributeNameForField(mmd); if (stringValue == null) { if (insert) { return; } attributes.put(new BasicAttribute(name)); return; } // TODO We only ever put String values in here, maybe could use other types? attributes.put(new BasicAttribute(name, stringValue)); } }
/** * Gets the relative distinguished name for object. * @param op ObjectProvider * @return the RDN for object */ private static Rdn getRdnForObject(StoreManager storeMgr, ObjectProvider op) throws InvalidNameException { AbstractClassMetaData cmd = op.getClassMetaData(); // TODO Cater for composite PK int fieldNumber = cmd.getPKMemberPositions()[0]; // Object value = op.provideField(fieldNumber); // AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); Attributes rdnAttributes = new BasicAttributes(); StoreFieldManager storeFM = new StoreFieldManager(storeMgr, op, rdnAttributes, true); op.provideFields(new int[]{fieldNumber}, storeFM); // AbstractMappingStrategy ms = MappingStrategyHelper.findMappingStrategy(storeMgr, op, mmd, rdnAttributes); // ms.insert(value); return new Rdn(rdnAttributes); }
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); }
/** * Method to return the Node/Relationship representing the specified ObjectProvider. * @param graphDB Database service * @param op The object provider * @return The Node/Relationship for this ObjectProvider (or null if not found) * @throws NucleusException if more than 1 Node/Relationship is found matching this ObjectProvider! */ public static PropertyContainer getPropertyContainerForObjectProvider(GraphDatabaseService graphDB, ObjectProvider op) { Object val = op.getAssociatedValue(Neo4jStoreManager.OBJECT_PROVIDER_PROPCONTAINER); if (val != null) { // Cached with ObjectProvider so return it return (PropertyContainer)val; } AbstractClassMetaData cmd = op.getClassMetaData(); ExecutionContext ec = op.getExecutionContext(); PropertyContainer propObj = getPropertyContainerForObjectId(graphDB, ec, cmd, op.getInternalObjectId()); if (propObj != null) { // Cache the Node with the ObjectProvider op.setAssociatedValue(Neo4jStoreManager.OBJECT_PROVIDER_PROPCONTAINER, propObj); } return propObj; }
public static Put getPutForObject(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 Put(rowKey); }
public static Get getGetForObject(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 Get(rowKey); }
public void insertObject(ObjectProvider op) { // Check if read-only so update not permitted assertReadOnlyForUpdateOfObject(op); AbstractClassMetaData cmd = op.getClassMetaData(); if (!storeMgr.managesClass(cmd.getFullClassName())) { // Make sure schema exists, using this connection storeMgr.manageClasses(op.getExecutionContext().getClassLoaderResolver(), new String[] {cmd.getFullClassName()}); } Table table = storeMgr.getStoreDataForClass(cmd.getFullClassName()).getTable(); Map<String,String> options = new HashMap<String,String>(); options.put(ConnectionFactoryImpl.STORE_JSON_URL, "/"); ManagedConnection mconn = storeMgr.getConnectionManager().getConnection(op.getExecutionContext(), options); URLConnection conn = (URLConnection) mconn.getConnection(); createBucket(conn, getHeaderForBucket()); options.put(ConnectionFactoryImpl.STORE_JSON_URL, getURLPath(op)); options.put("Content-Type", "application/json"); mconn = storeMgr.getConnectionManager().getConnection(op.getExecutionContext(), options); conn = (URLConnection) mconn.getConnection(); JSONObject jsonobj = new JSONObject(); op.provideFields(op.getClassMetaData().getAllMemberPositions(), new StoreFieldManager(op, jsonobj, true, table)); write("PUT", conn.getURL().getPath(), conn, jsonobj.toString(), getHeaders("PUT",options)); }
private void updateEmbedded(Object value) { if (value == null) { // create an instance with empty fields, this will null-out all embedded fields // TODO Populate the owner object in this call ObjectProvider embeddedSM = ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, effectiveClassMetaData, null, -1); int[] allMemberPositions = embeddedSM.getClassMetaData().getAllMemberPositions(); for (int i : allMemberPositions) { embeddedSM.makeDirty(i); } //get the dummy value value = embeddedSM.getObject(); } ObjectProvider embeddedSM = ec.findObjectProvider(value); boolean insert = false; if (embeddedSM == null) { embeddedSM = getEmbeddedObjectProvider(value); insert = true; } EmbeddedMetaData embeddedMetaData = mmd.getEmbeddedMetaData(); List<AbstractMemberMetaData> embeddedMmds = new ArrayList<AbstractMemberMetaData>(Arrays.asList(embeddedMetaData.getMemberMetaData())); updateMerge(embeddedSM, attributes, embeddedMmds, embeddedMetaData, insert); }
/** * 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)); }
getDeleteRequest(table, sm.getClassMetaData(), clr).execute(sm);
/** * 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 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); }
protected String getURLPath(ObjectProvider op) { AbstractClassMetaData cmd = op.getClassMetaData(); Table table = storeMgr.getStoreDataForClass(cmd.getFullClassName()).getTable(); String url = getURLPath(cmd); if (cmd.getIdentityType() == IdentityType.DATASTORE) { url += IdentityUtils.getTargetKeyForDatastoreIdentity(op.getInternalObjectId()); } else if (cmd.getIdentityType() == IdentityType.APPLICATION) { // Create JSON object with PK fields set and get the object JSONObject jsonobj = new JSONObject(); op.provideFields(cmd.getPKMemberPositions(), new StoreFieldManager(op, jsonobj, true, table)); try { // Append the PK to the URL AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(cmd.getPKMemberPositions()[0]); String name = table.getMemberColumnMappingForMember(mmd).getColumn(0).getName(); url += jsonobj.get(name).toString(); // TODO Cater for multiple PK fields } catch (JSONException e) { throw new NucleusException(e.getMessage(), e); } } return url; }
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(); } } }