fakesnow 0.9.5__tar.gz → 0.9.6__tar.gz

{fakesnow-0.9.5/fakesnow.egg-info → fakesnow-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.5
+Version: 0.9.6
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -213,15 +213,15 @@ License-File: LICENSE
 Requires-Dist: duckdb~=0.10.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=21.1.0
+Requires-Dist: sqlglot~=21.2.0
 Provides-Extra: dev
-Requires-Dist: black~=23.9; 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: pytest~=7.4; extra == "dev"
-Requires-Dist: ruff~=0.1.6; extra == "dev"
-Requires-Dist: twine~=4.0; extra == "dev"
+Requires-Dist: pytest~=8.0; extra == "dev"
+Requires-Dist: ruff~=0.3.2; 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"
@@ -234,6 +234,8 @@ Requires-Dist: jupysql; extra == "notebook"
 [![release](https://github.com/tekumara/fakesnow/actions/workflows/release.yml/badge.svg)](https://github.com/tekumara/fakesnow/actions/workflows/release.yml)
 [![PyPI](https://img.shields.io/pypi/v/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 
+[![ci](../../actions/workflows/ci.yml/badge.svg)](../../actions/workflows/ci.yml)
+
 Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector). Run and mock Snowflake DB locally.
 
 ## Install

{fakesnow-0.9.5 → fakesnow-0.9.6}/README.md

@@ -4,6 +4,8 @@
 [![release](https://github.com/tekumara/fakesnow/actions/workflows/release.yml/badge.svg)](https://github.com/tekumara/fakesnow/actions/workflows/release.yml)
 [![PyPI](https://img.shields.io/pypi/v/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 
+[![ci](../../actions/workflows/ci.yml/badge.svg)](../../actions/workflows/ci.yml)
+
 Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector). Run and mock Snowflake DB locally.
 
 ## Install

{fakesnow-0.9.5 → fakesnow-0.9.6}/fakesnow/fakes.py

@@ -198,7 +198,10 @@ class FakeSnowflakeCursor:
             .transform(transforms.identifier)
             .transform(lambda e: transforms.show_schemas(e, self._conn.database))
             .transform(lambda e: transforms.show_objects_tables(e, self._conn.database))
-            .transform(lambda e: transforms.show_primary_keys(e, self._conn.database))
+            # TODO collapse into a single show_keys function
+            .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="PRIMARY"))
+            .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="UNIQUE"))
+            .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="FOREIGN"))
             .transform(transforms.show_users)
             .transform(transforms.create_user)
         )

{fakesnow-0.9.5 → fakesnow-0.9.6}/fakesnow/info_schema.py

@@ -1,4 +1,5 @@
 """Info schema extension tables/views used for storing snowflake metadata not captured by duckdb."""
+
 from __future__ import annotations
 
 from string import Template

{fakesnow-0.9.5 → fakesnow-0.9.6}/fakesnow/transforms.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pathlib import Path
 from string import Template
-from typing import cast
+from typing import Literal, cast
 
 import sqlglot
 from sqlglot import exp
