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

fakesnow/arrow.py

@@ -62,7 +62,7 @@ def to_ipc(table: pa.Table) -> pa.Buffer:
 
 
 def to_sf(table: pa.Table, rowtype: list[ColumnInfo]) -> pa.Table:
-    def to_sf_col(col: pa.Array) -> pa.Array:
+    def to_sf_col(col: pa.ChunkedArray) -> pa.Array | pa.ChunkedArray:
         if pa.types.is_timestamp(col.type):
             return timestamp_to_sf_struct(col)
         elif pa.types.is_time(col.type):
@@ -83,7 +83,7 @@ def timestamp_to_sf_struct(ts: pa.Array | pa.ChunkedArray) -> pa.Array:
 
     # Round to seconds, ie: strip subseconds
     tsa_without_us = pc.floor_temporal(ts, unit="second")  # type: ignore https://github.com/zen-xu/pyarrow-stubs/issues/45
-    epoch = pc.divide(tsa_without_us.cast(pa.int64()), 1_000_000)  # type: ignore https://github.com/zen-xu/pyarrow-stubs/issues/44
+    epoch = pc.divide(tsa_without_us.cast(pa.int64()), 1_000_000)
 
     # Calculate fractional part as nanoseconds
     fraction = pc.multiply(pc.subsecond(ts), 1_000_000_000).cast(pa.int32())  # type: ignore
