Request Boundary methods - beginRequest()/endRequest() implementation

src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerConnection43.java

@@ -1,19 +1,24 @@
 package com.microsoft.sqlserver.jdbc;
 
+import java.sql.SQLException;
 import java.sql.ShardingKey;
 
 public interface ISQLServerConnection43 extends ISQLServerConnection {
 
+    public void beginRequest() throws SQLException;
+
+    public void endRequest() throws SQLException;
+
     public void setShardingKey(ShardingKey shardingKey) throws SQLServerException;
-    
+
     public void setShardingKey(ShardingKey shardingKey,
             ShardingKey superShardingKey) throws SQLServerException;
-    
+
     public boolean setShardingKeyIfValid(ShardingKey shardingKey,
             int timeout) throws SQLServerException;
-    
+
     public boolean setShardingKeyIfValid(ShardingKey shardingKey,
             ShardingKey superShardingKey,
             int timeout) throws SQLServerException;
-    
+
 }

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java

@@ -36,6 +36,7 @@
 import java.sql.Statement;
 import java.sql.Struct;
 import java.text.MessageFormat;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Enumeration;
 import java.util.HashMap;
@@ -3215,6 +3216,9 @@ public Statement createStatement(int resultSetType,
         checkClosed();
         Statement st = new SQLServerStatement(this, resultSetType, resultSetConcurrency,
                 SQLServerStatementColumnEncryptionSetting.UseConnectionSetting);
+        if (requestStarted) {
+            addOpenStatement(st);
+        }
         loggerExternal.exiting(getClassNameLogging(), "createStatement", st);
         return st;
     }
@@ -3238,7 +3242,9 @@ public PreparedStatement prepareStatement(String sql,
             st = new SQLServerPreparedStatement(this, sql, resultSetType, resultSetConcurrency,
                     SQLServerStatementColumnEncryptionSetting.UseConnectionSetting);
         }
-
+        if (requestStarted) {
+            addOpenStatement(st);
+        }
         loggerExternal.exiting(getClassNameLogging(), "prepareStatement", st);
         return st;
     }
@@ -3261,7 +3267,9 @@ private PreparedStatement prepareStatement(String sql,
         else {
             st = new SQLServerPreparedStatement(this, sql, resultSetType, resultSetConcurrency, stmtColEncSetting);
         }
-
+        if (requestStarted) {
+            addOpenStatement(st);
+        }
         loggerExternal.exiting(getClassNameLogging(), "prepareStatement", st);
         return st;
     }
@@ -3285,7 +3293,9 @@ public CallableStatement prepareCall(String sql,
             st = new SQLServerCallableStatement(this, sql, resultSetType, resultSetConcurrency,
                     SQLServerStatementColumnEncryptionSetting.UseConnectionSetting);
         }
-
+        if (requestStarted) {
+            addOpenStatement(st);
+        }
         loggerExternal.exiting(getClassNameLogging(), "prepareCall", st);
         return st;
     }
@@ -4650,6 +4660,9 @@ public Statement createStatement(int nType,
         checkValidHoldability(resultSetHoldability);
         checkMatchesCurrentHoldability(resultSetHoldability);
         Statement st = new SQLServerStatement(this, nType, nConcur, stmtColEncSetting);
+        if (requestStarted) {
+            addOpenStatement(st);
+        }
         loggerExternal.exiting(getClassNameLogging(), "createStatement", st);
         return st;
     }
@@ -4712,7 +4725,9 @@ public PreparedStatement prepareStatement(java.lang.String sql,
         else {
             st = new SQLServerPreparedStatement(this, sql, nType, nConcur, stmtColEncSetting);
         }
-
+        if (requestStarted) {
+            addOpenStatement(st);
+        }
         loggerExternal.exiting(getClassNameLogging(), "prepareStatement", st);
         return st;
     }
@@ -4748,7 +4763,9 @@ public CallableStatement prepareCall(String sql,
         else {
             st = new SQLServerCallableStatement(this, sql, nType, nConcur, stmtColEncSetiing);
         }
-
+        if (requestStarted) {
+            addOpenStatement(st);
+        }
         loggerExternal.exiting(getClassNameLogging(), "prepareCall", st);
         return st;
     }
@@ -5300,14 +5317,99 @@ public <T> T unwrap(Class<T> iface) throws SQLException {
         return t;
     }
 
