fakesnow 0.9.41__py3-none-any.whl → 0.9.43__py3-none-any.whl

fakesnow/copy_into.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import datetime
+import os
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import Any, NamedTuple, Protocol, cast
+from pathlib import Path
+from typing import Any, NamedTuple, Protocol, Union, cast
 from urllib.parse import urlparse, urlunparse
 
 import duckdb
@@ -13,6 +15,9 @@ from sqlglot import exp
 
 import fakesnow.transforms.stage as stage
 from fakesnow import logger
+from fakesnow.params import MutableParams, pop_qmark_param
+
+Params = Union[Sequence[Any], dict[Any, Any]]
 
 
 class LoadHistoryRecord(NamedTuple):
@@ -38,9 +43,9 @@ def copy_into(
     current_database: str | None,
     current_schema: str | None,
     expr: exp.Copy,
-    params: Sequence[Any] | dict[Any, Any] | None = None,
+    params: MutableParams | None = None,
 ) -> str:
-    cparams = _params(expr)
+    cparams = _params(expr, params)
     if isinstance(cparams.file_format, ReadParquet):
         from_ = expr.args["files"][0]
         # parquet must use MATCH_BY_COLUMN_NAME (TODO) or a copy transformation
@@ -54,11 +59,15 @@ def copy_into(
 
     from_source = _from_source(expr)
     source = (
-        stage_url_from_var(from_source, duck_conn, current_database, current_schema)
+        stage_url_from_var(from_source[1:], duck_conn, current_database, current_schema)
         if from_source.startswith("@")
         else from_source
     )
-    urls = _source_urls(source, cparams.files)
+    urls = _source_urls(source, cparams.files) if cparams.files else _source_glob(source, duck_conn)
+    if not urls:
+        sql = "SELECT 'Copy executed with 0 files processed.' AS status"
+        duck_conn.execute(sql)
+        return sql
 
     inserts = _inserts(expr, cparams, urls)
     table = expr.this
@@ -95,6 +104,10 @@ def copy_into(
                 error_limit = 1
                 error_count = 0
                 first_error_message = None
+                path = urlparse(url).path
+                if cparams.purge and stage.is_internal(path):
+                    # If the file is internal, we can remove it from the stage
+                    os.remove(path)
 
             history = LoadHistoryRecord(
                 schema_name=schema,
@@ -123,7 +136,7 @@ def copy_into(
             "first_error_character, first_error_column_name"
         )
         values = "\n, ".join(
-            f"('{h.file_name}', '{h.status}', {h.row_parsed}, {h.row_count}, "
+            f"('{_result_file_name(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'}, "
@@ -132,6 +145,7 @@ def copy_into(
         )
         sql = f"SELECT * FROM (VALUES\n  {values}\n) AS t({columns})"
         duck_conn.execute(sql)
+
         return sql
     except duckdb.HTTPException as e:
         raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=91016, sqlstate="22000") from None
@@ -139,13 +153,23 @@ def copy_into(
         raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=100038, sqlstate="22018") from None
 
 
-def _params(expr: exp.Copy) -> Params:
+def _result_file_name(url: str) -> str:
+    if not stage.is_internal(urlparse(url).path):
+        return url
+
+    # for internal stages, return the stage name lowered + file name
+    parts = url.split("/")
+    return f"{parts[-2].lower()}/{parts[-1]}"
+
+
+def _params(expr: exp.Copy, params: MutableParams | None = None) -> CopyParams:
     kwargs = {}
     force = False
+    purge = False
+    on_error = "ABORT_STATEMENT"
 
-    params = cast(list[exp.CopyParameter], expr.args.get("params", []))
-    cparams = Params()
-    for param in params:
+    cparams = CopyParams()
+    for param in cast(list[exp.CopyParameter], expr.args.get("params", [])):
         assert isinstance(param.this, exp.Var), f"{param.this.__class__} is not a Var"
         var = param.this.name.upper()
         if var == "FILE_FORMAT":
@@ -166,10 +190,22 @@ def _params(expr: exp.Copy) -> Params:
             force = True
         elif var == "FILES":
             kwargs["files"] = [lit.name for lit in param.find_all(exp.Literal)]
+        elif var == "PURGE":
+            purge = True
+        elif var == "ON_ERROR":
+            if isinstance(param.expression, exp.Var):
+                on_error = param.expression.name.upper()
+            elif isinstance(param.expression, exp.Placeholder):
+                on_error = pop_qmark_param(params, expr, param.expression)
+            else:
+                raise NotImplementedError(f"{param.expression.__class__=}")
+
+            if not (isinstance(on_error, str) and on_error.upper() == "ABORT_STATEMENT"):
+                raise NotImplementedError(param)
         else:
             raise ValueError(f"Unknown copy parameter: {param.this}")
 
-    return Params(force=force, **kwargs)
+    return CopyParams(force=force, purge=purge, on_error=on_error, **kwargs)
 
 
 def _from_source(expr: exp.Copy) -> str:
@@ -191,6 +227,9 @@ def _from_source(expr: exp.Copy) -> str:
             )
         # return the name of the stage, eg: @stage1
         return var.this
+    elif isinstance(from_, exp.Var):
+        # return the name of the stage, eg: @stage1
+        return from_.this
 
     assert isinstance(from_, exp.Literal), f"{from_} is not a exp.Literal"
     # return url
@@ -198,9 +237,9 @@ def _from_source(expr: exp.Copy) -> str:
 
 
 def stage_url_from_var(
-    from_source: str, duck_conn: DuckDBPyConnection, current_database: str | None, current_schema: str | None
+    var: str, duck_conn: DuckDBPyConnection, current_database: str | None, current_schema: str | None
 ) -> str:
-    database_name, schema_name, name = stage.parts_from_var(from_source, current_database, current_schema)
+    database_name, schema_name, name = stage.parts_from_var(var, current_database, current_schema)
 
     # Look up the stage URL
     duck_conn.execute(
@@ -211,7 +250,9 @@ def stage_url_from_var(
         (database_name, schema_name, name),
     )
     if result := duck_conn.fetchone():
-        return result[0]
+        # if no URL is found, it is an internal stage ie: local directory
+        url = result[0] or stage.internal_dir(f"{database_name}.{schema_name}.{name}")
+        return url
     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
@@ -220,16 +261,29 @@ def stage_url_from_var(
         )
 
 
-def _source_urls(from_source: str, files: list[str]) -> list[str]:
+def _source_urls(source: str, files: list[str]) -> list[str]:
     """Convert from_source to a list of URLs."""
-    scheme, netloc, path, params, query, fragment = urlparse(from_source)
+    scheme, netloc, path, params, query, fragment = urlparse(source)
     if not scheme:
         raise snowflake.connector.errors.ProgrammingError(
-            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{from_source}'", errno=1011, sqlstate="42601"
+            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{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 [from_source]
+    return [_urlunparse(scheme, netloc, path, params, query, fragment, file) for file in files] or [source]
+
+
+def _source_glob(source: str, duck_conn: DuckDBPyConnection) -> list[str]:
+    """List files from the source using duckdb glob."""
+    if stage.is_internal(source):
+        source = Path(source).as_uri()  # convert local directory to a file URL
+
+    scheme, _netloc, _path, _params, _query, _fragment = urlparse(source)
+    glob = f"{source}/*" if scheme == "file" else f"{source}*"
+    sql = f"SELECT file FROM glob('{glob}')"
+    logger.log_sql(sql)
+    result = duck_conn.execute(sql).fetchall()
+    return [r[0] for r in result]
 
 
 def _urlunparse(scheme: str, netloc: str, path: str, params: str, query: str, fragment: str, suffix: str) -> str:
@@ -245,7 +299,7 @@ def _urlunparse(scheme: str, netloc: str, path: str, params: str, query: str, fr
     return urlunparse((scheme, netloc, path, params, query, fragment))
 
 
-def _inserts(expr: exp.Copy, params: Params, urls: list[str]) -> list[exp.Expression]:
+def _inserts(expr: exp.Copy, params: CopyParams, urls: list[str]) -> list[exp.Expression]:
     # INTO expression
     target = expr.this
 
@@ -331,10 +385,8 @@ class ReadCSV(FileTypeHandler):
     delimiter: str = ","
 
     def read_expression(self, url: str) -> exp.Expression:
-        args = []
-
         # don't parse header and use as column names, keep them as column0, column1, etc
-        args.append(self.make_eq("header", False))
+        args = [self.make_eq("header", False)]
 
         if self.skip_header:
             args.append(self.make_eq("skip", 1))
@@ -357,8 +409,10 @@ class ReadParquet(FileTypeHandler):
 
 
 @dataclass
-class Params:
+class CopyParams:
     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
+    purge: bool = False
+    on_error: str = "ABORT_STATEMENT"  # Default to ABORT_STATEMENT

fakesnow/cursor.py

@@ -27,7 +27,9 @@ import fakesnow.info_schema as info_schema
 import fakesnow.transforms as transforms
 from fakesnow import logger
 from fakesnow.copy_into import copy_into
+from fakesnow.params import MutableParams
 from fakesnow.rowtype import describe_as_result_metadata
+from fakesnow.transforms import stage
 
 if TYPE_CHECKING:
     # don't require pandas at import time
@@ -41,6 +43,7 @@ SCHEMA_UNSET = "schema_unset"
 SQL_SUCCESS = "SELECT 'Statement executed successfully.' as 'status'"
 SQL_CREATED_DATABASE = Template("SELECT 'Database ${name} successfully created.' as 'status'")
 SQL_CREATED_SCHEMA = Template("SELECT 'Schema ${name} successfully created.' as 'status'")
+SQL_CREATED_SECRET = Template("SELECT 'Secret ${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")
@@ -146,7 +149,8 @@ class FakeSnowflakeCursor:
             self._sqlstate = None
 
             if os.environ.get("FAKESNOW_DEBUG") == "snowflake":
-                print(f"{command};{params=}" if params else f"{command};", file=sys.stderr)
+                p = params or kwargs.get("binding_params")
+                print(f"{command};params={p}" if p else f"{command};", file=sys.stderr)
 
             command = self._inline_variables(command)
             if kwargs.get("binding_params"):
@@ -155,6 +159,10 @@ class FakeSnowflakeCursor:
             else:
                 command, params = self._rewrite_with_params(command, params)
 
+            # convert tuple to mutable list
+            if not isinstance(params, (list, dict)) and params is not None:
+                params = list(params)
+
             if self._conn.nop_regexes and any(re.match(p, command, re.IGNORECASE) for p in self._conn.nop_regexes):
                 transformed = transforms.SUCCESS_NOP
                 self._execute(transformed, params)
@@ -164,9 +172,12 @@ class FakeSnowflakeCursor:
             self.check_db_and_schema(expression)
 
             for exp in self._transform_explode(expression):
-                transformed = self._transform(exp)
+                transformed = self._transform(exp, params)
                 self._execute(transformed, params)
 
+            if not kwargs.get("server") and (put_stage_data := transformed.args.get("put_stage_data")):  # pyright: ignore[reportPossiblyUnboundVariable]
+                self._put_files(put_stage_data)
+
             return self
         except snowflake.connector.errors.ProgrammingError as e:
             self._sqlstate = e.sqlstate
@@ -180,6 +191,13 @@ class FakeSnowflakeCursor:
             msg = f"{e} not implemented. Please raise an issue via https://github.com/tekumara/fakesnow/issues/new"
             raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=9999, sqlstate="99999") from e
 
+    def _put_files(self, put_stage_data: stage.UploadCommandDict) -> None:
+        results = stage.upload_files(put_stage_data)
+        _df = pyarrow.Table.from_pylist(results)
+        self._duck_conn.execute("select * from _df")
+        self._arrow_table = self._duck_conn.fetch_arrow_table()
+        self._rowcount = self._arrow_table.num_rows
+
     def check_db_and_schema(self, expression: exp.Expression) -> None:
         no_database, no_schema = checks.is_unqualified_table_expression(expression)
 
@@ -198,9 +216,10 @@ class FakeSnowflakeCursor:
                 sqlstate="22000",
             )
 
-    def _transform(self, expression: exp.Expression) -> exp.Expression:
+    def _transform(self, expression: exp.Expression, params: MutableParams | None) -> exp.Expression:
         return (
-            expression.transform(transforms.upper_case_unquoted_identifiers)
+            expression.transform(lambda e: transforms.identifier(e, params))
+            .transform(transforms.upper_case_unquoted_identifiers)
             .transform(transforms.update_variables, variables=self._conn.variables)
             .transform(transforms.set_schema, current_database=self._conn.database)
             .transform(transforms.create_database, db_path=self._conn.db_path)
@@ -238,7 +257,6 @@ class FakeSnowflakeCursor:
             .transform(transforms.sample)
             .transform(transforms.array_size)
             .transform(transforms.random)
-            .transform(transforms.identifier)
             .transform(transforms.array_agg_within_group)
             .transform(transforms.array_agg)
             .transform(transforms.array_construct_etc)
@@ -264,7 +282,8 @@ class FakeSnowflakeCursor:
             .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))
-            .transform(lambda e: transforms.put_stage(e, self._conn.database, self._conn.schema))
+            .transform(lambda e: transforms.list_stage(e, self._conn.database, self._conn.schema))
+            .transform(lambda e: transforms.put_stage(e, self._conn.database, self._conn.schema, params))
         )
 
     def _transform_explode(self, expression: exp.Expression) -> list[exp.Expression]:
@@ -272,7 +291,7 @@ class FakeSnowflakeCursor:
         # Split transforms have limited support at the moment.
         return transforms.merge(expression)
 
-    def _execute(self, transformed: exp.Expression, params: Sequence[Any] | dict[Any, Any] | None = None) -> None:
+    def _execute(self, transformed: exp.Expression, params: MutableParams | None = None) -> None:
         self._arrow_table = None
         self._arrow_table_fetch_index = None
         self._rowcount = None
@@ -335,13 +354,26 @@ class FakeSnowflakeCursor:
             result_sql = SQL_CREATED_DATABASE.substitute(name=create_db_name)
 
         elif stage_name := transformed.args.get("create_stage_name"):
-            if stage_name == "?":
-                assert isinstance(params, (tuple, list)) and len(params) == 1, (
-                    "Expected single parameter for create_stage_name"
+            (affected_count,) = self._duck_conn.fetchall()[0]
+            if affected_count == 0:
+                raise snowflake.connector.errors.ProgrammingError(
+                    msg=f"SQL compilation error:\nObject '{stage_name}' already exists.",
+                    errno=2002,
+                    sqlstate="42710",
                 )
-                result_sql = SQL_CREATED_STAGE.substitute(name=params[0].upper())
-            else:
-                result_sql = SQL_CREATED_STAGE.substitute(name=stage_name.upper())
+            result_sql = SQL_CREATED_STAGE.substitute(name=stage_name)
+
+        elif stage_name := transformed.args.get("list_stage_name") or transformed.args.get("put_stage_name"):
+            if self._duck_conn.fetch_arrow_table().num_rows != 1:
+                raise snowflake.connector.errors.ProgrammingError(
+                    msg=f"SQL compilation error:\nStage '{stage_name}' does not exist or not authorized.",
+                    errno=2003,
+                    sqlstate="02000",
+                )
+            if transformed.args.get("list_stage_name"):
+                result_sql = stage.list_stage_files_sql(stage_name)
+            elif transformed.args.get("put_stage_name"):
+                result_sql = SQL_SUCCESS
 
         elif cmd == "INSERT":
             (affected_count,) = self._duck_conn.fetchall()[0]
@@ -365,8 +397,8 @@ class FakeSnowflakeCursor:
                 lambda e: transforms.describe_table(e, self._conn.database, self._conn.schema)
             ).sql(dialect="duckdb")
 
-        elif (eid := transformed.find(exp.Identifier, bfs=False)) and isinstance(eid.this, str):
-            ident = eid.this if eid.quoted else eid.this.upper()
+        elif eid := transformed.find(exp.Identifier, bfs=False):
+            ident = eid.name
             if cmd == "CREATE SCHEMA" and ident:
                 result_sql = SQL_CREATED_SCHEMA.substitute(name=ident)
 
@@ -389,6 +421,15 @@ class FakeSnowflakeCursor:
 
                 elif cmd == "DROP SCHEMA" and ident == self._conn.schema:
                     self._conn._schema = None  # noqa: SLF001
+        elif (
+            cmd == "CREATE"
+            and isinstance(transformed, exp.Command)
+            and isinstance(transformed.expression, str)
+            and transformed.expression.upper().startswith(" SECRET")
+        ):
+            match = re.search(r"SECRET\s+(\w+)\s*\(", transformed.expression, re.IGNORECASE)
+            secret_name = match[1].upper() if match else "UNKNOWN"
+            result_sql = SQL_CREATED_SECRET.substitute(name=secret_name)
 
         if table_comment := cast(tuple[exp.Table, str], transformed.args.get("table_comment")):
             # record table comment
@@ -415,18 +456,6 @@ class FakeSnowflakeCursor:
         self._rowcount = affected_count or self._arrow_table.num_rows
         self._sfqid = str(uuid.uuid4())
 
-        if stage_name := transformed.args.get("put_stage_name"):
-            if stage_name == "?":
-                assert isinstance(params, (tuple, list)) and len(params) == 1, (
-                    "Expected single parameter for put_stage_name"
-                )
-            if self._arrow_table.num_rows != 1:
-                raise snowflake.connector.errors.ProgrammingError(
-                    msg=f"SQL compilation error:\nStage '{stage_name}' does not exist or not authorized.",
-                    errno=2003,
-                    sqlstate="02000",
-                )
-
         self._last_sql = result_sql or sql
         self._last_params = None if result_sql else params
         self._last_transformed = transformed

fakesnow/expr.py

@@ -30,3 +30,14 @@ def key_command(expression: exp.Expression) -> str:
         key = expression.key.upper()
 
     return key
+
+
+def normalise_ident(name: str) -> str:
+    """
+    Strip double quotes if present else return uppercased.
+    Snowflake treats quoted identifiers as case-sensitive and un-quoted identifiers as case-insensitive
+    """
+    if name.startswith('"') and name.endswith('"'):
+        return name[1:-1]  # Strip quotes
+
+    return name.upper()

fakesnow/params.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any, Union
+
+from sqlglot import exp
+
+MutableParams = Union[list[Any], dict[Any, Any]]
+
+
+def pop_qmark_param(params: MutableParams | None, expr: exp.Expression, pl: exp.Placeholder) -> Any:  # noqa: ANN401
+    assert isinstance(params, list), "params must be provided as a list or tuple to resolve qmarks"
+    i = index_of_placeholder(expr, pl)
+    return params.pop(i)
+
+
+def index_of_placeholder(expr: exp.Expression, target: exp.Placeholder) -> int:
+    """Count the number of prior placeholders to determine the index.
+
+    Args:
+        expression (exp.Expression): The expression to search.
+        ph (exp.Placeholder): The placeholder to find.
+
+    Returns:
+        int: The index of the placeholder, or -1 if not found.
+    """
+    for index, ph in enumerate(expr.find_all(exp.Placeholder, bfs=False)):
+        if ph is target:
+            return index
+    return -1

fakesnow/server.py

@@ -18,6 +18,7 @@ from starlette.routing import Route
 
 from fakesnow.arrow import to_ipc, to_sf
 from fakesnow.converter import from_binding
+from fakesnow.expr import normalise_ident
 from fakesnow.fakes import FakeSnowflakeConnection
 from fakesnow.instance import FakeSnow
 from fakesnow.rowtype import describe_as_rowtype
@@ -39,8 +40,8 @@ class ServerError(Exception):
 
 
 async def login_request(request: Request) -> JSONResponse:
-    database = request.query_params.get("databaseName")
-    schema = request.query_params.get("schemaName")
+    database = (d := request.query_params.get("databaseName")) and normalise_ident(d)
+    schema = (s := request.query_params.get("schemaName")) and normalise_ident(s)
     body = await request.body()
     if request.headers.get("Content-Encoding") == "gzip":
         body = gzip.decompress(body)
@@ -64,7 +65,10 @@ async def login_request(request: Request) -> JSONResponse:
                     {"name": "AUTOCOMMIT", "value": True},
                     {"name": "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY", "value": 3600},
                 ],
-                "sessionInfo": {},
+                "sessionInfo": {
+                    "databaseName": database,
+                    "schemaName": schema,
+                },
             },
             "success": True,
         }
