Calling stored procedure directly

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

@@ -6479,6 +6479,7 @@ private boolean nextPacket() throws SQLServerException {
         return true;
     }
 
+
     /**
      * Reads the next packet of the TDS channel.
      *

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

@@ -50,7 +50,8 @@ 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;
     boolean renewDefinition = false;
@@ -72,6 +73,16 @@ boolean isOutput() {
         return null != registeredOutDTV;
     }
 
+    /** Checks if a parameter is return type*/
+    boolean isReturnValue() {
+        return isReturnValue;
+    }
+
+    /** Sets a parameter to be a return type */
+    void setReturnValue(boolean isReturnValue) {
+        this.isReturnValue = isReturnValue;
+    }
+
     // 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.
@@ -207,9 +218,9 @@ final void skipValue(TDSReader tdsReader,
             boolean isDiscard) throws SQLServerException {
         if (null == getterDTV)
             getterDTV = new DTV();
-
+        
         deriveTypeInfo(tdsReader);
-
+        
         getterDTV.skipValue(typeInfo, tdsReader, isDiscard);
     }
 
@@ -254,7 +265,7 @@ void setFromReturnStatus(int returnStatus,
         if (null == getterDTV)
             getterDTV = new DTV();
 
-        getterDTV.setValue(null, JDBCType.INTEGER, returnStatus, JavaType.INTEGER, null, null, null, con, getForceEncryption());
+        getterDTV.setValue(null, this.getJdbcType(), returnStatus, JavaType.INTEGER, null, null, null, con, getForceEncryption());
     }
 
     void setValue(JDBCType jdbcType,
@@ -407,10 +418,12 @@ Object getValue(JDBCType jdbcType,
             InputStreamGetterArgs getterArgs,
             Calendar cal,
             TDSReader tdsReader) throws SQLServerException {
-        if (null == getterDTV)
+        if (null == getterDTV) {
             getterDTV = new DTV();
-
-        deriveTypeInfo(tdsReader);
+        }
+        if (null != 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);

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

@@ -58,11 +58,15 @@ public class SQLServerCallableStatement extends SQLServerPreparedStatement imple
 
     /** Currently active Stream Note only one stream can be active at a time */
     private Closeable activeStream;
+
+    /** Checks if return values is already accessed in stored procedure */
+    private boolean returnValueIsAccessed = false;
 
     // Internal function used in tracing
     String getClassNameInternal() {
         return "SQLServerCallableStatement";
     }
+
 
     /**
      * Create a new callable statement.
@@ -85,6 +89,7 @@ String getClassNameInternal() {
             int nRSConcur,
             SQLServerStatementColumnEncryptionSetting stmtColEncSetting) throws SQLServerException {
         super(connection, sql, nRSType, nRSConcur, stmtColEncSetting);
+        returnValueIsAccessed = false;
     }
 
     public void registerOutParameter(int index,
@@ -156,14 +161,22 @@ 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) {
+                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)
             skipOutParameters(1, false);
-
         return inOutParam[i - 1];
     }
 
@@ -212,18 +225,21 @@ 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;
+            }
         }
     }
 
@@ -289,57 +305,67 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException {
 
         OutParamHandler outParamHandler = new OutParamHandler();
 
+        if (bReturnValueSyntax && (nOutParamsAssigned == 0) && !isCursorable(executeMethod) && !isTVPType) 
+            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();
-            }
-
-            // 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;
+        // assert numParamsToSkip <= nOutParams - nOutParamsAssigned ;
+        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();
+                }
 
-                // 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.
+                // 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();
+                // 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) {
+                    outParamIndex++;
+                }
+                // Statements need to have their out param indices adjusted by the number
+                // of sp_[cursor][prep]exec params.
+                else if (isCursorable(executeMethod) || isTVPType) {
+                    outParamIndex -= outParamIndexAdjustment;
+                }
+                if ((outParamIndex < 0 || outParamIndex >= inOutParam.length) || (!inOutParam[outParamIndex].isOutput())) {
+                    getStatementLogger()
+                            .info(toString() + " Unexpected outParamIndex: " + outParamIndex + "; adjustment: " + outParamIndexAdjustment);
+                    connection.throwInvalidTDS();
+                }
 
-            // 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())) {
-                getStatementLogger().info(toString() + " Unexpected outParamIndex: " + outParamIndex + "; adjustment: " + outParamIndexAdjustment);
-                connection.throwInvalidTDS();
+                ++nOutParamsAssigned;
             }
-
-            ++nOutParamsAssigned;
         }
     }
 
@@ -424,7 +450,14 @@ private Parameter getterGetParam(int index) throws SQLServerException {
 
     private Object getValue(int parameterIndex,
             JDBCType jdbcType) throws SQLServerException {
-        return getterGetParam(parameterIndex).getValue(jdbcType, null, null, resultsReader());
+        Parameter param = getterGetParam(parameterIndex);
+        if (!param.isValueGotten() || !param.isReturnValue()) {
+            return param.getValue(jdbcType, null, null, resultsReader());
+        }
+        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); 
+        }
     }
 
     private Object getValue(int parameterIndex,
@@ -1386,8 +1419,7 @@ public NClob getNClob(String parameterName) throws SQLException {
         return getArray(findColumn(sCol));
     }
 
-    /* JDBC 3.0 */
-
+    /* JDBC 3.0 */   
     /**
      * Find a column's index given its name.
      * 
@@ -1459,7 +1491,6 @@ public NClob getNClob(String parameterName) throws SQLException {
         } else {
             columnNameWithoutAtSign = 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:
@@ -1504,7 +1535,7 @@ public NClob getNClob(String parameterName) throws SQLException {
             return matchPos + 1;
         else
             return matchPos;
-    }
+    } 
 
     public void setTimestamp(String sCol,
             java.sql.Timestamp x,

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

@@ -264,7 +264,7 @@ static ParsedSQLCacheItem  parseAndCacheSQL(Sha1HashKey key, String sql) throws
         String parsedSql = translator.translate(sql);
         String procName = translator.getProcedureName(); // may return null        
         boolean returnValueSyntax = translator.hasReturnValueSyntax();
-        int paramCount = countParams(parsedSql);
+        int paramCount = countParams(sql);
 
         ParsedSQLCacheItem  cacheItem = new ParsedSQLCacheItem (parsedSql, paramCount, procName, returnValueSyntax);
         parsedSQLCache.putIfAbsent(key, cacheItem);
@@ -287,15 +287,15 @@ static ParsedSQLCacheItem  parseAndCacheSQL(Sha1HashKey key, String sql) throws
       * @param sql
       *          SQL text to parse for number of parameters to intialize.
       */
-     private static int countParams(String sql) {
+     static int countParams(String sql) {
          int nParams = 0;
 
          // Figure out the expected number of parameters by counting the
          // parameter placeholders in the SQL string.
          int offset = -1;
          while ((offset = ParameterUtils.scanSQLForChar('?', sql, ++offset)) < sql.length())
              ++nParams;
-
+         
          return nParams;
      }