/** * INTERNAL: * Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet */ @Override public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) { // if the object is not instantiated, do not instantiate or cascade Object attributeValue = getAttributeValueFromObject(object); if (attributeValue != null && getIndirectionPolicy().objectIsInstantiated(attributeValue)) { Object cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow); ContainerPolicy cp = getContainerPolicy(); for (Object cloneIter = cp.iteratorFor(cloneObjectCollection); cp.hasNext(cloneIter);) { Object referencedObject = cp.next(cloneIter, uow); if (referencedObject != null && !visitedObjects.containsKey(referencedObject)) { visitedObjects.put(referencedObject, referencedObject); ObjectBuilder builder = getReferenceDescriptor(referencedObject.getClass(), uow).getObjectBuilder(); builder.cascadePerformRemovePrivateOwnedObjectFromChangeSet(referencedObject, uow, visitedObjects); } } } }
/** * INTERNAL: * Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet */ @Override public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) { // if the object is not instantiated, do not instantiate or cascade Object attributeValue = getAttributeValueFromObject(object); if (attributeValue != null && getIndirectionPolicy().objectIsInstantiated(attributeValue)) { Object cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow); ContainerPolicy cp = getContainerPolicy(); for (Object cloneIter = cp.iteratorFor(cloneObjectCollection); cp.hasNext(cloneIter);) { Object referencedObject = cp.next(cloneIter, uow); if (referencedObject != null && !visitedObjects.containsKey(referencedObject)) { visitedObjects.put(referencedObject, referencedObject); ObjectBuilder builder = getReferenceDescriptor(referencedObject.getClass(), uow).getObjectBuilder(); builder.cascadePerformRemovePrivateOwnedObjectFromChangeSet(referencedObject, uow, visitedObjects); } } } }
/** * INTERNAL: * Cascade perform removal of orphaned private owned objects from the UnitOfWorkChangeSet */ public void cascadePerformRemovePrivateOwnedObjectFromChangeSetIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects) { // if the object is not instantiated, do not instantiate or cascade Object attributeValue = getAttributeValueFromObject(object); if (attributeValue != null && getIndirectionPolicy().objectIsInstantiated(attributeValue)) { Object cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow); ContainerPolicy cp = getContainerPolicy(); for (Object cloneIter = cp.iteratorFor(cloneObjectCollection); cp.hasNext(cloneIter);) { Object referencedObject = cp.next(cloneIter, uow); if (referencedObject != null && !visitedObjects.containsKey(referencedObject)) { visitedObjects.put(referencedObject, referencedObject); ObjectBuilder builder = getReferenceDescriptor(referencedObject.getClass(), uow).getObjectBuilder(); builder.cascadePerformRemovePrivateOwnedObjectFromChangeSet(referencedObject, uow, visitedObjects); } } } }
/** * Verifying deletes make sure that all the records privately owned by this mapping are * actually removed. If such records are found than those are all read and removed one * by one taking their privately owned parts into account. */ protected void verifyDeleteForUpdate(DeleteObjectQuery query) throws DatabaseException, OptimisticLockException { Object objects = readPrivateOwnedForObject(query); // Delete all these object one by one. ContainerPolicy cp = getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter);) { query.getSession().deleteObject(cp.next(iter, query.getSession())); } }
/** * Verifying deletes make sure that all the records privately owned by this mapping are * actually removed. If such records are found than those are all read and removed one * by one taking their privately owned parts into account. */ protected void verifyDeleteForUpdate(DeleteObjectQuery query) throws DatabaseException, OptimisticLockException { Object objects = readPrivateOwnedForObject(query); // Delete all these object one by one. ContainerPolicy cp = getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter);) { query.getSession().deleteObject(cp.next(iter, query.getSession())); } }
/** * INTERNAL: * Checks if object is deleted from the database or not. */ @Override public boolean verifyDelete(Object object, AbstractSession session) throws DatabaseException { // Row is built for translation if (isReadOnly()) { return true; } AbstractRecord row = getDescriptor().getObjectBuilder().buildRowForTranslation(object, session); Object value = session.executeQuery(getSelectionQuery(), row); return getContainerPolicy().isEmpty(value); }
/** * Add the foreign key to the aggregate collection mapping target table. * Also add listOrderField if specified. */ private void createAggregateTargetTable(AggregateCollectionMapping mapping) { TableDefinition targTblDef = getTableDefFromDBTable(mapping.getReferenceDescriptor().getDefaultTable()); addFieldsForMappedKeyMapContainerPolicy(mapping.getContainerPolicy(), targTblDef); Iterator aggregateFieldIterator = mapping.getReferenceDescriptor().getFields().iterator(); while (aggregateFieldIterator.hasNext()) { DatabaseField dbField = (DatabaseField) aggregateFieldIterator.next(); //add the target foreign key field definition to the table definition targTblDef.addField(getFieldDefFromDBField(dbField, false)); } //unlike normal one-to-many mapping, aggregate collection mapping does not have 1:1 back reference //mapping, so the target foreign key fields are not stored in the target descriptor. Iterator targFKIter = mapping.getTargetForeignKeyFields().iterator(); while (targFKIter.hasNext()) { DatabaseField dbField = (DatabaseField) targFKIter.next(); //add the target foreign key field definition to the table definition targTblDef.addField(getFieldDefFromDBField(dbField, false)); } if(mapping.getListOrderField() != null) { getTableDefFromDBTable(mapping.getListOrderField().getTable()).addField(getFieldDefFromDBField(mapping.getListOrderField(), false)); } }
/** * Verifying deletes make sure that all the records privately owned by this mapping are * actually removed. If such records are found than those are all read and removed one * by one taking their privately owned parts into account. */ protected void verifyDeleteForUpdate(DeleteObjectQuery query) throws DatabaseException, OptimisticLockException { Object objects = readPrivateOwnedForObject(query); // Delete all these object one by one. ContainerPolicy cp = getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter);) { query.getSession().deleteObject(cp.next(iter, query.getSession())); } }
/** * INTERNAL: * Checks if object is deleted from the database or not. */ public boolean verifyDelete(Object object, AbstractSession session) throws DatabaseException { // Row is built for translation if (isReadOnly()) { return true; } AbstractRecord row = getDescriptor().getObjectBuilder().buildRowForTranslation(object, session); Object value = session.executeQuery(getSelectionQuery(), row); return getContainerPolicy().isEmpty(value); }
/** * To delete all the entries matching the selection criteria from the table stored in the * referenced descriptor */ protected void deleteAll(DeleteObjectQuery query, Object elements) throws DatabaseException { // Ensure that the query is prepare before cloning. ((DeleteAllQuery)getDeleteAllQuery()).executeDeleteAll(query.getSession().getSessionForClass(getReferenceClass()), query.getTranslationRow(), getContainerPolicy().vectorFor(elements, query.getSession())); }
/** * INTERNAL: * Cascade registerNew for Create through mappings that require the cascade */ public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects){ //aggregate objects are not registered but their mappings should be. Object cloneAttribute = null; cloneAttribute = getAttributeValueFromObject(object); if ((cloneAttribute == null) || (!getIndirectionPolicy().objectIsInstantiated(cloneAttribute))) { return; } ObjectBuilder builder = null; ContainerPolicy cp = getContainerPolicy(); Object cloneObjectCollection = null; cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow); Object cloneIter = cp.iteratorFor(cloneObjectCollection); while (cp.hasNext(cloneIter)) { Object wrappedObject = cp.nextEntry(cloneIter, uow); Object nextObject = cp.unwrapIteratorResult(wrappedObject); if (nextObject != null && (! visitedObjects.containsKey(nextObject))){ visitedObjects.put(nextObject, nextObject); builder = getReferenceDescriptor(nextObject.getClass(), uow).getObjectBuilder(); builder.cascadeRegisterNewForCreate(nextObject, uow, visitedObjects); cp.cascadeRegisterNewIfRequired(wrappedObject, uow, visitedObjects); } } }
/** * INTERNAL: * Checks if object is deleted from the database or not. */ @Override public boolean verifyDelete(Object object, AbstractSession session) throws DatabaseException { // Row is built for translation if (isReadOnly()) { return true; } AbstractRecord row = getDescriptor().getObjectBuilder().buildRowForTranslation(object, session); Object value = session.executeQuery(getSelectionQuery(), row); return getContainerPolicy().isEmpty(value); }
/** * INTERNAL: * Returns clone of InsertObjectQuery from the reference descriptor, if it is not set - create it. */ protected InsertObjectQuery getInsertObjectQuery(AbstractSession session, ClassDescriptor desc) { InsertObjectQuery insertQuery = desc.getQueryManager().getInsertQuery(); if (insertQuery == null) { insertQuery = new InsertObjectQuery(); desc.getQueryManager().setInsertQuery(insertQuery); } if (insertQuery.getModifyRow() == null) { AbstractRecord modifyRow = new DatabaseRecord(); for (int i = 0; i < getTargetForeignKeyFields().size(); i++) { DatabaseField field = getTargetForeignKeyFields().elementAt(i); modifyRow.put(field, null); } desc.getObjectBuilder().buildTemplateInsertRow(session, modifyRow); getContainerPolicy().addFieldsForMapKey(modifyRow); if(this.listOrderField != null) { modifyRow.put(this.listOrderField, null); } insertQuery.setModifyRow(modifyRow); } return insertQuery; }
/** * INTERNAL: * Cascade discover and persist new objects during commit. */ @Override public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, Set cascadeErrors) { //aggregate objects are not registered but their mappings should be. Object cloneAttribute = null; cloneAttribute = getAttributeValueFromObject(object); if ((cloneAttribute == null) || (!getIndirectionPolicy().objectIsInstantiated(cloneAttribute))) { return; } ObjectBuilder builder = null; ContainerPolicy cp = getContainerPolicy(); Object cloneObjectCollection = null; cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow); Object cloneIter = cp.iteratorFor(cloneObjectCollection); while (cp.hasNext(cloneIter)) { Object wrappedObject = cp.nextEntry(cloneIter, uow); Object nextObject = cp.unwrapIteratorResult(wrappedObject); if (nextObject != null) { builder = getReferenceDescriptor(nextObject.getClass(), uow).getObjectBuilder(); builder.cascadeDiscoverAndPersistUnregisteredNewObjects(nextObject, newObjects, unregisteredExistingObjects, visitedObjects, uow, cascadeErrors); cp.cascadeDiscoverAndPersistUnregisteredNewObjects(wrappedObject, newObjects, unregisteredExistingObjects, visitedObjects, uow, cascadeErrors); } } }
/** * INTERNAL: * Cascade discover and persist new objects during commit. */ @Override public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, Set cascadeErrors) { //aggregate objects are not registered but their mappings should be. Object cloneAttribute = null; cloneAttribute = getAttributeValueFromObject(object); if ((cloneAttribute == null) || (!getIndirectionPolicy().objectIsInstantiated(cloneAttribute))) { return; } ObjectBuilder builder = null; ContainerPolicy cp = getContainerPolicy(); Object cloneObjectCollection = null; cloneObjectCollection = getRealCollectionAttributeValueFromObject(object, uow); Object cloneIter = cp.iteratorFor(cloneObjectCollection); while (cp.hasNext(cloneIter)) { Object wrappedObject = cp.nextEntry(cloneIter, uow); Object nextObject = cp.unwrapIteratorResult(wrappedObject); if (nextObject != null) { builder = getReferenceDescriptor(nextObject.getClass(), uow).getObjectBuilder(); builder.cascadeDiscoverAndPersistUnregisteredNewObjects(nextObject, newObjects, unregisteredExistingObjects, visitedObjects, uow, cascadeErrors); cp.cascadeDiscoverAndPersistUnregisteredNewObjects(wrappedObject, newObjects, unregisteredExistingObjects, visitedObjects, uow, cascadeErrors); } } }
/** * INTERNAL: * Update the privately owned parts */ public void postUpdate(WriteObjectQuery writeQuery) throws DatabaseException, OptimisticLockException { if (isReadOnly()) { return; } // If objects are not instantiated that means they are not changed. if (!isAttributeValueInstantiatedOrChanged(writeQuery.getObject())) { return; } // Manage objects added and removed from the collection. Object objects = getRealCollectionAttributeValueFromObject(writeQuery.getObject(), writeQuery.getSession()); Object currentObjectsInDB = readPrivateOwnedForObject(writeQuery); if (currentObjectsInDB == null) { currentObjectsInDB = getContainerPolicy().containerInstance(1); } compareObjectsAndWrite(currentObjectsInDB, objects, writeQuery); }
/** * INTERNAL: * Used during building the backup shallow copy to copy the vector without re-registering the target objects. */ public Object buildBackupCloneForPartObject(Object attributeValue, Object clone, Object backup, UnitOfWorkImpl unitOfWork) { ContainerPolicy containerPolicy = getContainerPolicy(); if (attributeValue == null) { return containerPolicy.containerInstance(1); } Object clonedAttributeValue = containerPolicy.containerInstance(containerPolicy.sizeFor(attributeValue)); synchronized (attributeValue) { for (Object valuesIterator = containerPolicy.iteratorFor(attributeValue); containerPolicy.hasNext(valuesIterator);) { Object wrappedElement = containerPolicy.nextEntry(valuesIterator, unitOfWork); Object cloneValue = buildElementBackupClone(containerPolicy.unwrapIteratorResult(wrappedElement), unitOfWork); containerPolicy.addInto(containerPolicy.keyFromIterator(valuesIterator), cloneValue, clonedAttributeValue, unitOfWork); } } return clonedAttributeValue; }
/** * INTERNAL: * The message is passed to its reference class descriptor. */ @Override public void preInsert(WriteObjectQuery query) throws DatabaseException, OptimisticLockException { if (isReadOnly()) { return; } Object objects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession()); int index = 0; // pre-insert each object one by one ContainerPolicy cp = getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter);) { Object wrappedObject = cp.nextEntry(iter, query.getSession()); Object object = cp.unwrapIteratorResult(wrappedObject); InsertObjectQuery insertQuery = getAndPrepareModifyQueryForInsert(query, object); ContainerPolicy.copyMapDataToRow(cp.getKeyMappingDataForWriteQuery(wrappedObject, query.getSession()), insertQuery.getModifyRow()); if(this.listOrderField != null) { insertQuery.getModifyRow().add(this.listOrderField, index++); } // aggregates do not actually use a query to write to the database so the pre-write must be called here executeEvent(DescriptorEventManager.PreWriteEvent, insertQuery); executeEvent(DescriptorEventManager.PreInsertEvent, insertQuery); getReferenceDescriptor(object.getClass(), query.getSession()).getQueryManager().preInsert(insertQuery); cp.propogatePreInsert(query, wrappedObject); } }
/** * INTERNAL: * Insert privately owned parts */ @Override public void postInsert(WriteObjectQuery query) throws DatabaseException, OptimisticLockException { if (isReadOnly()) { return; } Object objects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession()); int index = 0; // insert each object one by one ContainerPolicy cp = getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter);) { Object wrappedObject = cp.nextEntry(iter, query.getSession()); Object object = cp.unwrapIteratorResult(wrappedObject); InsertObjectQuery insertQuery = getAndPrepareModifyQueryForInsert(query, object); ContainerPolicy.copyMapDataToRow(cp.getKeyMappingDataForWriteQuery(wrappedObject, query.getSession()), insertQuery.getModifyRow()); if(this.listOrderField != null) { insertQuery.getModifyRow().add(this.listOrderField, index++); } query.getSession().executeQuery(insertQuery, insertQuery.getTranslationRow()); cp.propogatePostInsert(query, wrappedObject); } }
/** * INTERNAL: * Insert privately owned parts */ public void postInsert(WriteObjectQuery query) throws DatabaseException, OptimisticLockException { if (isReadOnly()) { return; } Object objects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession()); int index = 0; // insert each object one by one ContainerPolicy cp = getContainerPolicy(); for (Object iter = cp.iteratorFor(objects); cp.hasNext(iter);) { Object wrappedObject = cp.nextEntry(iter, query.getSession()); Object object = cp.unwrapIteratorResult(wrappedObject); InsertObjectQuery insertQuery = getAndPrepareModifyQueryForInsert(query, object); ContainerPolicy.copyMapDataToRow(cp.getKeyMappingDataForWriteQuery(wrappedObject, query.getSession()), insertQuery.getModifyRow()); if(this.listOrderField != null) { insertQuery.getModifyRow().add(this.listOrderField, index++); } query.getSession().executeQuery(insertQuery, insertQuery.getTranslationRow()); cp.propogatePostInsert(query, wrappedObject); } }