From 740b25f08936dd7ed7f67bee9d39a502def8250e Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 28 Jun 2023 14:59:09 -0700 Subject: [PATCH 01/51] Initial implementation for exec cstmt directly --- .../microsoft/sqlserver/jdbc/Parameter.java | 64 +- .../jdbc/SQLServerCallableStatement.java | 741 +++++++++++------- .../sqlserver/jdbc/SQLServerConnection.java | 35 +- .../jdbc/SQLServerPreparedStatement.java | 77 +- .../sqlserver/jdbc/SQLServerStatement.java | 15 +- .../com/microsoft/sqlserver/jdbc/dtv.java | 19 +- 6 files changed, 634 insertions(+), 317 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index aa64c87b8..2f64c4e41 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -48,6 +48,7 @@ final CryptoMetadata getCryptoMetadata() { private boolean shouldHonorAEForParameter = false; private boolean userProvidesPrecision = false; private boolean userProvidesScale = false; + private boolean isReturnValue = false; // The parameter type definition private String typeDefinition = null; @@ -70,6 +71,60 @@ boolean isOutput() { return null != registeredOutDTV; } + /** + * Returns true/false if the parameter is of return type + * + * @return isReturnValue + */ + boolean isReturnValue() { + return isReturnValue; + } + + /** + * Sets the parameter to be of return type + * + * @param isReturnValue + */ + void setReturnValue(boolean isReturnValue) { + this.isReturnValue = isReturnValue; + } + + /** + * Sets the name of the parameter + * + * @param name + */ + void setName(String name) { + this.name = name; + } + + /** + * Retrieve the name of the parameter + * + * @return + */ + String getName() { + return this.name; + } + + /** + * Returns the `registeredOutDTV` instance of the parameter + * + * @return registeredOutDTV + */ + DTV getRegisteredOutDTV() { + return this.registeredOutDTV; + } + + /** + * Returns the `inputDTV` instance of the parameter + * + * @return inputDTV + */ + DTV getInputDTV() { + return this.inputDTV; + } + // Since a parameter can have only one type definition for both sending its value to the server (IN) // and getting its value from the server (OUT), we use the JDBC type of the IN parameter value if there // is one; otherwise we use the registered OUT param JDBC type. @@ -246,7 +301,7 @@ void setFromReturnStatus(int returnStatus, SQLServerConnection con) throws SQLSe if (null == getterDTV) getterDTV = new DTV(); - getterDTV.setValue(null, JDBCType.INTEGER, returnStatus, JavaType.INTEGER, null, null, null, con, + getterDTV.setValue(null, this.getJdbcType(), returnStatus, JavaType.INTEGER, null, null, null, con, getForceEncryption()); } @@ -387,8 +442,13 @@ boolean isValueGotten() { Object getValue(JDBCType jdbcType, InputStreamGetterArgs getterArgs, Calendar cal, TDSReader tdsReader, SQLServerStatement statement) throws SQLServerException { - if (null == getterDTV) + if (null == getterDTV) { getterDTV = new DTV(); + } + + if (null != tdsReader) { + deriveTypeInfo(tdsReader); + } deriveTypeInfo(tdsReader); // If the parameter is not encrypted or column encryption is turned off (either at connection or diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index ee6be2904..e52caa764 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -25,11 +25,7 @@ import java.sql.Timestamp; import java.text.MessageFormat; import java.time.LocalDateTime; -import java.util.Calendar; -import java.util.HashMap; -import java.util.TreeMap; -import java.util.Map; -import java.util.UUID; +import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; @@ -73,12 +69,25 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple /** Currently active Stream Note only one stream can be active at a time */ private transient Closeable activeStream; + /** Checks if return values is already accessed in stored procedure */ + private boolean returnValueIsAccessed = false; + /** map */ private Map map = new ConcurrentHashMap<>(); /** atomic integer */ AtomicInteger ai = new AtomicInteger(0); + /** + * Enum to check if the callablestatement is a setter or getter method. This enum is used in method findColumn where + * we get the parameter/column by name + * + */ + enum CallableStatementGetterSetterMethod { + isSetterMethod, + isGetterMethod + } + /** * Create a new callable statement. * @@ -97,6 +106,7 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple SQLServerCallableStatement(SQLServerConnection connection, String sql, int nRSType, int nRSConcur, SQLServerStatementColumnEncryptionSetting stmtColEncSetting) throws SQLServerException { super(connection, sql, nRSType, nRSConcur, stmtColEncSetting); + returnValueIsAccessed = false; } @Override @@ -168,13 +178,29 @@ private Parameter getOutParameter(int i) throws SQLServerException { processResults(); // if this item has been indexed already leave! - if (inOutParam[i - 1] == lastParamAccessed || inOutParam[i - 1].isValueGotten()) + if (inOutParam[i - 1] == lastParamAccessed || inOutParam[i - 1].isValueGotten()) { + // if it is a return value, increment the nOutParamsAssigned. Checking for isCursorable here is because the + // driver is executing + // the stored procedure for cursorable ones differently ( calling sp_cursorexecute r sp_cursorprepexec. + if (bReturnValueSyntax && inOutParam[i - 1].isValueGotten() && inOutParam[i - 1].isReturnValue() + && !returnValueIsAccessed && !isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, + bReturnValueSyntax)) { + nOutParamsAssigned++; + returnValueIsAccessed = true; + } return inOutParam[i - 1]; + } + + if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType) { + return inOutParam[i - 1]; + } // Skip OUT parameters (buffering them as we go) until we // reach the one we're looking for. - while (outParamIndex != i - 1) + while (outParamIndex != i - 1) { skipOutParameters(1, false); + } return inOutParam[i - 1]; } @@ -226,18 +252,24 @@ final void processOutParameters() throws SQLServerException { } // Next, if there are any unindexed parameters left then discard them too. - assert nOutParamsAssigned <= nOutParams; - if (nOutParamsAssigned < nOutParams) - skipOutParameters(nOutParams - nOutParamsAssigned, true); - - // Finally, skip the last-indexed parameter. If there were no unindexed parameters - // in the previous step, then this is the last-indexed parameter left from the first - // step. If we skipped unindexed parameters in the previous step, then this is the - // last-indexed parameter left at the end of that step. - if (outParamIndex >= 0) { - inOutParam[outParamIndex].skipValue(resultsReader(), true); - inOutParam[outParamIndex].resetOutputValue(); - outParamIndex = -1; + if (nOutParamsAssigned <= nOutParams) { + if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod)) { + nOutParamsAssigned++; + } + + if (nOutParamsAssigned < nOutParams) { + skipOutParameters(nOutParams - nOutParamsAssigned, true); + } + + // Finally, skip the last-indexed parameter. If there were no unindexed parameters + // in the previous step, then this is the last-indexed parameter left from the first + // step. If we skipped unindexed parameters in the previous step, then this is the + // last-indexed parameter left at the end of that step. + if (outParamIndex >= 0) { + inOutParam[outParamIndex].skipValue(resultsReader(), true); + inOutParam[outParamIndex].resetOutputValue(); + outParamIndex = -1; + } } } @@ -308,60 +340,73 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { OutParamHandler outParamHandler = new OutParamHandler(); + if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod) && !isTVPType + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { + nOutParamsAssigned++; + } + // Index the application OUT parameters - assert numParamsToSkip <= nOutParams - nOutParamsAssigned; - for (int paramsSkipped = 0; paramsSkipped < numParamsToSkip; ++paramsSkipped) { - // Discard the last-indexed parameter by skipping over it and - // discarding the value if it is no longer needed. - if (-1 != outParamIndex) { - inOutParam[outParamIndex].skipValue(resultsReader(), discardValues); - if (discardValues) - inOutParam[outParamIndex].resetOutputValue(); - } + if (numParamsToSkip <= nOutParams - nOutParamsAssigned) { + for (int paramsSkipped = 0; paramsSkipped < numParamsToSkip; ++paramsSkipped) { + // Discard the last-indexed parameter by skipping over it and + // discarding the value if it is no longer needed. + if (-1 != outParamIndex) { + inOutParam[outParamIndex].skipValue(resultsReader(), discardValues); + if (discardValues) { + inOutParam[outParamIndex].resetOutputValue(); + } + } - // Look for the next parameter value in the response. - outParamHandler.reset(); - TDSParser.parse(resultsReader(), outParamHandler); - - // If we don't find it, then most likely the server encountered some error that - // was bad enough to halt statement execution before returning OUT params, but - // not necessarily bad enough to close the connection. - if (!outParamHandler.foundParam()) { - // If we were just going to discard the OUT parameters we found anyway, - // then it's no problem that we didn't find any of them. For exmaple, - // when we are closing or reexecuting this CallableStatement (that is, - // calling in through processResponse), we don't care that execution - // failed to return the OUT parameters. - if (discardValues) - break; - - // If we were asked to retain the OUT parameters as we skip past them, - // then report an error if we did not find any. - MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_valueNotSetForParameter")); - Object[] msgArgs = {outParamIndex + 1}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), null, false); - } + // Look for the next parameter value in the response. + outParamHandler.reset(); + TDSParser.parse(resultsReader(), outParamHandler); + + // If we don't find it, then most likely the server encountered some error that + // was bad enough to halt statement execution before returning OUT params, but + // not necessarily bad enough to close the connection. + if (!outParamHandler.foundParam()) { + // If we were just going to discard the OUT parameters we found anyway, + // then it's no problem that we didn't find any of them. For exmaple, + // when we are closing or reexecuting this CallableStatement (that is, + // calling in through processResponse), we don't care that execution + // failed to return the OUT parameters. + if (discardValues) + break; + + // If we were asked to retain the OUT parameters as we skip past them, + // then report an error if we did not find any. + MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_valueNotSetForParameter")); + Object[] msgArgs = {outParamIndex + 1}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), null, false); + } - // In Yukon and later, large Object output parameters are reordered to appear at - // the end of the stream. First group of small parameters is sent, followed by - // group of large output parameters. There is no reordering within the groups. - - // Note that parameter ordinals are 0-indexed and that the return status is not - // considered to be an output parameter. - outParamIndex = outParamHandler.srv.getOrdinalOrLength(); - - // Statements need to have their out param indices adjusted by the number - // of sp_[cursor][prep]exec params. - outParamIndex -= outParamIndexAdjustment; - if ((outParamIndex < 0 || outParamIndex >= inOutParam.length) || (!inOutParam[outParamIndex].isOutput())) { - if (getStatementLogger().isLoggable(java.util.logging.Level.INFO)) { - getStatementLogger().info(toString() + " Unexpected outParamIndex: " + outParamIndex - + "; adjustment: " + outParamIndexAdjustment); + // In Yukon and later, large Object output parameters are reordered to appear at + // the end of the stream. First group of small parameters is sent, followed by + // group of large output parameters. There is no reordering within the groups. + + // Note that parameter ordinals are 0-indexed and that the return status is not + // considered to be an output parameter. + outParamIndex = outParamHandler.srv.getOrdinalOrLength(); + + if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && SQLServerConnection + .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { + outParamIndex++; + } else { + // Statements need to have their out param indices adjusted by the number + // of sp_[cursor][prep]exec params. + outParamIndex -= outParamIndexAdjustment; } - connection.throwInvalidTDS(); - } - ++nOutParamsAssigned; + if ((outParamIndex < 0 || outParamIndex >= inOutParam.length) || (!inOutParam[outParamIndex].isOutput())) { + if (getStatementLogger().isLoggable(java.util.logging.Level.INFO)) { + getStatementLogger().info(toString() + " Unexpected outParamIndex: " + outParamIndex + + "; adjustment: " + outParamIndexAdjustment); + } + connection.throwInvalidTDS(); + } + + ++nOutParamsAssigned; + } } } @@ -444,7 +489,13 @@ private Parameter getterGetParam(int index) throws SQLServerException { } private Object getValue(int parameterIndex, JDBCType jdbcType) throws SQLServerException { - return getterGetParam(parameterIndex).getValue(jdbcType, null, null, resultsReader(), this); + Parameter param = getterGetParam(parameterIndex); + if (!param.isValueGotten() || !param.isReturnValue()) { + return param.getValue(jdbcType, null, null, resultsReader(), this); + } else { + // if we have already retrieved the value, we have the typeInfo and we do not need to get it again + return param.getValue(param.getJdbcType(), null, null, null, this); + } } private Object getValue(int parameterIndex, JDBCType jdbcType, Calendar cal) throws SQLServerException { @@ -487,7 +538,8 @@ public int getInt(int index) throws SQLServerException { public int getInt(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getInt", parameterName); checkClosed(); - Integer value = (Integer) getValue(findColumn(parameterName), JDBCType.INTEGER); + Integer value = (Integer) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.INTEGER); loggerExternal.exiting(getClassNameLogging(), "getInt", value); return null != value ? value : 0; } @@ -510,7 +562,8 @@ public String getString(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getString", parameterName); checkClosed(); String value = null; - Object objectValue = getValue(findColumn(parameterName), JDBCType.CHAR); + Object objectValue = getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.CHAR); if (null != objectValue) { value = objectValue.toString(); } @@ -531,7 +584,8 @@ public final String getNString(int parameterIndex) throws SQLException { public final String getNString(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNString", parameterName); checkClosed(); - String value = (String) getValue(findColumn(parameterName), JDBCType.NCHAR); + String value = (String) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.NCHAR); loggerExternal.exiting(getClassNameLogging(), "getNString", value); return value; } @@ -561,7 +615,8 @@ public BigDecimal getBigDecimal(String parameterName, int scale) throws SQLServe if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterName, scale}); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.DECIMAL); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); if (null != value) value = value.setScale(scale, BigDecimal.ROUND_DOWN); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); @@ -581,7 +636,8 @@ public boolean getBoolean(int index) throws SQLServerException { public boolean getBoolean(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBoolean", parameterName); checkClosed(); - Boolean value = (Boolean) getValue(findColumn(parameterName), JDBCType.BIT); + Boolean value = (Boolean) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.BIT); loggerExternal.exiting(getClassNameLogging(), "getBoolean", value); return null != value ? value : false; } @@ -600,7 +656,8 @@ public byte getByte(int index) throws SQLServerException { public byte getByte(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getByte", parameterName); checkClosed(); - Short shortValue = (Short) getValue(findColumn(parameterName), JDBCType.TINYINT); + Short shortValue = (Short) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TINYINT); byte byteValue = (null != shortValue) ? shortValue.byteValue() : 0; loggerExternal.exiting(getClassNameLogging(), "getByte", byteValue); return byteValue; @@ -619,7 +676,8 @@ public byte[] getBytes(int index) throws SQLServerException { public byte[] getBytes(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBytes", parameterName); checkClosed(); - byte[] value = (byte[]) getValue(findColumn(parameterName), JDBCType.BINARY); + byte[] value = (byte[]) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBytes", value); return value; } @@ -637,7 +695,7 @@ public Date getDate(int index) throws SQLServerException { public Date getDate(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDate", parameterName); checkClosed(); - java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName), JDBCType.DATE); + java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -657,7 +715,8 @@ public Date getDate(String parameterName, Calendar cal) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName), JDBCType.DATE, cal); + java.sql.Date value = (java.sql.Date) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -675,7 +734,8 @@ public double getDouble(int index) throws SQLServerException { public double getDouble(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDouble", parameterName); checkClosed(); - Double value = (Double) getValue(findColumn(parameterName), JDBCType.DOUBLE); + Double value = (Double) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.DOUBLE); loggerExternal.exiting(getClassNameLogging(), "getDouble", value); return null != value ? value : 0; } @@ -691,10 +751,10 @@ public float getFloat(int index) throws SQLServerException { @Override public float getFloat(String parameterName) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getFloat", parameterName); checkClosed(); - Float value = (Float) getValue(findColumn(parameterName), JDBCType.REAL); + Float value = (Float) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.REAL); loggerExternal.exiting(getClassNameLogging(), "getFloat", value); return null != value ? value : 0; } @@ -713,7 +773,8 @@ public long getLong(int index) throws SQLServerException { public long getLong(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getLong", parameterName); checkClosed(); - Long value = (Long) getValue(findColumn(parameterName), JDBCType.BIGINT); + Long value = (Long) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.BIGINT); loggerExternal.exiting(getClassNameLogging(), "getLong", value); return null != value ? value : 0; } @@ -826,7 +887,7 @@ public T getObject(int index, Class type) throws SQLException { public Object getObject(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName); + int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); Object value = getValue(parameterIndex, null != getterGetParam(parameterIndex).getJdbcTypeSetByUser() ? getterGetParam(parameterIndex) .getJdbcTypeSetByUser() : getterGetParam(parameterIndex).getJdbcType()); @@ -838,7 +899,7 @@ public Object getObject(String parameterName) throws SQLServerException { public T getObject(String parameterName, Class type) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName); + int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); T value = getObject(parameterIndex, type); loggerExternal.exiting(getClassNameLogging(), "getObject", value); return value; @@ -846,7 +907,6 @@ public T getObject(String parameterName, Class type) throws SQLException @Override public short getShort(int index) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getShort", index); checkClosed(); Short value = (Short) getValue(index, JDBCType.SMALLINT); @@ -858,7 +918,8 @@ public short getShort(int index) throws SQLServerException { public short getShort(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getShort", parameterName); checkClosed(); - Short value = (Short) getValue(findColumn(parameterName), JDBCType.SMALLINT); + Short value = (Short) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.SMALLINT); loggerExternal.exiting(getClassNameLogging(), "getShort", value); return null != value ? value : 0; } @@ -877,7 +938,8 @@ public Time getTime(int index) throws SQLServerException { public Time getTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getTime", parameterName); checkClosed(); - java.sql.Time value = (java.sql.Time) getValue(findColumn(parameterName), JDBCType.TIME); + java.sql.Time value = (java.sql.Time) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -897,7 +959,8 @@ public Time getTime(String parameterName, Calendar cal) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Time value = (java.sql.Time) getValue(findColumn(parameterName), JDBCType.TIME, cal); + java.sql.Time value = (java.sql.Time) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -916,7 +979,8 @@ public Timestamp getTimestamp(int index) throws SQLServerException { public Timestamp getTimestamp(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.TIMESTAMP); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -932,11 +996,12 @@ public Timestamp getTimestamp(int index, Calendar cal) throws SQLServerException } @Override - public Timestamp getTimestamp(String name, Calendar cal) throws SQLServerException { + public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) - loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, new Object[] {name, cal}); + loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(name), JDBCType.TIMESTAMP, cal); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -963,7 +1028,8 @@ public Timestamp getDateTime(int index) throws SQLServerException { public Timestamp getDateTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDateTime", parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.DATETIME); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -979,11 +1045,12 @@ public Timestamp getDateTime(int index, Calendar cal) throws SQLServerException } @Override - public Timestamp getDateTime(String name, Calendar cal) throws SQLServerException { + public Timestamp getDateTime(String parameterName, Calendar cal) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) - loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {name, cal}); + loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(name), JDBCType.DATETIME, cal); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -1002,7 +1069,8 @@ public Timestamp getSmallDateTime(int index) throws SQLServerException { public Timestamp getSmallDateTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.SMALLDATETIME); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; } @@ -1018,11 +1086,13 @@ public Timestamp getSmallDateTime(int index, Calendar cal) throws SQLServerExcep } @Override - public Timestamp getSmallDateTime(String name, Calendar cal) throws SQLServerException { + public Timestamp getSmallDateTime(String parameterName, Calendar cal) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) - loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {name, cal}); + loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(name), JDBCType.SMALLDATETIME, cal); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME, + cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; } @@ -1053,8 +1123,8 @@ public microsoft.sql.DateTimeOffset getDateTimeOffset(String parameterName) thro throw new SQLServerException(SQLServerException.getErrString("R_notSupported"), SQLState.DATA_EXCEPTION_NOT_SPECIFIC, DriverError.NOT_SET, null); - microsoft.sql.DateTimeOffset value = (microsoft.sql.DateTimeOffset) getValue(findColumn(parameterName), - JDBCType.DATETIMEOFFSET); + microsoft.sql.DateTimeOffset value = (microsoft.sql.DateTimeOffset) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIMEOFFSET); loggerExternal.exiting(getClassNameLogging(), "getDateTimeOffset", value); return value; } @@ -1084,7 +1154,8 @@ public final java.io.InputStream getAsciiStream(int parameterIndex) throws SQLSe public final java.io.InputStream getAsciiStream(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getAsciiStream", parameterName); checkClosed(); - InputStream value = (InputStream) getStream(findColumn(parameterName), StreamType.ASCII); + InputStream value = (InputStream) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.ASCII); loggerExternal.exiting(getClassNameLogging(), "getAsciiStream", value); return value; } @@ -1102,7 +1173,8 @@ public BigDecimal getBigDecimal(int parameterIndex) throws SQLServerException { public BigDecimal getBigDecimal(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBigDecimal", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.DECIMAL); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); return value; } @@ -1120,7 +1192,8 @@ public BigDecimal getMoney(int parameterIndex) throws SQLServerException { public BigDecimal getMoney(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getMoney", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.MONEY); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.MONEY); loggerExternal.exiting(getClassNameLogging(), "getMoney", value); return value; } @@ -1138,7 +1211,8 @@ public BigDecimal getSmallMoney(int parameterIndex) throws SQLServerException { public BigDecimal getSmallMoney(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getSmallMoney", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.SMALLMONEY); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLMONEY); loggerExternal.exiting(getClassNameLogging(), "getSmallMoney", value); return value; } @@ -1156,7 +1230,8 @@ public final java.io.InputStream getBinaryStream(int parameterIndex) throws SQLS public final java.io.InputStream getBinaryStream(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBinaryStream", parameterName); checkClosed(); - InputStream value = (InputStream) getStream(findColumn(parameterName), StreamType.BINARY); + InputStream value = (InputStream) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBinaryStream", value); return value; } @@ -1174,7 +1249,8 @@ public Blob getBlob(int parameterIndex) throws SQLServerException { public Blob getBlob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBlob", parameterName); checkClosed(); - Blob value = (Blob) getValue(findColumn(parameterName), JDBCType.BLOB); + Blob value = (Blob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.BLOB); loggerExternal.exiting(getClassNameLogging(), "getBlob", value); return value; } @@ -1192,7 +1268,8 @@ public final java.io.Reader getCharacterStream(int parameterIndex) throws SQLSer public final java.io.Reader getCharacterStream(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getCharacterStream", parameterName); checkClosed(); - Reader reader = (Reader) getStream(findColumn(parameterName), StreamType.CHARACTER); + Reader reader = (Reader) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.CHARACTER); loggerExternal.exiting(getClassNameLogging(), "getCharacterSream", reader); return reader; } @@ -1210,7 +1287,8 @@ public final java.io.Reader getNCharacterStream(int parameterIndex) throws SQLEx public final java.io.Reader getNCharacterStream(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNCharacterStream", parameterName); checkClosed(); - Reader reader = (Reader) getStream(findColumn(parameterName), StreamType.NCHARACTER); + Reader reader = (Reader) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.NCHARACTER); loggerExternal.exiting(getClassNameLogging(), "getNCharacterStream", reader); return reader; } @@ -1240,7 +1318,8 @@ public Clob getClob(int parameterIndex) throws SQLServerException { public Clob getClob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getClob", parameterName); checkClosed(); - Clob clob = (Clob) getValue(findColumn(parameterName), JDBCType.CLOB); + Clob clob = (Clob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.CLOB); loggerExternal.exiting(getClassNameLogging(), "getClob", clob); return clob; } @@ -1258,7 +1337,8 @@ public NClob getNClob(int parameterIndex) throws SQLException { public NClob getNClob(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNClob", parameterName); checkClosed(); - NClob nClob = (NClob) getValue(findColumn(parameterName), JDBCType.NCLOB); + NClob nClob = (NClob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.NCLOB); loggerExternal.exiting(getClassNameLogging(), "getNClob", nClob); return nClob; } @@ -1272,7 +1352,7 @@ public Object getObject(int parameterIndex, java.util.Map> map) @Override public Object getObject(String parameterName, java.util.Map> m) throws SQLException { checkClosed(); - return getObject(findColumn(parameterName), m); + return getObject(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), m); } @Override @@ -1284,7 +1364,7 @@ public Ref getRef(int parameterIndex) throws SQLException { @Override public Ref getRef(String parameterName) throws SQLException { checkClosed(); - return getRef(findColumn(parameterName)); + return getRef(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); } @Override @@ -1296,106 +1376,151 @@ public java.sql.Array getArray(int parameterIndex) throws SQLException { @Override public java.sql.Array getArray(String parameterName) throws SQLException { checkClosed(); - return getArray(findColumn(parameterName)); + return getArray(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + } + + /** + * handle `@name` as well as `name`, since `@name` is what's returned by DatabaseMetaData#getProcedureColumns + * + * @param columnName + * @return + */ + private String stripLeadingAtSign(String columnName) { + return (columnName.startsWith("@") ? columnName.substring(1, columnName.length()) : columnName); } - /* JDBC 3.0 */ + /* JDBC 3.0 */ /** * Find a column's index given its name. - * + * * @param columnName * the name * @throws SQLServerException * when an error occurs * @return the index */ - private int findColumn(String columnName) throws SQLServerException { - if (null == parameterNames) { - try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { - // Note we are concatenating the information from the passed in sql, not any arguments provided by the - // user - // if the user can execute the sql, any fragments of it is potentially executed via the meta data call - // through injection - // is not a security issue. - - ThreePartName threePartName = ThreePartName.parse(procedureName); - StringBuilder metaQuery = new StringBuilder("exec sp_sproc_columns "); - if (null != threePartName.getDatabasePart()) { - metaQuery.append("@procedure_qualifier="); - metaQuery.append(threePartName.getDatabasePart()); - metaQuery.append(", "); - } - if (null != threePartName.getOwnerPart()) { - metaQuery.append("@procedure_owner="); - metaQuery.append(threePartName.getOwnerPart()); - metaQuery.append(", "); + private int findColumn(String columnName, CallableStatementGetterSetterMethod method) throws SQLServerException { + int matchPos = -1; + + if (!isCursorable(executeMethod)) { + // handle `@name` as well as `name`, since `@name` is what's returned + // by DatabaseMetaData#getProcedureColumns + String columnNameWithoutAtSign = stripLeadingAtSign(columnName); + + for (int i = 0; i < inOutParam.length; i++) { + if (null != inOutParam[i].getName() + && inOutParam[i].getName().equalsIgnoreCase(columnNameWithoutAtSign)) { + return i + 1; } - if (null != threePartName.getProcedurePart()) { - // we should always have a procedure name part - metaQuery.append("@procedure_name="); - metaQuery.append(threePartName.getProcedurePart()); - metaQuery.append(" , @ODBCVer=3, @fUsePattern=0"); - } else { - // This should rarely happen, this will only happen if we can't find the stored procedure name - // invalidly formatted call syntax. - MessageFormat form = new MessageFormat( - SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); - Object[] msgArgs = {columnName, ""}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, - false); + } + + if (method == CallableStatementGetterSetterMethod.isSetterMethod && matchPos <= 0) { + for (int i = 0; i < inOutParam.length; i++) { + // if it is not already registered as output param or the parameter is not an input parameter, then + // set the param name and return index. + if (null == inOutParam[i].getName() && !inOutParam[i].isReturnValue() + && null == inOutParam[i].getInputDTV() && null == inOutParam[i].getRegisteredOutDTV()) { + inOutParam[i].setName(columnNameWithoutAtSign); + return i + 1; + } } + } + + MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_parameterNamedIndex")); + Object[] msgArgs = {columnName}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, true); - try (ResultSet rs = s.executeQueryInternal(metaQuery.toString())) { - parameterNames = new HashMap<>(); - insensitiveParameterNames = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); - int columnIndex = 0; - while (rs.next()) { - String p = rs.getString(4).trim(); - parameterNames.put(p, columnIndex); - insensitiveParameterNames.put(p, columnIndex++); + } else { + // stored procedures with cursorable methods are not called directly so we have to get the metadata + if (parameterNames == null) { + try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { + // Note we are concatenating the information from the passed in sql, not any arguments provided by the + // user + // if the user can execute the sql, any fragments of it is potentially executed via the meta data call + // through injection + // is not a security issue. + ThreePartName threePartName = ThreePartName.parse(procedureName); + StringBuilder metaQuery = new StringBuilder("exec sp_sproc_columns "); + if (null != threePartName.getDatabasePart()) { + metaQuery.append("@procedure_qualifier="); + metaQuery.append(threePartName.getDatabasePart()); + metaQuery.append(", "); + } + if (null != threePartName.getOwnerPart()) { + metaQuery.append("@procedure_owner="); + metaQuery.append(threePartName.getOwnerPart()); + metaQuery.append(", "); } + if (null != threePartName.getProcedurePart()) { + // we should always have a procedure name part + metaQuery.append("@procedure_name="); + metaQuery.append(threePartName.getProcedurePart()); + metaQuery.append(" , @ODBCVer=3, @fUsePattern=0"); + } else { + // This should rarely happen, this will only happen if we can't find the stored procedure name + // invalidly formatted call syntax. + MessageFormat form = new MessageFormat( + SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); + Object[] msgArgs = {columnName, ""}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, + false); + } + + try (ResultSet rs = s.executeQueryInternal(metaQuery.toString())) { + parameterNames = new HashMap<>(); + insensitiveParameterNames = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + int columnIndex = 0; + while (rs.next()) { + String p = rs.getString(4).trim(); + parameterNames.put(p, columnIndex); + insensitiveParameterNames.put(p, columnIndex++); + } + } + } catch (SQLException e) { + SQLServerException.makeFromDriverError(connection, this, e.toString(), null, false); } - } catch (SQLException e) { - SQLServerException.makeFromDriverError(connection, this, e.toString(), null, false); } - } - // If the server didn't return anything (eg. the param names for the sp_sproc_columns), user might not - // have required permissions to view all the parameterNames. And, there's also the case depending on the permissions, - // @RETURN_VALUE may or may not be present. So, the parameterNames list might have an additional +1 parameter. - if (null != parameterNames && parameterNames.size() <= 1) { - return map.computeIfAbsent(columnName, ifAbsent -> ai.incrementAndGet()); - } + // If the server didn't return anything (eg. the param names for the sp_sproc_columns), user might not + // have required permissions to view all the parameterNames. And, there's also the case depending on the permissions, + // @RETURN_VALUE may or may not be present. So, the parameterNames list might have an additional +1 parameter. + if (null != parameterNames && parameterNames.size() <= 1) { + return map.computeIfAbsent(columnName, ifAbsent -> ai.incrementAndGet()); + } - // handle `@name` as well as `name`, since `@name` is what's returned - // by DatabaseMetaData#getProcedureColumns - String columnNameWithSign = columnName.startsWith("@") ? columnName : "@" + columnName; + // handle `@name` as well as `name`, since `@name` is what's returned + // by DatabaseMetaData#getProcedureColumns + String columnNameWithSign = columnName.startsWith("@") ? columnName : "@" + columnName; - // In order to be as accurate as possible when locating parameter name - // indexes, as well as be deterministic when running on various client - // locales, we search for parameter names using the following scheme: + // In order to be as accurate as possible when locating parameter name + // indexes, as well as be deterministic when running on various client + // locales, we search for parameter names using the following scheme: - // 1. Search using case-sensitive non-locale specific (binary) compare first. - // 2. Search using case-insensitive, non-locale specific (binary) compare last. - Integer matchPos = (parameterNames != null) ? parameterNames.get(columnNameWithSign) : null; - if (null == matchPos) { - matchPos = insensitiveParameterNames.get(columnNameWithSign); - } - if (null == matchPos) { - MessageFormat form = new MessageFormat( - SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); - Object[] msgArgs = {columnName, procedureName}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, false); + // 1. Search using case-sensitive non-locale specific (binary) compare first. + // 2. Search using case-insensitive, non-locale specific (binary) compare last. + matchPos = (parameterNames != null) ? parameterNames.get(columnNameWithSign) : -1; + if (matchPos == -1) { + matchPos = insensitiveParameterNames.get(columnNameWithSign); + } + + if (matchPos == -1) { + MessageFormat form = new MessageFormat( + SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); + Object[] msgArgs = {columnName, procedureName}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, false); + } + + // @RETURN_VALUE is always in the list. If the user uses return value ?=call(@p1) syntax then + // @p1 is index 2 otherwise its index 1. + if (bReturnValueSyntax) // 3.2717 + return matchPos + 1; + else + return matchPos; } - // @RETURN_VALUE is always in the list. If the user uses return value ?=call(@p1) syntax then - // @p1 is index 2 otherwise its index 1. - if (bReturnValueSyntax) // 3.2717 - return matchPos + 1; - else - return matchPos; + return matchPos; } @Override @@ -1405,7 +1530,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1416,7 +1542,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, Calenda loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1425,7 +1552,8 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1436,7 +1564,8 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1445,7 +1574,8 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + JavaType.DATE, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1456,17 +1586,18 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + JavaType.DATE, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @Override - public final void setCharacterStream(String parameterName, Reader reader) throws SQLException { + public final void setCharacterStream(String parameterName, Reader value) throws SQLException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) - loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, reader}); + loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, reader, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1476,18 +1607,19 @@ public final void setCharacterStream(String parameterName, Reader value, int len loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @Override - public final void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException { - + public final void setCharacterStream(String parameterName, Reader value, long length) throws SQLException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setCharacterStream", - new Object[] {parameterName, reader, length}); + new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, reader, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1496,8 +1628,8 @@ public final void setNCharacterStream(String parameterName, Reader value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1507,7 +1639,8 @@ public final void setNCharacterStream(String parameterName, Reader value, long l loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1516,17 +1649,18 @@ public final void setClob(String parameterName, Clob value) throws SQLException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.CLOB, value, JavaType.CLOB, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.CLOB, value, + JavaType.CLOB, false); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @Override - public final void setClob(String parameterName, Reader reader) throws SQLException { + public final void setClob(String parameterName, Reader value) throws SQLException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) - loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, reader}); + loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, reader, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1535,7 +1669,8 @@ public final void setClob(String parameterName, Reader value, long length) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1544,26 +1679,28 @@ public final void setNClob(String parameterName, NClob value) throws SQLExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.NCLOB, value, JavaType.NCLOB, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NCLOB, value, + JavaType.NCLOB, false); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @Override - public final void setNClob(String parameterName, Reader reader) throws SQLException { + public final void setNClob(String parameterName, Reader value) throws SQLException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, reader}); + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, reader, JavaType.READER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @Override - public final void setNClob(String parameterName, Reader reader, long length) throws SQLException { + public final void setNClob(String parameterName, Reader value, long length) throws SQLException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, reader, length}); + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, reader, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1572,7 +1709,7 @@ public final void setNString(String parameterName, String value) throws SQLExcep if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1582,7 +1719,7 @@ public final void setNString(String parameterName, String value, boolean forceEn loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1591,7 +1728,7 @@ public void setObject(String parameterName, Object value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value}); checkClosed(); - setObjectNoType(findColumn(parameterName), value, false); + setObjectNoType(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value, false); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1602,12 +1739,12 @@ public void setObject(String parameterName, Object value, int sqlType) throws SQ loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType}); checkClosed(); if (microsoft.sql.Types.STRUCTURED == sqlType) { - tvpName = getTVPNameFromObject(findColumn(parameterName), value); - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.TVP, JDBCType.TVP, null, null, false, - findColumn(parameterName), tvpName); + tvpName = getTVPNameFromObject(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.TVP, JDBCType.TVP, null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); } else - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), null, - null, false, findColumn(parameterName), tvpName); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(sqlType), null, + null, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1617,8 +1754,8 @@ public void setObject(String parameterName, Object value, int sqlType, int decim loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType, decimals}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), decimals, - null, false, findColumn(parameterName), null); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(sqlType), decimals, + null, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1634,9 +1771,9 @@ public void setObject(String parameterName, Object value, int sqlType, int decim // this is the number of digits after the decimal point. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(sqlType), (java.sql.Types.NUMERIC == sqlType || java.sql.Types.DECIMAL == sqlType) ? decimals : null, null, - forceEncrypt, findColumn(parameterName), null); + forceEncrypt, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1654,10 +1791,10 @@ public final void setObject(String parameterName, Object value, int targetSqlTyp // InputStream and Reader, this is the length of the data in the stream or reader. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(targetSqlType), + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(targetSqlType), (java.sql.Types.NUMERIC == targetSqlType || java.sql.Types.DECIMAL == targetSqlType || InputStream.class.isInstance(value) || Reader.class.isInstance(value)) ? scale : null, - precision, false, findColumn(parameterName), null); + precision, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1667,7 +1804,7 @@ public final void setAsciiStream(String parameterName, InputStream value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1678,7 +1815,7 @@ public final void setAsciiStream(String parameterName, InputStream value, int le loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1688,7 +1825,7 @@ public final void setAsciiStream(String parameterName, InputStream value, long l loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1697,7 +1834,7 @@ public final void setBinaryStream(String parameterName, InputStream value) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1708,7 +1845,7 @@ public final void setBinaryStream(String parameterName, InputStream value, int l loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1718,7 +1855,7 @@ public final void setBinaryStream(String parameterName, InputStream value, long loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1727,7 +1864,7 @@ public final void setBlob(String parameterName, Blob inputStream) throws SQLExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BLOB, inputStream, JavaType.BLOB, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BLOB, inputStream, JavaType.BLOB, false); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1736,7 +1873,7 @@ public final void setBlob(String parameterName, InputStream value) throws SQLExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1747,7 +1884,7 @@ public final void setBlob(String parameterName, InputStream inputStream, long le loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1756,7 +1893,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1765,7 +1902,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1776,7 +1913,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1785,7 +1922,7 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1795,7 +1932,7 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1807,7 +1944,7 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1817,7 +1954,7 @@ public void setDate(String parameterName, java.sql.Date value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, JavaType.DATE, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1826,7 +1963,7 @@ public void setTime(String parameterName, java.sql.Time value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, JavaType.TIME, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1835,7 +1972,7 @@ public void setTime(String parameterName, java.sql.Time value, int scale) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, JavaType.TIME, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1846,7 +1983,7 @@ public void setTime(String parameterName, java.sql.Time value, int scale, loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, JavaType.TIME, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1855,7 +1992,7 @@ public void setDateTime(String parameterName, java.sql.Timestamp value) throws S if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -1866,7 +2003,7 @@ public void setDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -1875,7 +2012,7 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value) thr if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -1886,7 +2023,7 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -1895,7 +2032,7 @@ public void setUniqueIdentifier(String parameterName, String guid) throws SQLSer if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -1905,7 +2042,7 @@ public void setUniqueIdentifier(String parameterName, String guid, boolean force loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -1914,7 +2051,7 @@ public void setBytes(String parameterName, byte[] value) throws SQLServerExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, JavaType.BYTEARRAY, false); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -1924,7 +2061,7 @@ public void setBytes(String parameterName, byte[] value, boolean forceEncrypt) t loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, JavaType.BYTEARRAY, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -1933,7 +2070,7 @@ public void setByte(String parameterName, byte value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, JavaType.BYTE, false); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -1943,7 +2080,7 @@ public void setByte(String parameterName, byte value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, JavaType.BYTE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -1952,7 +2089,7 @@ public void setString(String parameterName, String value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -1962,7 +2099,7 @@ public void setString(String parameterName, String value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -1971,7 +2108,7 @@ public void setMoney(String parameterName, BigDecimal value) throws SQLServerExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -1981,7 +2118,7 @@ public void setMoney(String parameterName, BigDecimal value, boolean forceEncryp loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -1990,7 +2127,7 @@ public void setSmallMoney(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2000,7 +2137,7 @@ public void setSmallMoney(String parameterName, BigDecimal value, boolean forceE loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2009,7 +2146,7 @@ public void setBigDecimal(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2020,7 +2157,7 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2031,7 +2168,7 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2041,7 +2178,7 @@ public void setDouble(String parameterName, double value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, JavaType.DOUBLE, false); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2051,7 +2188,7 @@ public void setDouble(String parameterName, double value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, JavaType.DOUBLE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2060,7 +2197,7 @@ public void setFloat(String parameterName, float value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, JavaType.FLOAT, false); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2070,7 +2207,7 @@ public void setFloat(String parameterName, float value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, JavaType.FLOAT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2079,7 +2216,7 @@ public void setInt(String parameterName, int value) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, JavaType.INTEGER, false); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2088,7 +2225,7 @@ public void setInt(String parameterName, int value, boolean forceEncrypt) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2097,7 +2234,7 @@ public void setLong(String parameterName, long value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, JavaType.LONG, false); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2107,7 +2244,7 @@ public void setLong(String parameterName, long value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, JavaType.LONG, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2116,7 +2253,7 @@ public void setShort(String parameterName, short value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, value, JavaType.SHORT, false); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2126,7 +2263,7 @@ public void setShort(String parameterName, short value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, value, JavaType.SHORT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2135,7 +2272,7 @@ public void setBoolean(String parameterName, boolean value) throws SQLServerExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2145,7 +2282,7 @@ public void setBoolean(String parameterName, boolean value, boolean forceEncrypt loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, JavaType.BOOLEAN, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2154,8 +2291,8 @@ public void setNull(String parameterName, int nType) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, - false, findColumn(parameterName), null); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, + false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2164,8 +2301,8 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType, sTypeName}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, - false, findColumn(parameterName), sTypeName); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, + false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sTypeName); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2173,43 +2310,43 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ public void setURL(String parameterName, URL url) throws SQLException { loggerExternal.entering(getClassNameLogging(), "setURL", parameterName); checkClosed(); - setURL(findColumn(parameterName), url); + setURL(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), url); loggerExternal.exiting(getClassNameLogging(), "setURL"); } @Override public final void setStructured(String parameterName, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataTable}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ResultSet tvpResultSet) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpResultSet}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ISQLServerDataRecord tvpDataRecord) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataRecord}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TVP, tvpDataRecord, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, tvpDataRecord, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @@ -2230,7 +2367,7 @@ public final void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLEx if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterName, xmlObject}); checkClosed(); - setSQLXMLInternal(findColumn(parameterName), xmlObject); + setSQLXMLInternal(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), xmlObject); loggerExternal.exiting(getClassNameLogging(), "setSQLXML"); } @@ -2247,7 +2384,7 @@ public final SQLXML getSQLXML(int parameterIndex) throws SQLException { public final SQLXML getSQLXML(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getSQLXML", parameterName); checkClosed(); - SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal(findColumn(parameterName)); + SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); loggerExternal.exiting(getClassNameLogging(), "getSQLXML", value); return value; } @@ -2275,7 +2412,7 @@ public void registerOutParameter(String parameterName, int sqlType, String typeN loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, typeName}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType, typeName); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, typeName); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2285,7 +2422,7 @@ public void registerOutParameter(String parameterName, int sqlType, int scale) t loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType, scale); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2296,7 +2433,7 @@ public void registerOutParameter(String parameterName, int sqlType, int precisio loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType, precision, scale); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, precision, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2306,7 +2443,7 @@ public void registerOutParameter(String parameterName, int sqlType) throws SQLSe loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index 66ad92b9d..d605ef1af 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -506,6 +506,39 @@ static ParsedSQLCacheItem parseAndCacheSQL(CityHash128Key key, String sql) throw return cacheItem; } + /** + * Checks if remote procedure call is a valid. Example: if exec procName 1,? we should not use RPC call directly, + * rather wrap it with sp_executesql call + * + */ + static boolean isCallRemoteProcDirectValid(String sql, int paramCount, boolean isReturnSyntax) { + int commaCount = SQLServerConnection.countCommas(sql); + if (isReturnSyntax) { + return paramCount == commaCount + 2; // if return syntax, sql text commas should be equal to paramCount - + // 2 + } else { + return paramCount == commaCount + 1; // if not return syntax, sql text commas should be equal to + // paramCount -1 + } + } + + /** + * Count the number of commas in sql text + * + */ + static int countCommas(String sql) { + int nParams = 0; + int offset = -1; + while ((offset = ParameterUtils.scanSQLForChar(',', sql, ++offset)) < sql.length()) + ++nParams; + + return nParams; + } + + static int countParams(String sql) { + return locateParams(sql).length; + } + /** Default size for prepared statement caches */ static final int DEFAULT_STATEMENT_POOLING_CACHE_SIZE = 0; @@ -7407,7 +7440,7 @@ String replaceParameterMarkers(String sqlSrc, int[] paramPositions, Parameter[] int paramIndex = 0; while (true) { - int srcEnd = (paramIndex >= paramPositions.length) ? sqlSrc.length() : paramPositions[paramIndex]; + int srcEnd = ParameterUtils.scanSQLForChar('?', sqlSrc, srcBegin); sqlSrc.getChars(srcBegin, srcEnd, sqlDst, dstBegin); dstBegin += srcEnd - srcBegin; diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index cfe578127..10cf8ceab 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -98,6 +98,11 @@ public class SQLServerPreparedStatement extends SQLServerStatement implements IS /** Set to true if the statement is a stored procedure call that expects a return value */ final boolean bReturnValueSyntax; + /** Check if statement contains TVP Type */ + static boolean isTVPType = false; + + static boolean validRPC = false; + /** user FMTOnly flag */ private boolean useFmtOnly = this.connection.getUseFmtOnly(); @@ -256,6 +261,7 @@ private boolean resetPrepStmtHandle(boolean discardCurrentCacheItem) { userSQLParamPositions = parsedSQL.parameterPositions; initParams(userSQLParamPositions.length); useBulkCopyForBatchInsert = conn.getUseBulkCopyForBatchInsert(); + isTVPType = false; } /** @@ -374,6 +380,10 @@ final void initParams(int nParams) { for (int i = 0; i < nParams; i++) { inOutParam[i] = new Parameter(Util.shouldHonorAEForParameters(stmtColumnEncriptionSetting, connection)); } + + if (bReturnValueSyntax) { + inOutParam[0].setReturnValue(true); + } } @Override @@ -745,9 +755,16 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { /** * Sends the statement parameters by RPC. */ - void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params) throws SQLServerException { + void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnValueSyntax) throws SQLServerException { char[] cParamName; - for (int index = 0; index < params.length; index++) { + int index = 0; + if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, params.length, bReturnValueSyntax)) { + returnParam = params[index]; + params[index].setReturnValue(true); + index++; + } + for (; index < params.length; index++) { if (JDBCType.TVP == params[index].getJdbcType()) { cParamName = new char[10]; int paramNameLen = SQLServerConnection.makeParamName(index, cParamName, 0, false); @@ -802,6 +819,22 @@ private void buildServerCursorPrepExecParams(TDSWriter tdsWriter) throws SQLServ tdsWriter.writeRPCInt(null, 0, true); } + private void buildRPCExecParams(TDSWriter tdsWriter) throws SQLServerException { + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) { + getStatementLogger().fine(toString() + ": calling PROC" + ", SQL:" + preparedSQL); + } + + expectPrepStmtHandle = false; + executedSqlDirectly = true; + expectCursorOutParams = false; + outParamIndexAdjustment = 0; + tdsWriter.writeShort((short) procedureName.length()); // procedure name length + tdsWriter.writeString(procedureName); + + tdsWriter.writeByte((byte) 0); // RPC procedure option 1 + tdsWriter.writeByte((byte) 0); // RPC procedure option 2 + } + private void buildPrepParams(TDSWriter tdsWriter) throws SQLServerException { if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) getStatementLogger().fine(toString() + ": calling sp_prepare: PreparedHandle:" @@ -1127,9 +1160,13 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN else buildServerCursorExecParams(tdsWriter); } else { + // if it is a parameterized stored procedure call and is not TVP, use sp_execute directly. + if (needsPrepare && callRPCDirectly(params, bReturnValueSyntax)) { + buildRPCExecParams(tdsWriter); + } // Move overhead of needing to do prepare & unprepare to only use cases that need more than one execution. // First execution, use sp_executesql, optimizing for assumption we will not re-use statement. - if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCall() && !isExecutedAtLeastOnce) { + else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCall() && !isExecutedAtLeastOnce) { buildExecSQLParams(tdsWriter); isExecutedAtLeastOnce = true; } else if (needsPrepare) { // Second execution, use prepared statements since we seem to be re-using it. @@ -1155,11 +1192,41 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN } } - sendParamsByRPC(tdsWriter, params); + sendParamsByRPC(tdsWriter, params, bReturnValueSyntax); return needsPrepare; } + /** + * Checks if we should call RPC directly for stored procedures + * + * @param params + * @return + * @throws SQLServerException + */ + boolean callRPCDirectly(Parameter[] params, boolean isReturnSyntax) throws SQLServerException { + int paramCount = SQLServerConnection.countParams(userSQL); + return (null != procedureName && paramCount != 0 && !isTVPType(params) + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, paramCount, isReturnSyntax)); + } + + /** + * Checks if the parameter is a TVP type. + * + * @param params + * @return + * @throws SQLServerException + */ + private boolean isTVPType(Parameter[] params) throws SQLServerException { + for (int i = 0; i < params.length; i++) { + if (JDBCType.TVP == params[i].getJdbcType()) { + isTVPType = true; + return true; + } + } + return false; + } + /** * Executes sp_prepare to prepare a parameterized statement and sets the prepared statement handle * @@ -2991,7 +3058,7 @@ final void doExecutePreparedStatementBatch(PrepStmtBatchExecCmd batchCommand) th resetForReexecute(); tdsWriter = batchCommand.startRequest(TDS.PKT_RPC); buildExecParams(tdsWriter); - sendParamsByRPC(tdsWriter, batchParam); + sendParamsByRPC(tdsWriter, batchParam, bReturnValueSyntax); ensureExecuteResultsReader( batchCommand.startResponse(getIsResponseBufferingAdaptive())); startResults(); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index d9dfdfdb6..2035e1fd1 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -64,7 +64,7 @@ public class SQLServerStatement implements ISQLServerStatement { private static final String ACTIVITY_ID = " ActivityId: "; /** response buffer adaptive flag */ - private boolean isResponseBufferingAdaptive = false; + boolean isResponseBufferingAdaptive = false; final boolean getIsResponseBufferingAdaptive() { return isResponseBufferingAdaptive; @@ -112,10 +112,13 @@ final boolean wasExecuted() { return null != tdsReader; } + /** Return parameter for stored procedure calls */ + Parameter returnParam; + /** * The input and out parameters for statement execution. */ - transient Parameter[] inOutParam; // Parameters for prepared stmts and stored procedures + transient Parameter[] inOutParam = null; // Parameters for prepared stmts and stored procedures /** * The statement's connection. @@ -1609,6 +1612,14 @@ boolean onRetStatus(TDSReader tdsReader) throws SQLServerException { else { procedureRetStatToken = new StreamRetStatus(); procedureRetStatToken.setFromTDS(tdsReader); + // Only read the return value from stored procedure if we are expecting one. Also, check that it is + // not cursorable and not TVP type. For these two, the driver is still following the old behavior of + // executing sp_executesql for stored procedures. + if (!isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType && null != inOutParam + && inOutParam.length > 0 && inOutParam[0].isReturnValue()) { + inOutParam[0].setFromReturnStatus(procedureRetStatToken.getStatus(), connection); + return false; + } } return true; diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java index 7fd3ba441..aa2fe4331 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java @@ -861,10 +861,17 @@ private void sendTemporal(DTV dtv, JavaType javaType, Object value) throws SQLSe timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), subSecondNanos, (valueLength), isOutParam, statement); } - } else - tdsWriter.writeRPCDateTime2(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); + } else { + if (jdbcType == JDBCType.DATETIME || jdbcType == JDBCType.SMALLDATETIME) { + tdsWriter.writeRPCDateTime(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, isOutParam); + } else { + tdsWriter.writeRPCDateTime2(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); + } + } break; @@ -2319,8 +2326,10 @@ Object getValue(DTV dtv, JDBCType jdbcType, int scale, InputStreamGetterArgs str TypeInfo typeInfo, CryptoMetadata cryptoMetadata, TDSReader tdsReader, SQLServerStatement statement) throws SQLServerException { // Client side type conversion is not supported - if (this.jdbcType != jdbcType) + // Checking for sql_variant here since the check will be performed elsewhere. + if (this.jdbcType != jdbcType && jdbcType != JDBCType.SQL_VARIANT) { DataTypes.throwConversionError(this.jdbcType.toString(), jdbcType.toString()); + } return value; } From 40095d57e2a9e403ad161536b758ec98b74c2901 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 28 Jun 2023 16:30:02 -0700 Subject: [PATCH 02/51] Regression fix, continue to do extra metadata lookup call to fetch SP param name info --- .../jdbc/SQLServerCallableStatement.java | 161 +++++++++--------- 1 file changed, 77 insertions(+), 84 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index e52caa764..5e278406d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -1401,7 +1401,6 @@ private String stripLeadingAtSign(String columnName) { * @return the index */ private int findColumn(String columnName, CallableStatementGetterSetterMethod method) throws SQLServerException { - int matchPos = -1; if (!isCursorable(executeMethod)) { // handle `@name` as well as `name`, since `@name` is what's returned @@ -1415,7 +1414,7 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me } } - if (method == CallableStatementGetterSetterMethod.isSetterMethod && matchPos <= 0) { + if (method == CallableStatementGetterSetterMethod.isSetterMethod) { for (int i = 0; i < inOutParam.length; i++) { // if it is not already registered as output param or the parameter is not an input parameter, then // set the param name and return index. @@ -1426,101 +1425,95 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me } } } + } - MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_parameterNamedIndex")); - Object[] msgArgs = {columnName}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, true); - - } else { - // stored procedures with cursorable methods are not called directly so we have to get the metadata - if (parameterNames == null) { - try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { - // Note we are concatenating the information from the passed in sql, not any arguments provided by the - // user - // if the user can execute the sql, any fragments of it is potentially executed via the meta data call - // through injection - // is not a security issue. - ThreePartName threePartName = ThreePartName.parse(procedureName); - StringBuilder metaQuery = new StringBuilder("exec sp_sproc_columns "); - if (null != threePartName.getDatabasePart()) { - metaQuery.append("@procedure_qualifier="); - metaQuery.append(threePartName.getDatabasePart()); - metaQuery.append(", "); - } - if (null != threePartName.getOwnerPart()) { - metaQuery.append("@procedure_owner="); - metaQuery.append(threePartName.getOwnerPart()); - metaQuery.append(", "); - } - if (null != threePartName.getProcedurePart()) { - // we should always have a procedure name part - metaQuery.append("@procedure_name="); - metaQuery.append(threePartName.getProcedurePart()); - metaQuery.append(" , @ODBCVer=3, @fUsePattern=0"); - } else { - // This should rarely happen, this will only happen if we can't find the stored procedure name - // invalidly formatted call syntax. - MessageFormat form = new MessageFormat( - SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); - Object[] msgArgs = {columnName, ""}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, - false); - } + // Stored procedures with cursorable methods are not called directly, so we have to get the metadata + if (parameterNames == null) { + try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { + // Note we are concatenating the information from the passed in sql, not any arguments provided by the + // user + // if the user can execute the sql, any fragments of it is potentially executed via the meta data call + // through injection + // is not a security issue. + ThreePartName threePartName = ThreePartName.parse(procedureName); + StringBuilder metaQuery = new StringBuilder("exec sp_sproc_columns "); + if (null != threePartName.getDatabasePart()) { + metaQuery.append("@procedure_qualifier="); + metaQuery.append(threePartName.getDatabasePart()); + metaQuery.append(", "); + } + if (null != threePartName.getOwnerPart()) { + metaQuery.append("@procedure_owner="); + metaQuery.append(threePartName.getOwnerPart()); + metaQuery.append(", "); + } + if (null != threePartName.getProcedurePart()) { + // we should always have a procedure name part + metaQuery.append("@procedure_name="); + metaQuery.append(threePartName.getProcedurePart()); + metaQuery.append(" , @ODBCVer=3, @fUsePattern=0"); + } else { + // This should rarely happen, this will only happen if we can't find the stored procedure name + // invalidly formatted call syntax. + MessageFormat form = new MessageFormat( + SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); + Object[] msgArgs = {columnName, ""}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, + false); + } - try (ResultSet rs = s.executeQueryInternal(metaQuery.toString())) { - parameterNames = new HashMap<>(); - insensitiveParameterNames = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); - int columnIndex = 0; - while (rs.next()) { - String p = rs.getString(4).trim(); - parameterNames.put(p, columnIndex); - insensitiveParameterNames.put(p, columnIndex++); - } + try (ResultSet rs = s.executeQueryInternal(metaQuery.toString())) { + parameterNames = new HashMap<>(); + insensitiveParameterNames = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + int columnIndex = 0; + while (rs.next()) { + String p = rs.getString(4).trim(); + parameterNames.put(p, columnIndex); + insensitiveParameterNames.put(p, columnIndex++); } - } catch (SQLException e) { - SQLServerException.makeFromDriverError(connection, this, e.toString(), null, false); } + } catch (SQLException e) { + SQLServerException.makeFromDriverError(connection, this, e.toString(), null, false); } + } - // If the server didn't return anything (eg. the param names for the sp_sproc_columns), user might not - // have required permissions to view all the parameterNames. And, there's also the case depending on the permissions, - // @RETURN_VALUE may or may not be present. So, the parameterNames list might have an additional +1 parameter. - if (null != parameterNames && parameterNames.size() <= 1) { - return map.computeIfAbsent(columnName, ifAbsent -> ai.incrementAndGet()); - } - - // handle `@name` as well as `name`, since `@name` is what's returned - // by DatabaseMetaData#getProcedureColumns - String columnNameWithSign = columnName.startsWith("@") ? columnName : "@" + columnName; + // If the server didn't return anything (eg. the param names for the sp_sproc_columns), user might not + // have required permissions to view all the parameterNames. And, there's also the case depending on the permissions, + // @RETURN_VALUE may or may not be present. So, the parameterNames list might have an additional +1 parameter. + if (null != parameterNames && parameterNames.size() <= 1) { + return map.computeIfAbsent(columnName, ifAbsent -> ai.incrementAndGet()); + } - // In order to be as accurate as possible when locating parameter name - // indexes, as well as be deterministic when running on various client - // locales, we search for parameter names using the following scheme: + // handle `@name` as well as `name`, since `@name` is what's returned + // by DatabaseMetaData#getProcedureColumns + String columnNameWithSign = columnName.startsWith("@") ? columnName : "@" + columnName; - // 1. Search using case-sensitive non-locale specific (binary) compare first. - // 2. Search using case-insensitive, non-locale specific (binary) compare last. - matchPos = (parameterNames != null) ? parameterNames.get(columnNameWithSign) : -1; - if (matchPos == -1) { - matchPos = insensitiveParameterNames.get(columnNameWithSign); - } + // In order to be as accurate as possible when locating parameter name + // indexes, as well as be deterministic when running on various client + // locales, we search for parameter names using the following scheme: - if (matchPos == -1) { - MessageFormat form = new MessageFormat( - SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); - Object[] msgArgs = {columnName, procedureName}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, false); - } + // 1. Search using case-sensitive non-locale specific (binary) compare first. + // 2. Search using case-insensitive, non-locale specific (binary) compare last. + int matchPos = (parameterNames != null) ? parameterNames.get(columnNameWithSign) : -1; + if (matchPos == -1) { + matchPos = insensitiveParameterNames.get(columnNameWithSign); + } - // @RETURN_VALUE is always in the list. If the user uses return value ?=call(@p1) syntax then - // @p1 is index 2 otherwise its index 1. - if (bReturnValueSyntax) // 3.2717 - return matchPos + 1; - else - return matchPos; + if (matchPos == -1) { + MessageFormat form = new MessageFormat( + SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); + Object[] msgArgs = {columnName, procedureName}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, false); } - return matchPos; + // @RETURN_VALUE is always in the list. If the user uses return value ?=call(@p1) syntax then + // @p1 is index 2 otherwise its index 1. + if (bReturnValueSyntax) // 3.2717 + return matchPos + 1; + else + return matchPos; + } @Override From 8b129c8d9d77a298f92561c6ac0e2df9d7dbc311 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 28 Aug 2023 15:54:26 -0700 Subject: [PATCH 03/51] Fixes p1 --- src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index 2f64c4e41..e2cae6e39 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -450,7 +450,6 @@ Object getValue(JDBCType jdbcType, InputStreamGetterArgs getterArgs, Calendar ca deriveTypeInfo(tdsReader); } - deriveTypeInfo(tdsReader); // If the parameter is not encrypted or column encryption is turned off (either at connection or // statement level), cryptoMeta would be null. return getterDTV.getValue(jdbcType, outScale, getterArgs, cal, typeInfo, cryptoMeta, tdsReader, statement); From d841377cc464ab5702ea2e4d441f03e7ebc2ce18 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Thu, 31 Aug 2023 14:24:15 -0700 Subject: [PATCH 04/51] Fixes p2 --- src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java | 2 +- .../microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index e2cae6e39..e0f06672e 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -1245,7 +1245,7 @@ void sendByRPC(TDSWriter tdsWriter, SQLServerStatement statement) throws SQLServ try { inputDTV.sendCryptoMetaData(this.cryptoMeta, tdsWriter); inputDTV.setJdbcTypeSetByUser(getJdbcTypeSetByUser(), getValueLength()); - inputDTV.sendByRPC(name, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, + inputDTV.sendByRPC(SQLServerPreparedStatement.callRpcDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, isOutput(), tdsWriter, statement); } finally { // reset the cryptoMeta in IOBuffer diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index 10cf8ceab..104ea8f3c 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -103,6 +103,8 @@ public class SQLServerPreparedStatement extends SQLServerStatement implements IS static boolean validRPC = false; + static boolean callRpcDirectly = false; + /** user FMTOnly flag */ private boolean useFmtOnly = this.connection.getUseFmtOnly(); @@ -1152,6 +1154,7 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN boolean needsPrepare = (hasNewTypeDefinitions && hasExistingTypeDefinitions) || !hasPreparedStatementHandle(); boolean isPrepareMethodSpPrepExec = connection.getPrepareMethod().equals(PrepareMethod.PREPEXEC.toString()); + callRpcDirectly = callRPCDirectly(params, bReturnValueSyntax); // Cursors don't use statement pooling. if (isCursorable(executeMethod)) { @@ -1161,7 +1164,7 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN buildServerCursorExecParams(tdsWriter); } else { // if it is a parameterized stored procedure call and is not TVP, use sp_execute directly. - if (needsPrepare && callRPCDirectly(params, bReturnValueSyntax)) { + if (needsPrepare && callRpcDirectly) { buildRPCExecParams(tdsWriter); } // Move overhead of needing to do prepare & unprepare to only use cases that need more than one execution. From 0aa1d33026a799e046ec45e05bfc2e82facfc450 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Thu, 31 Aug 2023 15:08:34 -0700 Subject: [PATCH 05/51] Fixes p3 --- .../com/microsoft/sqlserver/jdbc/TestResource.java | 1 + .../jdbc/callablestatement/CallableStatementTest.java | 10 ++++++---- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java index 9a4c4177b..78ff3875d 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java @@ -63,6 +63,7 @@ protected Object[][] getContents() { {"R_deadConnection", "Dead connection should be invalid"}, {"R_wrongExceptionMessage", "Wrong exception message"}, {"R_wrongSqlState", "Wrong sql state"}, {"R_parameterNotDefined", "Parameter {0} was not defined"}, + {"R_notValidParameterForProcedure", "{0} is not a parameter for procedure {1}."}, {"R_unexpectedExceptionContent", "Unexpected content in exception message"}, {"R_connectionClosed", "The connection has been closed"}, {"R_conversionFailed", "Conversion failed when converting {0} to {1} data type"}, 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 239ae1f71..9a13abec1 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -329,12 +329,14 @@ public void inputParamsTest() throws SQLException { // sanity check: unrecognized parameter name try (CallableStatement cs = connection.prepareCall(call)) { - cs.setString("@whatever", "test"); + cs.setString("p2", "world"); + cs.setString("@invalidParamName", "hello"); + cs.execute(); fail(TestResource.getResource("R_shouldThrowException")); } catch (SQLException sse) { - - MessageFormat form = new MessageFormat(TestResource.getResource("R_parameterNotDefined")); - Object[] msgArgs = {"@whatever"}; + MessageFormat form = new MessageFormat(TestResource.getResource("R_notValidParameterForProcedure")); + Object[] msgArgs = {"@invalidParamName", inputParamsProcedureName + .replace("[", "").replace("]", "")}; if (!sse.getMessage().startsWith(form.format(msgArgs))) { fail(TestResource.getResource("R_unexpectedExceptionContent")); From caafb052d88db62ed9fb8fa70f376fd332c970bf Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Thu, 7 Sep 2023 16:20:03 -0700 Subject: [PATCH 06/51] Fixes p4 --- src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java | 2 +- .../sqlserver/jdbc/SQLServerCallableStatement.java | 6 +++--- .../sqlserver/jdbc/SQLServerPreparedStatement.java | 7 +++++-- .../com/microsoft/sqlserver/jdbc/SQLServerStatement.java | 2 +- 4 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index e0f06672e..5fbe2d68a 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -1245,7 +1245,7 @@ void sendByRPC(TDSWriter tdsWriter, SQLServerStatement statement) throws SQLServ try { inputDTV.sendCryptoMetaData(this.cryptoMeta, tdsWriter); inputDTV.setJdbcTypeSetByUser(getJdbcTypeSetByUser(), getValueLength()); - inputDTV.sendByRPC(SQLServerPreparedStatement.callRpcDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, + inputDTV.sendByRPC(SQLServerPreparedStatement.callRpcDirectly && !conn.isColumnEncryptionSettingEnabled()? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, isOutput(), tdsWriter, statement); } finally { // reset the cryptoMeta in IOBuffer diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 5e278406d..9dec26663 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -192,7 +192,7 @@ private Parameter getOutParameter(int i) throws SQLServerException { return inOutParam[i - 1]; } - if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType) { + if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && !connection.isColumnEncryptionSettingEnabled()) { return inOutParam[i - 1]; } @@ -341,7 +341,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { OutParamHandler outParamHandler = new OutParamHandler(); if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod) && !isTVPType - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && !connection.isColumnEncryptionSettingEnabled()) { nOutParamsAssigned++; } @@ -389,7 +389,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { outParamIndex = outParamHandler.srv.getOrdinalOrLength(); if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && SQLServerConnection - .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { + .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && !connection.isColumnEncryptionSettingEnabled()) { outParamIndex++; } else { // Statements need to have their out param indices adjusted by the number diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index 104ea8f3c..a58b1c040 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -764,7 +764,10 @@ void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnVal && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, params.length, bReturnValueSyntax)) { returnParam = params[index]; params[index].setReturnValue(true); - index++; + + if (!connection.isColumnEncryptionSettingEnabled()) { + index++; + } } for (; index < params.length; index++) { if (JDBCType.TVP == params[index].getJdbcType()) { @@ -1164,7 +1167,7 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN buildServerCursorExecParams(tdsWriter); } else { // if it is a parameterized stored procedure call and is not TVP, use sp_execute directly. - if (needsPrepare && callRpcDirectly) { + if (needsPrepare && callRpcDirectly && !connection.isColumnEncryptionSettingEnabled()) { buildRPCExecParams(tdsWriter); } // Move overhead of needing to do prepare & unprepare to only use cases that need more than one execution. diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 2035e1fd1..4b0935942 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -1616,7 +1616,7 @@ boolean onRetStatus(TDSReader tdsReader) throws SQLServerException { // not cursorable and not TVP type. For these two, the driver is still following the old behavior of // executing sp_executesql for stored procedures. if (!isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType && null != inOutParam - && inOutParam.length > 0 && inOutParam[0].isReturnValue()) { + && inOutParam.length > 0 && inOutParam[0].isReturnValue() && !connection.isColumnEncryptionSettingEnabled()) { inOutParam[0].setFromReturnStatus(procedureRetStatToken.getStatus(), connection); return false; } From 01491d5f3e8cded8241733b6debf486d5b325595 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Fri, 8 Sep 2023 12:34:43 -0700 Subject: [PATCH 07/51] Updated test to test erroring out on retrieving out param value --- .../sqlserver/jdbc/unit/statement/StatementTest.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java index 76f764e41..1ac75b404 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java @@ -1432,7 +1432,7 @@ public void testFailedToResumeTransaction() throws Exception { */ @Test @Tag(Constants.xAzureSQLDW) - public void testResultSetErrors() throws Exception { + public void testRetrievingRegisteredOutParamWhenResultSetDoesNotExists() throws Exception { try (Connection con = getConnection(); Statement stmt = con.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE)) { @@ -1449,7 +1449,11 @@ public void testResultSetErrors() throws Exception { try (ResultSet rs = cstmt.executeQuery()) {} catch (Exception ex) {} ; - assertEquals(null, cstmt.getString(2), TestResource.getResource("R_valueNotMatch")); + try { + cstmt.getString(2); + fail(TestResource.getResource("R_expectedExceptionNotThrown")); + } catch (Exception e) { + } } } } From 6593b34855b66e1ea3f412add0e97597556b00da Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Sun, 17 Sep 2023 16:55:46 -0700 Subject: [PATCH 08/51] Revert "Fixes p4" This reverts commit b19dfb0416dae97ae6fcee0fc48d3de9a3c197c3. --- src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java | 2 +- .../sqlserver/jdbc/SQLServerCallableStatement.java | 6 +++--- .../sqlserver/jdbc/SQLServerPreparedStatement.java | 7 ++----- .../com/microsoft/sqlserver/jdbc/SQLServerStatement.java | 2 +- 4 files changed, 7 insertions(+), 10 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index 5fbe2d68a..e0f06672e 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -1245,7 +1245,7 @@ void sendByRPC(TDSWriter tdsWriter, SQLServerStatement statement) throws SQLServ try { inputDTV.sendCryptoMetaData(this.cryptoMeta, tdsWriter); inputDTV.setJdbcTypeSetByUser(getJdbcTypeSetByUser(), getValueLength()); - inputDTV.sendByRPC(SQLServerPreparedStatement.callRpcDirectly && !conn.isColumnEncryptionSettingEnabled()? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, + inputDTV.sendByRPC(SQLServerPreparedStatement.callRpcDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, isOutput(), tdsWriter, statement); } finally { // reset the cryptoMeta in IOBuffer diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 9dec26663..5e278406d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -192,7 +192,7 @@ private Parameter getOutParameter(int i) throws SQLServerException { return inOutParam[i - 1]; } - if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && !connection.isColumnEncryptionSettingEnabled()) { + if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType) { return inOutParam[i - 1]; } @@ -341,7 +341,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { OutParamHandler outParamHandler = new OutParamHandler(); if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod) && !isTVPType - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && !connection.isColumnEncryptionSettingEnabled()) { + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { nOutParamsAssigned++; } @@ -389,7 +389,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { outParamIndex = outParamHandler.srv.getOrdinalOrLength(); if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && SQLServerConnection - .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && !connection.isColumnEncryptionSettingEnabled()) { + .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { outParamIndex++; } else { // Statements need to have their out param indices adjusted by the number diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index a58b1c040..104ea8f3c 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -764,10 +764,7 @@ void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnVal && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, params.length, bReturnValueSyntax)) { returnParam = params[index]; params[index].setReturnValue(true); - - if (!connection.isColumnEncryptionSettingEnabled()) { - index++; - } + index++; } for (; index < params.length; index++) { if (JDBCType.TVP == params[index].getJdbcType()) { @@ -1167,7 +1164,7 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN buildServerCursorExecParams(tdsWriter); } else { // if it is a parameterized stored procedure call and is not TVP, use sp_execute directly. - if (needsPrepare && callRpcDirectly && !connection.isColumnEncryptionSettingEnabled()) { + if (needsPrepare && callRpcDirectly) { buildRPCExecParams(tdsWriter); } // Move overhead of needing to do prepare & unprepare to only use cases that need more than one execution. diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 4b0935942..2035e1fd1 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -1616,7 +1616,7 @@ boolean onRetStatus(TDSReader tdsReader) throws SQLServerException { // not cursorable and not TVP type. For these two, the driver is still following the old behavior of // executing sp_executesql for stored procedures. if (!isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType && null != inOutParam - && inOutParam.length > 0 && inOutParam[0].isReturnValue() && !connection.isColumnEncryptionSettingEnabled()) { + && inOutParam.length > 0 && inOutParam[0].isReturnValue()) { inOutParam[0].setFromReturnStatus(procedureRetStatToken.getStatus(), connection); return false; } From d03b5207c225234f60d42a5809c46371eb030c84 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Sun, 17 Sep 2023 16:52:13 -0700 Subject: [PATCH 09/51] UDF fix --- .../microsoft/sqlserver/jdbc/IOBuffer.java | 29 +++++++++++++++++++ .../jdbc/SQLServerCallableStatement.java | 6 ++-- .../sqlserver/jdbc/SQLServerStatement.java | 16 +++++++++- 3 files changed, 47 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java index bb709307d..2c918f639 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java @@ -6988,6 +6988,35 @@ final short peekStatusFlag() { return 0; } + final int peekReturnValueStatus() throws SQLServerException { + // Ensure that we have a packet to read from. + if (!ensurePayload()) { + throwInvalidTDS(); + } + + // In order to parse the 'status' value, we need to skip over the following properties in the TDS packet + // payload: TDS token type (1 byte value), ordinal/length (2 byte value), parameter name length value (1 byte value) and + // the number of bytes that make the parameter name (need to be calculated). + // + // 'offset' starts at 4 because tdsTokenType + ordinal/length + parameter name length value is 4 bytes. So, we + // skip 4 bytes immediateley. + int offset = 4; + int paramNameLength = currentPacket.payload[payloadOffset + 3]; + + // Check if parameter name is set. If it's set, it should be > 0. In which case, we add the + // additional bytes to skip. + if (paramNameLength > 0) { + // Each character in unicode is 2 bytes + offset += 2 * paramNameLength; + } + + if (payloadOffset + offset <= currentPacket.payloadLength) { + return currentPacket.payload[payloadOffset + offset] & 0xFF; + } + + return -1; + } + final int readUnsignedByte() throws SQLServerException { // Ensure that we have a packet to read from. if (!ensurePayload()) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 5e278406d..5c1393f9a 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -192,7 +192,7 @@ private Parameter getOutParameter(int i) throws SQLServerException { return inOutParam[i - 1]; } - if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType) { + if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && returnValueStatus != 2) { return inOutParam[i - 1]; } @@ -341,7 +341,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { OutParamHandler outParamHandler = new OutParamHandler(); if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod) && !isTVPType - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != 2) { nOutParamsAssigned++; } @@ -389,7 +389,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { outParamIndex = outParamHandler.srv.getOrdinalOrLength(); if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && SQLServerConnection - .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax)) { + .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != 2) { outParamIndex++; } else { // Statements need to have their out param indices adjusted by the number diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 2035e1fd1..3559fc99f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -56,6 +56,7 @@ public class SQLServerStatement implements ISQLServerStatement { /** * Always update serialVersionUID when prompted. */ + private static final long serialVersionUID = -4421134713913331507L; final static char LEFT_CURLY_BRACKET = 123; @@ -66,6 +67,9 @@ public class SQLServerStatement implements ISQLServerStatement { /** response buffer adaptive flag */ boolean isResponseBufferingAdaptive = false; + /** TDS token return value status **/ + int returnValueStatus; + final boolean getIsResponseBufferingAdaptive() { return isResponseBufferingAdaptive; } @@ -1627,11 +1631,21 @@ boolean onRetStatus(TDSReader tdsReader) throws SQLServerException { @Override boolean onRetValue(TDSReader tdsReader) throws SQLServerException { + // Status: A value of 0x01 means the return value corresponds to an output parameter from + // a stored procedure. If it's 0x02 then the value corresponds to a return value from a + // user defined function. + // + // If it's a return value from a user defined function, we need to return false from this method + // so that the return value is not skipped. + int status = tdsReader.peekReturnValueStatus(); + + SQLServerStatement.this.returnValueStatus = status; + // We are only interested in return values that are statement OUT parameters, // in which case we need to stop parsing and let CallableStatement take over. // A RETVALUE token appearing in the execution results, but before any RETSTATUS // token, is a TEXTPTR return value that should be ignored. - if (moreResults && null == procedureRetStatToken) { + if (moreResults && null == procedureRetStatToken && status != 2) { Parameter p = new Parameter( Util.shouldHonorAEForParameters(stmtColumnEncriptionSetting, connection)); p.skipRetValStatus(tdsReader); From e34350d202508c73e9424f4745d498e586fdc8f7 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 16 Oct 2023 20:17:24 -0700 Subject: [PATCH 10/51] Accounted for premature closing of statements --- .../jdbc/SQLServerCallableStatement.java | 6 ++++++ .../CallableStatementTest.java | 17 ++++++++++++----- 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 5c1393f9a..dbbedb6e9 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -1402,6 +1402,12 @@ private String stripLeadingAtSign(String columnName) { */ private int findColumn(String columnName, CallableStatementGetterSetterMethod method) throws SQLServerException { + // If inOutParam is null, likely the statement was closed beforehand. + if (null == inOutParam) { + SQLServerException.makeFromDriverError(connection, this, + SQLServerException.getErrString("R_statementIsClosed"), null, false); + } + if (!isCursorable(executeMethod)) { // handle `@name` as well as `name`, since `@name` is what's returned // by DatabaseMetaData#getProcedureColumns 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 9a13abec1..b12c89c3f 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -21,6 +21,7 @@ import java.util.TimeZone; import java.util.UUID; +import com.microsoft.sqlserver.jdbc.*; import com.microsoft.sqlserver.testframework.PrepUtil; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; @@ -29,11 +30,6 @@ import org.junit.platform.runner.JUnitPlatform; import org.junit.runner.RunWith; -import com.microsoft.sqlserver.jdbc.RandomUtil; -import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement; -import com.microsoft.sqlserver.jdbc.SQLServerDataSource; -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 com.microsoft.sqlserver.testframework.Constants; @@ -98,6 +94,17 @@ public static void setupTest() throws Exception { } } + @Test + public void testCallableStatementClosedConnection() throws Exception { + try (SQLServerCallableStatement stmt = (SQLServerCallableStatement) connection.prepareCall("sproc")) { + stmt.close(); // Prematurely close the statement, which causes inOutParams to be null. + stmt.setStructured("myParam", "myTvp", (SQLServerDataTable) null); + fail(TestResource.getResource("R_expectedFailPassed")); + } catch (Exception e) { + assertEquals(TestResource.getResource("R_statementClosed"), e.getMessage()); + } + } + // Test Needs more work to be configured to run on azureDB as there are slight differences // between the regular SQL Server vs. azureDB @Test From 8f7d40ae5c1179da2df848ec68d1263d5f9ba198 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 16 Oct 2023 22:21:23 -0700 Subject: [PATCH 11/51] Datetime out of range fix --- src/main/java/com/microsoft/sqlserver/jdbc/dtv.java | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java index aa2fe4331..45519acdc 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java @@ -862,15 +862,9 @@ private void sendTemporal(DTV dtv, JavaType javaType, Object value) throws SQLSe subSecondNanos, (valueLength), isOutParam, statement); } } else { - if (jdbcType == JDBCType.DATETIME || jdbcType == JDBCType.SMALLDATETIME) { - tdsWriter.writeRPCDateTime(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, isOutParam); - } else { - tdsWriter.writeRPCDateTime2(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); - } + tdsWriter.writeRPCDateTime2(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); } break; From 1114154353e6efe37b7b8a0a9a7f275acdfee1a7 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 23 Oct 2023 14:57:16 -0700 Subject: [PATCH 12/51] Cstmts executed internally by the driver for XA transactions send out params as non-PLP over the wire for nvarchar and binary types --- .../microsoft/sqlserver/jdbc/IOBuffer.java | 10 +++---- .../microsoft/sqlserver/jdbc/Parameter.java | 3 ++ .../jdbc/SQLServerCallableStatement.java | 5 ++++ .../sqlserver/jdbc/SQLServerXAResource.java | 28 +++++++++---------- .../com/microsoft/sqlserver/jdbc/dtv.java | 14 ++++++---- 5 files changed, 35 insertions(+), 25 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java index 2c918f639..ba3b3c470 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java @@ -4791,7 +4791,7 @@ void writeVMaxHeader(long headerLength, boolean isNull, SQLCollation collation) * Utility for internal writeRPCString calls */ void writeRPCStringUnicode(String sValue) throws SQLServerException { - writeRPCStringUnicode(null, sValue, false, null); + writeRPCStringUnicode(null, sValue, false, null, false); } /** @@ -4807,7 +4807,7 @@ void writeRPCStringUnicode(String sValue) throws SQLServerException { * the collation of the data value */ void writeRPCStringUnicode(String sName, String sValue, boolean bOut, - SQLCollation collation) throws SQLServerException { + SQLCollation collation, boolean isNonPLP) throws SQLServerException { boolean bValueNull = (sValue == null); int nValueLen = bValueNull ? 0 : (2 * sValue.length()); // Textual RPC requires a collation. If none is provided, as is the case when @@ -4819,7 +4819,7 @@ void writeRPCStringUnicode(String sName, String sValue, boolean bOut, * Use PLP encoding if either OUT params were specified or if the user query exceeds * DataTypes.SHORT_VARTYPE_MAX_BYTES */ - if (nValueLen > DataTypes.SHORT_VARTYPE_MAX_BYTES || bOut) { + if ((nValueLen > DataTypes.SHORT_VARTYPE_MAX_BYTES || bOut) && !isNonPLP) { writeRPCNameValType(sName, bOut, TDSType.NVARCHAR); // Handle Yukon v*max type header here. @@ -5565,7 +5565,7 @@ void writeCryptoMetaData() throws SQLServerException { } void writeRPCByteArray(String sName, byte[] bValue, boolean bOut, JDBCType jdbcType, - SQLCollation collation) throws SQLServerException { + SQLCollation collation, boolean isNonPLP) throws SQLServerException { boolean bValueNull = (bValue == null); int nValueLen = bValueNull ? 0 : bValue.length; boolean isShortValue = (nValueLen <= DataTypes.SHORT_VARTYPE_MAX_BYTES); @@ -5611,7 +5611,7 @@ void writeRPCByteArray(String sName, byte[] bValue, boolean bOut, JDBCType jdbcT writeRPCNameValType(sName, bOut, tdsType); - if (usePLP) { + if (usePLP && !isNonPLP) { // Handle Yukon v*max type header here. writeVMaxHeader(nValueLen, bValueNull, collation); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index e0f06672e..37f9a4dd0 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -37,6 +37,8 @@ final class Parameter { // For unencrypted parameters cryptometa will be null. For encrypted parameters it will hold encryption metadata. CryptoMetadata cryptoMeta = null; + boolean isNonPLP = false; + TypeInfo getTypeInfo() { return typeInfo; } @@ -1243,6 +1245,7 @@ void sendByRPC(TDSWriter tdsWriter, SQLServerStatement statement) throws SQLServ SQLServerConnection conn = statement.connection; try { + inputDTV.isNonPLP = isNonPLP; inputDTV.sendCryptoMetaData(this.cryptoMeta, tdsWriter); inputDTV.setJdbcTypeSetByUser(getJdbcTypeSetByUser(), getValueLength()); inputDTV.sendByRPC(SQLServerPreparedStatement.callRpcDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index dbbedb6e9..c733111b8 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -167,6 +167,11 @@ public void registerOutParameter(int index, int sqlType) throws SQLServerExcepti loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } + void registerOutParameterNonPLP(int index, int sqlType) throws SQLServerException { + registerOutParameter(index, sqlType); + inOutParam[index - 1].isNonPLP = true; + } + /** * Locate any output parameter values returned from the procedure call */ diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java index 7f9c44a2f..6d82bf836 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java @@ -417,8 +417,8 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X initCS = (SQLServerCallableStatement) controlConnection .prepareCall("{call master..xp_sqljdbc_xa_init_ex(?, ?,?)}"); initCS.registerOutParameter(1, Types.INTEGER); // Return status - initCS.registerOutParameter(2, Types.CHAR); // Return error message - initCS.registerOutParameter(3, Types.CHAR); // Return version number + initCS.registerOutParameterNonPLP(2, Types.CHAR); // Return error message + initCS.registerOutParameterNonPLP(3, Types.CHAR); // Return version number try { initCS.execute(); } catch (SQLServerException eX) { @@ -528,21 +528,21 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X sContext = "START:"; cs = getXACallableStatementHandle(XA_START); cs.registerOutParameter(n++, Types.INTEGER); // Return status - cs.registerOutParameter(n++, Types.CHAR); // Return error message + cs.registerOutParameterNonPLP(n++, Types.CHAR); // Return error message cs.setBytes(n++, gid); // Global XID cs.setBytes(n++, bid); // Branch ID cs.setInt(n++, xaFlags); // XA transaction flags - cs.registerOutParameter(n++, Types.BINARY); // Returned OLE transaction cookie + cs.registerOutParameterNonPLP(n++, Types.BINARY); // Returned OLE transaction cookie cs.setInt(n++, timeoutSeconds); // Transaction timeout in seconds. cs.setInt(n++, formatId); // Format ID - cs.registerOutParameter(n++, Types.CHAR); // DLL Version number + cs.registerOutParameterNonPLP(n++, Types.CHAR); // DLL Version number cs.setInt(n++, Integer.parseInt(version)); // Version of SQL Server cs.setInt(n++, instanceName.length()); // Length of SQL Server instance name cs.setBytes(n++, instanceName.getBytes()); // SQL Server instance name cs.setInt(n++, architectureMSSQL); // Architecture of SQL Server cs.setInt(n++, architectureOS); // Architecture of OS running SQL Server cs.setInt(n++, isTransacrionTimeoutSet); // pass 1 if setTransactionTimeout() is called - cs.registerOutParameter(n++, Types.BINARY); // Return UoW + cs.registerOutParameterNonPLP(n++, Types.BINARY); // Return UoW break; @@ -550,12 +550,12 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X sContext = "END:"; cs = getXACallableStatementHandle(XA_END); cs.registerOutParameter(n++, Types.INTEGER); - cs.registerOutParameter(n++, Types.CHAR); + cs.registerOutParameterNonPLP(n++, Types.CHAR); cs.setBytes(n++, gid); cs.setBytes(n++, bid); cs.setInt(n++, xaFlags); cs.setInt(n++, formatId); - cs.registerOutParameter(n++, Types.BINARY); // Return UoW + cs.registerOutParameterNonPLP(n++, Types.BINARY); // Return UoW break; case XA_PREPARE: @@ -566,7 +566,7 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X cs = getXACallableStatementHandle(XA_PREPARE); cs.registerOutParameter(n++, Types.INTEGER); - cs.registerOutParameter(n++, Types.CHAR); + cs.registerOutParameterNonPLP(n++, Types.CHAR); cs.setBytes(n++, gid); cs.setBytes(n++, bid); if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD) @@ -578,7 +578,7 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X sContext = "COMMIT:"; cs = getXACallableStatementHandle(XA_COMMIT); cs.registerOutParameter(n++, Types.INTEGER); - cs.registerOutParameter(n++, Types.CHAR); + cs.registerOutParameterNonPLP(n++, Types.CHAR); cs.setBytes(n++, gid); cs.setBytes(n++, bid); cs.setInt(n++, xaFlags); @@ -593,7 +593,7 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X cs = getXACallableStatementHandle(XA_ROLLBACK); cs.registerOutParameter(n++, Types.INTEGER); - cs.registerOutParameter(n++, Types.CHAR); + cs.registerOutParameterNonPLP(n++, Types.CHAR); cs.setBytes(n++, gid); cs.setBytes(n++, bid); if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD) @@ -608,7 +608,7 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X else cs = getXACallableStatementHandle(XA_FORGET); cs.registerOutParameter(n++, Types.INTEGER); - cs.registerOutParameter(n++, Types.CHAR); + cs.registerOutParameterNonPLP(n++, Types.CHAR); cs.setBytes(n++, gid); cs.setBytes(n++, bid); if ((SSTRANSTIGHTLYCPLD & xaFlags) == SSTRANSTIGHTLYCPLD) @@ -620,9 +620,9 @@ private XAReturnValue dtc_XA_interface(int nType, Xid xid, int xaFlags) throws X sContext = "RECOVER:"; cs = getXACallableStatementHandle(XA_RECOVER); cs.registerOutParameter(n++, Types.INTEGER); - cs.registerOutParameter(n++, Types.CHAR); + cs.registerOutParameterNonPLP(n++, Types.CHAR); cs.setInt(n++, xaFlags); - cs.registerOutParameter(n++, Types.BINARY); + cs.registerOutParameterNonPLP(n++, Types.BINARY); // Format Id need not be sent for recover action break; default: diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java index 45519acdc..83fc4eb9c 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java @@ -132,6 +132,8 @@ final class DTV { int valueLength = 0; boolean sendStringParametersAsUnicode = true; + boolean isNonPLP = false; + /** * Sets a DTV value from a Java object. * @@ -289,7 +291,7 @@ final class SendByRPCOp extends DTVExecuteOp { } void execute(DTV dtv, String strValue) throws SQLServerException { - tdsWriter.writeRPCStringUnicode(name, strValue, isOutParam, collation); + tdsWriter.writeRPCStringUnicode(name, strValue, isOutParam, collation, dtv.isNonPLP); } void execute(DTV dtv, Clob clobValue) throws SQLServerException { @@ -311,7 +313,7 @@ void execute(DTV dtv, Clob clobValue) throws SQLServerException { if (null != collation && (JDBCType.CHAR == jdbcType || JDBCType.VARCHAR == jdbcType || JDBCType.LONGVARCHAR == jdbcType || JDBCType.CLOB == jdbcType)) { if (null == clobReader) { - tdsWriter.writeRPCByteArray(name, null, isOutParam, jdbcType, collation); + tdsWriter.writeRPCByteArray(name, null, isOutParam, jdbcType, collation, false); } else { ReaderInputStream clobStream = new ReaderInputStream(clobReader, collation.getCharset(), clobLength); @@ -322,7 +324,7 @@ void execute(DTV dtv, Clob clobValue) throws SQLServerException { } else // Send CLOB value as Unicode { if (null == clobReader) { - tdsWriter.writeRPCStringUnicode(name, null, isOutParam, collation); + tdsWriter.writeRPCStringUnicode(name, null, isOutParam, collation, false); } else { tdsWriter.writeRPCReaderUnicode(name, clobReader, clobLength, isOutParam, collation); } @@ -1075,7 +1077,7 @@ void execute(DTV dtv, BigDecimal bigDecimalValue) throws SQLServerException { DriverError.NOT_SET, null); } else { String strValue = bigDecimalValue.toString(); - tdsWriter.writeRPCStringUnicode(name, strValue, isOutParam, collation); + tdsWriter.writeRPCStringUnicode(name, strValue, isOutParam, collation, false); } } else { tdsWriter.writeRPCBigDecimal(name, bigDecimalValue, outScale, isOutParam); @@ -1126,7 +1128,7 @@ void execute(DTV dtv, byte[] byteArrayValue) throws SQLServerException { } } else - tdsWriter.writeRPCByteArray(name, byteArrayValue, isOutParam, dtv.getJdbcType(), collation); + tdsWriter.writeRPCByteArray(name, byteArrayValue, isOutParam, dtv.getJdbcType(), collation, dtv.isNonPLP); } @@ -1379,7 +1381,7 @@ void execute(DTV dtv, Blob blobValue) throws SQLServerException { } if (null == blobStream) { - tdsWriter.writeRPCByteArray(name, null, isOutParam, dtv.getJdbcType(), collation); + tdsWriter.writeRPCByteArray(name, null, isOutParam, dtv.getJdbcType(), collation, false); } else { tdsWriter.writeRPCInputStream(name, blobStream, blobLength, isOutParam, dtv.getJdbcType(), collation); } From 34f647bc562688cd231f1ec49287871074b64071 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Tue, 31 Oct 2023 15:46:24 -0700 Subject: [PATCH 13/51] Accounted for zero param sproc --- .../microsoft/sqlserver/jdbc/SQLServerConnection.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index d605ef1af..3e8aec97f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -514,11 +514,12 @@ static ParsedSQLCacheItem parseAndCacheSQL(CityHash128Key key, String sql) throw static boolean isCallRemoteProcDirectValid(String sql, int paramCount, boolean isReturnSyntax) { int commaCount = SQLServerConnection.countCommas(sql); if (isReturnSyntax) { - return paramCount == commaCount + 2; // if return syntax, sql text commas should be equal to paramCount - - // 2 + // If return syntax, sql text commas should be equal to paramCount - 2. + // Or, if return syntax and paramCount is 1, it's a no param sproc. + return (paramCount == commaCount + 2) || paramCount == 1; } else { - return paramCount == commaCount + 1; // if not return syntax, sql text commas should be equal to - // paramCount -1 + // if not return syntax, sql text commas should be equal to paramCount - 1. + return paramCount == commaCount + 1; } } From dd390e2646eee7f926e7a764eb4481298895fc2c Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Tue, 31 Oct 2023 15:48:38 -0700 Subject: [PATCH 14/51] Fixed setting/registering of out of order params --- .../sqlserver/jdbc/SQLServerCallableStatement.java | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index c733111b8..3b3ad80af 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -1424,18 +1424,6 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me return i + 1; } } - - if (method == CallableStatementGetterSetterMethod.isSetterMethod) { - for (int i = 0; i < inOutParam.length; i++) { - // if it is not already registered as output param or the parameter is not an input parameter, then - // set the param name and return index. - if (null == inOutParam[i].getName() && !inOutParam[i].isReturnValue() - && null == inOutParam[i].getInputDTV() && null == inOutParam[i].getRegisteredOutDTV()) { - inOutParam[i].setName(columnNameWithoutAtSign); - return i + 1; - } - } - } } // Stored procedures with cursorable methods are not called directly, so we have to get the metadata From b99521c9c1ffd245c02dcc728d600e87422f5616 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 16:23:44 -0700 Subject: [PATCH 15/51] Datetime fractional seconds correction --- .../com/microsoft/sqlserver/jdbc/dtv.java | 23 +++- .../jdbc/datatypes/DateAndTimeTypeTest.java | 103 ++++++++++++++++-- 2 files changed, 114 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java index 83fc4eb9c..ee7906dbc 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java @@ -864,9 +864,26 @@ private void sendTemporal(DTV dtv, JavaType javaType, Object value) throws SQLSe subSecondNanos, (valueLength), isOutParam, statement); } } else { - tdsWriter.writeRPCDateTime2(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); + if (jdbcType == JDBCType.SMALLDATETIME) { + tdsWriter.writeRPCDateTime(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, isOutParam); + + } else if (jdbcType == JDBCType.DATETIME) { + if (conn.getDatetimeParameterType().equals(DatetimeType.DATETIME2.toString())) { + tdsWriter.writeRPCDateTime2(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, 3, isOutParam); + } else if (conn.getDatetimeParameterType().equals(DatetimeType.DATETIME.toString())) { + tdsWriter.writeRPCDateTime(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, isOutParam); + } + } else { + tdsWriter.writeRPCDateTime2(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); + } } break; diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java index 99dbe64dc..22ac9f767 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java @@ -7,14 +7,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertEquals; -import java.sql.Connection; -import java.sql.Date; -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.sql.*; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; @@ -49,6 +42,8 @@ public class DateAndTimeTypeTest extends AbstractTest { private static final String timeTVP = RandomUtil.getIdentifier("timeTVP"); private static final String timestampTVP = RandomUtil.getIdentifier("timestampTVP"); private static final String tableName = RandomUtil.getIdentifier("DataTypesTable"); + private static final String datetimeTable = RandomUtil.getIdentifier("DateTimeTable"); + private static final String datetimeSproc = RandomUtil.getIdentifier("dateTimeSproc"); private static final String primaryKeyConstraintName = "pk_" + tableName; /** @@ -241,7 +236,7 @@ public void testSendTimestampAsDatetime2() throws Exception { String actual = null; String query = "SELECT CONVERT(VARCHAR(40), ?, 126) as [value]"; - try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetime2"); + try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetime2"); PreparedStatement stmt = conn.prepareStatement(query)) { Timestamp ts = Timestamp.valueOf("2010-02-02 23:59:59.1234567"); @@ -295,6 +290,86 @@ public void testSendTimestampAsDatetimeoffset() throws Exception { assertEquals(expected, actual); } + @Test + public void testCstmtRegisterDatetimeOutParameterDateTimeParameterTypeDatetime() throws Exception { + String expected = "3160-08-17 19:09:06.937"; + String actual = null; + String query = "{CALL " + AbstractSQLGenerator.escapeIdentifier(datetimeSproc) + "(?)}"; + + // The following should be the T-SQL executed. Since datetimeParameterType=dateTime, the registererd param type + // should be 'datetime' eg. declare @p1 datetime as shown below. The expected fractional seconds should be 3. + // + // declare @p1 datetime + // set @p1='3160-08-17 19:09:06.937' + // exec sproc @p1 output + // select @p1 + try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetime"); + CallableStatement stmt = conn.prepareCall(query)) { + + stmt.registerOutParameter(1, microsoft.sql.Types.DATETIME); + stmt.execute(); + + actual = stmt.getString(1); + System.out.println(actual); + } + + assertEquals(expected, actual.toString()); + } + + @Test + public void testCstmtRegisterDatetimeOutParameterDateTimeParameterTypeDatetime2() throws Exception { + String expected = "3160-08-17 19:09:06.937"; + String actual = null; + String query = "{CALL " + AbstractSQLGenerator.escapeIdentifier(datetimeSproc) + "(?)}"; + + // The following should be the T-SQL executed. Since datetimeParameterType=dateTime2, the registered param type + // should be 'datetime2(3)' eg. declare @p1 datetime2(3) as shown below. The expected fractional seconds + // should be 7 in the T-SQL, but in the expected actual output it's rounded so fractional seconds should be 3. + // + // declare @p1 datetime2(3) + // set @p1='set @p1='3160-08-17 19:09:06.9370000'' + // exec sproc @p1 output + // select @p1 + try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetime2"); + CallableStatement stmt = conn.prepareCall(query)) { + + stmt.registerOutParameter(1, microsoft.sql.Types.DATETIME); + stmt.execute(); + + actual = stmt.getString(1); + System.out.println(actual); + } + + assertEquals(expected, actual.toString()); + } + + + @Test + public void testCstmtRegisterTimestampOutParameter() throws Exception { + String expected = "3160-08-17 19:09:06.9366667"; + String actual = null; + String query = "{CALL " + AbstractSQLGenerator.escapeIdentifier(datetimeSproc) + "(?)}"; + + // The following should be the T-SQL executed. Default driver behaviour for Timestamp SQL types is to register + // the param in the RPC as datetime2(7). So fractional seconds should be 7. + // + // declare @p1 datetime2(7) + // set @p1='3160-08-17 19:09:06.9366667' + // exec sproc @p1 output + // select @p1 + try (SQLServerConnection conn = PrepUtil.getConnection(connectionString); + CallableStatement stmt = conn.prepareCall(query)) { + + stmt.registerOutParameter(1, Types.TIMESTAMP); + stmt.execute(); + + actual = stmt.getString(1); + System.out.println(actual); + } + + assertEquals(expected, actual.toString()); + } + @BeforeEach public void testSetup() throws TestAbortedException, Exception { // To get TIME & setTime working on Servers >= 2008, we must add 'sendTimeAsDatetime=false' @@ -305,7 +380,12 @@ public void testSetup() throws TestAbortedException, Exception { String sql1 = "create table " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (id integer not null, my_date date, my_time time, my_timestamp datetime2 constraint " + AbstractSQLGenerator.escapeIdentifier(primaryKeyConstraintName) + " primary key (id))"; + String sql2 = "create table " + AbstractSQLGenerator.escapeIdentifier(datetimeTable) + " (c1 datetime2 NULL)"; + String sql3 = "create procedure " + AbstractSQLGenerator.escapeIdentifier(datetimeSproc) + + " (@p1 datetime2 output) as select top 1 @p1=c1 from " + AbstractSQLGenerator.escapeIdentifier(datetimeTable); stmt.execute(sql1); + stmt.execute(sql2); + stmt.execute(sql3); // add one sample data String sPrepStmt = "insert into " + AbstractSQLGenerator.escapeIdentifier(tableName) @@ -321,6 +401,9 @@ public void testSetup() throws TestAbortedException, Exception { createTVPs(timeTVP, "time"); createTVPs(timestampTVP, "datetime2"); } + + stmt.execute("insert into " + AbstractSQLGenerator.escapeIdentifier(datetimeTable) + + " values('3160-08-17 19:09:06.9366667')"); } } @@ -328,6 +411,8 @@ public void testSetup() throws TestAbortedException, Exception { public static void terminateVariation() throws SQLException { try (Statement stmt = connection.createStatement()) { TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt); + TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(datetimeTable), stmt); + TestUtils.dropProcedureIfExists(AbstractSQLGenerator.escapeIdentifier(datetimeSproc), stmt); } } } From 55a589c7548427f75e6dc5b87e01cf03d133d20f Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 18:30:52 -0700 Subject: [PATCH 16/51] DTC tests --- pom.xml | 3 +- .../com/microsoft/sqlserver/jdbc/DTC.java | 113 ++++++++++++++++++ .../sqlserver/testframework/Constants.java | 2 + 3 files changed, 117 insertions(+), 1 deletion(-) create mode 100644 src/test/java/com/microsoft/sqlserver/jdbc/DTC.java diff --git a/pom.xml b/pom.xml index eb0d51670..da7a6dc86 100644 --- a/pom.xml +++ b/pom.xml @@ -43,7 +43,8 @@ xAzureSQLDW - - - - For tests not compatible with Azure Data Warehouse - xAzureSQLMI - - - - For tests not compatible with Azure SQL Managed Instance NTLM - - - - - - - For tests using NTLM Authentication mode (excluded by default) - kerberos - - - - - For tests using Kerberos authentication (excluded by default) + kerberos - - - - - For tests using Kerberos authentication (excluded by default) + DTC - - - - - - - - For tests using MSDTC authentication (excluded by default) reqExternalSetup - For tests requiring external setup (excluded by default) clientCertAuth - - For tests requiring client certificate authentication setup (excluded by default) - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/DTC.java b/src/test/java/com/microsoft/sqlserver/jdbc/DTC.java new file mode 100644 index 000000000..cc76bf1ff --- /dev/null +++ b/src/test/java/com/microsoft/sqlserver/jdbc/DTC.java @@ -0,0 +1,113 @@ +package com.microsoft.sqlserver.jdbc; + +import com.microsoft.sqlserver.testframework.AbstractTest; +import com.microsoft.sqlserver.testframework.Constants; +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 javax.sql.XAConnection; +import javax.transaction.xa.XAResource; +import javax.transaction.xa.Xid; +import java.net.Inet4Address; +import java.sql.Connection; +import java.util.Random; + + +@RunWith(JUnitPlatform.class) +@Tag(Constants.DTC) +public class DTC extends AbstractTest { + @BeforeAll + public static void setupTest() throws Exception { + setConnection(); + } + + @Test + public void testCstmtXpSqljdbcXaInit() throws Exception { + SQLServerXADataSource XADataSource = new SQLServerXADataSource(); + XADataSource.setURL(connectionString); + XAConnection XAConnection = XADataSource.getXAConnection(); + + try (Connection con = XAConnection.getConnection()) { + XAResource xaRes = null; + Xid xid = null; + xid = XidImpl.getUniqueXid(1); + + xaRes = XAConnection.getXAResource(); + xaRes.setTransactionTimeout(0); + + // Driver calls 'master..xp_sqljdbc_xa_init_ex(?,?,?)' internally as a cstmt. + // Test that the registered out params are sent over the wire as non-PLP. + // If the RPC params are sent as PLP, test will fail with the following error: + // Failed to create the XA control connection. Error: "Cannot continue the execution because the + // session is in the kill state. + xaRes.start(xid, XAResource.TMNOFLAGS); + } + } + + static class XidImpl implements Xid { + public int formatId; + public byte[] gtrid; + public byte[] bqual; + static byte[] localIP = null; + static int txnUniqueID = 0; + + public byte[] getGlobalTransactionId() { + return gtrid; + } + + public byte[] getBranchQualifier() { + return bqual; + } + + public int getFormatId() { + return formatId; + } + + XidImpl(int formatId, byte[] gtrid, byte[] bqual) { + this.formatId = formatId; + this.gtrid = gtrid; + this.bqual = bqual; + } + + static Xid getUniqueXid(int tid) { + + Random rnd = new Random(System.currentTimeMillis()); + txnUniqueID++; + int txnUID = txnUniqueID; + int tidID = tid; + int randID = rnd.nextInt(); + byte[] gtrid = new byte[64]; + byte[] bqual = new byte[64]; + + if (null == localIP) { + try { + localIP = Inet4Address.getLocalHost().getAddress(); + } catch (Exception ex) { + localIP = new byte[] {0x01, 0x02, 0x03, 0x04}; + } + } + + System.arraycopy(localIP, 0, gtrid, 0, 4); + System.arraycopy(localIP, 0, bqual, 0, 4); + + // Bytes 4 -> 7 - unique transaction id. + // Bytes 8 ->11 - thread id. + // Bytes 12->15 - random number generated by using seed from current time in milliseconds. + for (int i = 0; i <= 3; i++) { + gtrid[i + 4] = (byte) (txnUID % 0x100); + bqual[i + 4] = (byte) (txnUID % 0x100); + txnUID >>= 8; + gtrid[i + 8] = (byte) (tidID % 0x100); + bqual[i + 8] = (byte) (tidID % 0x100); + tidID >>= 8; + gtrid[i + 12] = (byte) (randID % 0x100); + bqual[i + 12] = (byte) (randID % 0x100); + randID >>= 8; + } + return new DTC.XidImpl(0x1234, gtrid, bqual); + } + } +} diff --git a/src/test/java/com/microsoft/sqlserver/testframework/Constants.java b/src/test/java/com/microsoft/sqlserver/testframework/Constants.java index 92ba90811..a1eadf14c 100644 --- a/src/test/java/com/microsoft/sqlserver/testframework/Constants.java +++ b/src/test/java/com/microsoft/sqlserver/testframework/Constants.java @@ -26,6 +26,7 @@ private Constants() {} * xAzureSQLMI - - - - For tests not compatible with Azure SQL Managed Instance * NTLM - - - - - - - For NTLM tests * Kerberos - - - - - For Kerberos tests + * DTC - - - - - - - - For DTC tests * reqExternalSetup - For tests requiring external setup * clientCertAuth - - For tests requiring client certificate authentication setup * Fedauth - - - - - - For Fedauth tests @@ -43,6 +44,7 @@ private Constants() {} public static final String xAzureSQLMI = "xAzureSQLMI"; public static final String NTLM = "NTLM"; public static final String kerberos = "kerberos"; + public static final String DTC = "DTC"; public static final String MSI = "MSI"; public static final String reqExternalSetup = "reqExternalSetup"; public static final String clientCertAuth = "clientCertAuth"; From fbe237bb1811052c9e0551df99d700161509bda5 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 18:46:55 -0700 Subject: [PATCH 17/51] Zero param sproc test; Error test for casting of sproc return value --- .../sqlserver/jdbc/TestResource.java | 1 + .../CallableStatementTest.java | 37 +++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java index 78ff3875d..c9e07695a 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java @@ -77,6 +77,7 @@ protected Object[][] getContents() { {"R_supportUnwrapping", "{0} supports unwrapping."}, {"R_cantAccessSnapshot", "Cant access the TRANSACTION_SNAPSHOT "}, {"R_newConnectionShouldBeValid", "Newly created connection should be valid"}, + {"R_outputParamCastError", "class java.lang.Integer cannot be cast to class [B (java.lang.Integer and [B are in module java.base of loader 'bootstrap')"}, {"R_closedConnectionShouldBeInvalid", "Closed connection should be invalid"}, {"R_noExceptionNegativeTimeout", "No exception thrown with negative timeout"}, {"R_noExceptionClosedConnection", 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 b12c89c3f..c734bfd39 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -61,6 +61,8 @@ public class CallableStatementTest extends AbstractTest { .escapeIdentifier(RandomUtil.getIdentifier("manyParam_Procedure")); private static String manyParamUserDefinedType = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("manyParam_definedType")); + private static String zeroParamSproc = AbstractSQLGenerator + .escapeIdentifier(RandomUtil.getIdentifier("zeroParamSproc")); /** * Setup before test @@ -78,6 +80,7 @@ public static void setupTest() throws Exception { TestUtils.dropProcedureIfExists(inputParamsProcedureName, stmt); TestUtils.dropProcedureIfExists(getObjectLocalDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); + TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); TestUtils.dropUserDefinedTypeIfExists(manyParamUserDefinedType, stmt); TestUtils.dropProcedureIfExists(manyParamProc, stmt); TestUtils.dropTableIfExists(manyParamsTable, stmt); @@ -91,6 +94,7 @@ public static void setupTest() throws Exception { createTableManyParams(); createProcedureManyParams(); createGetObjectOffsetDateTimeProcedure(stmt); + createProcedureZeroParams(); } } @@ -351,6 +355,31 @@ public void inputParamsTest() throws SQLException { } } + @Test + public void testZeroParamSproc() throws SQLException { + String call = "{? = CALL " + zeroParamSproc + "}"; + + try (CallableStatement cs = connection.prepareCall(call)) { + cs.registerOutParameter(1, Types.INTEGER); + cs.execute(); + assertEquals(1, cs.getInt(1)); + } + } + + @Test + public void testSprocCastingError() throws SQLException { + String call = "{? = CALL " + zeroParamSproc + "}"; + + try (CallableStatement cs = connection.prepareCall(call)) { + cs.registerOutParameter(1, Types.BINARY); + cs.execute(); // Should not be able to get return value as binary + cs.getBytes(1); + fail(TestResource.getResource("R_expectedFailPassed")); + } catch (Exception e) { + assertEquals(TestResource.getResource("R_outputParamCastError"), e.getMessage()); + } + } + /** * Cleanup after test * @@ -366,6 +395,7 @@ public static void cleanup() throws SQLException { TestUtils.dropProcedureIfExists(inputParamsProcedureName, stmt); TestUtils.dropProcedureIfExists(getObjectLocalDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); + TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); } } @@ -434,4 +464,11 @@ private static void createUserDefinedType() throws SQLException { stmt.executeUpdate(TVPCreateCmd); } } + + private static void createProcedureZeroParams() throws SQLException { + String sql = "CREATE PROCEDURE " + zeroParamSproc + " AS RETURN 1"; + try (Statement stmt = connection.createStatement()) { + stmt.execute(sql); + } + } } From 9c6856483f4b1c3ae094a96e8aaeae90407d8ea5 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 19:12:17 -0700 Subject: [PATCH 18/51] Test shuffled ordering of registering and setting cstmt params --- .../CallableStatementTest.java | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) 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 c734bfd39..2873603cd 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -63,6 +63,8 @@ public class CallableStatementTest extends AbstractTest { .escapeIdentifier(RandomUtil.getIdentifier("manyParam_definedType")); private static String zeroParamSproc = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("zeroParamSproc")); + private static String outOfOrderSproc= AbstractSQLGenerator + .escapeIdentifier(RandomUtil.getIdentifier("outOfOrderSproc")); /** * Setup before test @@ -81,6 +83,7 @@ public static void setupTest() throws Exception { TestUtils.dropProcedureIfExists(getObjectLocalDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); + TestUtils.dropProcedureIfExists(outOfOrderSproc, stmt); TestUtils.dropUserDefinedTypeIfExists(manyParamUserDefinedType, stmt); TestUtils.dropProcedureIfExists(manyParamProc, stmt); TestUtils.dropTableIfExists(manyParamsTable, stmt); @@ -95,6 +98,7 @@ public static void setupTest() throws Exception { createProcedureManyParams(); createGetObjectOffsetDateTimeProcedure(stmt); createProcedureZeroParams(); + createOutOfOrderSproc(); } } @@ -380,6 +384,44 @@ public void testSprocCastingError() throws SQLException { } } + @Test + public void testNonOrderedRegisteringAndSettingOfParams() throws SQLException { + String call ="{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + + try (CallableStatement cstmt = connection.prepareCall(call)) { + int scale = 6; + Double obj1 = 2015.0123; + Double obj2 = 2015.012345; + Integer obj3 = -3; + Float obj4 = 2015.04f; + Integer obj5 = 3; + String obj6 = "foo"; + String obj7 = "bar"; + Long obj8 = 2015L; + + cstmt.setObject("i5", obj5, Types.CHAR); + cstmt.setObject("i6", obj6, Types.VARCHAR); + cstmt.setObject("i7", obj7, Types.CHAR); + cstmt.setObject("i8", obj8, Types.SMALLINT); + + cstmt.setObject(1, obj1, Types.NUMERIC); + cstmt.setObject(2, obj2, Types.NUMERIC, scale); + cstmt.setObject(3, obj3, Types.INTEGER); + cstmt.setObject(4, obj4, Types.FLOAT); + + cstmt.registerOutParameter(9, Types.NUMERIC); + cstmt.registerOutParameter("o2", Types.NUMERIC, scale); + cstmt.registerOutParameter("o3", Types.INTEGER); + cstmt.registerOutParameter("o4", Types.FLOAT); + + cstmt.registerOutParameter(13, Types.CHAR); + cstmt.registerOutParameter(14, Types.VARCHAR); + cstmt.registerOutParameter(15, Types.CHAR); + cstmt.registerOutParameter(16, Types.SMALLINT); + cstmt.execute(); + } + } + /** * Cleanup after test * @@ -396,6 +438,7 @@ public static void cleanup() throws SQLException { TestUtils.dropProcedureIfExists(getObjectLocalDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); + TestUtils.dropProcedureIfExists(outOfOrderSproc, stmt); } } @@ -471,4 +514,17 @@ private static void createProcedureZeroParams() throws SQLException { stmt.execute(sql); } } + + private static void createOutOfOrderSproc() throws SQLException { + String sql = "CREATE PROCEDURE " + outOfOrderSproc + " @i1 NUMERIC(16,10)," + " @i2 NUMERIC(16,6)," + + " @i3 INT," + " @i4 REAL," + " @i5 CHAR," + " @i6 VARCHAR(6)," + " @i7 CHAR," + + " @i8 SMALLINT, " + " @o1 NUMERIC(16,10) OUTPUT," + " @o2 NUMERIC(16,6) OUTPUT," + + " @o3 INT OUTPUT," + " @o4 REAL OUTPUT," + " @o5 CHAR OUTPUT," + " @o6 VARCHAR(6) OUTPUT," + + " @o7 CHAR OUTPUT," + " @o8 SMALLINT OUTPUT" + " as begin " + " set @o1=@i1;" + + " set @o2=@i2;" + " set @o3=@i3;" + " set @o4=@i4;" + " set @o5=@i5;" + " set @o6=@i6;" + + " set @o7=@i7;" + " set @o8=@i8;" + " end"; + try (Statement stmt = connection.createStatement()) { + stmt.execute(sql); + } + } } From 4d3e2dfd03ad323c2ecc54bbbef23e690775659b Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 19:42:24 -0700 Subject: [PATCH 19/51] UDF test --- .../jdbc/SQLServerCallableStatement.java | 6 ++-- .../sqlserver/jdbc/SQLServerStatement.java | 4 ++- .../CallableStatementTest.java | 36 +++++++++++++++++-- 3 files changed, 40 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 3b3ad80af..fd00738ab 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -197,7 +197,7 @@ private Parameter getOutParameter(int i) throws SQLServerException { return inOutParam[i - 1]; } - if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && returnValueStatus != 2) { + if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && returnValueStatus != userDefinedFunctionReturnStatus) { return inOutParam[i - 1]; } @@ -346,7 +346,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { OutParamHandler outParamHandler = new OutParamHandler(); if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod) && !isTVPType - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != 2) { + && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != userDefinedFunctionReturnStatus) { nOutParamsAssigned++; } @@ -394,7 +394,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { outParamIndex = outParamHandler.srv.getOrdinalOrLength(); if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && SQLServerConnection - .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != 2) { + .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != userDefinedFunctionReturnStatus) { outParamIndex++; } else { // Statements need to have their out param indices adjusted by the number diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 3559fc99f..84a5ae1a0 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -70,6 +70,8 @@ public class SQLServerStatement implements ISQLServerStatement { /** TDS token return value status **/ int returnValueStatus; + static int userDefinedFunctionReturnStatus = 2; + final boolean getIsResponseBufferingAdaptive() { return isResponseBufferingAdaptive; } @@ -1645,7 +1647,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { // in which case we need to stop parsing and let CallableStatement take over. // A RETVALUE token appearing in the execution results, but before any RETSTATUS // token, is a TEXTPTR return value that should be ignored. - if (moreResults && null == procedureRetStatToken && status != 2) { + if (moreResults && null == procedureRetStatToken && status != userDefinedFunctionReturnStatus) { Parameter p = new Parameter( Util.shouldHonorAEForParameters(stmtColumnEncriptionSetting, connection)); p.skipRetValStatus(tdsReader); 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 2873603cd..5a51a0bfb 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -63,8 +63,10 @@ public class CallableStatementTest extends AbstractTest { .escapeIdentifier(RandomUtil.getIdentifier("manyParam_definedType")); private static String zeroParamSproc = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("zeroParamSproc")); - private static String outOfOrderSproc= AbstractSQLGenerator + private static String outOfOrderSproc = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("outOfOrderSproc")); + private static String userDefinedFunction = AbstractSQLGenerator + .escapeIdentifier(RandomUtil.getIdentifier("userDefinedFunction")); /** * Setup before test @@ -84,6 +86,7 @@ public static void setupTest() throws Exception { TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); TestUtils.dropProcedureIfExists(outOfOrderSproc, stmt); + TestUtils.dropFunctionIfExists(userDefinedFunction, stmt); TestUtils.dropUserDefinedTypeIfExists(manyParamUserDefinedType, stmt); TestUtils.dropProcedureIfExists(manyParamProc, stmt); TestUtils.dropTableIfExists(manyParamsTable, stmt); @@ -99,6 +102,7 @@ public static void setupTest() throws Exception { createGetObjectOffsetDateTimeProcedure(stmt); createProcedureZeroParams(); createOutOfOrderSproc(); + createUserDefinedFunction(); } } @@ -376,7 +380,7 @@ public void testSprocCastingError() throws SQLException { try (CallableStatement cs = connection.prepareCall(call)) { cs.registerOutParameter(1, Types.BINARY); - cs.execute(); // Should not be able to get return value as binary + cs.execute(); // Should not be able to get return value as bytes cs.getBytes(1); fail(TestResource.getResource("R_expectedFailPassed")); } catch (Exception e) { @@ -422,6 +426,22 @@ public void testNonOrderedRegisteringAndSettingOfParams() throws SQLException { } } + @Test + public void testExecutingUserDefinedFunctionDirectly() throws SQLException { + String call ="{? = CALL " + userDefinedFunction + " (?,?,?,?,?,?)}"; + + try (CallableStatement cstmt = connection.prepareCall(call)) { + cstmt.setObject(2, "param"); + cstmt.setObject(3, "param"); + cstmt.setObject(4, "param"); + cstmt.setObject(5, "param"); + cstmt.setObject(6, "param"); + cstmt.setObject(7, "param"); + cstmt.registerOutParameter(1, Types.VARCHAR); + cstmt.execute(); + } + } + /** * Cleanup after test * @@ -439,6 +459,7 @@ public static void cleanup() throws SQLException { TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); TestUtils.dropProcedureIfExists(outOfOrderSproc, stmt); + TestUtils.dropFunctionIfExists(userDefinedFunction, stmt); } } @@ -527,4 +548,15 @@ private static void createOutOfOrderSproc() throws SQLException { stmt.execute(sql); } } + + private static void createUserDefinedFunction() throws SQLException { + String sql = "CREATE FUNCTION " + userDefinedFunction + + " (@p0 char(20), @p1 varchar(50), @p2 varchar(max), @p3 nchar(30), @p4 nvarchar(60), @p5 nvarchar(max)) " + + "RETURNS varchar(50) AS BEGIN " + + "DECLARE @ret varchar(50); " + + "SELECT @ret = 'foobar'; " + " RETURN @ret; end;"; + try (Statement stmt = connection.createStatement()) { + stmt.execute(sql); + } + } } From e4775351b715d078791521bc1b754f61760a6188 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 21:58:29 -0700 Subject: [PATCH 20/51] Skip return values from RPC on statement close if there are any --- pom.xml | 2 +- .../java/com/microsoft/sqlserver/jdbc/tdsparser.java | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index da7a6dc86..84f4ec4be 100644 --- a/pom.xml +++ b/pom.xml @@ -50,7 +50,7 @@ setup (excluded by default) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Default testing enabled with SQL Server 2019 (SQLv15) --> - xSQLv12,xSQLv15,NTLM,MSI,reqExternalSetup,clientCertAuth,fedAuth,kerberos + xSQLv12,xSQLv15,NTLM,MSI,reqExternalSetup,clientCertAuth,fedAuth,kerberos,DTC -preview diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java index a26133f69..df50180b6 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java @@ -232,6 +232,17 @@ boolean onRetStatus(TDSReader tdsReader) throws SQLServerException { } boolean onRetValue(TDSReader tdsReader) throws SQLServerException { + // Very unlikely to return true. If we do, it was because any return values in the + // tds response were never read after the RPC. If they were never read, it's safe to skip + // them here + if (this.logContext.equals("ExecDoneHandler")) { + Parameter param = new Parameter(false); + param.skipRetValStatus(tdsReader); + param.skipValue(tdsReader, true); + + return true; + } + TDSParser.throwUnexpectedTokenException(tdsReader, logContext); return false; } From b4e40307809b313377e9aeb45e834bf0cb43423f Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 22:22:33 -0700 Subject: [PATCH 21/51] Test mix of index a param names for cstmt --- .../CallableStatementTest.java | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) 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 5a51a0bfb..79ac4509e 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -65,6 +65,8 @@ public class CallableStatementTest extends AbstractTest { .escapeIdentifier(RandomUtil.getIdentifier("zeroParamSproc")); private static String outOfOrderSproc = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("outOfOrderSproc")); + private static String byParamNameSproc= AbstractSQLGenerator + .escapeIdentifier(RandomUtil.getIdentifier("byParamNameSproc")); private static String userDefinedFunction = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("userDefinedFunction")); @@ -86,6 +88,7 @@ public static void setupTest() throws Exception { TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); TestUtils.dropProcedureIfExists(outOfOrderSproc, stmt); + TestUtils.dropProcedureIfExists(byParamNameSproc, stmt); TestUtils.dropFunctionIfExists(userDefinedFunction, stmt); TestUtils.dropUserDefinedTypeIfExists(manyParamUserDefinedType, stmt); TestUtils.dropProcedureIfExists(manyParamProc, stmt); @@ -102,6 +105,7 @@ public static void setupTest() throws Exception { createGetObjectOffsetDateTimeProcedure(stmt); createProcedureZeroParams(); createOutOfOrderSproc(); + createByParamNameSproc(); createUserDefinedFunction(); } } @@ -439,6 +443,41 @@ public void testExecutingUserDefinedFunctionDirectly() throws SQLException { cstmt.setObject(7, "param"); cstmt.registerOutParameter(1, Types.VARCHAR); cstmt.execute(); + assertEquals("foobar", cstmt.getString(1)); + + // Re-execute again to test skipping of unread return values on statement close. + // If it fails, TDS errors will be thrown. + cstmt.execute(); + } + } + + @Test + public void testRegisteringOutputByIndexandAcquiringOutputParamByName() throws SQLException { + String call ="{CALL " + byParamNameSproc + " (?,?)}"; + + // Param names are p1 and p2 + try (CallableStatement cstmt = connection.prepareCall(call)) { + cstmt.setString(1, "foobar"); + cstmt.registerOutParameter(2, Types.NVARCHAR); + cstmt.execute(); + + assertEquals("foobar", cstmt.getString("p2")); + } + + try (CallableStatement cstmt = connection.prepareCall(call)) { + cstmt.setString("p1", "foobar"); + cstmt.registerOutParameter("p2", Types.NVARCHAR); + cstmt.execute(); + + assertEquals("foobar", cstmt.getString("p2")); + } + + try (CallableStatement cstmt = connection.prepareCall(call)) { + cstmt.setString("p1", "foobar"); + cstmt.registerOutParameter("p2", Types.NVARCHAR); + cstmt.execute(); + + assertEquals("foobar", cstmt.getString(2)); } } @@ -459,6 +498,7 @@ public static void cleanup() throws SQLException { TestUtils.dropProcedureIfExists(getObjectOffsetDateTimeProcedureName, stmt); TestUtils.dropProcedureIfExists(zeroParamSproc, stmt); TestUtils.dropProcedureIfExists(outOfOrderSproc, stmt); + TestUtils.dropProcedureIfExists(byParamNameSproc, stmt); TestUtils.dropFunctionIfExists(userDefinedFunction, stmt); } } @@ -549,6 +589,14 @@ private static void createOutOfOrderSproc() throws SQLException { } } + private static void createByParamNameSproc() throws SQLException { + String sql = "CREATE PROCEDURE " + byParamNameSproc + + " (@p1 nvarchar(30), @p2 nvarchar(30) output) AS BEGIN SELECT @p2 = @p1 END;"; + try (Statement stmt = connection.createStatement()) { + stmt.execute(sql); + } + } + private static void createUserDefinedFunction() throws SQLException { String sql = "CREATE FUNCTION " + userDefinedFunction + " (@p0 char(20), @p1 varchar(50), @p2 varchar(max), @p3 nchar(30), @p4 nvarchar(60), @p5 nvarchar(max)) " From 9646312247819b156f5450438113c32b227fdae1 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 23:01:27 -0700 Subject: [PATCH 22/51] Removed static callRpcDirectly variable --- .../com/microsoft/sqlserver/jdbc/Parameter.java | 4 ++-- .../sqlserver/jdbc/SQLServerPreparedStatement.java | 14 +++++--------- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index 37f9a4dd0..f2bc19f5f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -1240,7 +1240,7 @@ String getTypeDefinition(SQLServerConnection con, TDSReader tdsReader) throws SQ return typeDefinition; } - void sendByRPC(TDSWriter tdsWriter, SQLServerStatement statement) throws SQLServerException { + void sendByRPC(TDSWriter tdsWriter, boolean callRPCDirectly, SQLServerStatement statement) throws SQLServerException { assert null != inputDTV : "Parameter was neither set nor registered"; SQLServerConnection conn = statement.connection; @@ -1248,7 +1248,7 @@ void sendByRPC(TDSWriter tdsWriter, SQLServerStatement statement) throws SQLServ inputDTV.isNonPLP = isNonPLP; inputDTV.sendCryptoMetaData(this.cryptoMeta, tdsWriter); inputDTV.setJdbcTypeSetByUser(getJdbcTypeSetByUser(), getValueLength()); - inputDTV.sendByRPC(SQLServerPreparedStatement.callRpcDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, + inputDTV.sendByRPC(callRPCDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, isOutput(), tdsWriter, statement); } finally { // reset the cryptoMeta in IOBuffer diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index 104ea8f3c..0eba873d5 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -101,10 +101,6 @@ public class SQLServerPreparedStatement extends SQLServerStatement implements IS /** Check if statement contains TVP Type */ static boolean isTVPType = false; - static boolean validRPC = false; - - static boolean callRpcDirectly = false; - /** user FMTOnly flag */ private boolean useFmtOnly = this.connection.getUseFmtOnly(); @@ -757,7 +753,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { /** * Sends the statement parameters by RPC. */ - void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnValueSyntax) throws SQLServerException { + void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnValueSyntax, boolean callRpcDirectly) throws SQLServerException { char[] cParamName; int index = 0; if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType @@ -773,7 +769,7 @@ void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnVal tdsWriter.writeByte((byte) paramNameLen); tdsWriter.writeString(new String(cParamName, 0, paramNameLen)); } - params[index].sendByRPC(tdsWriter, this); + params[index].sendByRPC(tdsWriter, callRpcDirectly, this); } } @@ -1154,7 +1150,7 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN boolean needsPrepare = (hasNewTypeDefinitions && hasExistingTypeDefinitions) || !hasPreparedStatementHandle(); boolean isPrepareMethodSpPrepExec = connection.getPrepareMethod().equals(PrepareMethod.PREPEXEC.toString()); - callRpcDirectly = callRPCDirectly(params, bReturnValueSyntax); + boolean callRpcDirectly = callRPCDirectly(params, bReturnValueSyntax); // Cursors don't use statement pooling. if (isCursorable(executeMethod)) { @@ -1195,7 +1191,7 @@ else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCal } } - sendParamsByRPC(tdsWriter, params, bReturnValueSyntax); + sendParamsByRPC(tdsWriter, params, bReturnValueSyntax, callRpcDirectly); return needsPrepare; } @@ -3061,7 +3057,7 @@ final void doExecutePreparedStatementBatch(PrepStmtBatchExecCmd batchCommand) th resetForReexecute(); tdsWriter = batchCommand.startRequest(TDS.PKT_RPC); buildExecParams(tdsWriter); - sendParamsByRPC(tdsWriter, batchParam, bReturnValueSyntax); + sendParamsByRPC(tdsWriter, batchParam, bReturnValueSyntax, false); ensureExecuteResultsReader( batchCommand.startResponse(getIsResponseBufferingAdaptive())); startResults(); From f0d832c1f810c774fc08d7f1afa11ea48d47dbf1 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 23:14:52 -0700 Subject: [PATCH 23/51] Test cleanup --- .../microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java index 22ac9f767..99ca8dad9 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java @@ -377,6 +377,8 @@ public void testSetup() throws TestAbortedException, Exception { try (Connection connection = PrepUtil.getConnection(connectionString + ";sendTimeAsDatetime=false"); Statement stmt = (SQLServerStatement) connection.createStatement()) { TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(tableName), stmt); + TestUtils.dropTableIfExists(AbstractSQLGenerator.escapeIdentifier(datetimeTable), stmt); + TestUtils.dropProcedureIfExists(AbstractSQLGenerator.escapeIdentifier(datetimeSproc), stmt); String sql1 = "create table " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (id integer not null, my_date date, my_time time, my_timestamp datetime2 constraint " + AbstractSQLGenerator.escapeIdentifier(primaryKeyConstraintName) + " primary key (id))"; From 82c26c7a18422ce149d175956769a55376f6e685 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 1 Nov 2023 23:49:07 -0700 Subject: [PATCH 24/51] Fixed invalid param test --- .../sqlserver/jdbc/SQLServerCallableStatement.java | 5 +++-- .../jdbc/callablestatement/CallableStatementTest.java | 9 +++------ 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index fd00738ab..fd3b9e8ac 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -1494,8 +1494,9 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me // 1. Search using case-sensitive non-locale specific (binary) compare first. // 2. Search using case-insensitive, non-locale specific (binary) compare last. - int matchPos = (parameterNames != null) ? parameterNames.get(columnNameWithSign) : -1; - if (matchPos == -1) { + int matchPos = (parameterNames != null && parameterNames.containsKey(columnNameWithSign)) ? + parameterNames.get(columnNameWithSign) : -1; + if (matchPos == -1 && insensitiveParameterNames.containsKey(columnNameWithSign)) { matchPos = insensitiveParameterNames.get(columnNameWithSign); } 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 79ac4509e..6c69c6a94 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -352,14 +352,11 @@ public void inputParamsTest() throws SQLException { // sanity check: unrecognized parameter name try (CallableStatement cs = connection.prepareCall(call)) { - cs.setString("p2", "world"); - cs.setString("@invalidParamName", "hello"); - cs.execute(); + cs.setString("@whatever", "test"); fail(TestResource.getResource("R_shouldThrowException")); } catch (SQLException sse) { - MessageFormat form = new MessageFormat(TestResource.getResource("R_notValidParameterForProcedure")); - Object[] msgArgs = {"@invalidParamName", inputParamsProcedureName - .replace("[", "").replace("]", "")}; + MessageFormat form = new MessageFormat(TestResource.getResource("R_parameterNotDefined")); + Object[] msgArgs = {"@whatever"}; if (!sse.getMessage().startsWith(form.format(msgArgs))) { fail(TestResource.getResource("R_unexpectedExceptionContent")); From 5b62c1f67bac7e9681ab73e15f2587d74819bd71 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Thu, 2 Nov 2023 10:20:58 -0700 Subject: [PATCH 25/51] Fixed test for JDK 8 --- .../jdbc/callablestatement/CallableStatementTest.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) 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 6c69c6a94..afdae55a5 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -1,5 +1,6 @@ package com.microsoft.sqlserver.jdbc.callablestatement; +import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.fail; @@ -385,7 +386,8 @@ public void testSprocCastingError() throws SQLException { cs.getBytes(1); fail(TestResource.getResource("R_expectedFailPassed")); } catch (Exception e) { - assertEquals(TestResource.getResource("R_outputParamCastError"), e.getMessage()); + assertTrue(e.getMessage().equals(TestResource.getResource("R_outputParamCastError")) || + e.getMessage().contains("cannot be cast to")); } } From 12dd981f67cf9a93aebd5813345a32e9c2e73f0d Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Sun, 5 Nov 2023 20:53:28 -0800 Subject: [PATCH 26/51] Formatting; Removed comma counting --- .../microsoft/sqlserver/jdbc/IOBuffer.java | 8 +- .../microsoft/sqlserver/jdbc/Parameter.java | 7 +- .../jdbc/SQLServerCallableStatement.java | 255 +++++++++++------- .../sqlserver/jdbc/SQLServerConnection.java | 38 +-- .../jdbc/SQLServerPreparedStatement.java | 26 +- .../com/microsoft/sqlserver/jdbc/dtv.java | 6 +- .../sqlserver/jdbc/TestResource.java | 9 +- .../CallableStatementTest.java | 30 +-- .../jdbc/datatypes/DateAndTimeTypeTest.java | 49 ++-- .../jdbc/unit/statement/StatementTest.java | 3 +- 10 files changed, 236 insertions(+), 195 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java index ba3b3c470..8778c9609 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java @@ -4806,8 +4806,8 @@ void writeRPCStringUnicode(String sValue) throws SQLServerException { * @param collation * the collation of the data value */ - void writeRPCStringUnicode(String sName, String sValue, boolean bOut, - SQLCollation collation, boolean isNonPLP) throws SQLServerException { + void writeRPCStringUnicode(String sName, String sValue, boolean bOut, SQLCollation collation, + boolean isNonPLP) throws SQLServerException { boolean bValueNull = (sValue == null); int nValueLen = bValueNull ? 0 : (2 * sValue.length()); // Textual RPC requires a collation. If none is provided, as is the case when @@ -5564,8 +5564,8 @@ void writeCryptoMetaData() throws SQLServerException { writeByte(cryptoMeta.normalizationRuleVersion); } - void writeRPCByteArray(String sName, byte[] bValue, boolean bOut, JDBCType jdbcType, - SQLCollation collation, boolean isNonPLP) throws SQLServerException { + void writeRPCByteArray(String sName, byte[] bValue, boolean bOut, JDBCType jdbcType, SQLCollation collation, + boolean isNonPLP) throws SQLServerException { boolean bValueNull = (bValue == null); int nValueLen = bValueNull ? 0 : bValue.length; boolean isShortValue = (nValueLen <= DataTypes.SHORT_VARTYPE_MAX_BYTES); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java index f2bc19f5f..72c0e3a97 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java @@ -1240,7 +1240,8 @@ String getTypeDefinition(SQLServerConnection con, TDSReader tdsReader) throws SQ return typeDefinition; } - void sendByRPC(TDSWriter tdsWriter, boolean callRPCDirectly, SQLServerStatement statement) throws SQLServerException { + void sendByRPC(TDSWriter tdsWriter, boolean callRPCDirectly, + SQLServerStatement statement) throws SQLServerException { assert null != inputDTV : "Parameter was neither set nor registered"; SQLServerConnection conn = statement.connection; @@ -1248,8 +1249,8 @@ void sendByRPC(TDSWriter tdsWriter, boolean callRPCDirectly, SQLServerStatement inputDTV.isNonPLP = isNonPLP; inputDTV.sendCryptoMetaData(this.cryptoMeta, tdsWriter); inputDTV.setJdbcTypeSetByUser(getJdbcTypeSetByUser(), getValueLength()); - inputDTV.sendByRPC(callRPCDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, isOutput() ? outScale : scale, - isOutput(), tdsWriter, statement); + inputDTV.sendByRPC(callRPCDirectly ? name : null, null, conn.getDatabaseCollation(), valueLength, + isOutput() ? outScale : scale, isOutput(), tdsWriter, statement); } finally { // reset the cryptoMeta in IOBuffer inputDTV.sendCryptoMetaData(null, tdsWriter); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index fd3b9e8ac..9176d55a9 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -189,15 +189,15 @@ private Parameter getOutParameter(int i) throws SQLServerException { // the stored procedure for cursorable ones differently ( calling sp_cursorexecute r sp_cursorprepexec. if (bReturnValueSyntax && inOutParam[i - 1].isValueGotten() && inOutParam[i - 1].isReturnValue() && !returnValueIsAccessed && !isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, - bReturnValueSyntax)) { + && callRPCDirectly(inOutParam)) { nOutParamsAssigned++; returnValueIsAccessed = true; } return inOutParam[i - 1]; } - if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && returnValueStatus != userDefinedFunctionReturnStatus) { + if (inOutParam[i - 1].isReturnValue() && bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType + && returnValueStatus != userDefinedFunctionReturnStatus) { return inOutParam[i - 1]; } @@ -346,7 +346,7 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { OutParamHandler outParamHandler = new OutParamHandler(); if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod) && !isTVPType - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != userDefinedFunctionReturnStatus) { + && callRPCDirectly(inOutParam) && returnValueStatus != userDefinedFunctionReturnStatus) { nOutParamsAssigned++; } @@ -380,7 +380,8 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { // If we were asked to retain the OUT parameters as we skip past them, // then report an error if we did not find any. - MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_valueNotSetForParameter")); + MessageFormat form = new MessageFormat( + SQLServerException.getErrString("R_valueNotSetForParameter")); Object[] msgArgs = {outParamIndex + 1}; SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), null, false); } @@ -393,8 +394,8 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { // considered to be an output parameter. outParamIndex = outParamHandler.srv.getOrdinalOrLength(); - if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && SQLServerConnection - .isCallRemoteProcDirectValid(userSQL, inOutParam.length, bReturnValueSyntax) && returnValueStatus != userDefinedFunctionReturnStatus) { + if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && callRPCDirectly(inOutParam) + && returnValueStatus != userDefinedFunctionReturnStatus) { outParamIndex++; } else { // Statements need to have their out param indices adjusted by the number @@ -402,7 +403,8 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { outParamIndex -= outParamIndexAdjustment; } - if ((outParamIndex < 0 || outParamIndex >= inOutParam.length) || (!inOutParam[outParamIndex].isOutput())) { + if ((outParamIndex < 0 || outParamIndex >= inOutParam.length) + || (!inOutParam[outParamIndex].isOutput())) { if (getStatementLogger().isLoggable(java.util.logging.Level.INFO)) { getStatementLogger().info(toString() + " Unexpected outParamIndex: " + outParamIndex + "; adjustment: " + outParamIndexAdjustment); @@ -700,7 +702,8 @@ public Date getDate(int index) throws SQLServerException { public Date getDate(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDate", parameterName); checkClosed(); - java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); + java.sql.Date value = (java.sql.Date) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -1394,7 +1397,6 @@ private String stripLeadingAtSign(String columnName) { return (columnName.startsWith("@") ? columnName.substring(1, columnName.length()) : columnName); } - /* JDBC 3.0 */ /** * Find a column's index given its name. @@ -1476,7 +1478,6 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me } } - // If the server didn't return anything (eg. the param names for the sp_sproc_columns), user might not // have required permissions to view all the parameterNames. And, there's also the case depending on the permissions, // @RETURN_VALUE may or may not be present. So, the parameterNames list might have an additional +1 parameter. @@ -1494,8 +1495,8 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me // 1. Search using case-sensitive non-locale specific (binary) compare first. // 2. Search using case-insensitive, non-locale specific (binary) compare last. - int matchPos = (parameterNames != null && parameterNames.containsKey(columnNameWithSign)) ? - parameterNames.get(columnNameWithSign) : -1; + int matchPos = (parameterNames != null && parameterNames.containsKey(columnNameWithSign)) ? parameterNames + .get(columnNameWithSign) : -1; if (matchPos == -1 && insensitiveParameterNames.containsKey(columnNameWithSign)) { matchPos = insensitiveParameterNames.get(columnNameWithSign); } @@ -1682,8 +1683,8 @@ public final void setNClob(String parameterName, Reader value) throws SQLExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, value, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1702,7 +1703,8 @@ public final void setNString(String parameterName, String value) throws SQLExcep if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, value, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, + value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1712,7 +1714,8 @@ public final void setNString(String parameterName, String value, boolean forceEn loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, + value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1732,12 +1735,15 @@ public void setObject(String parameterName, Object value, int sqlType) throws SQ loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType}); checkClosed(); if (microsoft.sql.Types.STRUCTURED == sqlType) { - tvpName = getTVPNameFromObject(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.TVP, JDBCType.TVP, null, null, false, + tvpName = getTVPNameFromObject( + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), + value, JavaType.TVP, JDBCType.TVP, null, null, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); } else - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(sqlType), null, - null, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), + value, JavaType.of(value), JDBCType.of(sqlType), null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1747,8 +1753,9 @@ public void setObject(String parameterName, Object value, int sqlType, int decim loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType, decimals}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(sqlType), decimals, - null, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + JavaType.of(value), JDBCType.of(sqlType), decimals, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1764,7 +1771,8 @@ public void setObject(String parameterName, Object value, int sqlType, int decim // this is the number of digits after the decimal point. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(sqlType), + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + JavaType.of(value), JDBCType.of(sqlType), (java.sql.Types.NUMERIC == sqlType || java.sql.Types.DECIMAL == sqlType) ? decimals : null, null, forceEncrypt, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); @@ -1784,7 +1792,8 @@ public final void setObject(String parameterName, Object value, int targetSqlTyp // InputStream and Reader, this is the length of the data in the stream or reader. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, JavaType.of(value), JDBCType.of(targetSqlType), + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + JavaType.of(value), JDBCType.of(targetSqlType), (java.sql.Types.NUMERIC == targetSqlType || java.sql.Types.DECIMAL == targetSqlType || InputStream.class.isInstance(value) || Reader.class.isInstance(value)) ? scale : null, precision, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); @@ -1797,8 +1806,8 @@ public final void setAsciiStream(String parameterName, InputStream value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, value, JavaType.INPUTSTREAM, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1808,7 +1817,8 @@ public final void setAsciiStream(String parameterName, InputStream value, int le loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1818,7 +1828,8 @@ public final void setAsciiStream(String parameterName, InputStream value, long l loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1827,8 +1838,8 @@ public final void setBinaryStream(String parameterName, InputStream value) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1838,7 +1849,8 @@ public final void setBinaryStream(String parameterName, InputStream value, int l loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1848,7 +1860,8 @@ public final void setBinaryStream(String parameterName, InputStream value, long loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1857,7 +1870,8 @@ public final void setBlob(String parameterName, Blob inputStream) throws SQLExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BLOB, inputStream, JavaType.BLOB, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BLOB, + inputStream, JavaType.BLOB, false); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1866,8 +1880,8 @@ public final void setBlob(String parameterName, InputStream value) throws SQLExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, value, JavaType.INPUTSTREAM, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1877,7 +1891,8 @@ public final void setBlob(String parameterName, InputStream inputStream, long le loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + inputStream, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1886,7 +1901,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1895,7 +1911,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1906,7 +1923,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1915,7 +1933,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + value, JavaType.DATETIMEOFFSET, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1925,8 +1944,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, - false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + value, JavaType.DATETIMEOFFSET, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1937,8 +1956,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, - forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + value, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1947,7 +1966,8 @@ public void setDate(String parameterName, java.sql.Date value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, JavaType.DATE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + JavaType.DATE, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1956,7 +1976,8 @@ public void setTime(String parameterName, java.sql.Time value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, JavaType.TIME, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1965,7 +1986,8 @@ public void setTime(String parameterName, java.sql.Time value, int scale) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, JavaType.TIME, null, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1976,7 +1998,8 @@ public void setTime(String parameterName, java.sql.Time value, int scale, loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, JavaType.TIME, null, scale, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1985,7 +2008,8 @@ public void setDateTime(String parameterName, java.sql.Timestamp value) throws S if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, + value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -1996,7 +2020,8 @@ public void setDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, + value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -2005,7 +2030,8 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value) thr if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, + value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -2016,7 +2042,8 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, + value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -2025,7 +2052,8 @@ public void setUniqueIdentifier(String parameterName, String guid) throws SQLSer if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, + JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -2035,7 +2063,8 @@ public void setUniqueIdentifier(String parameterName, String guid, boolean force loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, + JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -2044,7 +2073,8 @@ public void setBytes(String parameterName, byte[] value) throws SQLServerExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, JavaType.BYTEARRAY, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, + JavaType.BYTEARRAY, false); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2054,7 +2084,8 @@ public void setBytes(String parameterName, byte[] value, boolean forceEncrypt) t loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, JavaType.BYTEARRAY, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, + JavaType.BYTEARRAY, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2063,7 +2094,8 @@ public void setByte(String parameterName, byte value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, JavaType.BYTE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, + JavaType.BYTE, false); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2073,7 +2105,8 @@ public void setByte(String parameterName, byte value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, JavaType.BYTE, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, + JavaType.BYTE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2082,7 +2115,8 @@ public void setString(String parameterName, String value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, + JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2092,7 +2126,8 @@ public void setString(String parameterName, String value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, + JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2101,7 +2136,8 @@ public void setMoney(String parameterName, BigDecimal value) throws SQLServerExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, + JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2111,7 +2147,8 @@ public void setMoney(String parameterName, BigDecimal value, boolean forceEncryp loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, + JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2120,7 +2157,8 @@ public void setSmallMoney(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, + value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2130,7 +2168,8 @@ public void setSmallMoney(String parameterName, BigDecimal value, boolean forceE loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, + value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2139,7 +2178,8 @@ public void setBigDecimal(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2150,7 +2190,8 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + JavaType.BIGDECIMAL, precision, scale, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2161,8 +2202,8 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, - forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + JavaType.BIGDECIMAL, precision, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2171,7 +2212,8 @@ public void setDouble(String parameterName, double value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, JavaType.DOUBLE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, + JavaType.DOUBLE, false); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2181,7 +2223,8 @@ public void setDouble(String parameterName, double value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, JavaType.DOUBLE, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, + JavaType.DOUBLE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2190,7 +2233,8 @@ public void setFloat(String parameterName, float value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, JavaType.FLOAT, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, + JavaType.FLOAT, false); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2200,7 +2244,8 @@ public void setFloat(String parameterName, float value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, JavaType.FLOAT, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, + JavaType.FLOAT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2209,7 +2254,8 @@ public void setInt(String parameterName, int value) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, JavaType.INTEGER, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, + JavaType.INTEGER, false); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2218,7 +2264,8 @@ public void setInt(String parameterName, int value, boolean forceEncrypt) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, + JavaType.INTEGER, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2227,7 +2274,8 @@ public void setLong(String parameterName, long value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, JavaType.LONG, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, + JavaType.LONG, false); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2237,7 +2285,8 @@ public void setLong(String parameterName, long value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, JavaType.LONG, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, + JavaType.LONG, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2246,7 +2295,8 @@ public void setShort(String parameterName, short value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, value, JavaType.SHORT, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, + value, JavaType.SHORT, false); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2256,7 +2306,8 @@ public void setShort(String parameterName, short value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, value, JavaType.SHORT, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, + value, JavaType.SHORT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2265,7 +2316,8 @@ public void setBoolean(String parameterName, boolean value) throws SQLServerExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, JavaType.BOOLEAN, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, + JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2275,7 +2327,8 @@ public void setBoolean(String parameterName, boolean value, boolean forceEncrypt loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, JavaType.BOOLEAN, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, + JavaType.BOOLEAN, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2284,8 +2337,9 @@ public void setNull(String parameterName, int nType) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, - false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, + JavaType.OBJECT, JDBCType.of(nType), null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2294,8 +2348,9 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType, sTypeName}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, - false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sTypeName); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, + JavaType.OBJECT, JDBCType.of(nType), null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sTypeName); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2310,36 +2365,42 @@ public void setURL(String parameterName, URL url) throws SQLException { @Override public final void setStructured(String parameterName, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataTable}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + tvpDataTable, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ResultSet tvpResultSet) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpResultSet}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + tvpResultSet, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ISQLServerDataRecord tvpDataRecord) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataRecord}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, tvpDataRecord, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + tvpDataRecord, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @@ -2377,7 +2438,8 @@ public final SQLXML getSQLXML(int parameterIndex) throws SQLException { public final SQLXML getSQLXML(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getSQLXML", parameterName); checkClosed(); - SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); loggerExternal.exiting(getClassNameLogging(), "getSQLXML", value); return value; } @@ -2405,7 +2467,8 @@ public void registerOutParameter(String parameterName, int sqlType, String typeN loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, typeName}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, typeName); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + typeName); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2415,7 +2478,8 @@ public void registerOutParameter(String parameterName, int sqlType, int scale) t loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, scale); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2426,7 +2490,8 @@ public void registerOutParameter(String parameterName, int sqlType, int precisio loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, precision, scale); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + precision, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index 3e8aec97f..6972ad893 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -506,36 +506,6 @@ static ParsedSQLCacheItem parseAndCacheSQL(CityHash128Key key, String sql) throw return cacheItem; } - /** - * Checks if remote procedure call is a valid. Example: if exec procName 1,? we should not use RPC call directly, - * rather wrap it with sp_executesql call - * - */ - static boolean isCallRemoteProcDirectValid(String sql, int paramCount, boolean isReturnSyntax) { - int commaCount = SQLServerConnection.countCommas(sql); - if (isReturnSyntax) { - // If return syntax, sql text commas should be equal to paramCount - 2. - // Or, if return syntax and paramCount is 1, it's a no param sproc. - return (paramCount == commaCount + 2) || paramCount == 1; - } else { - // if not return syntax, sql text commas should be equal to paramCount - 1. - return paramCount == commaCount + 1; - } - } - - /** - * Count the number of commas in sql text - * - */ - static int countCommas(String sql) { - int nParams = 0; - int offset = -1; - while ((offset = ParameterUtils.scanSQLForChar(',', sql, ++offset)) < sql.length()) - ++nParams; - - return nParams; - } - static int countParams(String sql) { return locateParams(sql).length; } @@ -1463,7 +1433,8 @@ public static void clearUserTokenCache() { private AuthenticationScheme intAuthScheme = AuthenticationScheme.NATIVE_AUTHENTICATION; /** use default native GSS-API Credential flag */ - private boolean useDefaultGSSCredential = SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.getDefaultValue(); + private boolean useDefaultGSSCredential = SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL + .getDefaultValue(); /** impersonated user credential */ private transient GSSCredential impersonatedUserCred; @@ -2521,7 +2492,7 @@ Connection connectInternal(Properties propsIn, } sPropKey = SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.toString(); sPropValue = activeConnectionProperties.getProperty(sPropKey); - if(null != sPropValue && isWindows) { + if (null != sPropValue && isWindows) { useDefaultGSSCredential = isBooleanPropertyOn(sPropKey, sPropValue); } } else if (intAuthScheme == AuthenticationScheme.NTLM) { @@ -5143,7 +5114,8 @@ private void logon(LogonCommand command) throws SQLServerException { } else if (AuthenticationScheme.JAVA_KERBEROS == intAuthScheme) { if (null != impersonatedUserCred || useDefaultGSSCredential) { authentication = new KerbAuthentication(this, currentConnectPlaceHolder.getServerName(), - currentConnectPlaceHolder.getPortNumber(), impersonatedUserCred, isUserCreatedCredential, useDefaultGSSCredential); + currentConnectPlaceHolder.getPortNumber(), impersonatedUserCred, isUserCreatedCredential, + useDefaultGSSCredential); } else { authentication = new KerbAuthentication(this, currentConnectPlaceHolder.getServerName(), currentConnectPlaceHolder.getPortNumber()); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index 0eba873d5..659883757 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -435,13 +435,13 @@ private String buildParamTypeDefinitions(Parameter[] params, boolean renewDefini return ""; // Output looks like @P0 timestamp, @P1 varchar - int stringLen = nCols * 2; // @P - stringLen += nCols; // spaces - stringLen += nCols -1; // commas + int stringLen = nCols * 2; // @P + stringLen += nCols; // spaces + stringLen += nCols - 1; // commas if (nCols > 10) - stringLen += 10 + ((nCols - 10) * 2); // @P{0-99} Numbers after p + stringLen += 10 + ((nCols - 10) * 2); // @P{0-99} Numbers after p else - stringLen += nCols; // @P{0-9} Numbers after p less than 10 + stringLen += nCols; // @P{0-9} Numbers after p less than 10 // Computing the type definitions up front, so we can get exact string lengths needed for the string builder. String[] typeDefinitions = new String[nCols]; @@ -753,11 +753,11 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { /** * Sends the statement parameters by RPC. */ - void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnValueSyntax, boolean callRpcDirectly) throws SQLServerException { + void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params, boolean bReturnValueSyntax, + boolean callRpcDirectly) throws SQLServerException { char[] cParamName; int index = 0; - if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, params.length, bReturnValueSyntax)) { + if (bReturnValueSyntax && !isCursorable(executeMethod) && !isTVPType && callRpcDirectly) { returnParam = params[index]; params[index].setReturnValue(true); index++; @@ -1150,7 +1150,7 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN boolean needsPrepare = (hasNewTypeDefinitions && hasExistingTypeDefinitions) || !hasPreparedStatementHandle(); boolean isPrepareMethodSpPrepExec = connection.getPrepareMethod().equals(PrepareMethod.PREPEXEC.toString()); - boolean callRpcDirectly = callRPCDirectly(params, bReturnValueSyntax); + boolean callRpcDirectly = callRPCDirectly(params); // Cursors don't use statement pooling. if (isCursorable(executeMethod)) { @@ -1165,7 +1165,8 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN } // Move overhead of needing to do prepare & unprepare to only use cases that need more than one execution. // First execution, use sp_executesql, optimizing for assumption we will not re-use statement. - else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCall() && !isExecutedAtLeastOnce) { + else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCall() + && !isExecutedAtLeastOnce) { buildExecSQLParams(tdsWriter); isExecutedAtLeastOnce = true; } else if (needsPrepare) { // Second execution, use prepared statements since we seem to be re-using it. @@ -1203,10 +1204,9 @@ else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCal * @return * @throws SQLServerException */ - boolean callRPCDirectly(Parameter[] params, boolean isReturnSyntax) throws SQLServerException { + boolean callRPCDirectly(Parameter[] params) throws SQLServerException { int paramCount = SQLServerConnection.countParams(userSQL); - return (null != procedureName && paramCount != 0 && !isTVPType(params) - && SQLServerConnection.isCallRemoteProcDirectValid(userSQL, paramCount, isReturnSyntax)); + return (null != procedureName && paramCount != 0 && !isTVPType(params)); } /** diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java index ee7906dbc..3b3ce7b8f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java @@ -874,7 +874,8 @@ private void sendTemporal(DTV dtv, JavaType javaType, Object value) throws SQLSe tdsWriter.writeRPCDateTime2(name, timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), subSecondNanos, 3, isOutParam); - } else if (conn.getDatetimeParameterType().equals(DatetimeType.DATETIME.toString())) { + } else if (conn.getDatetimeParameterType() + .equals(DatetimeType.DATETIME.toString())) { tdsWriter.writeRPCDateTime(name, timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), subSecondNanos, isOutParam); @@ -1145,7 +1146,8 @@ void execute(DTV dtv, byte[] byteArrayValue) throws SQLServerException { } } else - tdsWriter.writeRPCByteArray(name, byteArrayValue, isOutParam, dtv.getJdbcType(), collation, dtv.isNonPLP); + tdsWriter.writeRPCByteArray(name, byteArrayValue, isOutParam, dtv.getJdbcType(), collation, + dtv.isNonPLP); } diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java index c9e07695a..8416127d1 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java @@ -43,7 +43,8 @@ protected Object[][] getContents() { {"R_lengthTruncated", " The inserted length is truncated or not correct!"}, {"R_timeValueTruncated", " The time value is truncated or not correct!"}, {"R_invalidErrorMessage", "Invalid Error Message: "}, - {"R_kerberosNativeGSSFailure", "No valid credentials provided (Mechanism level: Failed to find any Kerberos tgt)"}, + {"R_kerberosNativeGSSFailure", + "No valid credentials provided (Mechanism level: Failed to find any Kerberos tgt)"}, {"R_expectedFailPassed", "Expected failure did not fail"}, {"R_dataTypeNotFound", "Cannot find data type"}, {"R_illegalCharWktPosition", "Illegal character in Well-Known text at position {0}."}, {"R_illegalCharWkt", "Illegal Well-Known text. Please make sure Well-Known text is valid."}, @@ -77,7 +78,8 @@ protected Object[][] getContents() { {"R_supportUnwrapping", "{0} supports unwrapping."}, {"R_cantAccessSnapshot", "Cant access the TRANSACTION_SNAPSHOT "}, {"R_newConnectionShouldBeValid", "Newly created connection should be valid"}, - {"R_outputParamCastError", "class java.lang.Integer cannot be cast to class [B (java.lang.Integer and [B are in module java.base of loader 'bootstrap')"}, + {"R_outputParamCastError", + "class java.lang.Integer cannot be cast to class [B (java.lang.Integer and [B are in module java.base of loader 'bootstrap')"}, {"R_closedConnectionShouldBeInvalid", "Closed connection should be invalid"}, {"R_noExceptionNegativeTimeout", "No exception thrown with negative timeout"}, {"R_noExceptionClosedConnection", @@ -206,6 +208,7 @@ protected Object[][] getContents() { {"R_connectTimedOut", "connect timed out"}, {"R_sessionKilled", "Cannot continue the execution because the session is in the kill state"}, {"R_failedFedauth", "Failed to acquire fedauth token: "}, - {"R_noLoginModulesConfiguredForJdbcDriver", "javax.security.auth.login.LoginException (No LoginModules configured for SQLJDBCDriver)"}, + {"R_noLoginModulesConfiguredForJdbcDriver", + "javax.security.auth.login.LoginException (No LoginModules configured for SQLJDBCDriver)"}, {"R_unexpectedThreadCount", "Thread count is higher than expected."}}; } 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 afdae55a5..7fc36fedc 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -66,7 +66,7 @@ public class CallableStatementTest extends AbstractTest { .escapeIdentifier(RandomUtil.getIdentifier("zeroParamSproc")); private static String outOfOrderSproc = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("outOfOrderSproc")); - private static String byParamNameSproc= AbstractSQLGenerator + private static String byParamNameSproc = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("byParamNameSproc")); private static String userDefinedFunction = AbstractSQLGenerator .escapeIdentifier(RandomUtil.getIdentifier("userDefinedFunction")); @@ -386,14 +386,14 @@ public void testSprocCastingError() throws SQLException { cs.getBytes(1); fail(TestResource.getResource("R_expectedFailPassed")); } catch (Exception e) { - assertTrue(e.getMessage().equals(TestResource.getResource("R_outputParamCastError")) || - e.getMessage().contains("cannot be cast to")); + assertTrue(e.getMessage().equals(TestResource.getResource("R_outputParamCastError")) + || e.getMessage().contains("cannot be cast to")); } } @Test public void testNonOrderedRegisteringAndSettingOfParams() throws SQLException { - String call ="{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; try (CallableStatement cstmt = connection.prepareCall(call)) { int scale = 6; @@ -431,7 +431,7 @@ public void testNonOrderedRegisteringAndSettingOfParams() throws SQLException { @Test public void testExecutingUserDefinedFunctionDirectly() throws SQLException { - String call ="{? = CALL " + userDefinedFunction + " (?,?,?,?,?,?)}"; + String call = "{? = CALL " + userDefinedFunction + " (?,?,?,?,?,?)}"; try (CallableStatement cstmt = connection.prepareCall(call)) { cstmt.setObject(2, "param"); @@ -452,7 +452,7 @@ public void testExecutingUserDefinedFunctionDirectly() throws SQLException { @Test public void testRegisteringOutputByIndexandAcquiringOutputParamByName() throws SQLException { - String call ="{CALL " + byParamNameSproc + " (?,?)}"; + String call = "{CALL " + byParamNameSproc + " (?,?)}"; // Param names are p1 and p2 try (CallableStatement cstmt = connection.prepareCall(call)) { @@ -577,12 +577,11 @@ private static void createProcedureZeroParams() throws SQLException { private static void createOutOfOrderSproc() throws SQLException { String sql = "CREATE PROCEDURE " + outOfOrderSproc + " @i1 NUMERIC(16,10)," + " @i2 NUMERIC(16,6)," - + " @i3 INT," + " @i4 REAL," + " @i5 CHAR," + " @i6 VARCHAR(6)," + " @i7 CHAR," - + " @i8 SMALLINT, " + " @o1 NUMERIC(16,10) OUTPUT," + " @o2 NUMERIC(16,6) OUTPUT," - + " @o3 INT OUTPUT," + " @o4 REAL OUTPUT," + " @o5 CHAR OUTPUT," + " @o6 VARCHAR(6) OUTPUT," - + " @o7 CHAR OUTPUT," + " @o8 SMALLINT OUTPUT" + " as begin " + " set @o1=@i1;" - + " set @o2=@i2;" + " set @o3=@i3;" + " set @o4=@i4;" + " set @o5=@i5;" + " set @o6=@i6;" - + " set @o7=@i7;" + " set @o8=@i8;" + " end"; + + " @i3 INT," + " @i4 REAL," + " @i5 CHAR," + " @i6 VARCHAR(6)," + " @i7 CHAR," + " @i8 SMALLINT, " + + " @o1 NUMERIC(16,10) OUTPUT," + " @o2 NUMERIC(16,6) OUTPUT," + " @o3 INT OUTPUT," + + " @o4 REAL OUTPUT," + " @o5 CHAR OUTPUT," + " @o6 VARCHAR(6) OUTPUT," + " @o7 CHAR OUTPUT," + + " @o8 SMALLINT OUTPUT" + " as begin " + " set @o1=@i1;" + " set @o2=@i2;" + " set @o3=@i3;" + + " set @o4=@i4;" + " set @o5=@i5;" + " set @o6=@i6;" + " set @o7=@i7;" + " set @o8=@i8;" + " end"; try (Statement stmt = connection.createStatement()) { stmt.execute(sql); } @@ -597,11 +596,10 @@ private static void createByParamNameSproc() throws SQLException { } private static void createUserDefinedFunction() throws SQLException { - String sql = "CREATE FUNCTION " + userDefinedFunction + String sql = "CREATE FUNCTION " + userDefinedFunction + " (@p0 char(20), @p1 varchar(50), @p2 varchar(max), @p3 nchar(30), @p4 nvarchar(60), @p5 nvarchar(max)) " - + "RETURNS varchar(50) AS BEGIN " - + "DECLARE @ret varchar(50); " - + "SELECT @ret = 'foobar'; " + " RETURN @ret; end;"; + + "RETURNS varchar(50) AS BEGIN " + "DECLARE @ret varchar(50); " + "SELECT @ret = 'foobar'; " + + " RETURN @ret; end;"; try (Statement stmt = connection.createStatement()) { stmt.execute(sql); } diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java index 99ca8dad9..fc198bf1f 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java @@ -200,21 +200,21 @@ public static void setupTests() throws Exception { * Test to make sure that a Timestamp is treated as a datetime object. */ @Test - public void testSendTimestampAsDatetime() throws Exception { + public void testSendTimestampAsDatetime() throws Exception { String expected = "2010-02-01T23:59:59.997"; String actual = null; String query = "SELECT CONVERT(VARCHAR(40), ?, 126) as [value]"; - try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetime"); - PreparedStatement stmt = conn.prepareStatement(query)) { + try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetime"); + PreparedStatement stmt = conn.prepareStatement(query)) { Timestamp ts = Timestamp.valueOf("2010-02-01 23:59:59.996"); // if cast to a datetime, 996ms is rounded up to 997ms /* - * send the timestamp to the server using the TIME SQL type rather than TIMESTAMP. The driver will - * strip the date portion and, because sendTimeAsDatetime=true, round the resulting time value to - * midnight because it should be sending a DATETIME which has only 1/300s accuracy - */ + * send the timestamp to the server using the TIME SQL type rather than TIMESTAMP. The driver will + * strip the date portion and, because sendTimeAsDatetime=true, round the resulting time value to + * midnight because it should be sending a DATETIME which has only 1/300s accuracy + */ stmt.setObject(1, ts, java.sql.Types.TIMESTAMP); ResultSet rs = stmt.executeQuery(); @@ -231,21 +231,21 @@ public void testSendTimestampAsDatetime() throws Exception { * Test to make sure that a Timestamp is treated as a datetime2 object. */ @Test - public void testSendTimestampAsDatetime2() throws Exception { + public void testSendTimestampAsDatetime2() throws Exception { String expected = "2010-02-02T23:59:59.1234567"; String actual = null; String query = "SELECT CONVERT(VARCHAR(40), ?, 126) as [value]"; try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetime2"); - PreparedStatement stmt = conn.prepareStatement(query)) { + PreparedStatement stmt = conn.prepareStatement(query)) { Timestamp ts = Timestamp.valueOf("2010-02-02 23:59:59.1234567"); /* - * send the timestamp to the server using the TIME SQL type rather than TIMESTAMP. The driver will - * strip the date portion and, because sendTimeAsDatetime=true, round the resulting time value to - * midnight because it should be sending a DATETIME which has only 1/300s accuracy - */ + * send the timestamp to the server using the TIME SQL type rather than TIMESTAMP. The driver will + * strip the date portion and, because sendTimeAsDatetime=true, round the resulting time value to + * midnight because it should be sending a DATETIME which has only 1/300s accuracy + */ stmt.setObject(1, ts, java.sql.Types.TIMESTAMP); ResultSet rs = stmt.executeQuery(); @@ -262,22 +262,22 @@ public void testSendTimestampAsDatetime2() throws Exception { * Test to make sure that a Timestamp is treated as a datetime2 object. */ @Test - public void testSendTimestampAsDatetimeoffset() throws Exception { + public void testSendTimestampAsDatetimeoffset() throws Exception { String expected = "2010-02-03T23:59:59.7654321Z"; String actual = null; String query = "SELECT CONVERT(VARCHAR(40), ?, 127) as [value]"; - - try (SQLServerConnection conn = PrepUtil.getConnection(connectionString + ";datetimeParameterType=datetimeoffset"); - PreparedStatement stmt = conn.prepareStatement(query)) { + try (SQLServerConnection conn = PrepUtil + .getConnection(connectionString + ";datetimeParameterType=datetimeoffset"); + PreparedStatement stmt = conn.prepareStatement(query)) { Timestamp ts = Timestamp.valueOf("2010-02-03 23:59:59.7654321"); /* - * send the timestamp to the server using the TIME SQL type rather than TIMESTAMP. The driver will - * strip the date portion and, because sendTimeAsDatetime=true, round the resulting time value to - * midnight because it should be sending a DATETIME which has only 1/300s accuracy - */ + * send the timestamp to the server using the TIME SQL type rather than TIMESTAMP. The driver will + * strip the date portion and, because sendTimeAsDatetime=true, round the resulting time value to + * midnight because it should be sending a DATETIME which has only 1/300s accuracy + */ stmt.setObject(1, ts, java.sql.Types.TIMESTAMP); ResultSet rs = stmt.executeQuery(); @@ -343,7 +343,6 @@ public void testCstmtRegisterDatetimeOutParameterDateTimeParameterTypeDatetime2( assertEquals(expected, actual.toString()); } - @Test public void testCstmtRegisterTimestampOutParameter() throws Exception { String expected = "3160-08-17 19:09:06.9366667"; @@ -382,9 +381,11 @@ public void testSetup() throws TestAbortedException, Exception { String sql1 = "create table " + AbstractSQLGenerator.escapeIdentifier(tableName) + " (id integer not null, my_date date, my_time time, my_timestamp datetime2 constraint " + AbstractSQLGenerator.escapeIdentifier(primaryKeyConstraintName) + " primary key (id))"; - String sql2 = "create table " + AbstractSQLGenerator.escapeIdentifier(datetimeTable) + " (c1 datetime2 NULL)"; + String sql2 = "create table " + AbstractSQLGenerator.escapeIdentifier(datetimeTable) + + " (c1 datetime2 NULL)"; String sql3 = "create procedure " + AbstractSQLGenerator.escapeIdentifier(datetimeSproc) - + " (@p1 datetime2 output) as select top 1 @p1=c1 from " + AbstractSQLGenerator.escapeIdentifier(datetimeTable); + + " (@p1 datetime2 output) as select top 1 @p1=c1 from " + + AbstractSQLGenerator.escapeIdentifier(datetimeTable); stmt.execute(sql1); stmt.execute(sql2); stmt.execute(sql3); diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java index 1ac75b404..a31b13fdf 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/StatementTest.java @@ -1452,8 +1452,7 @@ public void testRetrievingRegisteredOutParamWhenResultSetDoesNotExists() throws try { cstmt.getString(2); fail(TestResource.getResource("R_expectedExceptionNotThrown")); - } catch (Exception e) { - } + } catch (Exception e) {} } } } From 2b35e53905f76be9d69cfe2543947434f8943be0 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Sun, 5 Nov 2023 21:02:58 -0800 Subject: [PATCH 27/51] Removed getter/setter enum --- .../jdbc/SQLServerCallableStatement.java | 412 +++++++----------- 1 file changed, 147 insertions(+), 265 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 9176d55a9..35efe566d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -78,16 +78,6 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple /** atomic integer */ AtomicInteger ai = new AtomicInteger(0); - /** - * Enum to check if the callablestatement is a setter or getter method. This enum is used in method findColumn where - * we get the parameter/column by name - * - */ - enum CallableStatementGetterSetterMethod { - isSetterMethod, - isGetterMethod - } - /** * Create a new callable statement. * @@ -545,8 +535,7 @@ public int getInt(int index) throws SQLServerException { public int getInt(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getInt", parameterName); checkClosed(); - Integer value = (Integer) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.INTEGER); + Integer value = (Integer) getValue(findColumn(parameterName), JDBCType.INTEGER); loggerExternal.exiting(getClassNameLogging(), "getInt", value); return null != value ? value : 0; } @@ -569,8 +558,7 @@ public String getString(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getString", parameterName); checkClosed(); String value = null; - Object objectValue = getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.CHAR); + Object objectValue = getValue(findColumn(parameterName), JDBCType.CHAR); if (null != objectValue) { value = objectValue.toString(); } @@ -591,8 +579,7 @@ public final String getNString(int parameterIndex) throws SQLException { public final String getNString(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNString", parameterName); checkClosed(); - String value = (String) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.NCHAR); + String value = (String) getValue(findColumn(parameterName), JDBCType.NCHAR); loggerExternal.exiting(getClassNameLogging(), "getNString", value); return value; } @@ -622,8 +609,7 @@ public BigDecimal getBigDecimal(String parameterName, int scale) throws SQLServe if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterName, scale}); checkClosed(); - BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); + BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.DECIMAL); if (null != value) value = value.setScale(scale, BigDecimal.ROUND_DOWN); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); @@ -643,8 +629,7 @@ public boolean getBoolean(int index) throws SQLServerException { public boolean getBoolean(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBoolean", parameterName); checkClosed(); - Boolean value = (Boolean) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.BIT); + Boolean value = (Boolean) getValue(findColumn(parameterName), JDBCType.BIT); loggerExternal.exiting(getClassNameLogging(), "getBoolean", value); return null != value ? value : false; } @@ -663,8 +648,7 @@ public byte getByte(int index) throws SQLServerException { public byte getByte(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getByte", parameterName); checkClosed(); - Short shortValue = (Short) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TINYINT); + Short shortValue = (Short) getValue(findColumn(parameterName), JDBCType.TINYINT); byte byteValue = (null != shortValue) ? shortValue.byteValue() : 0; loggerExternal.exiting(getClassNameLogging(), "getByte", byteValue); return byteValue; @@ -683,8 +667,7 @@ public byte[] getBytes(int index) throws SQLServerException { public byte[] getBytes(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBytes", parameterName); checkClosed(); - byte[] value = (byte[]) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.BINARY); + byte[] value = (byte[]) getValue(findColumn(parameterName), JDBCType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBytes", value); return value; } @@ -702,8 +685,7 @@ public Date getDate(int index) throws SQLServerException { public Date getDate(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDate", parameterName); checkClosed(); - java.sql.Date value = (java.sql.Date) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); + java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -723,8 +705,7 @@ public Date getDate(String parameterName, Calendar cal) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Date value = (java.sql.Date) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); + java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -742,8 +723,7 @@ public double getDouble(int index) throws SQLServerException { public double getDouble(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDouble", parameterName); checkClosed(); - Double value = (Double) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.DOUBLE); + Double value = (Double) getValue(findColumn(parameterName), JDBCType.DOUBLE); loggerExternal.exiting(getClassNameLogging(), "getDouble", value); return null != value ? value : 0; } @@ -761,8 +741,7 @@ public float getFloat(int index) throws SQLServerException { public float getFloat(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getFloat", parameterName); checkClosed(); - Float value = (Float) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.REAL); + Float value = (Float) getValue(findColumn(parameterName), JDBCType.REAL); loggerExternal.exiting(getClassNameLogging(), "getFloat", value); return null != value ? value : 0; } @@ -781,8 +760,7 @@ public long getLong(int index) throws SQLServerException { public long getLong(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getLong", parameterName); checkClosed(); - Long value = (Long) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.BIGINT); + Long value = (Long) getValue(findColumn(parameterName), JDBCType.BIGINT); loggerExternal.exiting(getClassNameLogging(), "getLong", value); return null != value ? value : 0; } @@ -895,7 +873,7 @@ public T getObject(int index, Class type) throws SQLException { public Object getObject(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); + int parameterIndex = findColumn(parameterName); Object value = getValue(parameterIndex, null != getterGetParam(parameterIndex).getJdbcTypeSetByUser() ? getterGetParam(parameterIndex) .getJdbcTypeSetByUser() : getterGetParam(parameterIndex).getJdbcType()); @@ -907,7 +885,7 @@ public Object getObject(String parameterName) throws SQLServerException { public T getObject(String parameterName, Class type) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); + int parameterIndex = findColumn(parameterName); T value = getObject(parameterIndex, type); loggerExternal.exiting(getClassNameLogging(), "getObject", value); return value; @@ -926,8 +904,7 @@ public short getShort(int index) throws SQLServerException { public short getShort(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getShort", parameterName); checkClosed(); - Short value = (Short) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.SMALLINT); + Short value = (Short) getValue(findColumn(parameterName), JDBCType.SMALLINT); loggerExternal.exiting(getClassNameLogging(), "getShort", value); return null != value ? value : 0; } @@ -946,8 +923,7 @@ public Time getTime(int index) throws SQLServerException { public Time getTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getTime", parameterName); checkClosed(); - java.sql.Time value = (java.sql.Time) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME); + java.sql.Time value = (java.sql.Time) getValue(findColumn(parameterName), JDBCType.TIME); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -967,8 +943,7 @@ public Time getTime(String parameterName, Calendar cal) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Time value = (java.sql.Time) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME, cal); + java.sql.Time value = (java.sql.Time) getValue(findColumn(parameterName), JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -987,8 +962,7 @@ public Timestamp getTimestamp(int index) throws SQLServerException { public Timestamp getTimestamp(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP); + java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.TIMESTAMP); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -1008,8 +982,7 @@ public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP, cal); + java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -1036,8 +1009,7 @@ public Timestamp getDateTime(int index) throws SQLServerException { public Timestamp getDateTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDateTime", parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME); + java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.DATETIME); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -1057,8 +1029,7 @@ public Timestamp getDateTime(String parameterName, Calendar cal) throws SQLServe if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME, cal); + java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.DATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -1077,8 +1048,7 @@ public Timestamp getSmallDateTime(int index) throws SQLServerException { public Timestamp getSmallDateTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME); + java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.SMALLDATETIME); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; } @@ -1098,8 +1068,7 @@ public Timestamp getSmallDateTime(String parameterName, Calendar cal) throws SQL if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME, + java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.SMALLDATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; @@ -1131,8 +1100,8 @@ public microsoft.sql.DateTimeOffset getDateTimeOffset(String parameterName) thro throw new SQLServerException(SQLServerException.getErrString("R_notSupported"), SQLState.DATA_EXCEPTION_NOT_SPECIFIC, DriverError.NOT_SET, null); - microsoft.sql.DateTimeOffset value = (microsoft.sql.DateTimeOffset) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIMEOFFSET); + microsoft.sql.DateTimeOffset value = (microsoft.sql.DateTimeOffset) getValue(findColumn(parameterName), + JDBCType.DATETIMEOFFSET); loggerExternal.exiting(getClassNameLogging(), "getDateTimeOffset", value); return value; } @@ -1162,8 +1131,7 @@ public final java.io.InputStream getAsciiStream(int parameterIndex) throws SQLSe public final java.io.InputStream getAsciiStream(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getAsciiStream", parameterName); checkClosed(); - InputStream value = (InputStream) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.ASCII); + InputStream value = (InputStream) getStream(findColumn(parameterName), StreamType.ASCII); loggerExternal.exiting(getClassNameLogging(), "getAsciiStream", value); return value; } @@ -1181,8 +1149,7 @@ public BigDecimal getBigDecimal(int parameterIndex) throws SQLServerException { public BigDecimal getBigDecimal(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBigDecimal", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); + BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.DECIMAL); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); return value; } @@ -1200,8 +1167,7 @@ public BigDecimal getMoney(int parameterIndex) throws SQLServerException { public BigDecimal getMoney(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getMoney", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.MONEY); + BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.MONEY); loggerExternal.exiting(getClassNameLogging(), "getMoney", value); return value; } @@ -1219,8 +1185,7 @@ public BigDecimal getSmallMoney(int parameterIndex) throws SQLServerException { public BigDecimal getSmallMoney(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getSmallMoney", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLMONEY); + BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.SMALLMONEY); loggerExternal.exiting(getClassNameLogging(), "getSmallMoney", value); return value; } @@ -1238,8 +1203,7 @@ public final java.io.InputStream getBinaryStream(int parameterIndex) throws SQLS public final java.io.InputStream getBinaryStream(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBinaryStream", parameterName); checkClosed(); - InputStream value = (InputStream) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.BINARY); + InputStream value = (InputStream) getStream(findColumn(parameterName), StreamType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBinaryStream", value); return value; } @@ -1257,8 +1221,7 @@ public Blob getBlob(int parameterIndex) throws SQLServerException { public Blob getBlob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBlob", parameterName); checkClosed(); - Blob value = (Blob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.BLOB); + Blob value = (Blob) getValue(findColumn(parameterName), JDBCType.BLOB); loggerExternal.exiting(getClassNameLogging(), "getBlob", value); return value; } @@ -1276,8 +1239,7 @@ public final java.io.Reader getCharacterStream(int parameterIndex) throws SQLSer public final java.io.Reader getCharacterStream(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getCharacterStream", parameterName); checkClosed(); - Reader reader = (Reader) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.CHARACTER); + Reader reader = (Reader) getStream(findColumn(parameterName), StreamType.CHARACTER); loggerExternal.exiting(getClassNameLogging(), "getCharacterSream", reader); return reader; } @@ -1295,8 +1257,7 @@ public final java.io.Reader getNCharacterStream(int parameterIndex) throws SQLEx public final java.io.Reader getNCharacterStream(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNCharacterStream", parameterName); checkClosed(); - Reader reader = (Reader) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.NCHARACTER); + Reader reader = (Reader) getStream(findColumn(parameterName), StreamType.NCHARACTER); loggerExternal.exiting(getClassNameLogging(), "getNCharacterStream", reader); return reader; } @@ -1326,8 +1287,7 @@ public Clob getClob(int parameterIndex) throws SQLServerException { public Clob getClob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getClob", parameterName); checkClosed(); - Clob clob = (Clob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.CLOB); + Clob clob = (Clob) getValue(findColumn(parameterName), JDBCType.CLOB); loggerExternal.exiting(getClassNameLogging(), "getClob", clob); return clob; } @@ -1345,8 +1305,7 @@ public NClob getNClob(int parameterIndex) throws SQLException { public NClob getNClob(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNClob", parameterName); checkClosed(); - NClob nClob = (NClob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), - JDBCType.NCLOB); + NClob nClob = (NClob) getValue(findColumn(parameterName), JDBCType.NCLOB); loggerExternal.exiting(getClassNameLogging(), "getNClob", nClob); return nClob; } @@ -1360,7 +1319,7 @@ public Object getObject(int parameterIndex, java.util.Map> map) @Override public Object getObject(String parameterName, java.util.Map> m) throws SQLException { checkClosed(); - return getObject(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), m); + return getObject(findColumn(parameterName), m); } @Override @@ -1372,7 +1331,7 @@ public Ref getRef(int parameterIndex) throws SQLException { @Override public Ref getRef(String parameterName) throws SQLException { checkClosed(); - return getRef(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + return getRef(findColumn(parameterName)); } @Override @@ -1384,7 +1343,7 @@ public java.sql.Array getArray(int parameterIndex) throws SQLException { @Override public java.sql.Array getArray(String parameterName) throws SQLException { checkClosed(); - return getArray(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + return getArray(findColumn(parameterName)); } /** @@ -1407,7 +1366,7 @@ private String stripLeadingAtSign(String columnName) { * when an error occurs * @return the index */ - private int findColumn(String columnName, CallableStatementGetterSetterMethod method) throws SQLServerException { + private int findColumn(String columnName) throws SQLServerException { // If inOutParam is null, likely the statement was closed beforehand. if (null == inOutParam) { @@ -1524,8 +1483,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, - value, JavaType.TIMESTAMP, calendar, false); + setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1536,8 +1494,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, Calenda loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, - value, JavaType.TIMESTAMP, calendar, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1546,8 +1503,7 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, - JavaType.TIME, calendar, false); + setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1558,8 +1514,7 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, - JavaType.TIME, calendar, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1568,8 +1523,7 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, - JavaType.DATE, calendar, false); + setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1580,8 +1534,7 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, - JavaType.DATE, calendar, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1590,8 +1543,8 @@ public final void setCharacterStream(String parameterName, Reader value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, - value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, + DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1601,8 +1554,7 @@ public final void setCharacterStream(String parameterName, Reader value, int len loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, - value, JavaType.READER, length); + setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1612,8 +1564,7 @@ public final void setCharacterStream(String parameterName, Reader value, long le loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, - value, JavaType.READER, length); + setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1622,8 +1573,8 @@ public final void setNCharacterStream(String parameterName, Reader value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, - value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, + DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1633,8 +1584,7 @@ public final void setNCharacterStream(String parameterName, Reader value, long l loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, - value, JavaType.READER, length); + setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1643,8 +1593,7 @@ public final void setClob(String parameterName, Clob value) throws SQLException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.CLOB, value, - JavaType.CLOB, false); + setValue(findColumn(parameterName), JDBCType.CLOB, value, JavaType.CLOB, false); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1653,8 +1602,8 @@ public final void setClob(String parameterName, Reader value) throws SQLExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, - value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, + DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1663,8 +1612,7 @@ public final void setClob(String parameterName, Reader value, long length) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, - value, JavaType.READER, length); + setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1673,8 +1621,7 @@ public final void setNClob(String parameterName, NClob value) throws SQLExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NCLOB, value, - JavaType.NCLOB, false); + setValue(findColumn(parameterName), JDBCType.NCLOB, value, JavaType.NCLOB, false); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1683,8 +1630,8 @@ public final void setNClob(String parameterName, Reader value) throws SQLExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, - value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, + DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1693,8 +1640,7 @@ public final void setNClob(String parameterName, Reader value, long length) thro if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, - value, JavaType.READER, length); + setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1703,8 +1649,7 @@ public final void setNString(String parameterName, String value) throws SQLExcep if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, - value, JavaType.STRING, false); + setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1714,8 +1659,7 @@ public final void setNString(String parameterName, String value, boolean forceEn loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, - value, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1724,7 +1668,7 @@ public void setObject(String parameterName, Object value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value}); checkClosed(); - setObjectNoType(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value, false); + setObjectNoType(findColumn(parameterName), value, false); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1735,15 +1679,12 @@ public void setObject(String parameterName, Object value, int sqlType) throws SQ loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType}); checkClosed(); if (microsoft.sql.Types.STRUCTURED == sqlType) { - tvpName = getTVPNameFromObject( - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), - value, JavaType.TVP, JDBCType.TVP, null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + tvpName = getTVPNameFromObject(findColumn(parameterName), value); + setObject(setterGetParam(findColumn(parameterName)), value, JavaType.TVP, JDBCType.TVP, null, null, false, + findColumn(parameterName), tvpName); } else - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), - value, JavaType.of(value), JDBCType.of(sqlType), null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), null, + null, false, findColumn(parameterName), tvpName); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1753,9 +1694,8 @@ public void setObject(String parameterName, Object value, int sqlType, int decim loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType, decimals}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, - JavaType.of(value), JDBCType.of(sqlType), decimals, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), decimals, + null, false, findColumn(parameterName), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1771,10 +1711,9 @@ public void setObject(String parameterName, Object value, int sqlType, int decim // this is the number of digits after the decimal point. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, - JavaType.of(value), JDBCType.of(sqlType), + setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), (java.sql.Types.NUMERIC == sqlType || java.sql.Types.DECIMAL == sqlType) ? decimals : null, null, - forceEncrypt, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + forceEncrypt, findColumn(parameterName), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1792,11 +1731,10 @@ public final void setObject(String parameterName, Object value, int targetSqlTyp // InputStream and Reader, this is the length of the data in the stream or reader. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, - JavaType.of(value), JDBCType.of(targetSqlType), + setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(targetSqlType), (java.sql.Types.NUMERIC == targetSqlType || java.sql.Types.DECIMAL == targetSqlType || InputStream.class.isInstance(value) || Reader.class.isInstance(value)) ? scale : null, - precision, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + precision, false, findColumn(parameterName), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1806,8 +1744,8 @@ public final void setAsciiStream(String parameterName, InputStream value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, - value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, + DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1817,8 +1755,7 @@ public final void setAsciiStream(String parameterName, InputStream value, int le loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, - value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1828,8 +1765,7 @@ public final void setAsciiStream(String parameterName, InputStream value, long l loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, - value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1838,8 +1774,8 @@ public final void setBinaryStream(String parameterName, InputStream value) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, - value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, + DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1849,8 +1785,7 @@ public final void setBinaryStream(String parameterName, InputStream value, int l loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, - value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1860,8 +1795,7 @@ public final void setBinaryStream(String parameterName, InputStream value, long loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, - value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1870,8 +1804,7 @@ public final void setBlob(String parameterName, Blob inputStream) throws SQLExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BLOB, - inputStream, JavaType.BLOB, false); + setValue(findColumn(parameterName), JDBCType.BLOB, inputStream, JavaType.BLOB, false); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1880,8 +1813,8 @@ public final void setBlob(String parameterName, InputStream value) throws SQLExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, - value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, + DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1891,8 +1824,7 @@ public final void setBlob(String parameterName, InputStream inputStream, long le loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, - inputStream, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1901,8 +1833,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, - value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1911,8 +1842,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, - value, JavaType.TIMESTAMP, null, scale, false); + setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1923,8 +1853,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, - value, JavaType.TIMESTAMP, null, scale, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1933,8 +1862,7 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, - value, JavaType.DATETIMEOFFSET, false); + setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1944,8 +1872,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, - value, JavaType.DATETIMEOFFSET, null, scale, false); + setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, + false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1956,8 +1884,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, - value, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, + forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1966,8 +1894,7 @@ public void setDate(String parameterName, java.sql.Date value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, - JavaType.DATE, false); + setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1976,8 +1903,7 @@ public void setTime(String parameterName, java.sql.Time value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, - JavaType.TIME, false); + setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1986,8 +1912,7 @@ public void setTime(String parameterName, java.sql.Time value, int scale) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, - JavaType.TIME, null, scale, false); + setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1998,8 +1923,7 @@ public void setTime(String parameterName, java.sql.Time value, int scale, loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, - JavaType.TIME, null, scale, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -2008,8 +1932,7 @@ public void setDateTime(String parameterName, java.sql.Timestamp value) throws S if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, - value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -2020,8 +1943,7 @@ public void setDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, - value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -2030,8 +1952,7 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value) thr if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, - value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -2042,8 +1963,7 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, - value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -2052,8 +1972,7 @@ public void setUniqueIdentifier(String parameterName, String guid) throws SQLSer if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, - JavaType.STRING, false); + setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -2063,8 +1982,7 @@ public void setUniqueIdentifier(String parameterName, String guid, boolean force loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, - JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -2073,8 +1991,7 @@ public void setBytes(String parameterName, byte[] value) throws SQLServerExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, - JavaType.BYTEARRAY, false); + setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, false); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2084,8 +2001,7 @@ public void setBytes(String parameterName, byte[] value, boolean forceEncrypt) t loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, - JavaType.BYTEARRAY, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2094,8 +2010,7 @@ public void setByte(String parameterName, byte value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, - JavaType.BYTE, false); + setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, false); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2105,8 +2020,7 @@ public void setByte(String parameterName, byte value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, - JavaType.BYTE, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2115,8 +2029,7 @@ public void setString(String parameterName, String value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, - JavaType.STRING, false); + setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2126,8 +2039,7 @@ public void setString(String parameterName, String value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, - JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2136,8 +2048,7 @@ public void setMoney(String parameterName, BigDecimal value) throws SQLServerExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, - JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2147,8 +2058,7 @@ public void setMoney(String parameterName, BigDecimal value, boolean forceEncryp loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, - JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2157,8 +2067,7 @@ public void setSmallMoney(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, - value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2168,8 +2077,7 @@ public void setSmallMoney(String parameterName, BigDecimal value, boolean forceE loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, - value, JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2178,8 +2086,7 @@ public void setBigDecimal(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, - JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2190,8 +2097,7 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, - JavaType.BIGDECIMAL, precision, scale, false); + setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2202,8 +2108,8 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, - JavaType.BIGDECIMAL, precision, scale, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, + forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2212,8 +2118,7 @@ public void setDouble(String parameterName, double value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, - JavaType.DOUBLE, false); + setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, false); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2223,8 +2128,7 @@ public void setDouble(String parameterName, double value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, - JavaType.DOUBLE, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2233,8 +2137,7 @@ public void setFloat(String parameterName, float value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, - JavaType.FLOAT, false); + setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, false); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2244,8 +2147,7 @@ public void setFloat(String parameterName, float value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, - JavaType.FLOAT, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2254,8 +2156,7 @@ public void setInt(String parameterName, int value) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, - JavaType.INTEGER, false); + setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, false); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2264,8 +2165,7 @@ public void setInt(String parameterName, int value, boolean forceEncrypt) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, - JavaType.INTEGER, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2274,8 +2174,7 @@ public void setLong(String parameterName, long value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, - JavaType.LONG, false); + setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, false); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2285,8 +2184,7 @@ public void setLong(String parameterName, long value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, - JavaType.LONG, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2295,8 +2193,7 @@ public void setShort(String parameterName, short value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, - value, JavaType.SHORT, false); + setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, false); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2306,8 +2203,7 @@ public void setShort(String parameterName, short value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, - value, JavaType.SHORT, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2316,8 +2212,7 @@ public void setBoolean(String parameterName, boolean value) throws SQLServerExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, - JavaType.BOOLEAN, false); + setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2327,8 +2222,7 @@ public void setBoolean(String parameterName, boolean value, boolean forceEncrypt loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, - JavaType.BOOLEAN, forceEncrypt); + setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2337,9 +2231,8 @@ public void setNull(String parameterName, int nType) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, - JavaType.OBJECT, JDBCType.of(nType), null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, + false, findColumn(parameterName), null); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2348,9 +2241,8 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType, sTypeName}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, - JavaType.OBJECT, JDBCType.of(nType), null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sTypeName); + setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, + false, findColumn(parameterName), sTypeName); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2358,49 +2250,43 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ public void setURL(String parameterName, URL url) throws SQLException { loggerExternal.entering(getClassNameLogging(), "setURL", parameterName); checkClosed(); - setURL(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), url); + setURL(findColumn(parameterName), url); loggerExternal.exiting(getClassNameLogging(), "setURL"); } @Override public final void setStructured(String parameterName, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), - tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataTable}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, - tvpDataTable, JavaType.TVP, tvpName); + setValue(findColumn(parameterName), JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ResultSet tvpResultSet) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), - tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpResultSet}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, - tvpResultSet, JavaType.TVP, tvpName); + setValue(findColumn(parameterName), JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ISQLServerDataRecord tvpDataRecord) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), - tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataRecord}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, - tvpDataRecord, JavaType.TVP, tvpName); + setValue(findColumn(parameterName), JDBCType.TVP, tvpDataRecord, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @@ -2421,7 +2307,7 @@ public final void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLEx if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterName, xmlObject}); checkClosed(); - setSQLXMLInternal(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), xmlObject); + setSQLXMLInternal(findColumn(parameterName), xmlObject); loggerExternal.exiting(getClassNameLogging(), "setSQLXML"); } @@ -2438,8 +2324,7 @@ public final SQLXML getSQLXML(int parameterIndex) throws SQLException { public final SQLXML getSQLXML(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getSQLXML", parameterName); checkClosed(); - SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal(findColumn(parameterName)); loggerExternal.exiting(getClassNameLogging(), "getSQLXML", value); return value; } @@ -2467,8 +2352,7 @@ public void registerOutParameter(String parameterName, int sqlType, String typeN loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, typeName}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, - typeName); + registerOutParameter(findColumn(parameterName), sqlType, typeName); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2478,8 +2362,7 @@ public void registerOutParameter(String parameterName, int sqlType, int scale) t loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, - scale); + registerOutParameter(findColumn(parameterName), sqlType, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2490,8 +2373,7 @@ public void registerOutParameter(String parameterName, int sqlType, int precisio loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, - precision, scale); + registerOutParameter(findColumn(parameterName), sqlType, precision, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2501,7 +2383,7 @@ public void registerOutParameter(String parameterName, int sqlType) throws SQLSe loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType); + registerOutParameter(findColumn(parameterName), sqlType); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } From ce4972b9e51c9238aa6afab9e3beee9e2cc2e25a Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 10:08:17 -0800 Subject: [PATCH 28/51] Removed comments regarding Yukon in IOBuffer --- src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java index 8778c9609..1408a9d32 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java @@ -4822,7 +4822,6 @@ void writeRPCStringUnicode(String sName, String sValue, boolean bOut, SQLCollati if ((nValueLen > DataTypes.SHORT_VARTYPE_MAX_BYTES || bOut) && !isNonPLP) { writeRPCNameValType(sName, bOut, TDSType.NVARCHAR); - // Handle Yukon v*max type header here. writeVMaxHeader(nValueLen, // Length bValueNull, // Is null? collation); @@ -5411,7 +5410,6 @@ void writeTVPColumnMetaData(TVP value) throws SQLServerException { // Use PLP encoding on Yukon and later with long values if (!isShortValue) // PLP { - // Handle Yukon v*max type header here. writeShort((short) 0xFFFF); con.getDatabaseCollation().writeCollation(this); } else // non PLP @@ -5429,7 +5427,6 @@ void writeTVPColumnMetaData(TVP value) throws SQLServerException { isShortValue = pair.getValue().precision <= DataTypes.SHORT_VARTYPE_MAX_BYTES; // Use PLP encoding on Yukon and later with long values if (!isShortValue) // PLP - // Handle Yukon v*max type header here. writeShort((short) 0xFFFF); else // non PLP writeShort((short) DataTypes.SHORT_VARTYPE_MAX_BYTES); @@ -5612,7 +5609,6 @@ void writeRPCByteArray(String sName, byte[] bValue, boolean bOut, JDBCType jdbcT writeRPCNameValType(sName, bOut, tdsType); if (usePLP && !isNonPLP) { - // Handle Yukon v*max type header here. writeVMaxHeader(nValueLen, bValueNull, collation); // Send the data. @@ -6393,7 +6389,6 @@ void writeRPCInputStream(String sName, InputStream stream, long streamLength, bo writeRPCNameValType(sName, bOut, jdbcType.isTextual() ? TDSType.BIGVARCHAR : TDSType.BIGVARBINARY); - // Handle Yukon v*max type header here. writeVMaxHeader(streamLength, false, jdbcType.isTextual() ? collation : null); } @@ -6533,7 +6528,6 @@ void writeRPCReaderUnicode(String sName, Reader re, long reLength, boolean bOut, writeRPCNameValType(sName, bOut, TDSType.NVARCHAR); - // Handle Yukon v*max type header here. writeVMaxHeader( (DataTypes.UNKNOWN_STREAM_LENGTH == reLength) ? DataTypes.UNKNOWN_STREAM_LENGTH : 2 * reLength, // Length // (in From 8b12fc138b94e21ac276534b0d45e131dc14eda9 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 10:11:46 -0800 Subject: [PATCH 29/51] Changed returnValueIsAccessed to isReturnValueAccessed --- .../sqlserver/jdbc/SQLServerCallableStatement.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 35efe566d..a5cfd33c8 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -70,7 +70,7 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple private transient Closeable activeStream; /** Checks if return values is already accessed in stored procedure */ - private boolean returnValueIsAccessed = false; + private boolean isReturnValueAccessed = false; /** map */ private Map map = new ConcurrentHashMap<>(); @@ -96,7 +96,7 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple SQLServerCallableStatement(SQLServerConnection connection, String sql, int nRSType, int nRSConcur, SQLServerStatementColumnEncryptionSetting stmtColEncSetting) throws SQLServerException { super(connection, sql, nRSType, nRSConcur, stmtColEncSetting); - returnValueIsAccessed = false; + isReturnValueAccessed = false; } @Override @@ -178,10 +178,10 @@ private Parameter getOutParameter(int i) throws SQLServerException { // driver is executing // the stored procedure for cursorable ones differently ( calling sp_cursorexecute r sp_cursorprepexec. if (bReturnValueSyntax && inOutParam[i - 1].isValueGotten() && inOutParam[i - 1].isReturnValue() - && !returnValueIsAccessed && !isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType + && !isReturnValueAccessed && !isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType && callRPCDirectly(inOutParam)) { nOutParamsAssigned++; - returnValueIsAccessed = true; + isReturnValueAccessed = true; } return inOutParam[i - 1]; } From e2e0e3fc9b9358eb0005f6708c565c2b2c58be1e Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 10:19:18 -0800 Subject: [PATCH 30/51] Fixed intellij wildcard imports --- .../sqlserver/jdbc/SQLServerCallableStatement.java | 6 +++++- .../sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java | 9 ++++++++- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index a5cfd33c8..aec7433f1 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -25,7 +25,11 @@ import java.sql.Timestamp; import java.text.MessageFormat; import java.time.LocalDateTime; -import java.util.*; +import java.util.Calendar; +import java.util.HashMap; +import java.util.TreeMap; +import java.util.Map; +import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java index fc198bf1f..c77edf93b 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java @@ -7,7 +7,14 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertEquals; -import java.sql.*; +import java.sql.Connection; +import java.sql.Date; +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 org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; From 5630abd60795fb68a23bef1ae9c6a2dbad19da06 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 10:24:40 -0800 Subject: [PATCH 31/51] Renamed DTC test class and test --- .../com/microsoft/sqlserver/jdbc/{DTC.java => DTCTest.java} | 6 +++--- .../sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java | 2 ++ 2 files changed, 5 insertions(+), 3 deletions(-) rename src/test/java/com/microsoft/sqlserver/jdbc/{DTC.java => DTCTest.java} (92%) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/DTC.java b/src/test/java/com/microsoft/sqlserver/jdbc/DTCTest.java similarity index 92% rename from src/test/java/com/microsoft/sqlserver/jdbc/DTC.java rename to src/test/java/com/microsoft/sqlserver/jdbc/DTCTest.java index cc76bf1ff..3b7d2be8d 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/DTC.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/DTCTest.java @@ -18,14 +18,14 @@ @RunWith(JUnitPlatform.class) @Tag(Constants.DTC) -public class DTC extends AbstractTest { +public class DTCTest extends AbstractTest { @BeforeAll public static void setupTest() throws Exception { setConnection(); } @Test - public void testCstmtXpSqljdbcXaInit() throws Exception { + public void testXaStartXpSqljdbcXaInit() throws Exception { SQLServerXADataSource XADataSource = new SQLServerXADataSource(); XADataSource.setURL(connectionString); XAConnection XAConnection = XADataSource.getXAConnection(); @@ -107,7 +107,7 @@ static Xid getUniqueXid(int tid) { bqual[i + 12] = (byte) (randID % 0x100); randID >>= 8; } - return new DTC.XidImpl(0x1234, gtrid, bqual); + return new DTCTest.XidImpl(0x1234, gtrid, bqual); } } } diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java index c77edf93b..b3bbe3cb0 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java @@ -10,6 +10,8 @@ import java.sql.Connection; import java.sql.Date; import java.sql.PreparedStatement; +import java.sql.CallableStatement; +import java.sql.Types; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; From 70bc076bf61246be84de812a730a38735116a6d3 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 13:53:31 -0800 Subject: [PATCH 32/51] Revert "Removed getter/setter enum" This reverts commit 2b35e53905f76be9d69cfe2543947434f8943be0. --- .../jdbc/SQLServerCallableStatement.java | 412 +++++++++++------- 1 file changed, 265 insertions(+), 147 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index aec7433f1..4f8175c70 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -82,6 +82,16 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple /** atomic integer */ AtomicInteger ai = new AtomicInteger(0); + /** + * Enum to check if the callablestatement is a setter or getter method. This enum is used in method findColumn where + * we get the parameter/column by name + * + */ + enum CallableStatementGetterSetterMethod { + isSetterMethod, + isGetterMethod + } + /** * Create a new callable statement. * @@ -539,7 +549,8 @@ public int getInt(int index) throws SQLServerException { public int getInt(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getInt", parameterName); checkClosed(); - Integer value = (Integer) getValue(findColumn(parameterName), JDBCType.INTEGER); + Integer value = (Integer) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.INTEGER); loggerExternal.exiting(getClassNameLogging(), "getInt", value); return null != value ? value : 0; } @@ -562,7 +573,8 @@ public String getString(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getString", parameterName); checkClosed(); String value = null; - Object objectValue = getValue(findColumn(parameterName), JDBCType.CHAR); + Object objectValue = getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.CHAR); if (null != objectValue) { value = objectValue.toString(); } @@ -583,7 +595,8 @@ public final String getNString(int parameterIndex) throws SQLException { public final String getNString(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNString", parameterName); checkClosed(); - String value = (String) getValue(findColumn(parameterName), JDBCType.NCHAR); + String value = (String) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.NCHAR); loggerExternal.exiting(getClassNameLogging(), "getNString", value); return value; } @@ -613,7 +626,8 @@ public BigDecimal getBigDecimal(String parameterName, int scale) throws SQLServe if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterName, scale}); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.DECIMAL); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); if (null != value) value = value.setScale(scale, BigDecimal.ROUND_DOWN); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); @@ -633,7 +647,8 @@ public boolean getBoolean(int index) throws SQLServerException { public boolean getBoolean(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBoolean", parameterName); checkClosed(); - Boolean value = (Boolean) getValue(findColumn(parameterName), JDBCType.BIT); + Boolean value = (Boolean) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.BIT); loggerExternal.exiting(getClassNameLogging(), "getBoolean", value); return null != value ? value : false; } @@ -652,7 +667,8 @@ public byte getByte(int index) throws SQLServerException { public byte getByte(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getByte", parameterName); checkClosed(); - Short shortValue = (Short) getValue(findColumn(parameterName), JDBCType.TINYINT); + Short shortValue = (Short) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TINYINT); byte byteValue = (null != shortValue) ? shortValue.byteValue() : 0; loggerExternal.exiting(getClassNameLogging(), "getByte", byteValue); return byteValue; @@ -671,7 +687,8 @@ public byte[] getBytes(int index) throws SQLServerException { public byte[] getBytes(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBytes", parameterName); checkClosed(); - byte[] value = (byte[]) getValue(findColumn(parameterName), JDBCType.BINARY); + byte[] value = (byte[]) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBytes", value); return value; } @@ -689,7 +706,8 @@ public Date getDate(int index) throws SQLServerException { public Date getDate(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDate", parameterName); checkClosed(); - java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName), JDBCType.DATE); + java.sql.Date value = (java.sql.Date) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -709,7 +727,8 @@ public Date getDate(String parameterName, Calendar cal) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName), JDBCType.DATE); + java.sql.Date value = (java.sql.Date) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -727,7 +746,8 @@ public double getDouble(int index) throws SQLServerException { public double getDouble(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDouble", parameterName); checkClosed(); - Double value = (Double) getValue(findColumn(parameterName), JDBCType.DOUBLE); + Double value = (Double) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.DOUBLE); loggerExternal.exiting(getClassNameLogging(), "getDouble", value); return null != value ? value : 0; } @@ -745,7 +765,8 @@ public float getFloat(int index) throws SQLServerException { public float getFloat(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getFloat", parameterName); checkClosed(); - Float value = (Float) getValue(findColumn(parameterName), JDBCType.REAL); + Float value = (Float) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.REAL); loggerExternal.exiting(getClassNameLogging(), "getFloat", value); return null != value ? value : 0; } @@ -764,7 +785,8 @@ public long getLong(int index) throws SQLServerException { public long getLong(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getLong", parameterName); checkClosed(); - Long value = (Long) getValue(findColumn(parameterName), JDBCType.BIGINT); + Long value = (Long) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.BIGINT); loggerExternal.exiting(getClassNameLogging(), "getLong", value); return null != value ? value : 0; } @@ -877,7 +899,7 @@ public T getObject(int index, Class type) throws SQLException { public Object getObject(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName); + int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); Object value = getValue(parameterIndex, null != getterGetParam(parameterIndex).getJdbcTypeSetByUser() ? getterGetParam(parameterIndex) .getJdbcTypeSetByUser() : getterGetParam(parameterIndex).getJdbcType()); @@ -889,7 +911,7 @@ public Object getObject(String parameterName) throws SQLServerException { public T getObject(String parameterName, Class type) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName); + int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); T value = getObject(parameterIndex, type); loggerExternal.exiting(getClassNameLogging(), "getObject", value); return value; @@ -908,7 +930,8 @@ public short getShort(int index) throws SQLServerException { public short getShort(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getShort", parameterName); checkClosed(); - Short value = (Short) getValue(findColumn(parameterName), JDBCType.SMALLINT); + Short value = (Short) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.SMALLINT); loggerExternal.exiting(getClassNameLogging(), "getShort", value); return null != value ? value : 0; } @@ -927,7 +950,8 @@ public Time getTime(int index) throws SQLServerException { public Time getTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getTime", parameterName); checkClosed(); - java.sql.Time value = (java.sql.Time) getValue(findColumn(parameterName), JDBCType.TIME); + java.sql.Time value = (java.sql.Time) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -947,7 +971,8 @@ public Time getTime(String parameterName, Calendar cal) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Time value = (java.sql.Time) getValue(findColumn(parameterName), JDBCType.TIME, cal); + java.sql.Time value = (java.sql.Time) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -966,7 +991,8 @@ public Timestamp getTimestamp(int index) throws SQLServerException { public Timestamp getTimestamp(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.TIMESTAMP); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -986,7 +1012,8 @@ public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.TIMESTAMP, cal); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -1013,7 +1040,8 @@ public Timestamp getDateTime(int index) throws SQLServerException { public Timestamp getDateTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDateTime", parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.DATETIME); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -1033,7 +1061,8 @@ public Timestamp getDateTime(String parameterName, Calendar cal) throws SQLServe if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.DATETIME, cal); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -1052,7 +1081,8 @@ public Timestamp getSmallDateTime(int index) throws SQLServerException { public Timestamp getSmallDateTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", parameterName); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.SMALLDATETIME); + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; } @@ -1072,7 +1102,8 @@ public Timestamp getSmallDateTime(String parameterName, Calendar cal) throws SQL if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {parameterName, cal}); checkClosed(); - java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(parameterName), JDBCType.SMALLDATETIME, + java.sql.Timestamp value = (java.sql.Timestamp) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; @@ -1104,8 +1135,8 @@ public microsoft.sql.DateTimeOffset getDateTimeOffset(String parameterName) thro throw new SQLServerException(SQLServerException.getErrString("R_notSupported"), SQLState.DATA_EXCEPTION_NOT_SPECIFIC, DriverError.NOT_SET, null); - microsoft.sql.DateTimeOffset value = (microsoft.sql.DateTimeOffset) getValue(findColumn(parameterName), - JDBCType.DATETIMEOFFSET); + microsoft.sql.DateTimeOffset value = (microsoft.sql.DateTimeOffset) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIMEOFFSET); loggerExternal.exiting(getClassNameLogging(), "getDateTimeOffset", value); return value; } @@ -1135,7 +1166,8 @@ public final java.io.InputStream getAsciiStream(int parameterIndex) throws SQLSe public final java.io.InputStream getAsciiStream(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getAsciiStream", parameterName); checkClosed(); - InputStream value = (InputStream) getStream(findColumn(parameterName), StreamType.ASCII); + InputStream value = (InputStream) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.ASCII); loggerExternal.exiting(getClassNameLogging(), "getAsciiStream", value); return value; } @@ -1153,7 +1185,8 @@ public BigDecimal getBigDecimal(int parameterIndex) throws SQLServerException { public BigDecimal getBigDecimal(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBigDecimal", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.DECIMAL); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); return value; } @@ -1171,7 +1204,8 @@ public BigDecimal getMoney(int parameterIndex) throws SQLServerException { public BigDecimal getMoney(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getMoney", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.MONEY); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.MONEY); loggerExternal.exiting(getClassNameLogging(), "getMoney", value); return value; } @@ -1189,7 +1223,8 @@ public BigDecimal getSmallMoney(int parameterIndex) throws SQLServerException { public BigDecimal getSmallMoney(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getSmallMoney", parameterName); checkClosed(); - BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.SMALLMONEY); + BigDecimal value = (BigDecimal) getValue( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLMONEY); loggerExternal.exiting(getClassNameLogging(), "getSmallMoney", value); return value; } @@ -1207,7 +1242,8 @@ public final java.io.InputStream getBinaryStream(int parameterIndex) throws SQLS public final java.io.InputStream getBinaryStream(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBinaryStream", parameterName); checkClosed(); - InputStream value = (InputStream) getStream(findColumn(parameterName), StreamType.BINARY); + InputStream value = (InputStream) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBinaryStream", value); return value; } @@ -1225,7 +1261,8 @@ public Blob getBlob(int parameterIndex) throws SQLServerException { public Blob getBlob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBlob", parameterName); checkClosed(); - Blob value = (Blob) getValue(findColumn(parameterName), JDBCType.BLOB); + Blob value = (Blob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.BLOB); loggerExternal.exiting(getClassNameLogging(), "getBlob", value); return value; } @@ -1243,7 +1280,8 @@ public final java.io.Reader getCharacterStream(int parameterIndex) throws SQLSer public final java.io.Reader getCharacterStream(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getCharacterStream", parameterName); checkClosed(); - Reader reader = (Reader) getStream(findColumn(parameterName), StreamType.CHARACTER); + Reader reader = (Reader) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.CHARACTER); loggerExternal.exiting(getClassNameLogging(), "getCharacterSream", reader); return reader; } @@ -1261,7 +1299,8 @@ public final java.io.Reader getNCharacterStream(int parameterIndex) throws SQLEx public final java.io.Reader getNCharacterStream(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNCharacterStream", parameterName); checkClosed(); - Reader reader = (Reader) getStream(findColumn(parameterName), StreamType.NCHARACTER); + Reader reader = (Reader) getStream( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.NCHARACTER); loggerExternal.exiting(getClassNameLogging(), "getNCharacterStream", reader); return reader; } @@ -1291,7 +1330,8 @@ public Clob getClob(int parameterIndex) throws SQLServerException { public Clob getClob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getClob", parameterName); checkClosed(); - Clob clob = (Clob) getValue(findColumn(parameterName), JDBCType.CLOB); + Clob clob = (Clob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.CLOB); loggerExternal.exiting(getClassNameLogging(), "getClob", clob); return clob; } @@ -1309,7 +1349,8 @@ public NClob getNClob(int parameterIndex) throws SQLException { public NClob getNClob(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNClob", parameterName); checkClosed(); - NClob nClob = (NClob) getValue(findColumn(parameterName), JDBCType.NCLOB); + NClob nClob = (NClob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + JDBCType.NCLOB); loggerExternal.exiting(getClassNameLogging(), "getNClob", nClob); return nClob; } @@ -1323,7 +1364,7 @@ public Object getObject(int parameterIndex, java.util.Map> map) @Override public Object getObject(String parameterName, java.util.Map> m) throws SQLException { checkClosed(); - return getObject(findColumn(parameterName), m); + return getObject(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), m); } @Override @@ -1335,7 +1376,7 @@ public Ref getRef(int parameterIndex) throws SQLException { @Override public Ref getRef(String parameterName) throws SQLException { checkClosed(); - return getRef(findColumn(parameterName)); + return getRef(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); } @Override @@ -1347,7 +1388,7 @@ public java.sql.Array getArray(int parameterIndex) throws SQLException { @Override public java.sql.Array getArray(String parameterName) throws SQLException { checkClosed(); - return getArray(findColumn(parameterName)); + return getArray(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); } /** @@ -1370,7 +1411,7 @@ private String stripLeadingAtSign(String columnName) { * when an error occurs * @return the index */ - private int findColumn(String columnName) throws SQLServerException { + private int findColumn(String columnName, CallableStatementGetterSetterMethod method) throws SQLServerException { // If inOutParam is null, likely the statement was closed beforehand. if (null == inOutParam) { @@ -1487,7 +1528,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1498,7 +1540,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, Calenda loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1507,7 +1550,8 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1518,7 +1562,8 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1527,7 +1572,8 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + JavaType.DATE, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1538,7 +1584,8 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + JavaType.DATE, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1547,8 +1594,8 @@ public final void setCharacterStream(String parameterName, Reader value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1558,7 +1605,8 @@ public final void setCharacterStream(String parameterName, Reader value, int len loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1568,7 +1616,8 @@ public final void setCharacterStream(String parameterName, Reader value, long le loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1577,8 +1626,8 @@ public final void setNCharacterStream(String parameterName, Reader value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1588,7 +1637,8 @@ public final void setNCharacterStream(String parameterName, Reader value, long l loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1597,7 +1647,8 @@ public final void setClob(String parameterName, Clob value) throws SQLException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.CLOB, value, JavaType.CLOB, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.CLOB, value, + JavaType.CLOB, false); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1606,8 +1657,8 @@ public final void setClob(String parameterName, Reader value) throws SQLExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1616,7 +1667,8 @@ public final void setClob(String parameterName, Reader value, long length) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1625,7 +1677,8 @@ public final void setNClob(String parameterName, NClob value) throws SQLExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.NCLOB, value, JavaType.NCLOB, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NCLOB, value, + JavaType.NCLOB, false); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1634,8 +1687,8 @@ public final void setNClob(String parameterName, Reader value) throws SQLExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1644,7 +1697,8 @@ public final void setNClob(String parameterName, Reader value, long length) thro if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1653,7 +1707,8 @@ public final void setNString(String parameterName, String value) throws SQLExcep if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, + value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1663,7 +1718,8 @@ public final void setNString(String parameterName, String value, boolean forceEn loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, + value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1672,7 +1728,7 @@ public void setObject(String parameterName, Object value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value}); checkClosed(); - setObjectNoType(findColumn(parameterName), value, false); + setObjectNoType(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value, false); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1683,12 +1739,15 @@ public void setObject(String parameterName, Object value, int sqlType) throws SQ loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType}); checkClosed(); if (microsoft.sql.Types.STRUCTURED == sqlType) { - tvpName = getTVPNameFromObject(findColumn(parameterName), value); - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.TVP, JDBCType.TVP, null, null, false, - findColumn(parameterName), tvpName); + tvpName = getTVPNameFromObject( + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), + value, JavaType.TVP, JDBCType.TVP, null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); } else - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), null, - null, false, findColumn(parameterName), tvpName); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), + value, JavaType.of(value), JDBCType.of(sqlType), null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1698,8 +1757,9 @@ public void setObject(String parameterName, Object value, int sqlType, int decim loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType, decimals}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), decimals, - null, false, findColumn(parameterName), null); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + JavaType.of(value), JDBCType.of(sqlType), decimals, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1715,9 +1775,10 @@ public void setObject(String parameterName, Object value, int sqlType, int decim // this is the number of digits after the decimal point. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + JavaType.of(value), JDBCType.of(sqlType), (java.sql.Types.NUMERIC == sqlType || java.sql.Types.DECIMAL == sqlType) ? decimals : null, null, - forceEncrypt, findColumn(parameterName), null); + forceEncrypt, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1735,10 +1796,11 @@ public final void setObject(String parameterName, Object value, int targetSqlTyp // InputStream and Reader, this is the length of the data in the stream or reader. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(targetSqlType), + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + JavaType.of(value), JDBCType.of(targetSqlType), (java.sql.Types.NUMERIC == targetSqlType || java.sql.Types.DECIMAL == targetSqlType || InputStream.class.isInstance(value) || Reader.class.isInstance(value)) ? scale : null, - precision, false, findColumn(parameterName), null); + precision, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1748,8 +1810,8 @@ public final void setAsciiStream(String parameterName, InputStream value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1759,7 +1821,8 @@ public final void setAsciiStream(String parameterName, InputStream value, int le loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1769,7 +1832,8 @@ public final void setAsciiStream(String parameterName, InputStream value, long l loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1778,8 +1842,8 @@ public final void setBinaryStream(String parameterName, InputStream value) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1789,7 +1853,8 @@ public final void setBinaryStream(String parameterName, InputStream value, int l loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1799,7 +1864,8 @@ public final void setBinaryStream(String parameterName, InputStream value, long loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1808,7 +1874,8 @@ public final void setBlob(String parameterName, Blob inputStream) throws SQLExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BLOB, inputStream, JavaType.BLOB, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BLOB, + inputStream, JavaType.BLOB, false); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1817,8 +1884,8 @@ public final void setBlob(String parameterName, InputStream value) throws SQLExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, - DataTypes.UNKNOWN_STREAM_LENGTH); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1828,7 +1895,8 @@ public final void setBlob(String parameterName, InputStream inputStream, long le loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream, length}); checkClosed(); - setStream(findColumn(parameterName), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + inputStream, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1837,7 +1905,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1846,7 +1915,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1857,7 +1927,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + value, JavaType.TIMESTAMP, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1866,7 +1937,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + value, JavaType.DATETIMEOFFSET, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1876,8 +1948,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, - false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + value, JavaType.DATETIMEOFFSET, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1888,8 +1960,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, - forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + value, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1898,7 +1970,8 @@ public void setDate(String parameterName, java.sql.Date value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + JavaType.DATE, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1907,7 +1980,8 @@ public void setTime(String parameterName, java.sql.Time value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1916,7 +1990,8 @@ public void setTime(String parameterName, java.sql.Time value, int scale) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1927,7 +2002,8 @@ public void setTime(String parameterName, java.sql.Time value, int scale, loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + JavaType.TIME, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1936,7 +2012,8 @@ public void setDateTime(String parameterName, java.sql.Timestamp value) throws S if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, + value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -1947,7 +2024,8 @@ public void setDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, + value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -1956,7 +2034,8 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value) thr if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, + value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -1967,7 +2046,8 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, + value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -1976,7 +2056,8 @@ public void setUniqueIdentifier(String parameterName, String guid) throws SQLSer if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, + JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -1986,7 +2067,8 @@ public void setUniqueIdentifier(String parameterName, String guid, boolean force loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, + JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -1995,7 +2077,8 @@ public void setBytes(String parameterName, byte[] value) throws SQLServerExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, + JavaType.BYTEARRAY, false); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2005,7 +2088,8 @@ public void setBytes(String parameterName, byte[] value, boolean forceEncrypt) t loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, + JavaType.BYTEARRAY, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2014,7 +2098,8 @@ public void setByte(String parameterName, byte value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, + JavaType.BYTE, false); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2024,7 +2109,8 @@ public void setByte(String parameterName, byte value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, + JavaType.BYTE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2033,7 +2119,8 @@ public void setString(String parameterName, String value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, + JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2043,7 +2130,8 @@ public void setString(String parameterName, String value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, + JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2052,7 +2140,8 @@ public void setMoney(String parameterName, BigDecimal value) throws SQLServerExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, + JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2062,7 +2151,8 @@ public void setMoney(String parameterName, BigDecimal value, boolean forceEncryp loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, + JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2071,7 +2161,8 @@ public void setSmallMoney(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, + value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2081,7 +2172,8 @@ public void setSmallMoney(String parameterName, BigDecimal value, boolean forceE loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, + value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2090,7 +2182,8 @@ public void setBigDecimal(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2101,7 +2194,8 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + JavaType.BIGDECIMAL, precision, scale, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2112,8 +2206,8 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, - forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + JavaType.BIGDECIMAL, precision, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2122,7 +2216,8 @@ public void setDouble(String parameterName, double value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, + JavaType.DOUBLE, false); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2132,7 +2227,8 @@ public void setDouble(String parameterName, double value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, + JavaType.DOUBLE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2141,7 +2237,8 @@ public void setFloat(String parameterName, float value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, + JavaType.FLOAT, false); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2151,7 +2248,8 @@ public void setFloat(String parameterName, float value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, + JavaType.FLOAT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2160,7 +2258,8 @@ public void setInt(String parameterName, int value) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, + JavaType.INTEGER, false); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2169,7 +2268,8 @@ public void setInt(String parameterName, int value, boolean forceEncrypt) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, + JavaType.INTEGER, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2178,7 +2278,8 @@ public void setLong(String parameterName, long value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, + JavaType.LONG, false); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2188,7 +2289,8 @@ public void setLong(String parameterName, long value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, + JavaType.LONG, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2197,7 +2299,8 @@ public void setShort(String parameterName, short value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, + value, JavaType.SHORT, false); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2207,7 +2310,8 @@ public void setShort(String parameterName, short value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, + value, JavaType.SHORT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2216,7 +2320,8 @@ public void setBoolean(String parameterName, boolean value) throws SQLServerExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, false); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, + JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2226,7 +2331,8 @@ public void setBoolean(String parameterName, boolean value, boolean forceEncrypt loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, forceEncrypt); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, + JavaType.BOOLEAN, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2235,8 +2341,9 @@ public void setNull(String parameterName, int nType) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, - false, findColumn(parameterName), null); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, + JavaType.OBJECT, JDBCType.of(nType), null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2245,8 +2352,9 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType, sTypeName}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, - false, findColumn(parameterName), sTypeName); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, + JavaType.OBJECT, JDBCType.of(nType), null, null, false, + findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sTypeName); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2254,43 +2362,49 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ public void setURL(String parameterName, URL url) throws SQLException { loggerExternal.entering(getClassNameLogging(), "setURL", parameterName); checkClosed(); - setURL(findColumn(parameterName), url); + setURL(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), url); loggerExternal.exiting(getClassNameLogging(), "setURL"); } @Override public final void setStructured(String parameterName, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataTable}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + tvpDataTable, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ResultSet tvpResultSet) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpResultSet}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + tvpResultSet, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @Override public final void setStructured(String parameterName, String tvpName, ISQLServerDataRecord tvpDataRecord) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataRecord}); checkClosed(); - setValue(findColumn(parameterName), JDBCType.TVP, tvpDataRecord, JavaType.TVP, tvpName); + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + tvpDataRecord, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @@ -2311,7 +2425,7 @@ public final void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLEx if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterName, xmlObject}); checkClosed(); - setSQLXMLInternal(findColumn(parameterName), xmlObject); + setSQLXMLInternal(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), xmlObject); loggerExternal.exiting(getClassNameLogging(), "setSQLXML"); } @@ -2328,7 +2442,8 @@ public final SQLXML getSQLXML(int parameterIndex) throws SQLException { public final SQLXML getSQLXML(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getSQLXML", parameterName); checkClosed(); - SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal(findColumn(parameterName)); + SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal( + findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); loggerExternal.exiting(getClassNameLogging(), "getSQLXML", value); return value; } @@ -2356,7 +2471,8 @@ public void registerOutParameter(String parameterName, int sqlType, String typeN loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, typeName}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType, typeName); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + typeName); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2366,7 +2482,8 @@ public void registerOutParameter(String parameterName, int sqlType, int scale) t loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType, scale); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2377,7 +2494,8 @@ public void registerOutParameter(String parameterName, int sqlType, int precisio loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType, precision, scale); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + precision, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2387,7 +2505,7 @@ public void registerOutParameter(String parameterName, int sqlType) throws SQLSe loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType}); checkClosed(); - registerOutParameter(findColumn(parameterName), sqlType); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } From bf45de2783d3638ddadbf6873d437454203d8527 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 15:17:23 -0800 Subject: [PATCH 33/51] New connection string property to toggle sp_sproc_columns calls --- .../sqlserver/jdbc/ISQLServerDataSource.java | 15 + .../jdbc/SQLServerCallableStatement.java | 458 +++++++++--------- .../sqlserver/jdbc/SQLServerConnection.java | 30 ++ .../sqlserver/jdbc/SQLServerDataSource.java | 11 + .../sqlserver/jdbc/SQLServerDriver.java | 6 +- .../sqlserver/jdbc/SQLServerResource.java | 1 + .../CallableStatementTest.java | 1 + 7 files changed, 297 insertions(+), 225 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java index 3bfc279a5..816418751 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java @@ -609,6 +609,21 @@ public interface ISQLServerDataSource extends javax.sql.CommonDataSource { */ boolean getUseDefaultGSSCredential(); + /** + * Sets the value to indicate whether useDefaultGSSCredential is enabled. + * + * @param enable + * true if useDefaultGSSCredential is enabled. Otherwise, false. + */ + void setUseFastCallableStatements(boolean enable); + + /** + * Returns the useDefaultGSSCredential. + * + * @return if enabled, return true. Otherwise, false. + */ + boolean getUseFastCallableStatements(); + /** * Sets the GSSCredential. * diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 4f8175c70..8000ba61f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -88,8 +88,8 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple * */ enum CallableStatementGetterSetterMethod { - isSetterMethod, - isGetterMethod + IS_SETTER_METHOD, + IS_GETTER_METHOD } /** @@ -550,7 +550,7 @@ public int getInt(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getInt", parameterName); checkClosed(); Integer value = (Integer) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.INTEGER); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.INTEGER); loggerExternal.exiting(getClassNameLogging(), "getInt", value); return null != value ? value : 0; } @@ -573,7 +573,7 @@ public String getString(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getString", parameterName); checkClosed(); String value = null; - Object objectValue = getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + Object objectValue = getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.CHAR); if (null != objectValue) { value = objectValue.toString(); @@ -595,7 +595,7 @@ public final String getNString(int parameterIndex) throws SQLException { public final String getNString(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNString", parameterName); checkClosed(); - String value = (String) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + String value = (String) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.NCHAR); loggerExternal.exiting(getClassNameLogging(), "getNString", value); return value; @@ -627,7 +627,7 @@ public BigDecimal getBigDecimal(String parameterName, int scale) throws SQLServe loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterName, scale}); checkClosed(); BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DECIMAL); if (null != value) value = value.setScale(scale, BigDecimal.ROUND_DOWN); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); @@ -648,7 +648,7 @@ public boolean getBoolean(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBoolean", parameterName); checkClosed(); Boolean value = (Boolean) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.BIT); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.BIT); loggerExternal.exiting(getClassNameLogging(), "getBoolean", value); return null != value ? value : false; } @@ -668,7 +668,7 @@ public byte getByte(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getByte", parameterName); checkClosed(); Short shortValue = (Short) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TINYINT); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.TINYINT); byte byteValue = (null != shortValue) ? shortValue.byteValue() : 0; loggerExternal.exiting(getClassNameLogging(), "getByte", byteValue); return byteValue; @@ -687,7 +687,7 @@ public byte[] getBytes(int index) throws SQLServerException { public byte[] getBytes(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBytes", parameterName); checkClosed(); - byte[] value = (byte[]) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + byte[] value = (byte[]) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBytes", value); return value; @@ -707,7 +707,7 @@ public Date getDate(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDate", parameterName); checkClosed(); java.sql.Date value = (java.sql.Date) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -728,7 +728,7 @@ public Date getDate(String parameterName, Calendar cal) throws SQLServerExceptio loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {parameterName, cal}); checkClosed(); java.sql.Date value = (java.sql.Date) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATE); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DATE); loggerExternal.exiting(getClassNameLogging(), "getDate", value); return value; } @@ -746,7 +746,7 @@ public double getDouble(int index) throws SQLServerException { public double getDouble(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDouble", parameterName); checkClosed(); - Double value = (Double) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + Double value = (Double) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DOUBLE); loggerExternal.exiting(getClassNameLogging(), "getDouble", value); return null != value ? value : 0; @@ -765,7 +765,7 @@ public float getFloat(int index) throws SQLServerException { public float getFloat(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getFloat", parameterName); checkClosed(); - Float value = (Float) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + Float value = (Float) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.REAL); loggerExternal.exiting(getClassNameLogging(), "getFloat", value); return null != value ? value : 0; @@ -785,7 +785,7 @@ public long getLong(int index) throws SQLServerException { public long getLong(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getLong", parameterName); checkClosed(); - Long value = (Long) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + Long value = (Long) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.BIGINT); loggerExternal.exiting(getClassNameLogging(), "getLong", value); return null != value ? value : 0; @@ -899,7 +899,7 @@ public T getObject(int index, Class type) throws SQLException { public Object getObject(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); + int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD); Object value = getValue(parameterIndex, null != getterGetParam(parameterIndex).getJdbcTypeSetByUser() ? getterGetParam(parameterIndex) .getJdbcTypeSetByUser() : getterGetParam(parameterIndex).getJdbcType()); @@ -911,7 +911,7 @@ public Object getObject(String parameterName) throws SQLServerException { public T getObject(String parameterName, Class type) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getObject", parameterName); checkClosed(); - int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod); + int parameterIndex = findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD); T value = getObject(parameterIndex, type); loggerExternal.exiting(getClassNameLogging(), "getObject", value); return value; @@ -930,7 +930,7 @@ public short getShort(int index) throws SQLServerException { public short getShort(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getShort", parameterName); checkClosed(); - Short value = (Short) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + Short value = (Short) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.SMALLINT); loggerExternal.exiting(getClassNameLogging(), "getShort", value); return null != value ? value : 0; @@ -951,7 +951,7 @@ public Time getTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getTime", parameterName); checkClosed(); java.sql.Time value = (java.sql.Time) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.TIME); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -972,7 +972,7 @@ public Time getTime(String parameterName, Calendar cal) throws SQLServerExceptio loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {parameterName, cal}); checkClosed(); java.sql.Time value = (java.sql.Time) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIME, cal); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); return value; } @@ -992,7 +992,7 @@ public Timestamp getTimestamp(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, parameterName); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.TIMESTAMP); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -1013,7 +1013,7 @@ public Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLServ loggerExternal.entering(getClassNameLogging(), GET_TIMESTAMP, new Object[] {parameterName, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.TIMESTAMP, cal); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), GET_TIMESTAMP, value); return value; } @@ -1041,7 +1041,7 @@ public Timestamp getDateTime(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getDateTime", parameterName); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DATETIME); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -1062,7 +1062,7 @@ public Timestamp getDateTime(String parameterName, Calendar cal) throws SQLServe loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {parameterName, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIME, cal); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); return value; } @@ -1082,7 +1082,7 @@ public Timestamp getSmallDateTime(String parameterName) throws SQLServerExceptio loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", parameterName); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.SMALLDATETIME); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; } @@ -1103,7 +1103,7 @@ public Timestamp getSmallDateTime(String parameterName, Calendar cal) throws SQL loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {parameterName, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLDATETIME, + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.SMALLDATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); return value; @@ -1136,7 +1136,7 @@ public microsoft.sql.DateTimeOffset getDateTimeOffset(String parameterName) thro SQLState.DATA_EXCEPTION_NOT_SPECIFIC, DriverError.NOT_SET, null); microsoft.sql.DateTimeOffset value = (microsoft.sql.DateTimeOffset) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DATETIMEOFFSET); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DATETIMEOFFSET); loggerExternal.exiting(getClassNameLogging(), "getDateTimeOffset", value); return value; } @@ -1167,7 +1167,7 @@ public final java.io.InputStream getAsciiStream(String parameterName) throws SQL loggerExternal.entering(getClassNameLogging(), "getAsciiStream", parameterName); checkClosed(); InputStream value = (InputStream) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.ASCII); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), StreamType.ASCII); loggerExternal.exiting(getClassNameLogging(), "getAsciiStream", value); return value; } @@ -1186,7 +1186,7 @@ public BigDecimal getBigDecimal(String parameterName) throws SQLServerException loggerExternal.entering(getClassNameLogging(), "getBigDecimal", parameterName); checkClosed(); BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.DECIMAL); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.DECIMAL); loggerExternal.exiting(getClassNameLogging(), "getBigDecimal", value); return value; } @@ -1205,7 +1205,7 @@ public BigDecimal getMoney(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getMoney", parameterName); checkClosed(); BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.MONEY); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.MONEY); loggerExternal.exiting(getClassNameLogging(), "getMoney", value); return value; } @@ -1224,7 +1224,7 @@ public BigDecimal getSmallMoney(String parameterName) throws SQLServerException loggerExternal.entering(getClassNameLogging(), "getSmallMoney", parameterName); checkClosed(); BigDecimal value = (BigDecimal) getValue( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), JDBCType.SMALLMONEY); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.SMALLMONEY); loggerExternal.exiting(getClassNameLogging(), "getSmallMoney", value); return value; } @@ -1243,7 +1243,7 @@ public final java.io.InputStream getBinaryStream(String parameterName) throws SQ loggerExternal.entering(getClassNameLogging(), "getBinaryStream", parameterName); checkClosed(); InputStream value = (InputStream) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.BINARY); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), StreamType.BINARY); loggerExternal.exiting(getClassNameLogging(), "getBinaryStream", value); return value; } @@ -1261,7 +1261,7 @@ public Blob getBlob(int parameterIndex) throws SQLServerException { public Blob getBlob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getBlob", parameterName); checkClosed(); - Blob value = (Blob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + Blob value = (Blob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.BLOB); loggerExternal.exiting(getClassNameLogging(), "getBlob", value); return value; @@ -1281,7 +1281,7 @@ public final java.io.Reader getCharacterStream(String parameterName) throws SQLE loggerExternal.entering(getClassNameLogging(), "getCharacterStream", parameterName); checkClosed(); Reader reader = (Reader) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.CHARACTER); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), StreamType.CHARACTER); loggerExternal.exiting(getClassNameLogging(), "getCharacterSream", reader); return reader; } @@ -1300,7 +1300,7 @@ public final java.io.Reader getNCharacterStream(String parameterName) throws SQL loggerExternal.entering(getClassNameLogging(), "getNCharacterStream", parameterName); checkClosed(); Reader reader = (Reader) getStream( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), StreamType.NCHARACTER); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), StreamType.NCHARACTER); loggerExternal.exiting(getClassNameLogging(), "getNCharacterStream", reader); return reader; } @@ -1330,7 +1330,7 @@ public Clob getClob(int parameterIndex) throws SQLServerException { public Clob getClob(String parameterName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getClob", parameterName); checkClosed(); - Clob clob = (Clob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + Clob clob = (Clob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.CLOB); loggerExternal.exiting(getClassNameLogging(), "getClob", clob); return clob; @@ -1349,7 +1349,7 @@ public NClob getNClob(int parameterIndex) throws SQLException { public NClob getNClob(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getNClob", parameterName); checkClosed(); - NClob nClob = (NClob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), + NClob nClob = (NClob) getValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), JDBCType.NCLOB); loggerExternal.exiting(getClassNameLogging(), "getNClob", nClob); return nClob; @@ -1364,7 +1364,7 @@ public Object getObject(int parameterIndex, java.util.Map> map) @Override public Object getObject(String parameterName, java.util.Map> m) throws SQLException { checkClosed(); - return getObject(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod), m); + return getObject(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD), m); } @Override @@ -1376,7 +1376,7 @@ public Ref getRef(int parameterIndex) throws SQLException { @Override public Ref getRef(String parameterName) throws SQLException { checkClosed(); - return getRef(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + return getRef(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD)); } @Override @@ -1388,7 +1388,7 @@ public java.sql.Array getArray(int parameterIndex) throws SQLException { @Override public java.sql.Array getArray(String parameterName) throws SQLException { checkClosed(); - return getArray(findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + return getArray(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD)); } /** @@ -1412,113 +1412,123 @@ private String stripLeadingAtSign(String columnName) { * @return the index */ private int findColumn(String columnName, CallableStatementGetterSetterMethod method) throws SQLServerException { - // If inOutParam is null, likely the statement was closed beforehand. if (null == inOutParam) { SQLServerException.makeFromDriverError(connection, this, SQLServerException.getErrString("R_statementIsClosed"), null, false); } - if (!isCursorable(executeMethod)) { - // handle `@name` as well as `name`, since `@name` is what's returned - // by DatabaseMetaData#getProcedureColumns - String columnNameWithoutAtSign = stripLeadingAtSign(columnName); + if (!connection.getUseFastCallableStatement() || isCursorable(executeMethod)) { + // Stored procedures with cursorable methods are not called directly, so we have to get the metadata + if (parameterNames == null) { + try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { + // Note we are concatenating the information from the passed in sql, not any arguments provided by the + // user + // if the user can execute the sql, any fragments of it is potentially executed via the meta data call + // through injection + // is not a security issue. + ThreePartName threePartName = ThreePartName.parse(procedureName); + StringBuilder metaQuery = new StringBuilder("exec sp_sproc_columns "); + if (null != threePartName.getDatabasePart()) { + metaQuery.append("@procedure_qualifier="); + metaQuery.append(threePartName.getDatabasePart()); + metaQuery.append(", "); + } + if (null != threePartName.getOwnerPart()) { + metaQuery.append("@procedure_owner="); + metaQuery.append(threePartName.getOwnerPart()); + metaQuery.append(", "); + } + if (null != threePartName.getProcedurePart()) { + // we should always have a procedure name part + metaQuery.append("@procedure_name="); + metaQuery.append(threePartName.getProcedurePart()); + metaQuery.append(" , @ODBCVer=3, @fUsePattern=0"); + } else { + // This should rarely happen, this will only happen if we can't find the stored procedure name + // invalidly formatted call syntax. + MessageFormat form = new MessageFormat( + SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); + Object[] msgArgs = {columnName, ""}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, + false); + } - for (int i = 0; i < inOutParam.length; i++) { - if (null != inOutParam[i].getName() - && inOutParam[i].getName().equalsIgnoreCase(columnNameWithoutAtSign)) { - return i + 1; + try (ResultSet rs = s.executeQueryInternal(metaQuery.toString())) { + parameterNames = new HashMap<>(); + insensitiveParameterNames = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + int columnIndex = 0; + while (rs.next()) { + String p = rs.getString(4).trim(); + parameterNames.put(p, columnIndex); + insensitiveParameterNames.put(p, columnIndex++); + } + } + } catch (SQLException e) { + SQLServerException.makeFromDriverError(connection, this, e.toString(), null, false); } } - } - // Stored procedures with cursorable methods are not called directly, so we have to get the metadata - if (parameterNames == null) { - try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { - // Note we are concatenating the information from the passed in sql, not any arguments provided by the - // user - // if the user can execute the sql, any fragments of it is potentially executed via the meta data call - // through injection - // is not a security issue. - ThreePartName threePartName = ThreePartName.parse(procedureName); - StringBuilder metaQuery = new StringBuilder("exec sp_sproc_columns "); - if (null != threePartName.getDatabasePart()) { - metaQuery.append("@procedure_qualifier="); - metaQuery.append(threePartName.getDatabasePart()); - metaQuery.append(", "); - } - if (null != threePartName.getOwnerPart()) { - metaQuery.append("@procedure_owner="); - metaQuery.append(threePartName.getOwnerPart()); - metaQuery.append(", "); - } - if (null != threePartName.getProcedurePart()) { - // we should always have a procedure name part - metaQuery.append("@procedure_name="); - metaQuery.append(threePartName.getProcedurePart()); - metaQuery.append(" , @ODBCVer=3, @fUsePattern=0"); - } else { - // This should rarely happen, this will only happen if we can't find the stored procedure name - // invalidly formatted call syntax. - MessageFormat form = new MessageFormat( - SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); - Object[] msgArgs = {columnName, ""}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, - false); - } + // If the server didn't return anything (eg. the param names for the sp_sproc_columns), user might not + // have required permissions to view all the parameterNames. And, there's also the case depending on the permissions, + // @RETURN_VALUE may or may not be present. So, the parameterNames list might have an additional +1 parameter. + if (null != parameterNames && parameterNames.size() <= 1) { + return map.computeIfAbsent(columnName, ifAbsent -> ai.incrementAndGet()); + } - try (ResultSet rs = s.executeQueryInternal(metaQuery.toString())) { - parameterNames = new HashMap<>(); - insensitiveParameterNames = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); - int columnIndex = 0; - while (rs.next()) { - String p = rs.getString(4).trim(); - parameterNames.put(p, columnIndex); - insensitiveParameterNames.put(p, columnIndex++); - } - } - } catch (SQLException e) { - SQLServerException.makeFromDriverError(connection, this, e.toString(), null, false); + // handle `@name` as well as `name`, since `@name` is what's returned + // by DatabaseMetaData#getProcedureColumns + String columnNameWithSign = columnName.startsWith("@") ? columnName : "@" + columnName; + + // In order to be as accurate as possible when locating parameter name + // indexes, as well as be deterministic when running on various client + // locales, we search for parameter names using the following scheme: + + // 1. Search using case-sensitive non-locale specific (binary) compare first. + // 2. Search using case-insensitive, non-locale specific (binary) compare last. + int matchPos = (parameterNames != null && parameterNames.containsKey(columnNameWithSign)) ? parameterNames + .get(columnNameWithSign) : -1; + if (matchPos == -1 && insensitiveParameterNames.containsKey(columnNameWithSign)) { + matchPos = insensitiveParameterNames.get(columnNameWithSign); } - } - // If the server didn't return anything (eg. the param names for the sp_sproc_columns), user might not - // have required permissions to view all the parameterNames. And, there's also the case depending on the permissions, - // @RETURN_VALUE may or may not be present. So, the parameterNames list might have an additional +1 parameter. - if (null != parameterNames && parameterNames.size() <= 1) { - return map.computeIfAbsent(columnName, ifAbsent -> ai.incrementAndGet()); - } + if (matchPos == -1) { + MessageFormat form = new MessageFormat( + SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); + Object[] msgArgs = {columnName, procedureName}; + SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, false); + } - // handle `@name` as well as `name`, since `@name` is what's returned - // by DatabaseMetaData#getProcedureColumns - String columnNameWithSign = columnName.startsWith("@") ? columnName : "@" + columnName; + // @RETURN_VALUE is always in the list. If the user uses return value ?=call(@p1) syntax then + // @p1 is index 2 otherwise its index 1. + if (bReturnValueSyntax) // 3.2717 + return matchPos + 1; + else + return matchPos; + } - // In order to be as accurate as possible when locating parameter name - // indexes, as well as be deterministic when running on various client - // locales, we search for parameter names using the following scheme: + String columnNameWithoutAtSign = stripLeadingAtSign(columnName); - // 1. Search using case-sensitive non-locale specific (binary) compare first. - // 2. Search using case-insensitive, non-locale specific (binary) compare last. - int matchPos = (parameterNames != null && parameterNames.containsKey(columnNameWithSign)) ? parameterNames - .get(columnNameWithSign) : -1; - if (matchPos == -1 && insensitiveParameterNames.containsKey(columnNameWithSign)) { - matchPos = insensitiveParameterNames.get(columnNameWithSign); + if (method == CallableStatementGetterSetterMethod.IS_SETTER_METHOD) { + for (int i = 0; i < inOutParam.length; i++) { + // if it is not already registered as output param or the parameter is not an input parameter, then + // set the param name and return index. + if (null == inOutParam[i].getName() && !inOutParam[i].isReturnValue() + && null == inOutParam[i].getInputDTV() && null == inOutParam[i].getRegisteredOutDTV()) { + inOutParam[i].setName(columnNameWithoutAtSign); + return i + 1; + } + } } - if (matchPos == -1) { - MessageFormat form = new MessageFormat( - SQLServerException.getErrString("R_parameterNotDefinedForProcedure")); - Object[] msgArgs = {columnName, procedureName}; - SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, false); + for (int i = 0; i < inOutParam.length; i++) { + if (null != inOutParam[i].getName() + && inOutParam[i].getName().equalsIgnoreCase(columnNameWithoutAtSign)) { + return i + 1; + } } - // @RETURN_VALUE is always in the list. If the user uses return value ?=call(@p1) syntax then - // @p1 is index 2 otherwise its index 1. - if (bReturnValueSyntax) // 3.2717 - return matchPos + 1; - else - return matchPos; - + return -1; } @Override @@ -1528,7 +1538,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1540,7 +1550,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, Calenda loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); } @@ -1550,7 +1560,7 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIME, value, JavaType.TIME, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1562,7 +1572,7 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIME, value, JavaType.TIME, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1572,7 +1582,7 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATE, value, JavaType.DATE, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1584,7 +1594,7 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATE, value, JavaType.DATE, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1594,7 +1604,7 @@ public final void setCharacterStream(String parameterName, Reader value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.CHARACTER, value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1605,7 +1615,7 @@ public final void setCharacterStream(String parameterName, Reader value, int len loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1616,7 +1626,7 @@ public final void setCharacterStream(String parameterName, Reader value, long le loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); } @@ -1626,7 +1636,7 @@ public final void setNCharacterStream(String parameterName, Reader value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.NCHARACTER, value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1637,7 +1647,7 @@ public final void setNCharacterStream(String parameterName, Reader value, long l loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.NCHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); } @@ -1647,7 +1657,7 @@ public final void setClob(String parameterName, Clob value) throws SQLException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.CLOB, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.CLOB, value, JavaType.CLOB, false); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1657,7 +1667,7 @@ public final void setClob(String parameterName, Reader value) throws SQLExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.CHARACTER, value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1667,7 +1677,7 @@ public final void setClob(String parameterName, Reader value, long length) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.CHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setClob"); } @@ -1677,7 +1687,7 @@ public final void setNClob(String parameterName, NClob value) throws SQLExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NCLOB, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.NCLOB, value, JavaType.NCLOB, false); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1687,7 +1697,7 @@ public final void setNClob(String parameterName, Reader value) throws SQLExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.NCHARACTER, value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1697,7 +1707,7 @@ public final void setNClob(String parameterName, Reader value, long length) thro if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.NCHARACTER, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.NCHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNClob"); } @@ -1707,7 +1717,7 @@ public final void setNString(String parameterName, String value) throws SQLExcep if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.NVARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1718,7 +1728,7 @@ public final void setNString(String parameterName, String value, boolean forceEn loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.NVARCHAR, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setNString"); } @@ -1728,7 +1738,7 @@ public void setObject(String parameterName, Object value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value}); checkClosed(); - setObjectNoType(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value, false); + setObjectNoType(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), value, false); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1740,14 +1750,14 @@ public void setObject(String parameterName, Object value, int sqlType) throws SQ checkClosed(); if (microsoft.sql.Types.STRUCTURED == sqlType) { tvpName = getTVPNameFromObject( - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), value); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), value); + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD)), value, JavaType.TVP, JDBCType.TVP, null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), tvpName); } else - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD)), value, JavaType.of(value), JDBCType.of(sqlType), null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), tvpName); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), tvpName); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1757,9 +1767,9 @@ public void setObject(String parameterName, Object value, int sqlType, int decim loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType, decimals}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD)), value, JavaType.of(value), JDBCType.of(sqlType), decimals, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1775,10 +1785,10 @@ public void setObject(String parameterName, Object value, int sqlType, int decim // this is the number of digits after the decimal point. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD)), value, JavaType.of(value), JDBCType.of(sqlType), (java.sql.Types.NUMERIC == sqlType || java.sql.Types.DECIMAL == sqlType) ? decimals : null, null, - forceEncrypt, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + forceEncrypt, findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1796,11 +1806,11 @@ public final void setObject(String parameterName, Object value, int targetSqlTyp // InputStream and Reader, this is the length of the data in the stream or reader. // For all other types, this value will be ignored. - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), value, + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD)), value, JavaType.of(value), JDBCType.of(targetSqlType), (java.sql.Types.NUMERIC == targetSqlType || java.sql.Types.DECIMAL == targetSqlType || InputStream.class.isInstance(value) || Reader.class.isInstance(value)) ? scale : null, - precision, false, findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + precision, false, findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), null); loggerExternal.exiting(getClassNameLogging(), "setObject"); } @@ -1810,7 +1820,7 @@ public final void setAsciiStream(String parameterName, InputStream value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.ASCII, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1821,7 +1831,7 @@ public final void setAsciiStream(String parameterName, InputStream value, int le loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1832,7 +1842,7 @@ public final void setAsciiStream(String parameterName, InputStream value, long l loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.ASCII, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); } @@ -1842,7 +1852,7 @@ public final void setBinaryStream(String parameterName, InputStream value) throw if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.BINARY, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1853,7 +1863,7 @@ public final void setBinaryStream(String parameterName, InputStream value, int l loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1864,7 +1874,7 @@ public final void setBinaryStream(String parameterName, InputStream value, long loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); } @@ -1874,7 +1884,7 @@ public final void setBlob(String parameterName, Blob inputStream) throws SQLExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BLOB, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.BLOB, inputStream, JavaType.BLOB, false); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1884,7 +1894,7 @@ public final void setBlob(String parameterName, InputStream value) throws SQLExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, value}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.BINARY, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1895,7 +1905,7 @@ public final void setBlob(String parameterName, InputStream inputStream, long le loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream, length}); checkClosed(); - setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), StreamType.BINARY, + setStream(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBlob"); } @@ -1905,7 +1915,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1915,7 +1925,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1927,7 +1937,7 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIMESTAMP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); } @@ -1937,7 +1947,7 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1948,7 +1958,7 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1960,7 +1970,7 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIMEOFFSET, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); } @@ -1970,7 +1980,7 @@ public void setDate(String parameterName, java.sql.Date value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATE, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATE, value, JavaType.DATE, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); } @@ -1980,7 +1990,7 @@ public void setTime(String parameterName, java.sql.Time value) throws SQLServerE if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIME, value, JavaType.TIME, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -1990,7 +2000,7 @@ public void setTime(String parameterName, java.sql.Time value, int scale) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIME, value, JavaType.TIME, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -2002,7 +2012,7 @@ public void setTime(String parameterName, java.sql.Time value, int scale, loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TIME, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TIME, value, JavaType.TIME, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); } @@ -2012,7 +2022,7 @@ public void setDateTime(String parameterName, java.sql.Timestamp value) throws S if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -2024,7 +2034,7 @@ public void setDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DATETIME, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); } @@ -2034,7 +2044,7 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value) thr if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -2046,7 +2056,7 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value, loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLDATETIME, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); } @@ -2056,7 +2066,7 @@ public void setUniqueIdentifier(String parameterName, String guid) throws SQLSer if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.GUID, guid, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -2067,7 +2077,7 @@ public void setUniqueIdentifier(String parameterName, String guid, boolean force loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.GUID, guid, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); } @@ -2077,7 +2087,7 @@ public void setBytes(String parameterName, byte[] value) throws SQLServerExcepti if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.BINARY, value, JavaType.BYTEARRAY, false); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2088,7 +2098,7 @@ public void setBytes(String parameterName, byte[] value, boolean forceEncrypt) t loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BINARY, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.BINARY, value, JavaType.BYTEARRAY, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBytes"); } @@ -2098,7 +2108,7 @@ public void setByte(String parameterName, byte value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TINYINT, value, JavaType.BYTE, false); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2109,7 +2119,7 @@ public void setByte(String parameterName, byte value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TINYINT, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TINYINT, value, JavaType.BYTE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setByte"); } @@ -2119,7 +2129,7 @@ public void setString(String parameterName, String value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.VARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2130,7 +2140,7 @@ public void setString(String parameterName, String value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.VARCHAR, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.VARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setString"); } @@ -2140,7 +2150,7 @@ public void setMoney(String parameterName, BigDecimal value) throws SQLServerExc if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.MONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2151,7 +2161,7 @@ public void setMoney(String parameterName, BigDecimal value, boolean forceEncryp loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.MONEY, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.MONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setMoney"); } @@ -2161,7 +2171,7 @@ public void setSmallMoney(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2172,7 +2182,7 @@ public void setSmallMoney(String parameterName, BigDecimal value, boolean forceE loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLMONEY, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); } @@ -2182,7 +2192,7 @@ public void setBigDecimal(String parameterName, BigDecimal value) throws SQLServ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2194,7 +2204,7 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2206,7 +2216,7 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value, precision, scale, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DECIMAL, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); } @@ -2216,7 +2226,7 @@ public void setDouble(String parameterName, double value) throws SQLServerExcept if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DOUBLE, value, JavaType.DOUBLE, false); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2227,7 +2237,7 @@ public void setDouble(String parameterName, double value, boolean forceEncrypt) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.DOUBLE, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.DOUBLE, value, JavaType.DOUBLE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDouble"); } @@ -2237,7 +2247,7 @@ public void setFloat(String parameterName, float value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.REAL, value, JavaType.FLOAT, false); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2248,7 +2258,7 @@ public void setFloat(String parameterName, float value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.REAL, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.REAL, value, JavaType.FLOAT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setFloat"); } @@ -2258,7 +2268,7 @@ public void setInt(String parameterName, int value) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.INTEGER, value, JavaType.INTEGER, false); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2268,7 +2278,7 @@ public void setInt(String parameterName, int value, boolean forceEncrypt) throws if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.INTEGER, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setInt"); } @@ -2278,7 +2288,7 @@ public void setLong(String parameterName, long value) throws SQLServerException if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.BIGINT, value, JavaType.LONG, false); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2289,7 +2299,7 @@ public void setLong(String parameterName, long value, boolean forceEncrypt) thro loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIGINT, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.BIGINT, value, JavaType.LONG, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setLong"); } @@ -2299,7 +2309,7 @@ public void setShort(String parameterName, short value) throws SQLServerExceptio if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.SMALLINT, value, JavaType.SHORT, false); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2310,7 +2320,7 @@ public void setShort(String parameterName, short value, boolean forceEncrypt) th loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.SMALLINT, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.SMALLINT, value, JavaType.SHORT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setShort"); } @@ -2320,7 +2330,7 @@ public void setBoolean(String parameterName, boolean value) throws SQLServerExce if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.BIT, value, JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2331,7 +2341,7 @@ public void setBoolean(String parameterName, boolean value, boolean forceEncrypt loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.BIT, value, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.BIT, value, JavaType.BOOLEAN, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); } @@ -2341,9 +2351,9 @@ public void setNull(String parameterName, int nType) throws SQLServerException { if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), null); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), null); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2352,9 +2362,9 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType, sTypeName}); checkClosed(); - setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod)), null, + setObject(setterGetParam(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, false, - findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sTypeName); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), sTypeName); loggerExternal.exiting(getClassNameLogging(), "setNull"); } @@ -2362,20 +2372,20 @@ public void setNull(String parameterName, int nType, String sTypeName) throws SQ public void setURL(String parameterName, URL url) throws SQLException { loggerExternal.entering(getClassNameLogging(), "setURL", parameterName); checkClosed(); - setURL(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), url); + setURL(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), url); loggerExternal.exiting(getClassNameLogging(), "setURL"); } @Override public final void setStructured(String parameterName, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataTable}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @@ -2383,13 +2393,13 @@ public final void setStructured(String parameterName, String tvpName, @Override public final void setStructured(String parameterName, String tvpName, ResultSet tvpResultSet) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpResultSet}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @@ -2397,13 +2407,13 @@ public final void setStructured(String parameterName, String tvpName, @Override public final void setStructured(String parameterName, String tvpName, ISQLServerDataRecord tvpDataRecord) throws SQLServerException { - tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), + tvpName = getTVPNameIfNull(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {parameterName, tvpName, tvpDataRecord}); checkClosed(); - setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), JDBCType.TVP, + setValue(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), JDBCType.TVP, tvpDataRecord, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); } @@ -2425,7 +2435,7 @@ public final void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLEx if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterName, xmlObject}); checkClosed(); - setSQLXMLInternal(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), xmlObject); + setSQLXMLInternal(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), xmlObject); loggerExternal.exiting(getClassNameLogging(), "setSQLXML"); } @@ -2443,7 +2453,7 @@ public final SQLXML getSQLXML(String parameterName) throws SQLException { loggerExternal.entering(getClassNameLogging(), "getSQLXML", parameterName); checkClosed(); SQLServerSQLXML value = (SQLServerSQLXML) getSQLXMLInternal( - findColumn(parameterName, CallableStatementGetterSetterMethod.isGetterMethod)); + findColumn(parameterName, CallableStatementGetterSetterMethod.IS_GETTER_METHOD)); loggerExternal.exiting(getClassNameLogging(), "getSQLXML", value); return value; } @@ -2471,7 +2481,7 @@ public void registerOutParameter(String parameterName, int sqlType, String typeN loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, typeName}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), sqlType, typeName); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2482,7 +2492,7 @@ public void registerOutParameter(String parameterName, int sqlType, int scale) t loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), sqlType, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2494,7 +2504,7 @@ public void registerOutParameter(String parameterName, int sqlType, int precisio loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType, scale}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType, + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), sqlType, precision, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } @@ -2505,7 +2515,7 @@ public void registerOutParameter(String parameterName, int sqlType) throws SQLSe loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType}); checkClosed(); - registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.isSetterMethod), sqlType); + registerOutParameter(findColumn(parameterName, CallableStatementGetterSetterMethod.IS_SETTER_METHOD), sqlType); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index 6972ad893..f840e0922 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -164,6 +164,9 @@ public class SQLServerConnection implements ISQLServerConnection, java.io.Serial /** Flag that determines whether the accessToken callback was set **/ private transient SQLServerAccessTokenCallback accessTokenCallback = null; + /** Flag indicating whether to use sp_sproc_columns for parameter name lookup */ + private boolean useFastCallableStatements = SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue(); + /** * Keep this distinct from _federatedAuthenticationRequested, since some fedauth library types may not need more * info @@ -2312,6 +2315,15 @@ Connection connectInternal(Properties propsIn, } trustServerCertificate = isBooleanPropertyOn(sPropKey, sPropValue); + sPropKey = SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(); + sPropValue = activeConnectionProperties.getProperty(sPropKey); + if (null == sPropValue) { + sPropValue = Boolean + .toString(SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue()); + activeConnectionProperties.setProperty(sPropKey, sPropValue); + } + useFastCallableStatements = isBooleanPropertyOn(sPropKey, sPropValue); + // Set requestedEncryptionLevel according to the value of the encrypt connection property if (encryptOption.compareToIgnoreCase(EncryptOption.FALSE.toString()) == 0) { requestedEncryptionLevel = TDS.ENCRYPT_OFF; @@ -7831,6 +7843,24 @@ public void setAccessTokenCallbackClass(String accessTokenCallbackClass) { this.accessTokenCallbackClass = accessTokenCallbackClass; } + /** + * Returns whether or not sp_sproc_columns is being used for parameter name lookup. + * + * @return useFastCallableStatements + */ + public boolean getUseFastCallableStatement() { + return this.useFastCallableStatements; + } + + /** + * Sets whether or not sp_sproc_columns will be used for parameter name lookup. + * + * @return useFastCallableStatements + */ + public void setUseFastCallableStatements(boolean useFastCallableStatements) { + this.useFastCallableStatements = useFastCallableStatements; + } + /** * Cleans up discarded prepared statement handles on the server using batched un-prepare actions if the batching * threshold has been reached. diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java index 52182bbfd..477eaca22 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java @@ -250,6 +250,17 @@ public boolean getUseDefaultGSSCredential() { SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.getDefaultValue()); } + @Override + public void setUseFastCallableStatements(boolean enable) { + setBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(), enable); + } + + @Override + public boolean getUseFastCallableStatements() { + return getBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(), + SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue()); + } + @Override public void setAccessToken(String accessToken) { setStringProperty(connectionProps, SQLServerDriverStringProperty.ACCESS_TOKEN.toString(), accessToken); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java index fc4b1f73a..278888901 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java @@ -695,7 +695,8 @@ enum SQLServerDriverBooleanProperty { SEND_TEMPORAL_DATATYPES_AS_STRING_FOR_BULK_COPY("sendTemporalDataTypesAsStringForBulkCopy", true), DELAY_LOADING_LOBS("delayLoadingLobs", true), USE_DEFAULT_JAAS_CONFIG("useDefaultJaasConfig", false), - USE_DEFAULT_GSS_CREDENTIAL("useDefaultGSSCredential", false); + USE_DEFAULT_GSS_CREDENTIAL("useDefaultGSSCredential", false), + USE_FAST_CALLABLESTATEMENTS("useFastCallableStatements", false); private final String name; private final boolean defaultValue; @@ -772,6 +773,9 @@ public final class SQLServerDriver implements java.sql.Driver { new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.toString(), Boolean.toString(SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.getDefaultValue()), false, TRUE_FALSE), + new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(), + Boolean.toString(SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue()), false, + TRUE_FALSE), new SQLServerDriverPropertyInfo(SQLServerDriverStringProperty.KEY_STORE_AUTHENTICATION.toString(), SQLServerDriverStringProperty.KEY_STORE_AUTHENTICATION.getDefaultValue(), false, new String[] {KeyStoreAuthentication.JAVA_KEYSTORE_PASSWORD.toString()}), diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java index effb8ae6d..82b7baa3b 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java @@ -198,6 +198,7 @@ protected Object[][] getContents() { {"R_disableStatementPoolingPropertyDescription", "Disables the statement pooling feature."}, {"R_integratedSecurityPropertyDescription", "Indicates whether Windows authentication will be used to connect to SQL Server."}, {"R_useDefaultGSSCredentialPropertyDescription", "Indicates whether GSSCredential will be created using native GSS-API."}, + {"R_useFastCallableStatementsPropertyDescription", "Indicates whether sp_sproc_columns will be used for parameter name lookup when setting or registering parameters for callable statements."}, {"R_authenticationSchemePropertyDescription", "The authentication scheme to be used for integrated authentication."}, {"R_lockTimeoutPropertyDescription", "The number of milliseconds to wait before the database reports a lock time-out."}, {"R_connectRetryCountPropertyDescription", "The number of reconnection attempts if there is a connection failure."}, 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 7fc36fedc..f34b15f2a 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -396,6 +396,7 @@ public void testNonOrderedRegisteringAndSettingOfParams() throws SQLException { String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; try (CallableStatement cstmt = connection.prepareCall(call)) { + connection.setUseFastCallableStatements(true); int scale = 6; Double obj1 = 2015.0123; Double obj2 = 2015.012345; From 6c86610f29b1325c6bf7bd45401f1c0580dbf383 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 15:19:25 -0800 Subject: [PATCH 34/51] Deleted DTC test --- .../com/microsoft/sqlserver/jdbc/DTCTest.java | 113 ------------------ 1 file changed, 113 deletions(-) delete mode 100644 src/test/java/com/microsoft/sqlserver/jdbc/DTCTest.java diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/DTCTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/DTCTest.java deleted file mode 100644 index 3b7d2be8d..000000000 --- a/src/test/java/com/microsoft/sqlserver/jdbc/DTCTest.java +++ /dev/null @@ -1,113 +0,0 @@ -package com.microsoft.sqlserver.jdbc; - -import com.microsoft.sqlserver.testframework.AbstractTest; -import com.microsoft.sqlserver.testframework.Constants; -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 javax.sql.XAConnection; -import javax.transaction.xa.XAResource; -import javax.transaction.xa.Xid; -import java.net.Inet4Address; -import java.sql.Connection; -import java.util.Random; - - -@RunWith(JUnitPlatform.class) -@Tag(Constants.DTC) -public class DTCTest extends AbstractTest { - @BeforeAll - public static void setupTest() throws Exception { - setConnection(); - } - - @Test - public void testXaStartXpSqljdbcXaInit() throws Exception { - SQLServerXADataSource XADataSource = new SQLServerXADataSource(); - XADataSource.setURL(connectionString); - XAConnection XAConnection = XADataSource.getXAConnection(); - - try (Connection con = XAConnection.getConnection()) { - XAResource xaRes = null; - Xid xid = null; - xid = XidImpl.getUniqueXid(1); - - xaRes = XAConnection.getXAResource(); - xaRes.setTransactionTimeout(0); - - // Driver calls 'master..xp_sqljdbc_xa_init_ex(?,?,?)' internally as a cstmt. - // Test that the registered out params are sent over the wire as non-PLP. - // If the RPC params are sent as PLP, test will fail with the following error: - // Failed to create the XA control connection. Error: "Cannot continue the execution because the - // session is in the kill state. - xaRes.start(xid, XAResource.TMNOFLAGS); - } - } - - static class XidImpl implements Xid { - public int formatId; - public byte[] gtrid; - public byte[] bqual; - static byte[] localIP = null; - static int txnUniqueID = 0; - - public byte[] getGlobalTransactionId() { - return gtrid; - } - - public byte[] getBranchQualifier() { - return bqual; - } - - public int getFormatId() { - return formatId; - } - - XidImpl(int formatId, byte[] gtrid, byte[] bqual) { - this.formatId = formatId; - this.gtrid = gtrid; - this.bqual = bqual; - } - - static Xid getUniqueXid(int tid) { - - Random rnd = new Random(System.currentTimeMillis()); - txnUniqueID++; - int txnUID = txnUniqueID; - int tidID = tid; - int randID = rnd.nextInt(); - byte[] gtrid = new byte[64]; - byte[] bqual = new byte[64]; - - if (null == localIP) { - try { - localIP = Inet4Address.getLocalHost().getAddress(); - } catch (Exception ex) { - localIP = new byte[] {0x01, 0x02, 0x03, 0x04}; - } - } - - System.arraycopy(localIP, 0, gtrid, 0, 4); - System.arraycopy(localIP, 0, bqual, 0, 4); - - // Bytes 4 -> 7 - unique transaction id. - // Bytes 8 ->11 - thread id. - // Bytes 12->15 - random number generated by using seed from current time in milliseconds. - for (int i = 0; i <= 3; i++) { - gtrid[i + 4] = (byte) (txnUID % 0x100); - bqual[i + 4] = (byte) (txnUID % 0x100); - txnUID >>= 8; - gtrid[i + 8] = (byte) (tidID % 0x100); - bqual[i + 8] = (byte) (tidID % 0x100); - tidID >>= 8; - gtrid[i + 12] = (byte) (randID % 0x100); - bqual[i + 12] = (byte) (randID % 0x100); - randID >>= 8; - } - return new DTCTest.XidImpl(0x1234, gtrid, bqual); - } - } -} From f616f72443c930c5dd5affe3a22cbd9a898a3cc4 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 15:21:15 -0800 Subject: [PATCH 35/51] Removed non-driver error from TestResource --- src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java | 2 -- .../jdbc/callablestatement/CallableStatementTest.java | 3 +-- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java index 8416127d1..01816b698 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java @@ -78,8 +78,6 @@ protected Object[][] getContents() { {"R_supportUnwrapping", "{0} supports unwrapping."}, {"R_cantAccessSnapshot", "Cant access the TRANSACTION_SNAPSHOT "}, {"R_newConnectionShouldBeValid", "Newly created connection should be valid"}, - {"R_outputParamCastError", - "class java.lang.Integer cannot be cast to class [B (java.lang.Integer and [B are in module java.base of loader 'bootstrap')"}, {"R_closedConnectionShouldBeInvalid", "Closed connection should be invalid"}, {"R_noExceptionNegativeTimeout", "No exception thrown with negative timeout"}, {"R_noExceptionClosedConnection", 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 f34b15f2a..e79d36c2f 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -386,8 +386,7 @@ public void testSprocCastingError() throws SQLException { cs.getBytes(1); fail(TestResource.getResource("R_expectedFailPassed")); } catch (Exception e) { - assertTrue(e.getMessage().equals(TestResource.getResource("R_outputParamCastError")) - || e.getMessage().contains("cannot be cast to")); + assertTrue(e.getMessage().contains("cannot be cast to")); } } From c87fc0641010032992cfac7dc970b2f0f55771c1 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 15:37:12 -0800 Subject: [PATCH 36/51] Fixed switch case for date/time types in dtv class --- .../microsoft/sqlserver/jdbc/IOBuffer.java | 1 + .../com/microsoft/sqlserver/jdbc/dtv.java | 57 +++++++++++-------- .../CallableStatementTest.java | 1 - 3 files changed, 34 insertions(+), 25 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java index 1408a9d32..098d94763 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java @@ -465,6 +465,7 @@ static final String getEncryptionLevel(int level) { final static int COLINFO_STATUS_DIFFERENT_NAME = 0x20; final static int MAX_FRACTIONAL_SECONDS_SCALE = 7; + final static int DEFAULT_FRACTIONAL_SECONDS_SCALE = 3; final static Timestamp MAX_TIMESTAMP = Timestamp.valueOf("2079-06-06 23:59:59"); final static Timestamp MIN_TIMESTAMP = Timestamp.valueOf("1900-01-01 00:00:00"); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java index 3b3ce7b8f..008912787 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java @@ -847,44 +847,53 @@ private void sendTemporal(DTV dtv, JavaType javaType, Object value) throws SQLSe switch (jdbcType) { case DATETIME: - case SMALLDATETIME: - case TIMESTAMP: if (null != cryptoMeta) { - if ((JDBCType.DATETIME == jdbcType) || (JDBCType.SMALLDATETIME == jdbcType)) { - tdsWriter.writeEncryptedRPCDateTime(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, isOutParam, jdbcType, statement); - } else if (0 == valueLength) { - tdsWriter.writeEncryptedRPCDateTime2(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, outScale, isOutParam, statement); + tdsWriter.writeEncryptedRPCDateTime(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, isOutParam, jdbcType, statement); } else { - tdsWriter.writeEncryptedRPCDateTime2(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, (valueLength), isOutParam, statement); - } - } else { - if (jdbcType == JDBCType.SMALLDATETIME) { - tdsWriter.writeRPCDateTime(name, - timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, isOutParam); - - } else if (jdbcType == JDBCType.DATETIME) { if (conn.getDatetimeParameterType().equals(DatetimeType.DATETIME2.toString())) { tdsWriter.writeRPCDateTime2(name, timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, 3, isOutParam); + subSecondNanos, TDS.DEFAULT_FRACTIONAL_SECONDS_SCALE, isOutParam); } else if (conn.getDatetimeParameterType() .equals(DatetimeType.DATETIME.toString())) { tdsWriter.writeRPCDateTime(name, timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), subSecondNanos, isOutParam); } + } + + break; + + case SMALLDATETIME: + if (null != cryptoMeta) { + tdsWriter.writeEncryptedRPCDateTime(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, isOutParam, jdbcType, statement); + } else { + tdsWriter.writeRPCDateTime(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, isOutParam); + } + + break; + + case TIMESTAMP: + if (null != cryptoMeta) { + if (0 == valueLength) { + tdsWriter.writeEncryptedRPCDateTime2(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, outScale, isOutParam, statement); } else { - tdsWriter.writeRPCDateTime2(name, + tdsWriter.writeEncryptedRPCDateTime2(name, timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), - subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); + subSecondNanos, (valueLength), isOutParam, statement); } + } else { + tdsWriter.writeRPCDateTime2(name, + timestampNormalizedCalendar(calendar, javaType, conn.baseYear()), + subSecondNanos, TDS.MAX_FRACTIONAL_SECONDS_SCALE, isOutParam); } break; 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 e79d36c2f..d003e908a 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -395,7 +395,6 @@ public void testNonOrderedRegisteringAndSettingOfParams() throws SQLException { String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; try (CallableStatement cstmt = connection.prepareCall(call)) { - connection.setUseFastCallableStatements(true); int scale = 6; Double obj1 = 2015.0123; Double obj2 = 2015.012345; From 0ea9e60c312d4d63119b3948100afabbe8f3255b Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 16:15:22 -0800 Subject: [PATCH 37/51] SQLServerConnTest and RequestBoundaryMethodTest update --- .../com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java | 4 ++++ .../sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java | 2 ++ 2 files changed, 6 insertions(+) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java index 0ed94e3a6..17526b306 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java @@ -205,6 +205,10 @@ public void testDataSource() throws SQLServerException { assertEquals(booleanPropValue, ds.getUseDefaultGSSCredential(), TestResource.getResource("R_valuesAreDifferent")); + ds.setUseFastCallableStatements(booleanPropValue); + assertEquals(booleanPropValue, ds.getUseFastCallableStatements(), + TestResource.getResource("R_valuesAreDifferent")); + ds.setServerCertificate(stringPropValue); assertEquals(stringPropValue, ds.getServerCertificate(), TestResource.getResource("R_valuesAreDifferent")); 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 d0ce25564..baa78ea5d 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java @@ -504,6 +504,8 @@ private List getVerifiedMethodNames() { verifiedMethodNames.add("setMsiTokenCacheTtl"); verifiedMethodNames.add("getAccessTokenCallbackClass"); verifiedMethodNames.add("setAccessTokenCallbackClass"); + verifiedMethodNames.add("getUseFastCallableStatements"); + verifiedMethodNames.add("setUseFastCallableStatements"); return verifiedMethodNames; } } From dfceeffbdccc6a905b62c089ef00a816e1ec7c6f Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 16:42:57 -0800 Subject: [PATCH 38/51] Removed DTC test group --- pom.xml | 3 +-- .../java/com/microsoft/sqlserver/testframework/Constants.java | 2 -- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/pom.xml b/pom.xml index 84f4ec4be..36e773010 100644 --- a/pom.xml +++ b/pom.xml @@ -44,13 +44,12 @@ xAzureSQLMI - - - - For tests not compatible with Azure SQL Managed Instance NTLM - - - - - - - For tests using NTLM Authentication mode (excluded by default) kerberos - - - - - For tests using Kerberos authentication (excluded by default) - DTC - - - - - - - - For tests using MSDTC authentication (excluded by default) reqExternalSetup - For tests requiring external setup (excluded by default) clientCertAuth - - For tests requiring client certificate authentication setup (excluded by default) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Default testing enabled with SQL Server 2019 (SQLv15) --> - xSQLv12,xSQLv15,NTLM,MSI,reqExternalSetup,clientCertAuth,fedAuth,kerberos,DTC + xSQLv12,xSQLv15,NTLM,MSI,reqExternalSetup,clientCertAuth,fedAuth,kerberos -preview diff --git a/src/test/java/com/microsoft/sqlserver/testframework/Constants.java b/src/test/java/com/microsoft/sqlserver/testframework/Constants.java index a1eadf14c..92ba90811 100644 --- a/src/test/java/com/microsoft/sqlserver/testframework/Constants.java +++ b/src/test/java/com/microsoft/sqlserver/testframework/Constants.java @@ -26,7 +26,6 @@ private Constants() {} * xAzureSQLMI - - - - For tests not compatible with Azure SQL Managed Instance * NTLM - - - - - - - For NTLM tests * Kerberos - - - - - For Kerberos tests - * DTC - - - - - - - - For DTC tests * reqExternalSetup - For tests requiring external setup * clientCertAuth - - For tests requiring client certificate authentication setup * Fedauth - - - - - - For Fedauth tests @@ -44,7 +43,6 @@ private Constants() {} public static final String xAzureSQLMI = "xAzureSQLMI"; public static final String NTLM = "NTLM"; public static final String kerberos = "kerberos"; - public static final String DTC = "DTC"; public static final String MSI = "MSI"; public static final String reqExternalSetup = "reqExternalSetup"; public static final String clientCertAuth = "clientCertAuth"; From e3b2aa85dc07e887e2625a71d65e356885673be6 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Mon, 6 Nov 2023 17:04:56 -0800 Subject: [PATCH 39/51] Fixed docs/comments for new CS prop --- .../sqlserver/jdbc/ISQLServerDataSource.java | 13 +++++++------ .../sqlserver/jdbc/SQLServerConnection.java | 4 +++- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java index 816418751..fd80d16ba 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java @@ -610,17 +610,18 @@ public interface ISQLServerDataSource extends javax.sql.CommonDataSource { boolean getUseDefaultGSSCredential(); /** - * Sets the value to indicate whether useDefaultGSSCredential is enabled. + * Sets whether or not sp_sproc_columns will be used for parameter name lookup. * - * @param enable - * true if useDefaultGSSCredential is enabled. Otherwise, false. + * @param useFastCallableStatements + * When set to true, sp_sproc_columns is not used for parameter name lookup + * in callable statements. */ - void setUseFastCallableStatements(boolean enable); + void setUseFastCallableStatements(boolean useFastCallableStatements); /** - * Returns the useDefaultGSSCredential. + * Returns whether or not sp_sproc_columns is being used for parameter name lookup. * - * @return if enabled, return true. Otherwise, false. + * @return useFastCallableStatements */ boolean getUseFastCallableStatements(); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index f840e0922..ba4a9bfbf 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -7855,7 +7855,9 @@ public boolean getUseFastCallableStatement() { /** * Sets whether or not sp_sproc_columns will be used for parameter name lookup. * - * @return useFastCallableStatements + * @param useFastCallableStatements + * When set to true, sp_sproc_columns is not used for parameter name lookup + * in callable statements. */ public void setUseFastCallableStatements(boolean useFastCallableStatements) { this.useFastCallableStatements = useFastCallableStatements; From 245d17337730341fa04b2a76d7234a9837106e64 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Tue, 7 Nov 2023 12:37:55 -0800 Subject: [PATCH 40/51] Fixed setting/registering of when using only named parameters --- .../sqlserver/jdbc/SQLServerCallableStatement.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 8000ba61f..9df27eca3 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -1509,6 +1509,13 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me String columnNameWithoutAtSign = stripLeadingAtSign(columnName); + for (int i = 0; i < inOutParam.length; i++) { + if (null != inOutParam[i].getName() + && inOutParam[i].getName().equalsIgnoreCase(columnNameWithoutAtSign)) { + return i + 1; + } + } + if (method == CallableStatementGetterSetterMethod.IS_SETTER_METHOD) { for (int i = 0; i < inOutParam.length; i++) { // if it is not already registered as output param or the parameter is not an input parameter, then @@ -1521,13 +1528,6 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me } } - for (int i = 0; i < inOutParam.length; i++) { - if (null != inOutParam[i].getName() - && inOutParam[i].getName().equalsIgnoreCase(columnNameWithoutAtSign)) { - return i + 1; - } - } - return -1; } From 9c097810ffb6ae5d8d2b1bfb8c69b307f8d445e5 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Tue, 7 Nov 2023 16:30:48 -0800 Subject: [PATCH 41/51] RPC call check considers whether the call is an internal encryption query call --- .../microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index 659883757..c9fed9d7a 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -1206,7 +1206,7 @@ else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCal */ boolean callRPCDirectly(Parameter[] params) throws SQLServerException { int paramCount = SQLServerConnection.countParams(userSQL); - return (null != procedureName && paramCount != 0 && !isTVPType(params)); + return (null != procedureName && paramCount != 0 && !isTVPType(params) && !isInternalEncryptionQuery); } /** From 4099b84d148b6e7c0ad969cb98b46e28011fa65b Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Tue, 7 Nov 2023 16:45:57 -0800 Subject: [PATCH 42/51] Switched from useFastCallableStatements to useFlexibleCallableStatements --- .../sqlserver/jdbc/ISQLServerDataSource.java | 8 ++++---- .../jdbc/SQLServerCallableStatement.java | 2 +- .../sqlserver/jdbc/SQLServerConnection.java | 20 +++++++++---------- .../sqlserver/jdbc/SQLServerDataSource.java | 10 +++++----- .../sqlserver/jdbc/SQLServerDriver.java | 6 +++--- .../sqlserver/jdbc/SQLServerResource.java | 2 +- .../jdbc/SQLServerConnectionTest.java | 4 ++-- .../RequestBoundaryMethodsTest.java | 4 ++-- 8 files changed, 28 insertions(+), 28 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java index fd80d16ba..beb26a644 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java @@ -612,18 +612,18 @@ public interface ISQLServerDataSource extends javax.sql.CommonDataSource { /** * Sets whether or not sp_sproc_columns will be used for parameter name lookup. * - * @param useFastCallableStatements + * @param useFlexibleCallableStatements * When set to true, sp_sproc_columns is not used for parameter name lookup * in callable statements. */ - void setUseFastCallableStatements(boolean useFastCallableStatements); + void setUseFlexibleCallableStatements(boolean useFlexibleCallableStatements); /** * Returns whether or not sp_sproc_columns is being used for parameter name lookup. * - * @return useFastCallableStatements + * @return useFlexibleCallableStatements */ - boolean getUseFastCallableStatements(); + boolean getUseFlexibleCallableStatements(); /** * Sets the GSSCredential. diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 9df27eca3..beba1b52c 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -1418,7 +1418,7 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me SQLServerException.getErrString("R_statementIsClosed"), null, false); } - if (!connection.getUseFastCallableStatement() || isCursorable(executeMethod)) { + if (connection.geUseFlexibleCallableStatements() || isCursorable(executeMethod)) { // Stored procedures with cursorable methods are not called directly, so we have to get the metadata if (parameterNames == null) { try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index ba4a9bfbf..dc5cf1f33 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -165,7 +165,7 @@ public class SQLServerConnection implements ISQLServerConnection, java.io.Serial private transient SQLServerAccessTokenCallback accessTokenCallback = null; /** Flag indicating whether to use sp_sproc_columns for parameter name lookup */ - private boolean useFastCallableStatements = SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue(); + private boolean useFlexibleCallableStatements = SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue(); /** * Keep this distinct from _federatedAuthenticationRequested, since some fedauth library types may not need more @@ -2315,14 +2315,14 @@ Connection connectInternal(Properties propsIn, } trustServerCertificate = isBooleanPropertyOn(sPropKey, sPropValue); - sPropKey = SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(); + sPropKey = SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(); sPropValue = activeConnectionProperties.getProperty(sPropKey); if (null == sPropValue) { sPropValue = Boolean - .toString(SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue()); + .toString(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue()); activeConnectionProperties.setProperty(sPropKey, sPropValue); } - useFastCallableStatements = isBooleanPropertyOn(sPropKey, sPropValue); + useFlexibleCallableStatements = isBooleanPropertyOn(sPropKey, sPropValue); // Set requestedEncryptionLevel according to the value of the encrypt connection property if (encryptOption.compareToIgnoreCase(EncryptOption.FALSE.toString()) == 0) { @@ -7846,21 +7846,21 @@ public void setAccessTokenCallbackClass(String accessTokenCallbackClass) { /** * Returns whether or not sp_sproc_columns is being used for parameter name lookup. * - * @return useFastCallableStatements + * @return useFlexibleCallableStatements */ - public boolean getUseFastCallableStatement() { - return this.useFastCallableStatements; + public boolean geUseFlexibleCallableStatements() { + return this.useFlexibleCallableStatements; } /** * Sets whether or not sp_sproc_columns will be used for parameter name lookup. * - * @param useFastCallableStatements + * @param useFlexibleCallableStatements * When set to true, sp_sproc_columns is not used for parameter name lookup * in callable statements. */ - public void setUseFastCallableStatements(boolean useFastCallableStatements) { - this.useFastCallableStatements = useFastCallableStatements; + public void setUseFlexibleCallableStatements(boolean useFlexibleCallableStatements) { + this.useFlexibleCallableStatements = useFlexibleCallableStatements; } /** diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java index 477eaca22..a1a873b65 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java @@ -251,14 +251,14 @@ public boolean getUseDefaultGSSCredential() { } @Override - public void setUseFastCallableStatements(boolean enable) { - setBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(), enable); + public void setUseFlexibleCallableStatements(boolean enable) { + setBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(), enable); } @Override - public boolean getUseFastCallableStatements() { - return getBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(), - SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue()); + public boolean getUseFlexibleCallableStatements() { + return getBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(), + SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue()); } @Override diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java index 278888901..9e4f9945b 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java @@ -696,7 +696,7 @@ enum SQLServerDriverBooleanProperty { DELAY_LOADING_LOBS("delayLoadingLobs", true), USE_DEFAULT_JAAS_CONFIG("useDefaultJaasConfig", false), USE_DEFAULT_GSS_CREDENTIAL("useDefaultGSSCredential", false), - USE_FAST_CALLABLESTATEMENTS("useFastCallableStatements", false); + USE_FLEXIBLE_CALLABLESTATEMENTS("useFlexibleCallableStatements", true); private final String name; private final boolean defaultValue; @@ -773,8 +773,8 @@ public final class SQLServerDriver implements java.sql.Driver { new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.toString(), Boolean.toString(SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.getDefaultValue()), false, TRUE_FALSE), - new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.toString(), - Boolean.toString(SQLServerDriverBooleanProperty.USE_FAST_CALLABLESTATEMENTS.getDefaultValue()), false, + new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(), + Boolean.toString(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue()), false, TRUE_FALSE), new SQLServerDriverPropertyInfo(SQLServerDriverStringProperty.KEY_STORE_AUTHENTICATION.toString(), SQLServerDriverStringProperty.KEY_STORE_AUTHENTICATION.getDefaultValue(), false, diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java index 82b7baa3b..5a3ba6fb3 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java @@ -198,7 +198,7 @@ protected Object[][] getContents() { {"R_disableStatementPoolingPropertyDescription", "Disables the statement pooling feature."}, {"R_integratedSecurityPropertyDescription", "Indicates whether Windows authentication will be used to connect to SQL Server."}, {"R_useDefaultGSSCredentialPropertyDescription", "Indicates whether GSSCredential will be created using native GSS-API."}, - {"R_useFastCallableStatementsPropertyDescription", "Indicates whether sp_sproc_columns will be used for parameter name lookup when setting or registering parameters for callable statements."}, + {"R_useFlexibleCallableStatementsPropertyDescription", "Indicates whether sp_sproc_columns will be used for parameter name lookup when setting or registering parameters for callable statements."}, {"R_authenticationSchemePropertyDescription", "The authentication scheme to be used for integrated authentication."}, {"R_lockTimeoutPropertyDescription", "The number of milliseconds to wait before the database reports a lock time-out."}, {"R_connectRetryCountPropertyDescription", "The number of reconnection attempts if there is a connection failure."}, diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java index 17526b306..580da6da0 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionTest.java @@ -205,8 +205,8 @@ public void testDataSource() throws SQLServerException { assertEquals(booleanPropValue, ds.getUseDefaultGSSCredential(), TestResource.getResource("R_valuesAreDifferent")); - ds.setUseFastCallableStatements(booleanPropValue); - assertEquals(booleanPropValue, ds.getUseFastCallableStatements(), + ds.setUseFlexibleCallableStatements(booleanPropValue); + assertEquals(booleanPropValue, ds.getUseFlexibleCallableStatements(), TestResource.getResource("R_valuesAreDifferent")); ds.setServerCertificate(stringPropValue); 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 baa78ea5d..5b70e8dc3 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/RequestBoundaryMethodsTest.java @@ -504,8 +504,8 @@ private List getVerifiedMethodNames() { verifiedMethodNames.add("setMsiTokenCacheTtl"); verifiedMethodNames.add("getAccessTokenCallbackClass"); verifiedMethodNames.add("setAccessTokenCallbackClass"); - verifiedMethodNames.add("getUseFastCallableStatements"); - verifiedMethodNames.add("setUseFastCallableStatements"); + verifiedMethodNames.add("getUseFlexibleCallableStatements"); + verifiedMethodNames.add("setUseFlexibleCallableStatements"); return verifiedMethodNames; } } From 80a35d2cd077c489d5e756f4ac2b16ffe21cceb7 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Tue, 7 Nov 2023 17:43:17 -0800 Subject: [PATCH 43/51] Fixed typo in CS prop setter/getter --- .../microsoft/sqlserver/jdbc/SQLServerCallableStatement.java | 2 +- .../java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index beba1b52c..2f4f4235a 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -1418,7 +1418,7 @@ private int findColumn(String columnName, CallableStatementGetterSetterMethod me SQLServerException.getErrString("R_statementIsClosed"), null, false); } - if (connection.geUseFlexibleCallableStatements() || isCursorable(executeMethod)) { + if (connection.getUseFlexibleCallableStatements() || isCursorable(executeMethod)) { // Stored procedures with cursorable methods are not called directly, so we have to get the metadata if (parameterNames == null) { try (SQLServerStatement s = (SQLServerStatement) connection.createStatement()) { diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index dc5cf1f33..e07d26576 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -7848,7 +7848,7 @@ public void setAccessTokenCallbackClass(String accessTokenCallbackClass) { * * @return useFlexibleCallableStatements */ - public boolean geUseFlexibleCallableStatements() { + public boolean getUseFlexibleCallableStatements() { return this.useFlexibleCallableStatements; } From f8b0dc0e16fd71d4ee62bc11323ef1391518dd4e Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Tue, 7 Nov 2023 20:09:48 -0800 Subject: [PATCH 44/51] Include enclave package in RPC call --- .../microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index c9fed9d7a..d044c25bc 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -828,6 +828,9 @@ private void buildRPCExecParams(TDSWriter tdsWriter) throws SQLServerException { outParamIndexAdjustment = 0; tdsWriter.writeShort((short) procedureName.length()); // procedure name length tdsWriter.writeString(procedureName); + if (connection.isAEv2()) { + tdsWriter.sendEnclavePackage(preparedSQL, enclaveCEKs); + } tdsWriter.writeByte((byte) 0); // RPC procedure option 1 tdsWriter.writeByte((byte) 0); // RPC procedure option 2 @@ -1206,7 +1209,7 @@ else if (needsPrepare && !connection.getEnablePrepareOnFirstPreparedStatementCal */ boolean callRPCDirectly(Parameter[] params) throws SQLServerException { int paramCount = SQLServerConnection.countParams(userSQL); - return (null != procedureName && paramCount != 0 && !isTVPType(params) && !isInternalEncryptionQuery); + return (null != procedureName && paramCount != 0 && !isTVPType(params)); } /** From 1e6ee4885a02e724a82fc75418d1b9803b676f35 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Thu, 9 Nov 2023 15:41:57 -0800 Subject: [PATCH 45/51] Code Review Changes; Fixed threading issue --- .../sqlserver/jdbc/SQLServerCallableStatement.java | 2 +- .../sqlserver/jdbc/SQLServerConnection.java | 6 +++--- .../sqlserver/jdbc/SQLServerDataSource.java | 6 +++--- .../microsoft/sqlserver/jdbc/SQLServerDriver.java | 6 +++--- .../sqlserver/jdbc/SQLServerPreparedStatement.java | 9 ++++----- .../sqlserver/jdbc/SQLServerStatement.java | 7 +++++-- .../callablestatement/CallableStatementTest.java | 13 +++++++++---- .../jdbc/datatypes/DateAndTimeTypeTest.java | 2 +- 8 files changed, 29 insertions(+), 22 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 2f4f4235a..37d60d15e 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -192,7 +192,7 @@ private Parameter getOutParameter(int i) throws SQLServerException { // driver is executing // the stored procedure for cursorable ones differently ( calling sp_cursorexecute r sp_cursorprepexec. if (bReturnValueSyntax && inOutParam[i - 1].isValueGotten() && inOutParam[i - 1].isReturnValue() - && !isReturnValueAccessed && !isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType + && !isReturnValueAccessed && !isCursorable(executeMethod) && !isTVPType && callRPCDirectly(inOutParam)) { nOutParamsAssigned++; isReturnValueAccessed = true; diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index e07d26576..d6aba4774 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -165,7 +165,7 @@ public class SQLServerConnection implements ISQLServerConnection, java.io.Serial private transient SQLServerAccessTokenCallback accessTokenCallback = null; /** Flag indicating whether to use sp_sproc_columns for parameter name lookup */ - private boolean useFlexibleCallableStatements = SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue(); + private boolean useFlexibleCallableStatements = SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.getDefaultValue(); /** * Keep this distinct from _federatedAuthenticationRequested, since some fedauth library types may not need more @@ -2315,11 +2315,11 @@ Connection connectInternal(Properties propsIn, } trustServerCertificate = isBooleanPropertyOn(sPropKey, sPropValue); - sPropKey = SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(); + sPropKey = SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.toString(); sPropValue = activeConnectionProperties.getProperty(sPropKey); if (null == sPropValue) { sPropValue = Boolean - .toString(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue()); + .toString(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.getDefaultValue()); activeConnectionProperties.setProperty(sPropKey, sPropValue); } useFlexibleCallableStatements = isBooleanPropertyOn(sPropKey, sPropValue); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java index a1a873b65..f173493e0 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java @@ -252,13 +252,13 @@ public boolean getUseDefaultGSSCredential() { @Override public void setUseFlexibleCallableStatements(boolean enable) { - setBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(), enable); + setBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.toString(), enable); } @Override public boolean getUseFlexibleCallableStatements() { - return getBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(), - SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue()); + return getBooleanProperty(connectionProps, SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.toString(), + SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.getDefaultValue()); } @Override diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java index 9e4f9945b..f3a5b0360 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java @@ -696,7 +696,7 @@ enum SQLServerDriverBooleanProperty { DELAY_LOADING_LOBS("delayLoadingLobs", true), USE_DEFAULT_JAAS_CONFIG("useDefaultJaasConfig", false), USE_DEFAULT_GSS_CREDENTIAL("useDefaultGSSCredential", false), - USE_FLEXIBLE_CALLABLESTATEMENTS("useFlexibleCallableStatements", true); + USE_FLEXIBLE_CALLABLE_STATEMENTS("useFlexibleCallableStatements", true); private final String name; private final boolean defaultValue; @@ -773,8 +773,8 @@ public final class SQLServerDriver implements java.sql.Driver { new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.toString(), Boolean.toString(SQLServerDriverBooleanProperty.USE_DEFAULT_GSS_CREDENTIAL.getDefaultValue()), false, TRUE_FALSE), - new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.toString(), - Boolean.toString(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLESTATEMENTS.getDefaultValue()), false, + new SQLServerDriverPropertyInfo(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.toString(), + Boolean.toString(SQLServerDriverBooleanProperty.USE_FLEXIBLE_CALLABLE_STATEMENTS.getDefaultValue()), false, TRUE_FALSE), new SQLServerDriverPropertyInfo(SQLServerDriverStringProperty.KEY_STORE_AUTHENTICATION.toString(), SQLServerDriverStringProperty.KEY_STORE_AUTHENTICATION.getDefaultValue(), false, diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index d044c25bc..502442b53 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -98,8 +98,7 @@ public class SQLServerPreparedStatement extends SQLServerStatement implements IS /** Set to true if the statement is a stored procedure call that expects a return value */ final boolean bReturnValueSyntax; - /** Check if statement contains TVP Type */ - static boolean isTVPType = false; + /** user FMTOnly flag */ private boolean useFmtOnly = this.connection.getUseFmtOnly(); @@ -259,7 +258,6 @@ private boolean resetPrepStmtHandle(boolean discardCurrentCacheItem) { userSQLParamPositions = parsedSQL.parameterPositions; initParams(userSQLParamPositions.length); useBulkCopyForBatchInsert = conn.getUseBulkCopyForBatchInsert(); - isTVPType = false; } /** @@ -438,10 +436,11 @@ private String buildParamTypeDefinitions(Parameter[] params, boolean renewDefini int stringLen = nCols * 2; // @P stringLen += nCols; // spaces stringLen += nCols - 1; // commas - if (nCols > 10) + if (nCols > 10) { stringLen += 10 + ((nCols - 10) * 2); // @P{0-99} Numbers after p - else + } else { stringLen += nCols; // @P{0-9} Numbers after p less than 10 + } // Computing the type definitions up front, so we can get exact string lengths needed for the string builder. String[] typeDefinitions = new String[nCols]; diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 84a5ae1a0..201ef9c09 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -70,6 +70,9 @@ public class SQLServerStatement implements ISQLServerStatement { /** TDS token return value status **/ int returnValueStatus; + /** Check if statement contains TVP Type */ + boolean isTVPType = false; + static int userDefinedFunctionReturnStatus = 2; final boolean getIsResponseBufferingAdaptive() { @@ -119,7 +122,7 @@ final boolean wasExecuted() { } /** Return parameter for stored procedure calls */ - Parameter returnParam; + transient Parameter returnParam; /** * The input and out parameters for statement execution. @@ -1621,7 +1624,7 @@ boolean onRetStatus(TDSReader tdsReader) throws SQLServerException { // Only read the return value from stored procedure if we are expecting one. Also, check that it is // not cursorable and not TVP type. For these two, the driver is still following the old behavior of // executing sp_executesql for stored procedures. - if (!isCursorable(executeMethod) && !SQLServerPreparedStatement.isTVPType && null != inOutParam + if (!isCursorable(executeMethod) && !isTVPType && null != inOutParam && inOutParam.length > 0 && inOutParam[0].isReturnValue()) { inOutParam[0].setFromReturnStatus(procedureRetStatToken.getStatus(), connection); return false; 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 d003e908a..3c9b7290f 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -22,8 +22,6 @@ import java.util.TimeZone; import java.util.UUID; -import com.microsoft.sqlserver.jdbc.*; -import com.microsoft.sqlserver.testframework.PrepUtil; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Tag; @@ -31,6 +29,13 @@ import org.junit.platform.runner.JUnitPlatform; import org.junit.runner.RunWith; +import com.microsoft.sqlserver.jdbc.RandomUtil; +import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement; +import com.microsoft.sqlserver.jdbc.SQLServerDataSource; +import com.microsoft.sqlserver.jdbc.TestResource; +import com.microsoft.sqlserver.jdbc.TestUtils; +import com.microsoft.sqlserver.jdbc.SQLServerDataTable; +import com.microsoft.sqlserver.testframework.PrepUtil; import com.microsoft.sqlserver.testframework.AbstractSQLGenerator; import com.microsoft.sqlserver.testframework.AbstractTest; import com.microsoft.sqlserver.testframework.Constants; @@ -112,7 +117,7 @@ public static void setupTest() throws Exception { } @Test - public void testCallableStatementClosedConnection() throws Exception { + public void testCallableStatementClosedConnection() { try (SQLServerCallableStatement stmt = (SQLServerCallableStatement) connection.prepareCall("sproc")) { stmt.close(); // Prematurely close the statement, which causes inOutParams to be null. stmt.setStructured("myParam", "myTvp", (SQLServerDataTable) null); @@ -377,7 +382,7 @@ public void testZeroParamSproc() throws SQLException { } @Test - public void testSprocCastingError() throws SQLException { + public void testSprocCastingError() { String call = "{? = CALL " + zeroParamSproc + "}"; try (CallableStatement cs = connection.prepareCall(call)) { diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java index b3bbe3cb0..e8714b1c0 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/DateAndTimeTypeTest.java @@ -305,7 +305,7 @@ public void testCstmtRegisterDatetimeOutParameterDateTimeParameterTypeDatetime() String actual = null; String query = "{CALL " + AbstractSQLGenerator.escapeIdentifier(datetimeSproc) + "(?)}"; - // The following should be the T-SQL executed. Since datetimeParameterType=dateTime, the registererd param type + // The following should be the T-SQL executed. Since datetimeParameterType=dateTime, the registered parameter type // should be 'datetime' eg. declare @p1 datetime as shown below. The expected fractional seconds should be 3. // // declare @p1 datetime From d41e1f8af2052c3cfee4e1dfb78787b86061ea10 Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Wed, 15 Nov 2023 10:10:39 -0800 Subject: [PATCH 46/51] Merge conflict fix p2. --- src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java index bdb4bf11e..727e165b1 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java @@ -697,7 +697,7 @@ enum SQLServerDriverBooleanProperty { IGNORE_OFFSET_ON_DATE_TIME_OFFSET_CONVERSION("ignoreOffsetOnDateTimeOffsetConversion", false), USE_DEFAULT_JAAS_CONFIG("useDefaultJaasConfig", false), USE_DEFAULT_GSS_CREDENTIAL("useDefaultGSSCredential", false), - USE_FLEXIBLE_CALLABLE_STATEMENTS("useFlexibleCallableStatements", true) + USE_FLEXIBLE_CALLABLE_STATEMENTS("useFlexibleCallableStatements", true), CALC_BIG_DECIMAL_SCALE("calcBigDecimalScale", false); private final String name; From ef0869e37658633b3854ba386b931198807b5593 Mon Sep 17 00:00:00 2001 From: Terry Chow <32403408+tkyc@users.noreply.github.com> Date: Wed, 15 Nov 2023 15:31:28 -0800 Subject: [PATCH 47/51] Update src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java Co-authored-by: David Engel --- .../com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java index b49465b2e..af6b1afc1 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerDataSource.java @@ -613,8 +613,11 @@ public interface ISQLServerDataSource extends javax.sql.CommonDataSource { * Sets whether or not sp_sproc_columns will be used for parameter name lookup. * * @param useFlexibleCallableStatements - * When set to true, sp_sproc_columns is not used for parameter name lookup - * in callable statements. + * When set to false, sp_sproc_columns is not used for parameter name lookup + * in callable statements. This eliminates a round trip to the server but imposes limitations + * on how parameters are set. When set to false, applications must either reference + * parameters by name or by index, not both. Parameters must also be set in the same + * order as the stored procedure definition. */ void setUseFlexibleCallableStatements(boolean useFlexibleCallableStatements); From 224d03ac56f92c0e03942141e7253a19e9d60ef1 Mon Sep 17 00:00:00 2001 From: Terry Chow <32403408+tkyc@users.noreply.github.com> Date: Wed, 15 Nov 2023 15:31:47 -0800 Subject: [PATCH 48/51] Update src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java Co-authored-by: David Engel --- .../microsoft/sqlserver/jdbc/SQLServerCallableStatement.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index 37d60d15e..ad1dec9fe 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -89,7 +89,7 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple */ enum CallableStatementGetterSetterMethod { IS_SETTER_METHOD, - IS_GETTER_METHOD + IS_GETTER_METHOD } /** From 3af17dbb5768597f04eed5c25e0be75b68070dee Mon Sep 17 00:00:00 2001 From: Terry Chow <32403408+tkyc@users.noreply.github.com> Date: Wed, 15 Nov 2023 15:32:00 -0800 Subject: [PATCH 49/51] Update src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java Co-authored-by: David Engel --- .../java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 201ef9c09..0492d355d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -56,7 +56,6 @@ public class SQLServerStatement implements ISQLServerStatement { /** * Always update serialVersionUID when prompted. */ - private static final long serialVersionUID = -4421134713913331507L; final static char LEFT_CURLY_BRACKET = 123; From e771daff9afd7e7c2871c6c93dd7ae68ea4c7dfc Mon Sep 17 00:00:00 2001 From: Terry Chow <32403408+tkyc@users.noreply.github.com> Date: Wed, 15 Nov 2023 15:32:23 -0800 Subject: [PATCH 50/51] Update src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java Co-authored-by: David Engel --- .../microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index 502442b53..0c3493935 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -98,8 +98,6 @@ public class SQLServerPreparedStatement extends SQLServerStatement implements IS /** Set to true if the statement is a stored procedure call that expects a return value */ final boolean bReturnValueSyntax; - - /** user FMTOnly flag */ private boolean useFmtOnly = this.connection.getUseFmtOnly(); From 2e03f1278cac8ecdadaba92a85b741d54202713a Mon Sep 17 00:00:00 2001 From: Terry Chow Date: Thu, 16 Nov 2023 13:53:17 -0800 Subject: [PATCH 51/51] PR review; initial named parameter and index parameter restrictions --- .../sqlserver/jdbc/ISQLServerConnection.java | 2 +- .../jdbc/SQLServerCallableStatement.java | 10 + .../sqlserver/jdbc/SQLServerConnection.java | 7 +- .../jdbc/SQLServerPreparedStatement.java | 87 ++++ .../sqlserver/jdbc/SQLServerResource.java | 2 + .../sqlserver/jdbc/SQLServerStatement.java | 6 + .../sqlserver/jdbc/TestResource.java | 2 + .../CallableStatementTest.java | 434 ++++++++++++++++++ 8 files changed, 547 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerConnection.java index 314e64435..28e065980 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/ISQLServerConnection.java @@ -496,5 +496,5 @@ CallableStatement prepareCall(String sql, int nType, int nConcur, int nHold, * @param calcBigDecimalScale * A boolean that indicates if the driver should calculate scale from inputted big decimal values. */ - void setCalcBigDecimalScale(boolean computeBigDecimal); + void setCalcBigDecimalScale(boolean calcBigDecimalScale); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index ad1dec9fe..07c8969a2 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -470,6 +470,10 @@ private Parameter getterGetParam(int index) throws SQLServerException { // Check for valid index if (index < 1 || index > inOutParam.length) { + if (!connection.getUseFlexibleCallableStatements()) { + SQLServerException.makeFromDriverError(connection, this, + SQLServerException.getErrString("R_unknownOutputParameter"), SQLSTATE_07009, false); + } MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_invalidOutputParameter")); Object[] msgArgs = {index}; SQLServerException.makeFromDriverError(connection, this, form.format(msgArgs), SQLSTATE_07009, false); @@ -1412,6 +1416,12 @@ private String stripLeadingAtSign(String columnName) { * @return the index */ private int findColumn(String columnName, CallableStatementGetterSetterMethod method) throws SQLServerException { + isSetByName = true; + if (!connection.getUseFlexibleCallableStatements() && isSetByName && isSetByIndex) { + SQLServerException.makeFromDriverError(connection, this, + SQLServerException.getErrString("R_noNamedAndIndexedParameters"), null, false); + } + // If inOutParam is null, likely the statement was closed beforehand. if (null == inOutParam) { SQLServerException.makeFromDriverError(connection, this, diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index 0928ca02a..3c0712267 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -7842,8 +7842,11 @@ public boolean getUseFlexibleCallableStatements() { * Sets whether or not sp_sproc_columns will be used for parameter name lookup. * * @param useFlexibleCallableStatements - * When set to true, sp_sproc_columns is not used for parameter name lookup - * in callable statements. + * When set to false, sp_sproc_columns is not used for parameter name lookup + * in callable statements. This eliminates a round trip to the server but imposes limitations + * on how parameters are set. When set to false, applications must either reference + * parameters by name or by index, not both. Parameters must also be set in the same + * order as the stored procedure definition. */ public void setUseFlexibleCallableStatements(boolean useFlexibleCallableStatements) { this.useFlexibleCallableStatements = useFlexibleCallableStatements; diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index 0c3493935..52e1d5424 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -1299,6 +1299,11 @@ private SQLServerResultSet buildExecuteMetaData() throws SQLServerException, SQL * The index specified was outside the number of parameters for the statement. */ final Parameter setterGetParam(int index) throws SQLServerException { + if (!connection.getUseFlexibleCallableStatements() && isSetByName && isSetByIndex) { + SQLServerException.makeFromDriverError(connection, this, + SQLServerException.getErrString("R_noNamedAndIndexedParameters"), null, false); + } + if (index < 1 || index > inOutParam.length) { MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_indexOutOfRange")); Object[] msgArgs = {index}; @@ -1347,6 +1352,7 @@ final void setSQLXMLInternal(int parameterIndex, SQLXML value) throws SQLServerE @Override public final void setAsciiStream(int parameterIndex, InputStream x) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterIndex, x}); checkClosed(); @@ -1356,6 +1362,7 @@ public final void setAsciiStream(int parameterIndex, InputStream x) throws SQLEx @Override public final void setAsciiStream(int n, java.io.InputStream x, int length) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {n, x, length}); checkClosed(); @@ -1365,6 +1372,7 @@ public final void setAsciiStream(int n, java.io.InputStream x, int length) throw @Override public final void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterIndex, x, length}); checkClosed(); @@ -1374,6 +1382,7 @@ public final void setAsciiStream(int parameterIndex, InputStream x, long length) @Override public final void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterIndex, x}); checkClosed(); @@ -1384,6 +1393,7 @@ public final void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLServ @Override public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, int scale) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterIndex, x, precision, scale}); @@ -1395,6 +1405,7 @@ public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, @Override public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, int scale, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterIndex, x, precision, scale, forceEncrypt}); @@ -1405,6 +1416,7 @@ public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, @Override public final void setMoney(int n, BigDecimal x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {n, x}); checkClosed(); @@ -1414,6 +1426,7 @@ public final void setMoney(int n, BigDecimal x) throws SQLServerException { @Override public final void setMoney(int n, BigDecimal x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1423,6 +1436,7 @@ public final void setMoney(int n, BigDecimal x, boolean forceEncrypt) throws SQL @Override public final void setSmallMoney(int n, BigDecimal x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {n, x}); checkClosed(); @@ -1432,6 +1446,7 @@ public final void setSmallMoney(int n, BigDecimal x) throws SQLServerException { @Override public final void setSmallMoney(int n, BigDecimal x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1441,6 +1456,7 @@ public final void setSmallMoney(int n, BigDecimal x, boolean forceEncrypt) throw @Override public final void setBinaryStream(int parameterIndex, InputStream x) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStreaml", new Object[] {parameterIndex, x}); checkClosed(); @@ -1450,6 +1466,7 @@ public final void setBinaryStream(int parameterIndex, InputStream x) throws SQLE @Override public final void setBinaryStream(int n, java.io.InputStream x, int length) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {n, x, length}); checkClosed(); @@ -1459,6 +1476,7 @@ public final void setBinaryStream(int n, java.io.InputStream x, int length) thro @Override public final void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterIndex, x, length}); checkClosed(); @@ -1468,6 +1486,7 @@ public final void setBinaryStream(int parameterIndex, InputStream x, long length @Override public final void setBoolean(int n, boolean x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {n, x}); checkClosed(); @@ -1477,6 +1496,7 @@ public final void setBoolean(int n, boolean x) throws SQLServerException { @Override public final void setBoolean(int n, boolean x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1486,6 +1506,7 @@ public final void setBoolean(int n, boolean x, boolean forceEncrypt) throws SQLS @Override public final void setByte(int n, byte x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {n, x}); checkClosed(); @@ -1495,6 +1516,7 @@ public final void setByte(int n, byte x) throws SQLServerException { @Override public final void setByte(int n, byte x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1504,6 +1526,7 @@ public final void setByte(int n, byte x, boolean forceEncrypt) throws SQLServerE @Override public final void setBytes(int n, byte[] x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {n, x}); checkClosed(); @@ -1513,6 +1536,7 @@ public final void setBytes(int n, byte[] x) throws SQLServerException { @Override public final void setBytes(int n, byte[] x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1522,6 +1546,7 @@ public final void setBytes(int n, byte[] x, boolean forceEncrypt) throws SQLServ @Override public final void setUniqueIdentifier(int index, String guid) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {index, guid}); checkClosed(); @@ -1531,6 +1556,7 @@ public final void setUniqueIdentifier(int index, String guid) throws SQLServerEx @Override public final void setUniqueIdentifier(int index, String guid, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {index, guid, forceEncrypt}); @@ -1541,6 +1567,7 @@ public final void setUniqueIdentifier(int index, String guid, boolean forceEncry @Override public final void setDouble(int n, double x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {n, x}); checkClosed(); @@ -1550,6 +1577,7 @@ public final void setDouble(int n, double x) throws SQLServerException { @Override public final void setDouble(int n, double x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1559,6 +1587,7 @@ public final void setDouble(int n, double x, boolean forceEncrypt) throws SQLSer @Override public final void setFloat(int n, float x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {n, x}); checkClosed(); @@ -1568,6 +1597,7 @@ public final void setFloat(int n, float x) throws SQLServerException { @Override public final void setFloat(int n, float x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1577,6 +1607,7 @@ public final void setFloat(int n, float x, boolean forceEncrypt) throws SQLServe @Override public final void setGeometry(int n, Geometry x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setGeometry", new Object[] {n, x}); checkClosed(); @@ -1586,6 +1617,7 @@ public final void setGeometry(int n, Geometry x) throws SQLServerException { @Override public final void setGeography(int n, Geography x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setGeography", new Object[] {n, x}); checkClosed(); @@ -1595,6 +1627,7 @@ public final void setGeography(int n, Geography x) throws SQLServerException { @Override public final void setInt(int n, int value) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {n, value}); checkClosed(); @@ -1604,6 +1637,7 @@ public final void setInt(int n, int value) throws SQLServerException { @Override public final void setInt(int n, int value, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {n, value, forceEncrypt}); checkClosed(); @@ -1613,6 +1647,7 @@ public final void setInt(int n, int value, boolean forceEncrypt) throws SQLServe @Override public final void setLong(int n, long x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {n, x}); checkClosed(); @@ -1622,6 +1657,7 @@ public final void setLong(int n, long x) throws SQLServerException { @Override public final void setLong(int n, long x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -1631,6 +1667,7 @@ public final void setLong(int n, long x, boolean forceEncrypt) throws SQLServerE @Override public final void setNull(int index, int jdbcType) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {index, jdbcType}); checkClosed(); @@ -1676,6 +1713,7 @@ final void setObjectNoType(int index, Object obj, boolean forceEncrypt) throws S @Override public final void setObject(int index, Object obj) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {index, obj}); checkClosed(); @@ -1685,6 +1723,7 @@ public final void setObject(int index, Object obj) throws SQLServerException { @Override public final void setObject(int n, Object obj, int jdbcType) throws SQLServerException { + isSetByIndex = true; String tvpName = null; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {n, obj, jdbcType}); @@ -1699,6 +1738,7 @@ public final void setObject(int n, Object obj, int jdbcType) throws SQLServerExc @Override public final void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterIndex, x, targetSqlType, scaleOrLength}); @@ -1722,6 +1762,7 @@ public final void setObject(int parameterIndex, Object x, int targetSqlType, @Override public final void setObject(int parameterIndex, Object x, int targetSqlType, Integer precision, int scale) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterIndex, x, targetSqlType, precision, scale}); @@ -1743,6 +1784,7 @@ public final void setObject(int parameterIndex, Object x, int targetSqlType, Int @Override public final void setObject(int parameterIndex, Object x, int targetSqlType, Integer precision, int scale, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterIndex, x, targetSqlType, precision, scale, forceEncrypt}); @@ -1840,6 +1882,7 @@ public final void setObject(int parameterIndex, Object x, SQLType targetSqlType, @Override public final void setShort(int index, short x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {index, x}); checkClosed(); @@ -1849,6 +1892,7 @@ public final void setShort(int index, short x) throws SQLServerException { @Override public final void setShort(int index, short x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {index, x, forceEncrypt}); checkClosed(); @@ -1858,6 +1902,7 @@ public final void setShort(int index, short x, boolean forceEncrypt) throws SQLS @Override public final void setString(int index, String str) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {index, str}); checkClosed(); @@ -1867,6 +1912,7 @@ public final void setString(int index, String str) throws SQLServerException { @Override public final void setString(int index, String str, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {index, str, forceEncrypt}); checkClosed(); @@ -1876,6 +1922,7 @@ public final void setString(int index, String str, boolean forceEncrypt) throws @Override public final void setNString(int parameterIndex, String value) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterIndex, value}); checkClosed(); @@ -1885,6 +1932,7 @@ public final void setNString(int parameterIndex, String value) throws SQLExcepti @Override public final void setNString(int parameterIndex, String value, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterIndex, value, forceEncrypt}); @@ -1895,6 +1943,7 @@ public final void setNString(int parameterIndex, String value, boolean forceEncr @Override public final void setTime(int n, java.sql.Time x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x}); checkClosed(); @@ -1904,6 +1953,7 @@ public final void setTime(int n, java.sql.Time x) throws SQLServerException { @Override public final void setTime(int n, java.sql.Time x, int scale) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, scale}); checkClosed(); @@ -1913,6 +1963,7 @@ public final void setTime(int n, java.sql.Time x, int scale) throws SQLServerExc @Override public final void setTime(int n, java.sql.Time x, int scale, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, scale, forceEncrypt}); checkClosed(); @@ -1922,6 +1973,7 @@ public final void setTime(int n, java.sql.Time x, int scale, boolean forceEncryp @Override public final void setTimestamp(int n, java.sql.Timestamp x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x}); checkClosed(); @@ -1931,6 +1983,7 @@ public final void setTimestamp(int n, java.sql.Timestamp x) throws SQLServerExce @Override public final void setTimestamp(int n, java.sql.Timestamp x, int scale) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, scale}); checkClosed(); @@ -1941,6 +1994,7 @@ public final void setTimestamp(int n, java.sql.Timestamp x, int scale) throws SQ @Override public final void setTimestamp(int n, java.sql.Timestamp x, int scale, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, scale, forceEncrypt}); checkClosed(); @@ -1950,6 +2004,7 @@ public final void setTimestamp(int n, java.sql.Timestamp x, int scale, @Override public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x}); checkClosed(); @@ -1959,6 +2014,7 @@ public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x) throw @Override public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int scale) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x, scale}); checkClosed(); @@ -1969,6 +2025,7 @@ public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int s @Override public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int scale, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x, scale, forceEncrypt}); @@ -1979,6 +2036,7 @@ public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int s @Override public final void setDate(int n, java.sql.Date x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x}); checkClosed(); @@ -1988,6 +2046,7 @@ public final void setDate(int n, java.sql.Date x) throws SQLServerException { @Override public final void setDateTime(int n, java.sql.Timestamp x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {n, x}); checkClosed(); @@ -1997,6 +2056,7 @@ public final void setDateTime(int n, java.sql.Timestamp x) throws SQLServerExcep @Override public final void setDateTime(int n, java.sql.Timestamp x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -2006,6 +2066,7 @@ public final void setDateTime(int n, java.sql.Timestamp x, boolean forceEncrypt) @Override public final void setSmallDateTime(int n, java.sql.Timestamp x) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {n, x}); checkClosed(); @@ -2015,6 +2076,7 @@ public final void setSmallDateTime(int n, java.sql.Timestamp x) throws SQLServer @Override public final void setSmallDateTime(int n, java.sql.Timestamp x, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {n, x, forceEncrypt}); checkClosed(); @@ -2024,6 +2086,7 @@ public final void setSmallDateTime(int n, java.sql.Timestamp x, boolean forceEnc @Override public final void setStructured(int n, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { + isSetByIndex = true; tvpName = getTVPNameIfNull(n, tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpDataTable}); @@ -2034,6 +2097,7 @@ public final void setStructured(int n, String tvpName, SQLServerDataTable tvpDat @Override public final void setStructured(int n, String tvpName, ResultSet tvpResultSet) throws SQLServerException { + isSetByIndex = true; tvpName = getTVPNameIfNull(n, tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpResultSet}); @@ -2045,6 +2109,7 @@ public final void setStructured(int n, String tvpName, ResultSet tvpResultSet) t @Override public final void setStructured(int n, String tvpName, ISQLServerDataRecord tvpBulkRecord) throws SQLServerException { + isSetByIndex = true; tvpName = getTVPNameIfNull(n, tvpName); if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpBulkRecord}); @@ -3151,6 +3216,7 @@ public final boolean getUseFmtOnly() throws SQLServerException { @Override public final void setCharacterStream(int parameterIndex, Reader reader) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterIndex, reader}); checkClosed(); @@ -3160,6 +3226,7 @@ public final void setCharacterStream(int parameterIndex, Reader reader) throws S @Override public final void setCharacterStream(int n, java.io.Reader reader, int length) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {n, reader, length}); checkClosed(); @@ -3169,6 +3236,7 @@ public final void setCharacterStream(int n, java.io.Reader reader, int length) t @Override public final void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterIndex, reader, length}); @@ -3179,6 +3247,7 @@ public final void setCharacterStream(int parameterIndex, Reader reader, long len @Override public final void setNCharacterStream(int parameterIndex, Reader value) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterIndex, value}); checkClosed(); @@ -3188,6 +3257,7 @@ public final void setNCharacterStream(int parameterIndex, Reader value) throws S @Override public final void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterIndex, value, length}); @@ -3203,6 +3273,7 @@ public final void setRef(int i, java.sql.Ref x) throws SQLException { @Override public final void setBlob(int i, java.sql.Blob x) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {i, x}); checkClosed(); @@ -3212,6 +3283,7 @@ public final void setBlob(int i, java.sql.Blob x) throws SQLException { @Override public final void setBlob(int parameterIndex, InputStream inputStream) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterIndex, inputStream}); checkClosed(); @@ -3222,6 +3294,7 @@ public final void setBlob(int parameterIndex, InputStream inputStream) throws SQ @Override public final void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterIndex, inputStream, length}); @@ -3232,6 +3305,7 @@ public final void setBlob(int parameterIndex, InputStream inputStream, long leng @Override public final void setClob(int parameterIndex, java.sql.Clob clobValue) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, clobValue}); checkClosed(); @@ -3241,6 +3315,7 @@ public final void setClob(int parameterIndex, java.sql.Clob clobValue) throws SQ @Override public final void setClob(int parameterIndex, Reader reader) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, reader}); checkClosed(); @@ -3250,6 +3325,7 @@ public final void setClob(int parameterIndex, Reader reader) throws SQLException @Override public final void setClob(int parameterIndex, Reader reader, long length) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, reader, length}); checkClosed(); @@ -3259,6 +3335,7 @@ public final void setClob(int parameterIndex, Reader reader, long length) throws @Override public final void setNClob(int parameterIndex, NClob value) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, value}); checkClosed(); @@ -3268,6 +3345,7 @@ public final void setNClob(int parameterIndex, NClob value) throws SQLException @Override public final void setNClob(int parameterIndex, Reader reader) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, reader}); checkClosed(); @@ -3277,6 +3355,7 @@ public final void setNClob(int parameterIndex, Reader reader) throws SQLExceptio @Override public final void setNClob(int parameterIndex, Reader reader, long length) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, reader, length}); checkClosed(); @@ -3291,6 +3370,7 @@ public final void setArray(int i, java.sql.Array x) throws SQLException { @Override public final void setDate(int n, java.sql.Date x, java.util.Calendar cal) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x, cal}); checkClosed(); @@ -3301,6 +3381,7 @@ public final void setDate(int n, java.sql.Date x, java.util.Calendar cal) throws @Override public final void setDate(int n, java.sql.Date x, java.util.Calendar cal, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x, cal, forceEncrypt}); checkClosed(); @@ -3310,6 +3391,7 @@ public final void setDate(int n, java.sql.Date x, java.util.Calendar cal, @Override public final void setTime(int n, java.sql.Time x, java.util.Calendar cal) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, cal}); checkClosed(); @@ -3320,6 +3402,7 @@ public final void setTime(int n, java.sql.Time x, java.util.Calendar cal) throws @Override public final void setTime(int n, java.sql.Time x, java.util.Calendar cal, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, cal, forceEncrypt}); checkClosed(); @@ -3329,6 +3412,7 @@ public final void setTime(int n, java.sql.Time x, java.util.Calendar cal, @Override public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar cal) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal}); checkClosed(); @@ -3339,6 +3423,7 @@ public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar c @Override public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar cal, boolean forceEncrypt) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal, forceEncrypt}); checkClosed(); @@ -3348,6 +3433,7 @@ public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar c @Override public final void setNull(int paramIndex, int sqlType, String typeName) throws SQLServerException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {paramIndex, sqlType, typeName}); checkClosed(); @@ -3397,6 +3483,7 @@ public final void setRowId(int parameterIndex, RowId x) throws SQLException { @Override public final void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { + isSetByIndex = true; if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterIndex, xmlObject}); checkClosed(); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java index b6779c2f1..9055e9add 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResource.java @@ -144,6 +144,8 @@ protected Object[][] getContents() { {"R_stringNotInHex", "The string is not in a valid hex format."}, {"R_unknownType", "The Java type {0} is not a supported type."}, {"R_physicalConnectionIsClosed", "The physical connection is closed for this pooled connection."}, + {"R_noNamedAndIndexedParameters", "Detected uncompliant use of both named and indexed parameters while 'useFlexibleCallableStatements=false'. It is suggested to either exclusively use named parameters or indexed parameters."}, + {"R_unknownOutputParameter", "Cannot acquire output parameter value by name. No parameter index was associated with the output parameter name. If acquiring output parameter by name, verify that the output parameter was initially registered by name."}, {"R_invalidDataSourceReference", "Invalid DataSource reference."}, {"R_cantGetColumnValueFromDeletedRow", "Cannot get a value from a deleted row."}, {"R_cantGetUpdatedColumnValue", "Updated columns cannot be accessed until updateRow() or cancelRowUpdates() has been called."}, diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 0492d355d..2fe360514 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -149,6 +149,12 @@ final boolean wasExecuted() { */ boolean isCloseOnCompletion = false; + /** Checks if the callable statement's parameters are set by name **/ + protected boolean isSetByName = false; + + /** Checks if the prepared statement's parameters were set by index **/ + protected boolean isSetByIndex = false; + /** * Currently executing or most recently executed TDSCommand (statement cmd, server cursor cmd, ...) subject to * cancellation through Statement.cancel. diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java index 01816b698..449ea1f0b 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/TestResource.java @@ -56,6 +56,8 @@ protected Object[][] getContents() { {"R_createDropAlterTableFailed", "Create/drop/alter table with preparedStatement failed!"}, {"R_grantFailed", "grant table with preparedStatement failed!"}, {"R_connectionIsClosed", "The connection is closed."}, + {"R_noNamedAndIndexedParameters", "Detected uncompliant use of both named and indexed parameters while 'useFlexibleCallableStatements=false'. It is suggested to either exclusively use named parameters or indexed parameters."}, + {"R_unknownOutputParameter", "Cannot acquire output parameter value by name. No parameter index was associated with the output parameter name. If acquiring output parameter by name, verify that the output parameter was initially registered by name."}, {"R_ConnectionURLNull", "The connection URL is null."}, {"R_connectionIsNotClosed", "The connection is not closed."}, {"R_invalidExceptionMessage", "Invalid exception message"}, 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 3c9b7290f..e9d73b795 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -22,6 +22,7 @@ import java.util.TimeZone; import java.util.UUID; +import org.junit.Assert; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Tag; @@ -40,6 +41,8 @@ import com.microsoft.sqlserver.testframework.AbstractTest; import com.microsoft.sqlserver.testframework.Constants; +import javax.sql.DataSource; + /** * Test CallableStatement @@ -433,6 +436,437 @@ public void testNonOrderedRegisteringAndSettingOfParams() throws SQLException { } } + @Test + public void testNamedParametersUseFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + // useFlexibleCallableStatement=false and using all named parameters + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject("i1", obj1, Types.NUMERIC); + cstmt.setObject("i2", obj2, Types.NUMERIC, scale); + cstmt.setObject("i3", obj3, Types.INTEGER); + cstmt.setObject("i4", obj4, Types.FLOAT); + + cstmt.setObject("i5", obj5, Types.CHAR); + cstmt.setObject("i6", obj6, Types.VARCHAR); + cstmt.setObject("i7", obj7, Types.CHAR); + cstmt.setObject("i8", obj8, Types.SMALLINT); + + cstmt.registerOutParameter("o1", Types.NUMERIC); + cstmt.registerOutParameter("o2", Types.NUMERIC, scale); + cstmt.registerOutParameter("o3", Types.INTEGER); + cstmt.registerOutParameter("o4", Types.FLOAT); + + cstmt.registerOutParameter("o5", Types.CHAR); + cstmt.registerOutParameter("o6", Types.VARCHAR); + cstmt.registerOutParameter("o7", Types.CHAR); + cstmt.registerOutParameter("o8", Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble("o1")); + assertEquals(obj2, cstmt.getDouble("o2")); + assertEquals(obj3, cstmt.getInt("o3")); + assertEquals(obj4, cstmt.getFloat("o4")); + assertEquals(obj5, cstmt.getInt("o5")); + assertEquals(obj6, cstmt.getString("o6")); + assertEquals(obj7, cstmt.getString("o7")); + assertEquals(obj8, cstmt.getLong("o8")); + } + } + } + + @Test + public void testNamedParametersAcquireOutputParamValuesByIndexUseFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + // useFlexibleCallableStatement=false + // Setting parameters by name + // Registering output parameters by name + // Acquiring output parameter values by index + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject("i1", obj1, Types.NUMERIC); + cstmt.setObject("i2", obj2, Types.NUMERIC, scale); + cstmt.setObject("i3", obj3, Types.INTEGER); + cstmt.setObject("i4", obj4, Types.FLOAT); + + cstmt.setObject("i5", obj5, Types.CHAR); + cstmt.setObject("i6", obj6, Types.VARCHAR); + cstmt.setObject("i7", obj7, Types.CHAR); + cstmt.setObject("i8", obj8, Types.SMALLINT); + + cstmt.registerOutParameter("o1", Types.NUMERIC); + cstmt.registerOutParameter("o2", Types.NUMERIC, scale); + cstmt.registerOutParameter("o3", Types.INTEGER); + cstmt.registerOutParameter("o4", Types.FLOAT); + + cstmt.registerOutParameter("o5", Types.CHAR); + cstmt.registerOutParameter("o6", Types.VARCHAR); + cstmt.registerOutParameter("o7", Types.CHAR); + cstmt.registerOutParameter("o8", Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble(9)); + assertEquals(obj2, cstmt.getDouble(10)); + assertEquals(obj3, cstmt.getInt(11)); + assertEquals(obj4, cstmt.getFloat(12)); + assertEquals(obj5, cstmt.getInt(13)); + assertEquals(obj6, cstmt.getString(14)); + assertEquals(obj7, cstmt.getString(15)); + assertEquals(obj8, cstmt.getLong(16)); + } + } + } + + @Test + public void testNamedParametersAndOutParamByIndexUseFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + // useFlexibleCallableStatement=false + // Setting parameters by name + // Registering output params by index + // Acquiring output param values by index + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject("i1", obj1, Types.NUMERIC); + cstmt.setObject("i2", obj2, Types.NUMERIC, scale); + cstmt.setObject("i3", obj3, Types.INTEGER); + cstmt.setObject("i4", obj4, Types.FLOAT); + + cstmt.setObject("i5", obj5, Types.CHAR); + cstmt.setObject("i6", obj6, Types.VARCHAR); + cstmt.setObject("i7", obj7, Types.CHAR); + cstmt.setObject("i8", obj8, Types.SMALLINT); + + cstmt.registerOutParameter(9, Types.NUMERIC); + cstmt.registerOutParameter(10, Types.NUMERIC, scale); + cstmt.registerOutParameter(11, Types.INTEGER); + cstmt.registerOutParameter(12, Types.FLOAT); + + cstmt.registerOutParameter(13, Types.CHAR); + cstmt.registerOutParameter(14, Types.VARCHAR); + cstmt.registerOutParameter(15, Types.CHAR); + cstmt.registerOutParameter(16, Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble(9)); + assertEquals(obj2, cstmt.getDouble(10)); + assertEquals(obj3, cstmt.getInt(11)); + assertEquals(obj4, cstmt.getFloat(12)); + assertEquals(obj5, cstmt.getInt(13)); + assertEquals(obj6, cstmt.getString(14)); + assertEquals(obj7, cstmt.getString(15)); + assertEquals(obj8, cstmt.getLong(16)); + } + } + } + + @Test + public void testNamedParameterOutputParameterErrorFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + // useFlexibleCallableStatement=false + // Setting parameters by name + // Registering output params by index + // Acquiring output param value 'o1' by name + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject("i1", obj1, Types.NUMERIC); + cstmt.setObject("i2", obj2, Types.NUMERIC, scale); + cstmt.setObject("i3", obj3, Types.INTEGER); + cstmt.setObject("i4", obj4, Types.FLOAT); + + cstmt.setObject("i5", obj5, Types.CHAR); + cstmt.setObject("i6", obj6, Types.VARCHAR); + cstmt.setObject("i7", obj7, Types.CHAR); + cstmt.setObject("i8", obj8, Types.SMALLINT); + + cstmt.registerOutParameter(9, Types.NUMERIC); + cstmt.registerOutParameter(10, Types.NUMERIC, scale); + cstmt.registerOutParameter(11, Types.INTEGER); + cstmt.registerOutParameter(12, Types.FLOAT); + + cstmt.registerOutParameter(13, Types.CHAR); + cstmt.registerOutParameter(14, Types.VARCHAR); + cstmt.registerOutParameter(15, Types.CHAR); + cstmt.registerOutParameter(16, Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble("o1")); + assertEquals(obj2, cstmt.getDouble(10)); + assertEquals(obj3, cstmt.getInt(11)); + assertEquals(obj4, cstmt.getFloat(12)); + assertEquals(obj5, cstmt.getInt(13)); + assertEquals(obj6, cstmt.getString(14)); + assertEquals(obj7, cstmt.getString(15)); + assertEquals(obj8, cstmt.getLong(16)); + + fail(TestResource.getResource("R_expectedFailPassed")); + } catch (Exception e) { + assertEquals(TestResource.getResource("R_unknownOutputParameter"), e.getMessage()); + } + } + } + + @Test + public void testNamedParametersAndByIndexErrorUseFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + // useFlexibleCallableStatement=false + // Using majority named parameters and setting parameter by index + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject("i1", obj1, Types.NUMERIC); + cstmt.setObject("i2", obj2, Types.NUMERIC, scale); + cstmt.setObject("i3", obj3, Types.INTEGER); + cstmt.setObject("i4", obj4, Types.FLOAT); + + cstmt.setObject("i5", obj5, Types.CHAR); + cstmt.setObject("i6", obj6, Types.VARCHAR); + cstmt.setObject("i7", obj7, Types.CHAR); + cstmt.setObject(8, obj8, Types.SMALLINT); + + cstmt.registerOutParameter("o1", Types.NUMERIC); + cstmt.registerOutParameter("o2", Types.NUMERIC, scale); + cstmt.registerOutParameter("o3", Types.INTEGER); + cstmt.registerOutParameter("o4", Types.FLOAT); + + cstmt.registerOutParameter("o5", Types.CHAR); + cstmt.registerOutParameter("o6", Types.VARCHAR); + cstmt.registerOutParameter("o7", Types.CHAR); + cstmt.registerOutParameter("o8", Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble("o1")); + assertEquals(obj2, cstmt.getDouble("o2")); + assertEquals(obj3, cstmt.getInt("o3")); + assertEquals(obj4, cstmt.getFloat("o4")); + assertEquals(obj5, cstmt.getInt("o5")); + assertEquals(obj6, cstmt.getString("o6")); + assertEquals(obj7, cstmt.getString("o7")); + assertEquals(obj8, cstmt.getLong("o8")); + + fail(TestResource.getResource("R_expectedFailPassed")); + } catch (Exception e) { + assertEquals(TestResource.getResource("R_noNamedAndIndexedParameters"), e.getMessage()); + } + } + } + + @Test + public void testIndexedParametersUseFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + // useFlexibleCallableStatement=false and using all index parameters + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject(1, obj1, Types.NUMERIC); + cstmt.setObject(2, obj2, Types.NUMERIC, scale); + cstmt.setObject(3, obj3, Types.INTEGER); + cstmt.setObject(4, obj4, Types.FLOAT); + + cstmt.setObject(5, obj5, Types.CHAR); + cstmt.setObject(6, obj6, Types.VARCHAR); + cstmt.setObject(7, obj7, Types.CHAR); + cstmt.setObject(8, obj8, Types.SMALLINT); + + cstmt.registerOutParameter(9, Types.NUMERIC); + cstmt.registerOutParameter(10, Types.NUMERIC, scale); + cstmt.registerOutParameter(11, Types.INTEGER); + cstmt.registerOutParameter(12, Types.FLOAT); + + cstmt.registerOutParameter(13, Types.CHAR); + cstmt.registerOutParameter(14, Types.VARCHAR); + cstmt.registerOutParameter(15, Types.CHAR); + cstmt.registerOutParameter(16, Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble(9)); + assertEquals(obj2, cstmt.getDouble(10)); + assertEquals(obj3, cstmt.getInt(11)); + assertEquals(obj4, cstmt.getFloat(12)); + assertEquals(obj5, cstmt.getInt(13)); + assertEquals(obj6, cstmt.getString(14)); + assertEquals(obj7, cstmt.getString(15)); + assertEquals(obj8, cstmt.getLong(16)); + } + } + } + + @Test + public void testIndexedParametersAcquireOutputValueByNameErrorUseFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject(1, obj1, Types.NUMERIC); + cstmt.setObject(2, obj2, Types.NUMERIC, scale); + cstmt.setObject(3, obj3, Types.INTEGER); + cstmt.setObject(4, obj4, Types.FLOAT); + + cstmt.setObject(5, obj5, Types.CHAR); + cstmt.setObject(6, obj6, Types.VARCHAR); + cstmt.setObject(7, obj7, Types.CHAR); + cstmt.setObject(8, obj8, Types.SMALLINT); + + cstmt.registerOutParameter(9, Types.NUMERIC); + cstmt.registerOutParameter(10, Types.NUMERIC, scale); + cstmt.registerOutParameter(11, Types.INTEGER); + cstmt.registerOutParameter(12, Types.FLOAT); + + cstmt.registerOutParameter(13, Types.CHAR); + cstmt.registerOutParameter(14, Types.VARCHAR); + cstmt.registerOutParameter(15, Types.CHAR); + cstmt.registerOutParameter(16, Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble(9)); + assertEquals(obj2, cstmt.getDouble(10)); + assertEquals(obj3, cstmt.getInt(11)); + assertEquals(obj4, cstmt.getFloat(12)); + assertEquals(obj5, cstmt.getInt(13)); + assertEquals(obj6, cstmt.getString(14)); + assertEquals(obj7, cstmt.getString(15)); + assertEquals(obj8, cstmt.getLong("o8")); + fail(TestResource.getResource("R_expectedFailPassed")); + } catch (Exception e) { + assertEquals(TestResource.getResource("R_noNamedAndIndexedParameters"), e.getMessage()); + } + } + } + + @Test + public void testIndexedParametersRegisterOutputParamByNameUseFlexibleCallableStatementFalse() throws SQLException { + String call = "{CALL " + outOfOrderSproc + " (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)}"; + String connectionString = TestUtils.addOrOverrideProperty(getConnectionString(), "useFlexibleCallableStatements", "false"); + + try (Connection conn = DriverManager.getConnection(connectionString)) { + try (CallableStatement cstmt = conn.prepareCall(call)) { + int scale = 6; + double obj1 = 2015.0123; + double obj2 = 2015.012345; + int obj3 = -3; + float obj4 = 2015.04f; + int obj5 = 3; + String obj6 = "foo"; + String obj7 = "b"; + long obj8 = 2015L; + + cstmt.setObject(1, obj1, Types.NUMERIC); + cstmt.setObject(2, obj2, Types.NUMERIC, scale); + cstmt.setObject(3, obj3, Types.INTEGER); + cstmt.setObject(4, obj4, Types.FLOAT); + + cstmt.setObject(5, obj5, Types.CHAR); + cstmt.setObject(6, obj6, Types.VARCHAR); + cstmt.setObject(7, obj7, Types.CHAR); + cstmt.setObject(8, obj8, Types.SMALLINT); + + cstmt.registerOutParameter("o1", Types.NUMERIC); + cstmt.registerOutParameter(10, Types.NUMERIC, scale); + cstmt.registerOutParameter(11, Types.INTEGER); + cstmt.registerOutParameter(12, Types.FLOAT); + + cstmt.registerOutParameter(13, Types.CHAR); + cstmt.registerOutParameter(14, Types.VARCHAR); + cstmt.registerOutParameter(15, Types.CHAR); + cstmt.registerOutParameter(16, Types.SMALLINT); + cstmt.execute(); + + assertEquals(obj1, cstmt.getDouble(9)); + assertEquals(obj2, cstmt.getDouble(10)); + assertEquals(obj3, cstmt.getInt(11)); + assertEquals(obj4, cstmt.getFloat(12)); + assertEquals(obj5, cstmt.getInt(13)); + assertEquals(obj6, cstmt.getString(14)); + assertEquals(obj7, cstmt.getString(15)); + assertEquals(obj8, cstmt.getLong(16)); + + fail(TestResource.getResource("R_expectedFailPassed")); + } catch (Exception e) { + assertEquals(TestResource.getResource("R_noNamedAndIndexedParameters"), e.getMessage()); + } + } + } + @Test public void testExecutingUserDefinedFunctionDirectly() throws SQLException { String call = "{? = CALL " + userDefinedFunction + " (?,?,?,?,?,?)}";