fakesnow 0.9.37__py3-none-any.whl → 0.9.39__py3-none-any.whl

fakesnow/checks.py

@@ -39,8 +39,8 @@ def is_unqualified_table_expression(expression: exp.Expression) -> tuple[bool, b
             # "CREATE/DROP SCHEMA"
             no_database = not node.args.get("catalog")
             no_schema = False
-        elif parent_kind.upper() in {"TABLE", "VIEW"}:
-            # "CREATE/DROP TABLE/VIEW"
+        elif parent_kind.upper() in {"TABLE", "VIEW", "STAGE"}:
+            # "CREATE/DROP TABLE/VIEW/STAGE"
             no_database = not node.args.get("catalog")
             no_schema = not node.args.get("db")
         else:

fakesnow/copy_into.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+import datetime
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import Any, Protocol, cast
+from typing import Any, NamedTuple, Protocol, cast
 from urllib.parse import urlparse, urlunparse
 
 import duckdb
@@ -13,27 +14,121 @@ from sqlglot import exp
 from fakesnow import logger
 
 
+class LoadHistoryRecord(NamedTuple):
+    """Represents a record in the INFORMATION_SCHEMA.LOAD_HISTORY table."""
+
+    schema_name: str
+    file_name: str
+    table_name: str
+    last_load_time: str  # ISO8601 datetime with timezone
+    status: str
+    row_count: int
+    row_parsed: int
+    first_error_message: str | None
+    first_error_line_number: int | None
+    first_error_character_position: int | None
+    first_error_col_name: str | None
+    error_count: int
+    error_limit: int | None
+
+
 def copy_into(
-    duck_conn: DuckDBPyConnection, expr: exp.Copy, params: Sequence[Any] | dict[Any, Any] | None = None
+    duck_conn: DuckDBPyConnection,
+    current_database: str | None,
+    current_schema: str | None,
+    expr: exp.Copy,
+    params: Sequence[Any] | dict[Any, Any] | None = None,
 ) -> str:
     cparams = _params(expr)
-    urls = _source_urls(expr, cparams.files)
+    if isinstance(cparams.file_format, ReadParquet):
+        from_ = expr.args["files"][0]
+        # parquet must use MATCH_BY_COLUMN_NAME (TODO) or a copy transformation
+        # ie: the from clause in COPY INTO must be a subquery
+        if not isinstance(from_, exp.Subquery):
+            raise snowflake.connector.errors.ProgrammingError(
+                msg="SQL compilation error:\nPARQUET file format can produce one and only one column of type variant, object, or array. Load data into separate columns using the MATCH_BY_COLUMN_NAME copy option or copy with transformation.",  # noqa: E501
+                errno=2019,
+                sqlstate="0A000",
+            )
+
+    from_source = _from_source(expr)
+    source = (
+        stage_url_from_var(from_source, duck_conn, current_database, current_schema)
+        if from_source.startswith("@")
+        else from_source
+    )
+    urls = _source_urls(source, cparams.files)
+
     inserts = _inserts(expr, cparams, urls)
+    table = expr.this
+    if isinstance(expr.this, exp.Table):
+        table = expr.this
+    elif isinstance(expr.this, exp.Schema) and isinstance(expr.this.this, exp.Table):
+        table = expr.this.this
+    else:
+        raise AssertionError(f"copy into {expr.this.__class__} is not Table or Schema")
+
+    schema = table.db or current_schema
+    assert schema
 
-    results = []
+    histories: list[LoadHistoryRecord] = []
+    load_time = datetime.datetime.now(datetime.timezone.utc).isoformat()
     try:
-        # TODO: fetch files last modified dates and check if file exists in load_history already
+        check_sql = "SELECT 1 FROM _fs_information_schema._fs_load_history WHERE FILE_NAME = ? LIMIT 1"
+
         for i, url in zip(inserts, urls):
-            sql = i.sql(dialect="duckdb")
-            logger.log_sql(sql, params)
+            # Check if file has been loaded into any table before
+            duck_conn.execute(check_sql, [url])
+            if duck_conn.fetchone() and not cparams.force:
+                affected_count = 0
+                status = "LOAD_SKIPPED"
+                error_limit = None
+                error_count = 1
+                first_error_message = "File was loaded before."
+            else:
+                sql = i.sql(dialect="duckdb")
+                logger.log_sql(sql, params)
+                duck_conn.execute(sql, params)
+                (affected_count,) = duck_conn.fetchall()[0]
+                status = "LOADED"
+                error_limit = 1
+                error_count = 0
+                first_error_message = None
+
+            history = LoadHistoryRecord(
+                schema_name=schema,
+                file_name=url,
+                table_name=table.name,
+                last_load_time=load_time,
+                status=status,
+                row_count=affected_count,
+                row_parsed=affected_count,
+                first_error_message=first_error_message,
+                first_error_line_number=None,
+                first_error_character_position=None,
+                first_error_col_name=None,
+                error_count=error_count,
+                error_limit=error_limit,
+            )
+            histories.append(history)
+
+        if insert_histories := [h for h in histories if h.status != "LOAD_SKIPPED"]:
+            values = "\n ,".join(str(tuple(history)).replace("None", "NULL") for history in insert_histories)
+            sql = f"INSERT INTO _fs_information_schema._fs_load_history VALUES {values}"
             duck_conn.execute(sql, params)
-            (affected_count,) = duck_conn.fetchall()[0]
-            results.append(f"('{url}', 'LOADED', {affected_count}, {affected_count}, 1, 0, NULL, NULL, NULL, NULL)")
-
-            # TODO: update load_history with the results if loaded
 
-        columns = "file, status, rows_parsed, rows_loaded, error_limit, errors_seen, first_error, first_error_line, first_error_character, first_error_column_name"  # noqa: E501
-        values = "\n, ".join(results)
+        columns = (
+            "file, status, rows_parsed, rows_loaded, error_limit, errors_seen, first_error, first_error_line, "
+            "first_error_character, first_error_column_name"
+        )
+        values = "\n, ".join(
+            f"('{h.file_name}', '{h.status}', {h.row_parsed}, {h.row_count}, "
+            f"{h.error_limit or 'NULL'}, {h.error_count}, "
+            f"{repr(h.first_error_message) if h.first_error_message else 'NULL'}, "
+            f"{h.first_error_line_number or 'NULL'}, {h.first_error_character_position or 'NULL'}, "
+            f"{h.first_error_col_name or 'NULL'})"
+            for h in histories
+        )
         sql = f"SELECT * FROM (VALUES\n  {values}\n) AS t({columns})"
         duck_conn.execute(sql)
         return sql
@@ -62,6 +157,8 @@ def _params(expr: exp.Copy) -> Params:
 
             if var_type == "CSV":
                 kwargs["file_format"] = handle_csv(param.expressions)
+            elif var_type == "PARQUET":
+                kwargs["file_format"] = ReadParquet()
             else:
                 raise NotImplementedError(f"{var_type} FILE_FORMAT is not currently implemented")
         elif var == "FORCE":
@@ -71,28 +168,97 @@ def _params(expr: exp.Copy) -> Params:
         else:
             raise ValueError(f"Unknown copy parameter: {param.this}")
 
-    if not force:
-        raise NotImplementedError("COPY INTO with FORCE=false (default) is not currently implemented")
+    return Params(force=force, **kwargs)
+
+
+def _from_source(expr: exp.Copy) -> str:
+    # NB: sqlglot parses the from clause as "files" strangely
+    from_ = expr.args["files"][0].this
+
+    if isinstance(from_, exp.Select):
+        from_table = from_.args["from"]
+        # if a subquery is used in the FROM clause it must be loaded from a stage not an external location
+        assert isinstance(from_table, exp.From), f"{from_table.__class__} is not a From"
+        assert isinstance(from_table.this, exp.Table), f"{from_table.__class__} is not a Table"
+        var = from_table.this.this
+        if not isinstance(var, exp.Var):
+            # not a very helpful message, but this is what Snowflake returns
+            raise snowflake.connector.errors.ProgrammingError(
+                msg=f"SQL compilation error:\ninvalid URL prefix found in: {from_table.this.this}",
+                errno=1011,
+                sqlstate="42601",
+            )
+        # return the name of the stage, eg: @stage1
+        return var.this
 
-    return Params(**kwargs)
+    assert isinstance(from_, exp.Literal), f"{from_} is not a exp.Literal"
+    # return url
+    return from_.name
 
 
-def _source_urls(expr: exp.Copy, files: list[str]) -> list[str]:
+def normalise_ident(name: str) -> str:
     """
-    Given a COPY statement and a list of files, return a list of URLs with each file appended as a fragment.
-    Checks that the source is a valid URL.
+    Strip double quotes if present else return uppercased.
+    Snowflake treats quoted identifiers as case-sensitive and un-quoted identifiers as case-insensitive
     """
-    source = expr.args["files"][0].this
-    assert isinstance(source, exp.Literal), f"{source} is not a exp.Literal"
+    if name.startswith('"') and name.endswith('"'):
+        return name[1:-1]  # Strip quotes
+
+    return name.upper()
+
+
+def stage_url_from_var(
+    from_source: str, duck_conn: DuckDBPyConnection, current_database: str | None, current_schema: str | None
+) -> str:
+    parts = from_source[1:].split(".")
+    if len(parts) == 3:
+        # Fully qualified name
+        database_name, schema_name, name = parts
+    elif len(parts) == 2:
+        # Schema + stage name
+        assert current_database, "Current database must be set when stage name is not fully qualified"
+        database_name, schema_name, name = current_database, parts[0], parts[1]
+    elif len(parts) == 1:
+        # Stage name only
+        assert current_database, "Current database must be set when stage name is not fully qualified"
+        assert current_schema, "Current schema must be set when stage name is not fully qualified"
+        database_name, schema_name, name = current_database, current_schema, parts[0]
+    else:
+        raise ValueError(f"Invalid stage name: {from_source}")
+
+    # Normalize names to uppercase if not wrapped in double quotes
+    database_name = normalise_ident(database_name)
+    schema_name = normalise_ident(schema_name)
+    name = normalise_ident(name)
+
+    # Look up the stage URL
+    duck_conn.execute(
+        """
+        SELECT url FROM _fs_global._fs_information_schema._fs_stages
+        WHERE database_name = ? and schema_name  = ? and name = ?
+        """,
+        (database_name, schema_name, name),
+    )
+    if result := duck_conn.fetchone():
+        return result[0]
+    else:
+        raise snowflake.connector.errors.ProgrammingError(
+            msg=f"SQL compilation error:\nStage '{database_name}.{schema_name}.{name}' does not exist or not authorized.",  # noqa: E501
+            errno=2003,
+            sqlstate="02000",
+        )
 
-    scheme, netloc, path, params, query, fragment = urlparse(source.name)
+
+def _source_urls(from_source: str, files: list[str]) -> list[str]:
+    """Convert from_source to a list of URLs."""
+    scheme, netloc, path, params, query, fragment = urlparse(from_source)
     if not scheme:
         raise snowflake.connector.errors.ProgrammingError(
-            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{source.name}'", errno=1011, sqlstate="42601"
+            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{from_source}'", errno=1011, sqlstate="42601"
         )
 
     # rebuild url from components to ensure correct handling of host slash
-    return [_urlunparse(scheme, netloc, path, params, query, fragment, file) for file in files] or [source.name]
+    return [_urlunparse(scheme, netloc, path, params, query, fragment, file) for file in files] or [from_source]
 
 
 def _urlunparse(scheme: str, netloc: str, path: str, params: str, query: str, fragment: str, suffix: str) -> str:
@@ -111,9 +277,16 @@ def _urlunparse(scheme: str, netloc: str, path: str, params: str, query: str, fr
 def _inserts(expr: exp.Copy, params: Params, urls: list[str]) -> list[exp.Expression]:
     # INTO expression
     target = expr.this
-    columns = [exp.Column(this=exp.Identifier(this=f"column{i}")) for i in range(len(target.expressions))] or [
-        exp.Column(this=exp.Star())
-    ]
+
+    from_ = expr.args["files"][0]
+    if isinstance(from_, exp.Subquery):
+        select = from_.this
+        assert isinstance(select, exp.Select), f"{select.__class__} is not a Select"
+        columns = _strip_json_extract(select).expressions
+    else:
+        columns = [exp.Column(this=exp.Identifier(this=f"column{i}")) for i in range(len(target.expressions))] or [
+            exp.Column(this=exp.Star())
+        ]
 
     return [
         exp.Insert(
@@ -124,6 +297,20 @@ def _inserts(expr: exp.Copy, params: Params, urls: list[str]) -> list[exp.Expres
     ]
 
 
+def _strip_json_extract(expr: exp.Select) -> exp.Select:
+    """
+    Strip $1 prefix from SELECT statement columns.
+    """
+    dollar1 = exp.Parameter(this=exp.Literal(this="1", is_string=False))
+
+    for p in expr.find_all(exp.Parameter):
+        if p == dollar1 and p.parent and (key := p.parent.expression.find(exp.JSONPathKey)):
+            assert p.parent.parent, expr
+            p.parent.parent.args["this"] = exp.Identifier(this=key.this)
+
+    return expr
+
+
 def handle_csv(expressions: list[exp.Property]) -> ReadCSV:
     skip_header = ReadCSV.skip_header
     quote = ReadCSV.quote
@@ -192,8 +379,15 @@ class ReadCSV(FileTypeHandler):
         return exp.func("read_csv", exp.Literal(this=url, is_string=True), *args)
 
 
+@dataclass
+class ReadParquet(FileTypeHandler):
+    def read_expression(self, url: str) -> exp.Expression:
+        return exp.func("read_parquet", exp.Literal(this=url, is_string=True))
+
+
 @dataclass
 class Params:
     files: list[str] = field(default_factory=list)
     # Snowflake defaults to CSV when no file format is specified
     file_format: FileTypeHandler = field(default_factory=ReadCSV)
+    force: bool = False

fakesnow/cursor.py

@@ -43,6 +43,7 @@ SQL_CREATED_DATABASE = Template("SELECT 'Database ${name} successfully created.'
 SQL_CREATED_SCHEMA = Template("SELECT 'Schema ${name} successfully created.' as 'status'")
 SQL_CREATED_TABLE = Template("SELECT 'Table ${name} successfully created.' as 'status'")
 SQL_CREATED_VIEW = Template("SELECT 'View ${name} successfully created.' as 'status'")
+SQL_CREATED_STAGE = Template("SELECT 'Stage area ${name} successfully created.' as status")
 SQL_DROPPED = Template("SELECT '${name} successfully dropped.' as 'status'")
 SQL_INSERTED_ROWS = Template("SELECT ${count} as 'number of rows inserted'")
 SQL_UPDATED_ROWS = Template("SELECT ${count} as 'number of rows updated', 0 as 'number of multi-joined rows updated'")
@@ -203,10 +204,8 @@ 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)
+            .transform(transforms.information_schema_fs)
             .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)
             .transform(transforms.semi_structured_types)
@@ -248,8 +247,9 @@ class FakeSnowflakeCursor:
             .transform(transforms.show_procedures)
             .transform(transforms.show_warehouses)
             .transform(lambda e: transforms.show_schemas(e, self._conn.database))
-            .transform(lambda e: transforms.show_tables_etc(e, self._conn.database))
-            .transform(lambda e: transforms.show_columns(e, self._conn.database))
+            .transform(lambda e: transforms.show_tables_etc(e, self._conn.database, self._conn.schema))
+            .transform(lambda e: transforms.show_columns(e, self._conn.database, self._conn.schema))
+            .transform(lambda e: transforms.show_stages(e, self._conn.database, self._conn.schema))
             # 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"))
@@ -260,6 +260,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.create_clone)
             .transform(transforms.alias_in_join)
             .transform(transforms.alter_table_strip_cluster_by)
+            .transform(lambda e: transforms.create_stage(e, self._conn.database, self._conn.schema))
         )
 
     def _transform_explode(self, expression: exp.Expression) -> list[exp.Expression]:
@@ -287,17 +288,17 @@ class FakeSnowflakeCursor:
 
         try:
             if isinstance(transformed, exp.Copy):
-                sql = copy_into(self._duck_conn, transformed, params)
+                sql = copy_into(self._duck_conn, self._conn.database, self._conn.schema, transformed, params)
             else:
                 logger.log_sql(sql, params)
                 self._duck_conn.execute(sql, params)
         except duckdb.BinderException as e:
             msg = e.args[0]
-            raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=2043, sqlstate="02000") from None
+            raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=2043, sqlstate="02000") from e
         except duckdb.CatalogException as e:
             # minimal processing to make it look like a snowflake exception, message content may differ
             msg = cast(str, e.args[0]).split("\n")[0]
