fakesnow 0.9.20__tar.gz → 0.9.22__tar.gz

{fakesnow-0.9.20 → fakesnow-0.9.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.20
+Version: 0.9.22
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -213,20 +213,25 @@ License-File: LICENSE
 Requires-Dist: duckdb~=1.0.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=25.3.0
+Requires-Dist: sqlglot~=25.9.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
 Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra == "dev"
 Requires-Dist: pre-commit~=3.4; extra == "dev"
+Requires-Dist: pyarrow-stubs; extra == "dev"
 Requires-Dist: pytest~=8.0; extra == "dev"
-Requires-Dist: ruff~=0.4.2; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: ruff~=0.5.1; extra == "dev"
 Requires-Dist: twine~=5.0; extra == "dev"
 Requires-Dist: snowflake-sqlalchemy~=1.5.0; extra == "dev"
 Provides-Extra: notebook
 Requires-Dist: duckdb-engine; extra == "notebook"
 Requires-Dist: ipykernel; extra == "notebook"
 Requires-Dist: jupysql; extra == "notebook"
+Provides-Extra: server
+Requires-Dist: starlette; extra == "server"
+Requires-Dist: uvicorn; extra == "server"
 
 # fakesnow ❄️
 

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow/__init__.py

@@ -8,12 +8,11 @@ import unittest.mock as mock
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 
-import duckdb
 import snowflake.connector
 import snowflake.connector.pandas_tools
 
 import fakesnow.fakes as fakes
-from fakesnow.global_database import create_global_database
+from fakesnow.instance import FakeSnow
 
 
 @contextmanager
@@ -52,20 +51,15 @@ def patch(
     # won't be able to patch extra targets
     assert not isinstance(snowflake.connector.connect, mock.MagicMock), "Snowflake connector is already patched"
 
-    duck_conn = duckdb.connect(database=":memory:")
-    create_global_database(duck_conn)
+    fs = FakeSnow(
+        create_database_on_connect=create_database_on_connect,
+        create_schema_on_connect=create_schema_on_connect,
+        db_path=db_path,
+        nop_regexes=nop_regexes,
+    )
 
     fake_fns = {
-        # every time we connect, create a new cursor (ie: connection) so we can isolate each connection's
-        # schema setting, see https://duckdb.org/docs/api/python/overview.html#startup--shutdown
-        snowflake.connector.connect: lambda **kwargs: fakes.FakeSnowflakeConnection(
-            duck_conn.cursor(),
-            create_database=create_database_on_connect,
-            create_schema=create_schema_on_connect,
-            db_path=db_path,
-            nop_regexes=nop_regexes,
-            **kwargs,
-        ),
+        snowflake.connector.connect: fs.connect,
         snowflake.connector.pandas_tools.write_pandas: fakes.write_pandas,
     }
 

fakesnow-0.9.22/fakesnow/arrow.py

@@ -0,0 +1,32 @@
+import pyarrow as pa
+
+
+def with_sf_metadata(schema: pa.Schema) -> pa.Schema:
+    # see https://github.com/snowflakedb/snowflake-connector-python/blob/e9393a6/src/snowflake/connector/nanoarrow_cpp/ArrowIterator/CArrowTableIterator.cpp#L32
+    # and https://github.com/snowflakedb/snowflake-connector-python/blob/e9393a6/src/snowflake/connector/nanoarrow_cpp/ArrowIterator/SnowflakeType.cpp#L10
+    fms = []
+    for i, t in enumerate(schema.types):
+        f = schema.field(i)
+
+        if isinstance(t, pa.Decimal128Type):
+            fm = f.with_metadata({"logicalType": "FIXED", "precision": str(t.precision), "scale": str(t.scale)})
+        elif t == pa.string():
+            fm = f.with_metadata({"logicalType": "TEXT"})
+        else:
+            raise NotImplementedError(f"Unsupported Arrow type: {t}")
+        fms.append(fm)
+    return pa.schema(fms)
+
+
+def to_ipc(table: pa.Table) -> pa.Buffer:
+    batches = table.to_batches()
+    if len(batches) != 1:
+        raise NotImplementedError(f"{len(batches)} batches")
+    batch = batches[0]
+
+    sink = pa.BufferOutputStream()
+
+    with pa.ipc.new_stream(sink, with_sf_metadata(batch.schema)) as writer:
+        writer.write_batch(batch)
+
+    return sink.getvalue()

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow/fakes.py

@@ -114,7 +114,6 @@ class FakeSnowflakeCursor:
     def description(self) -> list[ResultMetadata]:
         # use a separate cursor to avoid consuming the result set on this cursor
         with self._conn.cursor() as cur:
-            # self._duck_conn.execute(sql, params)
             expression = sqlglot.parse_one(f"DESCRIBE {self._last_sql}", read="duckdb")
             cur._execute(expression, self._last_params)  # noqa: SLF001
             meta = FakeSnowflakeCursor._describe_as_result_metadata(cur.fetchall())
@@ -203,6 +202,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.sha256)
             .transform(transforms.create_clone)
             .transform(transforms.alias_in_join)
+            .transform(transforms.alter_table_strip_cluster_by)
         )
 
     def _execute(
@@ -234,12 +234,10 @@ class FakeSnowflakeCursor:
         if transformed.find(exp.Select) and (seed := transformed.args.get("seed")):
             sql = f"SELECT setseed({seed}); {sql}"
 
-        if (fs_debug := os.environ.get("FAKESNOW_DEBUG")) and fs_debug != "snowflake":
-            print(f"{sql};{params=}" if params else f"{sql};", file=sys.stderr)
-
         result_sql = None
 
         try:
+            self._log_sql(sql, params)
             self._duck_conn.execute(sql, params)
         except duckdb.BinderException as e:
             msg = e.args[0]
@@ -286,9 +284,9 @@ class FakeSnowflakeCursor:
             (affected_count,) = self._duck_conn.fetchall()[0]
             result_sql = SQL_DELETED_ROWS.substitute(count=affected_count)
 
-        elif cmd == "DESCRIBE TABLE":
-            # DESCRIBE TABLE has already been run above to detect and error if the table exists
-            # We now rerun DESCRIBE TABLE but transformed with columns to match Snowflake
+        elif cmd in ("DESCRIBE TABLE", "DESCRIBE VIEW"):
+            # DESCRIBE TABLE/VIEW has already been run above to detect and error if the table exists
+            # We now rerun DESCRIBE TABLE/VIEW but transformed with columns to match Snowflake
             result_sql = transformed.transform(
                 lambda e: transforms.describe_table(e, self._conn.database, self._conn.schema)
             ).sql(dialect="duckdb")
@@ -336,6 +334,7 @@ class FakeSnowflakeCursor:
             self._duck_conn.execute(info_schema.insert_text_lengths_sql(catalog, schema, table.name, text_lengths))
 
         if result_sql:
+            self._log_sql(result_sql, params)
             self._duck_conn.execute(result_sql)
 
         self._arrow_table = self._duck_conn.fetch_arrow_table()
@@ -346,6 +345,10 @@ class FakeSnowflakeCursor:
 
         return self
 
+    def _log_sql(self, sql: str, params: Sequence[Any] | dict[Any, Any] | None = None) -> None:
+        if (fs_debug := os.environ.get("FAKESNOW_DEBUG")) and fs_debug != "snowflake":
+            print(f"{sql};{params=}" if params else f"{sql};", file=sys.stderr)
+
     def executemany(
         self,
         command: str,
@@ -388,12 +391,13 @@ class FakeSnowflakeCursor:
         if self._arrow_table is None:
             # mimic snowflake python connector error type
             raise TypeError("No open result set")
+        tslice = self._arrow_table.slice(offset=self._arrow_table_fetch_index or 0, length=size).to_pylist()
+
         if self._arrow_table_fetch_index is None:
-            self._arrow_table_fetch_index = 0
+            self._arrow_table_fetch_index = size
         else:
             self._arrow_table_fetch_index += size
 
-        tslice = self._arrow_table.slice(offset=self._arrow_table_fetch_index, length=size).to_pylist()
         return tslice if self._use_dict_result else [tuple(d.values()) for d in tslice]
 
     def get_result_batches(self) -> list[ResultBatch] | None:
@@ -522,9 +526,14 @@ class FakeSnowflakeConnection:
     ):
         self._duck_conn = duck_conn
         # upper case database and schema like snowflake unquoted identifiers
-        # NB: catalog names are not case-sensitive in duckdb but stored as cased in information_schema.schemata
+        # so they appear as upper-cased in information_schema
+        # catalog and schema names are not actually case-sensitive in duckdb even though
+        # they are as cased in information_schema.schemata, so when selecting from
+        # information_schema.schemata below we use upper-case to match any existing duckdb
+        # catalog or schemas like "information_schema"
         self.database = database and database.upper()
         self.schema = schema and schema.upper()
+
         self.database_set = False
         self.schema_set = False
         self.db_path = Path(db_path) if db_path else None
@@ -538,7 +547,7 @@ class FakeSnowflakeConnection:
             and self.database
             and not duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}'"""
