Merge branch 'main' into saumya/stress-tests-gh

Author: gargsaumya

.github/workflows/issue-acknowledge.yml

@@ -11,11 +11,11 @@ jobs:
   acknowledge:
     runs-on: ubuntu-latest
     permissions:
-      issues: read
+      issues: write
     steps:
       # Step 1: Wait 15 minutes
       - name: Wait 15 minutes
-        run: sleep 10
+        run: sleep 900
 
       # Step 2: Check if a maintainer already responded
       - name: Check for existing maintainer response
@@ -24,7 +24,7 @@ jobs:
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
-            const maintainers = ['sumitmsft','dlevy-msft-sql']; 
+            const maintainers = ['sumitmsft','dlevy-msft-sql','gargsaumya','bewithgaurav','subrata-ms','jahnvi480','saurabh500']; 
 
             const comments = await github.rest.issues.listComments({
               owner: context.repo.owner,
@@ -44,11 +44,25 @@ jobs:
         if: steps.check.outputs.skip == 'false'
         uses: actions/github-script@v7
         with:
-          github-token: ${{ secrets.SUMIT_PAT_FOR_AUTO_RESPONSE }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             await github.rest.issues.createComment({
               owner: context.repo.owner,
               repo: context.repo.repo,
               issue_number: context.payload.issue.number,
-              body: `Hi @${context.payload.issue.user.login}, thank you for opening this issue!\n\nOur team will review it shortly. We aim to triage all new issues within 24-48 hours and get back to you.\n\nThank you for your patience!`
+              body: `Hi @${context.payload.issue.user.login}, thank you for opening this issue!\n\nOur team will review it shortly. We aim to triage all new issues within 24-48 hours and get back to you.\n\nIf you have additional information to share, please feel free to update the issue.\n\nThank you for your patience!`
+            });
+
+      # Step 4: Add "triage needed" label if no maintainer has responded
+      - name: Add triage needed label
+        if: steps.check.outputs.skip == 'false'
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            await github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.payload.issue.number,
+              labels: ['triage needed']
             });

.github/workflows/pr-code-coverage.yml

@@ -426,8 +426,8 @@ jobs:
             --arg covered_lines "${{ env.COVERED_LINES }}" \
             --arg total_lines "${{ env.TOTAL_LINES }}" \
             --arg patch_coverage_pct "${{ env.PATCH_COVERAGE_PCT }}" \
-            --arg low_coverage_files "${{ env.LOW_COVERAGE_FILES }}" \
-            --arg patch_coverage_summary "${{ env.PATCH_COVERAGE_SUMMARY }}" \
+            --arg low_coverage_files "$LOW_COVERAGE_FILES" \
+            --arg patch_coverage_summary "$PATCH_COVERAGE_SUMMARY" \
             --arg ado_url "${{ env.ADO_URL }}" \
             '{
               pr_number: $pr_number,

mssql_python/connection_string_parser.py

@@ -108,8 +108,10 @@ def _normalize_params(params: Dict[str, str], warn_rejected: bool = True) -> Dic
                 if normalized_key in _RESERVED_PARAMETERS:
                     continue
 
-                # Parameter is allowed
-                filtered[normalized_key] = value
+                # First-wins: match ODBC behaviour where the first
+                # occurrence of a synonym group takes precedence.
+                if normalized_key not in filtered:
+                    filtered[normalized_key] = value
             else:
                 # Parameter is not in allow-list
                 # Note: In normal flow, this should be empty since parser validates first

mssql_python/constants.py

@@ -115,6 +115,8 @@ class ConstantsDDBC(Enum):
     SQL_FETCH_RELATIVE = 6
     SQL_FETCH_BOOKMARK = 8
     SQL_DATETIMEOFFSET = -155
+    SQL_SS_TIME2 = -154
+    SQL_SS_XML = -152
     SQL_C_SS_TIMESTAMPOFFSET = 0x4001
     SQL_SCOPE_CURROW = 0
     SQL_BEST_ROWID = 1
@@ -365,6 +367,12 @@ def get_valid_types(cls) -> set:
             ConstantsDDBC.SQL_DATE.value,
             ConstantsDDBC.SQL_TIME.value,
             ConstantsDDBC.SQL_TIMESTAMP.value,
+            ConstantsDDBC.SQL_TYPE_DATE.value,
+            ConstantsDDBC.SQL_TYPE_TIME.value,
+            ConstantsDDBC.SQL_TYPE_TIMESTAMP.value,
+            ConstantsDDBC.SQL_SS_TIME2.value,
+            ConstantsDDBC.SQL_DATETIMEOFFSET.value,
+            ConstantsDDBC.SQL_SS_XML.value,
             ConstantsDDBC.SQL_GUID.value,
         }
 

