fakesnow 0.9.21__tar.gz → 0.9.22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.21
+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,7 +213,7 @@ License-File: LICENSE
 Requires-Dist: duckdb~=1.0.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=25.5.1
+Requires-Dist: sqlglot~=25.9.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

{fakesnow-0.9.21 → 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())
@@ -235,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]
@@ -287,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")
@@ -337,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()
@@ -347,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,
@@ -389,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:

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

@@ -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(
     """

{fakesnow-0.9.21 → fakesnow-0.9.22}/fakesnow/server.py

@@ -103,6 +103,7 @@ routes = [
         query_request,
         methods=["POST"],
     ),
+    Route("/queries/v1/abort-request", lambda _: JSONResponse({"success": True}), methods=["POST"]),
 ]
 
 app = Starlette(debug=True, routes=routes)

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

@@ -159,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
     """
@@ -183,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",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.21
+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,7 +213,7 @@ License-File: LICENSE
 Requires-Dist: duckdb~=1.0.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=25.5.1
+Requires-Dist: sqlglot~=25.9.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

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

@@ -1,7 +1,7 @@
 duckdb~=1.0.0
 pyarrow
 snowflake-connector-python
-sqlglot~=25.5.1
+sqlglot~=25.9.0
 
 [dev]
 build~=1.0

{fakesnow-0.9.21 → 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.21"
+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.5.1",
+    "sqlglot~=25.9.0",
 ]
 
 [project.urls]
@@ -62,6 +62,9 @@ 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

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

@@ -436,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")
@@ -605,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")
@@ -615,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.21 → fakesnow-0.9.22}/tests/test_info_schema.py

@@ -38,11 +38,45 @@ 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)
-    cur.execute("describe view information_schema.columns")
-    result = cur.fetchall()
-    names = [name for (name, *_) in result]
     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):

{fakesnow-0.9.21 → fakesnow-0.9.22}/tests/test_server.py

@@ -18,7 +18,7 @@ def unused_port(unused_tcp_port_factory: Callable[[], int]) -> int:
 
 
 @pytest.fixture(scope="session")
-def server(unused_tcp_port_factory: Callable[[], int]) -> Iterator[int]:
+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)
@@ -26,28 +26,42 @@ def server(unused_tcp_port_factory: Callable[[], int]) -> Iterator[int]:
 
     while not server.started:
         sleep(0.1)
-    yield port
+    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: int) -> None:
+def test_server_connect(server: dict) -> 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},
+            **server,
             # disable infinite retries on error
-            network_timeout=0,
+            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'")