+                where upper(catalog_name) = '{self.database}'"""
             ).fetchone()
         ):
             db_file = f"{self.db_path/self.database}.db" if self.db_path else ":memory:"
@@ -553,7 +562,7 @@ class FakeSnowflakeConnection:
             and self.schema
             and not duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}' and schema_name = '{self.schema}'"""
+                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self.schema}'"""
             ).fetchone()
         ):
             duck_conn.execute(f"CREATE SCHEMA {self.database}.{self.schema}")
@@ -564,7 +573,7 @@ class FakeSnowflakeConnection:
             and self.schema
             and duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}' and schema_name = '{self.schema}'"""
+                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self.schema}'"""
             ).fetchone()
         ):
             duck_conn.execute(f"SET schema='{self.database}.{self.schema}'")
@@ -575,7 +584,7 @@ class FakeSnowflakeConnection:
             self.database
             and duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}'"""
+                where upper(catalog_name) = '{self.database}'"""
             ).fetchone()
         ):
             duck_conn.execute(f"SET schema='{self.database}.main'")
@@ -602,6 +611,7 @@ class FakeSnowflakeConnection:
         self.cursor().execute("COMMIT")
 
     def cursor(self, cursor_class: type[SnowflakeCursor] = SnowflakeCursor) -> FakeSnowflakeCursor:
+        # TODO: use duck_conn cursor for thread-safety
         return FakeSnowflakeCursor(conn=self, duck_conn=self._duck_conn, use_dict_result=cursor_class == DictCursor)
 
     def execute_string(

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow/info_schema.py

@@ -62,8 +62,8 @@ case when columns.data_type='BIGINT' then 10
 case when columns.data_type='DOUBLE' then NULL else columns.numeric_scale end as numeric_scale,
 collation_name, is_identity, identity_generation, identity_cycle,
     ddb_columns.comment as comment,
-    null as identity_start,
-    null as identity_increment,
+    null::VARCHAR as identity_start,
+    null::VARCHAR as identity_increment,
 from ${catalog}.information_schema.columns columns
 left join ${catalog}.information_schema._fs_columns_ext ext
   on ext_table_catalog = columns.table_catalog
@@ -78,6 +78,7 @@ LEFT JOIN duckdb_columns ddb_columns
 """
 )
 
