fakesnow 0.9.28__py3-none-any.whl → 0.9.30__py3-none-any.whl

fakesnow/checks.py

@@ -63,6 +63,11 @@ def is_unqualified_table_expression(expression: exp.Expression) -> tuple[bool, b
         else:
             raise AssertionError(f"Unexpected parent kind: {parent_kind.name}")
 
+    elif node.parent.key == "show":
+        # don't require a database or schema for SHOW
+        # TODO: make this more nuanced
+        no_database = False
+        no_schema = False
     else:
         no_database = not node.args.get("catalog")
         no_schema = not node.args.get("db")

fakesnow/conn.py

@@ -42,13 +42,15 @@ class FakeSnowflakeConnection:
         # information_schema.schemata below we use upper-case to match any existing duckdb
         # catalog or schemas like "information_schema"
         self.database = database and database.upper()
-        self.schema = schema and schema.upper()
+        self._schema = schema and (
+            "_FS_INFORMATION_SCHEMA" if schema.upper() == "INFORMATION_SCHEMA" else schema.upper()
+        )
 
         self.database_set = False
         self.schema_set = False
         self.db_path = Path(db_path) if db_path else None
         self.nop_regexes = nop_regexes
-        self._paramstyle = snowflake.connector.paramstyle
+        self._paramstyle = kwargs.get("paramstyle", snowflake.connector.paramstyle)
         self.variables = Variables()
 
         # create database if needed
@@ -62,31 +64,31 @@ class FakeSnowflakeConnection:
         ):
             db_file = f"{self.db_path / self.database}.db" if self.db_path else ":memory:"
             duck_conn.execute(f"ATTACH DATABASE '{db_file}' AS {self.database}")
-            duck_conn.execute(info_schema.creation_sql(self.database))
+            duck_conn.execute(info_schema.per_db_creation_sql(self.database))
             duck_conn.execute(macros.creation_sql(self.database))
 
         # create schema if needed
         if (
             create_schema
             and self.database
-            and self.schema
+            and self._schema
             and not duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self.schema}'"""
+                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self._schema}'"""
             ).fetchone()
         ):
-            duck_conn.execute(f"CREATE SCHEMA {self.database}.{self.schema}")
+            duck_conn.execute(f"CREATE SCHEMA {self.database}.{self._schema}")
 
         # set database and schema if both exist
         if (
             self.database
-            and self.schema
+            and self._schema
             and duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self.schema}'"""
+                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self._schema}'"""
             ).fetchone()
         ):
-            duck_conn.execute(f"SET schema='{self.database}.{self.schema}'")
+            duck_conn.execute(f"SET schema='{self.database}.{self._schema}'")
             self.database_set = True
             self.schema_set = True
         # set database if only that exists
@@ -149,3 +151,7 @@ class FakeSnowflakeConnection:
 
     def rollback(self) -> None:
         self.cursor().execute("ROLLBACK")
+
+    @property
+    def schema(self) -> str | None:
+        return "INFORMATION_SCHEMA" if self._schema == "_FS_INFORMATION_SCHEMA" else self._schema

fakesnow/cursor.py

@@ -145,6 +145,8 @@ class FakeSnowflakeCursor:
                 return self
 
             expression = parse_one(command, read="snowflake")
+            self.check_db_and_schema(expression)
+
             for exp in self._transform_explode(expression):
                 transformed = self._transform(exp)
                 self._execute(transformed, params)
@@ -154,6 +156,24 @@ class FakeSnowflakeCursor:
             self._sqlstate = e.sqlstate
             raise e
 
+    def check_db_and_schema(self, expression: exp.Expression) -> None:
+        no_database, no_schema = checks.is_unqualified_table_expression(expression)
+
+        if no_database and not self._conn.database_set:
+            cmd = expr.key_command(expression)
+            raise snowflake.connector.errors.ProgrammingError(
+                msg=f"Cannot perform {cmd}. This session does not have a current database. Call 'USE DATABASE', or use a qualified name.",  # noqa: E501
+                errno=90105,
+                sqlstate="22000",
+            )
+        elif no_schema and not self._conn.schema_set:
+            cmd = expr.key_command(expression)
+            raise snowflake.connector.errors.ProgrammingError(
+                msg=f"Cannot perform {cmd}. This session does not have a current schema. Call 'USE SCHEMA', or use a qualified name.",  # noqa: E501
+                errno=90106,
+                sqlstate="22000",
+            )
+
     def _transform(self, expression: exp.Expression) -> exp.Expression:
         return (
             expression.transform(transforms.upper_case_unquoted_identifiers)
@@ -162,8 +182,9 @@ class FakeSnowflakeCursor:
             .transform(transforms.create_database, db_path=self._conn.db_path)
             .transform(transforms.extract_comment_on_table)
             .transform(transforms.extract_comment_on_columns)
-            .transform(transforms.information_schema_fs_columns_snowflake)
-            .transform(transforms.information_schema_fs_tables_ext)
+            .transform(transforms.information_schema_fs_columns)
+            .transform(transforms.information_schema_databases, current_schema=self._conn.schema)
+            .transform(transforms.information_schema_fs_tables)
             .transform(transforms.information_schema_fs_views)
             .transform(transforms.drop_schema_cascade)
             .transform(transforms.tag)
@@ -201,6 +222,9 @@ class FakeSnowflakeCursor:
             .transform(transforms.dateadd_date_cast)
             .transform(transforms.dateadd_string_literal_timestamp_cast)
             .transform(transforms.datediff_string_literal_timestamp_cast)
+            .transform(transforms.show_databases)
+            .transform(transforms.show_functions)
+            .transform(transforms.show_procedures)
             .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
@@ -228,21 +252,6 @@ class FakeSnowflakeCursor:
 
         cmd = expr.key_command(transformed)
 
-        no_database, no_schema = checks.is_unqualified_table_expression(transformed)
-
-        if no_database and not self._conn.database_set:
-            raise snowflake.connector.errors.ProgrammingError(
-                msg=f"Cannot perform {cmd}. This session does not have a current database. Call 'USE DATABASE', or use a qualified name.",  # noqa: E501
-                errno=90105,
-                sqlstate="22000",
-            )
-        elif no_schema and not self._conn.schema_set:
-            raise snowflake.connector.errors.ProgrammingError(
-                msg=f"Cannot perform {cmd}. This session does not have a current schema. Call 'USE SCHEMA', or use a qualified name.",  # noqa: E501
-                errno=90106,
-                sqlstate="22000",
-            )
-
         sql = transformed.sql(dialect="duckdb")
 
         if transformed.find(exp.Select) and (seed := transformed.args.get("seed")):
@@ -270,20 +279,24 @@ class FakeSnowflakeCursor:
                 raise e
         except duckdb.ConnectionException as e:
             raise snowflake.connector.errors.DatabaseError(msg=e.args[0], errno=250002, sqlstate="08003") from None
+        except duckdb.ParserException as e:
+            raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=1003, sqlstate="42000") from None
 
         affected_count = None
 
         if set_database := transformed.args.get("set_database"):
             self._conn.database = set_database
             self._conn.database_set = True
