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

fakesnow/arrow.py

@@ -5,7 +5,7 @@ from typing import cast
 import pyarrow as pa
 import pyarrow.compute as pc
 
-from fakesnow.types import ColumnInfo
+from fakesnow.rowtype import ColumnInfo
 
 
 def to_sf_schema(schema: pa.Schema, rowtype: list[ColumnInfo]) -> pa.Schema:
@@ -27,6 +27,10 @@ def to_sf_schema(schema: pa.Schema, rowtype: list[ColumnInfo]) -> pa.Schema:
             field = field.with_type(pa.struct(fields))
         elif isinstance(field.type, pa.Time64Type):
             field = field.with_type(pa.int64())
+        elif pa.types.is_uint64(field.type):
+            # snowflake-python-connector expects signed ints
+            # see https://github.com/snowflakedb/snowflake-connector-python/blob/5d7064c7f3f756792c1f6252bf5c9d807e4307e8/src/snowflake/connector/nanoarrow_cpp/ArrowIterator/CArrowChunkIterator.cpp#L187
+            field = field.with_type(pa.int64())
 
         return field.with_metadata(
             {

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
@@ -60,7 +62,7 @@ class FakeSnowflakeConnection:
                 where upper(catalog_name) = '{self.database}'"""
             ).fetchone()
         ):
-            db_file = f"{self.db_path/self.database}.db" if self.db_path else ":memory:"
+            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(macros.creation_sql(self.database))
@@ -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
@@ -114,6 +116,10 @@ class FakeSnowflakeConnection:
     ) -> None:
         pass
 
+    def autocommit(self, _mode: bool) -> None:
+        # autcommit is always on in duckdb
+        pass
+
     def close(self, retry: bool = True) -> None:
         self._duck_conn.close()
         self._is_closed = True
@@ -145,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

@@ -3,13 +3,14 @@ from __future__ import annotations
 import os
 import re
 import sys
+import uuid
 from collections.abc import Iterator, Sequence
 from string import Template
 from types import TracebackType
 from typing import TYPE_CHECKING, Any, cast
 
 import duckdb
-import pyarrow
+import pyarrow  # needed by fetch_arrow_table()
 import snowflake.connector.converter
 import snowflake.connector.errors
 import sqlglot
@@ -23,7 +24,7 @@ import fakesnow.checks as checks
 import fakesnow.expr as expr
 import fakesnow.info_schema as info_schema
 import fakesnow.transforms as transforms
-from fakesnow.types import describe_as_result_metadata
+from fakesnow.rowtype import describe_as_result_metadata
 
 if TYPE_CHECKING:
     # don't require pandas at import time
@@ -71,6 +72,7 @@ class FakeSnowflakeCursor:
         self._arrow_table = None
         self._arrow_table_fetch_index = None
         self._rowcount = None
+        self._sfqid = None
         self._converter = snowflake.connector.converter.SnowflakeConverter()
 
     def __enter__(self) -> Self:
@@ -143,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)
@@ -152,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)
@@ -161,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)
@@ -222,24 +245,10 @@ class FakeSnowflakeCursor:
         self._arrow_table = None
         self._arrow_table_fetch_index = None
         self._rowcount = None
+        self._sfqid = None
 
         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")):
@@ -275,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"):
@@ -325,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
@@ -353,6 +362,7 @@ class FakeSnowflakeCursor:
 
         self._arrow_table = self._duck_conn.fetch_arrow_table()
         self._rowcount = affected_count or self._arrow_table.num_rows
+        self._sfqid = str(uuid.uuid4())
 
         self._last_sql = result_sql or sql
         self._last_params = params
@@ -423,7 +433,7 @@ class FakeSnowflakeCursor:
 
     @property
     def sfqid(self) -> str | None:
-        return "fakesnow"
+        return self._sfqid
 
     @property
     def sqlstate(self) -> str | None:

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
@@ -146,12 +175,12 @@ def insert_table_comment_sql(catalog: str, schema: str, table: str, comment: str
 
 def insert_text_lengths_sql(catalog: str, schema: str, table: str, text_lengths: list[tuple[str, int]]) -> str:
     values = ", ".join(
-        f"('{catalog}', '{schema}', '{table}', '{col_name}', {size}, {min(size*4,16777216)})"
+        f"('{catalog}', '{schema}', '{table}', '{col_name}', {size}, {min(size * 4, 16777216)})"
         for (col_name, size) in 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/pandas_tools.py

@@ -4,13 +4,13 @@ import json
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
-import numpy as np
 from duckdb import DuckDBPyConnection
 
 from fakesnow.conn import FakeSnowflakeConnection
 
 if TYPE_CHECKING:
-    # don't require pandas at import time
+    # don't require pandas or numpy at import time
+    import numpy as np
     import pandas as pd
 
 

fakesnow/{types.py → rowtype.py}

@@ -25,12 +25,14 @@ duckdb_to_sf_type = {
     "DATE": "date",
     "DECIMAL": "fixed",
     "DOUBLE": "real",
+    "HUGEINT": "fixed",
     "INTEGER": "fixed",
     "JSON": "variant",
     "TIME": "time",
     "TIMESTAMP WITH TIME ZONE": "timestamp_tz",
     "TIMESTAMP_NS": "timestamp_ntz",
     "TIMESTAMP": "timestamp_ntz",
+    "UBIGINT": "fixed",
     "VARCHAR": "text",
 }
 

fakesnow/server.py

@@ -17,7 +17,7 @@ from starlette.routing import Route
 from fakesnow.arrow import to_ipc, to_sf
 from fakesnow.fakes import FakeSnowflakeConnection
 from fakesnow.instance import FakeSnow
-from fakesnow.types import describe_as_rowtype
+from fakesnow.rowtype import describe_as_rowtype
 
 shared_fs = FakeSnow()
 sessions: dict[str, FakeSnowflakeConnection] = {}
@@ -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"]
 
@@ -87,7 +92,8 @@ async def query_request(request: Request) -> JSONResponse:
                 "data": {
                     "rowtype": rowtype,
                     "rowsetBase64": rowset_b64,
-                    "total": 1,
+                    "total": cur._rowcount,  # noqa: SLF001
+                    "queryId": cur.sfqid,
                     "queryResultFormat": "arrow",
                 },
                 "success": True,

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")
 
 
@@ -133,7 +132,7 @@ def create_database(expression: exp.Expression, db_path: Path | None = None) ->
         ident = expression.find(exp.Identifier)
         assert ident, f"No identifier in {expression.sql}"
         db_name = ident.this
-        db_file = f"{db_path/db_name}.db" if db_path else ":memory:"
+        db_file = f"{db_path / db_name}.db" if db_path else ":memory:"
 
         if_not_exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
 
@@ -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/transforms_merge.py

@@ -48,7 +48,7 @@ def _create_merge_candidates(merge_expr: exp.Merge) -> exp.Expression:
     )
 
     # Iterate through the WHEN clauses to build up the CASE WHEN clauses
-    for w_idx, w in enumerate(merge_expr.expressions):
+    for w_idx, w in enumerate(merge_expr.args["whens"]):
         assert isinstance(w, exp.When), f"Expected When expression, got {w}"
 
         predicate = join_expr.copy()
@@ -83,9 +83,9 @@ def _create_merge_candidates(merge_expr: exp.Merge) -> exp.Expression:
     sql = f"""
     CREATE OR REPLACE TEMPORARY TABLE merge_candidates AS
     SELECT
-        {', '.join(sorted(values))},
+        {", ".join(sorted(values))},
         CASE
-            {' '.join(case_when_clauses)}
+            {" ".join(case_when_clauses)}
             ELSE NULL
         END AS MERGE_OP
     FROM {target_tbl}
@@ -109,7 +109,7 @@ def _mutations(merge_expr: exp.Merge) -> list[exp.Expression]:
     statements: list[exp.Expression] = []
 
     # Iterate through the WHEN clauses to generate delete/update/insert statements
-    for w_idx, w in enumerate(merge_expr.expressions):
+    for w_idx, w in enumerate(merge_expr.args["whens"]):
         assert isinstance(w, exp.When), f"Expected When expression, got {w}"
 
         matched = w.args.get("matched")
@@ -173,7 +173,7 @@ def _counts(merge_expr: exp.Merge) -> exp.Expression:
     operations = {"inserted": [], "updated": [], "deleted": []}
 
     # Iterate through the WHEN clauses to categorize operations
-    for w_idx, w in enumerate(merge_expr.expressions):
+    for w_idx, w in enumerate(merge_expr.args["whens"]):
         assert isinstance(w, exp.When), f"Expected When expression, got {w}"
 
         matched = w.args.get("matched")
@@ -191,12 +191,12 @@ def _counts(merge_expr: exp.Merge) -> exp.Expression:
             operations["inserted"].append(w_idx)
 
     count_statements = [
-        f"""COUNT_IF(merge_op in ({','.join(map(str, indices))})) as \"number of rows {op}\""""
+        f"""COUNT_IF(merge_op in ({",".join(map(str, indices))})) as \"number of rows {op}\""""
         for op, indices in operations.items()
         if indices
     ]
     sql = f"""
-    SELECT {', '.join(count_statements)}
+    SELECT {", ".join(count_statements)}
     FROM merge_candidates
     """
 

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: fakesnow
-Version: 0.9.27
+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~=25.34.0
+Requires-Dist: sqlglot~=26.6.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: dirty-equals; extra == "dev"
@@ -223,7 +223,7 @@ Requires-Dist: pre-commit~=4.0; extra == "dev"
 Requires-Dist: pyarrow-stubs==10.0.1.9; extra == "dev"
 Requires-Dist: pytest~=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
-Requires-Dist: ruff~=0.8.1; extra == "dev"
+Requires-Dist: ruff~=0.9.4; extra == "dev"
 Requires-Dist: twine~=6.0; extra == "dev"
 Requires-Dist: snowflake-sqlalchemy~=1.7.0; extra == "dev"
 Provides-Extra: notebook

fakesnow-0.9.29.dist-info/RECORD

@@ -0,0 +1,26 @@
+fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
+fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
+fakesnow/arrow.py,sha256=MwatkdZX5AFADzXvxhBFmcRJVxbW4D39VoqLyhpTbl0,5057
+fakesnow/checks.py,sha256=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,,

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

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

fakesnow-0.9.27.dist-info/RECORD

@@ -1,26 +0,0 @@
-fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
-fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
-fakesnow/arrow.py,sha256=EGAYeuCnRuvmWBEGqw2YOcgQR4zcCsZBu85kSRl70dQ,4698
-fakesnow/checks.py,sha256=N8sXldhS3u1gG32qvZ4VFlsKgavRKrQrxLiQU8am1lw,2691
-fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
-fakesnow/conn.py,sha256=Gy_Z7BZRm5yMjV3x6hR4iegDQFdG9aJBjqWdc3iWYFU,5353
-fakesnow/cursor.py,sha256=8wWtRCxzrM1yiHmH2C-9CT0b98nTzr23ygeaEAkumRE,20086
-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=nsDceFtjiSXrvkksKziVvqrefskaSyOmAspBwMAsaDg,6307
-fakesnow/instance.py,sha256=3cJvPRuFy19dMKXbtBLl6imzO48pEw8uTYhZyFDuwhk,3133
-fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
-fakesnow/pandas_tools.py,sha256=WjyjTV8QUCQQaCGboaEOvx2uo4BkknpWYjtLwkeCY6U,3468
-fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
-fakesnow/server.py,sha256=SO5xKZ4rvySsuKDsoSPSCZcFuIX_K7d1XJYhRRJ-7Bk,4150
-fakesnow/transforms.py,sha256=h35WHWxhlXpfe03f3FCF64QVmiCLMdDZF7oZmaAOS60,55451
-fakesnow/transforms_merge.py,sha256=7rq-UPjfFNRrFsqR8xx3otwP6-k4eslLVLhfuqSXq1A,8314
-fakesnow/types.py,sha256=9Tt83Z7ctc9_v6SYyayXYz4MEI4RZo4zq_uqdj4g3Dk,2681
-fakesnow/variables.py,sha256=WXyPnkeNwD08gy52yF66CVe2twiYC50tztNfgXV4q1k,3032
-fakesnow-0.9.27.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
-fakesnow-0.9.27.dist-info/METADATA,sha256=k7PwECuxM55u-Dx_WyieDaH1p2BrHlcmu9INMsxGtzQ,18108
-fakesnow-0.9.27.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-fakesnow-0.9.27.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.27.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
-fakesnow-0.9.27.dist-info/RECORD,,