mssql_python/cursor.py

@@ -17,7 +17,7 @@
 import warnings
 from typing import List, Union, Any, Optional, Tuple, Sequence, TYPE_CHECKING, Iterable
 from mssql_python.constants import ConstantsDDBC as ddbc_sql_const, SQLTypes
-from mssql_python.helpers import check_error
+from mssql_python.helpers import check_error, connstr_to_pycore_params
 from mssql_python.logging import logger
 from mssql_python import ddbc_bindings
 from mssql_python.exceptions import (
@@ -844,7 +844,7 @@ def _reset_inputsizes(self) -> None:
         self._inputsizes = None
 
     def _get_c_type_for_sql_type(self, sql_type: int) -> int:
-        """Map SQL type to appropriate C type for parameter binding"""
+        """Map SQL type to appropriate C type for parameter binding."""
         sql_to_c_type = {
             ddbc_sql_const.SQL_CHAR.value: ddbc_sql_const.SQL_C_CHAR.value,
             ddbc_sql_const.SQL_VARCHAR.value: ddbc_sql_const.SQL_C_CHAR.value,
@@ -865,9 +865,19 @@ def _get_c_type_for_sql_type(self, sql_type: int) -> int:
             ddbc_sql_const.SQL_BINARY.value: ddbc_sql_const.SQL_C_BINARY.value,
             ddbc_sql_const.SQL_VARBINARY.value: ddbc_sql_const.SQL_C_BINARY.value,
             ddbc_sql_const.SQL_LONGVARBINARY.value: ddbc_sql_const.SQL_C_BINARY.value,
+            # ODBC 3.x date/time types (reported by ODBC 18 driver)
+            ddbc_sql_const.SQL_TYPE_DATE.value: ddbc_sql_const.SQL_C_TYPE_DATE.value,
+            ddbc_sql_const.SQL_TYPE_TIME.value: ddbc_sql_const.SQL_C_TYPE_TIME.value,
+            ddbc_sql_const.SQL_TYPE_TIMESTAMP.value: ddbc_sql_const.SQL_C_TYPE_TIMESTAMP.value,
+            ddbc_sql_const.SQL_SS_TIME2.value: ddbc_sql_const.SQL_C_TYPE_TIME.value,
+            ddbc_sql_const.SQL_DATETIMEOFFSET.value: ddbc_sql_const.SQL_C_SS_TIMESTAMPOFFSET.value,
+            # ODBC 2.x aliases (accepted by setinputsizes via SQLTypes)
             ddbc_sql_const.SQL_DATE.value: ddbc_sql_const.SQL_C_TYPE_DATE.value,
             ddbc_sql_const.SQL_TIME.value: ddbc_sql_const.SQL_C_TYPE_TIME.value,
             ddbc_sql_const.SQL_TIMESTAMP.value: ddbc_sql_const.SQL_C_TYPE_TIMESTAMP.value,
+            # Other types
+            ddbc_sql_const.SQL_GUID.value: ddbc_sql_const.SQL_C_GUID.value,
+            ddbc_sql_const.SQL_SS_XML.value: ddbc_sql_const.SQL_C_WCHAR.value,
         }
         return sql_to_c_type.get(sql_type, ddbc_sql_const.SQL_C_DEFAULT.value)
 
@@ -1026,34 +1036,71 @@ def _map_data_type(self, sql_type):
         """
         Map SQL data type to Python data type.
 
+        Maps the ODBC SQL type code returned by SQLDescribeCol to the
+        corresponding Python type for cursor.description[i][1].
+
+        The ODBC 18 driver for SQL Server reports these type codes:
+          Standard ODBC 3.x types:
+            SQL_CHAR(1), SQL_VARCHAR(12), SQL_LONGVARCHAR(-1),
+            SQL_WCHAR(-8), SQL_WVARCHAR(-9), SQL_WLONGVARCHAR(-10),
+            SQL_INTEGER(4), SQL_SMALLINT(5), SQL_TINYINT(-6), SQL_BIGINT(-5),
+            SQL_BIT(-7), SQL_FLOAT(6), SQL_REAL(7), SQL_DOUBLE(8),
+            SQL_DECIMAL(3), SQL_NUMERIC(2),
+            SQL_BINARY(-2), SQL_VARBINARY(-3), SQL_LONGVARBINARY(-4),
+            SQL_TYPE_DATE(91), SQL_TYPE_TIME(92), SQL_TYPE_TIMESTAMP(93), SQL_GUID(-11)
+          SQL Server-specific types (from msodbcsql.h):
+            SQL_SS_TIME2(-154)  for time columns
+            SQL_DATETIMEOFFSET(-155)  for datetimeoffset columns
+            SQL_SS_XML(-152)  for xml columns
+
+        ODBC 2.x aliases (9, 10, 11) are also accepted defensively.
+
         Args:
-            sql_type: SQL data type.
+            sql_type: SQL data type code from SQLDescribeCol.
 
         Returns:
             Corresponding Python data type.
         """
         sql_to_python_type = {
-            ddbc_sql_const.SQL_INTEGER.value: int,
-            ddbc_sql_const.SQL_VARCHAR.value: str,
-            ddbc_sql_const.SQL_WVARCHAR.value: str,
+            # String types
             ddbc_sql_const.SQL_CHAR.value: str,
+            ddbc_sql_const.SQL_VARCHAR.value: str,
+            ddbc_sql_const.SQL_LONGVARCHAR.value: str,
             ddbc_sql_const.SQL_WCHAR.value: str,
+            ddbc_sql_const.SQL_WVARCHAR.value: str,
+            ddbc_sql_const.SQL_WLONGVARCHAR.value: str,
+            # Integer types
+            ddbc_sql_const.SQL_INTEGER.value: int,
+            ddbc_sql_const.SQL_SMALLINT.value: int,
+            ddbc_sql_const.SQL_TINYINT.value: int,
+            ddbc_sql_const.SQL_BIGINT.value: int,
+            # Floating-point types
             ddbc_sql_const.SQL_FLOAT.value: float,
             ddbc_sql_const.SQL_DOUBLE.value: float,
+            ddbc_sql_const.SQL_REAL.value: float,
+            # Exact numeric types
             ddbc_sql_const.SQL_DECIMAL.value: decimal.Decimal,
             ddbc_sql_const.SQL_NUMERIC.value: decimal.Decimal,
-            ddbc_sql_const.SQL_DATE.value: datetime.date,
-            ddbc_sql_const.SQL_TIMESTAMP.value: datetime.datetime,
-            ddbc_sql_const.SQL_TIME.value: datetime.time,
+            # Date/time types — values the ODBC 18 driver actually reports
+            ddbc_sql_const.SQL_TYPE_DATE.value: datetime.date,  # 91 — date
+            ddbc_sql_const.SQL_TYPE_TIME.value: datetime.time,  # 92 — time (ODBC 3.x)
+            ddbc_sql_const.SQL_TYPE_TIMESTAMP.value: datetime.datetime,  # 93 — datetime/datetime2/smalldatetime
+            ddbc_sql_const.SQL_SS_TIME2.value: datetime.time,  # -154 — time
+            ddbc_sql_const.SQL_DATETIMEOFFSET.value: datetime.datetime,  # -155 — datetimeoffset
+            # ODBC 2.x date/time aliases (defensive, in case any driver reports these)
+            ddbc_sql_const.SQL_DATE.value: datetime.date,  # 9
+            ddbc_sql_const.SQL_TIME.value: datetime.time,  # 10
+            ddbc_sql_const.SQL_TIMESTAMP.value: datetime.datetime,  # 11
+            # Boolean
             ddbc_sql_const.SQL_BIT.value: bool,
-            ddbc_sql_const.SQL_TINYINT.value: int,
-            ddbc_sql_const.SQL_SMALLINT.value: int,
-            ddbc_sql_const.SQL_BIGINT.value: int,
+            # Binary types
             ddbc_sql_const.SQL_BINARY.value: bytes,
             ddbc_sql_const.SQL_VARBINARY.value: bytes,
             ddbc_sql_const.SQL_LONGVARBINARY.value: bytes,
+            # UUID
             ddbc_sql_const.SQL_GUID.value: uuid.UUID,
-            # Add more mappings as needed
+            # XML — driver reports SQL_SS_XML (-152), fetched as str
+            ddbc_sql_const.SQL_SS_XML.value: str,
         }
         return sql_to_python_type.get(sql_type, str)
 
@@ -2451,6 +2498,7 @@ def nextset(self) -> Union[bool, None]:
         )
         return True
 