+            result_sql = SQL_SUCCESS
 
         elif set_schema := transformed.args.get("set_schema"):
-            self._conn.schema = set_schema
+            self._conn._schema = set_schema  # noqa: SLF001
             self._conn.schema_set = True
+            result_sql = SQL_SUCCESS
 
         elif create_db_name := transformed.args.get("create_db_name"):
             # we created a new database, so create the info schema extensions
-            self._duck_conn.execute(info_schema.creation_sql(create_db_name))
+            self._duck_conn.execute(info_schema.per_db_creation_sql(create_db_name))
             result_sql = SQL_CREATED_DATABASE.substitute(name=create_db_name)
 
         elif cmd == "INSERT":
@@ -328,10 +341,10 @@ class FakeSnowflakeCursor:
                 # if dropping the current database/schema then reset conn metadata
                 if cmd == "DROP DATABASE" and ident == self._conn.database:
                     self._conn.database = None
-                    self._conn.schema = None
+                    self._conn._schema = None  # noqa: SLF001
 
                 elif cmd == "DROP SCHEMA" and ident == self._conn.schema:
-                    self._conn.schema = None
+                    self._conn._schema = None  # noqa: SLF001
 
         if table_comment := cast(tuple[exp.Table, str], transformed.args.get("table_comment")):
             # record table comment

fakesnow/info_schema.py

@@ -4,10 +4,14 @@ from __future__ import annotations
 
 from string import Template
 
+SQL_CREATE_GLOBAL_FS_INFORMATION_SCHEMA = """
+create schema if not exists _fs_global._fs_information_schema
+"""
+
+
 # use ext prefix in columns to disambiguate when joining with information_schema.tables