-            raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=2003, sqlstate="42S02") from None
+            raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=2003, sqlstate="42S02") from e
         except duckdb.TransactionException as e:
             if "cannot rollback - no transaction is active" in str(
                 e
@@ -307,9 +308,9 @@ class FakeSnowflakeCursor:
             else:
                 raise e
         except duckdb.ConnectionException as e:
-            raise snowflake.connector.errors.DatabaseError(msg=e.args[0], errno=250002, sqlstate="08003") from None
+            raise snowflake.connector.errors.DatabaseError(msg=e.args[0], errno=250002, sqlstate="08003") from e
         except duckdb.ParserException as e:
-            raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=1003, sqlstate="42000") from None
+            raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=1003, sqlstate="42000") from e
 
         affected_count = None
 
@@ -329,6 +330,15 @@ class FakeSnowflakeCursor:
             self._duck_conn.execute(info_schema.per_db_creation_sql(create_db_name))
             result_sql = SQL_CREATED_DATABASE.substitute(name=create_db_name)
 
+        elif stage_name := transformed.args.get("stage_name"):
+            if stage_name == "?":
+                assert isinstance(params, (tuple, list)) and len(params) == 1, (
+                    "Expected single parameter for stage name"
+                )
+                result_sql = SQL_CREATED_STAGE.substitute(name=params[0].upper())
+            else:
+                result_sql = SQL_CREATED_STAGE.substitute(name=stage_name.upper())
+
         elif cmd == "INSERT":
             (affected_count,) = self._duck_conn.fetchall()[0]
             result_sql = SQL_INSERTED_ROWS.substitute(count=affected_count)

