fakesnow 0.9.4__tar.gz → 0.9.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.4
+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,20 +213,20 @@ 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"
 Requires-Dist: ipykernel; extra == "notebook"
 Requires-Dist: jupysql; extra == "notebook"
-Requires-Dist: snowflake-sqlalchemy; extra == "notebook"
 
 # fakesnow ❄️
 
@@ -234,6 +234,8 @@ Requires-Dist: snowflake-sqlalchemy; 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
@@ -356,7 +358,7 @@ For more detail see [tests/test_fakes.py](tests/test_fakes.py)
 ## Caveats
 
 - The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
-- VARCHAR field sizes are not enforced. Unlike Snowflake which errors with "User character length limit (xxx) exceeded by string" when an inserted string exceeds the column limit.
+- A more liberal Snowflake SQL dialect than a real Snowflake instance is supported, ie: some queries might pass using fakesnow that a real Snowflake instance would reject.
 
 ## Contributing
 

{fakesnow-0.9.4 → 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
@@ -126,7 +128,7 @@ For more detail see [tests/test_fakes.py](tests/test_fakes.py)
 ## Caveats
 
 - The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
-- VARCHAR field sizes are not enforced. Unlike Snowflake which errors with "User character length limit (xxx) exceeded by string" when an inserted string exceeds the column limit.
+- A more liberal Snowflake SQL dialect than a real Snowflake instance is supported, ie: some queries might pass using fakesnow that a real Snowflake instance would reject.
 
 ## Contributing
 

{fakesnow-0.9.4 → fakesnow-0.9.6}/fakesnow/__init__.py

@@ -85,6 +85,7 @@ def patch(
         p = mock.patch(im, side_effect=fake)
         stack.enter_context(p)
 
-    yield None
-
-    stack.close()
+    try:
+        yield None
+    finally:
+        stack.close()

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

@@ -37,6 +37,7 @@ SQL_SUCCESS = "SELECT 'Statement executed successfully.' as 'status'"
 SQL_CREATED_DATABASE = Template("SELECT 'Database ${name} successfully created.' as 'status'")
 SQL_CREATED_SCHEMA = Template("SELECT 'Schema ${name} successfully created.' as 'status'")
 SQL_CREATED_TABLE = Template("SELECT 'Table ${name} successfully created.' as 'status'")
+SQL_CREATED_VIEW = Template("SELECT 'View ${name} successfully created.' as 'status'")
 SQL_DROPPED = Template("SELECT '${name} successfully dropped.' as 'status'")
 SQL_INSERTED_ROWS = Template("SELECT ${count} as 'number of rows inserted'")
 SQL_UPDATED_ROWS = Template("SELECT ${count} as 'number of rows updated', 0 as 'number of multi-joined rows updated'")
@@ -177,6 +178,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.indices_to_json_extract)
             .transform(transforms.json_extract_cast_as_varchar)
             .transform(transforms.json_extract_cased_as_varchar)
+            .transform(transforms.json_extract_precedence)
             .transform(transforms.flatten)
             .transform(transforms.regex_replace)
             .transform(transforms.regex_substr)
@@ -196,6 +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))
+            # 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)
         )
@@ -230,12 +236,18 @@ class FakeSnowflakeCursor:
             raise snowflake.connector.errors.DatabaseError(msg=e.args[0], errno=250002, sqlstate="08003") from None
 
         affected_count = None
-        if cmd == "USE DATABASE" and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
-            self._conn.database = ident.this.upper()
+
+        if (maybe_ident := expression.find(exp.Identifier, bfs=False)) and isinstance(maybe_ident.this, str):
+            ident = maybe_ident.this if maybe_ident.quoted else maybe_ident.this.upper()
+        else:
+            ident = None
+
+        if cmd == "USE DATABASE" and ident:
+            self._conn.database = ident
             self._conn.database_set = True
 
-        elif cmd == "USE SCHEMA" and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
-            self._conn.schema = ident.this.upper()
+        elif cmd == "USE SCHEMA" and ident:
+            self._conn.schema = ident
             self._conn.schema_set = True
 
         elif create_db_name := transformed.args.get("create_db_name"):
@@ -243,24 +255,24 @@ class FakeSnowflakeCursor:
             self._duck_conn.execute(info_schema.creation_sql(create_db_name))
             result_sql = SQL_CREATED_DATABASE.substitute(name=create_db_name)
 