+
 # replicates https://docs.snowflake.com/sql-reference/info-schema/databases
 SQL_CREATE_INFORMATION_SCHEMA_DATABASES_VIEW = Template(
     """
@@ -86,7 +87,7 @@ select
     catalog_name as database_name,
     'SYSADMIN' as database_owner,
     'NO' as is_transient,
-    null as comment,
+    null::VARCHAR as comment,
     to_timestamp(0)::timestamptz as created,
     to_timestamp(0)::timestamptz as last_altered,
     1 as retention_time,
@@ -116,7 +117,7 @@ select
     to_timestamp(0)::timestamptz as last_altered,
     to_timestamp(0)::timestamptz as last_ddl,
     'SYSADMIN' as last_ddl_by,
-    null as comment
+    null::VARCHAR as comment
 from duckdb_views
 where database_name = '${catalog}'
   and schema_name != 'information_schema'

fakesnow-0.9.22/fakesnow/instance.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import duckdb
+
+import fakesnow.fakes as fakes
+
+GLOBAL_DATABASE_NAME = "_fs_global"
+USERS_TABLE_FQ_NAME = f"{GLOBAL_DATABASE_NAME}._fs_users_ext"
+
+# replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
+SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT = f"""
+create table if not exists {USERS_TABLE_FQ_NAME} (
+    name varchar,
+    created_on TIMESTAMPTZ,
+    login_name varchar,
+    display_name varchar,
+    first_name varchar,
+    last_name varchar,
+    email varchar,
+    mins_to_unlock varchar,
+    days_to_expiry varchar,
+    comment varchar,
+    disabled varchar,
+    must_change_password varchar,
+    snowflake_lock varchar,
+    default_warehouse varchar,
+    default_namespace varchar,
+    default_role varchar,
+    default_secondary_roles varchar,
+    ext_authn_duo varchar,
+    ext_authn_uid varchar,
+    mins_to_bypass_mfa varchar,
+    owner varchar,
+    last_success_login TIMESTAMPTZ,
+    expires_at_time TIMESTAMPTZ,
+    locked_until_time TIMESTAMPTZ,
+    has_password varchar,
+    has_rsa_public_key varchar,
+)
+"""
+
+
+def create_global_database(conn: duckdb.DuckDBPyConnection) -> None:
+    """Create a "global" database for storing objects which span databases.
+
+    Including (but not limited to):
+     - Users
+    """
+    conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
+    conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)
+
+
+class FakeSnow:
+    def __init__(
+        self,
+        create_database_on_connect: bool = True,
+        create_schema_on_connect: bool = True,
+        db_path: str | os.PathLike | None = None,
+        nop_regexes: list[str] | None = None,
+    ):
+        self.create_database_on_connect = create_database_on_connect
+        self.create_schema_on_connect = create_schema_on_connect
+        self.db_path = db_path
+        self.nop_regexes = nop_regexes
+
+        self.duck_conn = duckdb.connect(database=":memory:")
+
+        # create a "global" database for storing objects which span databases.
+        self.duck_conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
+        self.duck_conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)
+
+    def connect(
+        self, database: str | None = None, schema: str | None = None, **kwargs: Any
+    ) -> fakes.FakeSnowflakeConnection:
+        # every time we connect, create a new cursor (ie: connection) so we can isolate each connection's
+        # schema setting see
+        # https://github.com/duckdb/duckdb/blob/18254ec/tools/pythonpkg/src/pyconnection.cpp#L1440
+        # and to make connections thread-safe see
+        # https://duckdb.org/docs/api/python/overview.html#using-connections-in-parallel-python-programs
+        return fakes.FakeSnowflakeConnection(
+            self.duck_conn.cursor(),
+            database,
+            schema,
+            create_database=self.create_database_on_connect,
+            create_schema=self.create_schema_on_connect,
+            db_path=self.db_path,
+            nop_regexes=self.nop_regexes,
+            **kwargs,
+        )

fakesnow-0.9.22/fakesnow/server.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import gzip
+import json
+import secrets
+from base64 import b64encode
+from dataclasses import dataclass
+
+from starlette.applications import Starlette
+from starlette.concurrency import run_in_threadpool
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+from fakesnow.arrow import to_ipc
+from fakesnow.fakes import FakeSnowflakeConnection
+from fakesnow.instance import FakeSnow
+
+fs = FakeSnow()
+sessions = {}
+
+
+@dataclass
+class ServerError(Exception):
+    status_code: int
+    code: str
+    message: str
+
+
+def login_request(request: Request) -> JSONResponse:
+    database = request.query_params.get("databaseName")
+    schema = request.query_params.get("schemaName")
+    token = secrets.token_urlsafe(32)
+    sessions[token] = fs.connect(database, schema)
+    return JSONResponse({"data": {"token": token}, "success": True})
+
+
+async def query_request(request: Request) -> JSONResponse:
+    try:
+        conn = to_conn(request)
+
+        body = await request.body()
+        body_json = json.loads(gzip.decompress(body))
+
+        sql_text = body_json["sqlText"]
+
+        # only a single sql statement is sent at a time by the python snowflake connector
+        cur = await run_in_threadpool(conn.cursor().execute, sql_text)
+
+        assert cur._arrow_table, "No result set"  # noqa: SLF001
+
+        batch_bytes = to_ipc(cur._arrow_table)  # noqa: SLF001
+        rowset_b64 = b64encode(batch_bytes).decode("utf-8")
+
+        return JSONResponse(
+            {
+                "data": {
+                    "rowtype": [
+                        {
+                            "name": "'HELLO WORLD'",
+                            "nullable": False,
+                            "type": "text",
+                            "length": 11,
+                            "scale": None,
+                            "precision": None,
+                        }
+                    ],
+                    "rowsetBase64": rowset_b64,
+                    "total": 1,
+                    "queryResultFormat": "arrow",
+                },
+                "success": True,
+            }
+        )
+
+    except ServerError as e:
+        return JSONResponse(
+            {"data": None, "code": e.code, "message": e.message, "success": False, "headers": None},
+            status_code=e.status_code,
+        )
+
+
+def to_conn(request: Request) -> FakeSnowflakeConnection:
+    if not (auth := request.headers.get("Authorization")):
+        raise ServerError(status_code=401, code="390103", message="Session token not found in the request data.")
+
+    token = auth[17:-1]
+
+    if not (conn := sessions.get(token)):
+        raise ServerError(status_code=401, code="390104", message="User must login again to access the service.")
+
+    return conn
+
+
+routes = [
+    Route(
+        "/session/v1/login-request",
+        login_request,
+        methods=["POST"],
+    ),
+    Route(
+        "/queries/v1/query-request",
+        query_request,
+        methods=["POST"],
+    ),
+    Route("/queries/v1/abort-request", lambda _: JSONResponse({"success": True}), methods=["POST"]),
+]
+
+app = Starlette(debug=True, routes=routes)

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow/transforms.py

@@ -7,11 +7,11 @@ from typing import ClassVar, Literal, cast
 import sqlglot
 from sqlglot import exp
 
-from fakesnow.global_database import USERS_TABLE_FQ_NAME
+from fakesnow.instance import USERS_TABLE_FQ_NAME
 from fakesnow.variables import Variables
 
 MISSING_DATABASE = "missing_database"
-SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.'")
+SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.' as status")
 
 
 def alias_in_join(expression: exp.Expression) -> exp.Expression:
@@ -33,6 +33,18 @@ def alias_in_join(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def alter_table_strip_cluster_by(expression: exp.Expression) -> exp.Expression:
+    """Turn alter table cluster by into a no-op"""
+    if (
+        isinstance(expression, exp.AlterTable)
+        and (actions := expression.args.get("actions"))
+        and len(actions) == 1
+        and (isinstance(actions[0], exp.Cluster))
+    ):
+        return SUCCESS_NOP
+    return expression
+
+
 def array_size(expression: exp.Expression) -> exp.Expression:
     if isinstance(expression, exp.ArraySize):
         # case is used to convert 0 to null, because null is returned by duckdb when no case matches
@@ -147,22 +159,41 @@ SELECT
     column_default AS "default",
     'N' AS "primary key",
     'N' AS "unique key",
-    NULL AS "check",
-    NULL AS "expression",
-    NULL AS "comment",
-    NULL AS "policy name",
-    NULL AS "privacy domain",
+    NULL::VARCHAR AS "check",
+    NULL::VARCHAR AS "expression",
+    NULL::VARCHAR AS "comment",
+    NULL::VARCHAR AS "policy name",
+    NULL::JSON AS "privacy domain",
 FROM information_schema._fs_columns_snowflake
 WHERE table_catalog = '${catalog}' AND table_schema = '${schema}' AND table_name = '${table}'
 ORDER BY ordinal_position
 """
 )
 