fakesnow/info_schema.py

@@ -185,6 +185,49 @@ where database_name = '${catalog}'
 """
 )
 
+SQL_CREATE_LOAD_HISTORY_TABLE = Template(
+    """
+create table if not exists ${catalog}._fs_information_schema._fs_load_history (
+    SCHEMA_NAME VARCHAR,
+    FILE_NAME VARCHAR,
+    TABLE_NAME VARCHAR,
+    LAST_LOAD_TIME TIMESTAMPTZ,
+    STATUS VARCHAR,
+    ROW_COUNT INTEGER,
+    ROW_PARSED INTEGER,
+    FIRST_ERROR_MESSAGE VARCHAR,
+    FIRST_ERROR_LINE_NUMBER INTEGER,
+    FIRST_ERROR_CHARACTER_POSITION INTEGER,
+    FIRST_ERROR_COL_NAME VARCHAR,
+    ERROR_COUNT INTEGER,
+    ERROR_LIMIT INTEGER
+)
+    """
+)
+
+
+SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_STAGES_TABLE = """
+CREATE TABLE IF NOT EXISTS _fs_global._fs_information_schema._fs_stages (
+    created_on TIMESTAMPTZ,
+    name TEXT,
+    database_name TEXT,
+    schema_name TEXT,
+    url TEXT,
+    has_credentials TEXT,
+    has_encryption_key TEXT,
+    owner TEXT,
+    comment TEXT,
+    region TEXT,
+    type TEXT,
+    cloud TEXT,
+    notification_channel TEXT,
+    storage_integration TEXT,
+    endpoint TEXT,
+    owner_role_type TEXT,
+    directory_enabled TEXT
+);
+"""
+
 
 def per_db_creation_sql(catalog: str) -> str:
     return f"""
