foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/databaseaccess/ParameterizedSQLBatchWritingMechanism.java - eclipselink - Git at Google

 /*
  * 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
 package org.eclipse.persistence.internal.databaseaccess;

 import java.io.StringWriter;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.persistence.descriptors.DescriptorQueryManager;
 import org.eclipse.persistence.exceptions.DatabaseException;
 import org.eclipse.persistence.exceptions.OptimisticLockException;
 import org.eclipse.persistence.internal.sessions.AbstractSession;
 import org.eclipse.persistence.logging.SessionLog;
 import org.eclipse.persistence.queries.ModifyQuery;
 import org.eclipse.persistence.sessions.SessionProfiler;

 /**
  * INTERNAL:
  * <p>ParameterizedSQLBatchWritingMechanism is a private class, used by the DatabaseAccessor. it provides the required
  * behavior for batching statements, for write, with parameter binding turned on.</p>
  *
  * @since OracleAS TopLink 10<i>g</i> (9.0.4)
  */
 public class ParameterizedSQLBatchWritingMechanism extends BatchWritingMechanism {

     /**
      * This member variable is used to keep track of the last SQL string that was executed
      * by this mechanism.  If the current string and previous string match then simply
      * bind in the arguments, otherwise end previous batch and start a new batch
      */
     protected DatabaseCall previousCall;

     /**
      * This variable contains a list of the parameters list passed into the query
      */
     protected List<List> parameters;
     protected DatabaseCall lastCallAppended;

     public ParameterizedSQLBatchWritingMechanism() {
         super();
     }

     public ParameterizedSQLBatchWritingMechanism(DatabaseAccessor databaseAccessor) {
         this.databaseAccessor = databaseAccessor;
         this.parameters = new ArrayList<>();
         this.maxBatchSize = this.databaseAccessor.getLogin().getPlatform().getMaxBatchWritingSize();
         if (this.maxBatchSize == 0) {
             // the max size was not set on the platform - use default
             this.maxBatchSize = DatabasePlatform.DEFAULT_PARAMETERIZED_MAX_BATCH_WRITING_SIZE;
         }
     }

     /**
      * INTERNAL:
      * This method is called by the DatabaseAccessor to add this statement to the list of statements
      * being batched.  This call may result in the Mechanism executing the batched statements and
      * possibly, switching out the mechanisms
      */
     @Override
     public void appendCall(AbstractSession session, DatabaseCall dbCall) {
         if (dbCall.hasParameters()) {
             //make an equality check on the String, because if we are caching statements then
             //we will not have to perform the string comparison multiple times.
             if (this.previousCall == null) {
                 this.previousCall = dbCall;
                 this.parameters.add(dbCall.getParameters());
             } else {
                 if (this.previousCall.getSQLString().equals(dbCall.getSQLString()) && (this.parameters.size() < this.maxBatchSize)) {
                     this.parameters.add(dbCall.getParameters());
                 } else {
                     executeBatchedStatements(session);
                     this.previousCall = dbCall;
                     this.parameters.add(dbCall.getParameters());
                 }
             }
             // Store the largest queryTimeout on a single call for later use by the single statement in prepareBatchStatements
             if (dbCall != null) {
                 cacheQueryTimeout(session, dbCall);
             }
             this.lastCallAppended = dbCall;
             // feature for bug 4104613, allows users to force statements to flush on execution
             if (((ModifyQuery) dbCall.getQuery()).forceBatchStatementExecution())
             {
               executeBatchedStatements(session);
             }
         } else {
             executeBatchedStatements(session);
             switchMechanisms(session, dbCall);
         }
     }

     /**
      * INTERNAL:
      * This method is used to clear the batched statements without the need to execute the statements first
      * This is used in the case of rollback.
      */
     @Override
     public void clear() {
         this.previousCall = null;
         //Bug#419326 : A clone may be holding a reference to this.parameters.
         //So, instead of clearing the parameters, just initialize with a new reference.
         this.parameters = new ArrayList<>();
         this.statementCount = 0;
         this.executionCount  = 0;
         this.queryTimeoutCache = DescriptorQueryManager.NoTimeout;
         // bug 229831 : BATCH WRITING CAUSES MEMORY LEAKS WITH UOW
         this.lastCallAppended = null;
     }

     /**
      * INTERNAL:
      * This method is used by the DatabaseAccessor to clear the batched statements in the
      * case that a non batchable statement is being executed
      */
     @Override
     public void executeBatchedStatements(AbstractSession session) {
         if (this.parameters.isEmpty()) {
             return;
         }
         //Bug#419326 : Added below clone, clear and clone.executeBatch(session)
         //Cloning the mechanism and clearing the current mechanism ensures that the current batch
         //is not visible to recursive calls to executeBatchedStatements(session).
         ParameterizedSQLBatchWritingMechanism currentBatch = (ParameterizedSQLBatchWritingMechanism) this.clone();
         this.clear();
         currentBatch.executeBatch(session);
     }

     /**
      * INTERNAL:
      * This method is added to execute and clear the batched statements on the cloned batch mechanism which
      * is created in executeBatchedStatements(session).
      *
      * Introduced in fix for bug#419326.
      */
     private void executeBatch(AbstractSession session) {

         if (this.parameters.size() == 1) {
             // If only one call, just execute normally.
             try {
                 int rowCount = (Integer)this.databaseAccessor.basicExecuteCall(this.previousCall, null, session, false);
                 if (this.previousCall.hasOptimisticLock()) {
                     if (rowCount != 1) {
                         throw OptimisticLockException.batchStatementExecutionFailure();
                     }
                 }
             } finally {
                 clear();
             }
             return;
         }

         try {
             this.databaseAccessor.incrementCallCount(session);// Decrement occurs in close.

             if (session.shouldLog(SessionLog.FINE, SessionLog.SQL)) {
                 session.log(SessionLog.FINER, SessionLog.SQL, "begin_batch_statements", null, this.databaseAccessor);
                 session.log(SessionLog.FINE, SessionLog.SQL, this.previousCall.getSQLString(), null, this.databaseAccessor, false);
                 // took this logging part from SQLCall
                 for (List callParameters : this.parameters) {
                     StringWriter writer = new StringWriter();
                     DatabaseCall.appendLogParameters(callParameters, this.databaseAccessor, writer, session);
                     session.log(SessionLog.FINE, SessionLog.SQL, writer.toString(), null, this.databaseAccessor, false);
                 }
                 session.log(SessionLog.FINER, SessionLog.SQL, "end_batch_statements", null, this.databaseAccessor);
             }

             //bug 4241441: need to keep track of rows modified and throw opti lock exception if needed
             PreparedStatement statement = prepareBatchStatements(session);
             // += is used as native batch writing can return a row count before execution.
             this.executionCount += this.databaseAccessor.executeJDK12BatchStatement(statement, this.lastCallAppended, session, true);
             this.databaseAccessor.writeStatementsCount++;

             if (this.previousCall.hasOptimisticLock() && (this.executionCount != this.statementCount)) {
                 throw OptimisticLockException.batchStatementExecutionFailure();
             }
         } finally {
             // Reset the batched sql string
             //we MUST clear the mechanism here in order to append the new statement.
             this.clear();
         }
     }

     /**
      * INTERNAL:
      * Swaps out the Mechanism for the other Mechanism
      */
     protected void switchMechanisms(AbstractSession session, DatabaseCall dbCall) {
         this.databaseAccessor.setActiveBatchWritingMechanismToDynamicSQL();
         this.databaseAccessor.getActiveBatchWritingMechanism(session).appendCall(session, dbCall);
     }

     /**
      * INTERNAL:
      * This method is used to build the parameterized batch statement for the JDBC2.0 specification
      */
     protected PreparedStatement prepareBatchStatements(AbstractSession session) throws DatabaseException {
         PreparedStatement statement = null;
         try {
             session.startOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
             try {
                 DatabasePlatform platform = session.getPlatform();
                 boolean shouldUnwrapConnection = platform.usesNativeBatchWriting();
                 statement = (PreparedStatement)this.databaseAccessor.prepareStatement(this.previousCall, session, shouldUnwrapConnection);
                 // Perform platform specific preparations
                 platform.prepareBatchStatement(statement, this.maxBatchSize);
                    if (this.queryTimeoutCache > DescriptorQueryManager.NoTimeout) {
                     // Set the query timeout that was cached during the multiple calls to appendCall
                        statement.setQueryTimeout(this.queryTimeoutCache);
                 }

                 // Iterate over the parameter lists that were batched.
                 int statementSize = this.parameters.size();
                 for (int statementIndex = 0; statementIndex < statementSize; ++statementIndex) {
                     List parameterList = this.parameters.get(statementIndex);
                     int size = parameterList.size();
                     for (int index = 0; index < size; index++) {
                         platform.setParameterValueInDatabaseCall(parameterList.get(index), statement, index+1, session);
                     }

                     // Batch the parameters to the statement.
                     this.statementCount++;
                     this.executionCount += platform.addBatch(statement);
                 }
             } finally {
                 session.endOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
             }
         } catch (SQLException exception) {
             // If this is a connection from an external pool then closeStatement will close the connection.
             // we must test the connection before that happens.
             RuntimeException exceptionToThrow = this.databaseAccessor.processExceptionForCommError(session, exception, lastCallAppended);
             try {
                 // Ensure that the statement is closed, but still ensure that the real exception is thrown.
                 this.databaseAccessor.closeStatement(statement, session, null);
             } catch (SQLException closeException) {
             }
             if (exceptionToThrow == null){
                 throw DatabaseException.sqlException(exception, this.databaseAccessor, session, false);
             }
             throw exceptionToThrow;
         } catch (RuntimeException exception) {
             try {
                 // Ensure that the statement is closed, but still ensure that the real exception is thrown.
                 this.databaseAccessor.closeStatement(statement, session, null);
             } catch (SQLException closeException) {
             }
             throw exception;
         }
         return statement;
     }

     public DatabaseCall getPreviousCall() {
         return previousCall;
     }

     public void setPreviousCall(DatabaseCall previousCall) {
         this.previousCall = previousCall;
     }

     public List<List> getParameters() {
         return parameters;
     }

     public void setParameters(List<List> parameters) {
         this.parameters = parameters;
     }

     public DatabaseCall getLastCallAppended() {
         return lastCallAppended;
     }

     public void setLastCallAppended(DatabaseCall lastCallAppended) {
         this.lastCallAppended = lastCallAppended;
     }
 }
	/*
	* 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
	package org.eclipse.persistence.internal.databaseaccess;

	import java.io.StringWriter;
	import java.sql.PreparedStatement;
	import java.sql.SQLException;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.persistence.descriptors.DescriptorQueryManager;
	import org.eclipse.persistence.exceptions.DatabaseException;
	import org.eclipse.persistence.exceptions.OptimisticLockException;
	import org.eclipse.persistence.internal.sessions.AbstractSession;
	import org.eclipse.persistence.logging.SessionLog;
	import org.eclipse.persistence.queries.ModifyQuery;
	import org.eclipse.persistence.sessions.SessionProfiler;

	/**
	* INTERNAL:
	* <p>ParameterizedSQLBatchWritingMechanism is a private class, used by the DatabaseAccessor. it provides the required
	* behavior for batching statements, for write, with parameter binding turned on.</p>
	*
	* @since OracleAS TopLink 10<i>g</i> (9.0.4)
	*/
	public class ParameterizedSQLBatchWritingMechanism extends BatchWritingMechanism {

	/**
	* This member variable is used to keep track of the last SQL string that was executed
	* by this mechanism. If the current string and previous string match then simply
	* bind in the arguments, otherwise end previous batch and start a new batch
	*/
	protected DatabaseCall previousCall;

	/**
	* This variable contains a list of the parameters list passed into the query
	*/
	protected List<List> parameters;
	protected DatabaseCall lastCallAppended;

	public ParameterizedSQLBatchWritingMechanism() {
	super();
	}

	public ParameterizedSQLBatchWritingMechanism(DatabaseAccessor databaseAccessor) {
	this.databaseAccessor = databaseAccessor;
	this.parameters = new ArrayList<>();
	this.maxBatchSize = this.databaseAccessor.getLogin().getPlatform().getMaxBatchWritingSize();
	if (this.maxBatchSize == 0) {
	// the max size was not set on the platform - use default
	this.maxBatchSize = DatabasePlatform.DEFAULT_PARAMETERIZED_MAX_BATCH_WRITING_SIZE;
	}
	}

	/**
	* INTERNAL:
	* This method is called by the DatabaseAccessor to add this statement to the list of statements
	* being batched. This call may result in the Mechanism executing the batched statements and
	* possibly, switching out the mechanisms
	*/
	@Override
	public void appendCall(AbstractSession session, DatabaseCall dbCall) {
	if (dbCall.hasParameters()) {
	//make an equality check on the String, because if we are caching statements then
	//we will not have to perform the string comparison multiple times.
	if (this.previousCall == null) {
	this.previousCall = dbCall;
	this.parameters.add(dbCall.getParameters());
	} else {
	if (this.previousCall.getSQLString().equals(dbCall.getSQLString()) && (this.parameters.size() < this.maxBatchSize)) {
	this.parameters.add(dbCall.getParameters());
	} else {
	executeBatchedStatements(session);
	this.previousCall = dbCall;
	this.parameters.add(dbCall.getParameters());
	}
	}
	// Store the largest queryTimeout on a single call for later use by the single statement in prepareBatchStatements
	if (dbCall != null) {
	cacheQueryTimeout(session, dbCall);
	}
	this.lastCallAppended = dbCall;
	// feature for bug 4104613, allows users to force statements to flush on execution
	if (((ModifyQuery) dbCall.getQuery()).forceBatchStatementExecution())
	{
	executeBatchedStatements(session);
	}
	} else {
	executeBatchedStatements(session);
	switchMechanisms(session, dbCall);
	}
	}

	/**
	* INTERNAL:
	* This method is used to clear the batched statements without the need to execute the statements first
	* This is used in the case of rollback.
	*/
	@Override
	public void clear() {
	this.previousCall = null;
	//Bug#419326 : A clone may be holding a reference to this.parameters.
	//So, instead of clearing the parameters, just initialize with a new reference.
	this.parameters = new ArrayList<>();
	this.statementCount = 0;
	this.executionCount = 0;
	this.queryTimeoutCache = DescriptorQueryManager.NoTimeout;
	// bug 229831 : BATCH WRITING CAUSES MEMORY LEAKS WITH UOW
	this.lastCallAppended = null;
	}

	/**
	* INTERNAL:
	* This method is used by the DatabaseAccessor to clear the batched statements in the
	* case that a non batchable statement is being executed
	*/
	@Override
	public void executeBatchedStatements(AbstractSession session) {
	if (this.parameters.isEmpty()) {
	return;
	}
	//Bug#419326 : Added below clone, clear and clone.executeBatch(session)
	//Cloning the mechanism and clearing the current mechanism ensures that the current batch
	//is not visible to recursive calls to executeBatchedStatements(session).
	ParameterizedSQLBatchWritingMechanism currentBatch = (ParameterizedSQLBatchWritingMechanism) this.clone();
	this.clear();
	currentBatch.executeBatch(session);
	}

	/**
	* INTERNAL:
	* This method is added to execute and clear the batched statements on the cloned batch mechanism which
	* is created in executeBatchedStatements(session).
	*
	* Introduced in fix for bug#419326.
	*/
	private void executeBatch(AbstractSession session) {

	if (this.parameters.size() == 1) {
	// If only one call, just execute normally.
	try {
	int rowCount = (Integer)this.databaseAccessor.basicExecuteCall(this.previousCall, null, session, false);
	if (this.previousCall.hasOptimisticLock()) {
	if (rowCount != 1) {
	throw OptimisticLockException.batchStatementExecutionFailure();
	}
	}
	} finally {
	clear();
	}
	return;
	}

	try {
	this.databaseAccessor.incrementCallCount(session);// Decrement occurs in close.

	if (session.shouldLog(SessionLog.FINE, SessionLog.SQL)) {
	session.log(SessionLog.FINER, SessionLog.SQL, "begin_batch_statements", null, this.databaseAccessor);
	session.log(SessionLog.FINE, SessionLog.SQL, this.previousCall.getSQLString(), null, this.databaseAccessor, false);
	// took this logging part from SQLCall
	for (List callParameters : this.parameters) {
	StringWriter writer = new StringWriter();
	DatabaseCall.appendLogParameters(callParameters, this.databaseAccessor, writer, session);
	session.log(SessionLog.FINE, SessionLog.SQL, writer.toString(), null, this.databaseAccessor, false);
	}
	session.log(SessionLog.FINER, SessionLog.SQL, "end_batch_statements", null, this.databaseAccessor);
	}

	//bug 4241441: need to keep track of rows modified and throw opti lock exception if needed
	PreparedStatement statement = prepareBatchStatements(session);
	// += is used as native batch writing can return a row count before execution.
	this.executionCount += this.databaseAccessor.executeJDK12BatchStatement(statement, this.lastCallAppended, session, true);
	this.databaseAccessor.writeStatementsCount++;

	if (this.previousCall.hasOptimisticLock() && (this.executionCount != this.statementCount)) {
	throw OptimisticLockException.batchStatementExecutionFailure();
	}
	} finally {
	// Reset the batched sql string
	//we MUST clear the mechanism here in order to append the new statement.
	this.clear();
	}
	}

	/**
	* INTERNAL:
	* Swaps out the Mechanism for the other Mechanism
	*/
	protected void switchMechanisms(AbstractSession session, DatabaseCall dbCall) {
	this.databaseAccessor.setActiveBatchWritingMechanismToDynamicSQL();
	this.databaseAccessor.getActiveBatchWritingMechanism(session).appendCall(session, dbCall);
	}

	/**
	* INTERNAL:
	* This method is used to build the parameterized batch statement for the JDBC2.0 specification
	*/
	protected PreparedStatement prepareBatchStatements(AbstractSession session) throws DatabaseException {
	PreparedStatement statement = null;
	try {
	session.startOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
	try {
	DatabasePlatform platform = session.getPlatform();
	boolean shouldUnwrapConnection = platform.usesNativeBatchWriting();
	statement = (PreparedStatement)this.databaseAccessor.prepareStatement(this.previousCall, session, shouldUnwrapConnection);
	// Perform platform specific preparations
	platform.prepareBatchStatement(statement, this.maxBatchSize);
	if (this.queryTimeoutCache > DescriptorQueryManager.NoTimeout) {
	// Set the query timeout that was cached during the multiple calls to appendCall
	statement.setQueryTimeout(this.queryTimeoutCache);
	}

	// Iterate over the parameter lists that were batched.
	int statementSize = this.parameters.size();
	for (int statementIndex = 0; statementIndex < statementSize; ++statementIndex) {
	List parameterList = this.parameters.get(statementIndex);
	int size = parameterList.size();
	for (int index = 0; index < size; index++) {
	platform.setParameterValueInDatabaseCall(parameterList.get(index), statement, index+1, session);
	}

	// Batch the parameters to the statement.
	this.statementCount++;
	this.executionCount += platform.addBatch(statement);
	}
	} finally {
	session.endOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
	}
	} catch (SQLException exception) {
	// If this is a connection from an external pool then closeStatement will close the connection.
	// we must test the connection before that happens.
	RuntimeException exceptionToThrow = this.databaseAccessor.processExceptionForCommError(session, exception, lastCallAppended);
	try {
	// Ensure that the statement is closed, but still ensure that the real exception is thrown.
	this.databaseAccessor.closeStatement(statement, session, null);
	} catch (SQLException closeException) {
	}
	if (exceptionToThrow == null){
	throw DatabaseException.sqlException(exception, this.databaseAccessor, session, false);
	}
	throw exceptionToThrow;
	} catch (RuntimeException exception) {
	try {
	// Ensure that the statement is closed, but still ensure that the real exception is thrown.
	this.databaseAccessor.closeStatement(statement, session, null);
	} catch (SQLException closeException) {
	}
	throw exception;
	}
	return statement;
	}

	public DatabaseCall getPreviousCall() {
	return previousCall;
	}

	public void setPreviousCall(DatabaseCall previousCall) {
	this.previousCall = previousCall;
	}

	public List<List> getParameters() {
	return parameters;
	}

	public void setParameters(List<List> parameters) {
	this.parameters = parameters;
	}

	public DatabaseCall getLastCallAppended() {
	return lastCallAppended;
	}

	public void setLastCallAppended(DatabaseCall lastCallAppended) {
	this.lastCallAppended = lastCallAppended;
	}
	}