@@ -94,7 +98,7 @@ 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, binding_params=params)
+            cur = await run_in_threadpool(conn.cursor().execute, sql_text, binding_params=params, server=True)
             rowtype = describe_as_rowtype(cur._describe_last_sql())  # noqa: SLF001
 
             expr = cur._last_transformed  # noqa: SLF001
@@ -124,7 +128,7 @@ async def query_request(request: Request) -> JSONResponse:
             )
         except Exception as e:
             # we have a bug or use of an unsupported feature
-            msg = f"{sql_text=} Unhandled exception"
+            msg = f"{sql_text=} {params=} Unhandled exception"
             logger.error(msg, exc_info=e)
             # my guess at mimicking a 500 error as per https://docs.snowflake.com/en/developer-guide/sql-api/reference
             # and https://github.com/snowflakedb/gosnowflake/blob/8ed4c75ffd707dd712ad843f40189843ace683c4/restful.go#L318
@@ -147,6 +151,8 @@ async def query_request(request: Request) -> JSONResponse:
                     "total": cur._rowcount,  # noqa: SLF001
                     "queryId": cur.sfqid,
                     "queryResultFormat": "arrow",
+                    "finalDatabaseName": conn.database,
+                    "finalSchemaName": conn.schema,
                 },
                 "success": True,
             }