@@ -193,6 +236,7 @@ def per_db_creation_sql(catalog: str) -> str:
         {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)};
+        {SQL_CREATE_LOAD_HISTORY_TABLE.substitute(catalog=catalog)};
     """
 
 
@@ -203,6 +247,7 @@ def fs_global_creation_sql() -> str:
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_EXT};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_VIEW};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE};
+        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_STAGES_TABLE}
     """
 
 

fakesnow/server.py

@@ -63,6 +63,7 @@ async def login_request(request: Request) -> JSONResponse:
                     {"name": "AUTOCOMMIT", "value": True},
                     {"name": "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY", "value": 3600},
                 ],
+                "sessionInfo": {},
             },
             "success": True,
         }

fakesnow/transforms/__init__.py

@@ -8,10 +8,12 @@ from fakesnow.transforms.show import (
     show_keys as show_keys,
     show_procedures as show_procedures,
     show_schemas as show_schemas,
+    show_stages as show_stages,
     show_tables_etc as show_tables_etc,
     show_users as show_users,
     show_warehouses as show_warehouses,
 )
+from fakesnow.transforms.stage import create_stage as create_stage
 from fakesnow.transforms.transforms import (
     SUCCESS_NOP as SUCCESS_NOP,
     alias_in_join as alias_in_join,
@@ -36,9 +38,7 @@ from fakesnow.transforms.transforms import (
     identifier as identifier,
     indices_to_json_extract as indices_to_json_extract,
     information_schema_databases as information_schema_databases,
-    information_schema_fs_columns as information_schema_fs_columns,
-    information_schema_fs_tables as information_schema_fs_tables,
-    information_schema_fs_views as information_schema_fs_views,
+    information_schema_fs as information_schema_fs,
     integer_precision as integer_precision,
     json_extract_cased_as_varchar as json_extract_cased_as_varchar,
     json_extract_cast_as_varchar as json_extract_cast_as_varchar,

fakesnow/transforms/show.py

@@ -11,11 +11,52 @@ def fs_global_creation_sql() -> str:
         {SQL_CREATE_VIEW_SHOW_OBJECTS};
         {SQL_CREATE_VIEW_SHOW_TABLES};
         {SQL_CREATE_VIEW_SHOW_VIEWS};
+        {SQL_CREATE_VIEW_SHOW_COLUMNS};
+        {SQL_CREATE_VIEW_SHOW_DATABASES};
+        {SQL_CREATE_VIEW_SHOW_FUNCTIONS};
+        {SQL_CREATE_VIEW_SHOW_SCHEMAS};
+        {SQL_CREATE_VIEW_SHOW_PROCEDURES};
     """
 
 
+# see https://docs.snowflake.com/en/sql-reference/sql/show-columns
+SQL_CREATE_VIEW_SHOW_COLUMNS = """
+create view if not exists _fs_global._fs_information_schema._fs_show_columns as
+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
+ORDER BY table_catalog, table_schema, table_name, ordinal_position
+"""
+
+
 def show_columns(
-    expression: exp.Expression, current_database: str | None = None, current_schema: str | None = None
+    expression: exp.Expression, current_database: str | None, current_schema: str | None
 ) -> exp.Expression:
     """Transform SHOW COLUMNS to a query against the fs global information_schema columns table.
 
@@ -29,12 +70,7 @@ def show_columns(
     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:
+    if scope_kind == "DATABASE" and table:
         catalog = table.name
         schema = None
         table = None
@@ -46,42 +82,39 @@ def show_columns(
         catalog = table.catalog or current_database
         schema = table.db or current_schema
         table = table.name
+    elif scope_kind == "ACCOUNT":
+        # all columns
+        catalog = None
+        schema = None
+        table = None
+    elif not scope_kind:
+        # no explicit scope - show current database and schema only
+        catalog = current_database
+        schema = current_schema
+        table = None
     else:
         raise NotImplementedError(f"show_object_columns: {expression.sql(dialect='snowflake')}")
 
+    where = ["1=1"]
+    if catalog:
+        where.append(f"database_name = '{catalog}'")
+    if schema:
+        where.append(f"schema_name = '{schema}'")
+    if table:
+        where.append(f"table_name = '{table}'")
+    where_clause = " AND ".join(where)
+
     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
+    SELECT *
+    FROM _fs_global._fs_information_schema._fs_show_columns
+    WHERE {where_clause}
+    """
 
     return sqlglot.parse_one(query, read="duckdb")
 
 
-SQL_SHOW_DATABASES = """
+SQL_CREATE_VIEW_SHOW_DATABASES = """
+create view if not exists _fs_global._fs_information_schema._fs_show_databases as
 SELECT
     to_timestamp(0)::timestamptz as 'created_on',
     database_name as 'name',
@@ -102,18 +135,18 @@ 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.
+    """Transform SHOW DATABASES to a query against _fs_show_databases.
 
     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 sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_show_databases", read="duckdb")
 
     return expression
 
 
-# returns zero rows
-SQL_SHOW_FUNCTIONS = """
+SQL_CREATE_VIEW_SHOW_FUNCTIONS = """
+create view if not exists _fs_global._fs_information_schema._fs_show_functions as
 SELECT
     '1970-01-01 00:00:00 UTC'::timestamptz as created_on,
     'SYSTIMESTAMP' as name,
@@ -145,73 +178,14 @@ def show_functions(expression: exp.Expression) -> exp.Expression:
     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 sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_show_functions", read="duckdb")
 
     return expression
 
 
 def show_keys(
     expression: exp.Expression,
-    current_database: str | None = None,
+    current_database: str | None,
     *,
     kind: Literal["PRIMARY", "UNIQUE", "FOREIGN"],
 ) -> exp.Expression:
@@ -296,15 +270,138 @@ def show_keys(
     return expression
 
 
+SQL_CREATE_VIEW_SHOW_PROCEDURES = """
+create view if not exists _fs_global._fs_information_schema._fs_show_procedures as
+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(
+            "SELECT * FROM _fs_global._fs_information_schema._fs_show_procedures",
+            read="duckdb",
+        )
+
+    return expression
+
+
+SQL_CREATE_VIEW_SHOW_SCHEMAS = """
+create view if not exists _fs_global._fs_information_schema._fs_show_schemas as
+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) -> exp.Expression:
+    """Transform SHOW SCHEMAS to a query against the _fs_show_schemas view.
+
+    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
+
+        query = "SELECT * FROM _fs_global._fs_information_schema._fs_show_schemas"
+
+        if database:
+            query += f" WHERE database_name = '{database}'"
+        return sqlglot.parse_one(query, read="duckdb")
+
+    return expression
+
+
+def show_stages(expression: exp.Expression, current_database: str | None, current_schema: str | None) -> exp.Expression:
+    """Transform SHOW STAGES to a select from the fake _fs_stages table."""
+    if not (
+        isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "STAGES"
+    ):
+        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
+    elif scope_kind == "TABLE" and table:
+        catalog = table.db or current_database
+        assert isinstance(table.this, exp.Identifier)
+        schema = table.this.this
+    elif scope_kind == "ACCOUNT":
+        # show all objects / tables in the account
+        catalog = None
+        schema = None
+    else:
+        # no explicit scope - show current database and schema only
+        catalog = current_database
+        schema = current_schema
+
+    where = ["1=1"]
+    if catalog:
+        where.append(f"database_name = '{catalog}'")
+    if schema:
+        where.append(f"schema_name = '{schema}'")
+    where_clause = " AND ".join(where)
+
+    query = f"""
+        SELECT *
+        from _fs_global._fs_information_schema._fs_stages
+        where {where_clause}
+    """
+
+    return sqlglot.parse_one(query, read="duckdb")
+
+
 # see https://docs.snowflake.com/en/sql-reference/sql/show-objects
 SQL_CREATE_VIEW_SHOW_OBJECTS = """
 create view if not exists _fs_global._fs_information_schema._fs_show_objects as
 select
     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,
+    case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind',
     '' as comment,
     '' as cluster_by,
     -- TODO: implement rows and bytes as rows * 1024
@@ -313,9 +410,9 @@ select
     'SYSADMIN' as owner,
     1 as retention_time,
     'ROLE' as owner_role_type,
-    null as budget,
     'N' as is_hybrid,
-    'N' as is_dynamic
+    'N' as is_dynamic,
+    'N' as is_iceberg
 from information_schema.tables
 where not (table_schema == '_fs_information_schema')
 """
@@ -377,7 +474,9 @@ where not table_catalog in ('system')
 """
 
 
-def show_tables_etc(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
+def show_tables_etc(
+    expression: exp.Expression, current_database: str | None, current_schema: str | None
+) -> exp.Expression:
     """Transform SHOW OBJECTS/TABLES/VIEWS to a query against the _fs_information_schema views."""
     if not (
         isinstance(expression, exp.Show)
@@ -396,10 +495,14 @@ def show_tables_etc(expression: exp.Expression, current_database: str | None = N
     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"
+    elif scope_kind == "ACCOUNT":
+        # show all objects / tables in the account
         catalog = None
         schema = None
+    else:
+        # no explicit scope - show current database and schema only
+        catalog = current_database
+        schema = current_schema
 
     if expression.args["terse"] and show == "VIEWS":
         columns = ["created_on, name, 'VIEW' as kind, database_name, schema_name"]
@@ -430,84 +533,71 @@ def show_tables_etc(expression: exp.Expression, current_database: str | None = N
     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.
+def show_users(expression: exp.Expression) -> exp.Expression:
+    """Transform SHOW USERS to a query against the global database's information_schema._fs_users table.
 
-    See https://docs.snowflake.com/en/sql-reference/sql/show-procedures
+    https://docs.snowflake.com/en/sql-reference/sql/show-users
     """
-    if (
-        isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "PROCEDURES"
-    ):
-        return sqlglot.parse_one(SQL_SHOW_PROCEDURES, read="duckdb")
+    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", 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
+# 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,
 
-        return sqlglot.parse_one(
-            f"{SQL_SHOW_SCHEMAS} and catalog_name = '{database}'" if database else SQL_SHOW_SCHEMAS, read="duckdb"
-        )
+    -- deprecated - these 5 cols are for internal use
+    0 as actives,
+    0 as pendings,
+    0 as failed,
+    0 as suspended,
+    '123456789012' as uuid,
 
-    return expression
+    'STANDARD' as scaling_policy,
+    NULL as budget,
+    'ROLE' as owner_role_type,
+    NULL as resource_constraint;
+"""
 
 
-def show_users(expression: exp.Expression) -> exp.Expression:
-    """Transform SHOW USERS to a query against the global database's information_schema._fs_users table.
+def show_warehouses(expression: exp.Expression) -> exp.Expression:
+    """Transform SHOW WAREHOUSES.
 
-    https://docs.snowflake.com/en/sql-reference/sql/show-users
+    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() == "USERS":
-        return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users", read="duckdb")
+    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

fakesnow/transforms/stage.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import datetime
+
+import sqlglot
+from sqlglot import exp
+
+
+def create_stage(
+    expression: exp.Expression, current_database: str | None = None, current_schema: str | None = None
+) -> exp.Expression:
+    """Transform CREATE STAGE to an INSERT statement for the fake stages table."""
+    if not (
+        isinstance(expression, exp.Create)
+        and (kind := expression.args.get("kind"))
+        and isinstance(kind, str)
+        and kind.upper() == "STAGE"
+        and (table := expression.find(exp.Table))
+    ):
+        return expression
+
+    catalog = table.catalog or current_database
+    schema = table.db or current_schema
+    ident = table.this
+    if isinstance(ident, exp.Placeholder):
+        stage_name = "?"
+    elif isinstance(ident, exp.Identifier):
+        stage_name = ident.this if ident.quoted else ident.this.upper()
+    else:
+        raise ValueError(f"Invalid identifier type {ident.__class__.__name__} for stage name")
+    now = datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+    is_temp = False
+    url = ""
+    properties = expression.args.get("properties") or []
+    for prop in properties:
+        if isinstance(prop, exp.TemporaryProperty):
+            is_temp = True
+        elif (
+            isinstance(prop, exp.Property)
+            and isinstance(prop.this, exp.Var)
+            and isinstance(prop.this.this, str)
+            and prop.this.this.upper() == "URL"
+        ):
+            value = prop.args.get("value")
+            if isinstance(value, exp.Literal):
+                url = value.this
+
+    # Determine cloud provider based on url
+    cloud = "AWS" if url.startswith("s3://") else None
+
+    stage_type = ("EXTERNAL" if url else "INTERNAL") + (" TEMPORARY" if is_temp else "")
+    stage_name_value = stage_name if stage_name == "?" else repr(stage_name)
+
+    insert_sql = f"""
+        INSERT INTO _fs_global._fs_information_schema._fs_stages
+        (created_on, name, database_name, schema_name, url, has_credentials, has_encryption_key, owner,
+        comment, region, type, cloud, notification_channel, storage_integration, endpoint, owner_role_type,
+        directory_enabled)
+        VALUES (
+            '{now}', {stage_name_value}, '{catalog}', '{schema}', '{url}', 'N', 'N', 'SYSADMIN',
+            '', NULL, '{stage_type}', {f"'{cloud}'" if cloud else "NULL"}, NULL, NULL, NULL, 'ROLE',
+            'N'
+        )
+        """
+    transformed = sqlglot.parse_one(insert_sql, read="duckdb")
+    transformed.args["stage_name"] = stage_name
+    return transformed

fakesnow/transforms/transforms.py

@@ -530,8 +530,11 @@ def identifier(expression: exp.Expression) -> exp.Expression:
         and isinstance(expression.this, str)
         and expression.this.upper() == "IDENTIFIER"
     ):
-        expression = exp.Identifier(this=expression.expressions[0].this, quoted=False)
-
+        arg = expression.expressions[0]
+        # ? is parsed as exp.Placeholder
+        if isinstance(arg, exp.Placeholder):
+            return arg
+        return exp.Identifier(this=arg.this, quoted=False)
     return expression
 
 
@@ -569,20 +572,20 @@ def indices_to_json_extract(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-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.
+def information_schema_fs(expression: exp.Expression) -> exp.Expression:
+    """Redirects for
+    * _FS_COLUMNS view which has character_maximum_length or character_octet_length.
+    * _FS_TABLES to access additional metadata columns (eg: comment).
+    * _FS_VIEWS to return Snowflake's version instead of duckdb's
+    * _FS_LOAD_HISTORY table which duckdb doesn't have.
     """
 
     if (
         isinstance(expression, exp.Table)
-        and expression.db
         and expression.db.upper() == "INFORMATION_SCHEMA"
-        and expression.name
-        and expression.name.upper() == "COLUMNS"
+        and expression.name.upper() in {"COLUMNS", "TABLES", "VIEWS", "LOAD_HISTORY"}
     ):
-        expression.set("this", exp.Identifier(this="_FS_COLUMNS", quoted=False))
+        expression.set("this", exp.Identifier(this=f"_FS_{expression.name.upper()}", quoted=False))
         expression.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
 
     return expression
@@ -607,38 +610,6 @@ def information_schema_databases(
     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 := expression.find(exp.Table))
-        and tbl.db.upper() == "INFORMATION_SCHEMA"
-        and tbl.name.upper() == "TABLES"
-    ):
-        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 _FS_VIEWS to return Snowflake's version instead of duckdb's."""
-
-    if (
-        isinstance(expression, exp.Select)
-        and (tbl := expression.find(exp.Table))
-        and tbl.db.upper() == "INFORMATION_SCHEMA"
-        and tbl.name.upper() == "VIEWS"
-    ):
-        tbl.set("this", exp.Identifier(this="_FS_VIEWS", quoted=False))
-        tbl.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
-
-    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)),

fakesnow/variables.py

@@ -62,7 +62,9 @@ class Variables:
         for name, value in self._variables.items():
             sql = re.sub(rf"\${name}", value, sql, flags=re.IGNORECASE)
 
-        if remaining_variables := re.search(r"(?<!\$)\$\w+", sql):
+        # Only treat $<word> (not $<number>) as session variables,
+        # ignore identifiers containing $
+        if remaining_variables := re.search(r"(?<![\$\w])\$(?!\d+)\w+", sql):
             raise snowflake.connector.errors.ProgrammingError(
                 msg=f"Session variable '{remaining_variables.group().upper()}' does not exist"
             )

{fakesnow-0.9.37.dist-info → fakesnow-0.9.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakesnow
-Version: 0.9.37
+Version: 0.9.39
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004

{fakesnow-0.9.37.dist-info → fakesnow-0.9.39.dist-info}/RECORD

@@ -1,32 +1,33 @@
 fakesnow/__init__.py,sha256=71Rk_3s_4eTDCi7-bbo-xT71WN0E0MAPf5qjsguIeJU,5117
 fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
 fakesnow/arrow.py,sha256=XjTpFyLrD9jULWOtPgpr0RyNMmO6a5yi82y6ivi2CCI,4884
-fakesnow/checks.py,sha256=be-xo0oMoAUVhlMDCu1_Rkoh_L8p_p8qo9P6reJSHIQ,2874
+fakesnow/checks.py,sha256=bOJPMp46AvjJV_bXXjx2njO2dXNjffLrznwRuKyYZ4g,2889
 fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
 fakesnow/conn.py,sha256=diCwcjaCBrlCn9PyjbScfIQTNQjqiPTkQanUTqcvblE,6009
 fakesnow/converter.py,sha256=wPOfsFXIUJNJSx5oFNAxh13udxmAVIIHsLK8BiGkXGA,1635
-fakesnow/copy_into.py,sha256=JT4SpynozlcdmWwzlQwwncPiuHCE5UUv-XGX_CI9s90,7235
-fakesnow/cursor.py,sha256=so8OET_ZLlvRyxanKORfGU8gSiIa71FKILsS45lh0cE,22287
+fakesnow/copy_into.py,sha256=CRqAK5CUz9xYSwP9PZJpVxUz8KT9ZZpsCRQEuEEVSbM,14832
+fakesnow/cursor.py,sha256=xDKvet679VnICUxbDCfRnT8K9Q03Tii948_3XD2YFnk,22954
 fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
 fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
 fakesnow/fixtures.py,sha256=2rj0MTZlaZc4PNWhaqC5IiiLa7E9G0QZT3g45YawsL0,633
-fakesnow/info_schema.py,sha256=AYmTIHxk5Y6xdMTgttgBL1V0VO8qiM2T1-gKwkLmWDs,8720
+fakesnow/info_schema.py,sha256=lqEYD5aWK2MamjALbj6ct7pz_1yyAq3tAk51kLa8NKk,9872
 fakesnow/instance.py,sha256=OKoYXwaI6kL9HQpnHx44yzpON_xNfuIT_F4oJNF_XXQ,2114
 fakesnow/logger.py,sha256=U6EjUENQuTrDeNYqER2hxazoySmXzLmZJ-t-SDZgjkg,363
 fakesnow/macros.py,sha256=bQfZR5ptO4Gk-8fFRK2iksqYWkJUT8e-rPp-000qzu0,999
 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=RHf7ffKYi5xBH9fh8wZr3tEPmnzFWuvUbziCC8UwTh4,6652
-fakesnow/variables.py,sha256=C3y_9u7LuVtARkpcim3ihgVWg6KKdz1hSVeW4YI7oL4,3014
-fakesnow/transforms/__init__.py,sha256=jHbn7T6fSxhiu3KVn_Xupi5JwgY9SbjcfGU-0WpdELU,2769
+fakesnow/server.py,sha256=WyLU_4zcqQHLcvilQbNeavwRLVRQLm7n8NmtHJHzjqY,6687
+fakesnow/variables.py,sha256=BGnD4LAdVByfJ2GXL6qpGBaTF8ZJRjt3pdJsd9sIAcw,3134
+fakesnow/transforms/__init__.py,sha256=ZT0ehX8F1PPUY1983RjVofJ5spPE2syen5henc2m1Sk,2722
 fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
-fakesnow/transforms/show.py,sha256=0NjuLQjodrukfUw8mcxcAmtBkV_6r02mA3nuE3ad3rE,17458
-fakesnow/transforms/transforms.py,sha256=kjkQGTSkZ5lOJ-G13WQL4uB4yTzoIcsa3qcgBAgPH0c,47985
-fakesnow-0.9.37.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow/transforms/show.py,sha256=ejvs9S2l2Wcal4fhnNSVs3JkZwKsFxMEU35ufUV3-kg,20421
+fakesnow/transforms/stage.py,sha256=jkabKkxFEYjTVuLsDH3fgjyhFdc_GGh3DavWv7G7k68,2560
+fakesnow/transforms/transforms.py,sha256=I2X7KZ5wphq1NJvfbFmY8JYE-8vpVHMn-KTXurMxouE,47149
+fakesnow-0.9.39.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
 tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.37.dist-info/METADATA,sha256=6tfEtq0EvcWJEor8o4E-XgwkpO-gd5rh2o6EZ7BqRcc,20680
-fakesnow-0.9.37.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-fakesnow-0.9.37.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.37.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.37.dist-info/RECORD,,
+fakesnow-0.9.39.dist-info/METADATA,sha256=IlCT__J_g9f5ltb3eC7t0cUs5t3Aq0BaX4eNcKkxCYE,20680
+fakesnow-0.9.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fakesnow-0.9.39.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.39.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
+fakesnow-0.9.39.dist-info/RECORD,,

{fakesnow-0.9.37.dist-info → fakesnow-0.9.39.dist-info}/WHEEL

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