-SQL_CREATE_INFORMATION_SCHEMA_TABLES_EXT = Template(
-    """
-create table if not exists ${catalog}.information_schema._fs_tables_ext (
+SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_TABLES_EXT = """
+create table if not exists _fs_global._fs_information_schema._fs_tables_ext (
     ext_table_catalog varchar,
     ext_table_schema varchar,
     ext_table_name varchar,
@@ -15,11 +19,10 @@ create table if not exists ${catalog}.information_schema._fs_tables_ext (
     PRIMARY KEY(ext_table_catalog, ext_table_schema, ext_table_name)
 )
 """
-)
 
-SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_EXT = Template(
-    """
-create table if not exists ${catalog}.information_schema._fs_columns_ext (
+
+SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_EXT = """
+create table if not exists _fs_global._fs_information_schema._fs_columns_ext (
     ext_table_catalog varchar,
     ext_table_schema varchar,
     ext_table_name varchar,
@@ -29,13 +32,57 @@ create table if not exists ${catalog}.information_schema._fs_columns_ext (
     PRIMARY KEY(ext_table_catalog, ext_table_schema, ext_table_name, ext_column_name)
 )
 """
+
+# replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
+SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE_EXT = """
+create table if not exists _fs_global._fs_information_schema._fs_users_ext (
+    name varchar,
+    created_on TIMESTAMPTZ,
+    login_name varchar,
+    display_name varchar,
+    first_name varchar,
+    last_name varchar,
+    email varchar,
+    mins_to_unlock varchar,
+    days_to_expiry varchar,
+    comment varchar,
+    disabled varchar,
+    must_change_password varchar,
+    snowflake_lock varchar,
+    default_warehouse varchar,
+    default_namespace varchar,
+    default_role varchar,
+    default_secondary_roles varchar,
+    ext_authn_duo varchar,
+    ext_authn_uid varchar,
+    mins_to_bypass_mfa varchar,
+    owner varchar,
+    last_success_login TIMESTAMPTZ,
+    expires_at_time TIMESTAMPTZ,
+    locked_until_time TIMESTAMPTZ,
+    has_password varchar,
+    has_rsa_public_key varchar,
+)
+"""
+
+
+SQL_CREATE_FS_INFORMATION_SCHEMA = Template(
+    """
+create schema if not exists ${catalog}._fs_information_schema
+"""
 )
 
-# only include fields applicable to snowflake (as mentioned by describe table information_schema.columns)
-# snowflake integers are 38 digits, base 10, See https://docs.snowflake.com/en/sql-reference/data-types-numeric
 SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_VIEW = Template(
     """
-create view if not exists ${catalog}.information_schema._fs_columns_snowflake AS
+create view if not exists ${catalog}._fs_information_schema._fs_columns AS
+select * from _fs_global._fs_information_schema._fs_columns where table_catalog = '${catalog}'
+    """
+)
+
+# only include fields applicable to snowflake (as mentioned by describe table information_schema.columns)
+# snowflake integers are 38 digits, base 10, See https://docs.snowflake.com/en/sql-reference/data-types-numeric
+SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_VIEW = """
+create view if not exists _fs_global._fs_information_schema._fs_columns AS
 select
     columns.table_catalog AS table_catalog,
     columns.table_schema AS table_schema,
@@ -64,8 +111,8 @@ collation_name, is_identity, identity_generation, identity_cycle,
     ddb_columns.comment as comment,
     null::VARCHAR as identity_start,
     null::VARCHAR as identity_increment,
-from ${catalog}.information_schema.columns columns
-left join ${catalog}.information_schema._fs_columns_ext ext
+from system.information_schema.columns columns
+left join _fs_global._fs_information_schema._fs_columns_ext ext
   on ext_table_catalog = columns.table_catalog
  AND ext_table_schema = columns.table_schema
  AND ext_table_name = columns.table_name
@@ -75,14 +122,14 @@ LEFT JOIN duckdb_columns ddb_columns
  AND ddb_columns.schema_name = columns.table_schema
  AND ddb_columns.table_name = columns.table_name
  AND ddb_columns.column_name = columns.column_name
+where schema_name != '_fs_information_schema'
 """
-)
 
 
 # replicates https://docs.snowflake.com/sql-reference/info-schema/databases
 SQL_CREATE_INFORMATION_SCHEMA_DATABASES_VIEW = Template(
     """
-create view if not exists ${catalog}.information_schema.databases AS
+create view if not exists ${catalog}._fs_information_schema.databases AS
 select
     catalog_name as database_name,
     'SYSADMIN' as database_owner,
@@ -92,17 +139,31 @@ select
     to_timestamp(0)::timestamptz as last_altered,
     1 as retention_time,
     'STANDARD' as type
-from information_schema.schemata
+from system.information_schema.schemata
 where catalog_name not in ('memory', 'system', 'temp', '_fs_global')
-  and schema_name = 'information_schema'
+  and schema_name = 'main'
 """
 )
 
+# replicates https://docs.snowflake.com/sql-reference/info-schema/tables
+SQL_CREATE_INFORMATION_SCHEMA_TABLES_VIEW = Template(
+    """
+create view if not exists ${catalog}._fs_information_schema._fs_tables AS
+select *
+from system.information_schema.tables tables
+left join _fs_global._fs_information_schema._fs_tables_ext on
+    tables.table_catalog = _fs_tables_ext.ext_table_catalog AND
+    tables.table_schema = _fs_tables_ext.ext_table_schema AND
+    tables.table_name = _fs_tables_ext.ext_table_name
+where table_catalog = '${catalog}'
+  and table_schema != '_fs_information_schema'
+"""
+)
 
 # replicates https://docs.snowflake.com/sql-reference/info-schema/views
 SQL_CREATE_INFORMATION_SCHEMA_VIEWS_VIEW = Template(
     """
-create view if not exists ${catalog}.information_schema._fs_views AS
+create view if not exists ${catalog}._fs_information_schema._fs_views AS
 select
     database_name as table_catalog,
     schema_name as table_schema,
@@ -120,24 +181,34 @@ select
     null::VARCHAR as comment
 from duckdb_views
 where database_name = '${catalog}'
-  and schema_name != 'information_schema'
+  and schema_name != '_fs_information_schema'
 """
 )
 
 
-def creation_sql(catalog: str) -> str:
+def per_db_creation_sql(catalog: str) -> str:
     return f"""
-        {SQL_CREATE_INFORMATION_SCHEMA_TABLES_EXT.substitute(catalog=catalog)};
-        {SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_EXT.substitute(catalog=catalog)};
+        {SQL_CREATE_FS_INFORMATION_SCHEMA.substitute(catalog=catalog)};
         {SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_VIEW.substitute(catalog=catalog)};
         {SQL_CREATE_INFORMATION_SCHEMA_DATABASES_VIEW.substitute(catalog=catalog)};
+        {SQL_CREATE_INFORMATION_SCHEMA_TABLES_VIEW.substitute(catalog=catalog)};
         {SQL_CREATE_INFORMATION_SCHEMA_VIEWS_VIEW.substitute(catalog=catalog)};
     """
 
 
+def fs_global_creation_sql(catalog: str) -> str:
+    return f"""
+        {SQL_CREATE_GLOBAL_FS_INFORMATION_SCHEMA};
+        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_TABLES_EXT};
+        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_EXT};
+        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_VIEW};
+        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE_EXT};
+    """
+
+
 def insert_table_comment_sql(catalog: str, schema: str, table: str, comment: str) -> str:
     return f"""
-        INSERT INTO {catalog}.information_schema._fs_tables_ext
+        INSERT INTO _fs_global._fs_information_schema._fs_tables_ext
         values ('{catalog}', '{schema}', '{table}', '{comment}')
         ON CONFLICT (ext_table_catalog, ext_table_schema, ext_table_name)
         DO UPDATE SET comment = excluded.comment
@@ -151,7 +222,7 @@ def insert_text_lengths_sql(catalog: str, schema: str, table: str, text_lengths:
     )
 
     return f"""
-        INSERT INTO {catalog}.information_schema._fs_columns_ext
+        INSERT INTO _fs_global._fs_information_schema._fs_columns_ext
         values {values}
         ON CONFLICT (ext_table_catalog, ext_table_schema, ext_table_name, ext_column_name)
         DO UPDATE SET ext_character_maximum_length = excluded.ext_character_maximum_length,

fakesnow/instance.py

@@ -6,51 +6,9 @@ from typing import Any
 import duckdb
 
 import fakesnow.fakes as fakes
+from fakesnow import info_schema
 
 GLOBAL_DATABASE_NAME = "_fs_global"
-USERS_TABLE_FQ_NAME = f"{GLOBAL_DATABASE_NAME}._fs_users_ext"
-
-# replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
-SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT = f"""
-create table if not exists {USERS_TABLE_FQ_NAME} (
-    name varchar,
-    created_on TIMESTAMPTZ,
-    login_name varchar,
-    display_name varchar,
-    first_name varchar,
-    last_name varchar,
-    email varchar,
-    mins_to_unlock varchar,
-    days_to_expiry varchar,
-    comment varchar,
-    disabled varchar,
-    must_change_password varchar,
-    snowflake_lock varchar,
-    default_warehouse varchar,
-    default_namespace varchar,
-    default_role varchar,
-    default_secondary_roles varchar,
-    ext_authn_duo varchar,
-    ext_authn_uid varchar,
-    mins_to_bypass_mfa varchar,
-    owner varchar,
-    last_success_login TIMESTAMPTZ,
-    expires_at_time TIMESTAMPTZ,
-    locked_until_time TIMESTAMPTZ,
-    has_password varchar,
-    has_rsa_public_key varchar,
-)
-"""
-
-
-def create_global_database(conn: duckdb.DuckDBPyConnection) -> None:
-    """Create a "global" database for storing objects which span databases.
-
-    Including (but not limited to):
-     - Users
-    """
-    conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
-    conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)
 
 
 class FakeSnow:
@@ -70,7 +28,8 @@ class FakeSnow:
 
         # create a "global" database for storing objects which span databases.
         self.duck_conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
-        self.duck_conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)
+        # create the info schema extensions
+        self.duck_conn.execute(info_schema.fs_global_creation_sql(GLOBAL_DATABASE_NAME))
 
     def connect(
         self, database: str | None = None, schema: str | None = None, **kwargs: Any

fakesnow/server.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import gzip
 import json
+import logging
 import secrets
 from base64 import b64encode
 from dataclasses import dataclass
@@ -19,6 +20,11 @@ from fakesnow.fakes import FakeSnowflakeConnection
 from fakesnow.instance import FakeSnow
 from fakesnow.rowtype import describe_as_rowtype
 
+logger = logging.getLogger("fakesnow.server")
+# use same format as uvicorn
+logger.handlers = logging.getLogger("uvicorn").handlers
+logger.setLevel(logging.INFO)
+
 shared_fs = FakeSnow()
 sessions: dict[str, FakeSnowflakeConnection] = {}
 
@@ -34,7 +40,9 @@ async def login_request(request: Request) -> JSONResponse:
     database = request.query_params.get("databaseName")
     schema = request.query_params.get("schemaName")
     body = await request.body()
-    body_json = json.loads(gzip.decompress(body))
+    if request.headers.get("Content-Encoding") == "gzip":
+        body = gzip.decompress(body)
+    body_json = json.loads(body)
     session_params: dict[str, Any] = body_json["data"]["SESSION_PARAMETERS"]
     if db_path := session_params.get("FAKESNOW_DB_PATH"):
         # isolated creates a new in-memory database, rather than using the shared in-memory database
@@ -44,22 +52,36 @@ async def login_request(request: Request) -> JSONResponse:
         # share the in-memory database across connections
         fs = shared_fs
     token = secrets.token_urlsafe(32)
+    logger.info(f"Session login {database=} {schema=}")
     sessions[token] = fs.connect(database, schema)
-    return JSONResponse({"data": {"token": token}, "success": True})
+    return JSONResponse(
+        {
+            "data": {
+                "token": token,
+                "parameters": [{"name": "AUTOCOMMIT", "value": True}],
+            },
+            "success": True,
+        }
+    )
 
 
 async def query_request(request: Request) -> JSONResponse:
     try:
-        conn = to_conn(request)
+        conn = to_conn(to_token(request))
 
         body = await request.body()
-        body_json = json.loads(gzip.decompress(body))
+        if request.headers.get("Content-Encoding") == "gzip":
+            body = gzip.decompress(body)
+
+        body_json = json.loads(body)
 
         sql_text = body_json["sqlText"]
 
         try:
             # only a single sql statement is sent at a time by the python snowflake connector
             cur = await run_in_threadpool(conn.cursor().execute, sql_text)
+            rowtype = describe_as_rowtype(cur._describe_last_sql())  # noqa: SLF001
+
         except snowflake.connector.errors.ProgrammingError as e:
             code = f"{e.errno:06d}"
             return JSONResponse(
@@ -73,8 +95,13 @@ async def query_request(request: Request) -> JSONResponse:
                     "success": False,
                 }
             )
