getErrorChain() {
+ return errorChain;
+ }
+
+ @Override
+ public SQLServerError getSQLServerMessage() {
+ return this;
+ }
+
+ /**
+ * Downgrade a Error message into a Info message
+ *
+ * This simply create a SQLServerInfoMessage from this SQLServerError,
+ * without changing the message content.
+ *
+ * @return ISQLServerMessage
+ */
+ public ISQLServerMessage toSQLServerInfoMessage() {
+ return toSQLServerInfoMessage(-1, -1);
+ }
+
+ /**
+ * Downgrade a Error message into a Info message
+ *
+ * This simply create a SQLServerInfoMessage from this SQLServerError,
+ *
+ * @param newErrorSeverity
+ * - The new ErrorSeverity
+ *
+ * @return ISQLServerMessage
+ */
+ public ISQLServerMessage toSQLServerInfoMessage(int newErrorSeverity) {
+ return toSQLServerInfoMessage(newErrorSeverity, -1);
+ }
+
+ /**
+ * Downgrade a Error message into a Info message
+ *
+ * This simply create a SQLServerInfoMessage from this SQLServerError,
+ *
+ * @param newErrorSeverity
+ * - If you want to change the ErrorSeverity (-1: leave unchanged)
+ * @param newErrorNumber
+ * - If you want to change the ErrorNumber (-1: leave unchanged)
+ *
+ * @return ISQLServerMessage
+ */
+ public ISQLServerMessage toSQLServerInfoMessage(int newErrorSeverity, int newErrorNumber) {
+ if (newErrorSeverity != -1) {
+ this.setErrorSeverity(newErrorSeverity);
+ }
+
+ if (newErrorNumber != -1) {
+ this.setErrorNumber(newErrorNumber);
+ }
+
+ return new SQLServerInfoMessage(this);
+ }
+
+ /**
+ * Set a new ErrorSeverity for this Message
+ *
+ * @param newSeverity
+ * new severity
+ */
+ public void setErrorSeverity(int newSeverity) {
+ this.errorSeverity = newSeverity;
+ }
+
+ /**
+ * Set a new ErrorNumber for this Message
+ *
+ * @param newErrorNumber
+ * new error number
+ */
+ public void setErrorNumber(int newErrorNumber) {
+ this.errorNumber = newErrorNumber;
+ }
+
+ @Override
+ public SQLException toSqlExceptionOrSqlWarning() {
+ return new SQLServerException(this);
+ }
}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
index 7d4fa23f0..57387bb03 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
@@ -7,6 +7,7 @@
import java.sql.SQLFeatureNotSupportedException;
import java.text.MessageFormat;
+import java.util.List;
import java.util.UUID;
import java.util.logging.Level;
@@ -178,6 +179,14 @@ static String getErrString(String errCode) {
logException(obj, errText, bStack);
}
+ public SQLServerException(SQLServerError sqlServerError) {
+ super(sqlServerError.getErrorMessage(),
+ generateStateCode(null, sqlServerError.getErrorNumber(), sqlServerError.getErrorState()),
+ sqlServerError.getErrorNumber(), null);
+
+ this.sqlServerError = sqlServerError;
+ }
+
/**
* Constructs a new SQLServerException.
*
@@ -261,6 +270,21 @@ static void makeFromDatabaseError(SQLServerConnection con, Object obj, String er
SQLServerException.checkAndAppendClientConnId(errText, con), state, sqlServerError, bStack);
theException.setDriverErrorCode(DRIVER_ERROR_FROM_DATABASE);
+ // Add any extra messages to the SQLException error chain
+ List errorChain = sqlServerError.getErrorChain();
+ if (errorChain != null) {
+ for (SQLServerError srvError : errorChain) {
+ String state2 = generateStateCode(con, srvError.getErrorNumber(), srvError.getErrorState());
+
+ SQLServerException chainException = new SQLServerException(obj,
+ SQLServerException.checkAndAppendClientConnId(srvError.getErrorMessage(), con), state2,
+ srvError, bStack);
+ chainException.setDriverErrorCode(DRIVER_ERROR_FROM_DATABASE);
+
+ theException.setNextException(chainException);
+ }
+ }
+
// Close the connection if we get a severity 20 or higher error class (nClass is severity of error).
if ((sqlServerError.getErrorSeverity() >= 20) && (null != con)) {
con.notifyPooledConnection(theException);
@@ -395,16 +419,17 @@ static String generateStateCode(SQLServerConnection con, int errNum, Integer dat
static String checkAndAppendClientConnId(String errMsg, SQLServerConnection conn) {
if (null != conn && conn.isConnected()) {
UUID clientConnId = conn.getClientConIdInternal();
- assert null != clientConnId;
- StringBuilder sb = new StringBuilder(errMsg);
- // This syntax of adding connection id is matched in a retry logic. If anything changes here, make
- // necessary changes to enableSSL() function's exception handling mechanism.
- sb.append(LOG_CLIENT_CONNECTION_ID_PREFIX);
- sb.append(clientConnId.toString());
- return sb.toString();
- } else {
- return errMsg;
+ if (null != clientConnId) {
+ StringBuilder sb = (errMsg != null) ? new StringBuilder(errMsg) : new StringBuilder();
+ // This syntax of adding connection id is matched in a retry logic. If anything changes here, make
+ // necessary changes to enableSSL() function's exception handling mechanism.
+ sb.append(LOG_CLIENT_CONNECTION_ID_PREFIX);
+ sb.append(clientConnId.toString());
+ return sb.toString();
+ }
}
+ return (errMsg != null) ? errMsg : "";
+
}
static void throwNotSupportedException(SQLServerConnection con, Object obj) throws SQLServerException {
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerInfoMessage.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerInfoMessage.java
new file mode 100644
index 000000000..0b3a6075a
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerInfoMessage.java
@@ -0,0 +1,135 @@
+/*
+ * Microsoft JDBC Driver for SQL Server Copyright(c) Microsoft Corporation All rights reserved. This program is made
+ * available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc;
+
+import java.sql.SQLException;
+
+
+/**
+ * Holds information about SQL Server messages that is considered as Informational Messages (normally if SQL Server Severity is at 10)
+ *
+ * Instead of just holding the SQL Server message (like a normal SQLWarning, it also holds all the
+ * SQL Servers extended information, like: ErrorSeverity, ServerName, ProcName etc
+ *
+ * This enables client to print out extra information about the message.
+ * Like: In what procedure was the message produced.
+ *
+ * A SQLServerInfoMessage is produced when reading the TDS Stream and added to the Connection as a SQLServerWarning
+ */
+public final class SQLServerInfoMessage extends StreamPacket implements ISQLServerMessage {
+ SQLServerError msg = new SQLServerError();
+
+ SQLServerInfoMessage() {
+ super(TDS.TDS_MSG);
+ }
+
+ SQLServerInfoMessage(SQLServerError msg) {
+ super(TDS.TDS_MSG);
+ this.msg = msg;
+ }
+
+ @Override
+ void setFromTDS(TDSReader tdsReader) throws SQLServerException {
+ if (TDS.TDS_MSG != tdsReader.readUnsignedByte())
+ assert false;
+ msg.setContentsFromTDS(tdsReader);
+ }
+
+ @Override
+ public SQLServerError getSQLServerMessage() {
+ return msg;
+ }
+
+ @Override
+ public String getErrorMessage() {
+ return msg.getErrorMessage();
+ }
+
+ @Override
+ public int getErrorNumber() {
+ return msg.getErrorNumber();
+ }
+
+ @Override
+ public int getErrorState() {
+ return msg.getErrorState();
+ }
+
+ @Override
+ public int getErrorSeverity() {
+ return msg.getErrorSeverity();
+ }
+
+ @Override
+ public String getServerName() {
+ return msg.getServerName();
+ }
+
+ @Override
+ public String getProcedureName() {
+ return msg.getProcedureName();
+ }
+
+ @Override
+ public long getLineNumber() {
+ return msg.getLineNumber();
+ }
+
+ /**
+ * Upgrade a Info message into a Error message
+ *
+ * This simply create a SQLServerError from this SQLServerInfoMessage,
+ * without changing the message content.
+ *
+ * @return ISQLServerMessage
+ */
+ public ISQLServerMessage toSQLServerError() {
+ return toSQLServerError(-1, -1);
+ }
+
+ /**
+ * Upgrade a Info message into a Error message
+ *
+ * This simply create a SQLServerError from this SQLServerInfoMessage.
+ *
+ * @param newErrorSeverity
+ * - The new ErrorSeverity
+ *
+ * @return ISQLServerMessage
+ */
+ public ISQLServerMessage toSQLServerError(int newErrorSeverity) {
+ return toSQLServerError(newErrorSeverity, -1);
+ }
+
+ /**
+ * Upgrade a Info message into a Error message
+ *
+ * This simply create a SQLServerError from this SQLServerInfoMessage.
+ *
+ * @param newErrorSeverity
+ * - If you want to change the ErrorSeverity (-1: leave unchanged)
+ * @param newErrorNumber
+ * - If you want to change the ErrorNumber (-1: leave unchanged)
+ *
+ * @return ISQLServerMessage
+ */
+ public ISQLServerMessage toSQLServerError(int newErrorSeverity, int newErrorNumber) {
+ if (newErrorSeverity != -1) {
+ this.msg.setErrorSeverity(newErrorSeverity);
+ }
+
+ if (newErrorNumber != -1) {
+ this.msg.setErrorNumber(newErrorNumber);
+ }
+
+ return new SQLServerError(this.msg);
+ }
+
+ @Override
+ public SQLException toSqlExceptionOrSqlWarning() {
+ return new SQLServerWarning(this.msg);
+ }
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerMSAL4JUtils.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerMSAL4JUtils.java
index c8f2fb347..1ae69891b 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerMSAL4JUtils.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerMSAL4JUtils.java
@@ -14,6 +14,7 @@
import java.net.URI;
import java.net.URISyntaxException;
+import java.security.MessageDigest;
import java.text.MessageFormat;
import java.util.Collections;
@@ -21,6 +22,7 @@
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@@ -61,6 +63,8 @@ class SQLServerMSAL4JUtils {
static final String SLASH_DEFAULT = "/.default";
static final String ACCESS_TOKEN_EXPIRE = "access token expires: ";
+ private static final TokenCacheMap TOKEN_CACHE_MAP = new TokenCacheMap();
+
private final static String LOGCONTEXT = "MSAL version "
+ com.microsoft.aad.msal4j.PublicClientApplication.class.getPackage().getImplementationVersion() + ": ";
@@ -84,10 +88,17 @@ static SqlAuthenticationToken getSqlFedAuthToken(SqlFedAuthInfo fedAuthInfo, Str
lock.lock();
try {
+ String hashedSecret = getHashedSecret(new String[] {fedAuthInfo.stsurl, user, password});
+ PersistentTokenCacheAccessAspect persistentTokenCacheAccessAspect = TOKEN_CACHE_MAP.getEntry(hashedSecret);
+
+ if (null == persistentTokenCacheAccessAspect) {
+ persistentTokenCacheAccessAspect = new PersistentTokenCacheAccessAspect();
+ TOKEN_CACHE_MAP.addEntry(hashedSecret, persistentTokenCacheAccessAspect);
+ }
+
final PublicClientApplication pca = PublicClientApplication
.builder(ActiveDirectoryAuthentication.JDBC_FEDAUTH_CLIENT_ID).executorService(executorService)
- .setTokenCacheAccessAspect(PersistentTokenCacheAccessAspect.getInstance())
- .authority(fedAuthInfo.stsurl).build();
+ .setTokenCacheAccessAspect(persistentTokenCacheAccessAspect).authority(fedAuthInfo.stsurl).build();
final CompletableFuture future = pca.acquireToken(UserNamePasswordParameters
.builder(Collections.singleton(fedAuthInfo.spn + SLASH_DEFAULT), user, password.toCharArray())
@@ -132,11 +143,19 @@ static SqlAuthenticationToken getSqlFedAuthTokenPrincipal(SqlFedAuthInfo fedAuth
lock.lock();
try {
+ String hashedSecret = getHashedSecret(
+ new String[] {fedAuthInfo.stsurl, aadPrincipalID, aadPrincipalSecret});
+ PersistentTokenCacheAccessAspect persistentTokenCacheAccessAspect = TOKEN_CACHE_MAP.getEntry(hashedSecret);
+
+ if (null == persistentTokenCacheAccessAspect) {
+ persistentTokenCacheAccessAspect = new PersistentTokenCacheAccessAspect();
+ TOKEN_CACHE_MAP.addEntry(hashedSecret, persistentTokenCacheAccessAspect);
+ }
+
IClientCredential credential = ClientCredentialFactory.createFromSecret(aadPrincipalSecret);
ConfidentialClientApplication clientApplication = ConfidentialClientApplication
.builder(aadPrincipalID, credential).executorService(executorService)
- .setTokenCacheAccessAspect(PersistentTokenCacheAccessAspect.getInstance())
- .authority(fedAuthInfo.stsurl).build();
+ .setTokenCacheAccessAspect(persistentTokenCacheAccessAspect).authority(fedAuthInfo.stsurl).build();
final CompletableFuture future = clientApplication
.acquireToken(ClientCredentialParameters.builder(scopes).build());
@@ -181,6 +200,15 @@ static SqlAuthenticationToken getSqlFedAuthTokenPrincipalCertificate(SqlFedAuthI
lock.lock();
try {
+ String hashedSecret = getHashedSecret(new String[] {fedAuthInfo.stsurl, aadPrincipalID, certFile,
+ certPassword, certKey, certKeyPassword});
+ PersistentTokenCacheAccessAspect persistentTokenCacheAccessAspect = TOKEN_CACHE_MAP.getEntry(hashedSecret);
+
+ if (null == persistentTokenCacheAccessAspect) {
+ persistentTokenCacheAccessAspect = new PersistentTokenCacheAccessAspect();
+ TOKEN_CACHE_MAP.addEntry(hashedSecret, persistentTokenCacheAccessAspect);
+ }
+
ConfidentialClientApplication clientApplication = null;
// check if cert is PKCS12 first
@@ -202,8 +230,7 @@ static SqlAuthenticationToken getSqlFedAuthTokenPrincipalCertificate(SqlFedAuthI
IClientCredential credential = ClientCredentialFactory.createFromCertificate(is, certPassword);
clientApplication = ConfidentialClientApplication.builder(aadPrincipalID, credential)
- .executorService(executorService)
- .setTokenCacheAccessAspect(PersistentTokenCacheAccessAspect.getInstance())
+ .executorService(executorService).setTokenCacheAccessAspect(persistentTokenCacheAccessAspect)
.authority(fedAuthInfo.stsurl).build();
} catch (FileNotFoundException e) {
// re-throw if file not there no point to try another format
@@ -232,8 +259,7 @@ static SqlAuthenticationToken getSqlFedAuthTokenPrincipalCertificate(SqlFedAuthI
IClientCredential credential = ClientCredentialFactory.createFromCertificate(privateKey, cert);
clientApplication = ConfidentialClientApplication.builder(aadPrincipalID, credential)
- .executorService(executorService)
- .setTokenCacheAccessAspect(PersistentTokenCacheAccessAspect.getInstance())
+ .executorService(executorService).setTokenCacheAccessAspect(persistentTokenCacheAccessAspect)
.authority(fedAuthInfo.stsurl).build();
}
@@ -449,4 +475,45 @@ private static SQLServerException getCorrectedException(Exception e, String user
return new SQLServerException(form.format(msgArgs), null, 0, correctedExecutionException);
}
}
+
+ private static String getHashedSecret(String[] secrets) throws SQLServerException {
+ try {
+ MessageDigest md = MessageDigest.getInstance("SHA-256");
+ for (String secret : secrets) {
+ if (null != secret) {
+ md.update(secret.getBytes(java.nio.charset.StandardCharsets.UTF_16LE));
+ }
+ }
+ return new String(md.digest());
+ } catch (NoSuchAlgorithmException e) {
+ throw new SQLServerException(SQLServerException.getErrString("R_NoSHA256Algorithm"), e);
+ }
+ }
+
+ private static class TokenCacheMap {
+ private ConcurrentHashMap tokenCacheMap = new ConcurrentHashMap<>();
+
+ PersistentTokenCacheAccessAspect getEntry(String key) {
+ PersistentTokenCacheAccessAspect persistentTokenCacheAccessAspect = tokenCacheMap.get(key);
+
+ if (null != persistentTokenCacheAccessAspect) {
+ if (System.currentTimeMillis() > persistentTokenCacheAccessAspect.getExpiryTime()) {
+ tokenCacheMap.remove(key);
+
+ persistentTokenCacheAccessAspect = new PersistentTokenCacheAccessAspect();
+ persistentTokenCacheAccessAspect
+ .setExpiryTime(System.currentTimeMillis() + PersistentTokenCacheAccessAspect.TIME_TO_LIVE);
+
+ tokenCacheMap.put(key, persistentTokenCacheAccessAspect);
+ }
+ }
+
+ return persistentTokenCacheAccessAspect;
+ }
+
+ void addEntry(String key, PersistentTokenCacheAccessAspect value) {
+ value.setExpiryTime(System.currentTimeMillis() + PersistentTokenCacheAccessAspect.TIME_TO_LIVE);
+ tokenCacheMap.put(key, value);
+ }
+ }
}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java
index 921212391..ddf88ed2b 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java
@@ -29,6 +29,7 @@
import java.util.Map.Entry;
import java.util.Vector;
import java.util.logging.Level;
+import java.util.regex.Pattern;
import com.microsoft.sqlserver.jdbc.SQLServerConnection.CityHash128Key;
import com.microsoft.sqlserver.jdbc.SQLServerConnection.PreparedStatementHandle;
@@ -70,6 +71,15 @@ public class SQLServerPreparedStatement extends SQLServerStatement implements IS
/** Processed SQL statement text, may not be same as what user initially passed. */
final String userSQL;
+ // flag whether is exec escape syntax
+ private boolean isExecEscapeSyntax;
+
+ // flag whether is call escape syntax
+ private boolean isCallEscapeSyntax;
+
+ // flag whether is four part syntax
+ private boolean isFourPartSyntax;
+
/** Parameter positions in processed SQL statement text. */
final int[] userSQLParamPositions;
@@ -128,6 +138,22 @@ private void setPreparedStatementHandle(int handle) {
*/
private boolean useBulkCopyForBatchInsert;
+ /**
+ * Regex for JDBC 'call' escape syntax
+ */
+ private static final Pattern callEscapePattern = Pattern
+ .compile("^\\s*(?i)\\{(\\s*\\??\\s*=?\\s*)call (.+)\\s*\\(?\\?*,?\\)?\\s*}\\s*$");
+
+ /**
+ * Regex for 'exec' escape syntax
+ */
+ private static final Pattern execEscapePattern = Pattern.compile("^\\s*(?i)(?:exec|execute)\\b");
+
+ /**
+ * Regex for four part syntax
+ */
+ private static final Pattern fourPartSyntaxPattern = Pattern.compile("(.+)\\.(.+)\\.(.+)\\.(.+)");
+
/** Returns the prepared statement SQL */
@Override
public String toString() {
@@ -208,6 +234,12 @@ private boolean resetPrepStmtHandle(boolean discardCurrentCacheItem) {
*/
private Vector cryptoMetaBatch = new Vector<>();
+ /**
+ * Listener to clear the {@link SQLServerPreparedStatement#prepStmtHandle} and
+ * {@link SQLServerPreparedStatement#cachedPreparedStatementHandle} before reconnecting.
+ */
+ private ReconnectListener clearPrepStmtHandleOnReconnectListener;
+
/**
* Constructs a SQLServerPreparedStatement.
*
@@ -228,6 +260,9 @@ private boolean resetPrepStmtHandle(boolean discardCurrentCacheItem) {
SQLServerStatementColumnEncryptionSetting stmtColEncSetting) throws SQLServerException {
super(conn, nRSType, nRSConcur, stmtColEncSetting);
+ clearPrepStmtHandleOnReconnectListener = this::clearPrepStmtHandle;
+ connection.registerBeforeReconnectListener(clearPrepStmtHandleOnReconnectListener);
+
if (null == sql) {
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_NullValue"));
Object[] msgArgs1 = {"Statement SQL"};
@@ -253,6 +288,9 @@ private boolean resetPrepStmtHandle(boolean discardCurrentCacheItem) {
procedureName = parsedSQL.procedureName;
bReturnValueSyntax = parsedSQL.bReturnValueSyntax;
userSQL = parsedSQL.processedSQL;
+ isExecEscapeSyntax = isExecEscapeSyntax(sql);
+ isCallEscapeSyntax = isCallEscapeSyntax(sql);
+ isFourPartSyntax = isFourPartSyntax(sql);
userSQLParamPositions = parsedSQL.parameterPositions;
initParams(userSQLParamPositions.length);
useBulkCopyForBatchInsert = conn.getUseBulkCopyForBatchInsert();
@@ -262,6 +300,8 @@ private boolean resetPrepStmtHandle(boolean discardCurrentCacheItem) {
* Closes the prepared statement's prepared handle.
*/
private void closePreparedHandle() {
+ connection.removeBeforeReconnectListener(clearPrepStmtHandleOnReconnectListener);
+
if (!hasPreparedStatementHandle())
return;
@@ -487,6 +527,7 @@ public java.sql.ResultSet executeQuery() throws SQLServerException, SQLTimeoutEx
loggerExternal.finer(toString() + ACTIVITY_ID + ActivityCorrelator.getCurrent().toString());
}
checkClosed();
+ connection.unprepareUnreferencedPreparedStatementHandles(false);
executeStatement(new PrepStmtExecCmd(this, EXECUTE_QUERY));
loggerExternal.exiting(getClassNameLogging(), "executeQuery");
return resultSet;
@@ -501,6 +542,7 @@ public java.sql.ResultSet executeQuery() throws SQLServerException, SQLTimeoutEx
*/
final java.sql.ResultSet executeQueryInternal() throws SQLServerException, SQLTimeoutException {
checkClosed();
+ connection.unprepareUnreferencedPreparedStatementHandles(false);
executeStatement(new PrepStmtExecCmd(this, EXECUTE_QUERY_INTERNAL));
return resultSet;
}
@@ -513,7 +555,8 @@ public int executeUpdate() throws SQLServerException, SQLTimeoutException {
}
checkClosed();
- connection.unprepareUnreferencedPreparedStatementHandles(true);
+
+ connection.unprepareUnreferencedPreparedStatementHandles(false);
executeStatement(new PrepStmtExecCmd(this, EXECUTE_UPDATE));
// this shouldn't happen, caller probably meant to call executeLargeUpdate
@@ -534,7 +577,7 @@ public long executeLargeUpdate() throws SQLServerException, SQLTimeoutException
loggerExternal.finer(toString() + ACTIVITY_ID + ActivityCorrelator.getCurrent().toString());
}
checkClosed();
- connection.unprepareUnreferencedPreparedStatementHandles(true);
+ connection.unprepareUnreferencedPreparedStatementHandles(false);
executeStatement(new PrepStmtExecCmd(this, EXECUTE_UPDATE));
loggerExternal.exiting(getClassNameLogging(), "executeLargeUpdate", updateCount);
return updateCount;
@@ -547,7 +590,7 @@ public boolean execute() throws SQLServerException, SQLTimeoutException {
loggerExternal.finer(toString() + ACTIVITY_ID + ActivityCorrelator.getCurrent().toString());
}
checkClosed();
- connection.unprepareUnreferencedPreparedStatementHandles(true);
+ connection.unprepareUnreferencedPreparedStatementHandles(false);
executeStatement(new PrepStmtExecCmd(this, EXECUTE));
loggerExternal.exiting(getClassNameLogging(), "execute", null != resultSet);
return null != resultSet;
@@ -1208,7 +1251,18 @@ else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCal
*/
boolean callRPCDirectly(Parameter[] params) throws SQLServerException {
int paramCount = SQLServerConnection.countParams(userSQL);
- return (null != procedureName && paramCount != 0 && !isTVPType(params));
+
+ // In order to execute sprocs directly the following must be true:
+ // 1. There must be a sproc name
+ // 2. There must be parameters
+ // 3. Parameters must not be a TVP type
+ // 4. Compliant CALL escape syntax
+ // If isExecEscapeSyntax is true, EXEC escape syntax is used then use prior behaviour of
+ // wrapping call to execute the procedure
+ // If isFourPartSyntax is true, sproc is being executed against linked server, then
+ // use prior behaviour of wrapping call to execute procedure
+ return (null != procedureName && paramCount != 0 && !isTVPType(params) && isCallEscapeSyntax
+ && !isExecEscapeSyntax && !isFourPartSyntax);
}
/**
@@ -1228,6 +1282,18 @@ private boolean isTVPType(Parameter[] params) throws SQLServerException {
return false;
}
+ private boolean isExecEscapeSyntax(String sql) {
+ return execEscapePattern.matcher(sql).find();
+ }
+
+ private boolean isCallEscapeSyntax(String sql) {
+ return callEscapePattern.matcher(sql).find();
+ }
+
+ private boolean isFourPartSyntax(String sql) {
+ return fourPartSyntaxPattern.matcher(sql).find();
+ }
+
/**
* Executes sp_prepare to prepare a parameterized statement and sets the prepared statement handle
*
@@ -2201,7 +2267,7 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQL
loggerExternal.finer(toString() + ACTIVITY_ID + ActivityCorrelator.getCurrent().toString());
}
checkClosed();
- connection.unprepareUnreferencedPreparedStatementHandles(true);
+ connection.unprepareUnreferencedPreparedStatementHandles(false);
discardLastExecutionResults();
try {
@@ -2385,6 +2451,7 @@ public long[] executeLargeBatch() throws SQLServerException, BatchUpdateExceptio
loggerExternal.finer(toString() + ACTIVITY_ID + ActivityCorrelator.getCurrent().toString());
}
checkClosed();
+ connection.unprepareUnreferencedPreparedStatementHandles(false);
discardLastExecutionResults();
try {
@@ -3419,6 +3486,7 @@ public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar c
if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal});
checkClosed();
+
setValue(n, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, cal, false);
loggerExternal.exiting(getClassNameLogging(), "setTimestamp");
}
@@ -3430,6 +3498,7 @@ public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar c
if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal, forceEncrypt});
checkClosed();
+
setValue(n, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, cal, forceEncrypt);
loggerExternal.exiting(getClassNameLogging(), "setTimestamp");
}
@@ -3529,4 +3598,12 @@ public void addBatch(String sql) throws SQLServerException {
Object[] msgArgs = {"addBatch()"};
throw new SQLServerException(this, form.format(msgArgs), null, 0, false);
}
+
+ private void clearPrepStmtHandle() {
+ prepStmtHandle = 0;
+ cachedPreparedStatementHandle = null;
+ if (getStatementLogger().isLoggable(Level.FINER)) {
+ getStatementLogger().finer(toString() + " cleared cachedPrepStmtHandle!");
+ }
+ }
}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java
index 95b5ffa0b..28a1b219a 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java
@@ -535,7 +535,7 @@ protected Object[][] getContents() {
{"R_crCommandCannotTimeOut", "Request failed to time out and SQLServerConnection does not exist"},
{"R_InvalidIPAddressPreference", "IP address preference {0} is not valid."},
{"R_UnableLoadAuthDll", "Unable to load authentication DLL {0}"},
- {"R_illegalArgumentTrustManager", "Interal error. Peer certificate chain or key exchange algorithem can not be null or empty."},
+ {"R_illegalArgumentTrustManager", "Internal error. Peer certificate chain or key exchange algorithm can not be null or empty."},
{"R_serverCertExpired", "Server Certificate has expired: {0}: {1}"},
{"R_serverCertNotYetValid", "Server Certificate is not yet valid: {0}: {1}"},
{"R_serverCertError", "Error validating Server Certificate: {0}: \n{1}:\n{2}."},
@@ -545,7 +545,8 @@ protected Object[][] getContents() {
{"R_ManagedIdentityTokenAcquisitionFail", "Failed to acquire managed identity token. Request for the token succeeded, but no token was returned. The token is null."},
{"R_AmbiguousRowUpdate", "Failed to execute updateRow(). The update is attempting an ambiguous update on tables \"{0}\" and \"{1}\". Ensure all columns being updated prior to the updateRow() call belong to the same table."},
{"R_InvalidSqlQuery", "Invalid SQL Query: {0}"},
- {"R_InvalidScale", "Scale of input value is larger than the maximum allowed by SQL Server."}
+ {"R_InvalidScale", "Scale of input value is larger than the maximum allowed by SQL Server."},
+ {"R_colCountNotMatchColTypeCount", "Number of provided columns {0} does not match the column data types definition {1}."},
};
}
// @formatter:on
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java
index 4e096864d..12432c560 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java
@@ -262,10 +262,14 @@ final void executeStatement(TDSCommand newStmtCmd) throws SQLServerException, SQ
// (Re)execute this Statement with the new command
executeCommand(newStmtCmd);
} catch (SQLServerException e) {
- if (e.getDriverErrorCode() == SQLServerException.ERROR_QUERY_TIMEOUT)
+ if (e.getDriverErrorCode() == SQLServerException.ERROR_QUERY_TIMEOUT) {
+ if (e.getCause() == null) {
+ throw new SQLTimeoutException(e.getMessage(), e.getSQLState(), e.getErrorCode(), e);
+ }
throw new SQLTimeoutException(e.getMessage(), e.getSQLState(), e.getErrorCode(), e.getCause());
- else
+ } else {
throw e;
+ }
} finally {
if (newStmtCmd.wasExecuted())
lastStmtExecCmd = newStmtCmd;
@@ -1616,7 +1620,6 @@ boolean onDone(TDSReader tdsReader) throws SQLServerException {
}
}
}
-
// If the current command (whatever it was) produced an error then stop parsing and propagate it up.
// In this case, the command is likely to be a RAISERROR, but it could be anything.
if (doneToken.isError())
@@ -1686,8 +1689,8 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException {
@Override
boolean onInfo(TDSReader tdsReader) throws SQLServerException {
- StreamInfo infoToken = new StreamInfo();
- infoToken.setFromTDS(tdsReader);
+ SQLServerInfoMessage infoMessage = new SQLServerInfoMessage();
+ infoMessage.setFromTDS(tdsReader);
// Under some circumstances the server cannot produce the cursored result set
// that we requested, but produces a client-side (default) result set instead.
@@ -1701,13 +1704,40 @@ boolean onInfo(TDSReader tdsReader) throws SQLServerException {
// ErrorCause: Server cursor is not supported on the specified SQL, falling back to default result set
// ErrorCorrectiveAction: None required
//
- if (16954 == infoToken.msg.getErrorNumber())
+ if (16954 == infoMessage.msg.getErrorNumber())
executedSqlDirectly = true;
- SQLWarning warning = new SQLWarning(
- infoToken.msg.getErrorMessage(), SQLServerException.generateStateCode(connection,
- infoToken.msg.getErrorNumber(), infoToken.msg.getErrorState()),
- infoToken.msg.getErrorNumber());
+ // Call the message handler to see what that think of the message
+ // - discard
+ // - upgrade to Error
+ // - or simply pass on
+ ISQLServerMessageHandler msgHandler = ((ISQLServerConnection) getConnection())
+ .getServerMessageHandler();
+ if (msgHandler != null) {
+
+ // Let the message handler decide if the error should be unchanged, up/down-graded or ignored
+ ISQLServerMessage srvMessage = msgHandler.messageHandler(infoMessage);
+
+ // Ignored
+ if (srvMessage == null) {
+ return true;
+ }
+
+ // The message handler changed it to an "Error Message"
+ if (srvMessage.isErrorMessage()) {
+ // Set/Add the error message to the "super"
+ addDatabaseError((SQLServerError) srvMessage);
+ return true;
+ }
+
+ // Still a "info message", just set infoMessage and the code in the below section will create the Warnings
+ if (srvMessage.isInfoMessage()) {
+ infoMessage = (SQLServerInfoMessage) srvMessage;
+ }
+ }
+
+ // Create the SQLWarning and add them to the Warning chain
+ SQLWarning warning = new SQLServerWarning(infoMessage.msg);
if (sqlWarnings == null) {
sqlWarnings = new Vector<>();
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerWarning.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerWarning.java
new file mode 100644
index 000000000..de6df2a42
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerWarning.java
@@ -0,0 +1,45 @@
+/*
+ * Microsoft JDBC Driver for SQL Server Copyright(c) Microsoft Corporation All rights reserved. This program is made
+ * available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+package com.microsoft.sqlserver.jdbc;
+
+import java.sql.SQLWarning;
+
+
+/**
+ * Holds information about SQL Server messages that is considered as Informational Messages (normally if SQL Server Severity is at 10)
+ *
+ * Instead of just holding the SQL Server message (like a normal SQLWarning, it also holds all the
+ * SQL Servers extended information, like: ErrorSeverity, ServerName, ProcName etc
+ *
+ * This enables client to print out extra information about the message.
+ * Like: In what procedure was the message produced.
+ */
+public class SQLServerWarning extends SQLWarning {
+ private static final long serialVersionUID = -5212432397705929142L;
+
+ /** SQL server error */
+ private SQLServerError sqlServerError;
+
+ /*
+ * Create a SQLWarning from an SQLServerError object
+ */
+ public SQLServerWarning(SQLServerError sqlServerError) {
+ super(sqlServerError.getErrorMessage(), SQLServerException.generateStateCode(null,
+ sqlServerError.getErrorNumber(), sqlServerError.getErrorState()), sqlServerError.getErrorNumber(),
+ null);
+
+ this.sqlServerError = sqlServerError;
+ }
+
+ /**
+ * Returns SQLServerError object containing detailed info about exception as received from SQL Server. This API
+ * returns null if no server error has occurred.
+ *
+ * @return SQLServerError
+ */
+ public SQLServerError getSQLServerError() {
+ return sqlServerError;
+ }
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java
index 6d82bf836..5c451b22b 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java
@@ -5,7 +5,6 @@
package com.microsoft.sqlserver.jdbc;
-import java.net.SocketException;
import java.sql.CallableStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
@@ -25,8 +24,6 @@
import javax.transaction.xa.XAResource;
import javax.transaction.xa.Xid;
-import com.microsoft.sqlserver.jdbc.SQLServerError.TransientError;
-
/**
* Implements Transaction id used to recover transactions.
@@ -754,27 +751,13 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X
}
}
}
- } catch (SQLTimeoutException ex) {
+ } catch (SQLTimeoutException | SQLServerException ex) {
if (xaLogger.isLoggable(Level.FINER))
xaLogger.finer(toString() + " exception:" + ex);
XAException e = new XAException(ex.toString());
e.errorCode = XAException.XAER_RMFAIL;
throw e;
- } catch (SQLServerException ex) {
- if (xaLogger.isLoggable(Level.FINER))
- xaLogger.finer(toString() + " exception:" + ex);
-
- if (ex.getMessage().equals(SQLServerException.getErrString("R_noServerResponse"))
- || TransientError.isTransientError(ex.getSQLServerError()) || isResourceManagerFailure(ex)) {
- XAException e = new XAException(ex.toString());
- e.errorCode = XAException.XAER_RMFAIL;
- throw e;
- }
-
- XAException e = new XAException(ex.toString());
- e.errorCode = XAException.XAER_RMERR;
- throw e;
}
if (xaLogger.isLoggable(Level.FINER))
@@ -945,68 +928,4 @@ private static int nextResourceID() {
return baseResourceID.incrementAndGet();
}
- private enum ResourceManagerFailure {
- CONN_RESET("Connection reset"),
- CONN_RESET_BY_PEER("Connection reset by peer"),
- CONN_TIMEOUT("Connection timed out"),
- CONN_RESILIENCY_CLIENT_UNRECOVERABLE(SQLServerException.getErrString("R_crClientUnrecoverable"));
-
- private final String errString;
-
- ResourceManagerFailure(String errString) {
- this.errString = errString;
- }
-
- @Override
- public String toString() {
- return errString;
- }
-
- static ResourceManagerFailure fromString(String errString) {
- for (ResourceManagerFailure resourceManagerFailure : ResourceManagerFailure.values()) {
- if (errString.equalsIgnoreCase(resourceManagerFailure.toString())) {
- return resourceManagerFailure;
- }
- }
- return null;
- }
- }
-
- /**
- * Check if the root exception of the throwable should be a XAER_RMFAIL exception
- *
- * @param throwable
- * The exception to check if the root cause should be a XAER_RMFAIL
- *
- * @return True if XAER_RMFAIL, otherwise false
- */
- private boolean isResourceManagerFailure(Throwable throwable) {
- Throwable root = Util.getRootCause(throwable);
-
- if (null == root) {
- return false;
- }
-
- if (xaLogger.isLoggable(Level.FINE)) {
- xaLogger.fine(toString() + " Resource manager failure root exception: " + root);
- }
-
- ResourceManagerFailure err = ResourceManagerFailure.fromString(root.getMessage());
-
- if (null == err) {
- return false;
- }
-
- // Add as needed here for future XAER_RMFAIL exceptions
- switch (err) {
- case CONN_RESET:
- case CONN_RESET_BY_PEER:
- case CONN_TIMEOUT:
- case CONN_RESILIENCY_CLIENT_UNRECOVERABLE:
- return true;
- default:
- return false;
- }
- }
-
}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/StreamInfo.java b/src/main/java/com/microsoft/sqlserver/jdbc/StreamInfo.java
deleted file mode 100644
index 5b4cb571f..000000000
--- a/src/main/java/com/microsoft/sqlserver/jdbc/StreamInfo.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Microsoft JDBC Driver for SQL Server Copyright(c) Microsoft Corporation All rights reserved. This program is made
- * available under the terms of the MIT License. See the LICENSE file in the project root for more information.
- */
-
-package com.microsoft.sqlserver.jdbc;
-
-final class StreamInfo extends StreamPacket {
- final SQLServerError msg = new SQLServerError();
-
- StreamInfo() {
- super(TDS.TDS_MSG);
- }
-
- void setFromTDS(TDSReader tdsReader) throws SQLServerException {
- if (TDS.TDS_MSG != tdsReader.readUnsignedByte())
- assert false;
- msg.setContentsFromTDS(tdsReader);
- }
-}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Util.java b/src/main/java/com/microsoft/sqlserver/jdbc/Util.java
index 70b9c9aa8..61bda22b7 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/Util.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/Util.java
@@ -13,8 +13,6 @@
import java.net.UnknownHostException;
import java.text.DecimalFormat;
import java.text.MessageFormat;
-import java.util.List;
-import java.util.ArrayList;
import java.util.Date;
import java.util.Locale;
import java.util.Properties;
@@ -1046,23 +1044,6 @@ static char[] bytesToChars(byte[] bytes) {
}
return chars;
}
-
- /**
- * @param throwable
- * The exception to find root cause for.
- *
- * @return The root cause of the exception, otherwise null if null throwable input
- */
- static Throwable getRootCause(Throwable throwable) {
- final List list = new ArrayList<>();
-
- while (throwable != null && !list.contains(throwable)) {
- list.add(throwable);
- throwable = throwable.getCause();
- }
-
- return list.isEmpty() ? null : list.get(list.size() - 1);
- }
}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java
index c03d67eb0..3c08a80cd 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java
@@ -99,6 +99,8 @@ abstract class DTVExecuteOp {
abstract void execute(DTV dtv, Boolean booleanValue) throws SQLServerException;
+ abstract void execute(DTV dtv, UUID uuidValue) throws SQLServerException;
+
abstract void execute(DTV dtv, byte[] byteArrayValue) throws SQLServerException;
abstract void execute(DTV dtv, Blob blobValue) throws SQLServerException;
@@ -291,7 +293,11 @@ final class SendByRPCOp extends DTVExecuteOp {
}
void execute(DTV dtv, String strValue) throws SQLServerException {
- tdsWriter.writeRPCStringUnicode(name, strValue, isOutParam, collation, dtv.isNonPLP);
+ if (dtv.getJdbcType() == JDBCType.GUID) {
+ tdsWriter.writeRPCUUID(name, UUID.fromString(strValue), isOutParam);
+ } else {
+ tdsWriter.writeRPCStringUnicode(name, strValue, isOutParam, collation, dtv.isNonPLP);
+ }
}
void execute(DTV dtv, Clob clobValue) throws SQLServerException {
@@ -1126,6 +1132,10 @@ void execute(DTV dtv, Boolean booleanValue) throws SQLServerException {
tdsWriter.writeRPCBit(name, booleanValue, isOutParam);
}
+ void execute(DTV dtv, UUID uuidValue) throws SQLServerException {
+ tdsWriter.writeRPCUUID(name, uuidValue, isOutParam);
+ }
+
void execute(DTV dtv, byte[] byteArrayValue) throws SQLServerException {
if (null != cryptoMeta) {
tdsWriter.writeRPCNameValType(name, isOutParam, TDSType.BIGVARBINARY);
@@ -1537,10 +1547,16 @@ final void executeOp(DTVExecuteOp op) throws SQLServerException {
case VARCHAR:
case LONGVARCHAR:
case CLOB:
- case GUID:
op.execute(this, (byte[]) null);
break;
+ case GUID:
+ if (null != cryptoMeta)
+ op.execute(this, (byte[]) null);
+ else
+ op.execute(this, (UUID) null);
+ break;
+
case TINYINT:
if (null != cryptoMeta)
op.execute(this, (byte[]) null);
@@ -1619,7 +1635,7 @@ final void executeOp(DTVExecuteOp op) throws SQLServerException {
byte[] bArray = Util.asGuidByteArray((UUID) value);
op.execute(this, bArray);
} else {
- op.execute(this, String.valueOf(value));
+ op.execute(this, UUID.fromString(String.valueOf(value)));
}
} else if (JDBCType.SQL_VARIANT == jdbcType) {
op.execute(this, String.valueOf(value));
@@ -2194,6 +2210,8 @@ void execute(DTV dtv, Short shortValue) throws SQLServerException {}
void execute(DTV dtv, Boolean booleanValue) throws SQLServerException {}
+ void execute(DTV dtv, UUID uuidValue) throws SQLServerException {}
+
void execute(DTV dtv, byte[] byteArrayValue) throws SQLServerException {}
void execute(DTV dtv, Blob blobValue) throws SQLServerException {
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java
index c18d61a0c..90eebb8df 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java
@@ -197,6 +197,14 @@ final SQLServerError getDatabaseError() {
return databaseError;
}
+ public void addDatabaseError(SQLServerError databaseError) {
+ if (this.databaseError == null) {
+ this.databaseError = databaseError;
+ } else {
+ this.databaseError.addError(databaseError);
+ }
+ }
+
TDSTokenHandler(String logContext) {
this.logContext = logContext;
}
@@ -258,13 +266,29 @@ boolean onDone(TDSReader tdsReader) throws SQLServerException {
}
boolean onError(TDSReader tdsReader) throws SQLServerException {
- if (null == databaseError) {
- databaseError = new SQLServerError();
- databaseError.setFromTDS(tdsReader);
- } else {
- (new SQLServerError()).setFromTDS(tdsReader);
+ SQLServerError tmpDatabaseError = new SQLServerError();
+ tmpDatabaseError.setFromTDS(tdsReader);
+
+ ISQLServerMessageHandler msgHandler = tdsReader.getConnection().getServerMessageHandler();
+ if (msgHandler != null) {
+ // Let the message handler decide if the error should be unchanged/down-graded or ignored
+ ISQLServerMessage srvMessage = msgHandler.messageHandler(tmpDatabaseError);
+
+ // Ignored
+ if (srvMessage == null) {
+ return true;
+ }
+
+ // Down-graded to a SQLWarning
+ if (srvMessage.isInfoMessage()) {
+ tdsReader.getConnection().addWarning(srvMessage);
+ return true;
+ }
}
+ // set/add the database error
+ addDatabaseError(tmpDatabaseError);
+
return true;
}
diff --git a/src/main/java/microsoft/sql/DateTimeOffset.java b/src/main/java/microsoft/sql/DateTimeOffset.java
index e2fcc8409..bf9e95c7b 100644
--- a/src/main/java/microsoft/sql/DateTimeOffset.java
+++ b/src/main/java/microsoft/sql/DateTimeOffset.java
@@ -72,6 +72,22 @@ private DateTimeOffset(java.sql.Timestamp timestamp, int minutesOffset) {
assert 0 == this.utcMillis % 1000L : "utcMillis: " + this.utcMillis;
}
+ /**
+ * Constructs a DateTimeOffset from an existing java.time.OffsetDateTime
+ * DateTimeOffset represents values to 100 nanosecond precision. If the java.time.OffsetDateTime instance
+ * represents a value that is more precise, the value is rounded to the nearest multiple of 100 nanoseconds. Values
+ * within 50 nanoseconds of the next second are rounded up to the next second.
+ *
+ * @param offsetDateTime
+ * A java.time.OffsetDateTime value
+ */
+ private DateTimeOffset(java.time.OffsetDateTime offsetDateTime) {
+ int hundredNanos = ((offsetDateTime.getNano() + 50) / 100);
+ this.utcMillis = (offsetDateTime.toEpochSecond() * 1000) + (hundredNanos / HUNDRED_NANOS_PER_SECOND * 1000);
+ this.nanos = 100 * (hundredNanos % HUNDRED_NANOS_PER_SECOND);
+ this.minutesOffset = offsetDateTime.getOffset().getTotalSeconds() / 60;
+ }
+
/**
* Converts a java.sql.Timestamp value with an integer offset to the equivalent DateTimeOffset value
*
@@ -105,6 +121,20 @@ public static DateTimeOffset valueOf(java.sql.Timestamp timestamp, Calendar cale
(calendar.get(Calendar.ZONE_OFFSET) + calendar.get(Calendar.DST_OFFSET)) / (60 * 1000));
}
+ /**
+ * Directly converts a {@link java.time.OffsetDateTime} value to an equivalent {@link DateTimeOffset} value
+ * DateTimeOffset represents values to 100 nanosecond precision. If the java.time.OffsetDateTime instance
+ * represents a value that is more precise, the value is rounded to the nearest multiple of 100 nanoseconds. Values
+ * within 50 nanoseconds of the next second are rounded up to the next second.
+ *
+ * @param offsetDateTime
+ * A java.time.OffsetDateTime value
+ * @return The DateTimeOffset value of the input java.time.OffsetDateTime
+ */
+ public static DateTimeOffset valueOf(java.time.OffsetDateTime offsetDateTime) {
+ return new DateTimeOffset(offsetDateTime);
+ }
+
/** formatted value */
private String formattedValue = null;
diff --git a/src/samples/adaptive/pom.xml b/src/samples/adaptive/pom.xml
index 96e2be9a0..f1ce6c7d4 100644
--- a/src/samples/adaptive/pom.xml
+++ b/src/samples/adaptive/pom.xml
@@ -15,7 +15,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/alwaysencrypted/pom.xml b/src/samples/alwaysencrypted/pom.xml
index 294d4b419..b26a55e0c 100644
--- a/src/samples/alwaysencrypted/pom.xml
+++ b/src/samples/alwaysencrypted/pom.xml
@@ -15,7 +15,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/azureactivedirectoryauthentication/pom.xml b/src/samples/azureactivedirectoryauthentication/pom.xml
index 518da61a7..d704cd96f 100644
--- a/src/samples/azureactivedirectoryauthentication/pom.xml
+++ b/src/samples/azureactivedirectoryauthentication/pom.xml
@@ -14,7 +14,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/connections/pom.xml b/src/samples/connections/pom.xml
index 209697c3c..7bc8fd947 100644
--- a/src/samples/connections/pom.xml
+++ b/src/samples/connections/pom.xml
@@ -14,7 +14,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/constrained/pom.xml b/src/samples/constrained/pom.xml
index c2cc82ae6..9518b2c53 100644
--- a/src/samples/constrained/pom.xml
+++ b/src/samples/constrained/pom.xml
@@ -16,7 +16,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/dataclassification/pom.xml b/src/samples/dataclassification/pom.xml
index 74ba22bb0..f4f9f7ce4 100644
--- a/src/samples/dataclassification/pom.xml
+++ b/src/samples/dataclassification/pom.xml
@@ -16,7 +16,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/datatypes/pom.xml b/src/samples/datatypes/pom.xml
index 148d73819..264dbb745 100644
--- a/src/samples/datatypes/pom.xml
+++ b/src/samples/datatypes/pom.xml
@@ -15,7 +15,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/resultsets/pom.xml b/src/samples/resultsets/pom.xml
index d466f5e75..979b36010 100644
--- a/src/samples/resultsets/pom.xml
+++ b/src/samples/resultsets/pom.xml
@@ -14,7 +14,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/samples/sparse/pom.xml b/src/samples/sparse/pom.xml
index e6e3dd4de..9df693086 100644
--- a/src/samples/sparse/pom.xml
+++ b/src/samples/sparse/pom.xml
@@ -14,7 +14,7 @@
com.microsoft.sqlserver
mssql-jdbc
- 12.4.0.jre11
+ 12.6.0.jre11
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java
index 04fedc1ff..12eea46cf 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java
@@ -53,6 +53,7 @@ public class SQLServerConnectionTest extends AbstractTest {
// If no retry is done, the function should at least exit in 5 seconds
static int threshHoldForNoRetryInMilliseconds = 5000;
static int loginTimeOutInSeconds = 10;
+ static String tnirHost = getConfiguredProperty("tnirHost");
String randomServer = RandomUtil.getIdentifier("Server");
@@ -209,7 +210,8 @@ public void testDataSource() throws SQLServerException {
assertEquals(booleanPropValue, ds.getUseFlexibleCallableStatements(),
TestResource.getResource("R_valuesAreDifferent"));
ds.setCalcBigDecimalPrecision(booleanPropValue);
- assertEquals(booleanPropValue, ds.getCalcBigDecimalPrecision(), TestResource.getResource("R_valuesAreDifferent"));
+ assertEquals(booleanPropValue, ds.getCalcBigDecimalPrecision(),
+ TestResource.getResource("R_valuesAreDifferent"));
ds.setServerCertificate(stringPropValue);
assertEquals(stringPropValue, ds.getServerCertificate(), TestResource.getResource("R_valuesAreDifferent"));
@@ -488,6 +490,44 @@ public void testConnectCountInLoginAndCorrectRetryCount() {
}
}
+ // Test connect retry 0 but should still connect to TNIR
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ @Tag(Constants.xAzureSQLDB)
+ @Tag(Constants.reqExternalSetup)
+ public void testConnectTnir() {
+ org.junit.Assume.assumeTrue(isWindows);
+
+ // no retries but should connect to TNIR (this assumes host is defined in host file
+ try (Connection con = PrepUtil
+ .getConnection(connectionString + ";transparentNetworkIPResolution=true;connectRetryCount=0;serverName="
+ + tnirHost);) {} catch (Exception e) {
+ fail(e.getMessage());
+ }
+ }
+
+ // Test connect retry 0 and TNIR disabled
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ @Tag(Constants.xAzureSQLDB)
+ @Tag(Constants.reqExternalSetup)
+ public void testConnectNoTnir() {
+ org.junit.Assume.assumeTrue(isWindows);
+
+ // no retries no TNIR should fail even tho host is defined in host file
+ try (Connection con = PrepUtil.getConnection(connectionString
+ + ";transparentNetworkIPResolution=false;connectRetryCount=0;serverName=" + tnirHost);) {
+ assertTrue(con == null, TestResource.getResource("R_shouldNotConnect"));
+ } catch (Exception e) {
+ assertTrue(e.getMessage().matches(TestUtils.formatErrorMsg("R_tcpipConnectionFailed"))
+ || ((isSqlAzure() || isSqlAzureDW())
+ ? e.getMessage().contains(
+ TestResource.getResource("R_connectTimedOut"))
+ : false),
+ e.getMessage());
+ }
+ }
+
@Test
@Tag(Constants.xAzureSQLDW)
@Tag(Constants.xAzureSQLDB)
@@ -980,7 +1020,9 @@ public void run() {
ds.setURL(connectionString);
ds.setServerName("invalidServerName" + UUID.randomUUID());
- ds.setLoginTimeout(5);
+ ds.setLoginTimeout(30);
+ ds.setConnectRetryCount(3);
+ ds.setConnectRetryInterval(10);
try (Connection con = ds.getConnection()) {} catch (SQLException e) {}
}
};
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java
index e14bb671a..b3e854fd1 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java
@@ -63,6 +63,10 @@ protected Object[][] getContents() {
{"R_ConnectionURLNull", "The connection URL is null."},
{"R_connectionIsNotClosed", "The connection is not closed."},
{"R_invalidExceptionMessage", "Invalid exception message"},
+ {"R_invalidClientSecret", "AADSTS7000215: Invalid client secret provided"},
+ {"R_invalidCertFields",
+ "Error reading certificate, please verify the location of the certificate.signed fields invalid"},
+ {"R_invalidAADAuth", "Failed to authenticate the user {0} in Active Directory (Authentication={1})"},
{"R_failedValidate", "failed to validate values in $0} "}, {"R_tableNotDropped", "table not dropped. "},
{"R_connectionReset", "Connection reset"}, {"R_unknownException", "Unknown exception"},
{"R_deadConnection", "Dead connection should be invalid"},
@@ -212,5 +216,7 @@ protected Object[][] getContents() {
{"R_failedFedauth", "Failed to acquire fedauth token: "},
{"R_noLoginModulesConfiguredForJdbcDriver",
"javax.security.auth.login.LoginException (No LoginModules configured for SQLJDBCDriver)"},
- {"R_unexpectedThreadCount", "Thread count is higher than expected."}};
+ {"R_unexpectedThreadCount", "Thread count is higher than expected."},
+ {"R_expectedClassDoesNotMatchActualClass",
+ "Expected column class {0} does not match actual column class {1} for column {2}."}};
}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestUtils.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestUtils.java
index 2f20821a1..4283a80f5 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/TestUtils.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestUtils.java
@@ -237,6 +237,15 @@ public static boolean isAzureMI(Connection con) {
return ((SQLServerConnection) con).isAzureMI();
}
+ /**
+ * Checks if connection is established to Azure Synapse OnDemand server
+ *
+ */
+ public static boolean isAzureSynapseOnDemand(Connection con) {
+ isAzure(con);
+ return ((SQLServerConnection) con).isAzureSynapseOnDemandEndpoint();
+ }
+
/**
* Checks if connection is established to server that supports AEv2.
*
@@ -410,6 +419,18 @@ public static void dropTableIfExists(String tableName, java.sql.Statement stmt)
dropObjectIfExists(tableName, "U", stmt);
}
+ public static void dropTableWithSchemaIfExists(String tableNameWithSchema,
+ java.sql.Statement stmt) throws SQLException {
+ stmt.execute(
+ "IF OBJECT_ID('" + tableNameWithSchema + "', 'U') IS NOT NULL DROP TABLE " + tableNameWithSchema + ";");
+ }
+
+ public static void dropProcedureWithSchemaIfExists(String procedureWithSchema,
+ java.sql.Statement stmt) throws SQLException {
+ stmt.execute("IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'" + procedureWithSchema
+ + "') AND type in (N'P', N'PC')) DROP PROCEDURE " + procedureWithSchema + ";");
+ }
+
/**
* Deletes the contents of a table.
*
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyAllTypesTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyAllTypesTest.java
index 660406ce5..a78e53161 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyAllTypesTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyAllTypesTest.java
@@ -4,13 +4,33 @@
*/
package com.microsoft.sqlserver.jdbc.bulkCopy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.sql.Types;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import javax.sql.RowSetMetaData;
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.RowSetMetaDataImpl;
+import javax.sql.rowset.RowSetProvider;
+
+import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
@@ -20,8 +40,10 @@
import com.microsoft.sqlserver.jdbc.ComparisonUtil;
import com.microsoft.sqlserver.jdbc.RandomData;
import com.microsoft.sqlserver.jdbc.RandomUtil;
+import com.microsoft.sqlserver.jdbc.SQLServerBulkCSVFileRecord;
import com.microsoft.sqlserver.jdbc.SQLServerBulkCopy;
import com.microsoft.sqlserver.jdbc.SQLServerBulkCopyOptions;
+import com.microsoft.sqlserver.jdbc.TestResource;
import com.microsoft.sqlserver.jdbc.TestUtils;
import com.microsoft.sqlserver.testframework.AbstractSQLGenerator;
import com.microsoft.sqlserver.testframework.AbstractTest;
@@ -31,20 +53,6 @@
import com.microsoft.sqlserver.testframework.DBTable;
import com.microsoft.sqlserver.testframework.PrepUtil;
-import javax.sql.RowSetMetaData;
-import javax.sql.rowset.CachedRowSet;
-import javax.sql.rowset.RowSetFactory;
-import javax.sql.rowset.RowSetMetaDataImpl;
-import javax.sql.rowset.RowSetProvider;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
@RunWith(JUnitPlatform.class)
public class BulkCopyAllTypesTest extends AbstractTest {
@@ -55,12 +63,26 @@ public class BulkCopyAllTypesTest extends AbstractTest {
@BeforeAll
public static void setupTests() throws Exception {
setConnection();
+ setupMoneyTests();
+ }
+
+ public static void setupMoneyTests() throws SQLException {
+ try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+ TestUtils.dropTableIfExists(destTableName, stmt);
+ TestUtils.dropTableIfExists(destTableName2, stmt);
+
+ String table = "create table " + destTableName + " (c1 smallmoney, c2 money)";
+ stmt.execute(table);
+ table = "create table " + destTableName2 + " (c1 smallmoney, c2 money)";
+ stmt.execute(table);
+ }
}
/**
* Test TVP with result set
- *
+ *
* @throws SQLException
+ * an exception
*/
@Test
@Tag(Constants.xAzureSQLDW)
@@ -127,6 +149,12 @@ private void terminateVariation() throws SQLException {
private static final String dateTimeTestTable = AbstractSQLGenerator
.escapeIdentifier(RandomUtil.getIdentifier("bulkCopyTimestampTest"));
+ /**
+ * Test money/smallmoney with BulkCopy
+ *
+ * @throws SQLException
+ * an exception
+ */
@Test
public void testBulkCopyTimestamp() throws SQLException {
List timeStamps = new ArrayList<>();
@@ -185,4 +213,74 @@ public void testBulkCopyTimestamp() throws SQLException {
private static long getTime(Timestamp time) {
return (3 * time.getTime() + 5) / 10;
}
+
+ static String encoding = Constants.UTF8;
+ static String delimiter = Constants.COMMA;
+ static String destTableName = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("moneyBulkCopyDest"));
+ static String destTableName2 = AbstractSQLGenerator.escapeIdentifier(RandomUtil.getIdentifier("moneyBulkCopyDest"));
+
+ @Test
+ public void testMoneyWithBulkCopy() throws Exception {
+ try (Connection conn = PrepUtil.getConnection(connectionString)) {
+ testMoneyLimits(Constants.MIN_VALUE_SMALLMONEY - 1, Constants.MAX_VALUE_MONEY - 1, conn); // 1 less than SMALLMONEY MIN
+ testMoneyLimits(Constants.MAX_VALUE_SMALLMONEY + 1, Constants.MAX_VALUE_MONEY - 1, conn); // 1 more than SMALLMONEY MAX
+ testMoneyLimits(Constants.MAX_VALUE_SMALLMONEY - 1, Constants.MIN_VALUE_MONEY - 1, conn); // 1 less than MONEY MIN
+ testMoneyLimits(Constants.MAX_VALUE_SMALLMONEY - 1, Constants.MAX_VALUE_MONEY + 1, conn); // 1 more than MONEY MAX
+ }
+ }
+
+ private void testMoneyLimits(double smallMoneyVal, double moneyVal, Connection conn) throws Exception {
+ SQLServerBulkCSVFileRecord fileRecord = constructFileRecord(smallMoneyVal, moneyVal);
+
+ try {
+ testMoneyWithBulkCopy(conn, fileRecord);
+ fail(TestResource.getResource("R_expectedExceptionNotThrown"));
+ } catch (SQLException e) {
+ assertTrue(e.getMessage().matches(TestUtils.formatErrorMsg("R_valueOutOfRange")), e.getMessage());
+ }
+ }
+
+ private SQLServerBulkCSVFileRecord constructFileRecord(double smallMoneyVal, double moneyVal) throws Exception {
+ Map data = new HashMap();
+ data.put(smallMoneyVal, moneyVal);
+
+ StringBuilder stringBuilder = new StringBuilder();
+ stringBuilder.append("smallmoneycol, moneycol\n");
+
+ for (Map.Entry entry : data.entrySet()) {
+ stringBuilder.append(String.format("%s,%s\n", entry.getKey(), entry.getValue()));
+ }
+
+ byte[] bytes = stringBuilder.toString().getBytes(StandardCharsets.UTF_8);
+ SQLServerBulkCSVFileRecord fileRecord;
+ try (InputStream inputStream = new ByteArrayInputStream(bytes)) {
+ fileRecord = new SQLServerBulkCSVFileRecord(inputStream, encoding, delimiter, true);
+ }
+ return fileRecord;
+ }
+
+ private void testMoneyWithBulkCopy(Connection conn, SQLServerBulkCSVFileRecord fileRecord) throws SQLException {
+ try (SQLServerBulkCopy bulkCopy = new SQLServerBulkCopy(conn); Statement stmt = conn.createStatement()) {
+
+ fileRecord.addColumnMetadata(1, "c1", java.sql.Types.DECIMAL, 10, 4); // with smallmoney
+ fileRecord.addColumnMetadata(2, "c2", java.sql.Types.DECIMAL, 19, 4); // with money
+
+ bulkCopy.setDestinationTableName(destTableName);
+ bulkCopy.writeToServer(fileRecord);
+
+ try (ResultSet rs = stmt.executeQuery("select * FROM " + destTableName + " order by c1");
+ SQLServerBulkCopy bcOperation = new SQLServerBulkCopy(conn)) {
+ bcOperation.setDestinationTableName(destTableName2);
+ bcOperation.writeToServer(rs);
+ }
+ }
+ }
+
+ @AfterAll
+ public static void cleanUp() throws Exception {
+ try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+ TestUtils.dropTableIfExists(destTableName, stmt);
+ TestUtils.dropTableIfExists(destTableName2, stmt);
+ }
+ }
}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java
index 48e28b712..ac7fb02f5 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java
@@ -153,7 +153,7 @@ public void testEscapeColumnDelimitersCSV() throws Exception {
/*
* The list below is the copy of inputFileDelimiterEsc ape with quotes removed.
*/
- String[][] expectedEscaped = new String[11][4];
+ String[][] expectedEscaped = new String[12][4];
expectedEscaped[0] = new String[] {"test", " test\"", "no@split", " testNoQuote", ""};
expectedEscaped[1] = new String[] {null, null, null, null, ""};
expectedEscaped[2] = new String[] {"\"", "test\"test", "test@\" test", null, ""};
@@ -166,6 +166,8 @@ public void testEscapeColumnDelimitersCSV() throws Exception {
expectedEscaped[8] = new String[] {"1997", "Ford", "E350", "Super@ \"luxurious\" truck", ""};
expectedEscaped[9] = new String[] {"1997", "Ford", "E350", "E63", ""};
expectedEscaped[10] = new String[] {"1997", "Ford", "E350", " Super luxurious truck ", ""};
+ expectedEscaped[11] = new String[] {"1997", "F\r\no\r\nr\r\nd", "E350", "\"Super\" \"luxurious\" \"truck\"",
+ ""};
try (Connection con = getConnection(); Statement stmt = con.createStatement();
SQLServerBulkCopy bulkCopy = new SQLServerBulkCopy(con);
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java
index 3a480548d..5a502dab3 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java
@@ -81,7 +81,7 @@ public class CallableStatementTest extends AbstractTest {
/**
* Setup before test
- *
+ *
* @throws SQLException
*/
@BeforeAll
@@ -201,7 +201,7 @@ public void testCallableStatementSpPrepare() throws SQLException {
/**
* Tests CallableStatement.getString() with uniqueidentifier parameter
- *
+ *
* @throws SQLException
*/
@Test
@@ -226,7 +226,7 @@ public void getStringGUIDTest() throws SQLException {
/**
* test for setNull(index, varchar) to behave as setNull(index, nvarchar) when SendStringParametersAsUnicode is true
- *
+ *
* @throws SQLException
*/
@Test
@@ -302,7 +302,7 @@ public void testGetObjectAsLocalDateTime() throws SQLException {
/**
* Tests getObject(n, java.time.OffsetDateTime.class) and getObject(n, java.time.OffsetTime.class).
- *
+ *
* @throws SQLException
*/
@Test
@@ -332,7 +332,7 @@ public void testGetObjectAsOffsetDateTime() throws SQLException {
/**
* recognize parameter names with and without leading '@'
- *
+ *
* @throws SQLException
*/
@Test
@@ -1067,9 +1067,158 @@ public void testRegisteringOutputByIndexandAcquiringOutputParamByName() throws S
}
}
+ @Test
+ public void testExecuteSystemStoredProcedureNamedParametersAndIndexedParameterNoResultset() throws SQLException {
+ String call0 = "EXEC sp_getapplock @Resource=?, @LockTimeout='0', @LockMode='Exclusive', @LockOwner='Session'";
+ String call1 = "\rEXEC\r\rsp_getapplock @Resource=?, @LockTimeout='0', @LockMode='Exclusive', @LockOwner='Session'";
+ String call2 = " EXEC sp_getapplock @Resource=?, @LockTimeout='0', @LockMode='Exclusive', @LockOwner='Session'";
+ String call3 = "\tEXEC\t\t\tsp_getapplock @Resource=?, @LockTimeout='0', @LockMode='Exclusive', @LockOwner='Session'";
+
+ try (CallableStatement cstmt0 = connection.prepareCall(call0);
+ CallableStatement cstmt1 = connection.prepareCall(call1);
+ CallableStatement cstmt2 = connection.prepareCall(call2);
+ CallableStatement cstmt3 = connection.prepareCall(call3);) {
+ cstmt0.setString(1, "Resource-" + UUID.randomUUID());
+ cstmt0.execute();
+
+ cstmt1.setString(1, "Resource-" + UUID.randomUUID());
+ cstmt1.execute();
+
+ cstmt2.setString(1, "Resource-" + UUID.randomUUID());
+ cstmt2.execute();
+
+ cstmt3.setString(1, "Resource-" + UUID.randomUUID());
+ cstmt3.execute();
+ }
+ }
+
+ @Test
+ public void testExecSystemStoredProcedureNamedParametersAndIndexedParameterResultSet() throws SQLException {
+ String call = "exec sp_sproc_columns_100 ?, @ODBCVer=3, @fUsePattern=0";
+
+ try (CallableStatement cstmt = connection.prepareCall(call)) {
+ cstmt.setString(1, "sp_getapplock");
+
+ try (ResultSet rs = cstmt.executeQuery()) {
+ while (rs.next()) {
+ assertTrue(TestResource.getResource("R_resultSetEmpty"), !rs.getString(4).isEmpty());
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testExecSystemStoredProcedureNoIndexedParametersResultSet() throws SQLException {
+ String call = "execute sp_sproc_columns_100 sp_getapplock, @ODBCVer=3, @fUsePattern=0";
+
+ try (CallableStatement cstmt = connection.prepareCall(call); ResultSet rs = cstmt.executeQuery()) {
+ while (rs.next()) {
+ assertTrue(TestResource.getResource("R_resultSetEmpty"), !rs.getString(4).isEmpty());
+ }
+ }
+ }
+
+ @Test
+ public void testExecDocumentedSystemStoredProceduresIndexedParameters() throws SQLException {
+ String serverName;
+ String testTableName = "testTable";
+ Integer integer = new Integer(1);
+
+ try (Statement stmt = connection.createStatement(); ResultSet rs = stmt.executeQuery("SELECT @@SERVERNAME")) {
+ rs.next();
+ serverName = rs.getString(1);
+ }
+
+ String[] sprocs = {"EXEC sp_column_privileges ?", "exec sp_catalogs ?", "execute sp_column_privileges ?",
+ "EXEC sp_column_privileges_ex ?", "EXECUTE sp_columns ?", "execute sp_datatype_info ?",
+ "EXEC sp_sproc_columns ?", "EXECUTE sp_server_info ?", "exec sp_special_columns ?",
+ "execute sp_statistics ?", "EXEC sp_table_privileges ?", "exec sp_tables ?"};
+
+ Object[] params = {testTableName, serverName, testTableName, serverName, testTableName, integer,
+ "sp_column_privileges", integer, testTableName, testTableName, testTableName, testTableName};
+
+ int paramIndex = 0;
+
+ for (String sproc : sprocs) {
+ try (CallableStatement cstmt = connection.prepareCall(sproc)) {
+ cstmt.setObject(1, params[paramIndex]);
+ cstmt.execute();
+ paramIndex++;
+ } catch (Exception e) {
+ fail("Failed executing '" + sproc + "' with indexed parameter '" + params[paramIndex]);
+ }
+ }
+ }
+
+ @Test
+ @Tag(Constants.reqExternalSetup)
+ @Tag(Constants.xAzureSQLDB)
+ @Tag(Constants.xAzureSQLDW)
+ @Tag(Constants.xAzureSQLMI)
+ public void testFourPartSyntaxCallEscapeSyntax() throws SQLException {
+ String table = "serverList";
+
+ try (Statement stmt = connection.createStatement()) {
+ stmt.execute("IF OBJECT_ID(N'" + table + "') IS NOT NULL DROP TABLE " + table);
+ stmt.execute("CREATE TABLE " + table
+ + " (serverName varchar(100),network varchar(100),serverStatus varchar(4000), id int, collation varchar(100), connectTimeout int, queryTimeout int)");
+ stmt.execute("INSERT " + table + " EXEC sp_helpserver");
+
+ ResultSet rs = stmt
+ .executeQuery("SELECT COUNT(*) FROM " + table + " WHERE serverName = N'" + linkedServer + "'");
+ rs.next();
+
+ if (rs.getInt(1) == 1) {
+ stmt.execute("EXEC sp_dropserver @server='" + linkedServer + "';");
+ }
+
+ stmt.execute("EXEC sp_addlinkedserver @server='" + linkedServer + "';");
+ stmt.execute("EXEC sp_addlinkedsrvlogin @rmtsrvname=N'" + linkedServer + "', @rmtuser=N'" + remoteUser
+ + "', @rmtpassword=N'" + remotePassword + "'");
+ stmt.execute("EXEC sp_serveroption '" + linkedServer + "', 'rpc', true;");
+ stmt.execute("EXEC sp_serveroption '" + linkedServer + "', 'rpc out', true;");
+ }
+
+ SQLServerDataSource ds = new SQLServerDataSource();
+ ds.setServerName(linkedServer);
+ ds.setUser(remoteUser);
+ ds.setPassword(remotePassword);
+ ds.setEncrypt(false);
+ ds.setTrustServerCertificate(true);
+
+ try (Connection linkedServerConnection = ds.getConnection();
+ Statement stmt = linkedServerConnection.createStatement()) {
+ stmt.execute(
+ "create or alter procedure dbo.TestAdd(@Num1 int, @Num2 int, @Result int output) as begin set @Result = @Num1 + @Num2; end;");
+ }
+
+ try (CallableStatement cstmt = connection
+ .prepareCall("{call [" + linkedServer + "].master.dbo.TestAdd(?,?,?)}")) {
+ int sum = 11;
+ int param0 = 1;
+ int param1 = 10;
+ cstmt.setInt(1, param0);
+ cstmt.setInt(2, param1);
+ cstmt.registerOutParameter(3, Types.INTEGER);
+ cstmt.execute();
+ assertEquals(sum, cstmt.getInt(3));
+ }
+
+ try (CallableStatement cstmt = connection.prepareCall("exec [" + linkedServer + "].master.dbo.TestAdd ?,?,?")) {
+ int sum = 11;
+ int param0 = 1;
+ int param1 = 10;
+ cstmt.setInt(1, param0);
+ cstmt.setInt(2, param1);
+ cstmt.registerOutParameter(3, Types.INTEGER);
+ cstmt.execute();
+ assertEquals(sum, cstmt.getInt(3));
+ }
+ }
+
/**
* Cleanup after test
- *
+ *
* @throws SQLException
*/
@AfterAll
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java
index a23d6151f..d99d846ef 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java
@@ -23,11 +23,10 @@
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
-import org.junit.platform.runner.JUnitPlatform;
-import org.junit.runner.RunWith;
import com.microsoft.sqlserver.jdbc.ISQLServerConnection;
import com.microsoft.sqlserver.jdbc.RandomUtil;
+import com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource;
import com.microsoft.sqlserver.jdbc.SQLServerXADataSource;
import com.microsoft.sqlserver.jdbc.TestResource;
import com.microsoft.sqlserver.jdbc.TestUtils;
@@ -42,7 +41,6 @@
* Tests pooled connection
*
*/
-@RunWith(JUnitPlatform.class)
public class PoolingTest extends AbstractTest {
static String tempTableName = RandomUtil.getIdentifier("#poolingtest");
static String tableName = RandomUtil.getIdentifier("PoolingTestTable");
@@ -217,6 +215,69 @@ public void testApacheDBCP() throws SQLException {
}
}
+ /**
+ * test that prepared statement cache is cleared when disableStatementPooling is not set
+ */
+ @Test
+ public void testDisableStatementPooling() throws SQLException {
+ SQLServerConnectionPoolDataSource ds = new SQLServerConnectionPoolDataSource();
+ ds.setURL(connectionString + ";disableStatementPooling=false;statementPoolingCacheSize=20");
+ PooledConnection pConn = ds.getPooledConnection();
+
+ // create test table
+ try (Connection conn = pConn.getConnection(); Statement stmt = conn.createStatement()) {
+ TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
+
+ stmt.execute(
+ "create table " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (c1 int, c2 varchar(20))");
+ }
+
+ try {
+ for (int i = 0; i < 5; i++) {
+ try (Connection conn = pConn.getConnection();) {
+ conn.setAutoCommit(false);
+
+ try (Statement stmt = conn.createStatement(); PreparedStatement pstmt = conn.prepareStatement(
+ "insert into " + AbstractSQLGenerator.escapeIdentifier(tableName) + " values (?, ?)")) {
+
+ for (int j = 0; j < 3; j++) {
+ pstmt.setInt(1, j);
+ pstmt.setString(2, "test" + j);
+ pstmt.addBatch();
+ }
+
+ pstmt.executeBatch();
+ conn.commit();
+ }
+ }
+ }
+
+ try (Connection conn = pConn.getConnection(); Statement stmt = conn.createStatement();
+ ResultSet rs = stmt.executeQuery("select * from " + AbstractSQLGenerator.escapeIdentifier(tableName)
+ + " order by c1 desc")) {
+
+ int i = 1;
+ while (rs.next()) {
+ if (i <= 5) {
+ assertEquals(2, rs.getInt(1));
+ assertEquals("test2", rs.getString(2));
+ } else if (i > 5 && i <= 10) {
+ assertEquals(1, rs.getInt(1));
+ assertEquals("test1", rs.getString(2));
+ } else if (i > 10 && i <= 15) {
+ assertEquals(0, rs.getInt(1));
+ assertEquals("test0", rs.getString(2));
+ }
+ i++;
+ }
+ }
+ } finally {
+ if (null != pConn) {
+ pConn.close();
+ }
+ }
+ }
+
/**
* setup connection, get connection from pool, and test threads
*
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java
index d758950f8..9c1a7b2d9 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java
@@ -8,6 +8,7 @@
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -92,71 +93,70 @@ public void testModifiableConnectionProperties() throws SQLException {
boolean ignoreOffsetOnDateTimeOffsetConversion2 = false;
try (SQLServerConnection con = getConnection(); Statement stmt = con.createStatement()) {
- if (TestUtils.isJDBC43OrGreater(con)) {
- // Second database
- stmt.executeUpdate("CREATE DATABASE [" + sCatalog2 + "]");
-
- // First set of values.
- setConnectionFields(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1, holdability1,
- sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
- serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
- useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
- ignoreOffsetOnDateTimeOffsetConversion1);
- con.beginRequest();
- // Call setters with the second set of values inside beginRequest()/endRequest() block.
- setConnectionFields(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2, holdability2,
- sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
- serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
- useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
- ignoreOffsetOnDateTimeOffsetConversion2);
- con.endRequest();
- // Test if endRequest() resets the SQLServerConnection properties back to the first set of values.
- compareValuesAgainstConnection(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1,
- holdability1, sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
- serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
- useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
- ignoreOffsetOnDateTimeOffsetConversion1);
-
- // Multiple calls to beginRequest() without an intervening call to endRequest() are no-op.
- setConnectionFields(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2, holdability2,
- sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
- serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
- useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
- ignoreOffsetOnDateTimeOffsetConversion2);
- con.beginRequest();
- setConnectionFields(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1, holdability1,
- sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
- serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
- useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
- ignoreOffsetOnDateTimeOffsetConversion1);
- con.beginRequest();
- con.endRequest();
- // Same values as before the first beginRequest()
- compareValuesAgainstConnection(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2,
- holdability2, sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
- serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
- useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
- ignoreOffsetOnDateTimeOffsetConversion2);
-
- // A call to endRequest() without an intervening call to beginRequest() is no-op.
- setConnectionFields(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1, holdability1,
- sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
- serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
- useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
- ignoreOffsetOnDateTimeOffsetConversion1);
- setConnectionFields(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2, holdability2,
- sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
- serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
- useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
- ignoreOffsetOnDateTimeOffsetConversion2);
- con.endRequest();
- // No change.
- compareValuesAgainstConnection(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2,
- holdability2, sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
- serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
- useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
- ignoreOffsetOnDateTimeOffsetConversion2);
- }
+ assumeTrue(TestUtils.isJDBC43OrGreater(con));
+ // Second database
+ stmt.executeUpdate("CREATE DATABASE [" + sCatalog2 + "]");
+
+ // First set of values.
+ setConnectionFields(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1, holdability1,
+ sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
+ serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
+ useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
+ ignoreOffsetOnDateTimeOffsetConversion1);
+ con.beginRequest();
+ // Call setters with the second set of values inside beginRequest()/endRequest() block.
+ setConnectionFields(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2, holdability2,
+ sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
+ serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
+ useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
+ ignoreOffsetOnDateTimeOffsetConversion2);
+ con.endRequest();
+ // Test if endRequest() resets the SQLServerConnection properties back to the first set of values.
+ compareValuesAgainstConnection(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1,
+ holdability1, sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
+ serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
+ useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
+ ignoreOffsetOnDateTimeOffsetConversion1);
+
+ // Multiple calls to beginRequest() without an intervening call to endRequest() are no-op.
+ setConnectionFields(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2, holdability2,
+ sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
+ serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
+ useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
+ ignoreOffsetOnDateTimeOffsetConversion2);
+ con.beginRequest();
+ setConnectionFields(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1, holdability1,
+ sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
+ serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
+ useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
+ ignoreOffsetOnDateTimeOffsetConversion1);
+ con.beginRequest();
+ con.endRequest();
+ // Same values as before the first beginRequest()
+ compareValuesAgainstConnection(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2,
+ holdability2, sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
+ serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
+ useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
+ ignoreOffsetOnDateTimeOffsetConversion2);
+
+ // A call to endRequest() without an intervening call to beginRequest() is no-op.
+ setConnectionFields(con, autoCommitMode1, transactionIsolationLevel1, networkTimeout1, holdability1,
+ sendTimeAsDatetime1, statementPoolingCacheSize1, disableStatementPooling1,
+ serverPreparedStatementDiscardThreshold1, enablePrepareOnFirstPreparedStatementCall1, sCatalog1,
+ useBulkCopyForBatchInsert1, useFmtOnly1, delayLoadingLobs1,
+ ignoreOffsetOnDateTimeOffsetConversion1);
+ setConnectionFields(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2, holdability2,
+ sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
+ serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
+ useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
+ ignoreOffsetOnDateTimeOffsetConversion2);
+ con.endRequest();
+ // No change.
+ compareValuesAgainstConnection(con, autoCommitMode2, transactionIsolationLevel2, networkTimeout2,
+ holdability2, sendTimeAsDatetime2, statementPoolingCacheSize2, disableStatementPooling2,
+ serverPreparedStatementDiscardThreshold2, enablePrepareOnFirstPreparedStatementCall2, sCatalog2,
+ useBulkCopyForBatchInsert2, useFmtOnly2, delayLoadingLobs2,
+ ignoreOffsetOnDateTimeOffsetConversion2);
} finally {
TestUtils.dropDatabaseIfExists(sCatalog2, connectionString);
}
@@ -170,24 +170,23 @@ public void testModifiableConnectionProperties() throws SQLException {
@Test
public void testWarnings() throws SQLException {
try (Connection con = getConnection()) {
- if (TestUtils.isJDBC43OrGreater(con)) {
- con.beginRequest();
- generateWarning(con);
- assertNotNull(con.getWarnings());
- con.endRequest();
- assertNull(con.getWarnings());
-
- generateWarning(con);
- con.endRequest();
- assertNotNull(con.getWarnings());
-
- con.clearWarnings();
- con.beginRequest();
- generateWarning(con);
- con.beginRequest();
- con.endRequest();
- assertNull(con.getWarnings());
- }
+ assumeTrue(TestUtils.isJDBC43OrGreater(con));
+ con.beginRequest();
+ generateWarning(con);
+ assertNotNull(con.getWarnings());
+ con.endRequest();
+ assertNull(con.getWarnings());
+
+ generateWarning(con);
+ con.endRequest();
+ assertNotNull(con.getWarnings());
+
+ con.clearWarnings();
+ con.beginRequest();
+ generateWarning(con);
+ con.beginRequest();
+ con.endRequest();
+ assertNull(con.getWarnings());
}
}
@@ -199,27 +198,24 @@ public void testWarnings() throws SQLException {
@Test
public void testOpenTransactions() throws SQLException {
try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
- if (TestUtils.isJDBC43OrGreater(con)) {
- TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
- stmt.executeUpdate("CREATE TABLE " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (col int)");
- con.beginRequest();
- con.setAutoCommit(false);
- stmt.executeUpdate("INSERT INTO " + AbstractSQLGenerator.escapeIdentifier(tableName) + " values(5)");
- // endRequest() does a rollback here, the value does not get inserted into the table.
- con.endRequest();
- con.commit();
-
- try (ResultSet rs = con.createStatement()
- .executeQuery("SELECT * from " + AbstractSQLGenerator.escapeIdentifier(tableName))) {
- assertTrue(!rs.isBeforeFirst(), "Should not have returned a result set.");
- } finally {
- if (null != tableName) {
- TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
- }
+ assumeTrue(TestUtils.isJDBC43OrGreater(con));
+ TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
+ stmt.executeUpdate("CREATE TABLE " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (col int)");
+ con.beginRequest();
+ con.setAutoCommit(false);
+ stmt.executeUpdate("INSERT INTO " + AbstractSQLGenerator.escapeIdentifier(tableName) + " values(5)");
+ // endRequest() does a rollback here, the value does not get inserted into the table.
+ con.endRequest();
+ con.commit();
+
+ try (ResultSet rs = con.createStatement()
+ .executeQuery("SELECT * from " + AbstractSQLGenerator.escapeIdentifier(tableName))) {
+ assertTrue(!rs.isBeforeFirst(), "Should not have returned a result set.");
+ } finally {
+ if (null != tableName) {
+ TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
}
}
- } catch (Exception e) {
- fail(e.getMessage());
}
}
@@ -231,61 +227,58 @@ public void testOpenTransactions() throws SQLException {
@Test
public void testStatements() throws SQLException {
try (Connection con = getConnection();) {
- if (TestUtils.isJDBC43OrGreater(con)) {
- try (Statement stmt1 = con.createStatement()) {
- con.beginRequest();
- try (Statement stmt = con.createStatement()) {
- try (ResultSet rs = stmt.executeQuery("SELECT 1")) {
- rs.next();
- assertEquals(1, rs.getInt(1));
- con.endRequest();
-
- assertTrue(!stmt1.isClosed(),
- "Statement created outside of beginRequest()/endRequest() block should not be closed.");
- assertTrue(stmt.isClosed(),
- "Statement created inside beginRequest()/endRequest() block should be closed after endRequest().");
- assertTrue(rs.isClosed(), "ResultSet should be closed after endRequest().");
- }
+ assumeTrue(TestUtils.isJDBC43OrGreater(con));
+ try (Statement stmt1 = con.createStatement()) {
+ con.beginRequest();
+ try (Statement stmt = con.createStatement()) {
+ try (ResultSet rs = stmt.executeQuery("SELECT 1")) {
+ rs.next();
+ assertEquals(1, rs.getInt(1));
+ con.endRequest();
+
+ assertTrue(!stmt1.isClosed(),
+ "Statement created outside of beginRequest()/endRequest() block should not be closed.");
+ assertTrue(stmt.isClosed(),
+ "Statement created inside beginRequest()/endRequest() block should be closed after endRequest().");
+ assertTrue(rs.isClosed(), "ResultSet should be closed after endRequest().");
}
}
+ }
- // Multiple statements inside beginRequest()/endRequest() block
- con.beginRequest();
- try (Statement stmt = con.createStatement()) {
- TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
- stmt.executeUpdate(
- "CREATE TABLE " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (col int)");
- try (PreparedStatement ps = con.prepareStatement(
- "INSERT INTO " + AbstractSQLGenerator.escapeIdentifier(tableName) + " values (?)")) {
- ps.setInt(1, 2);
- ps.executeUpdate();
-
- try (Statement stmt1 = con.createStatement(); ResultSet rs = stmt1
- .executeQuery("SELECT * FROM " + AbstractSQLGenerator.escapeIdentifier(tableName))) {
- rs.next();
- assertEquals(2, rs.getInt(1));
- TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
-
- try (CallableStatement cs = con.prepareCall("{call sp_server_info}")) {
- cs.execute();
- con.endRequest();
-
- assertTrue(stmt.isClosed());
- assertTrue(ps.isClosed());
- assertTrue(stmt1.isClosed());
- assertTrue(cs.isClosed());
- assertTrue(rs.isClosed());
- }
+ // Multiple statements inside beginRequest()/endRequest() block
+ con.beginRequest();
+ try (Statement stmt = con.createStatement()) {
+ TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
+ stmt.executeUpdate("CREATE TABLE " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (col int)");
+ try (PreparedStatement ps = con.prepareStatement(
+ "INSERT INTO " + AbstractSQLGenerator.escapeIdentifier(tableName) + " values (?)")) {
+ ps.setInt(1, 2);
+ ps.executeUpdate();
+
+ try (Statement stmt1 = con.createStatement(); ResultSet rs = stmt1
+ .executeQuery("SELECT * FROM " + AbstractSQLGenerator.escapeIdentifier(tableName))) {
+ rs.next();
+ assertEquals(2, rs.getInt(1));
+ TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
+
+ try (CallableStatement cs = con.prepareCall("{call sp_server_info}")) {
+ cs.execute();
+ con.endRequest();
+
+ assertTrue(stmt.isClosed());
+ assertTrue(ps.isClosed());
+ assertTrue(stmt1.isClosed());
+ assertTrue(cs.isClosed());
+ assertTrue(rs.isClosed());
}
}
- } finally {
- if (null != tableName) {
- try (Statement stmt = con.createStatement()) {
- TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
- }
+ }
+ } finally {
+ if (null != tableName) {
+ try (Statement stmt = con.createStatement()) {
+ TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt);
}
}
-
}
}
}
@@ -307,67 +300,66 @@ class Variables {
final CountDownLatch latch = new CountDownLatch(3);
try {
sharedVariables.con = getConnection();
- if (TestUtils.isJDBC43OrGreater(sharedVariables.con)) {
- Thread thread1 = new Thread() {
- public void run() {
- try {
- sharedVariables.con.setNetworkTimeout(null, 100);
- sharedVariables.con.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
+ assumeTrue(TestUtils.isJDBC43OrGreater(sharedVariables.con));
+ Thread thread1 = new Thread() {
+ public void run() {
+ try {
+ sharedVariables.con.setNetworkTimeout(null, 100);
+ sharedVariables.con.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
+ latch.countDown();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Thread.currentThread().interrupt();
+ }
+ }
+ };
+
+ Thread thread2 = new Thread() {
+ public void run() {
+ try {
+ sharedVariables.stmt = sharedVariables.con.createStatement();
+ try (ResultSet rs = sharedVariables.stmt.executeQuery("SELECT 1")) {
+ rs.next();
+ assertEquals(1, rs.getInt(1));
latch.countDown();
- } catch (SQLException e) {
- e.printStackTrace();
- Thread.currentThread().interrupt();
}
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Thread.currentThread().interrupt();
}
- };
-
- Thread thread2 = new Thread() {
- public void run() {
- try {
- sharedVariables.stmt = sharedVariables.con.createStatement();
- try (ResultSet rs = sharedVariables.stmt.executeQuery("SELECT 1")) {
- rs.next();
- assertEquals(1, rs.getInt(1));
- latch.countDown();
- }
- } catch (SQLException e) {
- e.printStackTrace();
- Thread.currentThread().interrupt();
+ }
+ };
+
+ Thread thread3 = new Thread() {
+ public void run() {
+ try {
+ sharedVariables.pstmt = sharedVariables.con.prepareStatement("SELECT 1");
+ try (ResultSet rs = sharedVariables.pstmt.executeQuery()) {
+ rs.next();
+ assertEquals(1, rs.getInt(1));
+ latch.countDown();
}
+ } catch (SQLException e) {
+ e.printStackTrace();
+ Thread.currentThread().interrupt();
}
- };
-
- Thread thread3 = new Thread() {
- public void run() {
- try {
- sharedVariables.pstmt = sharedVariables.con.prepareStatement("SELECT 1");
- try (ResultSet rs = sharedVariables.pstmt.executeQuery()) {
- rs.next();
- assertEquals(1, rs.getInt(1));
- latch.countDown();
- }
- } catch (SQLException e) {
- e.printStackTrace();
- Thread.currentThread().interrupt();
- }
- }
- };
-
- int originalNetworkTimeout = sharedVariables.con.getNetworkTimeout();
- int originalHoldability = sharedVariables.con.getHoldability();
- sharedVariables.con.beginRequest();
- thread1.start();
- thread2.start();
- thread3.start();
- latch.await();
- sharedVariables.con.endRequest();
-
- assertEquals(originalNetworkTimeout, sharedVariables.con.getNetworkTimeout());
- assertEquals(originalHoldability, sharedVariables.con.getHoldability());
- assertTrue(sharedVariables.stmt.isClosed());
- assertTrue(sharedVariables.pstmt.isClosed());
- }
+ }
+ };
+
+ int originalNetworkTimeout = sharedVariables.con.getNetworkTimeout();
+ int originalHoldability = sharedVariables.con.getHoldability();
+ sharedVariables.con.beginRequest();
+ thread1.start();
+ thread2.start();
+ thread3.start();
+ latch.await();
+ sharedVariables.con.endRequest();
+
+ assertEquals(originalNetworkTimeout, sharedVariables.con.getNetworkTimeout());
+ assertEquals(originalHoldability, sharedVariables.con.getHoldability());
+ assertTrue(sharedVariables.stmt.isClosed());
+ assertTrue(sharedVariables.pstmt.isClosed());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
fail(e.getMessage());
@@ -521,10 +513,16 @@ private List getVerifiedMethodNames() {
verifiedMethodNames.add("setMsiTokenCacheTtl");
verifiedMethodNames.add("getAccessTokenCallbackClass");
verifiedMethodNames.add("setAccessTokenCallbackClass");
+ verifiedMethodNames.add("getServerMessageHandler");
+ verifiedMethodNames.add("setServerMessageHandler");
+ verifiedMethodNames.add("getCalcBigDecimalScale");
+ verifiedMethodNames.add("setCalcBigDecimalScale");
verifiedMethodNames.add("getUseFlexibleCallableStatements");
verifiedMethodNames.add("setUseFlexibleCallableStatements");
verifiedMethodNames.add("getCalcBigDecimalPrecision");
verifiedMethodNames.add("setCalcBigDecimalPrecision");
+ verifiedMethodNames.add("registerBeforeReconnectListener");
+ verifiedMethodNames.add("removeBeforeReconnectListener");
return verifiedMethodNames;
}
}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java
index 2a0e6b04b..268fda736 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java
@@ -9,7 +9,6 @@
import static org.junit.jupiter.api.Assertions.fail;
import java.lang.reflect.Field;
-import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
@@ -36,67 +35,81 @@
@RunWith(JUnitPlatform.class)
-@Tag("slow")
public class TimeoutTest extends AbstractTest {
static String randomServer = RandomUtil.getIdentifier("Server");
static String waitForDelaySPName = RandomUtil.getIdentifier("waitForDelaySP");
static final int waitForDelaySeconds = 10;
- static final int defaultTimeout = 15; // loginTimeout default value
+ static final int defaultTimeout = 30; // loginTimeout default value
@BeforeAll
public static void setupTests() throws Exception {
setConnection();
}
+ /*
+ * TODO:
+ * The tests below uses a simple interval counting logic to determine whether there was at least 1 retry.
+ * Given the interval is long enough, then 1 retry should take at least 1 interval long, so if it took < 1 interval, then it assumes there were no retry. However, this only works if TNIR or failover is not enabled since those cases should retry but no wait interval in between. So this interval counting can not detect these cases.
+ * Note a better and more reliable way would be to check attemptNumber using reflection to determine the number of retries.
+ */
+
+ // test default loginTimeout used if not specified in connection string
@Test
public void testDefaultLoginTimeout() {
- long timerEnd = 0;
-
+ long totalTime = 0;
long timerStart = System.currentTimeMillis();
- // Try a non existing server and see if the default timeout is 15 seconds
- try (Connection con = PrepUtil.getConnection("jdbc:sqlserver://" + randomServer + "connectRetryCount=0")) {
+
+ // non existing server and default values to see if took default timeout
+ try (Connection con = PrepUtil.getConnection("jdbc:sqlserver://" + randomServer)) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
- assertTrue((e.getMessage().contains(TestResource.getResource("R_tcpipConnectionToHost")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
+ assertTrue(
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_tcpipConnectionToHost").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
}
- verifyTimeout(timerEnd - timerStart, defaultTimeout);
+ // time should be < default loginTimeout
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(defaultTimeout),
+ "total time: " + totalTime + " default loginTimout: " + TimeUnit.SECONDS.toMillis(defaultTimeout));
}
+ // test setting loginTimeout value
@Test
public void testURLLoginTimeout() {
- long timerEnd = 0;
- int timeout = 10;
+ long totalTime = 0;
+ int timeout = 15;
long timerStart = System.currentTimeMillis();
+ // non existing server and set loginTimeout
try (Connection con = PrepUtil.getConnection("jdbc:sqlserver://" + randomServer + ";logintimeout=" + timeout)) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
- assertTrue((e.getMessage().contains(TestResource.getResource("R_tcpipConnectionToHost")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
+ assertTrue(
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_tcpipConnectionToHost").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
}
- verifyTimeout(timerEnd - timerStart, timeout);
+ // time should be < set loginTimeout
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(timeout),
+ "total time: " + totalTime + " loginTimeout: " + TimeUnit.SECONDS.toMillis(timeout));
}
+ // test setting timeout in DM
@Test
public void testDMLoginTimeoutApplied() {
- long timerEnd = 0;
- int timeout = 10;
+ long totalTime = 0;
+ int timeout = 15;
DriverManager.setLoginTimeout(timeout);
long timerStart = System.currentTimeMillis();
@@ -104,23 +117,26 @@ public void testDMLoginTimeoutApplied() {
try (Connection con = PrepUtil.getConnection("jdbc:sqlserver://" + randomServer)) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
- assertTrue((e.getMessage().contains(TestResource.getResource("R_tcpipConnectionToHost")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
+ assertTrue(
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_tcpipConnectionToHost").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
}
- verifyTimeout(timerEnd - timerStart, timeout);
+ // time should be < DM timeout
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(timeout),
+ "total time: " + totalTime + " DM loginTimeout: " + TimeUnit.SECONDS.toMillis(timeout));
}
+ // test that setting in connection string overrides value set in DM
@Test
public void testDMLoginTimeoutNotApplied() {
- long timerEnd = 0;
- int timeout = 10;
+ long totalTime = 0;
+ int timeout = 15;
try {
DriverManager.setLoginTimeout(timeout * 3); // 30 seconds
long timerStart = System.currentTimeMillis();
@@ -129,134 +145,185 @@ public void testDMLoginTimeoutNotApplied() {
.getConnection("jdbc:sqlserver://" + randomServer + ";loginTimeout=" + timeout)) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
assertTrue(
- (e.getMessage().contains(TestResource.getResource("R_tcpipConnectionToHost")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage()
- .contains(TestResource
- .getResource("R_connectTimedOut"))
- : false),
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_tcpipConnectionToHost").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
}
- verifyTimeout(timerEnd - timerStart, timeout);
+
+ // time should be < connection string loginTimeout
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(timeout),
+ "total time: " + totalTime + " loginTimeout: " + TimeUnit.SECONDS.toMillis(timeout));
} finally {
DriverManager.setLoginTimeout(0); // Default to 0 again
}
}
+ // Test connect retry set to 0 (disabled)
+ @Test
+ public void testConnectRetryDisable() {
+ long totalTime = 0;
+ long timerStart = System.currentTimeMillis();
+ int interval = defaultTimeout; // long interval so we can tell if there was a retry
+ long timeout = defaultTimeout * 2; // long loginTimeout to accommodate the long interval
+
+ // non existent server with long loginTimeout, should return fast if no retries at all
+ try (Connection con = PrepUtil.getConnection(
+ "jdbc:sqlserver://" + randomServer + ";transparentNetworkIPResolution=false;loginTimeout=" + timeout
+ + ";connectRetryCount=0;connectInterval=" + interval)) {
+ fail(TestResource.getResource("R_shouldNotConnect"));
+ } catch (Exception e) {
+ totalTime = System.currentTimeMillis() - timerStart;
+
+ assertTrue(
+ e.getMessage().matches(TestUtils.formatErrorMsg("R_tcpipConnectionFailed"))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
+ e.getMessage());
+ }
+
+ // if there was a retry then it would take at least 1 interval long, so if < interval means there were no retries
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(interval),
+ "total time: " + totalTime + " interval: " + TimeUnit.SECONDS.toMillis(interval));
+ }
+
// Test connect retry for non-existent server with loginTimeout
@Test
public void testConnectRetryBadServer() {
- long timerEnd = 0;
+ long totalTime = 0;
long timerStart = System.currentTimeMillis();
- int loginTimeout = 15;
+ int timeout = 15;
// non existent server with very short loginTimeout, no retry will happen as not a transient error
- try (Connection con = PrepUtil
- .getConnection("jdbc:sqlserver://" + randomServer + ";loginTimeout=" + loginTimeout)) {
+ try (Connection con = PrepUtil.getConnection("jdbc:sqlserver://" + randomServer + ";loginTimeout=" + timeout)) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
- assertTrue((e.getMessage().contains(TestResource.getResource("R_tcpipConnectionToHost")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
+ assertTrue(
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_tcpipConnectionToHost").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
}
- verifyTimeout(timerEnd - timerStart, loginTimeout);
+ // time should be < loginTimeout set
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(timeout),
+ "total time: " + totalTime + " loginTimeout: " + TimeUnit.SECONDS.toMillis(timeout));
}
// Test connect retry for database error
@Test
public void testConnectRetryServerError() {
- long timerEnd = 0;
+ long totalTime = 0;
long timerStart = System.currentTimeMillis();
+ int interval = defaultTimeout; // long interval so we can tell if there was a retry
+ long timeout = defaultTimeout * 2; // long loginTimeout to accommodate the long interval
- // non existent database with interval < loginTimeout this will generate a 4060 transient error and retry
- int connectRetryCount = new Random().nextInt(256);
- int connectRetryInterval = new Random().nextInt(defaultTimeout) + 1;
+ // non existent database with interval < loginTimeout this will generate a 4060 transient error and retry 1 time
try (Connection con = PrepUtil.getConnection(
TestUtils.addOrOverrideProperty(connectionString, "database", RandomUtil.getIdentifier("database"))
- + ";logintimeout=" + defaultTimeout + ";connectRetryCount=" + connectRetryCount
- + ";connectRetryInterval=" + connectRetryInterval)) {
+ + ";loginTimeout=" + timeout + ";connectRetryCount=" + 1 + ";connectRetryInterval=" + interval
+ + ";transparentNetworkIPResolution=false")) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
- assertTrue((e.getMessage().contains(TestResource.getResource("R_cannotOpenDatabase")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
+ assertTrue(
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_cannotOpenDatabase").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
}
- // connect + all retries should always be <= loginTimeout
- verifyTimeout(timerEnd - timerStart, defaultTimeout);
+ // 1 retry should be at least 1 interval long but < 2 intervals
+ assertTrue(TimeUnit.SECONDS.toMillis(interval) < totalTime,
+ "interval: " + TimeUnit.SECONDS.toMillis(interval) + " total time: " + totalTime);
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(2 * interval),
+ "total time: " + totalTime + " 2 * interval: " + TimeUnit.SECONDS.toMillis(interval));
}
// Test connect retry for database error using Datasource
@Test
public void testConnectRetryServerErrorDS() {
- long timerEnd = 0;
+ long totalTime = 0;
long timerStart = System.currentTimeMillis();
+ int interval = defaultTimeout; // long interval so we can tell if there was a retry
+ long loginTimeout = defaultTimeout * 2; // long loginTimeout to accommodate the long interval
- // non existent database with interval < loginTimeout this will generate a 4060 transient error and retry
- int connectRetryCount = new Random().nextInt(256);
- int connectRetryInterval = new Random().nextInt(defaultTimeout) + 1;
-
+ // non existent database with interval < loginTimeout this will generate a 4060 transient error and retry 1 time
SQLServerDataSource ds = new SQLServerDataSource();
String connectStr = TestUtils.addOrOverrideProperty(connectionString, "database",
- RandomUtil.getIdentifier("database")) + ";logintimeout=" + defaultTimeout + ";connectRetryCount="
- + connectRetryCount + ";connectRetryInterval=" + connectRetryInterval;
+ RandomUtil.getIdentifier("database")) + ";logintimeout=" + loginTimeout + ";connectRetryCount=1"
+ + ";connectRetryInterval=" + interval;
updateDataSource(connectStr, ds);
try (Connection con = PrepUtil.getConnection(connectStr)) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- assertTrue((e.getMessage().contains(TestResource.getResource("R_cannotOpenDatabase")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
+ assertTrue(
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_cannotOpenDatabase").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
}
- // connect + all retries should always be <= loginTimeout
- verifyTimeout(timerEnd - timerStart, defaultTimeout);
+ // 1 retry should be at least 1 interval long but < 2 intervals
+ assertTrue(TimeUnit.SECONDS.toMillis(interval) < totalTime,
+ "interval: " + TimeUnit.SECONDS.toMillis(interval) + " total time: " + totalTime);
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(2 * interval),
+ "total time: " + totalTime + " 2 * interval: " + TimeUnit.SECONDS.toMillis(2 * interval));
}
// Test connect retry for database error with loginTimeout
@Test
public void testConnectRetryTimeout() {
- long timerEnd = 0;
+ long totalTime = 0;
long timerStart = System.currentTimeMillis();
+ int interval = defaultTimeout; // long interval so we can tell if there was a retry
int loginTimeout = 2;
- // non existent database with very short loginTimeout so there is no time to do all retries
+ // non existent database with very short loginTimeout so there is no time to do any retry
try (Connection con = PrepUtil.getConnection(
TestUtils.addOrOverrideProperty(connectionString, "database", RandomUtil.getIdentifier("database"))
- + "connectRetryCount=" + (new Random().nextInt(256)) + ";connectRetryInterval="
- + (new Random().nextInt(defaultTimeout - 1) + 1) + ";loginTimeout=" + loginTimeout)) {
+ + "connectRetryCount=" + (new Random().nextInt(256)) + ";connectRetryInterval=" + interval
+ + ";loginTimeout=" + loginTimeout)) {
fail(TestResource.getResource("R_shouldNotConnect"));
} catch (Exception e) {
- timerEnd = System.currentTimeMillis();
+ totalTime = System.currentTimeMillis() - timerStart;
- assertTrue((e.getMessage().contains(TestResource.getResource("R_cannotOpenDatabase")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
+ assertTrue(
+ (e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_cannotOpenDatabase").toLowerCase()))
+ || ((isSqlAzure() || isSqlAzureDW()) ? e.getMessage().toLowerCase()
+ .contains(TestResource.getResource("R_connectTimedOut").toLowerCase()) : false),
e.getMessage());
}
- verifyTimeout(timerEnd - timerStart, loginTimeout);
+ // if there was a retry then it would take at least 1 interval long, so if < interval means there were no retries
+ assertTrue(totalTime < TimeUnit.SECONDS.toMillis(interval),
+ "total time: " + totalTime + " interval: " + TimeUnit.SECONDS.toMillis(interval));
+ }
+
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void testSocketTimeoutBoundedByLoginTimeoutReset() throws Exception {
+ try (Connection con = PrepUtil.getConnection(connectionString + ";socketTimeout=90000;loginTimeout=10;");
+ Statement stmt = con.createStatement()) {
+ // Login timeout (10s) is less than the 15s sec WAITFOR DELAY. Upon a login attempt, socketTimeout should be bounded
+ // by loginTimeout. After a successful login, when executing a query, socketTimeout should be reset to the
+ // original 90000ms timeout. The statement below should successfully execute as socketTimeout should not be bounded
+ // by loginTimeout, otherwise the test fails with a socket read timeout error.
+ stmt.execute("WAITFOR DELAY '00:00:15';");
+ }
}
// Test for detecting Azure server for connection retries
@@ -266,15 +333,21 @@ public void testAzureEndpointRetry() {
try (Connection con = PrepUtil.getConnection(connectionString)) {
Field fields[] = con.getClass().getSuperclass().getDeclaredFields();
for (Field f : fields) {
- if (f.getName() == "connectRetryCount") {
+ if (f.getName().equals("connectRetryCount")) {
f.setAccessible(true);
int retryCount = f.getInt(con);
- if (TestUtils.isAzure(con)) {
+
+ if (TestUtils.isAzureSynapseOnDemand(con)) {
+ assertTrue(retryCount == 5); // AZURE_SYNAPSE_ONDEMAND_ENDPOINT_RETRY_COUNT_DEFAULT
+ } else if (TestUtils.isAzure(con)) {
assertTrue(retryCount == 2); // AZURE_SERVER_ENDPOINT_RETRY_COUNT_DEFAFULT
- } else if (TestUtils.isAzureDW(con)) {
- assertTrue(retryCount == 5); // AZURE_SYNAPSE_ONDEMAND_ENDPOINT_RETRY_COUNT_DEFAFULT
} else {
- assertTrue(retryCount == 1); // default connectRetryCount
+ // default retryCount is 1 if not set in connection string
+ String retryCountFromConnStr = TestUtils.getProperty(connectionString, "connectRetryCount");
+ int expectedRetryCount = (retryCountFromConnStr != null) ? Integer
+ .parseInt(retryCountFromConnStr) : 1;
+
+ assertTrue(retryCount == expectedRetryCount); // default connectRetryCount
}
}
}
@@ -283,80 +356,6 @@ public void testAzureEndpointRetry() {
}
}
- @Test
- public void testFailoverInstanceResolution() throws SQLException {
- long timerEnd = 0;
- long timerStart = System.currentTimeMillis();
-
- // Try a non existing server and see if the default timeout is 15 seconds
- try (Connection con = PrepUtil
- .getConnection("jdbc:sqlserver://" + randomServer + ";databaseName=FailoverDB_abc;failoverPartner="
- + randomServer + "\\foo;user=sa;password=" + RandomUtil.getIdentifier("password"))) {
- fail(TestResource.getResource("R_shouldNotConnect"));
- } catch (Exception e) {
- timerEnd = System.currentTimeMillis();
-
- assertTrue((e.getMessage().contains(TestResource.getResource("R_tcpipConnectionToHost")))
- || ((isSqlAzure() || isSqlAzureDW())
- ? e.getMessage().contains(
- TestResource.getResource("R_connectTimedOut"))
- : false),
- e.getMessage());
- }
-
- verifyTimeout(timerEnd - timerStart, defaultTimeout * 2);
- }
-
- @Test
- public void testFOInstanceResolution2() throws SQLException {
- long timerEnd = 0;
-
- long timerStart = System.currentTimeMillis();
- try (Connection con = PrepUtil
- .getConnection("jdbc:sqlserver://" + randomServer + "\\fooggg;databaseName=FailoverDB;failoverPartner="
- + randomServer + "\\foo;user=sa;password=" + RandomUtil.getIdentifier("password"))) {
- fail(TestResource.getResource("R_shouldNotConnect"));
- } catch (Exception e) {
- timerEnd = System.currentTimeMillis();
- }
-
- verifyTimeout(timerEnd - timerStart, defaultTimeout);
- }
-
- /**
- * Tests that failover is correctly used after a socket timeout, by confirming total time includes socketTimeout
- * for both primary and failover server.
- */
- @Test
- public void testFailoverInstanceResolutionWithSocketTimeout() {
- long timerEnd;
- long timerStart = System.currentTimeMillis();
-
- try (Connection con = PrepUtil.getConnection("jdbc:sqlserver://" + randomServer
- + ";databaseName=FailoverDB;failoverPartner=" + randomServer + "\\foo;user=sa;password="
- + RandomUtil.getIdentifier("password") + ";socketTimeout=" + waitForDelaySeconds)) {
- fail(TestResource.getResource("R_shouldNotConnect"));
- } catch (Exception e) {
- timerEnd = System.currentTimeMillis();
- if (!(e instanceof SQLException)) {
- fail(TestResource.getResource("R_unexpectedErrorMessage") + e.getMessage());
- }
-
- // Driver should correctly attempt to connect to db, experience a socketTimeout, attempt to connect to
- // failover, and then have another socketTimeout. So, expected total time is 2 x socketTimeout.
- long totalTime = timerEnd - timerStart;
- long totalExpectedTime = waitForDelaySeconds * 1000L * 2; // We expect 2 * socketTimeout
- assertTrue(totalTime >= totalExpectedTime, TestResource.getResource("R_executionNotLong") + "totalTime: "
- + totalTime + " expectedTime: " + totalExpectedTime);
- }
- }
-
- private void verifyTimeout(long timeDiff, int timeout) {
- // Verify that login timeout does not take longer than seconds.
- assertTrue(timeDiff < TimeUnit.SECONDS.toMillis(timeout * 2),
- "timeout: " + TimeUnit.SECONDS.toMillis(timeout) + " timediff: " + timeDiff);
- }
-
/**
* When query timeout occurs, the connection is still usable.
*
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java
index ff2f2fc73..044cc6a3e 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java
@@ -59,10 +59,47 @@
@RunWith(JUnitPlatform.class)
public class DatabaseMetaDataTest extends AbstractTest {
+ private static final String uuid = UUID.randomUUID().toString().replaceAll("-", "");
private static final String tableName = RandomUtil.getIdentifier("DBMetadataTable");
private static final String functionName = RandomUtil.getIdentifier("DBMetadataFunction");
+ private static final String schema = "schema_demo" + uuid;
+ private static final String escapedSchema = "schema\\_demo" + uuid;
+ private static final String tableNameWithSchema = schema + ".resource";
+ private static final String sprocWithSchema = schema + ".updateresource";
private static Map getColumnsDWColumns = null;
private static Map getImportedKeysDWColumns = null;
+ private static final String TABLE_CAT = "TABLE_CAT";
+ private static final String TABLE_SCHEM = "TABLE_SCHEM";
+ private static final String TABLE_NAME = "TABLE_NAME";
+ private static final String COLUMN_NAME = "COLUMN_NAME";
+ private static final String DATA_TYPE = "DATA_TYPE";
+ private static final String TYPE_NAME = "TYPE_NAME";
+ private static final String COLUMN_SIZE = "COLUMN_SIZE";
+ private static final String BUFFER_LENGTH = "BUFFER_LENGTH";
+ private static final String DECIMAL_DIGITS = "DECIMAL_DIGITS";
+ private static final String NUM_PREC_RADIX = "NUM_PREC_RADIX";
+ private static final String NULLABLE = "NULLABLE";
+ private static final String REMARKS = "REMARKS";
+ private static final String COLUMN_DEF = "COLUMN_DEF";
+ private static final String SQL_DATA_TYPE = "SQL_DATA_TYPE";
+ private static final String SQL_DATETIME_SUB = "SQL_DATETIME_SUB";
+ private static final String CHAR_OCTET_LENGTH = "CHAR_OCTET_LENGTH";
+ private static final String ORDINAL_POSITION = "ORDINAL_POSITION";
+ private static final String IS_NULLABLE = "IS_NULLABLE";
+ private static final String SCOPE_CATALOG = "SCOPE_CATALOG";
+ private static final String SCOPE_SCHEMA = "SCOPE_SCHEMA";
+ private static final String SCOPE_TABLE = "SCOPE_TABLE";
+ private static final String SOURCE_DATA_TYPE = "SOURCE_DATA_TYPE";
+ private static final String IS_AUTOINCREMENT = "IS_AUTOINCREMENT";
+ private static final String IS_GENERATEDCOLUMN = "IS_GENERATEDCOLUMN";
+ private static final String SS_IS_SPARSE = "SS_IS_SPARSE";
+ private static final String SS_IS_COLUMN_SET = "SS_IS_COLUMN_SET";
+ private static final String SS_UDT_CATALOG_NAME = "SS_UDT_CATALOG_NAME";
+ private static final String SS_UDT_SCHEMA_NAME = "SS_UDT_SCHEMA_NAME";
+ private static final String SS_UDT_ASSEMBLY_TYPE_NAME = "SS_UDT_ASSEMBLY_TYPE_NAME";
+ private static final String SS_XML_SCHEMACOLLECTION_CATALOG_NAME = "SS_XML_SCHEMACOLLECTION_CATALOG_NAME";
+ private static final String SS_XML_SCHEMACOLLECTION_SCHEMA_NAME = "SS_XML_SCHEMACOLLECTION_SCHEMA_NAME";
+ private static final String SS_XML_SCHEMACOLLECTION_NAME = "SS_XML_SCHEMACOLLECTION_NAME";
/**
* Verify DatabaseMetaData#isWrapperFor and DatabaseMetaData#unwrap.
@@ -887,6 +924,111 @@ public void testGetImportedKeysDW() throws SQLException {
}
}
+ /**
+ * Validates the metadata data types defined by JDBC spec.
+ * Refer to DatabaseMetadata getColumns() specs
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void testValidateColumnMetadata() throws SQLException {
+ Map> getColumnMetaDataClass = new LinkedHashMap<>();
+
+ getColumnMetaDataClass.put(TABLE_CAT, String.class);
+ getColumnMetaDataClass.put(TABLE_SCHEM, String.class);
+ getColumnMetaDataClass.put(TABLE_NAME, String.class);
+ getColumnMetaDataClass.put(COLUMN_NAME, String.class);
+ getColumnMetaDataClass.put(DATA_TYPE, Integer.class);
+ getColumnMetaDataClass.put(TYPE_NAME, String.class);
+ getColumnMetaDataClass.put(COLUMN_SIZE, Integer.class);
+ getColumnMetaDataClass.put(BUFFER_LENGTH, Integer.class); // Not used
+ getColumnMetaDataClass.put(DECIMAL_DIGITS, Integer.class);
+ getColumnMetaDataClass.put(NUM_PREC_RADIX, Integer.class);
+ getColumnMetaDataClass.put(NULLABLE, Integer.class);
+ getColumnMetaDataClass.put(REMARKS, String.class);
+ getColumnMetaDataClass.put(COLUMN_DEF, String.class);
+ getColumnMetaDataClass.put(SQL_DATA_TYPE, Integer.class);
+ getColumnMetaDataClass.put(SQL_DATETIME_SUB, Integer.class);
+ getColumnMetaDataClass.put(CHAR_OCTET_LENGTH, Integer.class);
+ getColumnMetaDataClass.put(ORDINAL_POSITION, Integer.class);
+ getColumnMetaDataClass.put(IS_NULLABLE, String.class);
+ getColumnMetaDataClass.put(SCOPE_CATALOG, String.class);
+ getColumnMetaDataClass.put(SCOPE_SCHEMA, String.class);
+ getColumnMetaDataClass.put(SCOPE_TABLE, String.class);
+ getColumnMetaDataClass.put(SOURCE_DATA_TYPE, Short.class);
+ getColumnMetaDataClass.put(IS_AUTOINCREMENT, String.class);
+ getColumnMetaDataClass.put(IS_GENERATEDCOLUMN, String.class);
+ getColumnMetaDataClass.put(SS_IS_SPARSE, Short.class);
+ getColumnMetaDataClass.put(SS_IS_COLUMN_SET, Short.class);
+ getColumnMetaDataClass.put(SS_UDT_CATALOG_NAME, String.class);
+ getColumnMetaDataClass.put(SS_UDT_SCHEMA_NAME, String.class);
+ getColumnMetaDataClass.put(SS_UDT_ASSEMBLY_TYPE_NAME, String.class);
+ getColumnMetaDataClass.put(SS_XML_SCHEMACOLLECTION_CATALOG_NAME, String.class);
+ getColumnMetaDataClass.put(SS_XML_SCHEMACOLLECTION_SCHEMA_NAME, String.class);
+ getColumnMetaDataClass.put(SS_XML_SCHEMACOLLECTION_NAME, String.class);
+
+ try (Connection conn = getConnection()) {
+ ResultSetMetaData metadata = conn.getMetaData().getColumns(null, null, tableName, null).getMetaData();
+
+ // Ensure that there is an expected class for every column in the metadata result set
+ assertEquals(metadata.getColumnCount(), getColumnMetaDataClass.size());
+
+ for (int i = 1; i < metadata.getColumnCount(); i++) {
+ String columnLabel = metadata.getColumnLabel(i);
+ String columnClassName = metadata.getColumnClassName(i);
+ Class expectedClass = getColumnMetaDataClass.get(columnLabel);
+
+ // Ensure the metadata column is in the metadata column class map
+ if (expectedClass == null) {
+ MessageFormat form1 = new MessageFormat(TestResource.getResource("R_objectNullOrEmpty"));
+ Object[] msgArgs1 = {"expected metadata column class for column " + columnLabel};
+ fail(form1.format(msgArgs1));
+ }
+
+ // Ensure the actual and expected column metadata types match
+ if (!columnClassName.equals(expectedClass.getName())) {
+ MessageFormat form1 = new MessageFormat(
+ TestResource.getResource("R_expectedClassDoesNotMatchActualClass"));
+ Object[] msgArgs1 = {expectedClass.getName(), columnClassName, columnLabel};
+ fail(form1.format(msgArgs1));
+ }
+ }
+ }
+ }
+
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void shouldEscapeSchemaName() throws SQLException {
+ try (Statement stmt = connection.createStatement()) {
+ stmt.execute("CREATE SCHEMA " + schema);
+ stmt.execute("CREATE TABLE " + tableNameWithSchema + " (id UNIQUEIDENTIFIER, name NVARCHAR(400));");
+ stmt.execute("CREATE PROCEDURE " + sprocWithSchema + "(@id UNIQUEIDENTIFIER, @name VARCHAR(400)) AS "
+ + "BEGIN SET TRANSACTION ISOLATION LEVEL SERIALIZABLE BEGIN TRANSACTION UPDATE "
+ + tableNameWithSchema + " SET name = @name WHERE id = @id COMMIT END");
+ }
+
+ try (Connection con = getConnection()) {
+ DatabaseMetaData md = con.getMetaData();
+ try (ResultSet procedures = md.getProcedures(null, escapedSchema, "updateresource")) {
+ if (!procedures.next()) {
+ fail("Escaped schema pattern did not succeed. No results found.");
+ }
+ }
+
+ try (ResultSet columns = md.getProcedureColumns(null, escapedSchema, "updateresource", null)) {
+ if (!columns.next()) {
+ fail("Escaped schema pattern did not succeed. No results found.");
+ }
+ }
+ }
+
+ try (Statement stmt = connection.createStatement()) {
+ TestUtils.dropTableWithSchemaIfExists(tableNameWithSchema, stmt);
+ TestUtils.dropProcedureWithSchemaIfExists(sprocWithSchema, stmt);
+ TestUtils.dropSchemaIfExists(schema, stmt);
+ }
+ }
+
@BeforeAll
public static void setupTable() throws Exception {
setConnection();
@@ -904,6 +1046,9 @@ public static void terminate() throws SQLException {
try (Statement stmt = connection.createStatement()) {
TestUtils.dropTableIfExists(tableName, stmt);
TestUtils.dropFunctionIfExists(functionName, stmt);
+ TestUtils.dropTableWithSchemaIfExists(tableNameWithSchema, stmt);
+ TestUtils.dropProcedureWithSchemaIfExists(sprocWithSchema, stmt);
+ TestUtils.dropSchemaIfExists(schema, stmt);
}
}
}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DataTypesTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DataTypesTest.java
index 350f7cfc3..445d23dd0 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DataTypesTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DataTypesTest.java
@@ -1935,6 +1935,17 @@ public void testGetLocalDateTimeUnstorable() throws Exception {
}
}
+ @Test
+ public void testDateTimeOffsetValueOfOffsetDateTime() throws Exception {
+ OffsetDateTime expected = OffsetDateTime.now().withSecond(58).withNano(0);
+ OffsetDateTime roundUp = expected.withSecond(57).withNano(999999950);
+ OffsetDateTime roundDown = expected.withSecond(58).withNano(49);
+
+ assertEquals(expected, DateTimeOffset.valueOf(expected).getOffsetDateTime());
+ assertEquals(expected, DateTimeOffset.valueOf(roundUp).getOffsetDateTime());
+ assertEquals(expected, DateTimeOffset.valueOf(roundDown).getOffsetDateTime());
+ }
+
static LocalDateTime getUnstorableValue() throws Exception {
ZoneId systemTimezone = ZoneId.systemDefault();
Instant now = Instant.now();
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/GuidTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/GuidTest.java
new file mode 100644
index 000000000..6eb7fc51d
--- /dev/null
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/GuidTest.java
@@ -0,0 +1,100 @@
+package com.microsoft.sqlserver.jdbc.datatypes;
+
+import com.microsoft.sqlserver.jdbc.RandomUtil;
+import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
+import com.microsoft.sqlserver.jdbc.TestResource;
+import com.microsoft.sqlserver.jdbc.TestUtils;
+import com.microsoft.sqlserver.testframework.AbstractSQLGenerator;
+import com.microsoft.sqlserver.testframework.AbstractTest;
+import microsoft.sql.Types;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.Statement;
+import java.util.UUID;
+
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.microsoft.sqlserver.testframework.Constants;
+
+
+/*
+ * This test is for testing the serialisation of String as microsoft.sql.Types.GUID
+ */
+@RunWith(JUnitPlatform.class)
+public class GuidTest extends AbstractTest {
+
+ final static String tableName = RandomUtil.getIdentifier("GuidTestTable");
+ final static String escapedTableName = AbstractSQLGenerator.escapeIdentifier(tableName);
+
+ @BeforeAll
+ public static void setupTests() throws Exception {
+ setConnection();
+ }
+
+ /*
+ * Test UUID conversions
+ */
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void testGuid() throws Exception {
+ try (Connection conn = getConnection(); Statement stmt = conn.createStatement()) {
+
+ // Create the test table
+ TestUtils.dropTableIfExists(escapedTableName, stmt);
+
+ String query = "create table " + escapedTableName + " (uuid uniqueidentifier, id int IDENTITY primary key)";
+ stmt.executeUpdate(query);
+
+ UUID uuid = UUID.randomUUID();
+ String uuidString = uuid.toString();
+ int id = 1;
+
+ try (PreparedStatement pstmt = conn.prepareStatement("INSERT INTO " + escapedTableName
+ + " VALUES(?) SELECT * FROM " + escapedTableName + " where id = ?")) {
+
+ pstmt.setObject(1, uuidString, Types.GUID);
+ pstmt.setObject(2, id++);
+ pstmt.execute();
+ pstmt.getMoreResults();
+ try (SQLServerResultSet rs = (SQLServerResultSet) pstmt.getResultSet()) {
+ rs.next();
+ assertEquals(uuid, UUID.fromString(rs.getUniqueIdentifier(1)));
+ }
+
+ // Test NULL GUID
+ pstmt.setObject(1, null, Types.GUID);
+ pstmt.setObject(2, id++);
+ pstmt.execute();
+ pstmt.getMoreResults();
+ try (SQLServerResultSet rs = (SQLServerResultSet) pstmt.getResultSet()) {
+ rs.next();
+ String s = rs.getUniqueIdentifier(1);
+ assertNull(s);
+ assertTrue(rs.wasNull());
+ }
+
+ // Test Illegal GUID
+ try {
+ pstmt.setObject(1, "garbage", Types.GUID);
+ fail(TestResource.getResource("R_expectedFailPassed"));
+ } catch (IllegalArgumentException e) {
+ assertEquals("Invalid UUID string: garbage", e.getMessage());
+ }
+ }
+ } finally {
+ try (Statement stmt = connection.createStatement()) {
+ TestUtils.dropTableIfExists(escapedTableName, stmt);
+ }
+ }
+ }
+
+}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/exception/ChainedExceptionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/exception/ChainedExceptionTest.java
new file mode 100644
index 000000000..4c05d2fb7
--- /dev/null
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/exception/ChainedExceptionTest.java
@@ -0,0 +1,74 @@
+/*
+ * Microsoft JDBC Driver for SQL Server Copyright(c) Microsoft Corporation All rights reserved. This program is made
+ * available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+package com.microsoft.sqlserver.jdbc.exception;
+
+import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+import com.microsoft.sqlserver.jdbc.TestResource;
+import com.microsoft.sqlserver.testframework.AbstractTest;
+import com.microsoft.sqlserver.testframework.Constants;
+
+
+@RunWith(JUnitPlatform.class)
+public class ChainedExceptionTest extends AbstractTest {
+
+ @BeforeAll
+ public static void setupTests() throws Exception {
+ setConnection();
+ }
+
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void testTwoExceptions() throws Exception {
+ try (Connection conn = getConnection()) {
+
+ // The below should yield the following Server Messages:
+ // 1 : Msg 5074, Level 16, State 1: The object 'DF__#chained_exc__c1__AB25243A' is dependent on column 'c1'.
+ // 1 : Msg 4922, Level 16, State 9: ALTER TABLE ALTER COLUMN c1 failed because one or more objects access this column.
+ try (Statement stmnt = conn.createStatement()) {
+ stmnt.executeUpdate("CREATE TABLE #chained_exception_test_x1(c1 INT DEFAULT(0))");
+ stmnt.executeUpdate("ALTER TABLE #chained_exception_test_x1 ALTER COLUMN c1 VARCHAR(10)");
+ stmnt.executeUpdate("DROP TABLE IF EXISTS #chained_exception_test_x1");
+ }
+
+ fail(TestResource.getResource("R_expectedFailPassed"));
+
+ } catch (SQLException ex) {
+
+ // Check the SQLException and the chain
+ int exCount = 0;
+ int firstMsgNum = ex.getErrorCode();
+ int lastMsgNum = -1;
+
+ while (ex != null) {
+ exCount++;
+
+ lastMsgNum = ex.getErrorCode();
+
+ ex = ex.getNextException();
+ }
+
+ // Exception Count should be: 2
+ assertEquals(2, exCount, "Number of SQLExceptions in the SQLException chain");
+
+ // Check first Msg: 5074
+ assertEquals(5074, firstMsgNum, "First SQL Server Message");
+
+ // Check last Msg: 4922
+ assertEquals(4922, lastMsgNum, "Last SQL Server Message");
+ }
+ }
+}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/fedauth/FedauthTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/fedauth/FedauthTest.java
index 4bae199d2..e68fcacd8 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/fedauth/FedauthTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/fedauth/FedauthTest.java
@@ -18,6 +18,7 @@
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
+import java.text.MessageFormat;
import java.util.Collections;
import java.util.Properties;
import java.util.concurrent.CompletableFuture;
@@ -323,6 +324,66 @@ public void testAADServicePrincipalAuth() {
}
}
+ @Test
+ public void testAADServicePrincipalAuthFailureOnSubsequentConnectionsWithInvalidatedTokenCacheWithInvalidSecret() throws Exception {
+ String url = "jdbc:sqlserver://" + azureServer + ";database=" + azureDatabase + ";authentication="
+ + SqlAuthentication.ActiveDirectoryServicePrincipal + ";Username=" + applicationClientID + ";Password="
+ + applicationKey;
+
+ String invalidSecretUrl = "jdbc:sqlserver://" + azureServer + ";database=" + azureDatabase + ";authentication="
+ + SqlAuthentication.ActiveDirectoryServicePrincipal + ";Username=" + applicationClientID + ";Password="
+ + "invalidSecret";
+
+ // Should succeed on valid secret
+ try (Connection connection = DriverManager.getConnection(url)) {}
+
+ // Should fail on invalid secret
+ try (Connection connection = DriverManager.getConnection(invalidSecretUrl)) {
+ fail(TestResource.getResource("R_expectedFailPassed"));
+ } catch (Exception e) {
+ assertTrue(e.getMessage().contains(TestResource.getResource("R_invalidClientSecret")),
+ "Expected R_invalidClientSecret error.");
+ }
+ }
+
+ @Test
+ public void testActiveDirectoryPasswordFailureOnSubsequentConnectionsWithInvalidatedTokenCacheWithInvalidPassword() throws Exception {
+
+ // Should succeed on valid password
+ try (Connection conn = DriverManager.getConnection(adPasswordConnectionStr)) {}
+
+ // Should fail on invalid password
+ try (Connection conn = DriverManager.getConnection(adPasswordConnectionStr + ";password=invalidPassword;")) {
+ fail(TestResource.getResource("R_expectedFailPassed"));
+ } catch (Exception e) {
+ MessageFormat form = new MessageFormat(TestResource.getResource("R_invalidAADAuth"));
+ Object[] msgArgs = {azureUserName, "ActiveDirectoryPassword"};
+ assertTrue(e.getMessage().contains(form.format(msgArgs)), "Expected R_invalidAADAuth error.");
+ }
+ }
+
+ @Test
+ public void testAADServicePrincipalCertAuthFailureOnSubsequentConnectionsWithInvalidatedTokenCacheWithInvalidPassword() throws Exception {
+ // Should succeed on valid cert field values
+ String url = "jdbc:sqlserver://" + azureServer + ";database=" + azureDatabase + ";authentication="
+ + SqlAuthentication.ActiveDirectoryServicePrincipalCertificate + ";Username=" + applicationClientID
+ + ";password=" + certificatePassword + ";clientCertificate=" + clientCertificate;
+
+ // Should fail on invalid cert field values
+ String invalidPasswordUrl = "jdbc:sqlserver://" + azureServer + ";database=" + azureDatabase
+ + ";authentication=" + SqlAuthentication.ActiveDirectoryServicePrincipalCertificate + ";Username="
+ + applicationClientID + ";password=invalidPassword;clientCertificate=" + clientCertificate;
+
+ try (Connection conn = DriverManager.getConnection(url)) {}
+
+ try (Connection conn = DriverManager.getConnection(invalidPasswordUrl)) {
+ fail(TestResource.getResource("R_expectedFailPassed"));
+ } catch (Exception e) {
+ assertTrue(e.getMessage().contains(TestResource.getResource("R_invalidCertFields")),
+ "Expected R_invalidCertFields error.");
+ }
+ }
+
/**
* Test invalid connection property combinations when using AAD Service Principal Authentication.
*/
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/messageHandler/MessageHandlerTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/messageHandler/MessageHandlerTest.java
new file mode 100644
index 000000000..b9d52a681
--- /dev/null
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/messageHandler/MessageHandlerTest.java
@@ -0,0 +1,474 @@
+/*
+ * Microsoft JDBC Driver for SQL Server Copyright(c) Microsoft Corporation All rights reserved. This program is made
+ * available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+package com.microsoft.sqlserver.jdbc.messageHandler;
+
+import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import org.junit.jupiter.api.Tag;
+
+import java.sql.CallableStatement;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+import com.microsoft.sqlserver.jdbc.ISQLServerMessage;
+import com.microsoft.sqlserver.jdbc.ISQLServerMessageHandler;
+import com.microsoft.sqlserver.jdbc.SQLServerConnection;
+import com.microsoft.sqlserver.jdbc.TestResource;
+import com.microsoft.sqlserver.testframework.AbstractTest;
+import com.microsoft.sqlserver.testframework.Constants;
+
+
+@RunWith(JUnitPlatform.class)
+public class MessageHandlerTest extends AbstractTest {
+
+ @BeforeAll
+ public static void setupTests() throws Exception {
+ setConnection();
+ }
+
+ /**
+ * Helper method to count number of SQLWarnings in a chain
+ *
+ * @param str
+ * - Debug String, so we can evaluate from where we called it...
+ * @param sqlw
+ * - The SQL Warning chain. (can be null)
+ * @return A count of warnings
+ */
+ private static int getWarningCount(String str, SQLWarning sqlw) {
+ int count = 0;
+ while (sqlw != null) {
+ count++;
+ // System.out.println("DEBUG: getWarningCount(): [" + str + "] SQLWarning: Error=" + sqlw.getErrorCode() + ", Severity=" + ((SQLServerWarning)sqlw).getSQLServerError().getErrorSeverity() + ", Text=|" + sqlw.getMessage() + "|.");
+ sqlw = sqlw.getNextWarning();
+ }
+ return count;
+ }
+
+ /**
+ * Test message handler with normal Statement
+ *
+ * - Insert duplicate row -- Mapped to Info Message
+ * - Drop table that do not exist -- Mapped to ignore
+ *
+ */
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void testMsgHandlerWithStatement() throws Exception {
+ try (SQLServerConnection conn = getConnection()) {
+
+ class TestMsgHandler implements ISQLServerMessageHandler {
+ int numOfCalls = 0;
+ int numOfDowngrades = 0;
+ int numOfDiscards = 0;
+
+ @Override
+ public ISQLServerMessage messageHandler(ISQLServerMessage srvErrorOrWarning) {
+ numOfCalls++;
+ ISQLServerMessage retObj = srvErrorOrWarning;
+
+ if (srvErrorOrWarning.isErrorMessage()) {
+
+ // Downgrade: 2601 -- Cannot insert duplicate key row in object 'dbo.#msghandler_tmp_table' with unique index 'ix_id'. The duplicate key value is (1)
+ if (2601 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = srvErrorOrWarning.getSQLServerMessage().toSQLServerInfoMessage();
+ numOfDowngrades++;
+ }
+
+ // Discard: 3701 -- Cannot drop the table '#msghandler_tmp_table', because it does not exist or you do not have permission.
+ if (3701 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = null;
+ numOfDiscards++;
+ }
+ }
+
+ if (srvErrorOrWarning.isInfoMessage()) {
+
+ // Discard: 3621 -- The statement has been terminated.
+ if (3621 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = null;
+ numOfDiscards++;
+ }
+ }
+
+ return retObj;
+ }
+ }
+ TestMsgHandler testMsgHandler = new TestMsgHandler();
+
+ // Create a massage handler
+ conn.setServerMessageHandler(testMsgHandler);
+
+ try (Statement stmnt = conn.createStatement()) {
+
+ stmnt.executeUpdate("CREATE TABLE #msghandler_tmp_table(id int, c1 varchar(255))");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'create table', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'create table', at Statement.");
+
+ stmnt.executeUpdate("CREATE UNIQUE INDEX ix_id ON #msghandler_tmp_table(id)");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'create index', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'create index', at Statement.");
+
+ stmnt.executeUpdate("INSERT INTO #msghandler_tmp_table VALUES(1, 'row 1')");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'first insert', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'first insert', at Statement.");
+
+ stmnt.executeUpdate(
+ "INSERT INTO #msghandler_tmp_table VALUES(1, 'row 1 - again - msg handler downgrades it')");
+ assertNotNull(conn.getWarnings(),
+ "Expecting at least ONE SQLWarnings from 'second insert', which is a duplicate row, at Connection.");
+ assertNull(stmnt.getWarnings(),
+ "Expecting NO SQLWarnings from 'second insert', which is a duplicate row, at Statement.");
+ conn.clearWarnings(); // Clear Warnings at Connection level
+
+ stmnt.executeUpdate("DROP TABLE #msghandler_tmp_table");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'first drop table', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'first drop table', at Statement.");
+
+ stmnt.executeUpdate("DROP TABLE #msghandler_tmp_table"); // This should be IGNORED by the message handler
+ assertNull(conn.getWarnings(),
+ "Expecting NO SQLWarnings from 'second drop table, since it should be IGNORED by the message handler', at Connection.");
+ assertNull(stmnt.getWarnings(),
+ "Expecting NO SQLWarnings from 'second drop table, since it should be IGNORED by the message handler', at Statement.");
+
+ // numOfCalls to the message handler should be: 3
+ assertEquals(3, testMsgHandler.numOfCalls, "Number of message calls to the message handler.");
+
+ // numOfDowngrades in the message handler should be: 1
+ assertEquals(1, testMsgHandler.numOfDowngrades, "Number of message Downgrades in the message handler.");
+
+ // numOfDiscards in the message handler should be: 2
+ assertEquals(2, testMsgHandler.numOfDiscards, "Number of message Discards in the message handler.");
+ }
+
+ } catch (SQLException ex) {
+ fail(TestResource.getResource("R_unexpectedErrorMessage") + ex.getMessage());
+ }
+ }
+
+ /**
+ * Test message handler with PreparedStatement
+ *
+ * - Insert duplicate row -- Mapped to Info Message
+ * - Drop table that do not exist -- Mapped to ignore
+ *
+ */
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void testMsgHandlerWithPreparedStatement() throws Exception {
+ try (SQLServerConnection conn = getConnection()) {
+
+ class TestMsgHandler implements ISQLServerMessageHandler {
+ int numOfCalls = 0;
+ int numOfDowngrades = 0;
+ int numOfDiscards = 0;
+
+ @Override
+ public ISQLServerMessage messageHandler(ISQLServerMessage srvErrorOrWarning) {
+ numOfCalls++;
+ ISQLServerMessage retObj = srvErrorOrWarning;
+
+ if (srvErrorOrWarning.isErrorMessage()) {
+
+ // Downgrade: 2601 -- Cannot insert duplicate key row in object 'dbo.#msghandler_tmp_table' with unique index 'ix_id'. The duplicate key value is (1)
+ if (2601 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = srvErrorOrWarning.getSQLServerMessage().toSQLServerInfoMessage();
+ numOfDowngrades++;
+ }
+
+ // Discard: 3701 -- Cannot drop the table '#msghandler_tmp_table', because it does not exist or you do not have permission.
+ if (3701 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = null;
+ numOfDiscards++;
+ }
+ }
+
+ if (srvErrorOrWarning.isInfoMessage()) {
+
+ // Discard: 3621 -- The statement has been terminated.
+ if (3621 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = null;
+ numOfDiscards++;
+ }
+ }
+
+ return retObj;
+ }
+ }
+ TestMsgHandler testMsgHandler = new TestMsgHandler();
+
+ // Create a massage handler
+ conn.setServerMessageHandler(testMsgHandler);
+
+ try (Statement stmnt = conn.createStatement()) {
+ stmnt.executeUpdate("CREATE TABLE #msghandler_tmp_table(id int, c1 varchar(255))");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'create table', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'create table', at Statement.");
+ }
+
+ try (Statement stmnt = conn.createStatement()) {
+ stmnt.executeUpdate("CREATE UNIQUE INDEX ix_id ON #msghandler_tmp_table(id)");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'create index', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'create index', at Statement.");
+ }
+
+ try (PreparedStatement stmnt = conn.prepareStatement("INSERT INTO #msghandler_tmp_table VALUES(?, ?)")) {
+ stmnt.setInt(1, 1);
+ stmnt.setString(2, "row 1");
+ stmnt.executeUpdate();
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'first insert', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'first insert', at Statement.");
+ }
+
+ try (PreparedStatement stmnt = conn.prepareStatement("INSERT INTO #msghandler_tmp_table VALUES(?, ?)")) {
+ stmnt.setInt(1, 1);
+ stmnt.setString(2, "row 1 - again - msg handler downgrades it");
+ stmnt.executeUpdate();
+ assertNotNull(conn.getWarnings(),
+ "Expecting at least ONE SQLWarnings from 'second insert', which is a duplicate row, at Connection.");
+ assertNull(stmnt.getWarnings(),
+ "Expecting NO SQLWarnings from 'second insert', which is a duplicate row, at Statement.");
+ conn.clearWarnings(); // Clear Warnings at Connection level
+ }
+
+ try (Statement stmnt = conn.createStatement()) {
+ stmnt.executeUpdate("DROP TABLE #msghandler_tmp_table");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'first drop table', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'first drop table', at Statement.");
+ }
+
+ try (Statement stmnt = conn.createStatement()) {
+ stmnt.executeUpdate("DROP TABLE #msghandler_tmp_table");
+ assertNull(conn.getWarnings(), "Expecting NO SQLWarnings from 'first drop table', at Connection.");
+ assertNull(stmnt.getWarnings(), "Expecting NO SQLWarnings from 'first drop table', at Statement.");
+ }
+
+ // numOfCalls to the message handler should be: 3
+ assertEquals(3, testMsgHandler.numOfCalls, "Number of message calls to the message handler.");
+
+ // numOfDowngrades in the message handler should be: 1
+ assertEquals(1, testMsgHandler.numOfDowngrades, "Number of message Downgrades in the message handler.");
+
+ // numOfDiscards in the message handler should be: 2
+ assertEquals(2, testMsgHandler.numOfDiscards, "Number of message Discards in the message handler.");
+
+ } catch (SQLException ex) {
+ fail(TestResource.getResource("R_unexpectedErrorMessage") + ex.getMessage());
+ }
+ }
+
+ /**
+ * Test message handler with CallableStatement
+ *
+ * - Insert duplicate row -- Mapped to Info Message
+ * - Drop table that do not exist -- Mapped to ignore
+ *
+ */
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void testMsgHandlerWithCallableStatement() throws Exception {
+ try (SQLServerConnection conn = getConnection()) {
+
+ class TestMsgHandler implements ISQLServerMessageHandler {
+ int numOfCalls = 0;
+ int numOfDowngrades = 0;
+ int numOfDiscards = 0;
+
+ @Override
+ public ISQLServerMessage messageHandler(ISQLServerMessage srvErrorOrWarning) {
+ numOfCalls++;
+ ISQLServerMessage retObj = srvErrorOrWarning;
+
+ if (srvErrorOrWarning.isErrorMessage()) {
+
+ // Downgrade: 2601 -- Cannot insert duplicate key row in object 'dbo.#msghandler_tmp_table' with unique index 'ix_id'. The duplicate key value is (1)
+ if (2601 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = srvErrorOrWarning.getSQLServerMessage().toSQLServerInfoMessage();
+ numOfDowngrades++;
+ }
+
+ // Downgrade: 3701 -- Cannot drop the table '#msghandler_tmp_table', because it does not exist or you do not have permission.
+ if (3701 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = null;
+ numOfDiscards++;
+ }
+ }
+
+ if (srvErrorOrWarning.isInfoMessage()) {
+
+ // Discard: 3621 -- The statement has been terminated.
+ if (3621 == srvErrorOrWarning.getErrorNumber()) {
+ retObj = null;
+ numOfDiscards++;
+ }
+ }
+
+ return retObj;
+ }
+ }
+ TestMsgHandler testMsgHandler = new TestMsgHandler();
+
+ // Create a massage handler
+ conn.setServerMessageHandler(testMsgHandler);
+
+ // SQL to create procedure
+ String sqlCreateProc = "" + "CREATE PROCEDURE #msghandler_tmp_proc( \n" + " @out_row_count INT OUTPUT \n"
+ + ") \n" + "AS \n" + "BEGIN \n" + " -- Create a dummy table, with index \n"
+ + " CREATE TABLE #msghandler_tmp_table(id int, c1 varchar(255)) \n"
+ + " CREATE UNIQUE INDEX ix_id ON #msghandler_tmp_table(id) \n" + " \n"
+ + " -- Insert records 1 \n" + " INSERT INTO #msghandler_tmp_table VALUES(1, 'row 1') \n"
+ + " \n"
+ + " -- Insert records 1 -- Again, which will FAIL, but the message handler will downgrade it into a INFO Message \n"
+ + " INSERT INTO #msghandler_tmp_table VALUES(1, 'row 1 - again - msg handler downgrades it') \n"
+ + " \n" + " -- Count records \n" + " SELECT @out_row_count = count(*) \n"
+ + " FROM #msghandler_tmp_table \n" + " \n" + " -- Drop the table \n"
+ + " DROP TABLE #msghandler_tmp_table \n" + " \n"
+ + " -- Drop the table agin... The message handler will DISCARD the error\n"
+ + " DROP TABLE #msghandler_tmp_table \n" + " \n" + " RETURN 1 \n" + "END \n";
+
+ // Create the proc
+ try (Statement stmnt = conn.createStatement()) {
+ stmnt.executeUpdate(sqlCreateProc);
+ assertEquals(0, getWarningCount("Conn", conn.getWarnings()),
+ "Expecting NO SQLWarnings from 'create proc', at Connection.");
+ assertEquals(0, getWarningCount("Stmnt", conn.getWarnings()),
+ "Expecting NO SQLWarnings from 'create proc', at Statement.");
+ }
+
+ // Execute the proc
+ try (CallableStatement cstmnt = conn.prepareCall("{ ? =call #msghandler_tmp_proc(?) }")) {
+ cstmnt.registerOutParameter(1, Types.INTEGER);
+ cstmnt.registerOutParameter(2, Types.INTEGER);
+ cstmnt.execute();
+ int procReturnCode = cstmnt.getInt(1);
+ int procRowCount = cstmnt.getInt(2);
+
+ assertEquals(1, procReturnCode, "Expecting ReturnCode 1 from the temp procedure.");
+ assertEquals(1, procRowCount, "Expecting procRowCount 1 from the temp procedure.");
+
+ assertEquals(1, getWarningCount("Conn", conn.getWarnings()),
+ "Expecting NO SQLWarnings from 'exec proc', at Connection.");
+ assertEquals(0, getWarningCount("CStmnt", cstmnt.getWarnings()),
+ "Expecting NO SQLWarnings from 'exec proc', at CallableStatement.");
+ }
+
+ // numOfCalls to the message handler should be: 3
+ assertEquals(3, testMsgHandler.numOfCalls, "Number of message calls to the message handler.");
+
+ // numOfDowngrades in the message handler should be: 1
+ assertEquals(1, testMsgHandler.numOfDowngrades, "Number of message Downgrades in the message handler.");
+
+ // numOfDiscards in the message handler should be: 2
+ assertEquals(2, testMsgHandler.numOfDiscards, "Number of message Discards in the message handler.");
+
+ } catch (SQLException ex) {
+ fail(TestResource.getResource("R_unexpectedErrorMessage") + ex.getMessage());
+ }
+ }
+
+ /**
+ * Test message handler with CallableStatement -- and "feedback" messages
+ *
+ * Do a "long running procedure" and check that the message handler receives the "feedback" messages
+ */
+ @Test
+ @Tag(Constants.xAzureSQLDW)
+ public void testMsgHandlerWithProcedureFeedback() throws Exception {
+ try (SQLServerConnection conn = getConnection()) {
+
+ class TestMsgHandler implements ISQLServerMessageHandler {
+ int numOfCalls = 0;
+ Map feedbackMsgTs = new LinkedHashMap<>();
+
+ @Override
+ public ISQLServerMessage messageHandler(ISQLServerMessage srvErrorOrWarning) {
+ numOfCalls++;
+
+ if (50_000 == srvErrorOrWarning.getErrorNumber()) {
+ // System.out.println("DEBUG: testMsgHandlerWithProcedureFeedback.messageHandler(): FEEDBACK: " + srvErrorOrWarning.getErrorMessage());
+ // Remember when the message was received
+ feedbackMsgTs.put(srvErrorOrWarning.getErrorMessage(), System.currentTimeMillis());
+ }
+
+ return srvErrorOrWarning;
+ }
+ }
+ TestMsgHandler testMsgHandler = new TestMsgHandler();
+
+ // Create a massage handler
+ conn.setServerMessageHandler(testMsgHandler);
+
+ int doSqlLoopCount = 4;
+ // SQL to create procedure
+ String sqlCreateProc = "" + "CREATE PROCEDURE #msghandler_feeback_proc \n" + "AS \n" + "BEGIN \n"
+ + " DECLARE @loop_cnt INT = " + doSqlLoopCount + " \n" + " DECLARE @feedback VARCHAR(255) \n"
+ + " \n" + " WHILE (@loop_cnt > 0) \n" + " BEGIN \n" + " WAITFOR DELAY '00:00:01' \n"
+ + " \n"
+ + " SET @feedback = 'In proc, still looping... waiting for loop_count to reach 0. loop_count is now at: ' + convert(varchar(10), @loop_cnt) \n"
+ + " RAISERROR(@feedback, 0, 1) WITH NOWAIT \n" + " \n"
+ + " SET @loop_cnt = @loop_cnt - 1 \n" + " END \n" + " \n" + " RETURN @loop_cnt \n"
+ + "END \n";
+
+ // Create the proc
+ try (Statement stmnt = conn.createStatement()) {
+ stmnt.executeUpdate(sqlCreateProc);
+ assertEquals(0, getWarningCount("Conn", conn.getWarnings()),
+ "Expecting NO SQLWarnings from 'create proc', at Connection.");
+ assertEquals(0, getWarningCount("Stmnt", conn.getWarnings()),
+ "Expecting NO SQLWarnings from 'create proc', at Statement.");
+ }
+
+ // Execute the proc
+ try (CallableStatement cstmnt = conn.prepareCall("{ ? =call #msghandler_feeback_proc }")) {
+ cstmnt.registerOutParameter(1, Types.INTEGER);
+ cstmnt.execute();
+ int procReturnCode = cstmnt.getInt(1);
+
+ assertEquals(0, procReturnCode, "Unexpected ReturnCode from the temp procedure.");
+
+ assertEquals(0, getWarningCount("conn", conn.getWarnings()),
+ "Unexpected Number Of SQLWarnings from 'exec proc', at Connection.");
+ assertEquals(doSqlLoopCount, getWarningCount("cstmnt", cstmnt.getWarnings()),
+ "Unexpected Number Of SQLWarnings from 'exec proc', at CallableStatement.");
+ }
+
+ // numOfCalls to the message handler should be: #
+ assertEquals(doSqlLoopCount, testMsgHandler.numOfCalls, "Number of message calls to the message handler.");
+
+ // Loop all received messages and check that they are within a second (+-200ms)
+ long prevTime = 0;
+ for (Entry entry : testMsgHandler.feedbackMsgTs.entrySet()) {
+ if (prevTime == 0) {
+ prevTime = entry.getValue();
+ continue;
+ }
+
+ long msDiff = entry.getValue() - prevTime;
+ if (msDiff < 800 || msDiff > 1200) {
+ fail("Received Messages is to far apart. They should be approx 1000 ms. msDiff=" + msDiff
+ + " Message=|" + entry.getKey() + "|.");
+ }
+
+ prevTime = entry.getValue();
+ }
+
+ } catch (SQLException ex) {
+ fail(TestResource.getResource("R_unexpectedErrorMessage") + ex.getMessage());
+ }
+ }
+}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/preparedStatement/BatchExecutionWithBulkCopyTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/preparedStatement/BatchExecutionWithBulkCopyTest.java
index 4f5a4d66b..c1917fd68 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/preparedStatement/BatchExecutionWithBulkCopyTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/preparedStatement/BatchExecutionWithBulkCopyTest.java
@@ -22,6 +22,7 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
+import java.util.Random;
import java.util.UUID;
import org.junit.jupiter.api.AfterAll;
@@ -334,6 +335,7 @@ public void testMixColumns() throws Exception {
}
@Test
+ @Tag((Constants.xAzureSQLDW))
public void testNullGuid() throws Exception {
String valid = "insert into " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (c24) values (?)";
try (Connection connection = PrepUtil.getConnection(connectionString + ";useBulkCopyForBatchInsert=true;");
@@ -809,27 +811,18 @@ public void testComputedCols() throws Exception {
@Test
public void testNoSpaceInsert() throws Exception {
// table name with valid alphanumeric chars that don't need to be escaped, since escaping the table name would not test the space issue
- String testNoSpaceInsertTableName = "testNoSpaceInsertTable" + RandomData.generateInt(false);
- String valid = "insert into " + testNoSpaceInsertTableName + "(id, json)" + " values(?, ?)";
+ String testNoSpaceInsertTableName = "testNoSpaceInsertTable" + (new Random()).nextInt(Integer.MAX_VALUE);
+ String valid = "insert into " + testNoSpaceInsertTableName + "(col)" + " values(?)";
try (Connection connection = PrepUtil.getConnection(connectionString + ";useBulkCopyForBatchInsert=true;");
SQLServerPreparedStatement pstmt = (SQLServerPreparedStatement) connection.prepareStatement(valid);
Statement stmt = (SQLServerStatement) connection.createStatement();) {
- Field f1 = SQLServerConnection.class.getDeclaredField("isAzureDW");
- f1.setAccessible(true);
- f1.set(connection, true);
- TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableNameBulkComputedCols), stmt);
- String createTable = "create table " + testNoSpaceInsertTableName
- + " (id nvarchar(100) not null, json nvarchar(max) not null,"
- + " vcol1 as json_value([json], '$.vcol1'), vcol2 as json_value([json], '$.vcol2'))";
+ TestUtils.dropTableIfExists(testNoSpaceInsertTableName, stmt);
+ String createTable = "create table " + testNoSpaceInsertTableName + " (col varchar(4))";
stmt.execute(createTable);
- String jsonValue = "{\"vcol1\":\"" + UUID.randomUUID().toString() + "\",\"vcol2\":\""
- + UUID.randomUUID().toString() + "\" }";
- String idValue = UUID.randomUUID().toString();
- pstmt.setString(1, idValue);
- pstmt.setString(2, jsonValue);
+ pstmt.setString(1, "test");
pstmt.addBatch();
pstmt.executeBatch();
} finally {
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/resiliency/BasicConnectionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/resiliency/BasicConnectionTest.java
index b19d25248..d4ba85fa5 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/resiliency/BasicConnectionTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/resiliency/BasicConnectionTest.java
@@ -6,15 +6,20 @@
package com.microsoft.sqlserver.jdbc.resiliency;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
+import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
import java.util.UUID;
import javax.sql.PooledConnection;
@@ -64,7 +69,7 @@ public void testBasicConnectionAAD() throws Exception {
basicReconnect("jdbc:sqlserver://" + azureServer + ";database=" + azureDatabase + ";user="
+ azureUserName + ";password=" + azurePassword
+ ";loginTimeout=90;Authentication=ActiveDirectoryPassword");
- retry = THROTTLE_RETRY_COUNT + 1;
+ retry = THROTTLE_RETRY_COUNT + 1;
} catch (Exception e) {
if (e.getMessage().matches(TestUtils.formatErrorMsg("R_crClientAllRecoveryAttemptsFailed"))) {
System.out.println(e.getMessage() + ". Recovery failed, retry #" + retry + " in "
@@ -367,6 +372,99 @@ public void testPreparedStatementCacheShouldBeCleared() throws SQLException {
}
}
+ @Test
+ public void testPreparedStatementHandleOfStatementShouldBeCleared() throws SQLException {
+ try (SQLServerConnection con = (SQLServerConnection) ResiliencyUtils.getConnection(connectionString)) {
+ int cacheSize = 2;
+ String query = String.format("/*testPreparedStatementHandleOfStatementShouldBeCleared%s*/SELECT 1; -- ",
+ UUID.randomUUID().toString());
+
+ // enable caching
+ con.setDisableStatementPooling(false);
+ con.setStatementPoolingCacheSize(cacheSize);
+ con.setServerPreparedStatementDiscardThreshold(cacheSize);
+
+ List statements = new LinkedList<>();
+
+ // add statements to fill cache
+ for (int i = 0; i < cacheSize + 1; ++i) {
+ SQLServerPreparedStatement pstmt = (SQLServerPreparedStatement) con.prepareStatement(query + i);
+ pstmt.execute();
+ pstmt.execute();
+ pstmt.execute();
+ pstmt.getMoreResults();
+ statements.add(pstmt);
+ }
+
+ // handle of the prepared statement should be set
+ assertNotEquals(0, statements.get(1).getPreparedStatementHandle());
+
+ ResiliencyUtils.killConnection(con, connectionString, 1);
+
+ // call first statement to trigger reconnect
+ statements.get(0).execute();
+
+ // handle of the other statements should be cleared after reconnect
+ assertEquals(0, statements.get(1).getPreparedStatementHandle());
+ }
+ }
+
+ @Test
+ public void testPreparedStatementShouldNotUseWrongHandleAfterReconnect() throws SQLException {
+ try (SQLServerConnection con = (SQLServerConnection) ResiliencyUtils.getConnection(connectionString)) {
+ int cacheSize = 3;
+ String queryOne = "select * from sys.sysusers where name=?;";
+ String queryTwo = "select * from sys.sysusers where name=? and uid=?;";
+ String queryThree = "select * from sys.sysusers where name=? and uid=? and islogin=?";
+
+ String parameterOne = "name";
+ int parameterUid = 0;
+ int parameterIsLogin = 0;
+
+ // enable caching
+ con.setDisableStatementPooling(false);
+ con.setStatementPoolingCacheSize(cacheSize);
+ con.setServerPreparedStatementDiscardThreshold(cacheSize);
+
+ List statements = new LinkedList<>();
+
+ PreparedStatement ps = con.prepareStatement(queryOne);
+ ps.setString(1, parameterOne);
+ statements.add(ps);
+
+ ps = con.prepareStatement(queryTwo);
+ ps.setString(1, parameterOne);
+ ps.setInt(2, parameterUid);
+ statements.add(ps);
+
+ ps = con.prepareStatement(queryThree);
+ ps.setString(1, parameterOne);
+ ps.setInt(2, parameterUid);
+ ps.setInt(3, parameterIsLogin);
+ statements.add(ps);
+
+ // add new statements to fill cache
+ for (PreparedStatement preparedStatement : statements) {
+ preparedStatement.execute();
+ preparedStatement.execute();
+ preparedStatement.execute();
+ preparedStatement.getMoreResults();
+ }
+
+ ResiliencyUtils.killConnection(con, connectionString, 1);
+
+ // call statements in reversed order, in order to force the statement to use the wrong handle
+ // first execute triggers a reconnect
+ Collections.reverse(statements);
+ for (PreparedStatement preparedStatement : statements) {
+ preparedStatement.execute();
+ preparedStatement.execute();
+ preparedStatement.execute();
+ preparedStatement.getMoreResults();
+ }
+ }
+ }
+
@Test
public void testUnprocessedResponseCountSuccessfulIdleConnectionRecovery() throws SQLException {
try (SQLServerConnection con = (SQLServerConnection) ResiliencyUtils.getConnection(connectionString)) {
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecutionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecutionTest.java
index 3482eff6b..0dace62b2 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecutionTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecutionTest.java
@@ -13,11 +13,17 @@
import java.sql.BatchUpdateException;
import java.sql.CallableStatement;
import java.sql.Connection;
+import java.sql.Date;
+import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
import java.util.Arrays;
+import java.util.Calendar;
+import java.util.TimeZone;
import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
import org.junit.jupiter.api.AfterAll;
@@ -54,6 +60,10 @@ public class BatchExecutionTest extends AbstractTest {
private static String ctstable3;
private static String ctstable4;
private static String ctstable3Procedure1;
+ private static String timestampTable1 = AbstractSQLGenerator
+ .escapeIdentifier(RandomUtil.getIdentifier("timestamptable1"));
+ private static String timestampTable2 = AbstractSQLGenerator
+ .escapeIdentifier(RandomUtil.getIdentifier("timestamptable2"));
/**
* This tests the updateCount when the error query does cause a SQL state HY008.
@@ -99,6 +109,184 @@ public void testBatchUpdateCountTrueOnFirstPstmtSpPrepare() throws Exception {
testBatchUpdateCountWith(5, 4, true, "prepare", expectedUpdateCount);
}
+ @Test
+ public void testValidTimezoneForTimestampBatchInsertWithBulkCopy() throws Exception {
+ Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
+ long ms = 1578743412000L;
+
+ // Insert Timestamp using batch insert
+ try (Connection con = DriverManager.getConnection(connectionString); Statement stmt = con.createStatement();
+ PreparedStatement pstmt = con.prepareStatement("INSERT INTO " + timestampTable1 + " VALUES(?)")) {
+
+ TestUtils.dropTableIfExists(timestampTable1, stmt);
+ String createSql = "CREATE TABLE " + timestampTable1 + " (c1 DATETIME2(3))";
+ stmt.execute(createSql);
+
+ Timestamp timestamp = new Timestamp(ms);
+
+ pstmt.setTimestamp(1, timestamp, gmtCal);
+ pstmt.addBatch();
+ pstmt.executeBatch();
+ }
+
+ // Insert Timestamp using bulkcopy for batch insert
+ try (Connection con = DriverManager.getConnection(
+ connectionString + ";useBulkCopyForBatchInsert=true;sendTemporalDataTypesAsStringForBulkCopy=false;");
+ PreparedStatement pstmt = con.prepareStatement("INSERT INTO " + timestampTable1 + " VALUES(?)")) {
+
+ Timestamp timestamp = new Timestamp(ms);
+
+ pstmt.setTimestamp(1, timestamp, gmtCal);
+ pstmt.addBatch();
+ pstmt.executeBatch();
+ }
+
+ // Compare Timestamp values inserted, should be the same
+ try (Connection con = DriverManager.getConnection(connectionString); Statement stmt = con.createStatement();
+ ResultSet rs = stmt.executeQuery("SELECT * FROM " + timestampTable1)) {
+ Timestamp ts0;
+ Timestamp ts1;
+ Time t0;
+ Time t1;
+ Date d0;
+ Date d1;
+
+ rs.next();
+ ts0 = rs.getTimestamp(1);
+ t0 = rs.getTime(1);
+ d0 = rs.getDate(1);
+ rs.next();
+ ts1 = rs.getTimestamp(1);
+ t1 = rs.getTime(1);
+ d1 = rs.getDate(1);
+
+ assertEquals(ts0, ts1);
+ assertEquals(t0, t1);
+ assertEquals(d0, d1);
+ }
+ }
+
+ @Test
+ public void testValidTimezonesDstTimestampBatchInsertWithBulkCopy() throws Exception {
+ Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
+
+ for (String tzId : TimeZone.getAvailableIDs()) {
+ TimeZone.setDefault(TimeZone.getTimeZone(tzId));
+
+ long ms = 1696127400000L; // DST
+
+ // Insert Timestamp using batch insert
+ try (Connection con = DriverManager.getConnection(connectionString); Statement stmt = con.createStatement();
+ PreparedStatement pstmt = con.prepareStatement("INSERT INTO " + timestampTable1 + " VALUES(?)")) {
+
+ TestUtils.dropTableIfExists(timestampTable1, stmt);
+ String createSql = "CREATE TABLE " + timestampTable1 + " (c1 DATETIME2(3))";
+ stmt.execute(createSql);
+
+ Timestamp timestamp = new Timestamp(ms);
+
+ pstmt.setTimestamp(1, timestamp, gmtCal);
+ pstmt.addBatch();
+ pstmt.executeBatch();
+ }
+
+ // Insert Timestamp using bulkcopy for batch insert
+ try (Connection con = DriverManager.getConnection(connectionString
+ + ";useBulkCopyForBatchInsert=true;sendTemporalDataTypesAsStringForBulkCopy=false;");
+ PreparedStatement pstmt = con.prepareStatement("INSERT INTO " + timestampTable1 + " VALUES(?)")) {
+
+ Timestamp timestamp = new Timestamp(ms);
+
+ pstmt.setTimestamp(1, timestamp, gmtCal);
+ pstmt.addBatch();
+ pstmt.executeBatch();
+ }
+
+ // Compare Timestamp values inserted, should be the same
+ try (Connection con = DriverManager.getConnection(connectionString); Statement stmt = con.createStatement();
+ ResultSet rs = stmt.executeQuery("SELECT * FROM " + timestampTable1)) {
+ Timestamp ts0;
+ Timestamp ts1;
+ Time t0;
+ Time t1;
+ Date d0;
+ Date d1;
+
+ rs.next();
+ ts0 = rs.getTimestamp(1);
+ t0 = rs.getTime(1);
+ d0 = rs.getDate(1);
+ rs.next();
+ ts1 = rs.getTimestamp(1);
+ t1 = rs.getTime(1);
+ d1 = rs.getDate(1);
+
+ String failureMsg = "Failed for time zone: " + tzId;
+ assertEquals(ts0, ts1, failureMsg);
+ assertEquals(t0, t1, failureMsg);
+ assertEquals(d0, d1, failureMsg);
+ }
+ }
+ }
+
+ @Test
+ public void testBatchInsertTimestampNoTimezoneDoubleConversion() throws Exception {
+ Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
+ long ms = 1578743412000L;
+
+ // Insert Timestamp using prepared statement when useBulkCopyForBatchInsert=true
+ try (Connection con = DriverManager.getConnection(
+ connectionString + ";useBulkCopyForBatchInsert=true;sendTemporalDataTypesAsStringForBulkCopy=false;");
+ Statement stmt = con.createStatement();
+ PreparedStatement pstmt = con.prepareStatement("INSERT INTO " + timestampTable2 + " VALUES(?)")) {
+
+ TestUtils.dropTableIfExists(timestampTable2, stmt);
+ String createSql = "CREATE TABLE" + timestampTable2 + " (c1 DATETIME2(3))";
+ stmt.execute(createSql);
+
+ Timestamp timestamp = new Timestamp(ms);
+
+ pstmt.setTimestamp(1, timestamp, gmtCal);
+ pstmt.execute();
+ }
+
+ // Insert Timestamp using bulkcopy for batch insert
+ try (Connection con = DriverManager.getConnection(
+ connectionString + ";useBulkCopyForBatchInsert=true;sendTemporalDataTypesAsStringForBulkCopy=false;");
+ PreparedStatement pstmt = con.prepareStatement("INSERT INTO " + timestampTable2 + " VALUES(?)")) {
+
+ Timestamp timestamp = new Timestamp(ms);
+
+ pstmt.setTimestamp(1, timestamp, gmtCal);
+ pstmt.addBatch();
+ pstmt.executeBatch();
+ }
+
+ // Compare Timestamp values inserted, should be the same
+ try (Connection con = DriverManager.getConnection(connectionString); Statement stmt = con.createStatement();
+ ResultSet rs = stmt.executeQuery("SELECT * FROM " + timestampTable2)) {
+ Timestamp ts0;
+ Timestamp ts1;
+ Time t0;
+ Time t1;
+ Date d0;
+ Date d1;
+
+ rs.next();
+ ts0 = rs.getTimestamp(1);
+ t0 = rs.getTime(1);
+ d0 = rs.getDate(1);
+ rs.next();
+ ts1 = rs.getTimestamp(1);
+ t1 = rs.getTime(1);
+ d1 = rs.getDate(1);
+
+ assertEquals(ts0, ts1);
+ assertEquals(t0, t1);
+ assertEquals(d0, d1);
+ }
+ }
+
/**
* This tests the updateCount when the error query does not cause a SQL state HY008.
*
@@ -466,6 +654,9 @@ private static void dropTable() throws SQLException {
TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(ctstable1), stmt);
TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(ctstable3), stmt);
TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(ctstable4), stmt);
+ TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(ctstable4), stmt);
+ TestUtils.dropTableIfExists(timestampTable1, stmt);
+ TestUtils.dropTableIfExists(timestampTable2, stmt);
}
}
diff --git a/src/test/java/com/microsoft/sqlserver/testframework/AbstractTest.java b/src/test/java/com/microsoft/sqlserver/testframework/AbstractTest.java
index d17fa1469..1ce9cd195 100644
--- a/src/test/java/com/microsoft/sqlserver/testframework/AbstractTest.java
+++ b/src/test/java/com/microsoft/sqlserver/testframework/AbstractTest.java
@@ -62,6 +62,9 @@ public abstract class AbstractTest {
protected static String tenantID;
protected static String[] keyIDs = null;
+ protected static String linkedServer = null;
+ protected static String remoteUser = null;
+ protected static String remotePassword = null;
protected static String[] enclaveServer = null;
protected static String[] enclaveAttestationUrl = null;
protected static String[] enclaveAttestationProtocol = null;
@@ -197,6 +200,10 @@ public static void setup() throws Exception {
clientKeyPassword = getConfiguredProperty("clientKeyPassword", "");
+ linkedServer = getConfiguredProperty("linkedServer", null);
+ remoteUser = getConfiguredProperty("remoteUser", null);
+ remotePassword = getConfiguredProperty("remotePassword", null);
+
kerberosServer = getConfiguredProperty("kerberosServer", null);
kerberosServerPort = getConfiguredProperty("kerberosServerPort", null);
diff --git a/src/test/java/com/microsoft/sqlserver/testframework/Constants.java b/src/test/java/com/microsoft/sqlserver/testframework/Constants.java
index 92ba90811..e4338fc92 100644
--- a/src/test/java/com/microsoft/sqlserver/testframework/Constants.java
+++ b/src/test/java/com/microsoft/sqlserver/testframework/Constants.java
@@ -179,6 +179,11 @@ private Constants() {}
public static final String SEND_TEMPORAL_DATATYPES_AS_STRING_FOR_BULK_COPY = "SENDTEMPORALDATATYPESASSTRINGFORBULKCOPY";
public static final String PREPARE_METHOD = "PREPAREMETHOD";
public static final String CONFIG_PROPERTIES_FILE = "config.properties";
+ public static final String UTF8 = "UTF-8";
+ public static final double MAX_VALUE_MONEY = 922337203685477.5807;
+ public static final double MIN_VALUE_MONEY = -922337203685477.5808;
+ public static final double MAX_VALUE_SMALLMONEY = 214748.3647;
+ public static final double MIN_VALUE_SMALLMONEY = -214748.3648;
public enum LOB {
CLOB,
diff --git a/src/test/resources/BulkCopyCSVTestInputDelimiterEscape.csv b/src/test/resources/BulkCopyCSVTestInputDelimiterEscape.csv
index 10afd5d84..9425b0a1d 100644
--- a/src/test/resources/BulkCopyCSVTestInputDelimiterEscape.csv
+++ b/src/test/resources/BulkCopyCSVTestInputDelimiterEscape.csv
@@ -9,3 +9,7 @@
9@1997@Ford@E350@"Super@ ""luxurious"" truck"@
10@1997@ "Ford" @E350@ "E63"@
11@1997@Ford@E350@" Super luxurious truck "@
+12@1997@"F
+o
+r
+d"@"E350"@"""Super"" ""luxurious"" ""truck"""@