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

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
@@ -69,24 +71,24 @@ class FakeSnowflakeConnection:
         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)
@@ -163,7 +183,8 @@ class FakeSnowflakeCursor:
             .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_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)
@@ -228,21 +249,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")):
@@ -278,7 +284,7 @@ class FakeSnowflakeCursor:
             self._conn.database_set = True
 
         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
 
         elif create_db_name := transformed.args.get("create_db_name"):
@@ -328,10 +334,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,11 @@ from __future__ import annotations
 
 from string import Template
 
+from fakesnow.instance import GLOBAL_DATABASE_NAME
+
 # 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_INFORMATION_SCHEMA_TABLES_EXT = f"""
+create table if not exists {GLOBAL_DATABASE_NAME}.main._fs_tables_ext (
     ext_table_catalog varchar,
     ext_table_schema varchar,
     ext_table_name varchar,
@@ -15,11 +16,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_INFORMATION_SCHEMA_COLUMNS_EXT = f"""
+create table if not exists {GLOBAL_DATABASE_NAME}.main._fs_columns_ext (
     ext_table_catalog varchar,
     ext_table_schema varchar,
     ext_table_name varchar,
@@ -29,13 +29,19 @@ 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)
 )
 """
+
+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_snowflake AS
 select
     columns.table_catalog AS table_catalog,
     columns.table_schema AS table_schema,
@@ -64,8 +70,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.main._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,6 +81,8 @@ 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 database_name = '${catalog}'
+  and schema_name != '_fs_information_schema'
 """
 )
 
@@ -82,7 +90,7 @@ LEFT JOIN duckdb_columns ddb_columns
 # 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 +100,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.main._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 +142,31 @@ 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:
     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_INFORMATION_SCHEMA_TABLES_EXT};
+        {SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_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 {GLOBAL_DATABASE_NAME}.main._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 +180,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 {GLOBAL_DATABASE_NAME}.main._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,6 +6,7 @@ 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"
@@ -71,6 +72,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

@@ -34,7 +34,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
@@ -53,7 +55,10 @@ async def query_request(request: Request) -> JSONResponse:
         conn = to_conn(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"]
 

fakesnow/transforms.py

@@ -11,7 +11,6 @@ from fakesnow import transforms_merge
 from fakesnow.instance import USERS_TABLE_FQ_NAME
 from fakesnow.variables import Variables
 
-MISSING_DATABASE = "missing_database"
 SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.' as status")
 
 
@@ -167,7 +166,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_snowflake
 WHERE table_catalog = '${catalog}' AND table_schema = '${schema}' AND table_name = '${table}'
 ORDER BY ordinal_position
 """
@@ -188,7 +187,7 @@ SELECT
     NULL::VARCHAR AS "comment",
     NULL::VARCHAR AS "policy name",
     NULL::JSON AS "privacy domain",
-FROM (DESCRIBE information_schema.${view})
+FROM (DESCRIBE ${view})
 """
 )
 
@@ -211,9 +210,17 @@ def describe_table(
         catalog = table.catalog or current_database
         schema = table.db or current_schema
 
+        # TODO - move this after information_schema_fs_columns_snowflake
         if schema and schema.upper() == "INFORMATION_SCHEMA":
             # information schema views don't exist in _fs_columns_snowflake
-            return sqlglot.parse_one(SQL_DESCRIBE_INFO_SCHEMA.substitute(view=table.name), read="duckdb")
+            return sqlglot.parse_one(
+                SQL_DESCRIBE_INFO_SCHEMA.substitute(view=f"system.information_schema.{table.name}"), read="duckdb"
+            )
+        elif table.name.upper() == "_FS_COLUMNS_SNOWFLAKE":
+            # information schema views don't exist in _fs_columns_snowflake
+            return sqlglot.parse_one(
+                SQL_DESCRIBE_INFO_SCHEMA.substitute(view="_fs_information_schema._FS_COLUMNS_SNOWFLAKE"), read="duckdb"
+            )
 
         return sqlglot.parse_one(
             SQL_DESCRIBE_TABLE.substitute(catalog=catalog, schema=schema, table=table.name),
@@ -596,7 +603,7 @@ def indices_to_json_extract(expression: exp.Expression) -> exp.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.
+    """Redirect to the _FS_COLUMNS_SNOWFLAKE view which has metadata that matches snowflake.
 
     Because duckdb doesn't store character_maximum_length or character_octet_length.
     """
@@ -609,44 +616,58 @@ def information_schema_fs_columns_snowflake(expression: exp.Expression) -> exp.E
         and expression.name.upper() == "COLUMNS"
     ):
         expression.set("this", exp.Identifier(this="_FS_COLUMNS_SNOWFLAKE", 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
 
@@ -921,7 +942,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 +984,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 +1015,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')
+  and not schema_name in ('main', 'pg_catalog')
 """
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fakesnow
-Version: 0.9.28
+Version: 0.9.29
 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.6.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: dirty-equals; extra == "dev"

{fakesnow-0.9.28.dist-info → fakesnow-0.9.29.dist-info}/RECORD

@@ -3,24 +3,24 @@ 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/conn.py,sha256=da9ln_covsyKgdNdPXLzMTUBr72P0rRGadIDVt-kaeI,5737
+fakesnow/cursor.py,sha256=1BP1rZ28JfIfJkIR_8yEFDq2FrUf93JFrrYLJoKJr14,20587
 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/info_schema.py,sha256=_4YWnpuOFuyACr9k4iYdf2vLN7GDMG8X_pEBlC-8OmM,7269
+fakesnow/instance.py,sha256=7xHJv-5-KKAI3Qm7blcvkXgkGg7WYtXEm3nUS4jLyFs,3299
 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/server.py,sha256=VpM-ZjFS4JekLESEoQTndvXqnqz8bH4ZO8lq_66-c6s,4387
+fakesnow/transforms.py,sha256=dAoFFRFkJG8kcQdBPnE5w2eed4AZkh4NV3ajx1vu3A8,56444
 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,,
+fakesnow-0.9.29.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.29.dist-info/METADATA,sha256=sx4qqMsuxOaaDMKR5U8A4ZT0djn9wHSrOUjCqthUoWQ,18107
+fakesnow-0.9.29.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+fakesnow-0.9.29.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.29.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
+fakesnow-0.9.29.dist-info/RECORD,,