-
-        rowtype = describe_as_rowtype(cur._describe_last_sql())  # noqa: SLF001
+        except Exception as e:
+            # we have a bug or use of an unsupported feature
+            msg = f"Unhandled error during query {sql_text=}"
+            logger.error(msg, exc_info=e)
+            # my guess at mimicking a 500 error as per https://docs.snowflake.com/en/developer-guide/sql-api/reference
+            # and https://github.com/snowflakedb/gosnowflake/blob/8ed4c75ffd707dd712ad843f40189843ace683c4/restful.go#L318
+            raise ServerError(status_code=500, code="261000", message=msg) from None
 
         if cur._arrow_table:  # noqa: SLF001
             batch_bytes = to_ipc(to_sf(cur._arrow_table, rowtype))  # noqa: SLF001
@@ -102,24 +129,46 @@ async def query_request(request: Request) -> JSONResponse:
         )
 
 
-def to_conn(request: Request) -> FakeSnowflakeConnection:
+def to_token(request: Request) -> str:
     if not (auth := request.headers.get("Authorization")):
-        raise ServerError(status_code=401, code="390103", message="Session token not found in the request data.")
+        raise ServerError(status_code=401, code="390101", message="Authorization header not found in the request data.")
+
+    return auth[17:-1]
 
-    token = auth[17:-1]
 
