fakesnow 0.9.29__py3-none-any.whl → 0.9.31__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/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

@@ -64,7 +64,7 @@ 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

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)
@@ -182,7 +188,7 @@ 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_columns)
             .transform(transforms.information_schema_databases, current_schema=self._conn.schema)
             .transform(transforms.information_schema_fs_tables)
             .transform(transforms.information_schema_fs_views)
@@ -222,6 +228,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
@@ -276,20 +285,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  # 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":

fakesnow/info_schema.py

@@ -4,11 +4,14 @@ from __future__ import annotations
 
 from string import Template
 
-from fakesnow.instance import GLOBAL_DATABASE_NAME
+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 = f"""
-create table if not exists {GLOBAL_DATABASE_NAME}.main._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,
@@ -18,8 +21,8 @@ create table if not exists {GLOBAL_DATABASE_NAME}.main._fs_tables_ext (
 """
 
 
-SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_EXT = f"""
-create table if not exists {GLOBAL_DATABASE_NAME}.main._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,
@@ -30,18 +33,56 @@ create table if not exists {GLOBAL_DATABASE_NAME}.main._fs_columns_ext (
 )
 """
 
+# 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
 """
 )
 
+SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_VIEW = Template(
+    """
+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_INFORMATION_SCHEMA_COLUMNS_VIEW = Template(
-    """
-create view if not exists ${catalog}._fs_information_schema._fs_columns_snowflake AS
+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,
@@ -71,7 +112,7 @@ collation_name, is_identity, identity_generation, identity_cycle,
     null::VARCHAR as identity_start,
     null::VARCHAR as identity_increment,
 from system.information_schema.columns columns
-left join _fs_global.main._fs_columns_ext ext
+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
@@ -81,10 +122,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'
+where schema_name != '_fs_information_schema'
 """
-)
 
 
 # replicates https://docs.snowflake.com/sql-reference/info-schema/databases
@@ -112,7 +151,7 @@ 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
+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
@@ -147,7 +186,7 @@ where database_name = '${catalog}'
 )
 
 
-def creation_sql(catalog: str) -> str:
+def per_db_creation_sql(catalog: str) -> str:
     return f"""
         {SQL_CREATE_FS_INFORMATION_SCHEMA.substitute(catalog=catalog)};
         {SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_VIEW.substitute(catalog=catalog)};
@@ -159,14 +198,17 @@ def creation_sql(catalog: str) -> str:
 
 def fs_global_creation_sql(catalog: str) -> str:
     return f"""
-        {SQL_CREATE_INFORMATION_SCHEMA_TABLES_EXT};
-        {SQL_CREATE_INFORMATION_SCHEMA_COLUMNS_EXT};
+        {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 {GLOBAL_DATABASE_NAME}.main._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
@@ -180,7 +222,7 @@ def insert_text_lengths_sql(catalog: str, schema: str, table: str, text_lengths:
     )
 
     return f"""
-        INSERT INTO {GLOBAL_DATABASE_NAME}.main._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

@@ -9,49 +9,6 @@ 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:
@@ -71,7 +28,6 @@ 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))
 

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] = {}
 
@@ -46,13 +52,22 @@ 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()
         if request.headers.get("Content-Encoding") == "gzip":
@@ -65,6 +80,8 @@ async def query_request(request: Request) -> JSONResponse:
         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(
@@ -78,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
@@ -107,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.")
 
-    token = auth[17:-1]
+    return 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,10 +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
 
+__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")
 
 
@@ -166,7 +221,7 @@ SELECT
     NULL::VARCHAR AS "comment",
     NULL::VARCHAR AS "policy name",
     NULL::JSON AS "privacy domain",
-FROM _fs_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
 """
@@ -195,7 +250,7 @@ FROM (DESCRIBE ${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
     """
@@ -210,17 +265,10 @@ 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=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"
-            )
+        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),
@@ -230,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.
@@ -602,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 _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.
     """
@@ -615,7 +663,7 @@ 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
@@ -672,15 +720,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,
@@ -741,10 +795,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).
 
@@ -792,29 +842,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:
@@ -979,17 +1029,10 @@ def show_objects_tables(expression: exp.Expression, current_database: str | None
         catalog = table.db or current_database
         schema = table.name
     else:
-        # all objects / tables
+        # all objects / tables - will show everything in the "account"
         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'",
@@ -997,17 +1040,29 @@ def show_objects_tables(expression: exp.Expression, current_database: str | None
         "table_catalog as 'database_name'",
         "table_schema as 'schema_name'",
     ]
-
-    terse = expression.args["terse"]
-    if not terse:
+    if not expression.args["terse"]:
         columns.append('null as "comment"')
+    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)
 
-    columns_str = ", ".join(columns)
+    limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
 
-    query = (
-        f"SELECT {columns_str} from information_schema.tables "
-        f"where {tables_only}{exclude_fakesnow_tables}{table_catalog}{schema}{limit}"
-    )
+    query = f"""
+        SELECT {columns_clause}
+        from information_schema.tables
+        where {where_clause}
+        {limit}
+    """
 
     return sqlglot.parse_one(query, read="duckdb")
 
@@ -1023,7 +1078,7 @@ select
     catalog_name as 'database_name',
     NULL as 'schema_name'
 from information_schema.schemata
-where not catalog_name in ('memory', 'system', 'temp')
+where not catalog_name in ('memory', 'system', 'temp', '_fs_global')
   and not schema_name in ('main', 'pg_catalog')
 """
 
@@ -1046,6 +1101,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.
@@ -1145,8 +1307,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.
@@ -1156,12 +1316,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
 
@@ -1392,7 +1550,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
 
@@ -1410,7 +1568,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
 
@@ -1480,8 +1640,7 @@ def show_keys(
                   AND table_name NOT LIKE '_fs_%'
                 """
 
-        scope_kind = expression.args.get("scope_kind")
-        if scope_kind:
+        if scope_kind := expression.args.get("scope_kind"):
             table = expression.args["scope"]
 
             if scope_kind == "SCHEMA":

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fakesnow
-Version: 0.9.29
+Version: 0.9.31
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -213,17 +213,17 @@ License-File: LICENSE
 Requires-Dist: duckdb~=1.2.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=26.6.0
+Requires-Dist: sqlglot~=26.10.1
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 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.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.31.dist-info/RECORD

@@ -0,0 +1,26 @@
+fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
+fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
+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=tlcQK_w4r6BZHs3BTNHUFGk2hZz-lSnOdIrNLaJ-rBw,21349
+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=a-WNNqIo6IhY9p_m0zfdre7eb6KDmz-dbyrNkhpsHQk,60506
+fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
+fakesnow-0.9.31.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.31.dist-info/METADATA,sha256=RXWi0hLbvLkUtzDw0SHtcu-N3-Ebd1BC5K7JfoPnZ38,18106
+fakesnow-0.9.31.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+fakesnow-0.9.31.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.31.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
+fakesnow-0.9.31.dist-info/RECORD,,

{fakesnow-0.9.29.dist-info → fakesnow-0.9.31.dist-info}/WHEEL

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

fakesnow-0.9.29.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=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=_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=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.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,,