/** * Locates this object in the datastore. * @param op ObjectProvider for the object to be found * @throws NucleusObjectNotFoundException if the object doesnt exist * @throws NucleusDataStoreException when an error occurs in the datastore communication */ public void locateObject(ObjectProvider op) { ClassLoaderResolver clr = op.getExecutionContext().getClassLoaderResolver(); DatastoreClass table = getDatastoreClass(op.getObject().getClass().getName(), clr); getLocateRequest(table, op.getObject().getClass().getName()).execute(op); }
Object pc = pcSM.getObject(); Class<? extends Object> clazz = pc.getClass(); String methodName = ClassUtils.getJavaBeanGetterName(mappedBy, false); Method method = ClassUtils.getMethodForClass(clazz, methodName, null); Object fieldPC = method.invoke(pc); Object myPC = op.getObject(); if (fieldPC == null || fieldPC == myPC)
/** * Method to set the array for the specified owner to the passed value. * @param ownerOP ObjectProvider for the owner * @param array the array * @return Whether the array was updated successfully */ public boolean set(ObjectProvider ownerOP, Object array) { if (array == null) { return true; } // Check that all elements are inserted for (int i=0;i<Array.getLength(array);i++) { validateElementForWriting(ownerOP.getExecutionContext(), Array.get(array, i), null); } // Update the FK and position of all elements int length = Array.getLength(array); for (int i=0;i<length;i++) { E obj = (E)Array.get(array, i); updateElementFk(ownerOP, obj, ownerOP.getObject(), i); } return true; }
/** * Convenience method to update our object with the field values from the passed object. * Objects need to be of the same type, and the other object should not have a StateManager. * @param obj The object that we should copy fields from * @param fieldNumbers Numbers of fields to copy */ public static void copyFieldsFromObject(ObjectProvider op, Object obj, int[] fieldNumbers) { if (obj == null) { return; } Persistable myPC = (Persistable) op.getObject(); if (!obj.getClass().getName().equals(myPC.getClass().getName())) { return; } if (!(obj instanceof Persistable)) { throw new NucleusUserException("Must be Persistable"); } Persistable pc = (Persistable)obj; // Assign the new object to this StateManager temporarily so that we can copy its fields replaceStateManagerForPersistable(pc, op); myPC.dnCopyFields(pc, fieldNumbers); // Remove the StateManager from the other object replaceStateManagerForPersistable(pc, null); // Set the loaded flags now that we have copied op.markFieldsAsLoaded(fieldNumbers); }
public void fetchFields(ObjectProvider vsm) { if (ownerFieldNumber >= 0) { vsm.replaceFieldMakeDirty(ownerFieldNumber, newOwner); } vsm.replaceFieldMakeDirty(keyFieldNumber, newKey); JavaTypeMapping externalFKMapping = valueTable.getExternalMapping(ownerMemberMetaData, MappingType.EXTERNAL_FK); if (externalFKMapping != null) { // Set the owner in the value object where appropriate vsm.setAssociatedValue(externalFKMapping, op.getObject()); } } public void fetchNonLoadedFields(ObjectProvider op)
/** * Gets the object that is embedded within the current entry. * @return the object */ private Object fetchEmbedded() { // use embedded meta data from field EmbeddedMetaData embeddedMetaData = mmd.getEmbeddedMetaData(); // use field meta data from embedded meta data List<AbstractMemberMetaData> embeddedMmds = new ArrayList<AbstractMemberMetaData>(Arrays.asList(embeddedMetaData.getMemberMetaData())); // TODO Provide the owner in this call ObjectProvider embeddedSM = ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, effectiveClassMetaData, null, -1); // TODO Why get SM just after creating it???? embeddedSM = getEmbeddedObjectProvider(embeddedSM.getObject()); return fetchMerge(embeddedSM, attributes, embeddedMmds, embeddedMetaData); }
public void fetchFields(ObjectProvider vsm) { if (ownerFieldNumber >= 0) { vsm.replaceFieldMakeDirty(ownerFieldNumber, newOwner); } vsm.replaceFieldMakeDirty(valueFieldNumber, newValueObj); JavaTypeMapping externalFKMapping = valueTable.getExternalMapping(ownerMemberMetaData, MappingType.EXTERNAL_FK); if (externalFKMapping != null) { // Set the owner in the value object where appropriate vsm.setAssociatedValue(externalFKMapping, op.getObject()); } } public void fetchNonLoadedFields(ObjectProvider op)
/** * Utility to throw an exception if the object is not persistable. * @param op The ObjectProvider for the object */ void assertPCClass(ObjectProvider op) { Class c = op.getObject().getClass(); if (!op.getExecutionContext().getClassLoaderResolver().isAssignableFrom(cmd.getFullClassName(),c)) { throw new NucleusException(Localiser.msg("057013",cmd.getFullClassName(),c)).setFatal(); } }
public FetchFieldManager(ObjectProvider op, Document doc) { this.op = op; this.doc = doc; ExecutionContext ec = op.getExecutionContext(); node = XMLUtils.findNode(doc, op); try { value = ((XMLStoreManager)ec.getStoreManager()).getJAXBHandler().unmarshall(op.getObject().getClass(), node, op.getExecutionContext().getClassLoaderResolver()); } catch (JAXBException e) { NucleusLogger.DATASTORE_RETRIEVE.warn("Exception unmarshalling XML", e); } }
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); }
return (ownerOps != null && ownerOps.length > 0 ? ownerOps[0].getObject() : null);
/** * Convenience method to populate the passed PreparedStatement with the value from the owner. * @param op ObjectProvider * @param ec execution context * @param ps The PreparedStatement * @param jdbcPosition Position in JDBC statement to populate * @param joinTable Join table * @return The next position in the JDBC statement */ public static int populateOwnerInStatement(ObjectProvider op, ExecutionContext ec, PreparedStatement ps, int jdbcPosition, PersistableJoinTable joinTable) { if (!joinTable.getStoreManager().insertValuesOnInsert(joinTable.getOwnerMapping().getDatastoreMapping(0))) { // Don't try to insert any mappings with insert parameter that isnt ? (e.g Oracle) return jdbcPosition; } if (joinTable.getOwnerMemberMetaData() != null) { joinTable.getOwnerMapping().setObject(ec, ps, MappingHelper.getMappingIndices(jdbcPosition, joinTable.getOwnerMapping()), op.getObject(), op, joinTable.getOwnerMemberMetaData().getAbsoluteFieldNumber()); } else { joinTable.getOwnerMapping().setObject(ec, ps, MappingHelper.getMappingIndices(jdbcPosition, joinTable.getOwnerMapping()), op.getObject()); } return jdbcPosition + joinTable.getOwnerMapping().getNumberOfDatastoreMappings(); } }
embeddedSM.replaceField(embFieldNum, op.getObject());
bcs.getOwnerMapping().setObject(ec, ps, MappingHelper.getMappingIndices(jdbcPosition, bcs.getOwnerMapping()), ownerOP.getObject(), ownerOP, bcs.getOwnerMemberMetaData().getAbsoluteFieldNumber()); bcs.getOwnerMapping().setObject(ec, ps, MappingHelper.getMappingIndices(jdbcPosition, bcs.getOwnerMapping()), ownerOP.getObject());
public Object fetchObjectField(int fieldNumber) { ClassLoaderResolver clr = ec.getClassLoaderResolver(); AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); RelationType relationType = mmd.getRelationType(clr); // Special cases if (relationType != RelationType.NONE && MetaDataUtils.getInstance().isMemberEmbedded(ec.getMetaDataManager(), clr, mmd, relationType, null)) { // Embedded field if (RelationType.isRelationSingleValued(relationType)) { // TODO Null detection List<AbstractMemberMetaData> embMmds = new ArrayList<AbstractMemberMetaData>(); embMmds.add(mmd); AbstractClassMetaData embCmd = ec.getMetaDataManager().getMetaDataForClass(mmd.getType(), clr); ObjectProvider embOP = ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, embCmd, op, fieldNumber); FieldManager fetchEmbFM = new FetchEmbeddedFieldManager(embOP, sheet, rowNumber, embMmds, table); embOP.replaceFields(embCmd.getAllMemberPositions(), fetchEmbFM); return embOP.getObject(); } else if (RelationType.isRelationMultiValued(relationType)) { throw new NucleusUserException("Dont support embedded multi-valued field at " + mmd.getFullFieldName() + " with Excel"); } } return fetchObjectFieldInternal(fieldNumber, mmd, clr, relationType); }
@Override public Object fetchObjectField(int fieldNumber) { ClassLoaderResolver clr = ec.getClassLoaderResolver(); AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); RelationType relationType = mmd.getRelationType(clr); // Special cases if (relationType != RelationType.NONE && MetaDataUtils.getInstance().isMemberEmbedded(ec.getMetaDataManager(), clr, mmd, relationType, null)) { // Embedded field if (RelationType.isRelationSingleValued(relationType)) { // TODO Null detection List<AbstractMemberMetaData> embMmds = new ArrayList<AbstractMemberMetaData>(); embMmds.add(mmd); AbstractClassMetaData embCmd = ec.getMetaDataManager().getMetaDataForClass(mmd.getType(), clr); ObjectProvider embOP = ec.getNucleusContext().getObjectProviderFactory().newForEmbedded(ec, embCmd, op, fieldNumber); FieldManager fetchEmbFM = new FetchEmbeddedFieldManager(embOP, row, embMmds, table); embOP.replaceFields(embCmd.getAllMemberPositions(), fetchEmbFM); return embOP.getObject(); } else if (RelationType.isRelationMultiValued(relationType)) { throw new NucleusUserException("Dont support embedded multi-valued field at " + mmd.getFullFieldName() + " with ODF"); } } return fetchObjectFieldInternal(fieldNumber, mmd, clr, relationType); }
public boolean add(ObjectProvider op1, ObjectProvider op2) { String addStmt = getAddStmt(); ExecutionContext ec = op1.getExecutionContext(); SQLController sqlControl = storeMgr.getSQLController(); try { ManagedConnection mconn = storeMgr.getConnectionManager().getConnection(ec); PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, addStmt, false); try { // Insert the join table row int jdbcPosition = 1; jdbcPosition = populateOwnerInStatement(op1, ec, ps, jdbcPosition, joinTable); BackingStoreHelper.populateElementInStatement(ec, ps, op2.getObject(), jdbcPosition, joinTable.getRelatedMapping()); // Execute the statement int[] nums = sqlControl.executeStatementUpdate(ec, mconn, addStmt, ps, true); return (nums != null && nums.length == 1 && nums[0] == 1); } finally { sqlControl.closeStatement(mconn, ps); mconn.release(); } } catch (SQLException sqle) { throw new NucleusDataStoreException("Exception thrown inserting row into persistable relation join table", sqle); } }
public boolean update(ObjectProvider op1, ObjectProvider op2) { String updateStmt = getUpdateStmt(); ExecutionContext ec = op1.getExecutionContext(); SQLController sqlControl = storeMgr.getSQLController(); try { ManagedConnection mconn = storeMgr.getConnectionManager().getConnection(ec); PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, updateStmt, false); try { // Update the join table row int jdbcPosition = 1; jdbcPosition = BackingStoreHelper.populateElementInStatement(ec, ps, op2.getObject(), jdbcPosition, joinTable.getRelatedMapping()); populateOwnerInStatement(op1, ec, ps, jdbcPosition, joinTable); // Execute the statement int[] nums = sqlControl.executeStatementUpdate(ec, mconn, updateStmt, ps, true); return (nums != null && nums.length == 1 && nums[0] == 1); } finally { sqlControl.closeStatement(mconn, ps); mconn.release(); } } catch (SQLException sqle) { throw new NucleusDataStoreException("Exception thrown updating row into persistable relation join table", sqle); } }