+SQL_DESCRIBE_INFO_SCHEMA = Template(
+    """
+SELECT
+    column_name AS "name",
+    column_type as "type",
+    'COLUMN' AS "kind",
+    CASE WHEN "null" = 'YES' THEN 'Y' ELSE 'N' END AS "null?",
+    NULL::VARCHAR AS "default",
+    'N' AS "primary key",
+    'N' AS "unique key",
+    NULL::VARCHAR AS "check",
+    NULL::VARCHAR AS "expression",
+    NULL::VARCHAR AS "comment",
+    NULL::VARCHAR AS "policy name",
+    NULL::JSON AS "privacy domain",
+FROM (DESCRIBE information_schema.${view})
+"""
+)
+
 
 def describe_table(
     expression: exp.Expression, current_database: str | None = None, current_schema: str | None = None
 ) -> exp.Expression:
-    """Redirect to the information_schema._fs_describe_table to match snowflake.
+    """Redirect to the information_schema._fs_columns_snowflake to match snowflake.
 
     See https://docs.snowflake.com/en/sql-reference/sql/desc-table
     """
@@ -171,12 +202,16 @@ def describe_table(
         isinstance(expression, exp.Describe)
         and (kind := expression.args.get("kind"))
         and isinstance(kind, str)
-        and kind.upper() == "TABLE"
+        and kind.upper() in ("TABLE", "VIEW")
         and (table := expression.find(exp.Table))
     ):
         catalog = table.catalog or current_database
         schema = table.db or current_schema
 
+        if schema and schema.upper() == "INFORMATION_SCHEMA":
+            # information schema views don't exist in _fs_columns_snowflake
+            return sqlglot.parse_one(SQL_DESCRIBE_INFO_SCHEMA.substitute(view=table.name), read="duckdb")
+
         return sqlglot.parse_one(
             SQL_DESCRIBE_TABLE.substitute(catalog=catalog, schema=schema, table=table.name),
             read="duckdb",
@@ -551,12 +586,13 @@ def information_schema_fs_columns_snowflake(expression: exp.Expression) -> exp.E
     """
 
     if (
-        isinstance(expression, exp.Select)
-        and (tbl_exp := expression.find(exp.Table))
-        and tbl_exp.name.upper() == "COLUMNS"
-        and tbl_exp.db.upper() == "INFORMATION_SCHEMA"
+        isinstance(expression, exp.Table)
+        and expression.db
+        and expression.db.upper() == "INFORMATION_SCHEMA"
+        and expression.name
+        and expression.name.upper() == "COLUMNS"
     ):
-        tbl_exp.set("this", exp.Identifier(this="_FS_COLUMNS_SNOWFLAKE", quoted=False))
+        expression.set("this", exp.Identifier(this="_FS_COLUMNS_SNOWFLAKE", quoted=False))
 
     return expression
 

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow/variables.py

@@ -5,10 +5,23 @@ from sqlglot import exp
 
 
 # Implements snowflake variables: https://docs.snowflake.com/en/sql-reference/session-variables#using-variables-in-sql
+# [ ] Add support for setting multiple variables in a single statement
 class Variables:
     @classmethod
     def is_variable_modifier(cls, expr: exp.Expression) -> bool:
