/** Compare the attributes. Return true if they are alike. Ignore the order of the elements. */ private boolean compareAttributeValuesWithoutOrder( Object collection1, Object collection2, AbstractSession session) { ContainerPolicy cp = this.getContainerPolicy(); Vector vector2 = cp.vectorFor(collection2, session); // "clone" it so we can clear out the slots for (Object iter1 = cp.iteratorFor(collection1); cp.hasNext(iter1); ) { Object element1 = cp.next(iter1, session); boolean found = false; for (int i = 0; i < vector2.size(); i++) { if (this.compareElements(element1, vector2.elementAt(i), session)) { found = true; vector2.setElementAt(XXX, i); // clear out the matching element break; // matching element found - skip the rest of them } } if (!found) { return false; } } // look for elements that were not in collection1 for (Enumeration stream = vector2.elements(); stream.hasMoreElements(); ) { if (stream.nextElement() != XXX) { return false; } } return true; }
/** INTERNAL: Delete the reference objects. */ public void preDelete(DeleteObjectQuery query) throws DatabaseException, OptimisticLockException { if (isForeignKeyRelationship()) { return; } if (!this.shouldObjectModifyCascadeToParts(query)) { return; } Object objects = this.getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession()); ContainerPolicy cp = this.getContainerPolicy(); // if privately-owned parts have their privately-owned sub-parts, delete them one by one; // else delete everything in one shot if (this.mustDeleteReferenceObjectsOneByOne()) { for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter); ) { DeleteObjectQuery deleteQuery = new DeleteObjectQuery(); deleteQuery.setIsExecutionClone(true); deleteQuery.setObject(cp.next(iter, query.getSession())); deleteQuery.setCascadePolicy(query.getCascadePolicy()); query.getSession().executeQuery(deleteQuery); } if (!query.getSession().isUnitOfWork()) { // This deletes any objects on the database, as the collection in memory may have been // changed. // This is not required for unit of work, as the update would have already deleted these // objects, // and the backup copy will include the same objects causing double deletes. this.deleteReferenceObjectsLeftOnDatabase(query); } } else { this.deleteAll(query); } }
/** * INTERNAL: The mapping is initialized with the given session. This mapping is fully initialized * after this. */ public void initialize(AbstractSession session) throws DescriptorException { // modified so that reference class on composite mappings is no longer mandatory String referenceClassName = getReferenceClassName(); if (this.referenceClass == null && referenceClassName != null) { if (!referenceClassName.equals(XMLConstants.UNKNOWN_OR_TRANSIENT_CLASS)) { setReferenceClass( session .getDatasourcePlatform() .getConversionManager() .convertClassNameToClass(referenceClassName)); } } initializeReferenceDescriptorAndField(session); ContainerPolicy cp = getContainerPolicy(); if (cp != null) { if (cp.getContainerClass() == null) { Class cls = session .getDatasourcePlatform() .getConversionManager() .convertClassNameToClass(cp.getContainerClassName()); cp.setContainerClass(cls); } if (cp instanceof MapContainerPolicy) { initializeMapContainerPolicy(session, (MapContainerPolicy) cp); } } if (null != getContainerAccessor()) { getContainerAccessor().initializeAttributes(this.referenceClass); } }
protected Object instantiate(AbstractSession session) throws DatabaseException { Vector rows = mapping.getForeignKeyRows(this.getRow()); int size = rows.size(); ContainerPolicy cp = ((ReadAllQuery) this.getQuery()).getContainerPolicy(); Object returnValue = cp.containerInstance(size); for (int i = 0; i < size; i++) { AbstractRecord nextRow = (AbstractRecord) rows.get(i); Object results = session.executeQuery(getQuery(), nextRow); if (results instanceof Collection) { Iterator iter = ((Collection) results).iterator(); while (iter.hasNext()) { cp.addInto(iter.next(), returnValue, session); } } else if (results instanceof java.util.Map) { Iterator iter = ((java.util.Map) results).values().iterator(); while (iter.hasNext()) { cp.addInto(iter.next(), returnValue, session); } } else { cp.addInto(results, returnValue, session); } } return returnValue; }
/** * PUBLIC: Configure the query to use an instance of the specified container class to hold the * result objects. The key used to index the value in the Map is the value returned by a call to * the specified zero-argument method. The method must be implemented by the class (or a * superclass) of the value to be inserted into the Map. * * <p>jdk1.2.x: The container class must implement (directly or indirectly) the Map interface. * * <p>jdk1.1.x: The container class must be a subclass of Hashtable. * * <p>The referenceClass must set before calling this method. */ public void useMapClass(Class concreteClass, String methodName) { // the reference class has to be specified before coming here if (getReferenceClass() == null) { throw QueryException.referenceClassMissing(this); } ContainerPolicy policy = ContainerPolicy.buildPolicyFor(concreteClass); policy.setKeyName(methodName, getReferenceClass().getName()); setContainerPolicy(policy); }
/** * This method will make sure that all the records privately owned by this mapping are actually * removed. If such records are found then those are all read and removed one by one along with * their privately owned parts. */ protected void deleteReferenceObjectsLeftOnDatabase(DeleteObjectQuery query) throws DatabaseException, OptimisticLockException { Object objects = this.readPrivateOwnedForObject(query); // delete all these objects one by one ContainerPolicy cp = this.getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter); ) { query.getSession().deleteObject(cp.next(iter, query.getSession())); } }
/** INTERNAL: Insert privately owned parts */ public void preInsert(WriteObjectQuery query) throws DatabaseException, OptimisticLockException { if (!this.isForeignKeyRelationship()) { return; } if (!this.shouldObjectModifyCascadeToParts(query)) { return; } // only cascade dependents in UOW if (query.shouldCascadeOnlyDependentParts()) { return; } Object objects = this.getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession()); // insert each object one by one ContainerPolicy cp = this.getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter); ) { Object object = cp.next(iter, query.getSession()); if (this.isPrivateOwned()) { // no need to set changeset here as insert is just a copy of the object anyway InsertObjectQuery insertQuery = new InsertObjectQuery(); insertQuery.setIsExecutionClone(true); insertQuery.setObject(object); insertQuery.setCascadePolicy(query.getCascadePolicy()); query.getSession().executeQuery(insertQuery); } else { // This will happen in a unit of work or cascaded query. // This is done only for persistence by reachability and is not required if the targets are // in the queue anyway // Avoid cycles by checking commit manager, this is allowed because there is no dependency. if (!query.getSession().getCommitManager().isCommitInPreModify(object)) { WriteObjectQuery writeQuery = new WriteObjectQuery(); writeQuery.setIsExecutionClone(true); if (query.getSession().isUnitOfWork()) { UnitOfWorkChangeSet uowChangeSet = (UnitOfWorkChangeSet) ((UnitOfWorkImpl) query.getSession()).getUnitOfWorkChangeSet(); if (uowChangeSet != null) { writeQuery.setObjectChangeSet( (ObjectChangeSet) uowChangeSet.getObjectChangeSetForClone(object)); } } writeQuery.setObject(object); writeQuery.setCascadePolicy(query.getCascadePolicy()); query.getSession().executeQuery(writeQuery); } } } }
/** INTERNAL: Used to verify whether the specified object is deleted or not. */ public boolean verifyDelete(Object object, AbstractSession session) throws DatabaseException { if (this.isPrivateOwned()) { Object objects = this.getRealCollectionAttributeValueFromObject(object, session); ContainerPolicy containerPolicy = getContainerPolicy(); for (Object iter = containerPolicy.iteratorFor(objects); containerPolicy.hasNext(iter); ) { if (!session.verifyDelete(containerPolicy.next(iter, session))) { return false; } } } return true; }
/** * Build and return the change record that results from comparing the two collection attributes. * The order of the elements is significant. */ private ChangeRecord compareAttributeValuesForChangeWithOrder( Object cloneCollection, Object backupCollection, ObjectChangeSet owner, AbstractSession session) { ContainerPolicy cp = this.getContainerPolicy(); Vector cloneVector = cp.vectorFor( cloneCollection, session); // convert it to a Vector so we can preserve the order and use indexes Vector backupVector = cp.vectorFor(backupCollection, session); // "clone" it so we can clear out the slots EISOrderedCollectionChangeRecord changeRecord = new EISOrderedCollectionChangeRecord( owner, this.getAttributeName(), this.getDatabaseMapping()); for (int i = 0; i < cloneVector.size(); i++) { Object cloneElement = cloneVector.elementAt(i); boolean found = false; for (int j = 0; j < backupVector.size(); j++) { if (this.compareElementsForChange(cloneElement, backupVector.elementAt(j), session)) { // the clone element was found in the backup collection found = true; backupVector.setElementAt(XXX, j); // clear out the matching backup element changeRecord.addMovedChangeSet(this.buildChangeSet(cloneElement, owner, session), j, i); break; // matching backup element found - skip the rest of them } } if (!found) { // the clone element was not found, so it must have been added changeRecord.addAddedChangeSet(this.buildChangeSet(cloneElement, owner, session), i); } } for (int i = 0; i < backupVector.size(); i++) { Object backupElement = backupVector.elementAt(i); if (backupElement != XXX) { // the backup element was not in the clone collection, so it must have been removed changeRecord.addRemovedChangeSet(this.buildChangeSet(backupElement, owner, session), i); } } if (changeRecord.hasChanges()) { return changeRecord; } else { return null; } }
/** INTERNAL: */ @Override public void writeFromObjectIntoRow( Object object, AbstractRecord row, AbstractSession session, WriteType writeType) throws DescriptorException { if (this.isReadOnly()) { return; } Object attributeValue = this.getAttributeValueFromObject(object); if (attributeValue == null) { row.put(this.getField(), null); return; } ContainerPolicy cp = this.getContainerPolicy(); Vector nestedRows = new Vector(cp.sizeFor(attributeValue)); Object iter = cp.iteratorFor(attributeValue); if (null != iter) { while (cp.hasNext(iter)) { Object element = cp.next(iter, session); // convert the value - if necessary element = convertObjectValueToDataValue(element, session, ((XMLRecord) row).getMarshaller()); if (element == null) { XMLNullRepresentationType nullRepresentation = getNullPolicy().getMarshalNullRepresentation(); if (nullRepresentation == XMLNullRepresentationType.XSI_NIL) { nestedRows.add(XMLRecord.NIL); } else if (nullRepresentation == XMLNullRepresentationType.EMPTY_NODE) { Node emptyNode = XPathEngine.getInstance() .createUnownedElement(((XMLRecord) row).getDOM(), (XMLField) field); DOMRecord nestedRow = new DOMRecord(emptyNode); nestedRows.add(nestedRow); } } else { nestedRows.addElement(buildCompositeRow(element, session, row, writeType)); } } } Object fieldValue = null; if (!nestedRows.isEmpty()) { fieldValue = this.getDescriptor() .buildFieldValueFromNestedRows(nestedRows, getStructureName(), session); } row.put(this.getField(), fieldValue); }
/** * Compare the attributes. Return true if they are alike. The order of the elements is * significant. */ private boolean compareAttributeValuesWithOrder( Object collection1, Object collection2, AbstractSession session) { ContainerPolicy cp = this.getContainerPolicy(); Object iter1 = cp.iteratorFor(collection1); Object iter2 = cp.iteratorFor(collection2); while (cp.hasNext(iter1)) { if (!this.compareElements(cp.next(iter1, session), cp.next(iter2, session), session)) { return false; } } return true; }
/** * INTERNAL: The mapping is initialized with the given session. This mapping is fully initialized * after this. */ public void initialize(AbstractSession session) throws DescriptorException { super.initialize(session); ContainerPolicy cp = getContainerPolicy(); if (cp != null) { if (cp.getContainerClass() == null) { Class cls = session .getDatasourcePlatform() .getConversionManager() .convertClassNameToClass(cp.getContainerClassName()); cp.setContainerClass(cls); } } }
/** * INTERNAL: Extract the primary key values from the row, then create an * org.eclipse.persistence.internal.oxm.Reference instance and stored it on the session's * org.eclipse.persistence.internal.oxm.ReferenceResolver. */ public Object readFromRowIntoObject( AbstractRecord databaseRow, JoinedAttributeManager joinManager, Object targetObject, ObjectBuildingQuery sourceQuery, AbstractSession executionSession) throws DatabaseException { ClassDescriptor descriptor = sourceQuery.getSession().getClassDescriptor(getReferenceClass()); ContainerPolicy cp = this.getContainerPolicy(); Vector pkFieldNames = referenceDescriptor.getPrimaryKeyFieldNames(); Vector primaryKeyValues = new Vector(); primaryKeyValues.setSize(pkFieldNames.size()); HashMap primaryKeyMap = new HashMap(); // for each source xmlField, get the value from the row and store for (Iterator fieldIt = getFields().iterator(); fieldIt.hasNext(); ) { XMLField fld = (XMLField) fieldIt.next(); XMLField tgtFld = (XMLField) getSourceToTargetKeyFieldAssociations().get(fld); Object fieldValue = databaseRow.getValues(fld); if ((fieldValue == null) || (fieldValue instanceof String) || !(fieldValue instanceof Vector)) { return cp.containerInstance(); } // fix for bug# 5687430 // need to get the actual type of the target (i.e. int, String, etc.) // and use the converted value when checking the cache. XMLConversionManager xmlConversionManager = (XMLConversionManager) executionSession.getDatasourcePlatform().getConversionManager(); Vector newValues = new Vector(); for (Iterator valIt = ((Vector) fieldValue).iterator(); valIt.hasNext(); ) { for (StringTokenizer stok = new StringTokenizer((String) valIt.next()); stok.hasMoreTokens(); ) { Object value = xmlConversionManager.convertObject( stok.nextToken(), descriptor.getTypedField(tgtFld).getType()); if (value != null) { newValues.add(value); } } } primaryKeyMap.put(tgtFld.getXPath(), newValues); } // store the Reference instance on the resolver for use during mapping resolution phase ReferenceResolver resolver = ReferenceResolver.getInstance(sourceQuery.getSession()); if (resolver != null) { resolver.addReference(new Reference(this, targetObject, referenceClass, primaryKeyMap)); } return null; }
/** * Merge changes from the source to the target object. Make the necessary removals and adds and * map key modifications. */ private void mergeChangesIntoObjectWithoutOrder( Object target, ChangeRecord changeRecord, Object source, MergeManager mergeManager) { EISCollectionChangeRecord sdkChangeRecord = (EISCollectionChangeRecord) changeRecord; ContainerPolicy cp = this.getContainerPolicy(); AbstractSession session = mergeManager.getSession(); Object targetCollection = null; if (sdkChangeRecord.getOwner().isNew()) { targetCollection = cp.containerInstance(sdkChangeRecord.getAdds().size()); } else { targetCollection = this.getRealCollectionAttributeValueFromObject(target, session); } Vector removes = sdkChangeRecord.getRemoves(); Vector adds = sdkChangeRecord.getAdds(); Vector changedMapKeys = sdkChangeRecord.getChangedMapKeys(); synchronized (targetCollection) { for (Enumeration stream = removes.elements(); stream.hasMoreElements(); ) { Object removeElement = this.buildRemovedElementFromChangeSet(stream.nextElement(), mergeManager); Object targetElement = null; for (Object iter = cp.iteratorFor(targetCollection); cp.hasNext(iter); ) { targetElement = cp.next(iter, session); if (this.compareElements(targetElement, removeElement, session)) { break; // matching element found - skip the rest of them } } if (targetElement != null) { // a matching element was found, remove it cp.removeFrom(targetElement, targetCollection, session); } } for (Enumeration stream = adds.elements(); stream.hasMoreElements(); ) { Object addElement = this.buildAddedElementFromChangeSet(stream.nextElement(), mergeManager); cp.addInto(addElement, targetCollection, session); } for (Enumeration stream = changedMapKeys.elements(); stream.hasMoreElements(); ) { Object changedMapKeyElement = this.buildAddedElementFromChangeSet(stream.nextElement(), mergeManager); Object originalElement = ((UnitOfWorkImpl) session).getOriginalVersionOfObject(changedMapKeyElement); cp.removeFrom(originalElement, targetCollection, session); cp.addInto(changedMapKeyElement, targetCollection, session); } } // reset the attribute to allow for set method to re-morph changes if the collection is not // being stored directly this.setRealAttributeValueInObject(target, targetCollection); }
/** * Build and return the change record that results from comparing the two collection attributes. * Ignore the order of the elements. */ private ChangeRecord compareAttributeValuesForChangeWithoutOrder( Object cloneCollection, Object backupCollection, ObjectChangeSet owner, AbstractSession session) { ContainerPolicy cp = this.getContainerPolicy(); Vector backupVector = cp.vectorFor(backupCollection, session); // "clone" it so we can clear out the slots EISCollectionChangeRecord changeRecord = new EISCollectionChangeRecord(owner, this.getAttributeName(), this.getDatabaseMapping()); for (Object cloneIter = cp.iteratorFor(cloneCollection); cp.hasNext(cloneIter); ) { Object cloneElement = cp.next(cloneIter, session); boolean found = false; for (int i = 0; i < backupVector.size(); i++) { if (this.compareElementsForChange(cloneElement, backupVector.elementAt(i), session)) { // the clone element was found in the backup collection found = true; backupVector.setElementAt(XXX, i); // clear out the matching backup element if (this.mapKeyHasChanged(cloneElement, session)) { changeRecord.addChangedMapKeyChangeSet( this.buildChangeSet(cloneElement, owner, session)); } break; // matching backup element found - skip the rest of them } } if (!found) { // the clone element was not found, so it must have been added changeRecord.addAddedChangeSet(this.buildChangeSet(cloneElement, owner, session)); } } for (int i = 0; i < backupVector.size(); i++) { Object backupElement = backupVector.elementAt(i); if (backupElement != XXX) { // the backup element was not in the clone collection, so it must have been removed changeRecord.addRemovedChangeSet(this.buildChangeSet(backupElement, owner, session)); } } if (changeRecord.hasChanges()) { return changeRecord; } else { return null; } }
public void addEmployeeDescriptor(boolean methodAccess) { XMLDescriptor descriptor = new XMLDescriptor(); descriptor.setJavaClass(Employee.class); descriptor.setDefaultRootElement("employee"); XMLDirectMapping idMapping = new XMLDirectMapping(); idMapping.setAttributeName("id"); idMapping.setXPath("@id"); descriptor.addMapping(idMapping); XMLDirectMapping firstNameMapping = new XMLDirectMapping(); firstNameMapping.setAttributeName("firstName"); firstNameMapping.setXPath("first-name/text()"); descriptor.addMapping(firstNameMapping); XMLDirectMapping lastNameMapping = new XMLDirectMapping(); lastNameMapping.setAttributeName("lastName"); lastNameMapping.setXPath("last-name/text()"); descriptor.addMapping(lastNameMapping); XMLCompositeObjectMapping addressMapping = new XMLCompositeObjectMapping(); addressMapping.setAttributeName("address"); addressMapping.setReferenceClass(Address.class); addressMapping.setXPath("address"); descriptor.addMapping(addressMapping); XMLCompositeCollectionMapping phoneMapping = new XMLCompositeCollectionMapping(); phoneMapping.setAttributeName("phoneNumbers"); phoneMapping.setReferenceClass(PhoneNumber.class); phoneMapping.setXPath("phone-numbers/number"); phoneMapping.setContainerPolicy(ContainerPolicy.buildPolicyFor(ArrayList.class)); descriptor.addMapping(phoneMapping); this.addDescriptor(descriptor); }
/** * INTERNAL: Select all objects for an interface descriptor. This is accomplished by selecting for * all of the concrete classes and then merging the objects. * * @return Vector containing all objects. * @exception DatabaseException - an error has occurred on the database. */ public Object selectAllObjectsUsingMultipleTableSubclassRead(ReadAllQuery query) throws DatabaseException { org.eclipse.persistence.internal.queries.ContainerPolicy containerPolicy = query.getContainerPolicy(); Object objects = containerPolicy.containerInstance(1); for (Enumeration childDescriptors = getChildDescriptors().elements(); childDescriptors.hasMoreElements(); ) { ClassDescriptor descriptor = (ClassDescriptor) childDescriptors.nextElement(); objects = containerPolicy.concatenateContainers( objects, descriptor.getInterfacePolicy().selectAllObjects(query)); } return objects; }
/** * For isMany=false properties set the value to null. For isMany=true set the value to an empty * container of the appropriate type. */ public void unsetDeclaredProperty(int propertyIndex) { SDOProperty declaredProperty = (SDOProperty) dataObject.getType().getDeclaredProperties().get(propertyIndex); Mapping mapping = this.getJAXBMappingForProperty(declaredProperty); if (declaredProperty.isMany()) { ContainerMapping containerMapping = (ContainerMapping) mapping; ContainerPolicy containerPolicy = containerMapping.getContainerPolicy(); // OLD VALUE if (mapping.isAbstractCompositeCollectionMapping()) { XMLCompositeCollectionMapping compositeMapping = (XMLCompositeCollectionMapping) mapping; if (compositeMapping.getContainerAccessor() != null) { Object oldContainer = mapping.getAttributeValueFromObject(entity); if (oldContainer != null) { AbstractSession session = ((JAXBContext) jaxbHelperContext.getJAXBContext()) .getXMLContext() .getSession(entity); Object iterator = containerPolicy.iteratorFor(oldContainer); while (containerPolicy.hasNext(iterator)) { Object oldValue = containerPolicy.next(iterator, session); compositeMapping.getContainerAccessor().setAttributeValueInObject(oldValue, null); } } } } // NEW VALUE Object container = containerPolicy.containerInstance(); mapping.getAttributeAccessor().setAttributeValueInObject(entity, container); } else { // OLD VALUE Object oldValue = mapping.getAttributeAccessor().getAttributeValueFromObject(entity); if (mapping.isAbstractCompositeObjectMapping()) { XMLCompositeObjectMapping compositeMapping = (XMLCompositeObjectMapping) mapping; if (compositeMapping.getContainerAccessor() != null) { if (oldValue != null) { compositeMapping.getContainerAccessor().setAttributeValueInObject(oldValue, null); } } } // NEW VALUE mapping.getAttributeAccessor().setAttributeValueInObject(entity, null); } }
public boolean marshal( XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, AbstractSession session, NamespaceResolver namespaceResolver) { if (xmlBinaryDataCollectionMapping.isReadOnly()) { return false; } Object collection = xmlBinaryDataCollectionMapping.getAttributeAccessor().getAttributeValueFromObject(object); if (null == collection) { return false; } String xopPrefix = null; // If the field's resolver is non-null and has an entry for XOP, // use it - otherwise, create a new resolver, set the XOP entry, // on it, and use it instead. // We do this to avoid setting the XOP namespace declaration on // a given field or descriptor's resolver, as it is only required // on the current element if (namespaceResolver != null) { xopPrefix = namespaceResolver.resolveNamespaceURI(XMLConstants.XOP_URL); } if (xopPrefix == null || namespaceResolver == null) { xopPrefix = XMLConstants.XOP_PREFIX; marshalRecord.getNamespaceResolver().put(xopPrefix, XMLConstants.XOP_URL); } ContainerPolicy cp = getContainerPolicy(); Object iterator = cp.iteratorFor(collection); while (cp.hasNext(iterator)) { Object objectValue = cp.next(iterator, session); marshalSingleValue( xPathFragment, marshalRecord, object, objectValue, session, namespaceResolver, ObjectMarshalContext.getInstance()); } marshalRecord.getNamespaceResolver().removeNamespace(XMLConstants.XOP_PREFIX); return true; }
/** * Merge changes from the source to the target object. Simply replace the entire target * collection. */ private void mergeChangesIntoObjectWithOrder( Object target, ChangeRecord changeRecord, Object source, MergeManager mergeManager) { ContainerPolicy cp = this.getContainerPolicy(); AbstractSession session = mergeManager.getSession(); Vector changes = ((EISOrderedCollectionChangeRecord) changeRecord).getNewCollection(); Object targetCollection = cp.containerInstance(changes.size()); for (Enumeration stream = changes.elements(); stream.hasMoreElements(); ) { Object targetElement = this.buildAddedElementFromChangeSet(stream.nextElement(), mergeManager); cp.addInto(targetElement, targetCollection, session); } // reset the attribute to allow for set method to re-morph changes if the collection is not // being stored directly this.setRealAttributeValueInObject(target, targetCollection); }
/** * INTERNAL: Get the appropriate attribute value from the object and put it in the appropriate * field of the database row. Loop through the reference objects and extract the primary keys and * put them in the vector of "nested" rows. */ public void writeFromObjectIntoRow(Object object, AbstractRecord row, AbstractSession session) { if (!isForeignKeyRelationship) { return; } if (((getSourceForeignKeysToTargetKeys()) == null) || (getSourceForeignKeysToTargetKeys().size() == 0)) { return; } if (this.isReadOnly()) { return; } AbstractRecord referenceRow = this.getIndirectionPolicy().extractReferenceRow(this.getAttributeValueFromObject(object)); if (referenceRow != null) { // the reference objects have not been instantiated - use the value from the original row if (getForeignKeyGroupingElement() != null) { row.put( this.getForeignKeyGroupingElement(), referenceRow.getValues(this.getForeignKeyGroupingElement())); } else if (getSourceForeignKeyFields().size() > 0) { DatabaseField foreignKeyField = (DatabaseField) getSourceForeignKeyFields().get(0); row.put(foreignKeyField, referenceRow.getValues(foreignKeyField)); } return; } ContainerPolicy cp = this.getContainerPolicy(); // extract the keys from the objects Object attributeValue = this.getRealCollectionAttributeValueFromObject(object, session); Vector nestedRows = new Vector(cp.sizeFor(attributeValue)); if (getForeignKeyGroupingElement() != null) { for (Object iter = cp.iteratorFor(attributeValue); cp.hasNext(iter); ) { XMLRecord nestedRow = this.extractKeyRowFromReferenceObject(cp.next(iter, session), session, (XMLRecord) row); nestedRows.addElement(nestedRow); } row.add(this.getForeignKeyGroupingElement(), nestedRows); } else { DatabaseField singleField = (DatabaseField) getSourceForeignKeyFields().get(0); DatabaseField pkField = (DatabaseField) getSourceForeignKeysToTargetKeys().get(singleField); for (Object iter = cp.iteratorFor(attributeValue); cp.hasNext(iter); ) { Object singleValue = getReferenceDescriptor() .getObjectBuilder() .extractValueFromObjectForField(cp.next(iter, session), pkField, session); row.add(singleField, singleValue); } } }
/** * Compare the attributes. Return true if they are alike. Assume the passed-in attributes are * non-null. */ private boolean compareAttributeValues( Object collection1, Object collection2, AbstractSession session) { ContainerPolicy cp = this.getContainerPolicy(); if (cp.sizeFor(collection1) != cp.sizeFor(collection2)) { return false; } // if they are both empty, go no further... if (cp.sizeFor(collection1) == 0) { return true; } if (cp.hasOrder()) { return this.compareAttributeValuesWithOrder(collection1, collection2, session); } else { return this.compareAttributeValuesWithoutOrder(collection1, collection2, session); } }
/** * INTERNAL: Build and return the change record that results from comparing the two collection * attributes. */ public ChangeRecord compareForChange( Object clone, Object backup, ObjectChangeSet owner, AbstractSession session) { ContainerPolicy cp = this.getContainerPolicy(); Object cloneCollection = this.getRealCollectionAttributeValueFromObject(clone, session); Object backupCollection = null; if (owner.isNew()) { backupCollection = cp.containerInstance(1); } else { backupCollection = this.getRealCollectionAttributeValueFromObject(backup, session); } if (cp.hasOrder()) { return this.compareAttributeValuesForChangeWithOrder( cloneCollection, backupCollection, owner, session); } else { return this.compareAttributeValuesForChangeWithoutOrder( cloneCollection, backupCollection, owner, session); } }
/** * INTERNAL: The results are *not* in a cursor, build the collection. Cache the results in * temporaryCachedQueryResults. */ protected Object executeNonCursor() throws DatabaseException { Vector rows = getQueryMechanism().executeSelect(); Object results = null; if (this.resultType == MAP) { results = getContainerPolicy().buildContainerFromVector(rows, this.session); } else if (this.resultType == VALUE) { if (!rows.isEmpty()) { AbstractRecord record = (AbstractRecord) rows.get(0); // Use get with field for XML records. results = record.get(record.getFields().get(0)); if (getValueConverter() != null) { results = getValueConverter().convertDataValueToObjectValue(results, this.session); } } } else { int size = rows.size(); ContainerPolicy containerPolicy = getContainerPolicy(); results = containerPolicy.containerInstance(size); if (containerPolicy.shouldAddAll()) { if (size > 0) { List values = new ArrayList(size); for (int index = 0; index < size; index++) { AbstractRecord row = (AbstractRecord) rows.get(index); Object value = buildObject(row); values.add(value); } containerPolicy.addAll(values, results, this.session, rows, this); } } else { for (int index = 0; index < size; index++) { AbstractRecord row = (AbstractRecord) rows.get(index); Object value = buildObject(row); containerPolicy.addInto(value, results, this.session, row, this); } } } // Bug 6135563 - cache DataReadQuery results verbatim, as ObjectBuilder is not invoked cacheResult(results); return results; }
/** * INTERNAL: Execute the query. Get the rows and build the object from the rows. * * @exception DatabaseException - an error has occurred on the database * @return java.lang.Object collection of objects resulting from execution of query. */ protected Object executeObjectLevelReadQuery() throws DatabaseException { Object result = null; if (getContainerPolicy().overridesRead()) { return getContainerPolicy().execute(); } if (this.descriptor.isDescriptorForInterface()) { Object returnValue = this.descriptor.getInterfacePolicy().selectAllObjectsUsingMultipleTableSubclassRead(this); setExecutionTime(System.currentTimeMillis()); return returnValue; } List rows = getQueryMechanism().selectAllRows(); setExecutionTime(System.currentTimeMillis()); // If using 1-m joins, must set all rows. if (hasJoining() && this.joinedAttributeManager.isToManyJoin()) { this.joinedAttributeManager.setDataResults(rows, this.session); } if (this.session.isUnitOfWork()) { result = registerResultInUnitOfWork( rows, (UnitOfWorkImpl) this.session, this.translationRow, true); // } else { result = getContainerPolicy().containerInstance(rows.size()); this.descriptor.getObjectBuilder().buildObjectsInto(this, rows, result); } if (this.shouldIncludeData) { ComplexQueryResult complexResult = new ComplexQueryResult(); complexResult.setResult(result); complexResult.setData(rows); return complexResult; } // Add the other (already registered) results and return them. if (getDescriptor().hasTablePerClassPolicy()) { result = containerPolicy.concatenateContainers( result, getDescriptor() .getTablePerClassPolicy() .selectAllObjectsUsingMultipleTableSubclassRead(this)); } return result; }
/** INTERNAL: Delete the reference objects. */ @Override public void postDelete(DeleteObjectQuery query) throws DatabaseException, OptimisticLockException { if (!isForeignKeyRelationship()) { return; } if (!this.shouldObjectModifyCascadeToParts(query)) { return; } Object referenceObjects = this.getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession()); // if we have a custom delete all query, use it; // otherwise, delete the reference objects one by one if (this.hasCustomDeleteAllQuery()) { this.deleteAll(query, referenceObjects); } else { ContainerPolicy cp = this.getContainerPolicy(); for (Object iter = cp.iteratorFor(referenceObjects); cp.hasNext(iter); ) { DeleteObjectQuery deleteQuery = new DeleteObjectQuery(); deleteQuery.setIsExecutionClone(true); deleteQuery.setObject(cp.next(iter, query.getSession())); deleteQuery.setCascadePolicy(query.getCascadePolicy()); query.getSession().executeQuery(deleteQuery); } if (!query.getSession().isUnitOfWork()) { // This deletes any objects on the database, as the collection in memory may have been // changed. // This is not required for unit of work, as the update would have already deleted these // objects, // and the backup copy will include the same objects, causing double deletes. this.deleteReferenceObjectsLeftOnDatabase(query); } } }
/** INTERNAL: Write the attribute value from the object to the row. */ public void writeFromObjectIntoRow(Object object, AbstractRecord row, AbstractSession session) { // for each xmlField on this mapping for (Iterator fieldIt = getFields().iterator(); fieldIt.hasNext(); ) { XMLField xmlField = (XMLField) fieldIt.next(); ContainerPolicy cp = getContainerPolicy(); Object collection = getAttributeAccessor().getAttributeValueFromObject(object); if (collection == null) { return; } Object fieldValue; Object objectValue; String stringValue = ""; QName schemaType; Object iterator = cp.iteratorFor(collection); if (usesSingleNode()) { while (cp.hasNext(iterator)) { objectValue = cp.next(iterator, session); fieldValue = buildFieldValue(objectValue, xmlField, session); if (fieldValue != null) { schemaType = getSchemaType(xmlField, fieldValue, session); String newValue = getValueToWrite(schemaType, fieldValue, session); if (newValue != null) { stringValue += newValue; if (cp.hasNext(iterator)) { stringValue += SPACE; } } } } if (!(stringValue.equals(""))) { row.put(xmlField, stringValue); } } else { ArrayList keyValues = new ArrayList(); while (cp.hasNext(iterator)) { objectValue = cp.next(iterator, session); fieldValue = buildFieldValue(objectValue, xmlField, session); if (fieldValue != null) { schemaType = getSchemaType(xmlField, fieldValue, session); stringValue = getValueToWrite(schemaType, fieldValue, session); // row.add(xmlField, stringValue); keyValues.add(stringValue); } } row.put(xmlField, keyValues); } } }
/** * INTERNAL: Merge changes from the source to the target object. Simply replace the entire target * collection. */ public void mergeIntoObject( Object target, boolean isTargetUnInitialized, Object source, MergeManager mergeManager) { ContainerPolicy cp = this.getContainerPolicy(); AbstractSession session = mergeManager.getSession(); Object sourceCollection = this.getRealCollectionAttributeValueFromObject(source, session); Object targetCollection = cp.containerInstance(cp.sizeFor(sourceCollection)); for (Object iter = cp.iteratorFor(sourceCollection); cp.hasNext(iter); ) { Object targetElement = this.buildElementFromElement(cp.next(iter, session), mergeManager); cp.addInto(targetElement, targetCollection, session); } // reset the attribute to allow for set method to re-morph changes if the collection is not // being stored directly this.setRealAttributeValueInObject(target, targetCollection); }
/** * INTERNAL: Execute the query. If there are cached results return those. This must override the * super to support result caching. * * @param session - the session in which the receiver will be executed. * @return An object or vector, the result of executing the query. * @exception DatabaseException - an error has occurred on the database */ public Object execute(AbstractSession session, AbstractRecord row) throws DatabaseException { if (shouldCacheQueryResults()) { if (getContainerPolicy().overridesRead()) { throw QueryException.cannotCacheCursorResultsOnQuery(this); } if (shouldConformResultsInUnitOfWork()) { throw QueryException.cannotConformAndCacheQueryResults(this); } if (isPrepared()) { // only prepared queries can have cached results. Object queryResults = getQueryResults(session, row, true); if (queryResults != null) { if (QueryMonitor.shouldMonitor()) { QueryMonitor.incrementReadAllHits(this); } // bug6138532 - check for "cached no results" (InvalidObject singleton) in query // results, and return an empty container instance as configured if (queryResults == InvalidObject.instance) { return getContainerPolicy().containerInstance(0); } Collection results = (Collection) queryResults; if (session.isUnitOfWork()) { ContainerPolicy policy = getContainerPolicy(); Object resultCollection = policy.containerInstance(results.size()); Object iterator = policy.iteratorFor(results); while (policy.hasNext(iterator)) { Object result = ((UnitOfWorkImpl) session) .registerExistingObject(policy.next(iterator, session), this.descriptor); policy.addInto(result, resultCollection, session); } return resultCollection; } return results; } } } if (QueryMonitor.shouldMonitor()) { QueryMonitor.incrementReadAllMisses(this); } return super.execute(session, row); }
/** * INTERNAL: Return the value of the reference attribute or a value holder. Check whether the * mapping's attribute should be optimized through batch and joining. */ public Object valueFromRow( AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, AbstractSession executionSession) throws DatabaseException { if (((EISDescriptor) this.getDescriptor()).getDataFormat() == EISDescriptor.XML) { ((XMLRecord) row).setSession(executionSession); } ReadQuery targetQuery = getSelectionQuery(); if (!isForeignKeyRelationship) { // if the source query is cascading then the target query must use the same settings if (targetQuery.isObjectLevelReadQuery() && (sourceQuery.shouldCascadeAllParts() || (sourceQuery.shouldCascadePrivateParts() && isPrivateOwned()) || (sourceQuery.shouldCascadeByMapping() && this.cascadeRefresh))) { targetQuery = (ObjectLevelReadQuery) targetQuery.clone(); ((ObjectLevelReadQuery) targetQuery) .setShouldRefreshIdentityMapResult(sourceQuery.shouldRefreshIdentityMapResult()); targetQuery.setCascadePolicy(sourceQuery.getCascadePolicy()); // CR #4365 targetQuery.setQueryId(sourceQuery.getQueryId()); // For queries that have turned caching off, such as aggregate collection, leave it off. if (targetQuery.shouldMaintainCache()) { targetQuery.setShouldMaintainCache(sourceQuery.shouldMaintainCache()); } } return getIndirectionPolicy().valueFromQuery(targetQuery, row, sourceQuery.getSession()); } else { if (getIndirectionPolicy().usesIndirection()) { EISOneToManyQueryBasedValueHolder valueholder = new EISOneToManyQueryBasedValueHolder(this, targetQuery, row, sourceQuery.getSession()); return valueholder; } else { Vector subRows = getForeignKeyRows(row); if (subRows == null) { return null; } ContainerPolicy cp = this.getContainerPolicy(); Object results = cp.containerInstance(subRows.size()); for (int i = 0; i < subRows.size(); i++) { XMLRecord subRow = (XMLRecord) subRows.elementAt(i); subRow.setSession(executionSession); Object object = getIndirectionPolicy().valueFromQuery(targetQuery, subRow, sourceQuery.getSession()); if (object instanceof Collection) { java.util.Iterator iter = ((Collection) object).iterator(); while (iter.hasNext()) { cp.addInto(iter.next(), results, executionSession); } } else if (object instanceof java.util.Map) { java.util.Iterator iter = ((java.util.Map) object).values().iterator(); while (iter.hasNext()) { cp.addInto(iter.next(), results, executionSession); } } else { cp.addInto(object, results, executionSession); } } if (cp.sizeFor(results) == 0) { return null; } return results; } } }