@@ -93,7 +93,7 @@ def timestamp_to_sf_struct(ts: pa.Array | pa.ChunkedArray) -> pa.Array:
         timezone = pa.array([1440] * len(ts), type=pa.int32())
 
         return pa.StructArray.from_arrays(
-            arrays=[epoch, fraction, timezone],  # type: ignore https://github.com/zen-xu/pyarrow-stubs/issues/42
+            arrays=[epoch, fraction, timezone],
             fields=[
                 pa.field("epoch", nullable=False, type=pa.int64()),
                 pa.field("fraction", nullable=False, type=pa.int32()),
@@ -102,7 +102,7 @@ def timestamp_to_sf_struct(ts: pa.Array | pa.ChunkedArray) -> pa.Array:
         )
     else:
         return pa.StructArray.from_arrays(
-            arrays=[epoch, fraction],  # type: ignore https://github.com/zen-xu/pyarrow-stubs/issues/42
+            arrays=[epoch, fraction],
             fields=[
                 pa.field("epoch", nullable=False, type=pa.int64()),
                 pa.field("fraction", nullable=False, type=pa.int32()),

fakesnow/conn.py

@@ -62,7 +62,16 @@ class FakeSnowflakeConnection:
                 where upper(catalog_name) = '{self.database}'"""
             ).fetchone()
         ):
-            db_file = f"{self.db_path / self.database}.db" if self.db_path else ":memory:"
+            if self.db_path:
+                # raise a helpful error message when directory doesn't exist so users don't think
+                # they have to create the database themselves
+                if not os.path.isdir(self.db_path):
+                    raise NotADirectoryError(f"No such directory: '{self.db_path}'. Please ensure db_path exists.")
+                db_file = f"{self.db_path / self.database}.db"
+            else:
+                db_file = ":memory:"
+
+            # creates db file if it doesn't exist
             duck_conn.execute(f"ATTACH DATABASE '{db_file}' AS {self.database}")
             duck_conn.execute(info_schema.per_db_creation_sql(self.database))
             duck_conn.execute(macros.creation_sql(self.database))
@@ -102,9 +111,6 @@ class FakeSnowflakeConnection:
             duck_conn.execute(f"SET schema='{self.database}.main'")
             self.database_set = True
 
-        # use UTC instead of local time zone for consistent testing
-        duck_conn.execute("SET GLOBAL TimeZone = 'UTC'")
-
     def __enter__(self) -> Self:
         return self
 

fakesnow/cursor.py

@@ -14,6 +14,7 @@ import pyarrow  # needed by fetch_arrow_table()
 import snowflake.connector.converter
 import snowflake.connector.errors
 import sqlglot
+import sqlglot.errors
 from duckdb import DuckDBPyConnection
 from snowflake.connector.cursor import ResultMetadata
 from snowflake.connector.result_batch import ResultBatch
@@ -155,6 +156,11 @@ class FakeSnowflakeCursor:
         except snowflake.connector.errors.ProgrammingError as e:
             self._sqlstate = e.sqlstate
             raise e
+        except sqlglot.errors.ParseError as e:
+            self._sqlstate = "42000"
+            # strip highlight for better readability, TODO: show pointer to start of error
+            msg = str(e).replace("\x1b[4m", "").replace("\x1b[0m", "")
+            raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=1003, sqlstate="42000") from None
 
     def check_db_and_schema(self, expression: exp.Expression) -> None:
         no_database, no_schema = checks.is_unqualified_table_expression(expression)
@@ -225,8 +231,10 @@ class FakeSnowflakeCursor:
             .transform(transforms.show_databases)
             .transform(transforms.show_functions)
             .transform(transforms.show_procedures)
+            .transform(transforms.show_warehouses)
             .transform(lambda e: transforms.show_schemas(e, self._conn.database))
             .transform(lambda e: transforms.show_objects_tables(e, self._conn.database))
+            .transform(lambda e: transforms.show_columns(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"))
@@ -254,6 +262,9 @@ class FakeSnowflakeCursor:
 
         sql = transformed.sql(dialect="duckdb")
 
+        if not sql:
+            raise NotImplementedError(transformed.sql(dialect="snowflake"))
+
         if transformed.find(exp.Select) and (seed := transformed.args.get("seed")):
             sql = f"SELECT setseed({seed}); {sql}"
 
@@ -287,6 +298,7 @@ class FakeSnowflakeCursor:
         if set_database := transformed.args.get("set_database"):
             self._conn.database = set_database
             self._conn.database_set = True
+            self._conn.schema_set = False
             result_sql = SQL_SUCCESS
 
         elif set_schema := transformed.args.get("set_schema"):

fakesnow/instance.py

@@ -31,6 +31,9 @@ class FakeSnow:
         # create the info schema extensions
         self.duck_conn.execute(info_schema.fs_global_creation_sql(GLOBAL_DATABASE_NAME))
 
+        # use UTC instead of local time zone for consistent testing
+        self.duck_conn.execute("SET GLOBAL TimeZone = 'UTC'")
+
     def connect(
         self, database: str | None = None, schema: str | None = None, **kwargs: Any
     ) -> fakes.FakeSnowflakeConnection:

fakesnow/server.py

@@ -83,6 +83,7 @@ async def query_request(request: Request) -> JSONResponse:
             rowtype = describe_as_rowtype(cur._describe_last_sql())  # noqa: SLF001
 
         except snowflake.connector.errors.ProgrammingError as e:
+            logger.info(f"{sql_text=} ProgrammingError {e}")
             code = f"{e.errno:06d}"
             return JSONResponse(
                 {
@@ -97,7 +98,7 @@ async def query_request(request: Request) -> JSONResponse:
             )
         except Exception as e:
             # we have a bug or use of an unsupported feature
-            msg = f"Unhandled error during query {sql_text=}"
+            msg = f"{sql_text=} Unhandled exception"
             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

fakesnow/transforms/__init__.py

@@ -2,70 +2,25 @@ from __future__ import annotations
 
 from pathlib import Path
 from string import Template
-from typing import ClassVar, Literal, cast
+from typing import ClassVar, cast
 
 import sqlglot
 from sqlglot import exp
 
-from fakesnow.transforms.merge import merge
+from fakesnow.transforms.merge import merge as merge
+from fakesnow.transforms.show import (
+    show_columns as show_columns,
+    show_databases as show_databases,
+    show_functions as show_functions,
+    show_keys as show_keys,
+    show_objects_tables as show_objects_tables,
+    show_procedures as show_procedures,
+    show_schemas as show_schemas,
+    show_users as show_users,
+    show_warehouses as show_warehouses,
+)
 from fakesnow.variables import Variables
 
-__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")
 
 
@@ -621,7 +576,7 @@ def identifier(expression: exp.Expression) -> exp.Expression:
 
 
 def indices_to_json_extract(expression: exp.Expression) -> exp.Expression:
-    """Convert indices on objects and arrays to json_extract.
+    """Convert indices on objects and arrays to json_extract or json_extract_string
 
     Supports Snowflake array indices, see
     https://docs.snowflake.com/en/sql-reference/data-types-semistructured#accessing-elements-of-an-array-by-index-or-by-slice
@@ -640,12 +595,16 @@ def indices_to_json_extract(expression: exp.Expression) -> exp.Expression:
         and isinstance(index, exp.Literal)
         and index.this
     ):
+        if isinstance(expression.parent, exp.Cast) and expression.parent.to.this == exp.DataType.Type.VARCHAR:
+            # If the parent is a cast to varchar, we need to use JSONExtractScalar
+            # to get the unquoted string value.
+            klass = exp.JSONExtractScalar
+        else:
+            klass = exp.JSONExtract
         if index.is_string:
-            return exp.JSONExtract(this=expression.this, expression=exp.Literal(this=f"$.{index.this}", is_string=True))
+            return klass(this=expression.this, expression=exp.Literal(this=f"$.{index.this}", is_string=True))
         else:
-            return exp.JSONExtract(
-                this=expression.this, expression=exp.Literal(this=f"$[{index.this}]", is_string=True)
-            )
+            return klass(this=expression.this, expression=exp.Literal(this=f"$[{index.this}]", is_string=True))
 
     return expression
 
@@ -720,15 +679,21 @@ def information_schema_fs_views(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+NUMBER_38_0 = [
+    exp.DataTypeParam(this=exp.Literal(this="38", is_string=False)),
+    exp.DataTypeParam(this=exp.Literal(this="0", is_string=False)),
+]
+
+
 def integer_precision(expression: exp.Expression) -> exp.Expression:
-    """Convert integers to bigint.
+    """Convert integers and number(38,0) to bigint.
 
-    So dataframes will return them with a dtype of int64.
+    So fetch_all will return int and dataframes will return them with a dtype of int64.
     """
-
     if (
         isinstance(expression, exp.DataType)
-        and (expression.this == exp.DataType.Type.DECIMAL and not expression.expressions)
+        and expression.this == exp.DataType.Type.DECIMAL
+        and (not expression.expressions or expression.expressions == NUMBER_38_0)
     ) or expression.this in (exp.DataType.Type.INT, exp.DataType.Type.SMALLINT, exp.DataType.Type.TINYINT):
         return exp.DataType(
             this=exp.DataType.Type.BIGINT,
@@ -836,29 +801,29 @@ def object_construct(expression: exp.Expression) -> exp.Expression:
     See https://docs.snowflake.com/en/sql-reference/functions/object_construct
     """
 
-    if isinstance(expression, exp.Struct):
-        non_null_expressions = []
-        for e in expression.expressions:
-            if not (isinstance(e, exp.PropertyEQ)):
-                non_null_expressions.append(e)
-                continue
+    if not isinstance(expression, exp.Struct):
+        return expression
 
-            left = e.left
-            right = e.right
+    non_null_expressions = []
+    for e in expression.expressions:
+        if not (isinstance(e, exp.PropertyEQ)):
+            non_null_expressions.append(e)
+            continue
 
-            left_is_null = isinstance(left, exp.Null)
-            right_is_null = isinstance(right, exp.Null)
+        left = e.left
+        right = e.right
 
-            if left_is_null or right_is_null:
-                continue
+        left_is_null = isinstance(left, exp.Null)
+        right_is_null = isinstance(right, exp.Null)
 
-            non_null_expressions.append(e)
+        if left_is_null or right_is_null:
+            continue
 
-        new_struct = expression.copy()
-        new_struct.set("expressions", non_null_expressions)
-        return exp.Anonymous(this="TO_JSON", expressions=[new_struct])
+        non_null_expressions.append(e)
 
-    return expression
+    new_struct = expression.copy()
+    new_struct.set("expressions", non_null_expressions)
+    return exp.Anonymous(this="TO_JSON", expressions=[new_struct])
 
 
 def regex_replace(expression: exp.Expression) -> exp.Expression:
@@ -999,204 +964,6 @@ def set_schema(expression: exp.Expression, current_database: str | None) -> exp.
     return expression
 
 
-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 not (
-        isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and (show := expression.this.upper())
-        and show in {"OBJECTS", "TABLES"}
-    ):
-        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 == '_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 ""
-    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 = """
-select
-    to_timestamp(0)::timestamptz as 'created_on',
-    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 not catalog_name in ('memory', 'system', 'temp', '_fs_global')
-  and not schema_name in ('main', 'pg_catalog')
-"""
-
-
-def show_schemas(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
-    """Transform SHOW SCHEMAS to a query against the information_schema.schemata table.
-
-    See https://docs.snowflake.com/en/sql-reference/sql/show-schemas
-    """
-    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "SCHEMAS":
-        if (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
-            database = ident.this
-        else:
-            database = current_database
-
-        return sqlglot.parse_one(
-            f"{SQL_SHOW_SCHEMAS} and catalog_name = '{database}'" if database else SQL_SHOW_SCHEMAS, read="duckdb"
-        )
-
-    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.
@@ -1296,8 +1063,6 @@ def _get_to_number_args(e: exp.ToNumber) -> tuple[exp.Expression | None, exp.Exp
                 # to_number('100', 'TM9', 10, 2)
                 if arg_scale:
                     _scale = arg_scale
-            else:
-                pass
         else:
             # to_number('100', 10, ...)
             # arg_format is not a string, so it must be precision.
@@ -1307,12 +1072,10 @@ def _get_to_number_args(e: exp.ToNumber) -> tuple[exp.Expression | None, exp.Exp
             # And arg_precision must be scale
             if arg_precision:
                 _scale = arg_precision
-    else:
-        # If format is not provided, just check for precision and scale directly
-        if arg_precision:
-            _precision = arg_precision
-            if arg_scale:
-                _scale = arg_scale
+    elif arg_precision:
+        _precision = arg_precision
+        if arg_scale:
+            _scale = arg_scale
 
     return _format, _precision, _scale
 
@@ -1537,17 +1300,6 @@ def values_columns(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def show_users(expression: exp.Expression) -> exp.Expression:
-    """Transform SHOW USERS to a query against the global database's information_schema._fs_users table.
-
-    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("SELECT * FROM _fs_global._fs_information_schema._fs_users_ext", read="duckdb")
-
-    return expression
-
-
 def create_user(expression: exp.Expression) -> exp.Expression:
     """Transform CREATE USER to a query against the global database's information_schema._fs_users table.
 
@@ -1568,94 +1320,6 @@ def create_user(expression: exp.Expression) -> exp.Expression:
     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}' "
-            elif scope_kind == "TABLE":
-                if not table:
-                    raise ValueError(f"SHOW PRIMARY KEYS with {scope_kind} scope requires a table")
-
-                statement += f"AND table_name = '{table.name}' "
-            else:
-                raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind} not yet supported")
-        return sqlglot.parse_one(statement)
-    return expression
-
-
 def update_variables(
     expression: exp.Expression,
     variables: Variables,

fakesnow/transforms/show.py

@@ -0,0 +1,476 @@
+from __future__ import annotations
+
+from typing import Literal
+
+import sqlglot
+from sqlglot import exp
+
+
+def show_columns(
+    expression: exp.Expression, current_database: str | None = None, current_schema: str | None = None
+) -> exp.Expression:
+    """Transform SHOW COLUMNS to a query against the fs global information_schema columns table.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/show-columns
+    """
+    if not (
+        isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "COLUMNS"
+    ):
+        return expression
+
+    scope_kind = expression.args.get("scope_kind")
+    table = expression.find(exp.Table)
+
+    if scope_kind == "ACCOUNT" or not scope_kind:
+        # all columns
+        catalog = None
+        schema = None
+        table = None
+    elif scope_kind == "DATABASE" and table:
+        catalog = table.name
+        schema = None
+        table = None
+    elif scope_kind == "SCHEMA" and table:
+        catalog = table.db or current_database
+        schema = table.name
+        table = None
+    elif scope_kind in ("TABLE", "VIEW") and table:
+        catalog = table.catalog or current_database
+        schema = table.db or current_schema
+        table = table.name
+    else:
+        raise NotImplementedError(f"show_object_columns: {expression.sql(dialect='snowflake')}")
+
+    query = f"""
+    SELECT
+        table_name,
+        table_schema as "schema_name",
+        column_name,
+        CASE
+            WHEN data_type = 'NUMBER' THEN '{{"type":"FIXED","precision":'|| numeric_precision || ',"scale":' || numeric_scale || ',"nullable":true}}'
+            WHEN data_type = 'TEXT' THEN '{{"type":"TEXT","length":' || coalesce(character_maximum_length,16777216)  || ',"byteLength":' || CASE WHEN character_maximum_length = 16777216 THEN 16777216 ELSE coalesce(character_maximum_length*4,16777216) END  || ',"nullable":true,"fixed":false}}'
+            WHEN data_type in ('TIMESTAMP_NTZ','TIMESTAMP_TZ','TIME') THEN '{{"type":"' || data_type || '","precision":0,"scale":9,"nullable":true}}'
+            WHEN data_type = 'FLOAT' THEN '{{"type":"REAL","nullable":true}}'
+            WHEN data_type = 'BINARY' THEN '{{"type":"BINARY","length":8388608,"byteLength":8388608,"nullable":true,"fixed":true}}'
+            ELSE '{{"type":"' || data_type || '","nullable":true}}'
+        END as "data_type",
+        CASE WHEN is_nullable = 'YES' THEN 'true' ELSE 'false' END as "null?",
+        COALESCE(column_default, '') as "default",
+        'COLUMN' as "kind",
+        '' as "expression",
+        COALESCE(comment, '') as "comment",
+        table_catalog as "database_name",
+        '' as "autoincrement",
+        NULL as "schema_evolution_record"
+    FROM _fs_global._fs_information_schema._fs_columns c
+    WHERE 1=1
+    {f"AND table_catalog = '{catalog}'" if catalog else ""}
+    {f"AND table_schema = '{schema}'" if schema else ""}
+    {f"AND table_name = '{table}'" if table else ""}
+    ORDER BY table_name, ordinal_position
+    """  # noqa: E501
+
+    return sqlglot.parse_one(query, read="duckdb")
+
+
+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_WAREHOUSES = """
+SELECT
+    'FAKESNOW_WAREHOUSE' as name,
+    'STARTED' as state,
+    'STANDARD' as type,
+    'X-Small' as size,
+    1 as min_cluster_count,
+    1 as max_cluster_count,
+    1 as started_clusters,
+    0 as running,
+    0 as queued,
+    'N' as is_default,
+    'N' as is_current,
+    600 as auto_suspend,
+    'true' as auto_resume,
+    -- nb: deliberate space before '100' to match Snowflake's output
+    ' 100' as available,
+    '0' as provisioning,
+    '0' as quiescing,
+    '0' as other,
+    '1970-01-01 00:00:00.000000 UTC'::timestamptz as created_on,
+    '1970-01-01 00:00:00.000000 UTC'::timestamptz as resumed_on,
+    '1970-01-01 00:00:00.000000 UTC'::timestamptz as updated_on,
+    'SYSADMIN' as owner,
+    '' as comment,
+    'false' as enable_query_acceleration,
+    8 as query_acceleration_max_scale_factor,
+    'null' as resource_monitor,
+
+    -- deprecated - these 5 cols are for internal use
+    0 as actives,
+    0 as pendings,
+    0 as failed,
+    0 as suspended,
+    '123456789012' as uuid,
+
+    'STANDARD' as scaling_policy,
+    NULL as budget,
+    'ROLE' as owner_role_type,
+    NULL as resource_constraint;
+"""
+
+
+def show_warehouses(expression: exp.Expression) -> exp.Expression:
+    """Transform SHOW WAREHOUSES.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/show-warehouses
+    """
+    if (
+        isinstance(expression, exp.Show)
+        and isinstance(expression.this, str)
+        and expression.this.upper() == "WAREHOUSES"
+    ):
+        return sqlglot.parse_one(SQL_SHOW_WAREHOUSES, 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_%'
+                """
+
+        if scope_kind := expression.args.get("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}' "
+            elif scope_kind == "TABLE":
+                if not table:
+                    raise ValueError(f"SHOW PRIMARY KEYS with {scope_kind} scope requires a table")
+
+                statement += f"AND table_name = '{table.name}' "
+            else:
+                raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind} not yet supported")
+        return sqlglot.parse_one(statement)
+    return expression
+
+
+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 not (
+        isinstance(expression, exp.Show)
+        and isinstance(expression.this, str)
+        and (show := expression.this.upper())
+        and show in {"OBJECTS", "TABLES"}
+    ):
+        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 - will show everything in the "account"
+        catalog = None
+        schema = None
+
+    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'",
+    ]
+    if not expression.args["terse"]:
+        if show == "OBJECTS":
+            columns.extend(
+                [
+                    "'' as 'comment'",
+                    "'' as 'cluster_by'",
+                    # TODO: implement rows and bytes as rows * 1024
+                    "0 as 'rows'",
+                    "0 as 'bytes'",
+                    "'SYSADMIN' as 'owner'",
+                    "1 as 'retention_time'",
+                    "'ROLE' as 'owner_role_type'",
+                    "null as 'budget'",
+                    "'N' as 'is_hybrid'",
+                    "'N' as 'is_dynamic'",
+                ]
+            )
+        else:
+            # show == "TABLES"
+            columns.extend(
+                [
+                    "'' as 'comment'",
+                    "'' as 'cluster_by'",
+                    # TODO: implement rows and bytes as rows * 1024
+                    "0 as 'rows'",
+                    "0 as 'bytes'",
+                    "'SYSADMIN' as 'owner'",
+                    "1 as 'retention_time'",
+                    "'OFF' as 'automatic_clustering'",
+                    "'OFF' as 'change_tracking'",
+                    "'OFF' as 'search_optimization'",
+                    "null as 'search_optimization_progress'",
+                    "null as 'search_optimization_bytes'",
+                    "'N' as 'is_external'",
+                    "'N' as 'enable_schema_evolution'",
+                    "'ROLE' as 'owner_role_type'",
+                    "'N' as 'is_event'",
+                    "null as 'budget'",
+                    "'N' as 'is_hybrid'",
+                    "'N' as 'is_iceberg'",
+                    "'N' as 'is_dynamic'",
+                    "'N' as 'is_immutable'",
+                ]
+            )
+
+    columns_clause = ", ".join(columns)
+
+    where = ["not (table_schema == '_fs_information_schema')"]  # exclude fakesnow's internal schemas
+    if show == "TABLES":
+        where.append("table_type = 'BASE TABLE'")
+    if catalog:
+        where.append(f"table_catalog = '{catalog}'")
+    if schema:
+        where.append(f"table_schema = '{schema}'")
+    if (like := expression.args.get("like")) and isinstance(like, exp.Expression):
+        where.append(f"table_name ilike {like.sql()}")
+    where_clause = " AND ".join(where)
+
+    limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
+
+    query = f"""
+        SELECT {columns_clause}
+        from information_schema.tables
+        where {where_clause}
+        {limit}
+    """
+
+    return sqlglot.parse_one(query, read="duckdb")
+
+
+# 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
+
+
+SQL_SHOW_SCHEMAS = """
+select
+    to_timestamp(0)::timestamptz as 'created_on',
+    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 not catalog_name in ('memory', 'system', 'temp', '_fs_global')
+  and not schema_name in ('main', 'pg_catalog')
+"""
+
+
+def show_schemas(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
+    """Transform SHOW SCHEMAS to a query against the information_schema.schemata table.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/show-schemas
+    """
+    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "SCHEMAS":
+        if (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
+            database = ident.this
+        else:
+            database = current_database
+
+        return sqlglot.parse_one(
+            f"{SQL_SHOW_SCHEMAS} and catalog_name = '{database}'" if database else SQL_SHOW_SCHEMAS, read="duckdb"
+        )
+
+    return expression
+
+
+def show_users(expression: exp.Expression) -> exp.Expression:
+    """Transform SHOW USERS to a query against the global database's information_schema._fs_users table.
+
+    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("SELECT * FROM _fs_global._fs_information_schema._fs_users_ext", read="duckdb")
+
+    return expression

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fakesnow
-Version: 0.9.30
+Version: 0.9.32
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -220,7 +220,7 @@ Requires-Dist: dirty-equals; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
 Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra == "dev"
 Requires-Dist: pre-commit~=4.0; extra == "dev"
-Requires-Dist: pyarrow-stubs==10.0.1.9; extra == "dev"
+Requires-Dist: pyarrow-stubs==17.19; extra == "dev"
 Requires-Dist: pytest~=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: ruff~=0.11.0; extra == "dev"

{fakesnow-0.9.30.dist-info → fakesnow-0.9.32.dist-info}/RECORD

@@ -1,26 +1,28 @@
 fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
 fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
-fakesnow/arrow.py,sha256=MwatkdZX5AFADzXvxhBFmcRJVxbW4D39VoqLyhpTbl0,5057
+fakesnow/arrow.py,sha256=XjTpFyLrD9jULWOtPgpr0RyNMmO6a5yi82y6ivi2CCI,4884
 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/conn.py,sha256=2WClMmUgfQkQA2hFQjfMP3R-85TbTbZh_8Y1tCdcerA,6053
+fakesnow/cursor.py,sha256=Nvr8TQmmTFs6i0sJwfgCocrEF9td0D0SdDG41quIudI,21621
 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/instance.py,sha256=VsFbhVfy6EAJdEKykgavJwkMtrig01NehorptT51Jh8,2020
 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/server.py,sha256=oLnWJgcxwhPw4sNebJF3B9uxk28A-a-AI8Pyl_lz2_E,5986
 fakesnow/variables.py,sha256=WXyPnkeNwD08gy52yF66CVe2twiYC50tztNfgXV4q1k,3032
-fakesnow/transforms/__init__.py,sha256=ENBHnwfQHAlC9PWOq4tdz-9-YQGy2E48xJB5ce7qEA0,60345
+fakesnow/transforms/__init__.py,sha256=gD8wPo9QprwHkTOEMQ0-IsXSNfUruU0kBJPjO0po-J4,49377
 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/transforms/show.py,sha256=2qfK3Fi0RLylqTnkwSVgv5JIorXYb1y0fnf5oErRZ2o,16839
+tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
+fakesnow-0.9.32.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.32.dist-info/METADATA,sha256=HTGvul9rrgbrcSK79gmq4KndGAga0be6WzaKSUc_3c4,18106
+fakesnow-0.9.32.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+fakesnow-0.9.32.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.32.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
+fakesnow-0.9.32.dist-info/RECORD,,

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

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

{fakesnow-0.9.30.dist-info → fakesnow-0.9.32.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
 dist
 fakesnow
 notebooks
+tools

tools/decode.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+import base64
+import sys
+
+import pyarrow as pa
+
+
+def dump_field_metadata(field: pa.Field, index: int) -> None:
+    """Dump metadata for a single field."""
+    print(f"Field {index}: {field.name}")
+    print(f"  Type: {field.type}")
+    print(f"  Nullable: {field.nullable}")
+    print("  Metadata:")
+    assert field.metadata
+    for key, value in field.metadata.items():
+        try:
+            print(f"    {key.decode('utf-8')}: {value.decode('utf-8')}")
+        except UnicodeDecodeError:  # noqa: PERF203
+            print(f"    {key.decode('utf-8')}: <binary data>")
+    print()
+
+
+def main() -> None:
+    if len(sys.argv) > 1:
+        print("Usage: python dump_rowset_metadata.py < base64_encoded_file")
+        print("   or: cat base64_encoded_file | python dump_rowset_metadata.py")
+        print()
+        print("Dump pyarrow metadata for a base64-encoded rowset.")
+        sys.exit(1)
+
+    # Read base64 input from stdin
+    rowset_b64 = sys.stdin.read().strip()
+
+    try:
+        # Decode base64
+        data = base64.b64decode(rowset_b64)
+
+        # Parse with PyArrow
+        reader = pa.ipc.open_stream(data)
+
+    except Exception as e:
+        full_class_name = f"{e.__module__}.{e.__class__.__name__}"
+        print(f"Error processing rowset: {full_class_name} {e}")
+        sys.exit(1)
+
+    # Get the first batch
+    batch = next(iter(reader))
+
+    print(f"Total fields: {batch.num_columns}")
+    print("=" * 50)
+
+    # Dump metadata for each field
+    for i, field in enumerate(batch.schema):
+        dump_field_metadata(field, i)
+
+        # Also print a sample of the array data
+        print(f"  Batch data: {batch[i]}")
+        print(f"  Batch data type: {type(batch[i])}")
+        print("=" * 50)
+
+
+if __name__ == "__main__":
+    main()