fakesnow/transforms/__init__.py

@@ -15,6 +15,7 @@ from fakesnow.transforms.show import (
 )
 from fakesnow.transforms.stage import (
     create_stage as create_stage,
+    list_stage as list_stage,
     put_stage as put_stage,
 )
 from fakesnow.transforms.transforms import (

fakesnow/transforms/show.py

@@ -62,9 +62,7 @@ def show_columns(
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-columns
     """
-    if not (
-        isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "COLUMNS"
-    ):
+    if not (isinstance(expression, exp.Show) and expression.name.upper() == "COLUMNS"):
         return expression
 
     scope_kind = expression.args.get("scope_kind")
@@ -139,7 +137,7 @@ def show_databases(expression: exp.Expression) -> exp.Expression:
 
     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":
+    if isinstance(expression, exp.Show) and expression.name.upper() == "DATABASES":
         return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_show_databases", read="duckdb")
 
     return expression
@@ -177,7 +175,7 @@ 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":
+    if isinstance(expression, exp.Show) and expression.name.upper() == "FUNCTIONS":
         return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_show_functions", read="duckdb")
 
     return expression
@@ -197,11 +195,7 @@ def show_keys(
     if kind == "FOREIGN":
         snowflake_kind = "IMPORTED"
 
-    if (
-        isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == f"{snowflake_kind} KEYS"
-    ):
+    if isinstance(expression, exp.Show) and expression.name.upper() == f"{snowflake_kind} KEYS":
         if kind == "FOREIGN":
             statement = f"""
                 SELECT
@@ -298,11 +292,7 @@ def show_procedures(expression: exp.Expression) -> exp.Expression:
 
     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"
-    ):
+    if isinstance(expression, exp.Show) and expression.name.upper() == "PROCEDURES":
         return sqlglot.parse_one(
             "SELECT * FROM _fs_global._fs_information_schema._fs_show_procedures",
             read="duckdb",
@@ -333,7 +323,7 @@ def show_schemas(expression: exp.Expression, current_database: str | None) -> ex
 
     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 isinstance(expression, exp.Show) and expression.name.upper() == "SCHEMAS":
         if (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
             database = ident.this
         else:
@@ -350,9 +340,7 @@ def show_schemas(expression: exp.Expression, current_database: str | None) -> ex
 
 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"
-    ):
+    if not (isinstance(expression, exp.Show) and expression.name.upper() == "STAGES"):
         return expression
 
     scope_kind = expression.args.get("scope_kind")
@@ -480,8 +468,7 @@ def show_tables_etc(
     """Transform SHOW OBJECTS/TABLES/VIEWS to a query against the _fs_information_schema views."""
     if not (
         isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and (show := expression.this.upper())
+        and (show := expression.name.upper())
         and show in {"OBJECTS", "TABLES", "VIEWS"}
     ):
         return expression
@@ -538,7 +525,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":
+    if isinstance(expression, exp.Show) and expression.name.upper() == "USERS":
         return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users", read="duckdb")
 
     return expression
@@ -593,11 +580,7 @@ def show_warehouses(expression: exp.Expression) -> exp.Expression:
 
     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"
-    ):
+    if isinstance(expression, exp.Show) and expression.name.upper() == "WAREHOUSES":
         return sqlglot.parse_one(SQL_SHOW_WAREHOUSES, read="duckdb")
 
     return expression

fakesnow/transforms/stage.py

@@ -1,18 +1,45 @@
 from __future__ import annotations
 
 import datetime
+import os
+import tempfile
+from pathlib import PurePath
+from typing import Any, TypedDict
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 
 import snowflake.connector.errors
 import sqlglot
+from snowflake.connector.file_util import SnowflakeFileUtil
 from sqlglot import exp
 
-LOCAL_BUCKET_PATH = "/tmp/fakesnow_bucket"
+from fakesnow.expr import normalise_ident
+from fakesnow.params import MutableParams
+
+# TODO: clean up temp files on exit
+LOCAL_BUCKET_PATH = tempfile.mkdtemp(prefix="fakesnow_bucket_")
+
+
+class StageInfoDict(TypedDict):
+    locationType: str
+    location: str
+    creds: dict[str, Any]
+
+
+class UploadCommandDict(TypedDict):
+    stageInfo: StageInfoDict
+    src_locations: list[str]
+    parallel: int
+    autoCompress: bool
+    sourceCompression: str
+    overwrite: bool
+    command: str
 
 
 def create_stage(
-    expression: exp.Expression, current_database: str | None, current_schema: str | None
+    expression: exp.Expression,
+    current_database: str | None,
+    current_schema: str | None,
 ) -> exp.Expression:
     """Transform CREATE STAGE to an INSERT statement for the fake stages table."""
     if not (
@@ -24,15 +51,17 @@ def create_stage(
     ):
         return expression
 
+    ident = table.this
+    if not isinstance(ident, exp.Identifier):
+        raise snowflake.connector.errors.ProgrammingError(
+            msg=f"SQL compilation error:\nInvalid identifier type {ident.__class__.__name__} for stage name.",
+            errno=1003,
+            sqlstate="42000",
+        )
+
     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")
+    stage_name = ident.this
     now = datetime.datetime.now(datetime.timezone.utc).isoformat()
 
     is_temp = False
@@ -55,17 +84,19 @@ def create_stage(
     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',
+        SELECT
+            '{now}', '{stage_name}', '{catalog}', '{schema}', '{url}', 'N', 'N', 'SYSADMIN',
             '', NULL, '{stage_type}', {f"'{cloud}'" if cloud else "NULL"}, NULL, NULL, NULL, 'ROLE',
             'N'
+        WHERE NOT EXISTS (
+            SELECT 1 FROM _fs_global._fs_information_schema._fs_stages
+            WHERE name = '{stage_name}' AND database_name = '{catalog}' AND schema_name = '{schema}'
         )
         """
     transformed = sqlglot.parse_one(insert_sql, read="duckdb")
@@ -73,10 +104,44 @@ def create_stage(
     return transformed
 
 
-# TODO: handle ?
+def list_stage(expression: exp.Expression, current_database: str | None, current_schema: str | None) -> exp.Expression:
+    """Transform LIST to list file system operation.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/list
+    """
+    if not (
+        isinstance(expression, exp.Alias)
+        and isinstance(expression.this, exp.Column)
+        and isinstance(expression.this.this, exp.Identifier)
+        and isinstance(expression.this.this.this, str)
+        and expression.this.this.this.upper() == "LIST"
+    ):
+        return expression
+
+    stage = expression.args["alias"].this
+    if not isinstance(stage, exp.Var):
+        raise ValueError(f"LIST command requires a stage name as a Var, got {stage}")
+
+    var = stage.text("this")
+    catalog, schema, stage_name = parts_from_var(var, current_database=current_database, current_schema=current_schema)
+
+    query = f"""
+        SELECT *
+        from _fs_global._fs_information_schema._fs_stages
+        where database_name = '{catalog}' and schema_name = '{schema}' and name = '{stage_name}'
+    """
+
+    transformed = sqlglot.parse_one(query, read="duckdb")
+    transformed.args["list_stage_name"] = f"{catalog}.{schema}.{stage_name}"
+    return transformed
 
 
-def put_stage(expression: exp.Expression, current_database: str | None, current_schema: str | None) -> exp.Expression:
+def put_stage(
+    expression: exp.Expression,
+    current_database: str | None,
+    current_schema: str | None,
+    params: MutableParams | None,
+) -> exp.Expression:
     """Transform PUT to a SELECT statement to locate the stage.
 
     See https://docs.snowflake.com/en/sql-reference/sql/put
@@ -90,14 +155,20 @@ def put_stage(expression: exp.Expression, current_database: str | None, current_
     target = expression.args["target"]
 
     assert isinstance(target, exp.Var), f"{target} is not a exp.Var"
-    var = target.text("this")
-    if not var.startswith("@"):
-        msg = f"SQL compilation error:\n{var} does not start with @"
+    this = target.text("this")
+    if this == "?":
+        if not (isinstance(params, list) and len(params) == 1):
+            raise NotImplementedError("PUT requires a single parameter for the stage name")
+        this = params.pop(0)
+    if not this.startswith("@"):
+        msg = f"SQL compilation error:\n{this} does not start with @"
         raise snowflake.connector.errors.ProgrammingError(
             msg=msg,
             errno=1003,
             sqlstate="42000",
         )
+    # strip leading @
+    var = this[1:]
     catalog, schema, stage_name = parts_from_var(var, current_database=current_database, current_schema=current_schema)
 
     query = f"""
@@ -107,12 +178,13 @@ def put_stage(expression: exp.Expression, current_database: str | None, current_
     """
 
     transformed = sqlglot.parse_one(query, read="duckdb")
-    transformed.args["put_stage_name"] = f"{catalog}.{schema}.{stage_name}"
+    fqname = f"{catalog}.{schema}.{stage_name}"
+    transformed.args["put_stage_name"] = fqname
     transformed.args["put_stage_data"] = {
         "stageInfo": {
             # use LOCAL_FS otherwise we need to mock S3 with HTTPS which requires a certificate
             "locationType": "LOCAL_FS",
-            "location": f"{LOCAL_BUCKET_PATH}/{stage_name}/",
+            "location": internal_dir(fqname),
             "creds": {},
         },
         "src_locations": [src_path],
@@ -127,19 +199,8 @@ def put_stage(expression: exp.Expression, current_database: str | None, current_
     return transformed
 
 
-def normalise_ident(name: str) -> str:
-    """
-    Strip double quotes if present else return uppercased.
-    Snowflake treats quoted identifiers as case-sensitive and un-quoted identifiers as case-insensitive
-    """
-    if name.startswith('"') and name.endswith('"'):
-        return name[1:-1]  # Strip quotes
-
-    return name.upper()
-
-
 def parts_from_var(var: str, current_database: str | None, current_schema: str | None) -> tuple[str, str, str]:
-    parts = var[1:].split(".")
+    parts = var.split(".")
     if len(parts) == 3:
         # Fully qualified name
         database_name, schema_name, name = parts
@@ -161,3 +222,62 @@ def parts_from_var(var: str, current_database: str | None, current_schema: str |
     name = normalise_ident(name)
 
     return database_name, schema_name, name
+
+
+def is_internal(s: str) -> bool:
+    return PurePath(s).is_relative_to(LOCAL_BUCKET_PATH)
+
+
+def internal_dir(fqname: str) -> str:
+    """
+    Given a fully qualified stage name, return the directory path where the stage files are stored.
+    """
+    catalog, schema, stage_name = fqname.split(".")
+    return f"{LOCAL_BUCKET_PATH}/{catalog}/{schema}/{stage_name}/"
+
+
+def list_stage_files_sql(stage_name: str) -> str:
+    """
+    Generate SQL to list files in a stage directory, matching Snowflake's LIST output format.
+    """
+    sdir = internal_dir(stage_name)
+    return f"""
+        select
+            lower(split_part(filename, '/', -2)) || '/' || split_part(filename, '/', -1) AS name,
+            size,
+            md5(content) as md5,
+            strftime(last_modified, '%a, %d %b %Y %H:%M:%S GMT') as last_modified
+        from read_blob('{sdir}/*')
+    """
+
+
+def upload_files(put_stage_data: UploadCommandDict) -> list[dict[str, Any]]:
+    results = []
+    for src in put_stage_data["src_locations"]:
+        basename = os.path.basename(src)
+        stage_dir = put_stage_data["stageInfo"]["location"]
+
+        os.makedirs(stage_dir, exist_ok=True)
+        gzip_file_name, target_size = SnowflakeFileUtil.compress_file_with_gzip(src, stage_dir)
+
+        # Rename to match expected .gz extension on upload
+        target_basename = basename + ".gz"
+        target = os.path.join(stage_dir, target_basename)
+        os.replace(gzip_file_name, target)
+
+        target_size = os.path.getsize(target)
+        source_size = os.path.getsize(src)
+
+        results.append(
+            {
+                "source": basename,
+                "target": target_basename,
+                "source_size": source_size,
+                "target_size": target_size,
+                "source_compression": "NONE",
+                "target_compression": "GZIP",
+                "status": "UPLOADED",
+                "message": "",
+            }
+        )
+    return results

fakesnow/transforms/transforms.py

@@ -7,6 +7,7 @@ from typing import ClassVar, cast
 import sqlglot
 from sqlglot import exp
 
+from fakesnow.params import MutableParams, pop_qmark_param
 from fakesnow.variables import Variables
 
 SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.' as status")
@@ -230,7 +231,7 @@ def describe_table(
         catalog = table.catalog or current_database
         schema = table.db or current_schema
 
-        if schema and schema.upper() == "_FS_INFORMATION_SCHEMA":
+        if schema == "_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")
@@ -537,22 +538,47 @@ def float_to_double(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def identifier(expression: exp.Expression) -> exp.Expression:
-    """Convert identifier function to an identifier.
+def identifier(expression: exp.Expression, params: MutableParams | None) -> exp.Expression:
+    """Convert identifier function to an identifier or table.
 
     See https://docs.snowflake.com/en/sql-reference/identifier-literal
     """
 
     if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "IDENTIFIER"
+        isinstance(expression, exp.Table)
+        and isinstance(expression.this, exp.Anonymous)
+        and isinstance(expression.this.this, str)
+        and expression.this.this.upper() == "IDENTIFIER"
     ):
-        arg = expression.expressions[0]
+        arg = expression.this.expressions[0]
+
         # ? is parsed as exp.Placeholder
-        if isinstance(arg, exp.Placeholder):
-            return arg
-        return exp.Identifier(this=arg.this, quoted=False)
+        val: str = pop_qmark_param(params, arg.root(), arg) if isinstance(arg, exp.Placeholder) else arg.this
+
+        # If the whole identifier is quoted, treat as a single quoted identifier inside a Table node
+        if val.startswith('"') and val.endswith('"'):
+            return exp.Table(this=exp.Identifier(this=val[1:-1], quoted=True))
+
+        # Split a dotted identifier string into parts, identifying and stripping quoted segments
+        parts = [(p[1:-1], True) if p.startswith('"') and p.endswith('"') else (p, False) for p in val.split(".")]
+        if len(parts) == 1:
+            return exp.Table(this=exp.Identifier(this=parts[0][0], quoted=parts[0][1]))
+        elif len(parts) == 2:
+            # db.table
+            return exp.Table(
+                this=exp.Identifier(this=parts[1][0], quoted=parts[1][1]),
+                db=exp.Identifier(this=parts[0][0], quoted=parts[0][1]),
+            )
+        elif len(parts) == 3:
+            # catalog.db.table
+            return exp.Table(
+                this=exp.Identifier(this=parts[2][0], quoted=parts[2][1]),
+                db=exp.Identifier(this=parts[1][0], quoted=parts[1][1]),
+                catalog=exp.Identifier(this=parts[0][0], quoted=parts[0][1]),
+            )
+        else:
+            # fallback: treat as a single identifier
+            return exp.Table(this=exp.Identifier(this=val, quoted=False))
     return expression
 
 
@@ -600,10 +626,10 @@ def information_schema_fs(expression: exp.Expression) -> exp.Expression:
 
     if (
         isinstance(expression, exp.Table)
-        and expression.db.upper() == "INFORMATION_SCHEMA"
-        and expression.name.upper() in {"COLUMNS", "TABLES", "VIEWS", "LOAD_HISTORY"}
+        and expression.db == "INFORMATION_SCHEMA"
+        and expression.name in {"COLUMNS", "TABLES", "VIEWS", "LOAD_HISTORY"}
     ):
-        expression.set("this", exp.Identifier(this=f"_FS_{expression.name.upper()}", quoted=False))
+        expression.set("this", exp.Identifier(this=f"_FS_{expression.name}", quoted=False))
         expression.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
 
     return expression
@@ -615,11 +641,8 @@ def information_schema_databases(
 ) -> 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"
+        and (expression.db == "INFORMATION_SCHEMA" or (current_schema and current_schema == "INFORMATION_SCHEMA"))
+        and expression.name == "DATABASES"
     ):
         return exp.Table(
             this=exp.Identifier(this="DATABASES", quoted=False),
@@ -978,11 +1001,7 @@ def to_date(expression: exp.Expression) -> exp.Expression:
         exp.Expression: The transformed expression.
     """
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "TO_DATE"
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() == "TO_DATE":
         return exp.Cast(
             this=expression.expressions[0],
             to=exp.DataType(this=exp.DataType.Type.DATE, nested=False, prefix=False),
@@ -1066,11 +1085,7 @@ def to_decimal(expression: exp.Expression) -> exp.Expression:
             to=exp.DataType(this=exp.DataType.Type.DECIMAL, expressions=[precision, scale], nested=False, prefix=False),
         )
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() in ["TO_DECIMAL", "TO_NUMERIC"]
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() in ["TO_DECIMAL", "TO_NUMERIC"]:
         return _to_decimal(expression, exp.Cast)
 
     return expression
@@ -1081,11 +1096,11 @@ def try_to_decimal(expression: exp.Expression) -> exp.Expression:
     See https://docs.snowflake.com/en/sql-reference/functions/try_to_decimal
     """
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() in ["TRY_TO_DECIMAL", "TRY_TO_NUMBER", "TRY_TO_NUMERIC"]
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() in [
+        "TRY_TO_DECIMAL",
+        "TRY_TO_NUMBER",
+        "TRY_TO_NUMERIC",
+    ]:
         return _to_decimal(expression, exp.TryCast)
 
     return expression
@@ -1111,9 +1126,7 @@ def to_timestamp_ntz(expression: exp.Expression) -> exp.Expression:
     Because it's not yet supported by sqlglot, see https://github.com/tobymao/sqlglot/issues/2748
     """
 
-    if isinstance(expression, exp.Anonymous) and (
-        isinstance(expression.this, str) and expression.this.upper() == "TO_TIMESTAMP_NTZ"
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() == "TO_TIMESTAMP_NTZ":
         return exp.StrToTime(
             this=expression.expressions[0],
             format=exp.Literal(this="%Y-%m-%d %H:%M:%S", is_string=True),
@@ -1164,11 +1177,7 @@ def try_parse_json(expression: exp.Expression) -> exp.Expression:
         exp.Expression: The transformed expression.
     """
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "TRY_PARSE_JSON"
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() == "TRY_PARSE_JSON":
         expressions = expression.expressions
         return exp.TryCast(
             this=expressions[0],

{fakesnow-0.9.41.dist-info → fakesnow-0.9.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakesnow
-Version: 0.9.41
+Version: 0.9.43
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -420,7 +420,7 @@ Fully supported:
 - Multiple databases
 - [Parameter binding](https://docs.snowflake.com/en/user-guide/python-connector-example#binding-data) in queries
 - Table comments
-- Pandas integration including [write_pandas(..)](https://docs.snowflake.com/en/user-guide/python-connector-api#write_pandas) (not available via the server yet)
+- Pandas integration including [write_pandas(..)](https://docs.snowflake.com/en/user-guide/python-connector-api#write_pandas)
 - Result batch retrieval via [get_result_batches()](https://docs.snowflake.com/en/user-guide/python-connector-api#get_result_batches)
 - HTTP server for non-Python connectors
 
@@ -431,7 +431,8 @@ Partially supported:
 - Semi-structured data operations
 - Tags
 - User management
-- `COPY INTO` from S3 sources, see [COPY INTO](#copy-into)
+- Stages and PUT
+- `COPY INTO` from S3 sources and stages, see [COPY INTO](#copy-into)
 
 Not yet implemented:
 
@@ -447,7 +448,7 @@ For more detail see the [test suite](tests/).
 
 ## COPY INTO
 
-`COPY INTO` can be used from S3 sources. By default the standard AWS credential chain will be used. If you are getting an HTTP 403 or need to provide alternative S3 credentials you can use the duckdb [CREATE SECRET](https://duckdb.org/docs/stable/extensions/httpfs/s3api) statement. For an example of creating a secret to use a moto S3 endpoint see `s3_client` in [conftest.py](tests/conftest.py#L80)
+`COPY INTO` can be used from S3 sources and stages. By default the standard AWS credential chain will be used. If you are getting an HTTP 403 or need to provide alternative S3 credentials you can use the duckdb [CREATE SECRET](https://duckdb.org/docs/stable/extensions/httpfs/s3api) statement. For an example of creating a secret to use a moto S3 endpoint see `s3_client` in [conftest.py](tests/conftest.py#L80)
 
 ## Contributing
 

{fakesnow-0.9.41.dist-info → fakesnow-0.9.43.dist-info}/RECORD

@@ -5,9 +5,9 @@ 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=YIr5Bq3JwKOPYWm5t2QXUuFGxLL-1ioEXEumNjGbBvM,13648
-fakesnow/cursor.py,sha256=mOwyXnBFXp79nDh0vtbmxS_hmFNy4j7hPlskENWeIrI,23818
-fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
+fakesnow/copy_into.py,sha256=utlV03RWHdWblIlKs92Q__9BWHi_gvqT76RV6tEMWTo,16006
+fakesnow/cursor.py,sha256=A1jWLGkXzHcYbM0wFrbh2PiewzFFS7ZlfOm-x3AGHgg,25412
+fakesnow/expr.py,sha256=tLcHC-mx2O6-vCt77RVlRQa3CovqUdu4vc5WOSmuQdk,1231
 fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
 fakesnow/fixtures.py,sha256=2rj0MTZlaZc4PNWhaqC5IiiLa7E9G0QZT3g45YawsL0,633
 fakesnow/info_schema.py,sha256=lqEYD5aWK2MamjALbj6ct7pz_1yyAq3tAk51kLa8NKk,9872
@@ -15,19 +15,20 @@ fakesnow/instance.py,sha256=OKoYXwaI6kL9HQpnHx44yzpON_xNfuIT_F4oJNF_XXQ,2114
 fakesnow/logger.py,sha256=U6EjUENQuTrDeNYqER2hxazoySmXzLmZJ-t-SDZgjkg,363
 fakesnow/macros.py,sha256=lxtznTCYryjecFkwswbqWMzCVamDLWyQZRKWtkWCWEk,1397
 fakesnow/pandas_tools.py,sha256=wI203UQHC8JvDzxE_VjE1NeV4rThek2P-u52oTg2foo,3481
+fakesnow/params.py,sha256=Hp7tBiDycdOh8LuRoISsOZycD7DufDAMKyF_hqEjh6M,929
 fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
 fakesnow/rowtype.py,sha256=QUp8EaXD5LT0Xv8BXk5ze4WseEn52xoJ6R05pJjs5mM,2729
-fakesnow/server.py,sha256=PGNuYEpmI0L0ZrwBCP1pDTc_lnFrtfSnlZ6zyVuCTqk,7173
+fakesnow/server.py,sha256=NzhpVM_3L9QeG84bhn0_It6ABM9ifs1CYWPgKhWaOeE,7511
 fakesnow/variables.py,sha256=BGnD4LAdVByfJ2GXL6qpGBaTF8ZJRjt3pdJsd9sIAcw,3134
-fakesnow/transforms/__init__.py,sha256=OE-dunCuum8lv832s2cjEzThgBnpKELo5aaTXD_bMNg,2807
+fakesnow/transforms/__init__.py,sha256=3dpcXjeLkfc4e9rO0G8Mnv9zZgmwsKSwQ7UJeyLYnOg,2837
 fakesnow/transforms/merge.py,sha256=H2yYyzGsxjpggS6PY91rAUtYCFuOkBm8uGi0EO0r6T0,8375
-fakesnow/transforms/show.py,sha256=ejvs9S2l2Wcal4fhnNSVs3JkZwKsFxMEU35ufUV3-kg,20421
-fakesnow/transforms/stage.py,sha256=FSIyI5kpthD_pdbVfzYCrby5HaikMZUpdRr6oBSrgk4,6176
-fakesnow/transforms/transforms.py,sha256=t99pHmNm8aG89o738zVSXCG6a0dOXpnY1OqAz28EQHc,48072
-fakesnow-0.9.41.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow/transforms/show.py,sha256=NIJDkf4-ns4VTw0DQphEn2DnwxQjXyTU2wS9VSUh6Wc,19919
+fakesnow/transforms/stage.py,sha256=VRE122Twha1Dd7QC2rdAAWWG93OxIiJZv2DfvGSsMZ8,10047
+fakesnow/transforms/transforms.py,sha256=ykzay7J28MsifhRKhm5qJJd__hMcLNVZTT14MSdWcJs,49102
+fakesnow-0.9.43.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
 tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.41.dist-info/METADATA,sha256=cOvEP3Mo_H0yn37XeRPozuvwY6OS7tqDnleGP8Vgplg,20680
-fakesnow-0.9.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fakesnow-0.9.41.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.41.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.41.dist-info/RECORD,,
+fakesnow-0.9.43.dist-info/METADATA,sha256=tUAcWIfezqI1Lu64-sz8VToB4bFIyfaEFyOPCJpDREY,20684
+fakesnow-0.9.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fakesnow-0.9.43.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.43.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
+fakesnow-0.9.43.dist-info/RECORD,,