Introduce new prepareMethod exec for PreparedStatement

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

@@ -8425,6 +8425,41 @@ void endRequestInternal() throws SQLException {
 
     String replaceParameterMarkers(String sqlSrc, int[] paramPositions, Parameter[] params,
             boolean isReturnValueSyntax) {
+        return replaceParameterMarkers(sqlSrc, paramPositions, params, isReturnValueSyntax, false);
+    }
+
+    String replaceParameterMarkers(String sqlSrc, int[] paramPositions, Parameter[] params,
+            boolean isReturnValueSyntax, boolean useDirectValues) {
+
+        if (useDirectValues) {
+            // EXEC method: substitute actual parameter values directly into SQL
+            if (params == null || params.length == 0) {
+                return sqlSrc;
+            }
+
+            // Convert Parameter array to List<Object> for
+            // SqlServerPreparedStatementExpander
+            List<Object> paramValues = new ArrayList<>(params.length);
+            for (Parameter param : params) {
+                if (param == null) {
+                    paramValues.add(null);
+                } else {
+                    try {
+                        Object value = param.getSetterValue();
+                        paramValues.add(value);
+                    } catch (Exception e) {
+                        // If getSetterValue() fails, add null
+                        paramValues.add(null);
+                    }
+                }
+            }
+
+            // Use SqlServerPreparedStatementExpander for robust parameter replacement
+            // This handles SQL parsing, comments, quotes, and NULL rewrites automatically
+            return SqlServerPreparedStatementExpander.expand(sqlSrc, paramValues);
+        }
+
+        // Existing RPC logic: replace ? with @p1, @p2 parameter names
         final int MAX_PARAM_NAME_LEN = 6;
         char[] sqlDst = new char[sqlSrc.length() + (params.length * (MAX_PARAM_NAME_LEN + OUT.length))
                 + (params.length * 2)];

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

@@ -532,7 +532,8 @@ public String toString() {
 
 enum PrepareMethod {
     PREPEXEC("prepexec"), // sp_prepexec, default prepare method
-    PREPARE("prepare");
+    PREPARE("prepare"),
+    EXEC("exec");
 
     private final String value;
 
@@ -840,7 +841,7 @@ public final class SQLServerDriver implements java.sql.Driver {
                     SQLServerDriverStringProperty.SERVER_CERTIFICATE.getDefaultValue(), false, null),
             new SQLServerDriverPropertyInfo(SQLServerDriverStringProperty.PREPARE_METHOD.toString(),
                     SQLServerDriverStringProperty.PREPARE_METHOD.getDefaultValue(), false,
-                    new String[] {PrepareMethod.PREPEXEC.toString(), PrepareMethod.PREPARE.toString()}),
+                    new String[] {PrepareMethod.PREPEXEC.toString(), PrepareMethod.PREPARE.toString(), PrepareMethod.EXEC.toString()}),
             new SQLServerDriverPropertyInfo(SQLServerDriverStringProperty.FAILOVER_PARTNER.toString(),
                     SQLServerDriverStringProperty.FAILOVER_PARTNER.getDefaultValue(), false, null),
             new SQLServerDriverPropertyInfo(SQLServerDriverStringProperty.HOSTNAME_IN_CERTIFICATE.toString(),

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

@@ -678,7 +678,10 @@ final void doExecutePreparedStatement(PrepStmtExecCmd command) throws SQLServerE
 
                 // Start the request and detach the response reader so that we can
                 // continue using it after we return.
-                TDSWriter tdsWriter = command.startRequest(TDS.PKT_RPC);
+                // Use PKT_QUERY for exec mode (direct execution), PKT_RPC for prepared
+                // statements
+                boolean isPrepareMethodExec = connection.getPrepareMethod().equals(PrepareMethod.EXEC.toString());
+                TDSWriter tdsWriter = command.startRequest(isPrepareMethodExec ? TDS.PKT_QUERY : TDS.PKT_RPC);
 
                 needsPrepare = doPrepExec(tdsWriter, inOutParam, hasNewTypeDefinitions, hasExistingTypeDefinitions,
                         command);
@@ -1119,6 +1122,10 @@ private boolean reuseCachedHandle(boolean hasNewTypeDefinitions, boolean discard
         if (isCursorable(executeMethod))
             return false;
 
+        // No caching for exec method as it always executes directly without preparation
+        if (connection.getPrepareMethod().equals(PrepareMethod.EXEC.toString()))
+            return false;
+
         // If current cache items needs to be discarded or New type definitions found with existing cached handle
         // reference then deregister cached
         // handle.
@@ -1165,6 +1172,31 @@ private boolean doPrepExec(TDSWriter tdsWriter, Parameter[] params, boolean hasN
 
         boolean needsPrepare = (hasNewTypeDefinitions && hasExistingTypeDefinitions) || !hasPreparedStatementHandle();
         boolean isPrepareMethodSpPrepExec = connection.getPrepareMethod().equals(PrepareMethod.PREPEXEC.toString());
+        boolean isPrepareMethodExec = connection.getPrepareMethod().equals(PrepareMethod.EXEC.toString());
+
+        // If using exec method, execute directly like regular Statement to mimic Sybase
+        // DYNAMIC_PREPARE=false
+        if (isPrepareMethodExec) {
+            // Build direct SQL using enhanced replaceParameterMarkers with direct values
+            String directSQL = connection.replaceParameterMarkers(userSQL, userSQLParamPositions, params, false, true);
+            // Note: TDS request already started as PKT_QUERY in caller
+
+            // For batch execution, prepend SET NOCOUNT OFF to ensure we get individual row
+            // counts
+            if (executeMethod == EXECUTE_BATCH) {
+                tdsWriter.writeString("SET NOCOUNT OFF; " + directSQL);
+            } else {
+                tdsWriter.writeString(directSQL);
+            }
+
+            expectPrepStmtHandle = false;
+            executedSqlDirectly = true;
+            expectCursorOutParams = false;
+            outParamIndexAdjustment = 0;
+            resetPrepStmtHandle(false);
+
+            return false; // No preparation needed
+        }
 
         // Cursors don't use statement pooling.
         if (isCursorable(executeMethod)) {
@@ -3062,12 +3094,41 @@ final void doExecutePreparedStatementBatch(PrepStmtBatchExecCmd batchCommand) th
                         hasNewTypeDefinitions = false;
                     }
 
+                    boolean isPrepareMethodExec = connection.getPrepareMethod()
+                            .equals(PrepareMethod.EXEC.toString());
+
                     if (numBatchesExecuted < numBatchesPrepared) {
                         // assert null != tdsWriter;
-                        tdsWriter.writeByte((byte) NBATCH_STATEMENT_DELIMITER);
+                        if (isPrepareMethodExec) {
+                            // For EXEC method with batching, each statement must be sent separately
+                            // to get individual update counts. Close current request and start a new one.
+                            ensureExecuteResultsReader(batchCommand.startResponse(getIsResponseBufferingAdaptive()));
+
+                            // Process results for previous statement
+                            while (numBatchesExecuted < numBatchesPrepared - 1) {
+                                startResults();
+                                if (!getNextResult(true))
+                                    break;
+                                if (null != resultSet) {
+                                    SQLServerException.makeFromDriverError(connection, this,
+                                            SQLServerException.getErrString("R_resultsetGeneratedForUpdate"), null,
+                                            false);
+                                }
+                                batchCommand.updateCounts[numBatchesExecuted++] = getUpdateCount();
+                            }
+
+                            // Start new request for next batch item
+                            resetForReexecute();
+                            tdsWriter = batchCommand.startRequest(TDS.PKT_QUERY);
+                        } else {
+                            // For RPC methods, use batch delimiter
+                            tdsWriter.writeByte((byte) NBATCH_STATEMENT_DELIMITER);
+                        }
                     } else {
                         resetForReexecute();
-                        tdsWriter = batchCommand.startRequest(TDS.PKT_RPC);
+                        // Use PKT_QUERY for exec mode (direct execution), PKT_RPC for prepared
+                        // statements
+                        tdsWriter = batchCommand.startRequest(isPrepareMethodExec ? TDS.PKT_QUERY : TDS.PKT_RPC);
                     }
 
                     // If we have to (re)prepare the statement then we must execute it so