SNOW-3665226: prevent fully-qualified DDL from polluting schema/database cache (#2909)

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: Patryk Czajka <patryk.czajka@snowflake.com>

Author: 3 people

DESCRIPTION.md

@@ -18,6 +18,7 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
   - Fixed S3 storage client to correctly handle 307/308 (method-preserving) and 301/302 (GET/HEAD only) redirects by disabling automatic redirect following and re-signing each request with AWS SigV4 credentials for the redirect target. The region is updated from the `x-amz-bucket-region` response header on each redirect. Redirects are capped at 5 hops.
   - Added native AKS (Azure Kubernetes Service) workload identity support. When running on AKS with workload identity configured, the connector automatically uses `WorkloadIdentityCredential` to authenticate via the injected service account credentials. OIDC backward compatibility is also supported.
   - Added the `workload_identity_aws_use_outbound_token` connection option (default `false`) to opt into AWS WIF JWT attestation via STS `GetWebIdentityToken` instead of the default SigV4 `GetCallerIdentity` method.
+  - Fixed a bug where a fully-qualified DDL statement (e.g. `CREATE VIEW db.schema.obj`) on a session with no current schema would populate the connector's cached `_schema`/`_database` from the referenced object's namespace. This made `get_current_schema()` diverge from the server's `CURRENT_SCHEMA()` and mis-qualified Snowpark temp objects (SNOW-3665226).
 
 - v4.6.0(May 28,2026)
   - Dropped support for Python 3.9. The minimum supported version is now Python 3.10.

src/snowflake/connector/aio/_connection.py

@@ -1084,9 +1084,14 @@ async def cmd_query(
             ret["data"] = {}
         if _update_current_object:
             data = ret["data"]
-            if "finalDatabaseName" in data and data["finalDatabaseName"] is not None:
+            is_context_switch = sql.strip().upper().startswith("USE ")
+            if data.get("finalDatabaseName") is not None and (
+                self._database is not None or is_context_switch
+            ):
                 self._database = data["finalDatabaseName"]
-            if "finalSchemaName" in data and data["finalSchemaName"] is not None:
+            if data.get("finalSchemaName") is not None and (
+                self._schema is not None or is_context_switch
+            ):
                 self._schema = data["finalSchemaName"]
             if "finalWarehouseName" in data and data["finalWarehouseName"] is not None:
                 self._warehouse = data["finalWarehouseName"]

src/snowflake/connector/connection.py

@@ -1989,9 +1989,14 @@ def cmd_query(
             ret["data"] = {}
         if _update_current_object:
             data = ret["data"]
-            if "finalDatabaseName" in data and data["finalDatabaseName"] is not None:
+            is_context_switch = sql.strip().upper().startswith("USE ")
+            if data.get("finalDatabaseName") is not None and (
+                self._database is not None or is_context_switch
+            ):
                 self._database = data["finalDatabaseName"]
-            if "finalSchemaName" in data and data["finalSchemaName"] is not None:
+            if data.get("finalSchemaName") is not None and (
+                self._schema is not None or is_context_switch
+            ):
                 self._schema = data["finalSchemaName"]
             if "finalWarehouseName" in data and data["finalWarehouseName"] is not None:
                 self._warehouse = data["finalWarehouseName"]

test/integ/test_connection.py

@@ -2685,3 +2685,124 @@ def test_empty_result_stats(conn_cnx):
                     num_dml_duplicates=None,
                 ),
             )
+
+
+def test_fqn_ddl_does_not_pollute_schema_cache(conn_cnx, db_parameters):
+    """SNOW-3665226: a fully-qualified DDL must not populate the connector's
+    cached _schema/_database when the session has none set (finalSchemaName/
+    finalDatabaseName reflect the referenced object, not the session context).
+    """
+    database = db_parameters["database"].upper()
+    schema = db_parameters["schema"].upper()
+    view_name = f'"{database}"."{schema}"."SNOW_3665226_REPRO_VIEW"'
+
+    # Open a session with NO database and NO schema so both caches start as None.
+    # The FQN object below lives in `database`.`schema`; without the guard the
+    # connector would overwrite the None caches with the object's namespace. We
+    # start _database as None too (not just _schema) so its "None is not
+    # overridden" path is actually exercised rather than a tautology.
+    with conn_cnx(database=None, schema=None) as cnx:
+        with cnx.cursor() as cur:
+            # Sanity-check: cache and server agree (both empty) before the test.
+            assert cnx._database is None
+            assert cnx._schema is None
+            server_db_before, server_schema_before = cur.execute(
+                "SELECT CURRENT_DATABASE(), CURRENT_SCHEMA()"
+            ).fetchone()
+            assert server_db_before is None
+            assert server_schema_before is None
+
+            # Touch a fully-qualified object — this must not change the session context.
+            try:
+                cur.execute(f"CREATE OR REPLACE TEMP VIEW {view_name} AS SELECT 1 AS x")
+            finally:
+                cur.execute(f"DROP VIEW IF EXISTS {view_name}")
+
+            # Caches must still be None — the session context never changed.
+            assert cnx._database is None, (
+                f"connector cache was polluted: _database={cnx._database!r}, "
+                "but no USE DATABASE was issued"
+            )
+            assert cnx._schema is None, (
+                f"connector cache was polluted: _schema={cnx._schema!r}, "
+                "but no USE SCHEMA was issued"
+            )
+
+            # Server must also still return NULL for the current namespace.
+            server_db_after, server_schema_after = cur.execute(
+                "SELECT CURRENT_DATABASE(), CURRENT_SCHEMA()"
+            ).fetchone()
+            assert (
+                server_db_after is None
+            ), f"unexpected server database: {server_db_after!r}"
+            assert (
+                server_schema_after is None
+            ), f"unexpected server schema: {server_schema_after!r}"
+
+
+def test_fqn_ddl_does_not_pollute_schema_cache_with_active_context(
+    conn_cnx, db_parameters
+):
+    """SNOW-3665226: fully-qualified DDL must not mutate the connector's cached
+    current schema / database when the session *does* have an active schema set.
+
+    Repro variant: connect with an explicit database+schema context, then execute
+    a DDL referencing a fully-qualified object in a *different* schema.  Before
+    the fix the connector would overwrite _schema/_database with the object's
+    schema, causing get_current_schema() to diverge from CURRENT_SCHEMA().
+    """
+    unique = random_string(5).lower()
+    database = db_parameters["database"].upper()
+    session_schema = f"SNOW_3665226_SESSION_{unique}".upper()
+    other_schema = f"SNOW_3665226_OTHER_{unique}".upper()
+
+    # Use a separate bootstrap connection to create two schemas in the existing
+    # test database (avoids needing CREATE DATABASE privilege).
+    with conn_cnx() as bootstrap_cnx:
+        with bootstrap_cnx.cursor() as cur:
+            cur.execute(f"CREATE SCHEMA IF NOT EXISTS {session_schema}")
+            cur.execute(f"CREATE SCHEMA IF NOT EXISTS {other_schema}")
+
+    try:
+        # Connect with the known db+schema as the session context.
+        with conn_cnx(database=database, schema=session_schema) as cnx:
+            with cnx.cursor() as cur:
+                # Sanity-check: cache and server agree before the DDL.
+                assert cnx._database.upper() == database
+                assert cnx._schema.upper() == session_schema
+                server_schema_before = cur.execute(
+                    "SELECT CURRENT_SCHEMA()"
+                ).fetchone()[0]
+                assert server_schema_before.upper() == session_schema
+
+                # Execute DDL targeting a *different* schema (fully-qualified).
+                view_fqn = f'"{database}"."{other_schema}"."SNOW_3665226_VIEW_{unique}"'
+                try:
+                    cur.execute(
+                        f"CREATE OR REPLACE TEMP VIEW {view_fqn} AS SELECT 1 AS x"
+                    )
+                finally:
+                    cur.execute(f"DROP VIEW IF EXISTS {view_fqn}")
+
+                # The connector cache must still reflect the original session context.
+                assert cnx._schema.upper() == session_schema, (
+                    f"connector _schema was polluted: got {cnx._schema!r}, "
+                    f"expected {session_schema!r}"
+                )
+                assert cnx._database.upper() == database, (
+                    f"connector _database was polluted: got {cnx._database!r}, "
+                    f"expected {database!r}"
+                )
+
+                # Server must also still report the original schema.
+                server_schema_after = cur.execute("SELECT CURRENT_SCHEMA()").fetchone()[
+                    0
+                ]
+                assert (
+                    server_schema_after.upper() == session_schema
+                ), f"unexpected server schema: {server_schema_after!r}"
+    finally:
+        with conn_cnx() as cleanup_cnx:
+            with cleanup_cnx.cursor() as cur:
+                cur.execute(f"DROP SCHEMA IF EXISTS {session_schema}")
+                cur.execute(f"DROP SCHEMA IF EXISTS {other_schema}")