+    # ── Mapping from ODBC connection-string keywords (lowercase, as _parse returns)
     def _bulkcopy(
         self,
         table_name: str,
@@ -2585,38 +2633,10 @@ def _bulkcopy(
                 "Specify the target database explicitly to avoid accidentally writing to system databases."
             )
 
-        # Build connection context for bulk copy library
-        # Note: Password is extracted separately to avoid storing it in the main context
-        # dict that could be accidentally logged or exposed in error messages.
-        trust_cert = params.get("trustservercertificate", "yes").lower() in ("yes", "true")
-
-        # Parse encryption setting from connection string
-        encrypt_param = params.get("encrypt")
-        if encrypt_param is not None:
-            encrypt_value = encrypt_param.strip().lower()
-            if encrypt_value in ("yes", "true", "mandatory", "required"):
-                encryption = "Required"
-            elif encrypt_value in ("no", "false", "optional"):
-                encryption = "Optional"
-            else:
-                # Pass through unrecognized values (e.g., "Strict") to the underlying driver
-                encryption = encrypt_param
-        else:
-            encryption = "Optional"
-
-        context = {
-            "server": params.get("server"),
-            "database": params.get("database"),
-            "trust_server_certificate": trust_cert,
-            "encryption": encryption,
-        }
-
-        # Build pycore_context with appropriate authentication.
-        # For Azure AD: acquire a FRESH token right now instead of reusing
-        # the one from connect() time — avoids expired-token errors when
-        # bulkcopy() is called long after the original connection.
-        pycore_context = dict(context)
+        # Translate parsed connection string into the dict py-core expects.
+        pycore_context = connstr_to_pycore_params(params)
 
+        # Token acquisition — only thing cursor must handle (needs azure-identity SDK)
         if self.connection._auth_type:
             # Fresh token acquisition for mssql-py-core connection
             from mssql_python.auth import AADAuth
@@ -2633,10 +2653,6 @@ def _bulkcopy(
                 "Bulk copy: acquired fresh Azure AD token for auth_type=%s",
                 self.connection._auth_type,
             )
-        else:
-            # SQL Server authentication — use uid/password from connection string
-            pycore_context["user_name"] = params.get("uid", "")
-            pycore_context["password"] = params.get("pwd", "")
 
         pycore_connection = None
         pycore_cursor = None
@@ -2675,9 +2691,8 @@ def _bulkcopy(
         finally:
             # Clear sensitive data to minimize memory exposure
             if pycore_context:
-                pycore_context.pop("password", None)
-                pycore_context.pop("user_name", None)
-                pycore_context.pop("access_token", None)
+                for key in ("password", "user_name", "access_token"):
+                    pycore_context.pop(key, None)
             # Clean up bulk copy resources
             for resource in (pycore_cursor, pycore_connection):
                 if resource and hasattr(resource, "close"):

mssql_python/helpers.py

@@ -250,6 +250,97 @@ def _sanitize_for_logging(input_val: Any, max_length: int = max_log_length) -> s
     return True, None, sanitized_attr, sanitized_val
 
 
+def connstr_to_pycore_params(params: dict) -> dict:
+    """Translate parsed ODBC connection-string params for py-core's bulk copy path.
+
+    When ``cursor.bulkcopy()`` is called, mssql-python opens a *separate*
+    connection through mssql-py-core.
+    py-core's ``connection.rs`` expects a Python dict with snake_case keys —
+    different from the ODBC-style keys that ``_ConnectionStringParser._parse``
+    returns.
+
+    This function bridges that gap: it maps lowercase ODBC keys (e.g.
+    ``"trustservercertificate"``) to py-core keys (``"trust_server_certificate"``)
+    and converts numeric strings to ``int`` for timeout/size params.
+    Boolean params (TrustServerCertificate, MultiSubnetFailover) are passed as
+    strings — ``connection.rs`` validates Yes/No and rejects invalid values.
+    Unrecognised keys are silently dropped.
+    """
+    # Only keys listed below are forwarded to py-core.
+    # Unknown/reserved keys (app, workstationid, language, connect_timeout,
+    # mars_connection) are silently dropped here.  In the normal connect()
+    # path the parser validates keywords first (validate_keywords=True),
+    # but bulkcopy parses with validation off, so this mapping is the
+    # authoritative filter in that path.
+    key_map = {
+        # auth / credentials
+        "uid": "user_name",
+        "pwd": "password",
+        "trusted_connection": "trusted_connection",
+        "authentication": "authentication",
+        # server (accept parser synonyms)
+        "server": "server",
+        "addr": "server",
+        "address": "server",
+        # database
+        "database": "database",
+        "applicationintent": "application_intent",
+        # encryption / TLS (include snake_case alias the parser may emit)
+        "encrypt": "encryption",
+        "trustservercertificate": "trust_server_certificate",
+        "trust_server_certificate": "trust_server_certificate",
+        "hostnameincertificate": "host_name_in_certificate",
+        "servercertificate": "server_certificate",
+        # Kerberos
+        "serverspn": "server_spn",
+        # network
+        "multisubnetfailover": "multi_subnet_failover",
+        "ipaddresspreference": "ip_address_preference",
+        "keepalive": "keep_alive",
+        "keepaliveinterval": "keep_alive_interval",
+        # sizing / limits ("packet size" with space is a common pyodbc-ism)
+        "packetsize": "packet_size",
+        "packet size": "packet_size",
+        "connectretrycount": "connect_retry_count",
+        "connectretryinterval": "connect_retry_interval",
+    }
+    int_keys = {
+        "packet_size",
+        "connect_retry_count",
+        "connect_retry_interval",
+        "keep_alive",
+        "keep_alive_interval",
+    }
+
+    pycore_params: dict = {}
+
+    for connstr_key, pycore_key in key_map.items():
+        raw_value = params.get(connstr_key)
+        if raw_value is None:
+            continue
+
+        # First-wins: match ODBC behaviour — first synonym in the
+        # connection string takes precedence (e.g. Addr before Server).
+        if pycore_key in pycore_params:
+            continue
+
+        # ODBC values are always strings; py-core expects native types for int keys.
+        # Boolean params (trust_server_certificate, multi_subnet_failover) are passed
+        # as strings — all Yes/No validation is in connection.rs for single-location
+        # consistency with Encrypt, ApplicationIntent, IPAddressPreference, etc.
+        if pycore_key in int_keys:
+            # Numeric params (timeouts, packet size, etc.) — skip on bad input
+            try:
+                pycore_params[pycore_key] = int(raw_value)
+            except (ValueError, TypeError):
+                pass  # let py-core fall back to its compiled-in default
+        else:
+            # String params (server, database, encryption, etc.) — pass through
+            pycore_params[pycore_key] = raw_value
+
+    return pycore_params
+
+
 # Settings functionality moved here to avoid circular imports
 
 # Initialize the locale setting only once at module import time