Fix get_results_from_sfqid with DictCursor + multi statements (#2531)

Port PR: snowflakedb/Stored-Proc-Python-Connector#225

I noticed that get_results_from_sfqid assumes that fetchall returns a tuple when that's not necessarily the case. Fixing it here + adding a test that fails without the fix.

```
E                   AssertionError: assert [{'multiple s...ccessfully.'}] == [{'1': 1}]
E                     At index 0 diff: {'multiple statement execution': 'Multiple statements executed successfully.'} != {'1': 1}
E                     Full diff:
E                     - [{'1': 1}]
E                     + [{'multiple statement execution': 'Multiple statements executed successfully.'}]
```

Author: sfc-gh-bchinn

DESCRIPTION.md

@@ -7,36 +7,9 @@ https://docs.snowflake.com/
 Source code is also available at: https://github.com/snowflakedb/snowflake-connector-python
 
 # Release Notes
-- v4.1.0(TBD)
-  - Added the `SNOWFLAKE_AUTH_FORCE_SERVER` environment variable to force the use of the local-listening server when using the `externalbrowser` auth method.
-    - This allows headless environments (like Docker or Airflow) running locally to auth via a browser URL.
-  - Fix compilation error when building from sources with libc++.
-
-- v4.0.0(October 09,2025)
-  - Added support for checking certificates revocation using revocation lists (CRLs)
-  - Added `CERT_REVOCATION_CHECK_MODE` to `CLIENT_ENVIRONMENT`
+- v3.18.0(TBD)
   - Added the `workload_identity_impersonation_path` parameter to support service account impersonation for Workload Identity Federation on GCP and AWS workloads only
   - Fixed `get_results_from_sfqid` when using `DictCursor` and executing multiple statements at once
-  - Added the `oauth_credentials_in_body` parameter supporting an option to send the oauth client credentials in the request body
-  - Fix retry behavior for `ECONNRESET` error
-  - Added an option to exclude `botocore` and `boto3` dependencies by setting `SNOWFLAKE_NO_BOTO` environment variable during installation
-  - Revert changing exception type in case of token expired scenario for `Oauth` authenticator back to `DatabaseError`
-  - Enhanced configuration file security checks with stricter permission validation.
-    - Configuration files writable by group or others now raise a `ConfigSourceError` with detailed permission information, preventing potential credential tampering.
-  - Fixed the return type of `SnowflakeConnection.cursor(cursor_class)` to match the type of `cursor_class`
-  - Constrained the types of `fetchone`, `fetchmany`, `fetchall`
-    - As part of this fix, `DictCursor` is no longer a subclass of `SnowflakeCursor`; use `SnowflakeCursorBase` as a superclass of both.
-  - Fix "No AWS region was found" error if AWS region was set in `AWS_DEFAULT_REGION` variable instead of `AWS_REGION` for `WORKLOAD_IDENTITY` authenticator
-  - Add `ocsp_root_certs_dict_lock_timeout` connection parameter to set the timeout (in seconds) for acquiring the lock on the OCSP root certs dictionary. Default value for this parameter is -1 which indicates no timeout.
-  - Fixed behaviour of trying S3 Transfer Accelerate endpoint by default for internal stages, and always getting HTTP403 due to permissions missing on purpose. Now /accelerate is not attempted.
-
-- v3.18.0(October 03,2025)
-  - Added support for pandas conversion for Day-time and Year-Month Interval types
-
-- v3.17.4(September 22,2025)
-  - Added support for intermediate certificates as roots when they are stored in the trust store
-  - Bumped up vendored `urllib3` to `2.5.0` and `requests` to `v2.32.5`
-  - Dropped support for OpenSSL versions older than 1.1.1
 
 - v3.17.3(September 02,2025)
   - Enhanced configuration file permission warning messages.

src/snowflake/connector/aio/_cursor.py

@@ -1279,8 +1279,7 @@ async def wait_until_ready() -> None:
         await self.connection.get_query_status_throw_if_error(
             sfqid
         )  # Trigger an exception if query failed
-        klass = self.__class__
-        self._inner_cursor = klass(self.connection)
+        self._inner_cursor = SnowflakeCursor(self.connection)
         self._sfqid = sfqid
         self._prefetch_hook = wait_until_ready
 

src/snowflake/connector/cursor.py

@@ -1749,8 +1749,7 @@ def wait_until_ready() -> None:
         self.connection.get_query_status_throw_if_error(
             sfqid
         )  # Trigger an exception if query failed
-        klass = self.__class__
-        self._inner_cursor = klass(self.connection)
+        self._inner_cursor = SnowflakeCursor(self.connection)
         self._sfqid = sfqid
         self._prefetch_hook = wait_until_ready
 

test/integ/aio_it/test_async_async.py

@@ -11,20 +11,22 @@
 import pytest
 
 from snowflake.connector import DatabaseError, ProgrammingError
+from snowflake.connector.aio import DictCursor, SnowflakeCursor
 from snowflake.connector.constants import QueryStatus
 
 # Mark all tests in this file to time out after 2 minutes to prevent hanging forever
 pytestmark = pytest.mark.timeout(120)
 
 
-async def test_simple_async(conn_cnx):
+@pytest.mark.parametrize("cursor_class", [SnowflakeCursor, DictCursor])
+async def test_simple_async(conn_cnx, cursor_class):
     """Simple test to that shows the most simple usage of fire and forget.
 
     This test also makes sure that wait_until_ready function's sleeping is tested and
     that some fields are copied over correctly from the original query.
     """
     async with conn_cnx() as con:
-        async with con.cursor() as cur:
+        async with con.cursor(cursor_class) as cur:
             await cur.execute_async(
                 "select count(*) from table(generator(timeLimit => 5))"
             )

test/integ/aio_it/test_multi_statement_async.py

@@ -10,7 +10,7 @@
 import pytest
 
 from snowflake.connector import ProgrammingError, errors
-from snowflake.connector.aio import SnowflakeCursor
+from snowflake.connector.aio import DictCursor, SnowflakeCursor
 from snowflake.connector.constants import PARAMETER_MULTI_STATEMENT_COUNT, QueryStatus
 from snowflake.connector.util_text import random_string
 
@@ -141,10 +141,11 @@ async def test_binding_multi(conn_cnx, style: str, skip_to_last_set: bool):
             )
 
 
