fakesnow 0.9.20__tar.gz → 0.9.21__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.20
+Version: 0.9.21
 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.5.1
 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.21}/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.21/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.21}/fakesnow/fakes.py

@@ -203,6 +203,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.sha256)
             .transform(transforms.create_clone)
             .transform(transforms.alias_in_join)
+            .transform(transforms.alter_table_strip_cluster_by)
         )
 
     def _execute(
@@ -522,9 +523,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 +544,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 +559,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 +570,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 +581,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 +608,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.21}/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
@@ -86,7 +86,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 +116,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.21/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.21/fakesnow/server.py

@@ -0,0 +1,108 @@
+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"],
+    ),
+]
+
+app = Starlette(debug=True, routes=routes)

{fakesnow-0.9.20 → fakesnow-0.9.21}/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
@@ -551,12 +563,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.21}/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.21}/fakesnow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.20
+Version: 0.9.21
 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.5.1
 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.21}/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.21}/fakesnow.egg-info/requires.txt

@@ -1,15 +1,17 @@
 duckdb~=1.0.0
 pyarrow
 snowflake-connector-python
-sqlglot~=25.3.0
+sqlglot~=25.5.1
 
 [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.21}/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.21"
 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.5.1",
 ]
 
 [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,14 @@ strictListInference = true
 strictDictionaryInference = true
 strictParameterNoneValue = true
 reportTypedDictNotRequiredAccess = false
+reportIncompatibleVariableOverride = true
 reportIncompatibleMethodOverride = true
+reportMatchNotExhaustive = true
 reportUnnecessaryTypeIgnoreComment = true
 
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
 [tool.ruff]
 line-length = 120
 # first-party imports for sorting

fakesnow-0.9.21/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.21}/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.21}/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):

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

@@ -38,6 +38,12 @@ def test_info_schema_columns_describe(cur: snowflake.connector.cursor.SnowflakeC
 
     assert cur.description == expected_metadata
 
+    # should contain snowflake-specific columns (from _FS_COLUMNS_SNOWFLAKE)
+    cur.execute("describe view information_schema.columns")
+    result = cur.fetchall()
+    names = [name for (name, *_) in result]
+    assert "comment" in names
+
 
 def test_info_schema_columns_numeric(cur: snowflake.connector.cursor.SnowflakeCursor):
     # see https://docs.snowflake.com/en/sql-reference/data-types-numeric
@@ -211,3 +217,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.21/tests/test_server.py

@@ -0,0 +1,53 @@
+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[int]:
+    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 port
+
+    server.should_exit = True
+    # wait for server thread to end
+    thread.join()
+
+
+def test_server_connect(server: int) -> None:
+    with (
+        snowflake.connector.connect(
+            user="fake",
+            password="snow",
+            account="fakesnow",
+            host="localhost",
+            port=server,
+            protocol="http",
+            # disable telemetry
+            session_parameters={"CLIENT_OUT_OF_BAND_TELEMETRY_ENABLED": False},
+            # disable infinite retries on error
+            network_timeout=0,
+        ) as conn1,
+        conn1.cursor() as cur,
+    ):
+        cur.execute("select 'hello', to_decimal('12.3456', 10,2)")
+        assert cur.fetchall() == [("hello", Decimal("12.35"))]

{fakesnow-0.9.20 → fakesnow-0.9.21}/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)