-    public void beginRequest() throws SQLFeatureNotSupportedException {
+    private boolean requestStarted = false;
+    private boolean originalDatabaseAutoCommitMode;
+    private int originalTransactionIsolationLevel;
+    private int originalNetworkTimeout;
+    private int originalHoldability;
+    private boolean originalSendTimeAsDatetime;
+    private int originalStatementPoolingCacheSize;
+    private boolean originalDisableStatementPooling;
+    private int originalServerPreparedStatementDiscardThreshold;
+    private Boolean originalEnablePrepareOnFirstPreparedStatementCall;
+    private String originalSCatalog = null;
+    private volatile SQLWarning originalSqlWarnings = null;
+    private List<Statement> openStatements = null;
+
+    protected void beginRequestInternal() throws SQLException {
         DriverJDBCVersion.checkSupportsJDBC43();
-        throw new SQLFeatureNotSupportedException("beginRequest not implemented");
+        synchronized (this) {
+            if (!requestStarted) {
+                originalDatabaseAutoCommitMode = databaseAutoCommitMode;
+                originalTransactionIsolationLevel = transactionIsolationLevel;
+                originalNetworkTimeout = getNetworkTimeout();
+                originalHoldability = holdability;
+                originalSendTimeAsDatetime = sendTimeAsDatetime;
+                originalStatementPoolingCacheSize = statementPoolingCacheSize;
+                originalDisableStatementPooling = disableStatementPooling;
+                originalServerPreparedStatementDiscardThreshold = serverPreparedStatementDiscardThreshold;
+                originalEnablePrepareOnFirstPreparedStatementCall = enablePrepareOnFirstPreparedStatementCall;
+                originalSCatalog = sCatalog;
+                originalSqlWarnings = sqlWarnings;
+                openStatements = new ArrayList<Statement>();
+                requestStarted = true;
+            }
+        }
     }
 
-    public void endRequest() throws SQLFeatureNotSupportedException {
+    protected void endRequestInternal() throws SQLException {
         DriverJDBCVersion.checkSupportsJDBC43();
-        throw new SQLFeatureNotSupportedException("endRequest not implemented");
+        synchronized (this) {
+            if (requestStarted) {
+                if (!databaseAutoCommitMode) {
+                    rollback();
+                }
+                if (databaseAutoCommitMode != originalDatabaseAutoCommitMode) {
+                    setAutoCommit(originalDatabaseAutoCommitMode);
+                }
+                if (transactionIsolationLevel != originalTransactionIsolationLevel) {
+                    setTransactionIsolation(originalTransactionIsolationLevel);
+                }
+                if (getNetworkTimeout() != originalNetworkTimeout) {
+                    setNetworkTimeout(null, originalNetworkTimeout);
+                }
+                if (holdability != originalHoldability) {
+                    setHoldability(originalHoldability);
+                }
+                if (sendTimeAsDatetime != originalSendTimeAsDatetime) {
+                    setSendTimeAsDatetime(originalSendTimeAsDatetime);
+                }
+                if (statementPoolingCacheSize != originalStatementPoolingCacheSize) {
+                    setStatementPoolingCacheSize(originalStatementPoolingCacheSize);
+                }
+                if (disableStatementPooling != originalDisableStatementPooling) {
+                    setDisableStatementPooling(originalDisableStatementPooling);
+                }
+                if (serverPreparedStatementDiscardThreshold != originalServerPreparedStatementDiscardThreshold) {
+                    if (0 > originalServerPreparedStatementDiscardThreshold) {
+                        setServerPreparedStatementDiscardThreshold(DEFAULT_SERVER_PREPARED_STATEMENT_DISCARD_THRESHOLD);
+                    }
+                    else {
+                        setServerPreparedStatementDiscardThreshold(originalServerPreparedStatementDiscardThreshold);
+                    }
+                }
+                if (enablePrepareOnFirstPreparedStatementCall != originalEnablePrepareOnFirstPreparedStatementCall) {
+                    if (null == originalEnablePrepareOnFirstPreparedStatementCall) {
+                        setEnablePrepareOnFirstPreparedStatementCall(DEFAULT_ENABLE_PREPARE_ON_FIRST_PREPARED_STATEMENT_CALL);
+                    }
+                    else {
+                        setEnablePrepareOnFirstPreparedStatementCall(originalEnablePrepareOnFirstPreparedStatementCall);
+                    }
+                }
+                if (!sCatalog.equals(originalSCatalog)) {
+                    setCatalog(originalSCatalog);
+                }
+                sqlWarnings = originalSqlWarnings;
+                if (null != openStatements) {
+                    while (!openStatements.isEmpty()) {
+                        try (Statement st = openStatements.get(0)) {
+                        }
+                    }
+                    openStatements.clear();
+                }
+                requestStarted = false;
+            }
+        }
     }
 
     /**
@@ -5883,6 +5985,26 @@ public void onEviction(Sha1HashKey key, PreparedStatementHandle handle) {
             }
         }
     }
+
+    /**
+     * @param st
+     *            Statement to add to openStatements
+     */
+    final synchronized void addOpenStatement(Statement st) {
+        if (null != openStatements) {
+            openStatements.add(st);
+        }
+    }
+
+    /**
+     * @param st
+     *            Statement to remove from openStatements
+     */
+    final synchronized void removeOpenStatement(Statement st) {
+        if (null != openStatements) {
+            openStatements.remove(st);
+        }
+    }
 }
 
 // Helper class for security manager functions used by SQLServerConnection class.

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection43.java

@@ -1,5 +1,6 @@
 package com.microsoft.sqlserver.jdbc;
 
+import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
 import java.sql.ShardingKey;
 
@@ -8,7 +9,51 @@ public class SQLServerConnection43 extends SQLServerConnection implements ISQLSe
     SQLServerConnection43(String parentInfo) throws SQLServerException {
         super(parentInfo);
     }
-
+
+    /**
+     * Hints to the driver that a request, an independent unit of work, is beginning on this connection. It backs up the values of the connection
+     * properties that are modifiable through public methods. Each request is independent of all other requests with regard to state local to the
+     * connection either on the client or the server. Work done between {@code beginRequest}, {@code endRequest} pairs does not depend on any other
+     * work done on the connection either as part of another request or outside of any request. A request may include multiple transactions. There may
+     * be dependencies on committed database state as that is not local to the connection. {@code beginRequest} marks the beginning of the work unit.
+     * <p>
+     * Local state is defined as any state associated with a Connection that is local to the current Connection either in the client or the database
+     * that is not transparently reproducible.
+     * <p>
+     * Calls to {@code beginRequest} and {@code endRequest} are not nested. Multiple calls to {@code beginRequest} without an intervening call to
+     * {@code endRequest} is not an error. The first {@code beginRequest} call marks the start of the request and subsequent calls are treated as a
+     * no-op It is recommended to enclose each unit of work in {@code beginRequest}, {@code endRequest} pairs such that there is no open transaction
+     * at the beginning or end of the request and no dependency on local state that crosses request boundaries. Committed database state is not local.
+     *
+     * This method is to be used by Connection pooling managers.
+     * <p>
+     * The pooling manager should call {@code beginRequest} on the underlying connection prior to returning a connection to the caller.
+     * <p>
+     * 
+     * @throws SQLException
+     *             if an error occurs
+     * @see endRequest
+     */
+    public void beginRequest() throws SQLException {
+        beginRequestInternal();
+    }
+
+    /**
+     * Hints to the driver that a request, an independent unit of work, has completed. It rolls back the open transactions. Resets the connection
+     * properties that are modifiable through public methods back to their original values. Calls to {@code beginRequest} and {@code endRequest} are
+     * not nested. Multiple calls to {@code endRequest} without an intervening call to {@code beginRequest} is not an error. The first
+     * {@code endRequest} call marks the request completed and subsequent calls are treated as a no-op. If {@code endRequest} is called without an
+     * initial call to {@code beginRequest} is a no-op. This method is to be used by Connection pooling managers.
+     * <p>
+     * 
+     * @throws SQLException
+     *             if an error occurs
+     * @see beginRequest
+     */
+    public void endRequest() throws SQLException {
+        endRequestInternal();
+    }
+
     public void setShardingKey(ShardingKey shardingKey) throws SQLServerException {
         DriverJDBCVersion.checkSupportsJDBC43();
         throw new SQLServerException("setShardingKey not implemented", new SQLFeatureNotSupportedException("setShardingKey not implemented"));
@@ -17,20 +62,22 @@ public void setShardingKey(ShardingKey shardingKey) throws SQLServerException {
     public void setShardingKey(ShardingKey shardingKey,
             ShardingKey superShardingKey) throws SQLServerException {
         DriverJDBCVersion.checkSupportsJDBC43();
-        throw new SQLServerException("setShardingKey not implemented", new SQLFeatureNotSupportedException("setShardingKey not implemented")) ;
+        throw new SQLServerException("setShardingKey not implemented", new SQLFeatureNotSupportedException("setShardingKey not implemented"));
     }
 
     public boolean setShardingKeyIfValid(ShardingKey shardingKey,
             int timeout) throws SQLServerException {
         DriverJDBCVersion.checkSupportsJDBC43();
-        throw new SQLServerException("setShardingKeyIfValid not implemented", new SQLFeatureNotSupportedException("setShardingKeyIfValid not implemented"));
+        throw new SQLServerException("setShardingKeyIfValid not implemented",
+                new SQLFeatureNotSupportedException("setShardingKeyIfValid not implemented"));
     }
 
     public boolean setShardingKeyIfValid(ShardingKey shardingKey,
             ShardingKey superShardingKey,
             int timeout) throws SQLServerException {
         DriverJDBCVersion.checkSupportsJDBC43();
-        throw new SQLServerException("setShardingKeyIfValid not implemented", new SQLFeatureNotSupportedException("setShardingKeyIfValid not implemented"));
+        throw new SQLServerException("setShardingKeyIfValid not implemented",
+                new SQLFeatureNotSupportedException("setShardingKeyIfValid not implemented"));
     }
 
 }

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java

@@ -631,7 +631,9 @@ void closeInternal() {
         // Regardless what happens when cleaning up,
         // the statement is considered closed.
         assert !bIsClosed;
-
+
+        connection.removeOpenStatement(this);
+
         discardLastExecutionResults();
 
         bIsClosed = true;