fakesnow 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

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/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/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/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.dist-info → fakesnow-0.9.6.dist-info}/METADATA

@@ -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.6.dist-info/RECORD

@@ -0,0 +1,18 @@
+fakesnow/__init__.py,sha256=KWTeAxTcWXClN4bNo4kWHbC0ukOum7A4vtuL9zC1pT0,3472
+fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
+fakesnow/checks.py,sha256=-QMvdcrRbhN60rnzxLBJ0IkUBWyLR8gGGKKmCS0w9mA,2383
+fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
+fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
+fakesnow/fakes.py,sha256=5Fq_Qk-Iqxxzl-1XkcMyGDw2NY5hzE_50e5xii-jxhA,28463
+fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
+fakesnow/global_database.py,sha256=WTVIP1VhNvdCeX7TQncX1TRpGQU5rBf5Pbxim40zeSU,1399
+fakesnow/info_schema.py,sha256=CdIcGXHEQ_kmEAzdQKvA-PX41LA6wlK-4p1J45qgKYA,6266
+fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
+fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
+fakesnow/transforms.py,sha256=4cGfNbcd-X1l0UEGFudjoRejTjxSwWo-E0NXGpdVlaE,40109
+fakesnow-0.9.6.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.6.dist-info/METADATA,sha256=PBc3zlOgUpHFpxAJoTHnZaKcgZz8J6LqfVnP_yMytRw,17802
+fakesnow-0.9.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+fakesnow-0.9.6.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.6.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
+fakesnow-0.9.6.dist-info/RECORD,,

{fakesnow-0.9.4.dist-info → fakesnow-0.9.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

fakesnow-0.9.4.dist-info/RECORD

@@ -1,18 +0,0 @@
-fakesnow/__init__.py,sha256=UGfEpHKJWFEZfx_myvXuMyxMiHrFjfJmKnJcRQMyxL8,3443
-fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
-fakesnow/checks.py,sha256=-QMvdcrRbhN60rnzxLBJ0IkUBWyLR8gGGKKmCS0w9mA,2383
-fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
-fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
-fakesnow/fakes.py,sha256=gNw5tRu00pcC8m3CdLfv06wrHxBm_In8kJQ-IGNXp-Y,28197
-fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
-fakesnow/global_database.py,sha256=WTVIP1VhNvdCeX7TQncX1TRpGQU5rBf5Pbxim40zeSU,1399
-fakesnow/info_schema.py,sha256=5Rbq5HWb1YG-QY4Fj5zUC8KWRNt42aHw2J7tfHtbCug,5544
-fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
-fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
-fakesnow/transforms.py,sha256=z9tZDOtvQDAoYmQDvDegUOwxgBFvjnSfKCo7kTc-ryA,36300
-fakesnow-0.9.4.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
-fakesnow-0.9.4.dist-info/METADATA,sha256=4-uOp2P5nWelvwky5v7htSJPcLlZaJ0DtURryGxAdp4,17724
-fakesnow-0.9.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-fakesnow-0.9.4.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.4.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
-fakesnow-0.9.4.dist-info/RECORD,,