-        elif cmd == "CREATE SCHEMA" and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
-            name = ident.this if ident.quoted else ident.this.upper()
-            result_sql = SQL_CREATED_SCHEMA.substitute(name=name)
+        elif cmd == "CREATE SCHEMA" and ident:
+            result_sql = SQL_CREATED_SCHEMA.substitute(name=ident)
+
+        elif cmd == "CREATE TABLE" and ident:
+            result_sql = SQL_CREATED_TABLE.substitute(name=ident)
 
-        elif cmd == "CREATE TABLE" and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
-            name = ident.this if ident.quoted else ident.this.upper()
-            result_sql = SQL_CREATED_TABLE.substitute(name=name)
+        elif cmd == "CREATE VIEW" and ident:
+            result_sql = SQL_CREATED_VIEW.substitute(name=ident)
 
-        elif cmd.startswith("DROP") and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
-            name = ident.this if ident.quoted else ident.this.upper()
-            result_sql = SQL_DROPPED.substitute(name=name)
+        elif cmd.startswith("DROP") and ident:
+            result_sql = SQL_DROPPED.substitute(name=ident)
 
             # if dropping the current database/schema then reset conn metadata
-            if cmd == "DROP DATABASE" and name == self._conn.database:
+            if cmd == "DROP DATABASE" and ident == self._conn.database:
                 self._conn.database = None
                 self._conn.schema = None
 
-            elif cmd == "DROP SCHEMA" and name == self._conn.schema:
+            elif cmd == "DROP SCHEMA" and ident == self._conn.schema:
                 self._conn.schema = None
 
         elif cmd == "INSERT":