-        return isinstance(expr, exp.Set) or cls._is_unset_expression(expr)
+        return cls._is_set_expression(expr) or cls._is_unset_expression(expr)
+
+    @classmethod
+    def _is_set_expression(cls, expr: exp.Expression) -> bool:
+        if isinstance(expr, exp.Set):
+            is_set = not expr.args.get("unset")
+            if is_set:  # SET varname = value;
+                set_expressions = expr.args.get("expressions")
+                assert set_expressions, "SET without values in expression(s) is unexpected."
+                # Avoids mistakenly setting variables for statements that use SET in a different context.
+                # (eg. WHEN MATCHED THEN UPDATE SET x=7)
+                return isinstance(set_expressions[0], exp.SetItem)
+        return False
 
     @classmethod
     def _is_unset_expression(cls, expr: exp.Expression) -> bool:
@@ -22,11 +35,11 @@ class Variables:
 
     def update_variables(self, expr: exp.Expression) -> None:
         if isinstance(expr, exp.Set):
-            unset = expr.args.get("unset")
-            if not unset:  # SET varname = value;
-                unset_expressions = expr.args.get("expressions")
-                assert unset_expressions, "SET without values in expression(s) is unexpected."
-                eq = unset_expressions[0].this
+            is_set = not expr.args.get("unset")
+            if is_set:  # SET varname = value;
+                set_expressions = expr.args.get("expressions")
+                assert set_expressions, "SET without values in expression(s) is unexpected."
+                eq = set_expressions[0].this
                 name = eq.this.sql()
                 value = eq.args.get("expression").sql()
                 self._set(name, value)

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.20
+Version: 0.9.22
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -213,20 +213,25 @@ License-File: LICENSE
 Requires-Dist: duckdb~=1.0.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=25.3.0
+Requires-Dist: sqlglot~=25.9.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
 Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra == "dev"
 Requires-Dist: pre-commit~=3.4; extra == "dev"
+Requires-Dist: pyarrow-stubs; extra == "dev"
 Requires-Dist: pytest~=8.0; extra == "dev"
-Requires-Dist: ruff~=0.4.2; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: ruff~=0.5.1; extra == "dev"
 Requires-Dist: twine~=5.0; extra == "dev"
 Requires-Dist: snowflake-sqlalchemy~=1.5.0; extra == "dev"
 Provides-Extra: notebook
 Requires-Dist: duckdb-engine; extra == "notebook"
 Requires-Dist: ipykernel; extra == "notebook"
 Requires-Dist: jupysql; extra == "notebook"
+Provides-Extra: server
+Requires-Dist: starlette; extra == "server"
+Requires-Dist: uvicorn; extra == "server"
 
 # fakesnow ❄️
 

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow.egg-info/SOURCES.txt

@@ -3,15 +3,17 @@ README.md
 pyproject.toml
 fakesnow/__init__.py
 fakesnow/__main__.py
+fakesnow/arrow.py
 fakesnow/checks.py
 fakesnow/cli.py
 fakesnow/expr.py
 fakesnow/fakes.py
 fakesnow/fixtures.py
-fakesnow/global_database.py
 fakesnow/info_schema.py
+fakesnow/instance.py
 fakesnow/macros.py
 fakesnow/py.typed
+fakesnow/server.py
 fakesnow/transforms.py
 fakesnow/variables.py
 fakesnow.egg-info/PKG-INFO
@@ -20,6 +22,7 @@ fakesnow.egg-info/dependency_links.txt
 fakesnow.egg-info/entry_points.txt
 fakesnow.egg-info/requires.txt
 fakesnow.egg-info/top_level.txt
+tests/test_arrow.py
 tests/test_checks.py
 tests/test_cli.py
 tests/test_connect.py
@@ -27,6 +30,7 @@ tests/test_expr.py
 tests/test_fakes.py
 tests/test_info_schema.py
 tests/test_patch.py
+tests/test_server.py
 tests/test_sqlalchemy.py
 tests/test_transforms.py
 tests/test_users.py

{fakesnow-0.9.20 → fakesnow-0.9.22}/fakesnow.egg-info/requires.txt

@@ -1,15 +1,17 @@
 duckdb~=1.0.0
 pyarrow
 snowflake-connector-python
-sqlglot~=25.3.0
+sqlglot~=25.9.0
 
 [dev]
 build~=1.0
 pandas-stubs
 snowflake-connector-python[pandas,secure-local-storage]
 pre-commit~=3.4
+pyarrow-stubs
 pytest~=8.0
-ruff~=0.4.2
+pytest-asyncio
+ruff~=0.5.1
 twine~=5.0
 snowflake-sqlalchemy~=1.5.0
 
@@ -17,3 +19,7 @@ snowflake-sqlalchemy~=1.5.0
 duckdb-engine
 ipykernel
 jupysql
+
+[server]
+starlette
+uvicorn

{fakesnow-0.9.20 → fakesnow-0.9.22}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "fakesnow"
 description = "Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally."
-version = "0.9.20"
+version = "0.9.22"
 readme = "README.md"
 license = { file = "LICENSE" }
 classifiers = ["License :: OSI Approved :: MIT License"]
@@ -11,7 +11,7 @@ dependencies = [
     "duckdb~=1.0.0",
     "pyarrow",
     "snowflake-connector-python",
-    "sqlglot~=25.3.0",
+    "sqlglot~=25.9.0",
 ]
 
 [project.urls]
@@ -28,13 +28,17 @@ dev = [
     # include compatible version of pandas, and secure-local-storage for token caching
     "snowflake-connector-python[pandas, secure-local-storage]",
     "pre-commit~=3.4",
+    "pyarrow-stubs",
     "pytest~=8.0",
-    "ruff~=0.4.2",
+    "pytest-asyncio",
+    "ruff~=0.5.1",
     "twine~=5.0",
     "snowflake-sqlalchemy~=1.5.0",
 ]
 # for debugging, see https://duckdb.org/docs/guides/python/jupyter.html
 notebook = ["duckdb-engine", "ipykernel", "jupysql"]
+# for the standalone server
+server = ["starlette", "uvicorn"]
 
 [build-system]
 requires = ["setuptools~=69.1", "wheel~=0.42"]
