/**
* Commit all of the objects of the class type in the change set. This allows for the order of the
* classes to be processed optimally.
*/
protected void commitNewObjectsForClassWithChangeSet(
UnitOfWorkChangeSet uowChangeSet, Class theClass) {
Map<ObjectChangeSet, ObjectChangeSet> newObjectChangesList =
uowChangeSet.getNewObjectChangeSets().get(theClass);
if (newObjectChangesList != null) { // may be no changes for that class type.
AbstractSession session = getSession();
ClassDescriptor descriptor = session.getDescriptor(theClass);
List<ObjectChangeSet> newChangeSets = new ArrayList(newObjectChangesList.values());
int size = newChangeSets.size();
for (int index = 0; index < size; index++) {
ObjectChangeSet changeSetToWrite = newChangeSets.get(index);
Object objectToWrite = changeSetToWrite.getUnitOfWorkClone();
if (!isProcessedCommit(objectToWrite)) {
// PERF: Get the descriptor query, to avoid extra query creation.
InsertObjectQuery commitQuery = descriptor.getQueryManager().getInsertQuery();
if (commitQuery == null) {
commitQuery = new InsertObjectQuery();
commitQuery.setDescriptor(descriptor);
} else {
// Ensure original query has been prepared.
commitQuery.checkPrepare(session, commitQuery.getTranslationRow());
commitQuery = (InsertObjectQuery) commitQuery.clone();
}
commitQuery.setIsExecutionClone(true);
commitQuery.setObjectChangeSet(changeSetToWrite);
commitQuery.setObject(objectToWrite);
commitQuery.cascadeOnlyDependentParts();
commitQuery.setModifyRow(null);
session.executeQuery(commitQuery);
}
uowChangeSet.putNewObjectInChangesList(changeSetToWrite, session);
}
}
}
/** INTERNAL: Build and return a new element based on the change set. */
public Object buildRemovedElementFromChangeSet(Object changeSet, MergeManager mergeManager) {
ObjectChangeSet objectChangeSet = (ObjectChangeSet) changeSet;
if (!mergeManager.shouldMergeChangesIntoDistributedCache()) {
mergeManager.registerRemovedNewObjectIfRequired(objectChangeSet.getUnitOfWorkClone());
}
return this.buildElementFromChangeSet(changeSet, mergeManager);
}
/** INTERNAL: Build and return a new element based on the change set. */
public Object buildAddedElementFromChangeSet(Object changeSet, MergeManager mergeManager) {
ObjectChangeSet objectChangeSet = (ObjectChangeSet) changeSet;
if (this.shouldMergeCascadeParts(mergeManager)) {
Object targetElement = null;
if (mergeManager.shouldMergeChangesIntoDistributedCache()) {
targetElement =
objectChangeSet.getTargetVersionOfSourceObject(mergeManager.getSession(), true);
} else {
targetElement = objectChangeSet.getUnitOfWorkClone();
}
mergeManager.mergeChanges(targetElement, objectChangeSet);
}
return this.buildElementFromChangeSet(changeSet, mergeManager);
}
/** INTERNAL: Get a value from the object and set that in the respective field of the row. */
public void writeFromObjectIntoRowWithChangeRecord(
ChangeRecord changeRecord, AbstractRecord record, AbstractSession session) {
if (isReadOnly()) {
return;
}
ObjectChangeSet changeSet =
(ObjectChangeSet) ((ObjectReferenceChangeRecord) changeRecord).getNewValue();
Object referenceObject = changeSet.getUnitOfWorkClone();
if (referenceObject == null) {
return;
}
Ref ref =
((ObjectRelationalDataTypeDescriptor) getReferenceDescriptor())
.getRef(referenceObject, session);
record.put(getField(), ref);
}
/**
* Commit changed of the objects of the class type in the change set. This allows for the order of
* the classes to be processed optimally.
*/
protected void commitChangedObjectsForClassWithChangeSet(
UnitOfWorkChangeSet uowChangeSet, Class theClass) {
Map<ObjectChangeSet, ObjectChangeSet> objectChangesList =
uowChangeSet.getObjectChanges().get(theClass);
if (objectChangesList != null) { // may be no changes for that class type.
ClassDescriptor descriptor = null;
AbstractSession session = getSession();
Collection<ObjectChangeSet> changes = objectChangesList.values();
if (((UnitOfWorkImpl) session).shouldOrderUpdates()) {
changes = new ArrayList(objectChangesList.values());
Collections.sort((List) changes);
}
for (ObjectChangeSet changeSetToWrite : changes) {
Object objectToWrite = changeSetToWrite.getUnitOfWorkClone();
if (descriptor == null) {
descriptor = session.getDescriptor(objectToWrite);
}
if (!isProcessedCommit(objectToWrite)) {
// Commit and resume on failure can cause a new change set to be in existing, so need to
// check here.
WriteObjectQuery commitQuery = null;
if (changeSetToWrite.isNew()) {
commitQuery = new InsertObjectQuery();
} else {
commitQuery = new UpdateObjectQuery();
}
commitQuery.setIsExecutionClone(true);
commitQuery.setDescriptor(descriptor);
commitQuery.setObjectChangeSet(changeSetToWrite);
commitQuery.setObject(objectToWrite);
commitQuery.cascadeOnlyDependentParts();
// removed checking session type to set cascade level
// will always be a unitOfWork so we need to cascade dependent parts
session.executeQuery(commitQuery);
}
}
}
}
/**
* INTERNAL: Get a value from the object and set that in the respective field of the row. If the
* mapping id target foreign key, you must only write the type into the roe, the rest will be
* updated when the object itself is written
*/
@Override
public void writeFromObjectIntoRowWithChangeRecord(
ChangeRecord changeRecord, AbstractRecord record, AbstractSession session) {
if (isReadOnly()) {
return;
}
ObjectChangeSet changeSet =
(ObjectChangeSet) ((ObjectReferenceChangeRecord) changeRecord).getNewValue();
if (changeSet == null) {
writeFromNullObjectIntoRow(record);
} else {
Object referenceObject = changeSet.getUnitOfWorkClone();
if (isForeignKeyRelationship()) {
Enumeration sourceFields = getForeignKeyFields().elements();
ClassDescriptor descriptor = session.getDescriptor(referenceObject.getClass());
while (sourceFields.hasMoreElements()) {
DatabaseField sourceKey = (DatabaseField) sourceFields.nextElement();
String targetQueryKey = (String) getSourceToTargetQueryKeyNames().get(sourceKey);
DatabaseField targetKeyField =
descriptor.getObjectBuilder().getFieldForQueryKeyName(targetQueryKey);
if (targetKeyField == null) {
throw DescriptorException.variableOneToOneMappingIsNotDefinedProperly(
this, descriptor, targetQueryKey);
}
Object referenceValue =
descriptor
.getObjectBuilder()
.extractValueFromObjectForField(referenceObject, targetKeyField, session);
record.put(sourceKey, referenceValue);
}
}
if (getTypeField() != null) {
record.put(getTypeField(), getTypeForImplementor(referenceObject.getClass()));
}
}
}
/** INTERNAL: Build and return a change set for the specified element. */
public Object buildChangeSet(Object element, ObjectChangeSet owner, AbstractSession session) {
ObjectBuilder objectBuilder = session.getDescriptor(element).getObjectBuilder();
return objectBuilder.createObjectChangeSet(
element, (UnitOfWorkChangeSet) owner.getUOWChangeSet(), session);
}