@@ -38,7 +38,8 @@ def create_database(expression: exp.Expression, db_path: Path | None = None) ->
     """
 
     if isinstance(expression, exp.Create) and str(expression.args.get("kind")).upper() == "DATABASE":
-        assert (ident := expression.find(exp.Identifier)), f"No identifier in {expression.sql}"
+        ident = expression.find(exp.Identifier)
+        assert ident, f"No identifier in {expression.sql}"
         db_name = ident.this
         db_file = f"{db_path/db_name}.db" if db_path else ":memory:"
 
@@ -681,55 +682,61 @@ def set_schema(expression: exp.Expression, current_database: str | None) -> exp.
     return expression
 
 
-SQL_SHOW_OBJECTS = """
-select
-    to_timestamp(0)::timestamptz as 'created_on',
-    table_name as 'name',
-    case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind',
-    table_catalog as 'database_name',
-    table_schema as 'schema_name'
-from information_schema.tables
-"""
-
-
 def show_objects_tables(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
     """Transform SHOW OBJECTS/TABLES to a query against the information_schema.tables table.
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-objects
         https://docs.snowflake.com/en/sql-reference/sql/show-tables
     """
-    if (
+    if not (
         isinstance(expression, exp.Show)
         and isinstance(expression.this, str)
-        and expression.this.upper() in ["OBJECTS", "TABLES"]
+        and (show := expression.this.upper())
+        and show in {"OBJECTS", "TABLES"}
     ):
-        scope_kind = expression.args.get("scope_kind")
-        table = expression.find(exp.Table)
-
-        if scope_kind == "DATABASE":
-            catalog = (table and table.name) or current_database
-            schema = None
-        elif scope_kind == "SCHEMA" and table:
-            catalog = table.db or current_database
-            schema = table.name
-        else:
-            # all objects / tables
-            catalog = None
-            schema = None
-
-        tables_only = "table_type = 'BASE TABLE' and " if expression.this.upper() == "TABLES" else ""
-        exclude_fakesnow_tables = "not (table_schema == 'information_schema' and table_name like '_fs_%%')"
-        # without a database will show everything in the "account"
-        table_catalog = f" and table_catalog = '{catalog}'" if catalog else ""
-        schema = f" and table_schema = '{schema}'" if schema else ""
-        limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
-
-        return sqlglot.parse_one(
-            f"{SQL_SHOW_OBJECTS} where {tables_only}{exclude_fakesnow_tables}{table_catalog}{schema}{limit}",
-            read="duckdb",
-        )
+        return expression
 
-    return expression
+    scope_kind = expression.args.get("scope_kind")
+    table = expression.find(exp.Table)
+
+    if scope_kind == "DATABASE":
+        catalog = (table and table.name) or current_database
+        schema = None
+    elif scope_kind == "SCHEMA" and table:
+        catalog = table.db or current_database
+        schema = table.name
+    else:
+        # all objects / tables
+        catalog = None
+        schema = None
+
+    tables_only = "table_type = 'BASE TABLE' and " if show == "TABLES" else ""
+    exclude_fakesnow_tables = "not (table_schema == 'information_schema' and table_name like '_fs_%%')"
+    # without a database will show everything in the "account"
+    table_catalog = f" and table_catalog = '{catalog}'" if catalog else ""
+    schema = f" and table_schema = '{schema}'" if schema else ""
+    limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
+
+    columns = [
+        "to_timestamp(0)::timestamptz as 'created_on'",
+        "table_name as 'name'",
+        "case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind'",
+        "table_catalog as 'database_name'",
+        "table_schema as 'schema_name'",
+    ]
+
+    terse = expression.args["terse"]
+    if not terse:
+        columns.append('null as "comment"')
+
+    columns_str = ", ".join(columns)
+
+    query = (
+        f"SELECT {columns_str} from information_schema.tables "
+        f"where {tables_only}{exclude_fakesnow_tables}{table_catalog}{schema}{limit}"
+    )
+
+    return sqlglot.parse_one(query, read="duckdb")
 
 
 SQL_SHOW_SCHEMAS = """