@@ -51,9 +55,17 @@ strictListInference = true
 strictDictionaryInference = true
 strictParameterNoneValue = true
 reportTypedDictNotRequiredAccess = false
+reportIncompatibleVariableOverride = true
 reportIncompatibleMethodOverride = true
+reportMatchNotExhaustive = true
 reportUnnecessaryTypeIgnoreComment = true
 
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+# error on unhandled exceptions in background threads
+# useful for catching errors in server or snowflake connector threads
+filterwarnings = ["error::pytest.PytestUnhandledThreadExceptionWarning"]
+
 [tool.ruff]
 line-length = 120
 # first-party imports for sorting

fakesnow-0.9.22/tests/test_arrow.py

@@ -0,0 +1,53 @@
+from base64 import b64decode
+
+import pandas as pd
+import pyarrow as pa
+
+from fakesnow.arrow import to_ipc, with_sf_metadata
+
+
+def test_with_sf_metadata() -> None:
+    # see https://arrow.apache.org/docs/python/api/datatypes.html
+    def f(t: pa.DataType) -> dict:
+        return with_sf_metadata(pa.schema([pa.field(str(t), t)])).field(0).metadata
+
+    assert f(pa.string()) == {b"logicalType": b"TEXT"}
+    assert f(pa.decimal128(10, 2)) == {b"logicalType": b"FIXED", b"precision": b"10", b"scale": b"2"}
+
+
+def test_ipc_writes_sf_metadata() -> None:
+    df = pd.DataFrame.from_dict(
+        {
+            "'HELLO WORLD'": ["hello world"],
+        }
+    )
+
+    table = pa.Table.from_pandas(df)
+    table_bytes = to_ipc(table)
+
+    batch = next(iter(pa.ipc.open_stream(table_bytes)))
+
+    # field and schema metadata is ignored
+    assert pa.table(batch) == table
+    assert batch.schema.field(0).metadata == {b"logicalType": b"TEXT"}, "Missing Snowflake field metadata"
+
+
+def test_read_base64() -> None:
+    # select to_decimal('12.3456', 10,2)
+    rowset_b64 = "/////5gBAAAQAAAAAAAKAAwABgAFAAgACgAAAAABBAAMAAAACAAIAAAABAAIAAAABAAAAAEAAAAYAAAAAAASABgACAAAAAcADAAAABAAFAASAAAAAAAAAhQAAAA0AQAACAAAACgAAAAAAAAAGwAAAFRPX0RFQ0lNQUwoJzEyLjM0NTYnLCAxMCwyKQAGAAAA0AAAAKAAAAB8AAAAVAAAACwAAAAEAAAAUP///xAAAAAEAAAAAQAAAFQAAAAJAAAAZmluYWxUeXBlAAAAdP///xAAAAAEAAAAAQAAADIAAAAKAAAAYnl0ZUxlbmd0aAAAmP///xAAAAAEAAAAAQAAADAAAAAKAAAAY2hhckxlbmd0aAAAvP///xAAAAAEAAAAAQAAADIAAAAFAAAAc2NhbGUAAADc////EAAAAAQAAAACAAAAMTAAAAkAAABwcmVjaXNpb24AAAAIAAwABAAIAAgAAAAUAAAABAAAAAUAAABGSVhFRAAAAAsAAABsb2dpY2FsVHlwZQAIAAwACAAHAAgAAAAAAAABEAAAAAAAAAD/////iAAAABQAAAAAAAAADAAWAAYABQAIAAwADAAAAAADBAAYAAAACAAAAAAAAAAAAAoAGAAMAAQACAAKAAAAPAAAABAAAAABAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAADTBAAAAAAAAA=="  # noqa: E501
+
+    f = b64decode(rowset_b64)
+    reader = pa.ipc.open_stream(f)
+
+    batch = next(reader)
+
+    field = batch.schema.field(0)
+    assert field == pa.field(name="TO_DECIMAL('12.3456', 10,2)", type=pa.int16(), nullable=False)
+    assert field.metadata == {
+        b"logicalType": b"FIXED",
+        b"precision": b"10",
+        b"scale": b"2",
+        b"charLength": b"0",
+        b"byteLength": b"2",
+        b"finalType": b"T",
+    }

{fakesnow-0.9.20 → fakesnow-0.9.22}/tests/test_connect.py

@@ -83,6 +83,15 @@ def test_connect_db_path_reuse():
             assert cur.execute("select * from example").fetchall() == [(420,)]
 
 
+def test_connect_information_schema():
+    with fakesnow.patch(create_schema_on_connect=False):
+        conn = snowflake.connector.connect(database="db1", schema="information_schema")
+        assert conn.schema == "INFORMATION_SCHEMA"
+        with conn, conn.cursor() as cur:
+            # shouldn't fail
+            cur.execute("SELECT * FROM databases")
+
+
 def test_connect_without_database(_fakesnow_no_auto_create: None):
     with snowflake.connector.connect() as conn, conn.cursor() as cur:
         with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:

{fakesnow-0.9.20 → fakesnow-0.9.22}/tests/test_fakes.py

@@ -41,10 +41,13 @@ def test_alias_on_join(conn: snowflake.connector.SnowflakeConnection):
     assert cur.fetchall() == [("VARCHAR1", "CHAR1", "JOIN"), ("VARCHAR2", "CHAR2", None)]
 
 
-def test_alter_table(cur: snowflake.connector.cursor.SnowflakeCursor):
-    cur.execute("create table table1 (id int)")
-    cur.execute("alter table table1 add column name varchar(20)")
-    cur.execute("select name from table1")
+def test_alter_table(dcur: snowflake.connector.cursor.SnowflakeCursor):
+    dcur.execute("create table table1 (id int)")
+    dcur.execute("alter table table1 add column name varchar(20)")
+    dcur.execute("select name from table1")
+    assert dcur.execute("alter table table1 cluster by (name)").fetchall() == [
+        {"status": "Statement executed successfully."}
+    ]
 
 
 def test_array_size(cur: snowflake.connector.cursor.SnowflakeCursor):