{fakesnow-0.9.4 → 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
@@ -35,28 +36,45 @@ create table if not exists ${catalog}.information_schema._fs_columns_ext (
 SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_VIEW = Template(
     """
 create view if not exists ${catalog}.information_schema._fs_columns_snowflake AS
-select table_catalog, table_schema, table_name, column_name, ordinal_position, column_default, is_nullable,
-case when starts_with(data_type, 'DECIMAL') or data_type='BIGINT' then 'NUMBER'
-     when data_type='VARCHAR' then 'TEXT'
-     when data_type='DOUBLE' then 'FLOAT'
-     when data_type='BLOB' then 'BINARY'
-     when data_type='TIMESTAMP' then 'TIMESTAMP_NTZ'
-     when data_type='TIMESTAMP WITH TIME ZONE' then 'TIMESTAMP_TZ'
-     when data_type='JSON' then 'VARIANT'
-     else data_type end as data_type,
+select
+    columns.table_catalog AS table_catalog,
+    columns.table_schema AS table_schema,
+    columns.table_name AS table_name,
+    columns.column_name AS column_name,
+    columns.ordinal_position AS ordinal_position,
+    columns.column_default AS column_default,
+    columns.is_nullable AS is_nullable,
+case when starts_with(columns.data_type, 'DECIMAL') or columns.data_type='BIGINT' then 'NUMBER'
+     when columns.data_type='VARCHAR' then 'TEXT'
+     when columns.data_type='DOUBLE' then 'FLOAT'
+     when columns.data_type='BLOB' then 'BINARY'
+     when columns.data_type='TIMESTAMP' then 'TIMESTAMP_NTZ'
+     when columns.data_type='TIMESTAMP WITH TIME ZONE' then 'TIMESTAMP_TZ'
+     when columns.data_type='JSON' then 'VARIANT'
+     else columns.data_type end as data_type,
 ext_character_maximum_length as character_maximum_length, ext_character_octet_length as character_octet_length,
-case when data_type='BIGINT' then 38
-     when data_type='DOUBLE' then NULL
-    else numeric_precision end as numeric_precision,
-case when data_type='BIGINT' then 10
-    when data_type='DOUBLE' then NULL
-    else numeric_precision_radix end as numeric_precision_radix,
-case when data_type='DOUBLE' then NULL else numeric_scale end as numeric_scale,
-collation_name, is_identity, identity_generation, identity_cycle
-from ${catalog}.information_schema.columns
+case when columns.data_type='BIGINT' then 38
+     when columns.data_type='DOUBLE' then NULL
+    else columns.numeric_precision end as numeric_precision,
+case when columns.data_type='BIGINT' then 10
+    when columns.data_type='DOUBLE' then NULL
+    else columns.numeric_precision_radix end as numeric_precision_radix,
+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,
+from ${catalog}.information_schema.columns columns
 left join ${catalog}.information_schema._fs_columns_ext ext
-on ext_table_catalog = table_catalog AND ext_table_schema = table_schema
-AND ext_table_name = table_name AND ext_column_name = column_name
+  on ext_table_catalog = columns.table_catalog
+ AND ext_table_schema = columns.table_schema
+ AND ext_table_name = columns.table_name
+ AND ext_column_name = columns.column_name
+LEFT JOIN duckdb_columns ddb_columns
+  ON ddb_columns.database_name = columns.table_catalog
+ AND ddb_columns.schema_name = columns.table_schema
+ AND ddb_columns.table_name = columns.table_name
+ AND ddb_columns.column_name = columns.column_name
 """
 )
 

{fakesnow-0.9.4 → 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:"
 
@@ -449,6 +450,16 @@ def json_extract_cast_as_varchar(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def json_extract_precedence(expression: exp.Expression) -> exp.Expression:
+    """Associate json extract operands to avoid duckdb operators of higher precedence transforming the expression.
+
+    See https://github.com/tekumara/fakesnow/issues/53
+    """
+    if isinstance(expression, exp.JSONExtract):
+        return exp.Paren(this=expression)
+    return expression
+
+
 def random(expression: exp.Expression) -> exp.Expression:
     """Convert random() and random(seed).
 
@@ -671,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 = """
@@ -987,3 +1004,86 @@ def create_user(expression: exp.Expression) -> exp.Expression:
             return sqlglot.parse_one(f"INSERT INTO {USERS_TABLE_FQ_NAME} (name) VALUES ('{name}')", read="duckdb")
 
     return expression
+
+
+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() == f"{snowflake_kind} KEYS"
+    ):
+        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:
+            table = expression.args["scope"]
+
+            if scope_kind == "SCHEMA":
+                db = table and table.db
+                schema = table and table.name
+                if db:
+                    statement += f"AND database_name = '{db}' "
+
+                if schema:
+                    statement += f"AND schema_name = '{schema}' "
+            else:
+                raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind} not yet supported")
+        return sqlglot.parse_one(statement)
+    return expression

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.4
+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,20 +213,20 @@ 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"
 Requires-Dist: ipykernel; extra == "notebook"
 Requires-Dist: jupysql; extra == "notebook"
-Requires-Dist: snowflake-sqlalchemy; extra == "notebook"
 
 # fakesnow ❄️
 
@@ -234,6 +234,8 @@ Requires-Dist: snowflake-sqlalchemy; 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
@@ -356,7 +358,7 @@ For more detail see [tests/test_fakes.py](tests/test_fakes.py)
 ## Caveats
 
 - The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
-- VARCHAR field sizes are not enforced. Unlike Snowflake which errors with "User character length limit (xxx) exceeded by string" when an inserted string exceeds the column limit.
+- A more liberal Snowflake SQL dialect than a real Snowflake instance is supported, ie: some queries might pass using fakesnow that a real Snowflake instance would reject.
 
 ## Contributing
 

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

@@ -1,5 +1,4 @@
 LICENSE
-MANIFEST.in
 README.md
 pyproject.toml
 fakesnow/__init__.py
@@ -26,5 +25,6 @@ tests/test_expr.py
 tests/test_fakes.py
 tests/test_info_schema.py
 tests/test_patch.py
+tests/test_sqlalchemy.py
 tests/test_transforms.py
 tests/test_users.py

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

@@ -1,19 +1,19 @@
 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]
 duckdb-engine
 ipykernel
 jupysql
-snowflake-sqlalchemy

{fakesnow-0.9.4 → 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.4"
+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,28 +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", "snowflake-sqlalchemy"]
-
-[tool.setuptools.packages.find]
-where = ["."]
-exclude = ["tests*"]
+notebook = ["duckdb-engine", "ipykernel", "jupysql"]
 
 [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 = "."
@@ -53,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.4 → 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,)]
 
 
@@ -438,6 +442,15 @@ def test_description_create_drop_table(dcur: snowflake.connector.cursor.DictCurs
     assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
 
 
+def test_description_create_drop_view(dcur: snowflake.connector.cursor.DictCursor):
+    dcur.execute("create view example(id) as select 1")
+    assert dcur.fetchall() == [{"status": "View EXAMPLE successfully created."}]
+    assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+    dcur.execute("drop view example")
+    assert dcur.fetchall() == [{"status": "EXAMPLE successfully dropped."}]
+    assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+
+
 def test_description_insert(dcur: snowflake.connector.cursor.DictCursor):
     dcur.execute("create table example (x int)")
     dcur.execute("insert into example values (1), (2)")
@@ -649,6 +662,11 @@ def test_get_path_as_varchar(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert cur.fetchall() == [("42",)]
 
 
+def test_get_path_precedence(cur: snowflake.connector.cursor.SnowflakeCursor):
+    cur.execute("select {'K1': {'K2': 1}} as col where col:K1:K2 > 0")
+    assert indent(cur.fetchall()) == [('{\n  "K1": {\n    "K2": 1\n  }\n}',)]
+
+
 def test_get_result_batches(cur: snowflake.connector.cursor.SnowflakeCursor):
     # no result set
     assert cur.get_result_batches() is None
@@ -850,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")
@@ -871,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,
@@ -891,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")
@@ -929,7 +1036,82 @@ 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):
+    dcur.execute("CREATE TABLE example (id int, name varchar, PRIMARY KEY (id, name))")
+
+    dcur.execute("show primary keys")
+    result = dcur.fetchall()
+
+    assert result == [
+        {
+            "created_on": datetime.datetime(1970, 1, 1, 0, 0, tzinfo=pytz.utc),
+            "database_name": "DB1",
+            "schema_name": "SCHEMA1",
+            "table_name": "EXAMPLE",
+            "column_name": "ID",
+            "key_sequence": 1,
+            "constraint_name": "db1_schema1_example_pkey",
+            "rely": "false",
+            "comment": None,
+        },
+        {
+            "created_on": datetime.datetime(1970, 1, 1, 0, 0, tzinfo=pytz.utc),
+            "database_name": "DB1",
+            "schema_name": "SCHEMA1",
+            "table_name": "EXAMPLE",
+            "column_name": "NAME",
+            "key_sequence": 1,
+            "constraint_name": "db1_schema1_example_pkey",
+            "rely": "false",
+            "comment": None,
+        },
+    ]
+
+    dcur.execute("show primary keys in schema db1.schema1")
+    result2 = dcur.fetchall()
+    assert result == result2
+
+    # 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 == []
 
 
 def test_sqlstate(cur: snowflake.connector.cursor.SnowflakeCursor):

fakesnow-0.9.6/tests/test_sqlalchemy.py

@@ -0,0 +1,46 @@
+from typing import cast
+
+from sqlalchemy import Column, MetaData, Table, types
+from sqlalchemy.engine import Engine
+from sqlalchemy.sql.expression import TextClause
+
+
+def test_engine(snowflake_engine: Engine):
+    # verifies cursor.description, commit, and rollback issued by SQLAlchemy
+    with snowflake_engine.connect() as conn:
+        conn.execute(TextClause("CREATE VIEW foo AS SELECT * FROM information_schema.databases"))
+
+        result = conn.execute("SELECT database_name FROM foo")
+        assert result
+        assert result.fetchall() == [("DB1",)]
+
+
+def test_metadata_create_all(snowflake_engine: Engine):
+    metadata = MetaData()
+
+    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:
+        result = conn.execute(table.select())
+        assert result
+        assert result.fetchall() == []
+
+
+def test_reflect(snowflake_engine: Engine):
+    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.4 → fakesnow-0.9.6}/tests/test_transforms.py

@@ -21,6 +21,7 @@ from fakesnow.transforms import (
     integer_precision,
     json_extract_cased_as_varchar,
     json_extract_cast_as_varchar,
+    json_extract_precedence,
     object_construct,
     parse_json,
     random,
@@ -237,6 +238,18 @@ def test_json_extract_cast_as_varchar() -> None:
     )
 
 
+def test_json_extract_precedence() -> None:
+    assert (
+        sqlglot.parse_one(
+            """select {'K1': {'K2': 1}} as col where col:K1:K2 > 0""",
+            read="snowflake",
+        )
+        .transform(json_extract_precedence)
+        .sql(dialect="duckdb")
+        == """SELECT {'K1': {'K2': 1}} AS col WHERE (col -> '$.K1' -> '$.K2') > 0"""
+    )
+
+
 def test_object_construct() -> None:
     assert (
         sqlglot.parse_one(

fakesnow-0.9.4/MANIFEST.in

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