Introduce new prepareMethod exec for PreparedStatement

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

@@ -15,7 +15,9 @@
 import java.net.InetSocketAddress;
 import java.net.SocketException;
 import java.net.UnknownHostException;
+import java.sql.Blob;
 import java.sql.CallableStatement;
+import java.sql.Clob;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
@@ -29,6 +31,7 @@
 import java.sql.Savepoint;
 import java.sql.Statement;
 import java.text.MessageFormat;
+import java.text.SimpleDateFormat;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
@@ -230,6 +233,9 @@ public class SQLServerConnection implements ISQLServerConnection, java.io.Serial
     /** Engine Edition 11 = Azure Synapse serverless SQL pool */
     private static final int ENGINE_EDITION_SQL_AZURE_SYNAPSE_SERVERLESS_SQL_POOL = 11;
 
+    // --- SQL Parameter Expansion Methods ---
+    private static final SimpleDateFormat TS_FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US);
+
     /**
      * Azure SQL server endpoints
      */
@@ -8453,6 +8459,146 @@ String replaceParameterMarkers(String sqlSrc, int[] paramPositions, Parameter[]
         return new String(sqlDst, 0, dstBegin);
     }
 
+    String replaceParameterMarkersWithValues(String sqlSrc, int[] paramPositions, Parameter[] params,
+            boolean isReturnValueSyntax) throws SQLServerException {
+
+        // EXEC method: substitute actual parameter values directly into SQL
+        if (params == null || params.length == 0) {
+            return sqlSrc;
+        }
+
+        StringBuilder result = new StringBuilder(sqlSrc.length() + params.length * 20);
+        try {
+            // Estimate capacity for the result
+            int srcBegin = 0;
+
+            for (int paramIndex = 0; paramIndex < paramPositions.length; paramIndex++) {
+                int srcEnd = paramPositions[paramIndex];
+
+                // Append SQL text before this parameter marker
+                result.append(sqlSrc, srcBegin, srcEnd);
+
+                // Get parameter value and format it
+                Object value = null;
+                if (params[paramIndex] != null) {
+                    value = params[paramIndex].getSetterValue();
+                }
+
+                // Append formatted literal value
+                result.append(formatLiteralValue(value));
+
+                // Move past the '?' marker
+                srcBegin = srcEnd + 1;
+            }
+
+            // Append remaining SQL after last parameter
+            result.append(sqlSrc, srcBegin, sqlSrc.length());
+        } catch (Exception e) {
+            throw new SQLServerException("Error during parameter replacement", e);
+        }
+
+        return result.toString();
+    }
+
+    // Format Java value into a T-SQL literal safe for SQL Server
+    String formatLiteralValue(Object value) throws SQLException {
+        if (value == null) {
+            return "NULL";
+        } else if (value instanceof String) {
+            String prefix = sendStringParametersAsUnicode() ? "N'" : "'";
+            return prefix + escapeSQLString((String) value) + "'";
+        } else if (value instanceof Character) {
+            String prefix = sendStringParametersAsUnicode() ? "N'" : "'";
+            return prefix + escapeSQLString(value.toString()) + "'";
+        } else if (value instanceof Boolean) {
+            return ((Boolean) value) ? "1" : "0";
+        } else if (value instanceof java.math.BigDecimal) {
+            // Use toPlainString() to avoid scientific notation
+            java.math.BigDecimal bd = (java.math.BigDecimal) value;
+            String plainStr = bd.toPlainString();
+
+            // For very large or high-precision decimals, wrap in CAST to preserve precision
+            // SQL Server decimal max precision is 38, scale max 38
+            int precision = bd.precision();
+            int scale = bd.scale();
+
+            if (precision > 18 || scale > 6) {
+                // Need explicit CAST for high precision numbers
+                // Clamp to SQL Server limits: decimal(38, min(scale, 38))
+                // Ensure scale <= precision
+                int sqlPrecision = Math.min(precision, 38);
+                int sqlScale = Math.min(Math.min(scale, 38), sqlPrecision);
+                return "CAST(" + plainStr + " AS DECIMAL(" + sqlPrecision + "," + sqlScale + "))";
+            }
+            return plainStr;
+        } else if (value instanceof Byte || value instanceof Short || value instanceof Integer
+                || value instanceof Long) {
+            return value.toString();
+        } else if (value instanceof Float) {
+            // Float and Double need special handling to avoid precision loss and scientific
+            // notation
+            Float f = (Float) value;
+            // Handle special float values that cannot be converted to BigDecimal
+            if (f.isInfinite() || f.isNaN()) {
+                String prefix = sendStringParametersAsUnicode() ? "N'" : "'";
+                return prefix + escapeSQLString(f.toString()) + "'";
+            }
+            // Convert Float to BigDecimal for precise representation
+            return new java.math.BigDecimal(value.toString()).toPlainString();
+        } else if (value instanceof Double) {
+            Double d = (Double) value;
+            // Handle special double values that cannot be converted to BigDecimal
+            if (d.isInfinite() || d.isNaN()) {
+                String prefix = sendStringParametersAsUnicode() ? "N'" : "'";
+                return prefix + escapeSQLString(d.toString()) + "'";
+            }
+            // Convert Double to BigDecimal for precise representation
+            return new java.math.BigDecimal(value.toString()).toPlainString();
+        } else if (value instanceof java.sql.Date) {
+            return "CAST('" + escapeSQLString(value.toString()) + "' AS DATE)";
+        } else if (value instanceof java.sql.Time) {
+            return "CAST('" + escapeSQLString(value.toString()) + "' AS TIME)";
+        } else if (value instanceof java.sql.Timestamp) {
+            return "CAST('" + escapeSQLString(value.toString()) + "' AS DATETIME2)";
+        } else if (value instanceof java.util.Date) {
+            // generic java.util.Date -> timestamp
+            return "CAST('" + TS_FMT.format((java.util.Date) value) + "' AS DATETIME2)";
+        } else if (value instanceof byte[]) {
+            return bytesToHexLiteral((byte[]) value);
+        } else if (value instanceof Blob) {
+            Blob b = (Blob) value;
+            int len = (int) b.length();
+            byte[] bytes = b.getBytes(1, len);
+            return bytesToHexLiteral(bytes);
+        } else if (value instanceof Clob) {
+            Clob c = (Clob) value;
+            String s = c.getSubString(1, (int) c.length());
+            String prefix = sendStringParametersAsUnicode() ? "N'" : "'";
+            return prefix + escapeSQLString(s) + "'";
+        } else {
+            // fallback
+            String prefix = sendStringParametersAsUnicode() ? "N'" : "'";
+            return prefix + escapeSQLString(value.toString()) + "'";
+        }
+    }
+
+    private String escapeSQLString(String s) {
+        if (s == null || s.isEmpty())
+            return "";
+        // double single quotes
+        return s.replace("'", "''");
+    }
+
+    private String bytesToHexLiteral(byte[] bytes) {
+        if (bytes == null || bytes.length == 0)
+            return "0x";
+        StringBuilder sb = new StringBuilder(bytes.length * 2 + 2);
+        sb.append("0x");
+        for (byte b : bytes)
+            sb.append(String.format("%02X", b));
+        return sb.toString();
+    }
+
     /**
      * Makes a SQL Server style parameter name.
      * 

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(),