@@ -433,6 +436,52 @@ def test_describe_table(dcur: snowflake.connector.cursor.DictCursor):
     assert "002003 (42S02): Catalog Error: Table with name THIS_DOES_NOT_EXIST does not exist!" in str(excinfo.value)
 
 
+def test_describe_view(dcur: snowflake.connector.cursor.DictCursor):
+    dcur.execute(
+        """
+        create or replace table example (
+            XVARCHAR VARCHAR
+            -- ,XVARCHAR20 VARCHAR(20) -- TODO: preserve varchar size
+        )
+        """
+    )
+
+    common = {
+        "kind": "COLUMN",
+        "null?": "Y",
+        "default": None,
+        "primary key": "N",
+        "unique key": "N",
+        "check": None,
+        "expression": None,
+        "comment": None,
+        "policy name": None,
+        "privacy domain": None,
+    }
+    expected = [
+        {"name": "XVARCHAR", "type": "VARCHAR(16777216)", **common},
+        # TODO: preserve varchar size
+        # {"name": "XVARCHAR20", "type": "VARCHAR(20)", **common},
+    ]
+
+    dcur.execute("create view v1 as select * from example")
+    assert dcur.execute("describe view v1").fetchall() == expected
+    assert [r.name for r in dcur.description] == [
+        "name",
+        "type",
+        "kind",
+        "null?",
+        "default",
+        "primary key",
+        "unique key",
+        "check",
+        "expression",
+        "comment",
+        "policy name",
+        "privacy domain",
+    ]
+
+
 ## descriptions are needed for ipython-sql/jupysql which describes every statement
 def test_description_create_drop_database(dcur: snowflake.connector.cursor.DictCursor):
     dcur.execute("create database example")
@@ -602,9 +651,10 @@ def test_fetchmany(conn: snowflake.connector.SnowflakeConnection):
         cur.execute("insert into customers values (3, 'Jeremy', 'K')")
         cur.execute("select id, first_name, last_name from customers")
 
+        # mimic jupysql fetchmany behaviour
         assert cur.fetchmany(2) == [(1, "Jenny", "P"), (2, "Jasper", "M")]
-        assert cur.fetchmany(2) == [(3, "Jeremy", "K")]
-        assert cur.fetchmany(2) == []
+        assert cur.fetchmany(5) == [(3, "Jeremy", "K")]
+        assert cur.fetchmany(5) == []
 
     with conn.cursor(snowflake.connector.cursor.DictCursor) as cur:
         cur.execute("select id, first_name, last_name from customers")
@@ -612,10 +662,10 @@ def test_fetchmany(conn: snowflake.connector.SnowflakeConnection):
             {"ID": 1, "FIRST_NAME": "Jenny", "LAST_NAME": "P"},
             {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M"},
         ]