@@ -999,32 +1006,70 @@ def create_user(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def show_primary_keys(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
-    """Transform SHOW PRIMARY KEYS to a query against the duckdb_constraints table.
+def show_keys(
+    expression: exp.Expression,
+    current_database: str | None = None,
+    *,
+    kind: Literal["PRIMARY", "UNIQUE", "FOREIGN"],
+) -> exp.Expression:
+    """Transform SHOW <kind> KEYS to a query against the duckdb_constraints meta-table.
 
     https://docs.snowflake.com/en/sql-reference/sql/show-primary-keys
     """
+    snowflake_kind = kind
+    if kind == "FOREIGN":
+        snowflake_kind = "IMPORTED"
+
     if (
         isinstance(expression, exp.Show)
         and isinstance(expression.this, str)
-        and expression.this.upper() == "PRIMARY KEYS"
+        and expression.this.upper() == f"{snowflake_kind} KEYS"
     ):
-        statement = f"""
-            SELECT
-                to_timestamp(0)::timestamptz as created_on,
-                database_name as database_name,
-                schema_name as schema_name,
-                table_name as table_name,
-                unnest(constraint_column_names) as column_name,
-                1 as key_sequence,
-                LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS constraint_name,
-                'false' as rely,
-                null as comment
-            FROM duckdb_constraints
-            WHERE constraint_type = 'PRIMARY KEY'
-              AND database_name = '{current_database}'
-              AND table_name NOT LIKE '_fs_%'
-            """
+        if kind == "FOREIGN":
+            statement = f"""
+                SELECT
+                    to_timestamp(0)::timestamptz as created_on,
+
+                    '' as pk_database_name,
+                    '' as pk_schema_name,
+                    '' as pk_table_name,
+                    '' as pk_column_name,
+                    unnest(constraint_column_names) as pk_column_name,
+
+                    database_name as fk_database_name,
+                    schema_name as fk_schema_name,
+                    table_name as fk_table_name,
+                    unnest(constraint_column_names) as fk_column_name,
+                    1 as key_sequence,
+                    'NO ACTION' as update_rule,
+                    'NO ACTION' as delete_rule,
+                    LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS fk_name,
+                    LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS pk_name,
+                    'NOT DEFERRABLE' as deferrability,
+                    'false' as rely,
+                    null as "comment"
+                FROM duckdb_constraints
+                WHERE constraint_type = 'PRIMARY KEY'
+                  AND database_name = '{current_database}'
+                  AND table_name NOT LIKE '_fs_%'
+                """
+        else:
+            statement = f"""
+                SELECT
+                    to_timestamp(0)::timestamptz as created_on,
+                    database_name as database_name,
+                    schema_name as schema_name,
+                    table_name as table_name,
+                    unnest(constraint_column_names) as column_name,
+                    1 as key_sequence,
+                    LOWER(CONCAT(database_name, '_', schema_name, '_', table_name, '_pkey')) AS constraint_name,
+                    'false' as rely,
+                    null as "comment"
+                FROM duckdb_constraints
+                WHERE constraint_type = '{kind} KEY'
+                  AND database_name = '{current_database}'
+                  AND table_name NOT LIKE '_fs_%'
+                """
 
         scope_kind = expression.args.get("scope_kind")
         if scope_kind:

{fakesnow-0.9.5 → fakesnow-0.9.6/fakesnow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.5
+Version: 0.9.6
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -213,15 +213,15 @@ License-File: LICENSE
 Requires-Dist: duckdb~=0.10.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=21.1.0
+Requires-Dist: sqlglot~=21.2.0
 Provides-Extra: dev
-Requires-Dist: black~=23.9; 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: pytest~=7.4; extra == "dev"
-Requires-Dist: ruff~=0.1.6; extra == "dev"
-Requires-Dist: twine~=4.0; extra == "dev"
+Requires-Dist: pytest~=8.0; extra == "dev"
+Requires-Dist: ruff~=0.3.2; 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"
@@ -234,6 +234,8 @@ Requires-Dist: jupysql; extra == "notebook"
 [![release](https://github.com/tekumara/fakesnow/actions/workflows/release.yml/badge.svg)](https://github.com/tekumara/fakesnow/actions/workflows/release.yml)
 [![PyPI](https://img.shields.io/pypi/v/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 
+[![ci](../../actions/workflows/ci.yml/badge.svg)](../../actions/workflows/ci.yml)
+
 Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector). Run and mock Snowflake DB locally.
 
 ## Install

{fakesnow-0.9.5 → fakesnow-0.9.6}/fakesnow.egg-info/SOURCES.txt

@@ -1,5 +1,4 @@
 LICENSE
-MANIFEST.in
 README.md
 pyproject.toml
 fakesnow/__init__.py

{fakesnow-0.9.5 → fakesnow-0.9.6}/fakesnow.egg-info/requires.txt

@@ -1,16 +1,16 @@
 duckdb~=0.10.0
 pyarrow
 snowflake-connector-python
-sqlglot~=21.1.0
+sqlglot~=21.2.0
 
 [dev]
-black~=23.9
 build~=1.0
+pandas-stubs
 snowflake-connector-python[pandas,secure-local-storage]
 pre-commit~=3.4
-pytest~=7.4
-ruff~=0.1.6
-twine~=4.0
+pytest~=8.0
+ruff~=0.3.2
+twine~=5.0
 snowflake-sqlalchemy~=1.5.0
 
 [notebook]

{fakesnow-0.9.5 → fakesnow-0.9.6}/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.5"
+version = "0.9.6"
 readme = "README.md"
 license = { file = "LICENSE" }
 classifiers = ["License :: OSI Approved :: MIT License"]
@@ -11,7 +11,7 @@ dependencies = [
     "duckdb~=0.10.0",
     "pyarrow",
     "snowflake-connector-python",
-    "sqlglot~=21.1.0",
+    "sqlglot~=21.2.0",
 ]
 
 [project.urls]
@@ -22,29 +22,26 @@ fakesnow = "fakesnow.cli:main"
 
 [project.optional-dependencies]
 dev = [
-    "black~=23.9",
     "build~=1.0",
+    # to fix https://github.com/pandas-dev/pandas/issues/56995
+    "pandas-stubs",
     # include compatible version of pandas, and secure-local-storage for token caching
     "snowflake-connector-python[pandas, secure-local-storage]",
     "pre-commit~=3.4",
-    "pytest~=7.4",
-    "ruff~=0.1.6",
-    "twine~=4.0",
+    "pytest~=8.0",
+    "ruff~=0.3.2",
+    "twine~=5.0",
     "snowflake-sqlalchemy~=1.5.0",
 ]
 # for debugging, see https://duckdb.org/docs/guides/python/jupyter.html
 notebook = ["duckdb-engine", "ipykernel", "jupysql"]
 
-[tool.setuptools.packages.find]
-where = ["."]
-exclude = ["tests*"]
-
 [build-system]
-requires = ["setuptools~=68.2", "wheel~=0.40"]
+requires = ["setuptools~=69.1", "wheel~=0.42"]
 
-[tool.black]
-# use PyCharm default line length of 120
-line-length = 120
+[tool.setuptools.packages.find]
+where = ["."]
+exclude = ["tests*", "node_modules*", "build*"]
 
 [tool.pyright]
 venvPath = "."
@@ -54,63 +51,53 @@ strictListInference = true
 strictDictionaryInference = true
 strictParameterNoneValue = true
 reportTypedDictNotRequiredAccess = false
+reportIncompatibleMethodOverride = true
+reportUnnecessaryTypeIgnoreComment = true
 
 [tool.ruff]
-# Compatibility between Ruff and Black
-# https://beta.ruff.rs/docs/faq/#is-ruff-compatible-with-black
 line-length = 120
+# first-party imports for sorting
+src = ["."]
+fix = true
+show-fixes = true
 
+[tool.ruff.lint]
 # rules to enable/ignore
 select = [
-    # pyflakes
-    "F",
-    # pycodestyle
-    "E",
-    "W",
-    # type annotations
-    "ANN",
-    # pep8-naming
-    "N",
-    # bugbear
-    "B",
-    # isort
-    "I",
-    # flake8-unused-arguments - disabled because our fakes don't use all arguments
-    # "ARG",
-    # flake8-self
-    "SLF",
-    # pyupgrade
-    "UP",
-    # perflint
-    "PERF",
-    # ruff-specific
-    "RUF",
-    # flake8-simplify
-    "SIM",
-    # flake8-builtins
-    "A"
+    "F",   # pyflakes
+    "E",   # pycodestyle
+    "W",   # pycodestyle
+    "ANN", # type annotations
+    "N",   # pep8-naming
+    "B",   # bugbear
+    "I",   # isort
+    # "ARG",  # flake8-unused-arguments - disabled because our fakes don't use all arguments
+    "SLF",  # flake8-self
+    "UP",   # pyupgrade
+    "PERF", # perflint
+    "RUF",  # ruff-specific
+    "SIM",  # flake8-simplify
+    "S113", # request-without-timeout
+    "A",    # flake8-builtins
 ]
 ignore = [
-    # allow untyped self and cls args, and no return type from dunder methods
+    # allow untyped self and cls args
     "ANN101",
     "ANN102",
+    # allow no return type from dunder methods
     "ANN204",
     # allow == True because pandas dataframes overload equality
     "E712",
 ]
-# first-party imports for sorting
-src = ["."]
-fix = true
-show-fixes = true
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 combine-as-imports = true
 force-wrap-aliases = true
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 # test functions don't need return types
 "tests/*" = ["ANN201", "ANN202"]
 
-[tool.ruff.flake8-annotations]
+[tool.ruff.lint.flake8-annotations]
 # allow *args: Any, **kwargs: Any
 allow-star-arg-any = true

{fakesnow-0.9.5 → fakesnow-0.9.6}/tests/test_fakes.py

@@ -115,17 +115,21 @@ def test_connect_different_sessions_use_database(_fakesnow_no_auto_create: None)
 
 def test_connect_reuse_db():
     with tempfile.TemporaryDirectory(prefix="fakesnow-test") as db_path:
-        with fakesnow.patch(db_path=db_path), snowflake.connector.connect(
-            database="db1", schema="schema1"
-        ) as conn, conn.cursor() as cur:
+        with (
+            fakesnow.patch(db_path=db_path),
+            snowflake.connector.connect(database="db1", schema="schema1") as conn,
+            conn.cursor() as cur,
+        ):
             # creates db1.schema1.example
             cur.execute("create table example (x int)")
             cur.execute("insert into example values (420)")
 
         # reconnect
-        with fakesnow.patch(db_path=db_path), snowflake.connector.connect(
-            database="db1", schema="schema1"
-        ) as conn, conn.cursor() as cur:
+        with (
+            fakesnow.patch(db_path=db_path),
+            snowflake.connector.connect(database="db1", schema="schema1") as conn,
+            conn.cursor() as cur,
+        ):
             assert cur.execute("select * from example").fetchall() == [(420,)]
 
 
@@ -864,6 +868,76 @@ def test_semi_structured_types(cur: snowflake.connector.cursor.SnowflakeCursor):
     ]
 
 
+@pytest.mark.xfail(
+    reason="only partial supports exists to support sqlalchemy, see test_reflect",
+)
+def test_show_keys(dcur: snowflake.connector.cursor.SnowflakeCursor):
+    dcur.execute("CREATE TABLE test_table (id INT PRIMARY KEY, name TEXT UNIQUE)")
+    dcur.execute("CREATE TABLE test_table2 (id INT, other_id INT, FOREIGN KEY (other_id) REFERENCES test_table(id))")
+
+    dcur.execute("SHOW PRIMARY KEYS")
+    primary_keys = dcur.fetchall()
+    assert primary_keys == [
+        {
+            "created_on": datetime.datetime(1970, 1, 1, 0, 0, tzinfo=pytz.utc),
+            "database_name": "DB1",
+            "schema_name": "SCHEMA1",
+            "table_name": "TEST_TABLE",
+            "column_name": "ID",
+            "key_sequence": 1,
+            "constraint_name": "SYS_CONSTRAINT_DB1_SCHEMA1_TEST_TABLE_ID_pk",
+            "rely": "false",
+            "comment": None,
+        }
+    ]
+
+    dcur.execute("SHOW UNIQUE KEYS")
+    unique_keys = dcur.fetchall()
+    assert unique_keys == [
+        {
+            "created_on": datetime.datetime(1970, 1, 1, 0, 0, tzinfo=pytz.utc),
+            "database_name": "DB1",
+            "schema_name": "SCHEMA1",
+            "table_name": "TEST_TABLE",
+            "column_name": "NAME",
+            "key_sequence": 1,
+            "constraint_name": "SYS_CONSTRAINT_DB1_SCHEMA1_TEST_TABLE_NAME_uk",
+            "rely": "false",
+            "comment": None,
+        }
+    ]
+
+    dcur.execute("SHOW IMPORTED KEYS")
+    foreign_keys = dcur.fetchall()
+    assert foreign_keys == [
+        {
+            "created_on": datetime.datetime(1970, 1, 1, 0, 0, tzinfo=pytz.utc),
+            "pk_database_name": "DB1",
+            "pk_schema_name": "SCHEMA1",
+            "pk_table_name": "TEST_TABLE",
+            "pk_column_name": "ID",
+            "fk_database_name": "DB1",
+            "fk_schema_name": "SCHEMA1",
+            "fk_table_name": "TEST_TABLE2",
+            "fk_column_name": "OTHER_ID",
+            "key_sequence": 1,
+            "update_rule": "NO ACTION",
+            "delete_rule": "NO ACTION",
+            "fk_name": "SYS_CONSTRAINT_DB1_SCHEMA1_TEST_TABLE2_OTHER_ID_fk",
+            "pk_name": "SYS_CONSTRAINT_DB1_SCHEMA1_TEST_TABLE_ID_pk",
+            "deferrability": "NOT DEFERRABLE",
+            "rely": "false",
+            "comment": None,
+        }
+    ]
+
+    dcur.execute("SHOW PRIMARY KEYS IN SCHEMA")
+    assert dcur.fetchall() == primary_keys
+
+    dcur.execute("SHOW PRIMARY KEYS IN DATABASE")
+    assert dcur.fetchall() == primary_keys
+
+
 def test_show_objects(dcur: snowflake.connector.cursor.SnowflakeCursor):
     dcur.execute("create table example(x int)")
     dcur.execute("create view view1 as select * from example")
@@ -885,6 +959,7 @@ def test_show_objects(dcur: snowflake.connector.cursor.SnowflakeCursor):
         },
     ]
     assert dcur.fetchall() == objects
+
     dcur.execute("show terse objects in database")
     assert dcur.fetchall() == [
         *objects,
@@ -905,6 +980,24 @@ def test_show_objects(dcur: snowflake.connector.cursor.SnowflakeCursor):
     ]
     assert [r.name for r in dcur.description] == ["created_on", "name", "kind", "database_name", "schema_name"]
 
+    dcur.execute("show objects").fetchall()
+    assert [r.name for r in dcur.description] == [
+        "created_on",
+        "name",
+        "kind",
+        "database_name",
+        "schema_name",
+        "comment",
+        # TODO: include these columns
+        # "cluster_by",
+        # "rows",
+        # "bytes",
+        # "owner",
+        # "retention_time",
+        # "owner_role_type",
+        # "budget"
+    ]
+
 
 def test_show_schemas(dcur: snowflake.connector.cursor.SnowflakeCursor):
     dcur.execute("show terse schemas in database db1 limit 100")
@@ -943,7 +1036,41 @@ def test_show_tables(dcur: snowflake.connector.cursor.SnowflakeCursor):
     # assert dcur.fetchall() == objects
     dcur.execute("show terse tables in db1.schema1")
     assert dcur.fetchall() == objects
-    assert [r.name for r in dcur.description] == ["created_on", "name", "kind", "database_name", "schema_name"]
+    assert [r.name for r in dcur.description] == [
+        "created_on",
+        "name",
+        "kind",
+        "database_name",
+        "schema_name",
+    ]
+
+    dcur.execute("show tables in db1.schema1")
+    assert [r.name for r in dcur.description] == [
+        "created_on",
+        "name",
+        "kind",
+        "database_name",
+        "schema_name",
+        "comment",
+        # TODO: include these columns
+        # "cluster_by",
+        # "rows",
+        # "bytes",
+        # "owner",
+        # "retention_time",
+        # "automatic_clustering",
+        # "change_tracking",
+        # "search_optimization",
+        # "search_optimization_progress",
+        # "search_optimization_bytes",
+        # "is_external",
+        # "enable_schema_evolution",
+        # "owner_role_type",
+        # "is_event",
+        # "budget",
+        # "is_hybrid",
+        # "is_iceberg",
+    ]
 
 
 def test_show_primary_keys(dcur: snowflake.connector.cursor.SnowflakeCursor):
@@ -981,7 +1108,7 @@ def test_show_primary_keys(dcur: snowflake.connector.cursor.SnowflakeCursor):
     result2 = dcur.fetchall()
     assert result == result2
 
-    # Assertion to sanity check that the above "in schema" filter isnt wrong, and in fact filters
+    # Assertion to sanity check that the above "in schema" filter isn't wrong, and in fact filters
     dcur.execute("show primary keys in schema db1.information_schema")
     result3 = dcur.fetchall()
     assert result3 == []

{fakesnow-0.9.5 → fakesnow-0.9.6}/tests/test_sqlalchemy.py

@@ -1,5 +1,5 @@
-import duckdb
-import pytest
+from typing import cast
+
 from sqlalchemy import Column, MetaData, Table, types
 from sqlalchemy.engine import Engine
 from sqlalchemy.sql.expression import TextClause
@@ -18,7 +18,7 @@ def test_engine(snowflake_engine: Engine):
 def test_metadata_create_all(snowflake_engine: Engine):
     metadata = MetaData()
 
-    table = Table("foo", metadata, Column(types.Integer, name="id"), Column(types.String, name="name"))
+    table = cast(Table, Table("foo", metadata, Column(types.Integer, name="id"), Column(types.String, name="name")))
     metadata.create_all(bind=snowflake_engine)
 
     with snowflake_engine.connect() as conn:
@@ -27,13 +27,20 @@ def test_metadata_create_all(snowflake_engine: Engine):
         assert result.fetchall() == []
 
 
-@pytest.mark.xfail(
-    reason="sqlglot currently has unsupported SHOW variants",
-    strict=True,
-    raises=duckdb.ParserException,
-)
 def test_reflect(snowflake_engine: Engine):
-    snowflake_engine.execute(TextClause("CREATE TABLE foo (id INTEGER, name VARCHAR)"))
+    with snowflake_engine.connect() as conn:
+        conn.execute(TextClause("CREATE TABLE foo (id INTEGER, name VARCHAR)"))
 
     metadata = MetaData()
     metadata.reflect(bind=snowflake_engine, only=["foo"])
+
+    assert metadata.tables
+    foo_table: Table = metadata.tables["foo"]
+
+    with snowflake_engine.connect() as conn:
+        result = conn.execute(foo_table.insert().values(id=1, name="one"))
+
+        result = conn.execute(foo_table.select())
+
+        assert result
+        assert result.fetchall() == [(1, "one")]

fakesnow-0.9.5/MANIFEST.in

@@ -1 +0,0 @@
-recursive-include fakesnow py.typed