org.eclipse.persistence.internal.sessions.CommitManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of eclipselink Show documentation
Show all versions of eclipselink Show documentation
EclipseLink build based upon Git transaction f2b9fc5
/*
* Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0,
* or the Eclipse Distribution License v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
// Contributors:
// Oracle - initial API and implementation from Oracle TopLink
// 09/12/2018 - Will Dazey
// - 391279: Add support for Unidirectional OneToMany mappings with non-nullable values
package org.eclipse.persistence.internal.sessions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.Vector;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.exceptions.DatabaseException;
import org.eclipse.persistence.exceptions.OptimisticLockException;
import org.eclipse.persistence.internal.databaseaccess.DatasourceCall;
import org.eclipse.persistence.internal.helper.DatabaseTable;
import org.eclipse.persistence.internal.helper.DescriptorCompare;
import org.eclipse.persistence.internal.helper.Helper;
import org.eclipse.persistence.internal.localization.ToStringLocalization;
import org.eclipse.persistence.internal.queries.DatabaseQueryMechanism;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.queries.DeleteObjectQuery;
import org.eclipse.persistence.queries.InsertObjectQuery;
import org.eclipse.persistence.queries.UpdateObjectQuery;
import org.eclipse.persistence.queries.WriteObjectQuery;
import org.eclipse.persistence.sessions.UnitOfWork.CommitOrderType;
/**
* This class maintains a commit stack and resolves circular references.
*/
public class CommitManager {
/** Order based on mapping foreign key constraints on how to insert objects by class. */
protected List> commitOrder;
/**
* This tracks the commit state for the objects, PENDING, PRE, POST, COMPLETE.
* The key is the object and the value is the state.
*/
protected Map commitState;
/** The commit is in progress, but the row has not been written. */
protected static final Integer PRE = 1;
/** The commit is in progress, and the row has been written. */
protected static final Integer POST = 2;
/** The commit is complete for the object. */
protected static final Integer COMPLETE = 3;
/** This object should be ignored. */
protected static final Integer IGNORE = 4;
/** Set of objects that had partial row written to resolve constraints. */
protected Map shallowCommits;
protected AbstractSession session;
/** The commit manager is active while writing a set of objects (UOW), it is not active when writing a single object (DB session). */
protected boolean isActive;
/** Map of modification events used to defer insertion into m-m, dc, join tables. */
protected Map> dataModifications;
/**
* Map of deferred calls groups by their table.
* This is used to defer multiple table writes for batching and deadlock avoidance.
*/
protected Map> deferredCalls;
/** List of orphaned objects pending deletion. */
protected List objectsToDelete;
/** Counter used to keep track of commit depth for non-UOW writes. */
protected int commitDepth;
/**
* Create the commit manager on the session.
* It must be initialized later on after the descriptors have been added.
*/
public CommitManager(AbstractSession session) {
this.session = session;
}
/**
* Add the data query to be performed at the end of the commit.
* This is done to decrease dependencies and avoid deadlock.
*/
public void addDataModificationEvent(DatabaseMapping mapping, Object[] event) {
if (!getDataModifications().containsKey(mapping)) {
this.dataModifications.put(mapping, new ArrayList());
}
this.dataModifications.get(mapping).add(event);
}
/**
* Add the data query to be performed at the end of the commit.
* This is done to decrease dependencies and avoid deadlock.
*/
public void addDeferredCall(DatabaseTable table, DatasourceCall call, DatabaseQueryMechanism mechanism) {
if (!getDeferredCalls().containsKey(table)) {
this.deferredCalls.put(table, new ArrayList());
}
Object[] arguments = new Object[2];
arguments[0] = call;
arguments[1] = mechanism;
this.deferredCalls.get(table).add(arguments);
}
/**
* Deletion are cached until the end.
*/
public void addObjectToDelete(Object objectToDelete) {
getObjectsToDelete().add(objectToDelete);
}
/**
* Commit all of the objects as a single transaction.
* This should commit the object in the correct order to maintain referential integrity.
*/
public void commitAllObjectsWithChangeSet(UnitOfWorkChangeSet uowChangeSet) throws RuntimeException, DatabaseException, OptimisticLockException {
reinitialize();
this.isActive = true;
this.session.beginTransaction();
try {
// PERF: if the number of classes in the project is large this loop can be a perf issue.
// If only one class types changed, then avoid loop.
if ((uowChangeSet.getObjectChanges().size() + uowChangeSet.getNewObjectChangeSets().size()) <= 1) {
Iterator> classes = uowChangeSet.getNewObjectChangeSets().keySet().iterator();
if (classes.hasNext()) {
Class theClass = classes.next();
commitNewObjectsForClassWithChangeSet(uowChangeSet, theClass);
}
classes = uowChangeSet.getObjectChanges().keySet().iterator();
if (classes.hasNext()) {
Class theClass = classes.next();
commitChangedObjectsForClassWithChangeSet(uowChangeSet, theClass);
}
} else {
// The commit order is all of the classes ordered by dependencies, this is done for deadlock avoidance.
List> commitOrder = getCommitOrder();
int size = commitOrder.size();
for (int index = 0; index < size; index++) {
Class theClass = commitOrder.get(index);
commitAllObjectsForClassWithChangeSet(uowChangeSet, theClass);
}
}
if (hasDeferredCalls()) {
// Perform all batched up calls, done to avoid dependencies.
for (List calls: this.deferredCalls.values()) {
for (Object[] argument : calls) {
((DatabaseQueryMechanism)argument[1]).executeDeferredCall((DatasourceCall)argument[0]);
}
}
}
if (hasDataModifications()) {
// Perform all batched up data modifications, done to avoid dependencies.
for (Map.Entry> entry: this.dataModifications.entrySet()) {
List events = entry.getValue();
int size = events.size();
DatabaseMapping mapping = entry.getKey();
for (int index = 0; index < size; index++) {
Object[] event = events.get(index);
mapping.performDataModificationEvent(event, getSession());
}
}
}
if (hasObjectsToDelete()) {
// These are orphaned objects, to be deleted from private ownership updates.
// TODO: These should be added to the unit of work deleted so they are deleted in the correct order.
List objects = getObjectsToDelete();
int size = objects.size();
reinitialize();
for (int index = 0; index < size; index++) {
this.session.deleteObject(objects.get(index));
}
}
this.session.commitTransaction();
} catch (RuntimeException exception) {
this.session.rollbackTransaction();
throw exception;
} finally {
reinitialize();
this.isActive = false;
}
}
/**
* 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 commitAllObjectsForClassWithChangeSet(UnitOfWorkChangeSet uowChangeSet, Class theClass) {
// Although new objects should be first, there is an issue that new objects get added to non-new after the insert,
// so the object would be written twice.
commitChangedObjectsForClassWithChangeSet(uowChangeSet, theClass);
commitNewObjectsForClassWithChangeSet(uowChangeSet, theClass);
}
/**
* 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 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 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);
}
}
}
/**
* 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 objectChangesList = uowChangeSet.getObjectChanges().get(theClass);
if (objectChangesList != null) {// may be no changes for that class type.
ClassDescriptor descriptor = null;
AbstractSession session = getSession();
Collection changes = objectChangesList.values();
CommitOrderType order = ((UnitOfWorkImpl)session).getCommitOrder();
if (order != CommitOrderType.NONE) {
changes = new ArrayList(objectChangesList.values());
if (order == CommitOrderType.CHANGES) {
Collections.sort((List)changes, new ObjectChangeSet.ObjectChangeSetComparator());
} else {
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);
}
}
}
}
/**
* delete all of the objects as a single transaction.
* This should delete the object in the correct order to maintain referential integrity.
*/
public void deleteAllObjects(List objects) throws RuntimeException, DatabaseException, OptimisticLockException {
this.isActive = true;
AbstractSession session = getSession();
session.beginTransaction();
try {
// PERF: Optimize single object case.
if (objects.size() == 1) {
deleteAllObjects(objects.get(0).getClass(), objects, session);
} else {
List> commitOrder = getCommitOrder();
for (int orderIndex = commitOrder.size() - 1; orderIndex >= 0; orderIndex--) {
Class theClass = commitOrder.get(orderIndex);
deleteAllObjects(theClass, objects, session);
}
}
session.commitTransaction();
} catch (RuntimeException exception) {
try {
session.rollbackTransaction();
} catch (Exception ignore) {
}
throw exception;
} finally {
reinitialize();
this.isActive = false;
}
}
/**
* Delete all of the objects with the matching class.
*/
public void deleteAllObjects(Class theClass, List objects, AbstractSession session) {
ClassDescriptor descriptor = null;
if (((UnitOfWorkImpl)session).getCommitOrder() != CommitOrderType.NONE) {// bug 331064 - Sort the delete order
objects = sort(theClass, objects);
}
int size = objects.size();
for (int index = 0; index < size; index++) {
Object objectToDelete = objects.get(index);
if (objectToDelete.getClass() == theClass) {
if (descriptor == null) {
descriptor = session.getDescriptor(theClass);
}
// PERF: Get the descriptor query, to avoid extra query creation.
DeleteObjectQuery deleteQuery = descriptor.getQueryManager().getDeleteQuery();
if (deleteQuery == null) {
deleteQuery = new DeleteObjectQuery();
deleteQuery.setDescriptor(descriptor);
} else {
// Ensure original query has been prepared.
deleteQuery.checkPrepare(session, deleteQuery.getTranslationRow());
deleteQuery = (DeleteObjectQuery)deleteQuery.clone();
}
deleteQuery.setIsExecutionClone(true);
deleteQuery.setObject(objectToDelete);
session.executeQuery(deleteQuery);
}
}
}
/**
* Sort the objects based on PK.
*/
// bug 331064 - Sort the delete order based on PKs.
private List sort (Class theClass, List objects) {
ClassDescriptor descriptor = session.getDescriptor(theClass);
org.eclipse.persistence.internal.descriptors.ObjectBuilder objectBuilder = descriptor.getObjectBuilder();
int size = objects.size();
TreeMap sortedObjects = new TreeMap();
for (int index = 0; index < size; index++) {
Object objectToDelete = objects.get(index);
if (objectToDelete.getClass() == theClass) {
sortedObjects.put(objectBuilder.extractPrimaryKeyFromObject(objectToDelete, session), objectToDelete);
}
}
return new ArrayList(sortedObjects.values());
}
/**
* Return the order in which objects should be committed to the database.
* This order is based on ownership in the descriptors and is require for referential integrity.
* The commit order is a vector of vectors,
* where the first vector is all root level classes, the second is classes owned by roots and so on.
*/
public List> getCommitOrder() {
if (this.commitOrder == null) {
this.commitOrder = new ArrayList();
}
return this.commitOrder;
}
/**
* Return the map of states of the objects being committed.
* The states are defined as static Integers (PENDING, PRE, POST, COMPLETE).
*/
protected Map getCommitState() {
if (this.commitState == null) {
// 2612538 - the default size of Map (32) is appropriate
this.commitState = new IdentityHashMap();
}
return this.commitState;
}
protected boolean hasDataModifications() {
return ((this.dataModifications != null) && (!this.dataModifications.isEmpty()));
}
/**
* Used to store data queries to be performed at the end of the commit.
* This is done to decrease dependencies and avoid deadlock.
*/
protected Map> getDataModifications() {
if (dataModifications == null) {
dataModifications = new LinkedHashMap();
}
return dataModifications;
}
protected boolean hasDeferredCalls() {
return ((this.deferredCalls != null) && (!this.deferredCalls.isEmpty()));
}
/**
* Used to store calls to be performed at the end of the commit.
* This is done for multiple table descriptors to allow batching and avoid deadlock.
*/
protected Map> getDeferredCalls() {
if (this.deferredCalls == null) {
this.deferredCalls = new LinkedHashMap();
}
return this.deferredCalls;
}
protected boolean hasObjectsToDelete() {
return ((objectsToDelete != null) && (!objectsToDelete.isEmpty()));
}
/**
* Deletion are cached until the end.
*/
public List getObjectsToDelete() {
if (objectsToDelete == null) {
objectsToDelete = new ArrayList();
}
return objectsToDelete;
}
/**
* Return the session that this is managing commits for.
*/
protected AbstractSession getSession() {
return this.session;
}
/**
* Return any objects that have been shallow committed during this commit process.
*/
protected Map getShallowCommits() {
if (this.shallowCommits == null) {
// 2612538 - the default size of Map (32) is appropriate
this.shallowCommits = new IdentityHashMap();
}
return this.shallowCommits;
}
/**
* Reset the commit order from the session's descriptors.
* This uses the constraint dependencies in the descriptor's mappings,
* to decide which descriptors are dependent on which other descriptors.
* Multiple computations of the commit order should produce the same ordering.
* This is done to improve performance on unit of work writes through decreasing the
* stack size, and acts as a deadlock avoidance mechanism.
*/
public void initializeCommitOrder() {
Vector descriptors = Helper.buildVectorFromMapElements(getSession().getDescriptors());
// Must ensure uniqueness, some descriptor my be register twice for interfaces.
descriptors = Helper.addAllUniqueToVector(new Vector<>(descriptors.size()), descriptors);
ClassDescriptor[] descriptorsArray = new ClassDescriptor[descriptors.size()];
for (int index = 0; index < descriptors.size(); index++) {
descriptorsArray[index] = descriptors.elementAt(index);
}
Arrays.sort(descriptorsArray, new DescriptorCompare());
descriptors = new Vector<>(descriptors.size());
for (int index = 0; index < descriptorsArray.length; index++) {
descriptors.addElement(descriptorsArray[index]);
}
CommitOrderCalculator calculator = new CommitOrderCalculator(getSession());
calculator.addNodes(descriptors);
calculator.calculateMappingDependencies();
calculator.orderCommits();
descriptors = calculator.getOrderedDescriptors();
calculator = new CommitOrderCalculator(getSession());
calculator.addNodes(descriptors);
calculator.calculateSpecifiedDependencies();
calculator.orderCommits();
setCommitOrder(calculator.getOrderedClasses());
}
/**
* Return if the commit manager is active.
*/
public boolean isActive() {
return isActive;
}
/**
* Return if the object has been processed.
* This should be called by any query that is writing an object,
* if true the query should not write the object.
*/
public boolean isProcessedCommit(Object object) {
return getCommitState().get(object) != null;
}
/**
* Return if the object has been committed.
* This should be called by any query that is writing an object,
* if true the query should not write the object.
*/
public boolean isCommitCompleted(Object object) {
return getCommitState().get(object) == COMPLETE;
}
/**
* Return if the object has been committed.
* This should be called by any query that is writing an object,
* if true the query should not write the object.
*/
public boolean isCommitCompletedInPostOrIgnore(Object object) {
Integer state = getCommitState().get(object);
return (state == COMPLETE) || (state == POST) || (state == IGNORE);
}
/**
* Return if the object is being in progress of being post modify commit.
* This should be called by any query that is writing an object.
*/
public boolean isCommitInPostModify(Object object) {
return getCommitState().get(object) == POST;
}
/**
* Return if the object is being in progress of being pre modify commit.
* This should be called by any query that is writing an object,
* if true the query must force a shallow insert of the object if it is new.
*/
public boolean isCommitInPreModify(Object objectOrChangeSet) {
return getCommitState().get(objectOrChangeSet) == PRE;
}
/**
* Return if the object is shallow committed.
* This is required to resolve bidirectional references.
*/
public boolean isShallowCommitted(Object object) {
if (this.shallowCommits == null) {
return false;
}
return this.shallowCommits.containsKey(object);
}
/**
* Mark the commit of the object as being fully completed.
* This should be called by any query that has finished writing an object.
*/
public void markCommitCompleted(Object object) {
this.commitDepth --;
getCommitState().put(object, COMPLETE);
// If not in a unit of work commit and the commit of this object is done reset the commit manager.
if ((!this.isActive) && (this.commitDepth == 0)) {
reinitialize();
return;
}
}
public void markIgnoreCommit(Object object){
getCommitState().put(object, IGNORE);
}
/**
* Add an object as being in progress of being committed.
* This should be called by any query that is writing an object.
*/
public void markPostModifyCommitInProgress(Object object) {
getCommitState().put(object, POST);
}
/**
* Add an object as being in progress of being committed.
* This should be called by any query that is writing an object.
*/
public void markPreModifyCommitInProgress(Object object) {
this.commitDepth ++;
getCommitState().put(object, PRE);
}
/**
* Mark the object as shallow committed.
* This is required to resolve bidirectional references.
*/
public void markShallowCommit(Object object) {
getShallowCommits().put(object, object); // Use as set.
}
/**
* Reset the commits.
* This must be done before a new commit process is begun.
*/
public void reinitialize() {
this.commitState = null;
this.commitDepth = 0;
this.shallowCommits = null;
this.objectsToDelete = null;
this.dataModifications = null;
this.deferredCalls = null;
}
/**
* Set the order in which objects should be committed to the database.
* This order is based on ownership in the descriptors and is require for referential integrity.
* The commit order is a vector of vectors,
* where the first vector is all root level classes, the second is classes owned by roots and so on.
*/
public void setCommitOrder(List commitOrder) {
this.commitOrder = commitOrder;
}
/**
* Used to store data queries to be performed at the end of the commit.
* This is done to decrease dependencies and avoid deadlock.
*/
protected void setDataModifications(Map> dataModifications) {
this.dataModifications = dataModifications;
}
/**
* Set if the commit manager is active.
*/
public void setIsActive(boolean isActive) {
this.isActive = isActive;
}
/**
* Deletion are cached until the end.
*/
protected void setObjectsToDelete(List objectsToDelete) {
this.objectsToDelete = objectsToDelete;
}
/**
* Set the session that this is managing commits for.
*/
protected void setSession(AbstractSession session) {
this.session = session;
}
/**
* Set any objects that have been shallow committed during this commit process.
*/
protected void setShallowCommits(Map shallowCommits) {
this.shallowCommits = shallowCommits;
}
/**
* Print the in progress depth.
*/
@Override
public String toString() {
Object[] args = {this.commitDepth};
return Helper.getShortClassName(getClass()) + ToStringLocalization.buildMessage("commit_depth", args);
}
}