-async def test_async_exec_multi(conn_cnx, skip_to_last_set: bool):
+@pytest.mark.parametrize("cursor_class", [SnowflakeCursor, DictCursor])
+async def test_async_exec_multi(conn_cnx, cursor_class, skip_to_last_set: bool):
     """Tests whether async execution query works within a multi-statement"""
     async with conn_cnx() as con:
-        async with con.cursor() as cur:
+        async with con.cursor(cursor_class) as cur:
             await cur.execute_async(
                 "select 1; select 2; select count(*) from table(generator(timeLimit => 1)); select 'b';",
                 num_statements=4,
@@ -162,9 +163,23 @@ async def test_async_exec_multi(conn_cnx, skip_to_last_set: bool):
             )
 
             await cur.get_results_from_sfqid(q_id)
+            if cursor_class == SnowflakeCursor:
+                expected = [
+                    [(1,)],
+                    [(2,)],
+                    lambda x: len(x) == 1 and len(x[0]) == 1 and x[0][0] > 0,
+                    [("b",)],
+                ]
+            elif cursor_class == DictCursor:
+                expected = [
+                    [{"1": 1}],
+                    [{"2": 2}],
+                    lambda x: len(x) == 1 and len(x[0]) == 1 and x[0]["COUNT(*)"] > 0,
+                    [{"'B'": "b"}],
+                ]
             await _check_multi_statement_results(
                 cur,
-                checks=[[(1,)], [(2,)], lambda x: x > [(0,)], [("b",)]],
+                checks=expected,
                 skip_to_last_set=skip_to_last_set,
             )
 

test/integ/test_async.py

@@ -7,6 +7,7 @@
 import pytest
 
 from snowflake.connector import DatabaseError, ProgrammingError
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
 # Mark all tests in this file to time out after 2 minutes to prevent hanging forever
 pytestmark = [pytest.mark.timeout(120), pytest.mark.skipolddriver]
@@ -17,14 +18,15 @@
     QueryStatus = None
 
 
-def test_simple_async(conn_cnx):
+@pytest.mark.parametrize("cursor_class", [SnowflakeCursor, DictCursor])
+def test_simple_async(conn_cnx, cursor_class):
     """Simple test to that shows the most simple usage of fire and forget.
 
     This test also makes sure that wait_until_ready function's sleeping is tested and
     that some fields are copied over correctly from the original query.
     """
     with conn_cnx() as con:
-        with con.cursor() as cur:
+        with con.cursor(cursor_class) as cur:
             cur.execute_async("select count(*) from table(generator(timeLimit => 5))")
             cur.get_results_from_sfqid(cur.sfqid)
             assert len(cur.fetchall()) == 1

test/integ/test_multi_statement.py

@@ -14,6 +14,7 @@
 
 import snowflake.connector.cursor
 from snowflake.connector import ProgrammingError, errors
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 
 try:  # pragma: no cover
     from snowflake.connector.constants import (
@@ -153,10 +154,11 @@ def test_binding_multi(conn_cnx, style: str, skip_to_last_set: bool):
             )
 
 
-def test_async_exec_multi(conn_cnx, skip_to_last_set: bool):
+@pytest.mark.parametrize("cursor_class", [SnowflakeCursor, DictCursor])
+def test_async_exec_multi(conn_cnx, cursor_class, skip_to_last_set: bool):
     """Tests whether async execution query works within a multi-statement"""
     with conn_cnx() as con:
-        with con.cursor() as cur:
+        with con.cursor(cursor_class) as cur:
             cur.execute_async(
                 "select 1; select 2; select count(*) from table(generator(timeLimit => 1)); select 'b';",
                 num_statements=4,
@@ -165,14 +167,29 @@ def test_async_exec_multi(conn_cnx, skip_to_last_set: bool):
             assert con.is_still_running(con.get_query_status(q_id))
         _wait_while_query_running(con, q_id, sleep_time=1)
     with conn_cnx() as con:
-        with con.cursor() as cur:
+        with con.cursor(cursor_class) as cur:
             _wait_until_query_success(con, q_id, num_checks=3, sleep_per_check=1)
             assert con.get_query_status_throw_if_error(q_id) == QueryStatus.SUCCESS
 
+            if cursor_class == SnowflakeCursor:
+                expected = [
+                    [(1,)],
+                    [(2,)],
+                    lambda x: len(x) == 1 and len(x[0]) == 1 and x[0][0] > 0,
+                    [("b",)],
+                ]
+            elif cursor_class == DictCursor:
+                expected = [
+                    [{"1": 1}],
+                    [{"2": 2}],
+                    lambda x: len(x) == 1 and len(x[0]) == 1 and x[0]["COUNT(*)"] > 0,
+                    [{"'B'": "b"}],
+                ]
+
             cur.get_results_from_sfqid(q_id)
             _check_multi_statement_results(
                 cur,
-                checks=[[(1,)], [(2,)], lambda x: x > [(0,)], [("b",)]],
+                checks=expected,
                 skip_to_last_set=skip_to_last_set,
             )