fakesnow 0.9.34__py3-none-any.whl → 0.9.36__py3-none-any.whl

fakesnow/__init__.py

@@ -91,3 +91,54 @@ def patch(
     finally:
         stack.close()
         fs.duck_conn.close()
+
+
+@contextmanager
+def server(port: int | None = None, session_parameters: dict[str, str | int | bool] | None = None) -> Iterator[dict]:
+    """Start a fake snowflake server in a separate thread and yield connection kwargs.
+
+    Args:
+        port (int | None, optional): Port to run the server on. If None, an available port is chosen. Defaults to None.
+
+    Yields:
+        Iterator[dict]: Connection parameters for the fake snowflake server.
+    """
+    import socket
+    import threading
+    from time import sleep
+
+    import uvicorn
+
+    import fakesnow.server
+
+    # find an unused TCP port between 1024-65535
+    if not port:
+        with contextlib.closing(socket.socket(type=socket.SOCK_STREAM)) as sock:
+            sock.bind(("127.0.0.1", 0))
+            port = sock.getsockname()[1]
+
+    assert port
+    server = uvicorn.Server(uvicorn.Config(fakesnow.server.app, port=port, log_level="info"))
+    thread = threading.Thread(target=server.run, name="Server", daemon=True)
+    thread.start()
+
+    while not server.started:
+        sleep(0.1)
+
+    try:
+        yield dict(
+            user="fake",
+            password="snow",
+            account="fakesnow",
+            host="localhost",
+            port=port,
+            protocol="http",
+            # disable telemetry
+            session_parameters={"CLIENT_OUT_OF_BAND_TELEMETRY_ENABLED": False} | (session_parameters or {}),
+            # disable retries on error
+            network_timeout=1,
+        )
+    finally:
+        server.should_exit = True
+        # wait for server thread to end
+        thread.join()

fakesnow/conn.py

@@ -6,8 +6,7 @@ from pathlib import Path
 from types import TracebackType
 from typing import Any
 
-import snowflake.connector.converter
-import snowflake.connector.errors
+import snowflake.connector
 import sqlglot
 from duckdb import DuckDBPyConnection
 from snowflake.connector.cursor import DictCursor, SnowflakeCursor

fakesnow/converter.py

@@ -4,7 +4,7 @@ import binascii
 import datetime
 from datetime import date, time, timezone
 
-# convert bindings provided as strings to the server into python types
+# convert server bindings from strings into python types
 
 
 def from_binding(binding: dict[str, str]) -> int | bytes | bool | date | time | datetime.datetime | str:

fakesnow/cursor.py

@@ -46,6 +46,12 @@ 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'")
 SQL_DELETED_ROWS = Template("SELECT ${count} as 'number of rows deleted'")
+SQL_COPY_ROWS = Template(
+    "SELECT '${file}' as file, 'LOADED' as status, ${count} as rows_parsed, "
+    "${count} as rows_loaded, 1 as error_limit, 0 as errors_seen, "
+    "NULL as first_error, NULL as first_error_line, NULL as first_error_character, "
+    "NULL as first_error_column_name"
+)
 
 
 class FakeSnowflakeCursor:
@@ -166,6 +172,9 @@ class FakeSnowflakeCursor:
             # strip highlight for better readability, TODO: show pointer to start of error
             msg = str(e).replace("\x1b[4m", "").replace("\x1b[0m", "")
             raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=1003, sqlstate="42000") from None
+        except NotImplementedError as e:
+            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 check_db_and_schema(self, expression: exp.Expression) -> None:
         no_database, no_schema = checks.is_unqualified_table_expression(expression)
@@ -238,7 +247,7 @@ 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_objects_tables(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))
             # TODO collapse into a single show_keys function
             .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="PRIMARY"))
@@ -246,6 +255,7 @@ class FakeSnowflakeCursor:
             .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="FOREIGN"))
             .transform(transforms.show_users)
             .transform(transforms.create_user)
+            .transform(transforms.copy_into)
             .transform(transforms.sha256)
             .transform(transforms.create_clone)
             .transform(transforms.alias_in_join)
@@ -297,6 +307,10 @@ class FakeSnowflakeCursor:
             raise snowflake.connector.errors.DatabaseError(msg=e.args[0], errno=250002, sqlstate="08003") from None
         except duckdb.ParserException as e:
             raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=1003, sqlstate="42000") from None
+        except duckdb.HTTPException as e:
+            raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=91016, sqlstate="22000") from None
+        except duckdb.ConversionException as e:
+            raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=100038, sqlstate="22018") from None
 
         affected_count = None
 
@@ -316,6 +330,10 @@ 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 copy_from := transformed.args.get("copy_from"):
+            (affected_count,) = self._duck_conn.fetchall()[0]
+            result_sql = SQL_COPY_ROWS.substitute(count=affected_count, file=copy_from)
+
         elif cmd == "INSERT":
             (affected_count,) = self._duck_conn.fetchall()[0]
             result_sql = SQL_INSERTED_ROWS.substitute(count=affected_count)