-        assert cur.fetchmany(2) == [
+        assert cur.fetchmany(5) == [
             {"ID": 3, "FIRST_NAME": "Jeremy", "LAST_NAME": "K"},
         ]
-        assert cur.fetchmany(2) == []
+        assert cur.fetchmany(5) == []
 
 
 def test_fetch_pandas_all(cur: snowflake.connector.cursor.SnowflakeCursor):

{fakesnow-0.9.20 → fakesnow-0.9.22}/tests/test_info_schema.py

@@ -39,6 +39,46 @@ def test_info_schema_columns_describe(cur: snowflake.connector.cursor.SnowflakeC
     assert cur.description == expected_metadata
 
 
+def test_describe_view_columns(dcur: snowflake.connector.cursor.DictCursor):
+    cols = [
+        "name",
+        "type",
+        "kind",
+        "null?",
+        "default",
+        "primary key",
+        "unique key",
+        "check",
+        "expression",
+        "comment",
+        "policy name",
+        "privacy domain",
+    ]
+    dcur.execute("describe view information_schema.columns")
+    result: list[dict] = dcur.fetchall()  # type: ignore
+    assert list(result[0].keys()) == cols
+    names = [r["name"] for r in result]
+    # should contain snowflake-specific columns (from _FS_COLUMNS_SNOWFLAKE)
+    assert "comment" in names
+    # fmt: off
+    assert dcur.description[:-1] == [
+        ResultMetadata(name='name', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='type', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='kind', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='null?', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='default', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='primary key', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='unique key', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='check', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='expression', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='comment', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='policy name', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        # TODO: ignore the following, see https://github.com/tekumara/fakesnow/issues/26
+        # ResultMetadata(name='privacy domain', type_code=9, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)
+    ]
+    # fmt: on
+
+
 def test_info_schema_columns_numeric(cur: snowflake.connector.cursor.SnowflakeCursor):
     # see https://docs.snowflake.com/en/sql-reference/data-types-numeric
     cur.execute(
@@ -211,3 +251,16 @@ def test_info_schema_show_primary_keys_from_table(cur: snowflake.connector.curso
 
     pk_columns = [result[4] for result in pk_result]
     assert pk_columns == ["ID", "VERSION"]
+
+
+def test_type_column_is_not_null(cur: snowflake.connector.cursor.SnowflakeCursor) -> None:
+    for table in [
+        "information_schema.databases",
+        "information_schema.views",
+        "information_schema.columns",
+    ]:
+        cur.execute(f"DESCRIBE VIEW {table}")
+        result = cur.fetchall()
+        data_types = [dt for (_, dt, *_) in result]
+        nulls = [dt for dt in data_types if "NULL" in dt]
+        assert not nulls

fakesnow-0.9.22/tests/test_server.py

@@ -0,0 +1,67 @@
+import threading
+from collections.abc import Iterator
+from decimal import Decimal
+from time import sleep
+from typing import Callable
+
+import pytest
+import snowflake.connector
+import uvicorn
+
+import fakesnow.server
+
+
+@pytest.fixture(scope="session")
+def unused_port(unused_tcp_port_factory: Callable[[], int]) -> int:
+    # unused_tcp_port_factory is from pytest-asyncio
+    return unused_tcp_port_factory()
+
+
+@pytest.fixture(scope="session")
+def server(unused_tcp_port_factory: Callable[[], int]) -> Iterator[dict]:
+    port = unused_tcp_port_factory()
+    server = uvicorn.Server(uvicorn.Config(fakesnow.server.app, port=port, log_level="info"))
+    thread = threading.Thread(target=server.run, name="Server", daemon=True)
+    thread.start()
+
+    while not server.started:
+        sleep(0.1)
+    yield dict(
+        user="fake",
+        password="snow",
+        account="fakesnow",
+        host="localhost",
+        port=port,
+        protocol="http",
+        # disable telemetry
+        session_parameters={"CLIENT_OUT_OF_BAND_TELEMETRY_ENABLED": False},
+    )
+
+    server.should_exit = True
+    # wait for server thread to end
+    thread.join()
+
+
+def test_server_connect(server: dict) -> None:
+    with (
+        snowflake.connector.connect(
+            **server,
+            # disable infinite retries on error
+            network_timeout=1,
+        ) as conn1,
+        conn1.cursor() as cur,
+    ):
+        cur.execute("select 'hello', to_decimal('12.3456', 10,2)")
+        assert cur.fetchall() == [("hello", Decimal("12.35"))]
+
+
+def test_server_abort_request(server: dict) -> None:
+    with (
+        snowflake.connector.connect(
+            **server,
+            # triggers an abort request
+            network_timeout=0,
+        ) as conn1,
+        conn1.cursor() as cur,
+    ):
+        cur.execute("select 'will abort'")

{fakesnow-0.9.20 → fakesnow-0.9.22}/tests/test_transforms.py

@@ -8,6 +8,7 @@ from fakesnow.transforms import (
     SUCCESS_NOP,
     _get_to_number_args,
     alias_in_join,
+    alter_table_strip_cluster_by,
     array_agg,
     array_agg_within_group,
     array_size,
@@ -74,6 +75,13 @@ def test_alias_in_join() -> None:
     )
 
 
+def test_alter_table_strip_cluster_by() -> None:
+    assert (
+        sqlglot.parse_one("alter table table1 cluster by (name)").transform(alter_table_strip_cluster_by).sql()
+        == "SELECT 'Statement executed successfully.' AS status"
+    )
+
+
 def test_array_size() -> None:
     assert (
         sqlglot.parse_one("""select array_size(parse_json('["a","b"]'))""").transform(array_size).sql(dialect="duckdb")
@@ -342,7 +350,7 @@ def test_extract_comment_on_columns() -> None:
     e = sqlglot.parse_one("ALTER TABLE ingredients ALTER amount COMMENT 'tablespoons'").transform(
         extract_comment_on_columns
     )
-    assert e.sql() == "SELECT 'Statement executed successfully.'"
+    assert e.sql() == "SELECT 'Statement executed successfully.' AS status"
     assert e.args["col_comments"] == [("amount", "tablespoons")]
 
     # TODO
@@ -365,19 +373,19 @@ def test_extract_comment_on_table() -> None:
     assert e.args["table_comment"] == (table1, "foobar")
 
     e = sqlglot.parse_one("COMMENT ON TABLE table1 IS 'comment1'").transform(extract_comment_on_table)
-    assert e.sql() == "SELECT 'Statement executed successfully.'"
+    assert e.sql() == "SELECT 'Statement executed successfully.' AS status"
     assert e.args["table_comment"] == (table1, "comment1")
 
     e = sqlglot.parse_one("COMMENT ON TABLE table1 IS $$comment2$$", read="snowflake").transform(
         extract_comment_on_table
     )
-    assert e.sql() == "SELECT 'Statement executed successfully.'"
+    assert e.sql() == "SELECT 'Statement executed successfully.' AS status"
     assert e.args["table_comment"] == (table1, "comment2")
 
     e = sqlglot.parse_one("ALTER TABLE table1 SET COMMENT = 'comment1'", read="snowflake").transform(
         extract_comment_on_table
     )
-    assert e.sql() == "SELECT 'Statement executed successfully.'"
+    assert e.sql() == "SELECT 'Statement executed successfully.' AS status"
     assert e.args["table_comment"] == (table1, "comment1")
 
 

fakesnow-0.9.20/fakesnow/global_database.py

@@ -1,46 +0,0 @@
-from duckdb import DuckDBPyConnection
-
-GLOBAL_DATABASE_NAME = "_fs_global"
-USERS_TABLE_FQ_NAME = f"{GLOBAL_DATABASE_NAME}._fs_users_ext"
-
-# replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
-SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT = f"""
-create table if not exists {USERS_TABLE_FQ_NAME} (
-    name varchar,
-    created_on TIMESTAMPTZ,
-    login_name varchar,
-    display_name varchar,
-    first_name varchar,
-    last_name varchar,
-    email varchar,
-    mins_to_unlock varchar,
-    days_to_expiry varchar,
-    comment varchar,
-    disabled varchar,
-    must_change_password varchar,
-    snowflake_lock varchar,
-    default_warehouse varchar,
-    default_namespace varchar,
-    default_role varchar,
-    default_secondary_roles varchar,
-    ext_authn_duo varchar,
-    ext_authn_uid varchar,
-    mins_to_bypass_mfa varchar,
-    owner varchar,
-    last_success_login TIMESTAMPTZ,
-    expires_at_time TIMESTAMPTZ,
-    locked_until_time TIMESTAMPTZ,
-    has_password varchar,
-    has_rsa_public_key varchar,
-)
-"""
-
-
-def create_global_database(conn: DuckDBPyConnection) -> None:
-    """Create a "global" database for storing objects which span database.
-
-    Including (but not limited to):
-     - Users
-    """
-    conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
-    conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)