+def to_conn(token: str) -> FakeSnowflakeConnection:
     if not (conn := sessions.get(token)):
         raise ServerError(status_code=401, code="390104", message="User must login again to access the service.")
 
     return conn
 
 
+async def session(request: Request) -> JSONResponse:
+    try:
+        token = to_token(request)
+        _ = to_conn(token)
+
+        if bool(request.query_params.get("delete")):
+            del sessions[token]
+
+        return JSONResponse(
+            {"data": None, "code": None, "message": None, "success": True},
+        )
+
+    except ServerError as e:
+        return JSONResponse(
+            {"data": None, "code": e.code, "message": e.message, "success": False, "headers": None},
+            status_code=e.status_code,
+        )
+
+
 routes = [
     Route(
         "/session/v1/login-request",
         login_request,
         methods=["POST"],
     ),
+    Route("/session", session, methods=["POST"]),
     Route(
         "/queries/v1/query-request",
         query_request,

fakesnow/{transforms.py → transforms/__init__.py}

@@ -7,11 +7,65 @@ from typing import ClassVar, Literal, cast
 import sqlglot
 from sqlglot import exp
 
-from fakesnow import transforms_merge
-from fakesnow.instance import USERS_TABLE_FQ_NAME
+from fakesnow.transforms.merge import merge
 from fakesnow.variables import Variables
 
-MISSING_DATABASE = "missing_database"
+__all__ = [
+    "alias_in_join",
+    "alter_table_strip_cluster_by",
+    "array_agg",
+    "array_agg_within_group",
+    "array_size",
+    "create_clone",
+    "create_database",
+    "create_user",
+    "dateadd_date_cast",
+    "dateadd_string_literal_timestamp_cast",
+    "datediff_string_literal_timestamp_cast",
+    "drop_schema_cascade",
+    "extract_comment_on_columns",
+    "extract_comment_on_table",
+    "extract_text_length",
+    "flatten",
+    "flatten_value_cast_as_varchar",
+    "float_to_double",
+    "identifier",
+    "indices_to_json_extract",
+    "information_schema_databases",
+    "information_schema_fs_tables",
+    "information_schema_fs_views",
+    "integer_precision",
+    "json_extract_cased_as_varchar",
+    "json_extract_cast_as_varchar",
+    "json_extract_precedence",
+    "merge",
+    "object_construct",
+    "random",
+    "regex_replace",
+    "regex_substr",
+    "sample",
+    "semi_structured_types",
+    "set_schema",
+    "sha256",
+    "show_keys",
+    "show_objects_tables",
+    "show_schemas",
+    "show_users",
+    "split",
+    "tag",
+    "timestamp_ntz",
+    "to_date",
+    "to_decimal",
+    "to_timestamp",
+    "to_timestamp_ntz",
+    "trim_cast_varchar",
+    "try_parse_json",
+    "try_to_decimal",
+    "update_variables",
+    "upper_case_unquoted_identifiers",
+    "values_columns",
+]
+
 SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.' as status")
 
 
@@ -167,7 +221,7 @@ SELECT
     NULL::VARCHAR AS "comment",
     NULL::VARCHAR AS "policy name",
     NULL::JSON AS "privacy domain",
-FROM information_schema._fs_columns_snowflake
+FROM _fs_information_schema._fs_columns
 WHERE table_catalog = '${catalog}' AND table_schema = '${schema}' AND table_name = '${table}'
 ORDER BY ordinal_position
 """
@@ -188,7 +242,7 @@ SELECT
     NULL::VARCHAR AS "comment",
     NULL::VARCHAR AS "policy name",
     NULL::JSON AS "privacy domain",
-FROM (DESCRIBE information_schema.${view})
+FROM (DESCRIBE ${view})
 """
 )
 
@@ -196,7 +250,7 @@ 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_columns_snowflake to match snowflake.
+    """Redirect to the information_schema._fs_columns to match snowflake.
 
     See https://docs.snowflake.com/en/sql-reference/sql/desc-table
     """
@@ -211,9 +265,10 @@ def describe_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")
+        if schema and schema.upper() == "_FS_INFORMATION_SCHEMA":
+            # describing an information_schema view
+            # (schema already transformed from information_schema -> _fs_information_schema)
+            return sqlglot.parse_one(SQL_DESCRIBE_INFO_SCHEMA.substitute(view=f"{schema}.{table.name}"), read="duckdb")
 
         return sqlglot.parse_one(
             SQL_DESCRIBE_TABLE.substitute(catalog=catalog, schema=schema, table=table.name),
@@ -223,7 +278,7 @@ def describe_table(
     return expression
 
 
-def drop_schema_cascade(expression: exp.Expression) -> exp.Expression:
+def drop_schema_cascade(expression: exp.Expression) -> exp.Expression:  #
     """Drop schema cascade.
 
     By default duckdb won't delete a schema if it contains tables, whereas snowflake will.
@@ -595,8 +650,8 @@ def indices_to_json_extract(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def information_schema_fs_columns_snowflake(expression: exp.Expression) -> exp.Expression:
-    """Redirect to the information_schema._fs_columns_snowflake view which has metadata that matches snowflake.
+def information_schema_fs_columns(expression: exp.Expression) -> exp.Expression:
+    """Redirect to the _FS_COLUMNS view which has metadata that matches snowflake.
 
     Because duckdb doesn't store character_maximum_length or character_octet_length.
     """
@@ -608,45 +663,59 @@ def information_schema_fs_columns_snowflake(expression: exp.Expression) -> exp.E
         and expression.name
         and expression.name.upper() == "COLUMNS"
     ):
-        expression.set("this", exp.Identifier(this="_FS_COLUMNS_SNOWFLAKE", quoted=False))
+        expression.set("this", exp.Identifier(this="_FS_COLUMNS", quoted=False))
+        expression.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
 
     return expression
 
 
-def information_schema_fs_tables_ext(expression: exp.Expression) -> exp.Expression:
-    """Join to information_schema._fs_tables_ext to access additional metadata columns (eg: comment)."""
+def information_schema_databases(
+    expression: exp.Expression,
+    current_schema: str | None = None,
+) -> exp.Expression:
+    if (
+        isinstance(expression, exp.Table)
+        and (
+            expression.db.upper() == "INFORMATION_SCHEMA"
+            or (current_schema and current_schema.upper() == "INFORMATION_SCHEMA")
+        )
+        and expression.name.upper() == "DATABASES"
+    ):
+        return exp.Table(
+            this=exp.Identifier(this="DATABASES", quoted=False),
+            db=exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False),
+        )
+    return expression
+
+
+def information_schema_fs_tables(
+    expression: exp.Expression,
+) -> exp.Expression:
+    """Use _FS_TABLES to access additional metadata columns (eg: comment)."""
 
     if (
         isinstance(expression, exp.Select)
-        and (tbl_exp := expression.find(exp.Table))
-        and tbl_exp.name.upper() == "TABLES"
-        and tbl_exp.db.upper() == "INFORMATION_SCHEMA"
+        and (tbl := expression.find(exp.Table))
+        and tbl.db.upper() == "INFORMATION_SCHEMA"
+        and tbl.name.upper() == "TABLES"
     ):
-        return expression.join(
-            "information_schema._fs_tables_ext",
-            on=(
-                """
-                tables.table_catalog = _fs_tables_ext.ext_table_catalog AND
-                tables.table_schema = _fs_tables_ext.ext_table_schema AND
-                tables.table_name = _fs_tables_ext.ext_table_name
-                """
-            ),
-            join_type="left",
-        )
+        tbl.set("this", exp.Identifier(this="_FS_TABLES", quoted=False))
+        tbl.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
 
     return expression
 
 
 def information_schema_fs_views(expression: exp.Expression) -> exp.Expression:
-    """Use information_schema._fs_views to return Snowflake's version instead of duckdb's."""
+    """Use _FS_VIEWS to return Snowflake's version instead of duckdb's."""
 
     if (
         isinstance(expression, exp.Select)
-        and (tbl_exp := expression.find(exp.Table))
-        and tbl_exp.name.upper() == "VIEWS"
-        and tbl_exp.db.upper() == "INFORMATION_SCHEMA"
+        and (tbl := expression.find(exp.Table))
+        and tbl.db.upper() == "INFORMATION_SCHEMA"
+        and tbl.name.upper() == "VIEWS"
     ):
-        tbl_exp.set("this", exp.Identifier(this="_FS_VIEWS", quoted=False))
+        tbl.set("this", exp.Identifier(this="_FS_VIEWS", quoted=False))
+        tbl.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
 
     return expression
 
@@ -720,10 +789,6 @@ def json_extract_precedence(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def merge(expression: exp.Expression) -> list[exp.Expression]:
-    return transforms_merge.merge(expression)
-
-
 def random(expression: exp.Expression) -> exp.Expression:
     """Convert random() and random(seed).
 
@@ -921,7 +986,10 @@ def set_schema(expression: exp.Expression, current_database: str | None) -> exp.
                 db_name = db.name
             else:
                 # isn't qualified with a database
-                db_name = current_database or MISSING_DATABASE
+                db_name = current_database
+
+            # assertion always true because check_db_schema is called before this
+            assert db_name
 
             schema = expression.this.name
             return exp.Command(
@@ -960,7 +1028,7 @@ def show_objects_tables(expression: exp.Expression, current_database: str | 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_%%')"
+    exclude_fakesnow_tables = "not (table_schema == '_fs_information_schema')"
     # 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 ""
@@ -991,12 +1059,16 @@ def show_objects_tables(expression: exp.Expression, current_database: str | None
 SQL_SHOW_SCHEMAS = """
 select
     to_timestamp(0)::timestamptz as 'created_on',
-    schema_name as 'name',
+    case
+        when schema_name = '_fs_information_schema' then 'information_schema'
+        else schema_name
+    end as 'name',
     NULL as 'kind',
     catalog_name as 'database_name',
     NULL as 'schema_name'
 from information_schema.schemata
-where catalog_name not in ('memory', 'system', 'temp') and schema_name not in ('main', 'pg_catalog')
+where not catalog_name in ('memory', 'system', 'temp', '_fs_global')
+  and not schema_name in ('main', 'pg_catalog')
 """
 
 
@@ -1018,6 +1090,113 @@ def show_schemas(expression: exp.Expression, current_database: str | None = None
     return expression
 
 
+SQL_SHOW_DATABASES = """
+SELECT
+    to_timestamp(0)::timestamptz as 'created_on',
+    database_name as 'name',
+    'N' as 'is_default',
+    'N' as 'is_current',
+    '' as 'origin',
+    'SYSADMIN' as 'owner',
+    comment,
+    '' as 'options',
+    1 as 'retention_time',
+    'STANDARD' as 'kind',
+    NULL as 'budget',
+    'ROLE' as 'owner_role_type',
+    NULL as 'object_visibility'
+FROM duckdb_databases
+WHERE database_name NOT IN ('memory', '_fs_global')
+"""
+
+
+def show_databases(expression: exp.Expression) -> exp.Expression:
+    """Transform SHOW DATABASES to a query against the information_schema.schemata table.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/show-databases
+    """
+    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "DATABASES":
+        return sqlglot.parse_one(SQL_SHOW_DATABASES, read="duckdb")
+
+    return expression
+
+
+# returns zero rows
+SQL_SHOW_FUNCTIONS = """
+SELECT
+    '1970-01-01 00:00:00 UTC'::timestamptz as created_on,
+    'SYSTIMESTAMP' as name,
+    '' as schema_name,
+    'Y' as is_builtin,
+    'N' as is_aggregate,
+    'N' as is_ansi,
+    0 as min_num_arguments,
+    0 as max_num_arguments,
+    'SYSTIMESTAMP() RETURN TIMESTAMP_LTZ' as arguments,
+    'Returns the current timestamp' as description,
+    '' as catalog_name,
+    'N' as is_table_function,
+    'N' as valid_for_clustering,
+    NULL as is_secure,
+    '' as secrets,
+    '' as external_access_integrations,
+    'N' as is_external_function,
+    'SQL' as language,
+    'N' as is_memoizable,
+    'N' as is_data_metric
+WHERE 0 = 1;
+"""
+
+
+def show_functions(expression: exp.Expression) -> exp.Expression:
+    """Transform SHOW FUNCTIONS.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/show-functions
+    """
+    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "FUNCTIONS":
+        return sqlglot.parse_one(SQL_SHOW_FUNCTIONS, read="duckdb")
+
+    return expression
+
+
+# returns zero rows
+SQL_SHOW_PROCEDURES = """
+SELECT
+    '2012-08-01 07:00:00 UTC'::timestamptz as 'created_on',
+    'SYSTEM$CLASSIFY' as 'name',
+    '' as 'schema_name',
+    'Y' as 'is_builtin',
+    'N' as 'is_aggregate',
+    'N' as 'is_ansi',
+    2 as 'min_num_arguments',
+    2 as 'max_num_arguments',
+    'SYSTEM$CLASSIFY(VARCHAR, OBJECT) RETURN OBJECT' as 'arguments',
+    'classify stored proc' as 'description',
+    '' as 'catalog_name',
+    'N' as 'is_table_function',
+    'N' as 'valid_for_clustering',
+    NULL as 'is_secure',
+    '' as 'secrets',
+    '' as 'external_access_integrations',
+WHERE 0 = 1;
+"""
+
+
+def show_procedures(expression: exp.Expression) -> exp.Expression:
+    """Transform SHOW PROCEDURES.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/show-procedures
+    """
+    if (
+        isinstance(expression, exp.Show)
+        and isinstance(expression.this, str)
+        and expression.this.upper() == "PROCEDURES"
+    ):
+        return sqlglot.parse_one(SQL_SHOW_PROCEDURES, read="duckdb")
+
+    return expression
+
+
 def split(expression: exp.Expression) -> exp.Expression:
     """
     Convert output of duckdb str_split from varchar[] to JSON array to match Snowflake.
@@ -1364,7 +1543,7 @@ def show_users(expression: exp.Expression) -> exp.Expression:
     https://docs.snowflake.com/en/sql-reference/sql/show-users
     """
     if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "USERS":
-        return sqlglot.parse_one(f"SELECT * FROM {USERS_TABLE_FQ_NAME}", read="duckdb")
+        return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users_ext", read="duckdb")
 
     return expression
 
@@ -1382,7 +1561,9 @@ def create_user(expression: exp.Expression) -> exp.Expression:
             _, name, *ignored = sub_exp.split(" ")
             if ignored:
                 raise NotImplementedError(f"`CREATE USER` with {ignored} not yet supported")
-            return sqlglot.parse_one(f"INSERT INTO {USERS_TABLE_FQ_NAME} (name) VALUES ('{name}')", read="duckdb")
+            return sqlglot.parse_one(
+                f"INSERT INTO _fs_global._fs_information_schema._fs_users_ext (name) VALUES ('{name}')", read="duckdb"
+            )
 
     return expression
 

{fakesnow-0.9.28.dist-info → fakesnow-0.9.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fakesnow
-Version: 0.9.28
+Version: 0.9.30
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -210,10 +210,10 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: duckdb~=1.1.3
+Requires-Dist: duckdb~=1.2.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=26.3.9
+Requires-Dist: sqlglot~=26.10.1
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: dirty-equals; extra == "dev"
@@ -223,7 +223,7 @@ Requires-Dist: pre-commit~=4.0; extra == "dev"
 Requires-Dist: pyarrow-stubs==10.0.1.9; extra == "dev"
 Requires-Dist: pytest~=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
-Requires-Dist: ruff~=0.9.4; extra == "dev"
+Requires-Dist: ruff~=0.11.0; extra == "dev"
 Requires-Dist: twine~=6.0; extra == "dev"
 Requires-Dist: snowflake-sqlalchemy~=1.7.0; extra == "dev"
 Provides-Extra: notebook

fakesnow-0.9.30.dist-info/RECORD

@@ -0,0 +1,26 @@
+fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
+fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
+fakesnow/arrow.py,sha256=MwatkdZX5AFADzXvxhBFmcRJVxbW4D39VoqLyhpTbl0,5057
+fakesnow/checks.py,sha256=be-xo0oMoAUVhlMDCu1_Rkoh_L8p_p8qo9P6reJSHIQ,2874
+fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
+fakesnow/conn.py,sha256=HGhFKErKWvAfVEy3QSc0tfNmzGh_T7FtvRfWuDBy_CQ,5744
+fakesnow/cursor.py,sha256=KP8aDhq_m10ibpLjiL4retcwUCh_8PsY5sZfEFY_3No,20970
+fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
+fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
+fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
+fakesnow/info_schema.py,sha256=xDhGy07fpc8bcy_VTfh54UzwNIaB4ZhGmjgJeoiZ0hQ,8744
+fakesnow/instance.py,sha256=vbg4XiAjpdglEqOM7X_HvCOnE-6Bf67nTYeBfGVUSNU,1889
+fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
+fakesnow/pandas_tools.py,sha256=wI203UQHC8JvDzxE_VjE1NeV4rThek2P-u52oTg2foo,3481
+fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
+fakesnow/rowtype.py,sha256=QUp8EaXD5LT0Xv8BXk5ze4WseEn52xoJ6R05pJjs5mM,2729
+fakesnow/server.py,sha256=-jKyEVuD2TEr88jUSA1Lu86MAymel7LQAiNlytHqhTg,5934
+fakesnow/variables.py,sha256=WXyPnkeNwD08gy52yF66CVe2twiYC50tztNfgXV4q1k,3032
+fakesnow/transforms/__init__.py,sha256=ENBHnwfQHAlC9PWOq4tdz-9-YQGy2E48xJB5ce7qEA0,60345
+fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
+fakesnow-0.9.30.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.30.dist-info/METADATA,sha256=ryFSnkBU9Vb4BrYI9g9q16zN4M2env6w8-syT7LbJ1k,18109
+fakesnow-0.9.30.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+fakesnow-0.9.30.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.30.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
+fakesnow-0.9.30.dist-info/RECORD,,

{fakesnow-0.9.28.dist-info → fakesnow-0.9.30.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

fakesnow-0.9.28.dist-info/RECORD

@@ -1,26 +0,0 @@
-fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
-fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
-fakesnow/arrow.py,sha256=MwatkdZX5AFADzXvxhBFmcRJVxbW4D39VoqLyhpTbl0,5057
-fakesnow/checks.py,sha256=N8sXldhS3u1gG32qvZ4VFlsKgavRKrQrxLiQU8am1lw,2691
-fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
-fakesnow/conn.py,sha256=GJ7Y2dBW2jcOCIZ0gTYS0F8OmeoD7aW6lTWHpm02hbE,5459
-fakesnow/cursor.py,sha256=uYf3zshauWXnKdUoVEE3YxMbc-SoVLHCUUkqwtMW8ns,20228
-fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
-fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
-fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
-fakesnow/info_schema.py,sha256=FyDcajHU0BK0Yx6JTIkWFoM0PPFm6f6Pf0B2NHLNR0M,6310
-fakesnow/instance.py,sha256=3cJvPRuFy19dMKXbtBLl6imzO48pEw8uTYhZyFDuwhk,3133
-fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
-fakesnow/pandas_tools.py,sha256=wI203UQHC8JvDzxE_VjE1NeV4rThek2P-u52oTg2foo,3481
-fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
-fakesnow/rowtype.py,sha256=QUp8EaXD5LT0Xv8BXk5ze4WseEn52xoJ6R05pJjs5mM,2729
-fakesnow/server.py,sha256=lrXk8iXioSl-qWweXLH7l6aPrcV4Bym9rjB6x_C5Fg8,4222
-fakesnow/transforms.py,sha256=pSv3pQlD1Y8tzXQ1rft2g5wYLcHrDRoy5EkFWgqkmec,55453
-fakesnow/transforms_merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
-fakesnow/variables.py,sha256=WXyPnkeNwD08gy52yF66CVe2twiYC50tztNfgXV4q1k,3032
-fakesnow-0.9.28.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
-fakesnow-0.9.28.dist-info/METADATA,sha256=t0B6J7rG5uyS2430rgPWieQgACfyUU9dIL5cUdYllDg,18107
-fakesnow-0.9.28.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-fakesnow-0.9.28.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.28.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
-fakesnow-0.9.28.dist-info/RECORD,,