@@ -403,7 +421,7 @@ class FakeSnowflakeCursor:
     ) -> FakeSnowflakeCursor:
         if isinstance(seqparams, dict):
             # see https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-api
-            raise NotImplementedError("dict params not supported yet")
+            raise NotImplementedError("executemany dict params")
 
         # TODO: support insert optimisations
         # the snowflake connector will optimise inserts into a single query

fakesnow/fixtures.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterator
+from typing import Any
 
 import pytest
 
@@ -11,6 +12,12 @@ def _fakesnow() -> Iterator[None]:
         yield
 
 
+@pytest.fixture(scope="session")
+def fakesnow_server() -> Iterator[dict[str, Any]]:
+    with fakesnow.server() as conn_kwargs:
+        yield conn_kwargs
+
+
 @pytest.fixture
 def _fakesnow_no_auto_create() -> Iterator[None]:
     with fakesnow.patch(create_database_on_connect=False, create_schema_on_connect=False):

fakesnow/info_schema.py

@@ -34,8 +34,8 @@ create table if not exists _fs_global._fs_information_schema._fs_columns_ext (
 """
 
 # replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
-SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE_EXT = """
-create table if not exists _fs_global._fs_information_schema._fs_users_ext (
+SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE = """
+create table if not exists _fs_global._fs_information_schema._fs_users (
     name varchar,
     created_on TIMESTAMPTZ,
     login_name varchar,
@@ -196,13 +196,13 @@ def per_db_creation_sql(catalog: str) -> str:
     """
 
 
-def fs_global_creation_sql(catalog: str) -> str:
+def fs_global_creation_sql() -> str:
     return f"""
         {SQL_CREATE_GLOBAL_FS_INFORMATION_SCHEMA};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_TABLES_EXT};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_EXT};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_VIEW};
-        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE_EXT};
+        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE};
     """
 
 

fakesnow/instance.py

@@ -7,6 +7,7 @@ import duckdb
 
 import fakesnow.fakes as fakes
 from fakesnow import info_schema
+from fakesnow.transforms import show
 
 GLOBAL_DATABASE_NAME = "_fs_global"
 
@@ -28,8 +29,9 @@ class FakeSnow:
 
         # create a "global" database for storing objects which span databases.
         self.duck_conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
-        # create the info schema extensions
-        self.duck_conn.execute(info_schema.fs_global_creation_sql(GLOBAL_DATABASE_NAME))
+        # create the info schema extensions and show views
+        self.duck_conn.execute(info_schema.fs_global_creation_sql())
+        self.duck_conn.execute(show.fs_global_creation_sql())
 
         # use UTC instead of local time zone for consistent testing
         self.duck_conn.execute("SET GLOBAL TimeZone = 'UTC'")

fakesnow/server.py

@@ -59,7 +59,10 @@ async def login_request(request: Request) -> JSONResponse:
         {
             "data": {
                 "token": token,
-                "parameters": [{"name": "AUTOCOMMIT", "value": True}],
+                "parameters": [
+                    {"name": "AUTOCOMMIT", "value": True},
+                    {"name": "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY", "value": 3600},
+                ],
             },
             "success": True,
         }
@@ -78,12 +81,12 @@ async def query_request(request: Request) -> JSONResponse:
 
         sql_text = body_json["sqlText"]
 
-        params = None
-
         if bindings := body_json.get("bindings"):
-            # Convert parameters like {'1': {'type': 'FIXED', 'value': '1'}, ...} to tuple (1, ...)
+            # Convert parameters like {'1': {'type': 'FIXED', 'value': '10'}, ...} to tuple (10, ...)
             params = tuple(from_binding(bindings[str(pos)]) for pos in range(1, len(bindings) + 1))
             logger.debug(f"Bindings: {params}")
+        else:
+            params = None
 
         try:
             # only a single sql statement is sent at a time by the python snowflake connector
@@ -121,6 +124,9 @@ async def query_request(request: Request) -> JSONResponse:
         return JSONResponse(
             {
                 "data": {
+                    "parameters": [
+                        {"name": "TIMEZONE", "value": "Etc/UTC"},
+                    ],
                     "rowtype": rowtype,
                     "rowsetBase64": rowset_b64,
                     "total": cur._rowcount,  # noqa: SLF001

fakesnow/transforms/__init__.py

@@ -7,15 +7,16 @@ from typing import ClassVar, cast
 import sqlglot
 from sqlglot import exp
 
+from fakesnow.transforms.copy_into import copy_into as copy_into
 from fakesnow.transforms.merge import merge as merge
 from fakesnow.transforms.show import (
     show_columns as show_columns,
     show_databases as show_databases,
     show_functions as show_functions,
     show_keys as show_keys,
-    show_objects_tables as show_objects_tables,
     show_procedures as show_procedures,
     show_schemas as show_schemas,
+    show_tables_etc as show_tables_etc,
     show_users as show_users,
     show_warehouses as show_warehouses,
 )
@@ -837,7 +838,7 @@ def regex_replace(expression: exp.Expression) -> exp.Expression:
         if len(expression.args) > 3:
             # see https://docs.snowflake.com/en/sql-reference/functions/regexp_replace
             raise NotImplementedError(
-                "REGEXP_REPLACE with additional parameters (eg: <position>, <occurrence>, <parameters>) not supported"
+                "REGEXP_REPLACE with additional parameters (eg: <position>, <occurrence>, <parameters>)"
             )
 
         # pattern: snowflake requires escaping backslashes in single-quoted string constants, but duckdb doesn't
@@ -1316,9 +1317,9 @@ def create_user(expression: exp.Expression) -> exp.Expression:
         if sub_exp.upper().startswith("USER"):
             _, name, *ignored = sub_exp.split(" ")
             if ignored:
-                raise NotImplementedError(f"`CREATE USER` with {ignored} not yet supported")
+                raise NotImplementedError(f"`CREATE USER` with {ignored}")
             return sqlglot.parse_one(
-                f"INSERT INTO _fs_global._fs_information_schema._fs_users_ext (name) VALUES ('{name}')", read="duckdb"
+                f"INSERT INTO _fs_global._fs_information_schema._fs_users (name) VALUES ('{name}')", read="duckdb"
             )
 
     return expression

fakesnow/transforms/copy_into.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from pathlib import PurePath
+from typing import Protocol
+from urllib.parse import urlparse, urlunparse
+
+import snowflake.connector.errors
+from sqlglot import exp
+from typing_extensions import Self
+
+
+def copy_into(expr: exp.Expression) -> exp.Expression:
+    if not isinstance(expr, exp.Copy):
+        return expr
+
+    schema = expr.this
+
+    columns = [exp.Column(this=exp.Identifier(this=f"column{i}")) for i in range(len(schema.expressions))] or [
+        exp.Column(this=exp.Star())
+    ]
+
+    params = expr.args.get("params", [])
+    # TODO: remove columns
+    file_type_handler = _handle_params(params, [c.name for c in columns])
+
+    # the FROM expression
+    source = expr.args["files"][0].this
+    assert isinstance(source, exp.Literal), f"{source.__class__} is not a exp.Literal"
+
+    if len(file_type_handler.files) > 1:
+        raise NotImplementedError("Multiple files not currently supported")
+    file = file_type_handler.files[0]
+
+    scheme, netloc, path, params, query, fragment = urlparse(source.name)
+    if not scheme:
+        raise snowflake.connector.errors.ProgrammingError(
+            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{source.name}'", errno=1011, sqlstate="42601"
+        )
+    path = str(PurePath(path) / file.name)
+    url = urlunparse((scheme, netloc, path, params, query, fragment))
+
+    return exp.Insert(
+        this=schema,
+        expression=exp.Select(expressions=columns).from_(exp.Table(this=file_type_handler.read_expression(url))),
+        copy_from=url,
+    )
+
+
+def _handle_params(params: list[exp.CopyParameter], columns: list[str]) -> FileTypeHandler:
+    file_type_handler = None
+    force = False
+    files = []
+    for param in params:
+        var = param.this.name
+        if var == "FILE_FORMAT":
+            if file_type_handler:
+                raise ValueError(params)
+
+            var_type = next((e.args["value"].this for e in param.expressions if e.this.this == "TYPE"), None)
+            if not var_type:
+                raise NotImplementedError("FILE_FORMAT without TYPE is not currently implemented")
+
+            if var_type == "CSV":
+                file_type_handler = handle_csv(param.expressions, columns)
+            else:
+                raise NotImplementedError(f"{var_type} FILE_FORMAT is not currently implemented")
+
+        elif var == "FILES":
+            files = param.expression.expressions if isinstance(param.expression, exp.Tuple) else [param.expression.this]
+        elif var == "FORCE":
+            force = True
+            pass
+        else:
+            raise ValueError(f"Unknown copy parameter: {param.this}")
+
+    if not force:
+        raise NotImplementedError("COPY INTO with FORCE=false (default) is not currently implemented")
+
+    if not files:
+        raise NotImplementedError("COPY INTO without FILES is not currently implemented")
+
+    if not file_type_handler:
+        # default to CSV
+        file_type_handler = handle_csv([], columns)
+
+    file_type_handler = file_type_handler.with_files(files)
+    return file_type_handler
+
+
+def handle_csv(expressions: list[exp.Property], columns: list[str]) -> ReadCSV:
+    skip_header = ReadCSV.skip_header
+    quote = ReadCSV.quote
+    delimiter = ReadCSV.delimiter
+
+    for expression in expressions:
+        exp_type = expression.name
+        if exp_type in {"TYPE"}:
+            continue
+
+        elif exp_type == "SKIP_HEADER":
+            skip_header = True
+        elif exp_type == "FIELD_OPTIONALLY_ENCLOSED_BY":
+            quote = expression.args["value"].this
+        elif exp_type == "FIELD_DELIMITER":
+            delimiter = expression.args["value"].this
+        else:
+            raise NotImplementedError(f"{exp_type} is not currently implemented")
+
+    return ReadCSV(
+        skip_header=skip_header,
+        quote=quote,
+        delimiter=delimiter,
+        columns=columns,
+    )
+
+
+@dataclass
+class FileTypeHandler(Protocol):
+    files: list = field(default_factory=list)
+
+    def read_expression(self, url: str) -> exp.Expression: ...
+
+    def with_files(self, files: list) -> Self:
+        return replace(self, files=files)
+
+    @staticmethod
+    def make_eq(name: str, value: list | str | int | bool) -> exp.EQ:
+        if isinstance(value, list):
+            expression = exp.array(*[exp.Literal(this=str(v), is_string=isinstance(v, str)) for v in value])
+        elif isinstance(value, bool):
+            expression = exp.Boolean(this=value)
+        else:
+            expression = exp.Literal(this=str(value), is_string=isinstance(value, str))
+
+        return exp.EQ(this=exp.Literal(this=name, is_string=False), expression=expression)
+
+
+@dataclass
+class ReadCSV(FileTypeHandler):
+    skip_header: bool = False
+    quote: str | None = None
+    delimiter: str = ","
+    columns: list[str] = field(default_factory=list)
+
+    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))
+
+        if self.skip_header:
+            args.append(self.make_eq("skip", 1))
+
+        if self.quote:
+            quote = self.quote.replace("'", "''")
+            args.append(self.make_eq("quote", quote))
+
+        if self.delimiter and self.delimiter != ",":
+            delimiter = self.delimiter.replace("'", "''")
+            args.append(self.make_eq("sep", delimiter))
+
+        return exp.func("read_csv", exp.Literal(this=url, is_string=True), *args)

fakesnow/transforms/show.py

@@ -6,6 +6,14 @@ import sqlglot
 from sqlglot import exp
 
 
+def fs_global_creation_sql() -> str:
+    return f"""
+        {SQL_CREATE_VIEW_SHOW_OBJECTS};
+        {SQL_CREATE_VIEW_SHOW_TABLES};
+        {SQL_CREATE_VIEW_SHOW_VIEWS};
+    """
+
+
 def show_columns(
     expression: exp.Expression, current_database: str | None = None, current_schema: str | None = None
 ) -> exp.Expression:
@@ -283,22 +291,99 @@ def show_keys(
 
                 statement += f"AND table_name = '{table.name}' "
             else:
-                raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind} not yet supported")
+                raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind}")
         return sqlglot.parse_one(statement)
     return expression
 
 
-def show_objects_tables(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
-    """Transform SHOW OBJECTS/TABLES to a query against the information_schema.tables table.
+# see https://docs.snowflake.com/en/sql-reference/sql/show-objects
+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,
+    '' as comment,
+    '' as cluster_by,
+    -- TODO: implement rows and bytes as rows * 1024
+    0 as rows,
+    0 as bytes,
+    'SYSADMIN' as owner,
+    1 as retention_time,
+    'ROLE' as owner_role_type,
+    null as budget,
+    'N' as is_hybrid,
+    'N' as is_dynamic
+from information_schema.tables
+where not (table_schema == '_fs_information_schema')
+"""
 
-    See https://docs.snowflake.com/en/sql-reference/sql/show-objects
-        https://docs.snowflake.com/en/sql-reference/sql/show-tables
-    """
+# see https://docs.snowflake.com/en/sql-reference/sql/show-tables
+SQL_CREATE_VIEW_SHOW_TABLES = """
+create view if not exists _fs_global._fs_information_schema._fs_show_tables as
+select
+    to_timestamp(0)::timestamptz as created_on,
+    table_name as name,
+    'TABLE' as kind,
+    table_catalog as database_name,
+    table_schema as schema_name,
+    '' as comment,
+    '' as cluster_by,
+    -- TODO: implement rows and bytes as rows * 1024
+    0 as rows,
+    0 as bytes,
+    'SYSADMIN' as owner,
+    1 as retention_time,
+    'OFF' as automatic_clustering,
+    'OFF' as change_tracking,
+    'OFF' as search_optimization,
+    null as search_optimization_progress,
+    null as search_optimization_bytes,
+    'N' as is_external,
+    'N' as enable_schema_evolution,
+    'ROLE' as owner_role_type,
+    'N' as is_event,
+    null as budget,
+    'N' as is_hybrid,
+    'N' as is_iceberg,
+    'N' as is_dynamic,
+    'N' as is_immutable
+from information_schema.tables
+where not (table_schema == '_fs_information_schema')
+and table_type = 'BASE TABLE'
+"""
+
+# see https://docs.snowflake.com/en/sql-reference/sql/show-views
+SQL_CREATE_VIEW_SHOW_VIEWS = """
+create view if not exists _fs_global._fs_information_schema._fs_show_views as
+select
+    to_timestamp(0)::timestamptz as created_on,
+    table_name as name,
+    '' as reserved,
+    table_catalog as database_name,
+    table_schema as schema_name,
+    'SYSADMIN' as owner,
+    '' as comment,
+    view_definition as text,
+    false as is_secure,
+    false as is_materialized,
+    'ROLE' as owner_role_type,
+    'OFF' as change_tracking
+from information_schema.views
+where not table_catalog in ('system')
+  and not table_schema in ('main', '_fs_information_schema')
+"""
+
+
+def show_tables_etc(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
+    """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 in {"OBJECTS", "TABLES"}
+        and show in {"OBJECTS", "TABLES", "VIEWS"}
     ):
         return expression
 
@@ -316,76 +401,28 @@ def show_objects_tables(expression: exp.Expression, current_database: str | None
         catalog = None
         schema = None
 
-    columns = [
-        "to_timestamp(0)::timestamptz as 'created_on'",
-        "table_name as 'name'",
-        "case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind'",
-        "table_catalog as 'database_name'",
-        "table_schema as 'schema_name'",
-    ]
-    if not expression.args["terse"]:
-        if show == "OBJECTS":
-            columns.extend(
-                [
-                    "'' as 'comment'",
-                    "'' as 'cluster_by'",
-                    # TODO: implement rows and bytes as rows * 1024
-                    "0 as 'rows'",
-                    "0 as 'bytes'",
-                    "'SYSADMIN' as 'owner'",
-                    "1 as 'retention_time'",
-                    "'ROLE' as 'owner_role_type'",
-                    "null as 'budget'",
-                    "'N' as 'is_hybrid'",
-                    "'N' as 'is_dynamic'",
-                ]
-            )
-        else:
-            # show == "TABLES"
-            columns.extend(
-                [
-                    "'' as 'comment'",
-                    "'' as 'cluster_by'",
-                    # TODO: implement rows and bytes as rows * 1024
-                    "0 as 'rows'",
-                    "0 as 'bytes'",
-                    "'SYSADMIN' as 'owner'",
-                    "1 as 'retention_time'",
-                    "'OFF' as 'automatic_clustering'",
-                    "'OFF' as 'change_tracking'",
-                    "'OFF' as 'search_optimization'",
-                    "null as 'search_optimization_progress'",
-                    "null as 'search_optimization_bytes'",
-                    "'N' as 'is_external'",
-                    "'N' as 'enable_schema_evolution'",
-                    "'ROLE' as 'owner_role_type'",
-                    "'N' as 'is_event'",
-                    "null as 'budget'",
-                    "'N' as 'is_hybrid'",
-                    "'N' as 'is_iceberg'",
-                    "'N' as 'is_dynamic'",
-                    "'N' as 'is_immutable'",
-                ]
-            )
-
+    if expression.args["terse"] and show == "VIEWS":
+        columns = ["created_on, name, 'VIEW' as kind, database_name, schema_name"]
+    elif expression.args["terse"]:
+        columns = ["created_on, name, kind, database_name, schema_name"]
+    else:
+        columns = ["*"]
     columns_clause = ", ".join(columns)
 
-    where = ["not (table_schema == '_fs_information_schema')"]  # exclude fakesnow's internal schemas
-    if show == "TABLES":
-        where.append("table_type = 'BASE TABLE'")
+    where = ["1=1"]
     if catalog:
-        where.append(f"table_catalog = '{catalog}'")
+        where.append(f"database_name = '{catalog}'")
     if schema:
-        where.append(f"table_schema = '{schema}'")
+        where.append(f"schema_name = '{schema}'")
     if (like := expression.args.get("like")) and isinstance(like, exp.Expression):
-        where.append(f"table_name ilike {like.sql()}")
+        where.append(f"name ilike {like.sql()}")
     where_clause = " AND ".join(where)
 
     limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
 
     query = f"""
         SELECT {columns_clause}
-        from information_schema.tables
+        from _fs_global._fs_information_schema._fs_show_{show.lower()}
         where {where_clause}
         {limit}
     """
@@ -471,6 +508,6 @@ def show_users(expression: exp.Expression) -> exp.Expression:
     https://docs.snowflake.com/en/sql-reference/sql/show-users
     """
     if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "USERS":
-        return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users_ext", read="duckdb")
+        return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users", read="duckdb")
 
     return expression

fakesnow/variables.py

@@ -45,7 +45,7 @@ class Variables:
                 self._set(name, value)
             else:
                 # Haven't been able to produce this in tests yet due to UNSET being parsed as an Alias expression.
-                raise NotImplementedError("UNSET not supported yet")
+                raise NotImplementedError("UNSET")
         elif self._is_unset_expression(expr):  # Unfortunately UNSET varname; is parsed as an Alias expression :(
             alias = expr.args.get("alias")
             assert alias, "UNSET without value in alias attribute is unexpected."

{fakesnow-0.9.34.dist-info → fakesnow-0.9.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakesnow
-Version: 0.9.34
+Version: 0.9.36
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -215,6 +215,7 @@ Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
 Requires-Dist: sqlglot~=26.12.1
 Provides-Extra: dev
+Requires-Dist: boto3-stubs[s3,sts]; extra == "dev"
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: dirty-equals; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
@@ -222,10 +223,11 @@ Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra ==
 Requires-Dist: pre-commit~=4.0; extra == "dev"
 Requires-Dist: pyarrow-stubs==17.19; extra == "dev"
 Requires-Dist: pytest~=8.0; extra == "dev"
-Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: ruff~=0.11.0; extra == "dev"
 Requires-Dist: twine~=6.0; extra == "dev"
 Requires-Dist: snowflake-sqlalchemy~=1.7.0; extra == "dev"
+Requires-Dist: boto3; extra == "dev"
+Requires-Dist: moto[server]>=5; extra == "dev"
 Provides-Extra: notebook
 Requires-Dist: duckdb-engine; extra == "notebook"
 Requires-Dist: ipykernel; extra == "notebook"
@@ -242,7 +244,7 @@ Dynamic: license-file
 [![PyPI](https://img.shields.io/pypi/v/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 
-Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector). Run and mock Snowflake DB locally.
+Run, mock and test fake Snowflake databases locally.
 
 ## Install
 
@@ -250,9 +252,21 @@ Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/p
 pip install fakesnow
 ```
 
+Or to install with the server:
+
+```
+pip install fakesnow[server]
+```
+
 ## Usage
 
-Run script.py with fakesnow:
+fakesnow offers two main approaches for faking Snowflake: in-process patching of the [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector) or a standalone HTTP server.
+
+Patching only applies to the current Python process. If a subprocess is spawned it won't be patched. For subprocesses, or for non-Python clients, use the server instead.
+
+### In-process patching
+
+To run script.py with patching:
 
 ```shell
 fakesnow script.py
@@ -266,9 +280,9 @@ fakesnow -m pytest
 
 `fakesnow` executes `fakesnow.patch` before running the script or module.
 
-### fakesnow.patch
+#### Use fakesnow.patch in your code
 
-To use fakesnow within your code:
+Alternatively, use fakesnow.patch in your code:
 
 ```python
 import fakesnow
@@ -280,12 +294,16 @@ with fakesnow.patch():
     print(conn.cursor().execute("SELECT 'Hello fake world!'").fetchone())
 ```
 
-The following imports are automatically patched:
+#### What gets patched
+
+The following standard imports are automatically patched:
 
 - `import snowflake.connector.connect`
 - `import snowflake.connector.pandas_tools.write_pandas`
 
-To patch modules that use the `from ... import` syntax, manually specify them, eg: if _mymodule.py_ has the import:
+#### Handling "from ... import" Statements
+
+To patch modules that use the `from ... import` syntax, you need to manually specify them, eg: if _mymodule.py_ contains:
 
 ```python
 from snowflake.connector.pandas_tools import write_pandas
@@ -298,33 +316,77 @@ with fakesnow.patch("mymodule.write_pandas"):
     ...
 ```
 
-By default databases are in-memory. To persist databases between processes, specify a databases path:
+#### Database Persistence
+
+By default, databases are in-memory and will be lost when the process ends. To persist databases between processes, specify a databases path:
 
 ```python
 with fakesnow.patch(db_path="databases/"):
     ...
 ```
 
+### Run fakesnow as a server
+
+For scenarios where patching won't work (like subprocesses or non-Python clients), you can run fakesnow as an HTTP server:
+
+```python
+import fakesnow
+import snowflake.connector
+
+# Start the fakesnow server in a context manager
+# This yields connection kwargs (host, port, etc.)
+with fakesnow.server() as conn_kwargs:
+    # Connect to the fakesnow server using the yielded kwargs
+    with snowflake.connector.connect(**conn_kwargs) as conn:
+        print(conn.cursor().execute("SELECT 'Hello fake server!'").fetchone())
+
+    # The server is automatically stopped when exiting the context manager
+```
+
+This starts an HTTP server in its own thread listening for requests on localhost on an available random port.
+The server accepts any username/password combination.
+
+#### Server Configuration Options
+
+By default, the server uses a single in-memory database for its lifetime. To configure database persistence or isolation:
+
+```python
+# Databases will be saved to the "databases/" directory
+with fakesnow.server(session_parameters={"FAKESNOW_DB_PATH": "databases/"}):
+    ...
+
+# Each connection gets its own isolated in-memory database
+with fakesnow.server(session_parameters={"FAKESNOW_DB_PATH": ":isolated:"}):
+    ...
+```
+
+To specify a port for the server:
+
+```python
+with fakesnow.server(port=12345) as conn_kwargs:
+    ...
+```
+
 ### pytest fixtures
 
-pytest [fixtures](fakesnow/fixtures.py) are provided for testing. Example _conftest.py_:
+fakesnow provides [fixtures](fakesnow/fixtures.py) for easier test integration. Here's an example _conftest.py_ using them:
 
 ```python
 from typing import Iterator
 
-import fakesnow.fixtures
 import pytest
 
-pytest_plugins = fakesnow.fixtures.__name__
+pytest_plugins = "fakesnow.fixtures"
 
 @pytest.fixture(scope="session", autouse=True)
 def setup(_fakesnow_session: None) -> Iterator[None]:
     # the standard imports are now patched
-    ...
+    # Add any additional setup here
     yield
+    # Add any teardown here
 ```
 
-Or with `from ... import` patch targets:
+For code that uses `from ... import` statements:
 
 ```python
 from typing import Iterator
@@ -338,34 +400,56 @@ def _fakesnow_session() -> Iterator[None]:
         yield
 ```
 
+To start a fakesnow server instance, use the `fakesnow_server` session fixture:
+
+```python
+import snowflake.connector
+
+def test_with_server(fakesnow_server: dict):
+    # fakesnow_server contains connection kwargs (host, port, etc.)
+    with snowflake.connector.connect(**fakesnow_server) as conn:
+        conn.cursor().execute("SELECT 1")
+        assert conn.cursor().fetchone() == (1,)
+```
+
 ## Implementation coverage
 
-- [x] cursors and standard SQL
-- [x] [get_result_batches()](https://docs.snowflake.com/en/user-guide/python-connector-api#get_result_batches)
-- [x] information schema
-- [x] multiple databases
-- [x] [parameter binding](https://docs.snowflake.com/en/user-guide/python-connector-example#binding-data)
-- [x] table comments
-- [x] [write_pandas(..)](https://docs.snowflake.com/en/user-guide/python-connector-api#write_pandas)
-- [ ] [access control](https://docs.snowflake.com/en/user-guide/security-access-control-overview)
-- [ ] standalone/out of process api/support for faking non-python connectors
-- [ ] [stored procedures](https://docs.snowflake.com/en/sql-reference/stored-procedures)
+Fully supported:
 
-Partial support
+- Standard SQL operations and cursors
+- Information schema queries
+- 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)
+- 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
 
-- [x] date functions
-- [x] regex functions
-- [x] semi-structured data
-- [x] tags
-- [x] user management (See [tests/test_users.py](tests/test_users.py))
+Partially supported:
 
-For more detail see [tests/test_fakes.py](tests/test_fakes.py)
+- Date functions
+- Regular expression functions
+- Semi-structured data operations
+- Tags
+- User management
+- `COPY INTO` from S3 sources, see [COPY INTO](#copy-into)
+
+Not yet implemented:
+
+- [Access control](https://docs.snowflake.com/en/user-guide/security-access-control-overview)
+- [Stored procedures](https://docs.snowflake.com/en/sql-reference/stored-procedures)
+
+For more detail see the [test suite](tests/).
 
 ## Caveats
 
-- The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
-- A more liberal Snowflake SQL dialect than used by a real Snowflake instance is supported, ie: some queries might pass using fakesnow that a real Snowflake instance would reject.
+- Row ordering is non-deterministic and may differ from Snowflake unless you fully specify the ORDER BY clause.
+- fakesnow supports a more liberal SQL dialect than actual Snowflake. This means some queries that work with fakesnow might not work with a real Snowflake instance.
+
+## 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)
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) to get started and develop in this repo.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for instructions on getting started with development and contributing to this project.

fakesnow-0.9.36.dist-info/RECORD

@@ -0,0 +1,30 @@
+fakesnow/__init__.py,sha256=It-8mTZWBaVi4suZjL7UJlJBGFhLWmPnI-THX02XRJU,5108
+fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
+fakesnow/arrow.py,sha256=XjTpFyLrD9jULWOtPgpr0RyNMmO6a5yi82y6ivi2CCI,4884
+fakesnow/checks.py,sha256=be-xo0oMoAUVhlMDCu1_Rkoh_L8p_p8qo9P6reJSHIQ,2874
+fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
+fakesnow/conn.py,sha256=diCwcjaCBrlCn9PyjbScfIQTNQjqiPTkQanUTqcvblE,6009
+fakesnow/converter.py,sha256=xoBFnfBbGWQyUQAVr6zi-RyglU8A7A3GSlwLPkH1dzI,1621
+fakesnow/cursor.py,sha256=3JCxSoBJ2g6bndIGQnJnTAWu8Ad7zK_6kwmAY_b0VKE,22949
+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/instance.py,sha256=OKoYXwaI6kL9HQpnHx44yzpON_xNfuIT_F4oJNF_XXQ,2114
+fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
+fakesnow/pandas_tools.py,sha256=wI203UQHC8JvDzxE_VjE1NeV4rThek2P-u52oTg2foo,3481
+fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
+fakesnow/rowtype.py,sha256=QUp8EaXD5LT0Xv8BXk5ze4WseEn52xoJ6R05pJjs5mM,2729
+fakesnow/server.py,sha256=RHf7ffKYi5xBH9fh8wZr3tEPmnzFWuvUbziCC8UwTh4,6652
+fakesnow/variables.py,sha256=C3y_9u7LuVtARkpcim3ihgVWg6KKdz1hSVeW4YI7oL4,3014
+fakesnow/transforms/__init__.py,sha256=RcVGkp95yKByluQ5O6RALJTiRlox8FK4pMl1rt_gJPc,49536
+fakesnow/transforms/copy_into.py,sha256=QJ1hh3hVi9kPJgyQHlGO3Vi8sP3qnWmvY4JWO--HWl0,5565
+fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
+fakesnow/transforms/show.py,sha256=0NjuLQjodrukfUw8mcxcAmtBkV_6r02mA3nuE3ad3rE,17458
+fakesnow-0.9.36.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
+fakesnow-0.9.36.dist-info/METADATA,sha256=Nu1iV0SOnWCNeQCVJXbwC2PVxx7mkdQ6YDfDVkfTmI4,21160
+fakesnow-0.9.36.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+fakesnow-0.9.36.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.36.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
+fakesnow-0.9.36.dist-info/RECORD,,

{fakesnow-0.9.34.dist-info → fakesnow-0.9.36.dist-info}/WHEEL

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

fakesnow-0.9.34.dist-info/RECORD

@@ -1,29 +0,0 @@
-fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
-fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
-fakesnow/arrow.py,sha256=XjTpFyLrD9jULWOtPgpr0RyNMmO6a5yi82y6ivi2CCI,4884
-fakesnow/checks.py,sha256=be-xo0oMoAUVhlMDCu1_Rkoh_L8p_p8qo9P6reJSHIQ,2874
-fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
-fakesnow/conn.py,sha256=2WClMmUgfQkQA2hFQjfMP3R-85TbTbZh_8Y1tCdcerA,6053
-fakesnow/converter.py,sha256=7YlASaMomzchMZoorTH3KtVmgBakaHrF5fAl5VP747I,1635
-fakesnow/cursor.py,sha256=mK4nC1iucON1MohicTugJqUOfRsx5c8ToUJgnCfUSbs,21813
-fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
-fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
-fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
-fakesnow/info_schema.py,sha256=xDhGy07fpc8bcy_VTfh54UzwNIaB4ZhGmjgJeoiZ0hQ,8744
-fakesnow/instance.py,sha256=VsFbhVfy6EAJdEKykgavJwkMtrig01NehorptT51Jh8,2020
-fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
-fakesnow/pandas_tools.py,sha256=wI203UQHC8JvDzxE_VjE1NeV4rThek2P-u52oTg2foo,3481
-fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
-fakesnow/rowtype.py,sha256=QUp8EaXD5LT0Xv8BXk5ze4WseEn52xoJ6R05pJjs5mM,2729
-fakesnow/server.py,sha256=4DgZUTd-G_usjSqy6NdUqd2fWUw2a-wHSSeJt3cdneA,6375
-fakesnow/variables.py,sha256=WXyPnkeNwD08gy52yF66CVe2twiYC50tztNfgXV4q1k,3032
-fakesnow/transforms/__init__.py,sha256=xFrpw28DaHvMt6LGaRMsPqTo8PWogg10JgEu3oa6jdA,49515
-fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
-fakesnow/transforms/show.py,sha256=2qfK3Fi0RLylqTnkwSVgv5JIorXYb1y0fnf5oErRZ2o,16839
-fakesnow-0.9.34.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
-tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.34.dist-info/METADATA,sha256=Hqkb8CT1-QTNzQqRMVhEHWGwx3gJORv9YHy7wGSoBgQ,18128
-fakesnow-0.9.34.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-fakesnow-0.9.34.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.34.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.34.dist-info/RECORD,,