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

fakesnow/copy_into.py

@@ -11,6 +11,7 @@ import snowflake.connector.errors
 from duckdb import DuckDBPyConnection
 from sqlglot import exp
 
+import fakesnow.transforms.stage as stage
 from fakesnow import logger
 
 
@@ -196,40 +197,10 @@ def _from_source(expr: exp.Copy) -> str:
     return from_.name
 
 
-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 stage_url_from_var(
     from_source: str, duck_conn: DuckDBPyConnection, current_database: str | None, current_schema: str | None
 ) -> str:
-    parts = from_source[1:].split(".")
-    if len(parts) == 3:
-        # Fully qualified name
-        database_name, schema_name, name = parts
-    elif len(parts) == 2:
-        # Schema + stage name
-        assert current_database, "Current database must be set when stage name is not fully qualified"
-        database_name, schema_name, name = current_database, parts[0], parts[1]
-    elif len(parts) == 1:
-        # Stage name only
-        assert current_database, "Current database must be set when stage name is not fully qualified"
-        assert current_schema, "Current schema must be set when stage name is not fully qualified"
-        database_name, schema_name, name = current_database, current_schema, parts[0]
-    else:
-        raise ValueError(f"Invalid stage name: {from_source}")
-
-    # Normalize names to uppercase if not wrapped in double quotes
-    database_name = normalise_ident(database_name)
-    schema_name = normalise_ident(schema_name)
-    name = normalise_ident(name)
+    database_name, schema_name, name = stage.parts_from_var(from_source, current_database, current_schema)
 
     # Look up the stage URL
     duck_conn.execute(

fakesnow/cursor.py

@@ -76,6 +76,7 @@ class FakeSnowflakeCursor:
         self._use_dict_result = use_dict_result
         self._last_sql = None
         self._last_params = None
+        self._last_transformed = None
         self._sqlstate = None
         self._arraysize = 1
         self._arrow_table = None
@@ -106,6 +107,7 @@ class FakeSnowflakeCursor:
     def close(self) -> bool:
         self._last_sql = None
         self._last_params = None
+        self._last_transformed = None
         return True
 
     def describe(self, command: str, *args: Any, **kwargs: Any) -> list[ResultMetadata]:
@@ -239,6 +241,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.identifier)
             .transform(transforms.array_agg_within_group)
             .transform(transforms.array_agg)
+            .transform(transforms.array_construct_etc)
             .transform(transforms.dateadd_date_cast)
             .transform(transforms.dateadd_string_literal_timestamp_cast)
             .transform(transforms.datediff_string_literal_timestamp_cast)
@@ -261,6 +264,7 @@ 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))
         )
 
     def _transform_explode(self, expression: exp.Expression) -> list[exp.Expression]:
@@ -330,10 +334,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 stage_name := transformed.args.get("stage_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 stage name"
+                    "Expected single parameter for create_stage_name"
                 )
                 result_sql = SQL_CREATED_STAGE.substitute(name=params[0].upper())
             else:
@@ -411,8 +415,21 @@ 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
 
     def executemany(
         self,

fakesnow/macros.py

@@ -29,9 +29,20 @@ CREATE OR REPLACE MACRO ${catalog}._fs_flatten(input) AS TABLE
     """
 )
 
+# emulates https://docs.snowflake.com/en/sql-reference/functions/array_construct_compact
+# requires transforms.array_construct_compact
+ARRAY_CONSTRUCT_COMPACT = Template(
+    """
+CREATE OR REPLACE MACRO ${catalog}.array_construct_compact(list) AS (
+    SELECT ARRAY_AGG(x)::JSON FROM UNNEST(list) AS t(x) WHERE x IS NOT NULL
+);
+"""
+)
+
 
 def creation_sql(catalog: str) -> str:
     return f"""
         {EQUAL_NULL.substitute(catalog=catalog)};
         {FS_FLATTEN.substitute(catalog=catalog)};
+        {ARRAY_CONSTRUCT_COMPACT.substitute(catalog=catalog)};
     """

fakesnow/server.py

@@ -9,6 +9,7 @@ from dataclasses import dataclass
 from typing import Any
 
 import snowflake.connector.errors
+from sqlglot import parse_one
 from starlette.applications import Starlette
 from starlette.concurrency import run_in_threadpool
 from starlette.requests import Request
@@ -89,11 +90,24 @@ async def query_request(request: Request) -> JSONResponse:
         else:
             params = None
 
+        expr = parse_one(sql_text, read="snowflake")
+
         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)
             rowtype = describe_as_rowtype(cur._describe_last_sql())  # noqa: SLF001
 
+            expr = cur._last_transformed  # noqa: SLF001
+            assert expr
+            if put_stage_data := expr.args.get("put_stage_data"):
+                # this is a PUT command, so return the stage data
+                return JSONResponse(
+                    {
+                        "data": put_stage_data,
+                        "success": True,
+                    }
+                )
+
         except snowflake.connector.errors.ProgrammingError as e:
             logger.info(f"{sql_text=} ProgrammingError {e}")
             code = f"{e.errno:06d}"

fakesnow/transforms/__init__.py

@@ -13,13 +13,17 @@ from fakesnow.transforms.show import (
     show_users as show_users,
     show_warehouses as show_warehouses,
 )
-from fakesnow.transforms.stage import create_stage as create_stage
+from fakesnow.transforms.stage import (
+    create_stage as create_stage,
+    put_stage as put_stage,
+)
 from fakesnow.transforms.transforms import (
     SUCCESS_NOP as SUCCESS_NOP,
     alias_in_join as alias_in_join,
     alter_table_strip_cluster_by as alter_table_strip_cluster_by,
     array_agg as array_agg,
     array_agg_within_group as array_agg_within_group,
+    array_construct_etc as array_construct_etc,
     array_size as array_size,
     create_clone as create_clone,
     create_database as create_database,

fakesnow/transforms/stage.py

@@ -1,13 +1,18 @@
 from __future__ import annotations
 
 import datetime
+from urllib.parse import urlparse
+from urllib.request import url2pathname
 
+import snowflake.connector.errors
 import sqlglot
 from sqlglot import exp
 
+LOCAL_BUCKET_PATH = "/tmp/fakesnow_bucket"
+
 
 def create_stage(
-    expression: exp.Expression, current_database: str | None = None, current_schema: str | None = None
+    expression: exp.Expression, current_database: str | None, current_schema: str | None
 ) -> exp.Expression:
     """Transform CREATE STAGE to an INSERT statement for the fake stages table."""
     if not (
@@ -64,5 +69,95 @@ def create_stage(
         )
         """
     transformed = sqlglot.parse_one(insert_sql, read="duckdb")
-    transformed.args["stage_name"] = stage_name
+    transformed.args["create_stage_name"] = stage_name
+    return transformed
+
+
+# TODO: handle ?
+
+
+def put_stage(expression: exp.Expression, current_database: str | None, current_schema: str | None) -> exp.Expression:
+    """Transform PUT to a SELECT statement to locate the stage.
+
+    See https://docs.snowflake.com/en/sql-reference/sql/put
+    """
+    if not isinstance(expression, exp.Put):
+        return expression
+
+    assert isinstance(expression.this, exp.Literal), "PUT command requires a file path as a literal"
+    src_url = urlparse(expression.this.this)
+    src_path = url2pathname(src_url.path)
+    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 @"
+        raise snowflake.connector.errors.ProgrammingError(
+            msg=msg,
+            errno=1003,
+            sqlstate="42000",
+        )
+    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["put_stage_name"] = f"{catalog}.{schema}.{stage_name}"
+    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}/",
+            "creds": {},
+        },
+        "src_locations": [src_path],
+        # defaults as per https://docs.snowflake.com/en/sql-reference/sql/put TODO: support other values
+        "parallel": 4,
+        "autoCompress": True,
+        "sourceCompression": "auto_detect",
+        "overwrite": False,
+        "command": "UPLOAD",
+    }
+
     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(".")
+    if len(parts) == 3:
+        # Fully qualified name
+        database_name, schema_name, name = parts
+    elif len(parts) == 2:
+        # Schema + stage name
+        assert current_database, "Current database must be set when stage name is not fully qualified"
+        database_name, schema_name, name = current_database, parts[0], parts[1]
+    elif len(parts) == 1:
+        # Stage name only
+        assert current_database, "Current database must be set when stage name is not fully qualified"
+        assert current_schema, "Current schema must be set when stage name is not fully qualified"
+        database_name, schema_name, name = current_database, current_schema, parts[0]
+    else:
+        raise ValueError(f"Invalid stage name: {var}")
+
+    # Normalize names to uppercase if not wrapped in double quotes
+    database_name = normalise_ident(database_name)
+    schema_name = normalise_ident(schema_name)
+    name = normalise_ident(name)
+
+    return database_name, schema_name, name

fakesnow/transforms/transforms.py

@@ -45,6 +45,24 @@ def alter_table_strip_cluster_by(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def array_construct_etc(expression: exp.Expression) -> exp.Expression:
+    """Handle ARRAY_CONSTRUCT_* and ARRAY_CAT
+
+    Convert ARRAY_CONSTRUCT args to json_array.
+    Convert ARRAY_CONSTRUCT_COMPACT args to a list.
+    Because the macro expects a single argument to use with UNNEST.
+
+    TODO: fix ARRAY_CONSTRUCT_COMPACT to handle args of differing types.
+    """
+    if isinstance(expression, exp.ArrayConstructCompact):
+        return exp.ArrayConstructCompact(expressions=[exp.Array(expressions=expression.expressions)])
+    elif isinstance(expression, exp.Array) and isinstance(expression.parent, exp.Select):
+        return exp.Anonymous(this="json_array", expressions=expression.expressions)
+    elif isinstance(expression, exp.ArrayConcat) and isinstance(expression.parent, exp.Select):
+        return exp.Cast(this=expression, to=exp.DataType(this=exp.DataType.Type.JSON, nested=False))
+    return expression
+
+
 def array_size(expression: exp.Expression) -> exp.Expression:
     if isinstance(expression, exp.ArraySize):
         # return null if not json array

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakesnow
-Version: 0.9.39
+Version: 0.9.40
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -214,7 +214,7 @@ License-File: LICENSE
 Requires-Dist: duckdb~=1.2.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=26.16.2
+Requires-Dist: sqlglot~=26.24.0
 Provides-Extra: server
 Requires-Dist: starlette; extra == "server"
 Requires-Dist: uvicorn; extra == "server"

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

@@ -5,29 +5,29 @@ 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=CRqAK5CUz9xYSwP9PZJpVxUz8KT9ZZpsCRQEuEEVSbM,14832
-fakesnow/cursor.py,sha256=xDKvet679VnICUxbDCfRnT8K9Q03Tii948_3XD2YFnk,22954
+fakesnow/copy_into.py,sha256=YIr5Bq3JwKOPYWm5t2QXUuFGxLL-1ioEXEumNjGbBvM,13648
+fakesnow/cursor.py,sha256=mOwyXnBFXp79nDh0vtbmxS_hmFNy4j7hPlskENWeIrI,23818
 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=lqEYD5aWK2MamjALbj6ct7pz_1yyAq3tAk51kLa8NKk,9872
 fakesnow/instance.py,sha256=OKoYXwaI6kL9HQpnHx44yzpON_xNfuIT_F4oJNF_XXQ,2114
 fakesnow/logger.py,sha256=U6EjUENQuTrDeNYqER2hxazoySmXzLmZJ-t-SDZgjkg,363
-fakesnow/macros.py,sha256=bQfZR5ptO4Gk-8fFRK2iksqYWkJUT8e-rPp-000qzu0,999
+fakesnow/macros.py,sha256=lxtznTCYryjecFkwswbqWMzCVamDLWyQZRKWtkWCWEk,1397
 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=WyLU_4zcqQHLcvilQbNeavwRLVRQLm7n8NmtHJHzjqY,6687
+fakesnow/server.py,sha256=PGNuYEpmI0L0ZrwBCP1pDTc_lnFrtfSnlZ6zyVuCTqk,7173
 fakesnow/variables.py,sha256=BGnD4LAdVByfJ2GXL6qpGBaTF8ZJRjt3pdJsd9sIAcw,3134
-fakesnow/transforms/__init__.py,sha256=ZT0ehX8F1PPUY1983RjVofJ5spPE2syen5henc2m1Sk,2722
+fakesnow/transforms/__init__.py,sha256=OE-dunCuum8lv832s2cjEzThgBnpKELo5aaTXD_bMNg,2807
 fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
 fakesnow/transforms/show.py,sha256=ejvs9S2l2Wcal4fhnNSVs3JkZwKsFxMEU35ufUV3-kg,20421
-fakesnow/transforms/stage.py,sha256=jkabKkxFEYjTVuLsDH3fgjyhFdc_GGh3DavWv7G7k68,2560
-fakesnow/transforms/transforms.py,sha256=I2X7KZ5wphq1NJvfbFmY8JYE-8vpVHMn-KTXurMxouE,47149
-fakesnow-0.9.39.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow/transforms/stage.py,sha256=FSIyI5kpthD_pdbVfzYCrby5HaikMZUpdRr6oBSrgk4,6176
+fakesnow/transforms/transforms.py,sha256=t99pHmNm8aG89o738zVSXCG6a0dOXpnY1OqAz28EQHc,48072
+fakesnow-0.9.40.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
 tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.39.dist-info/METADATA,sha256=IlCT__J_g9f5ltb3eC7t0cUs5t3Aq0BaX4eNcKkxCYE,20680
-fakesnow-0.9.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fakesnow-0.9.39.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.39.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.39.dist-info/RECORD,,
+fakesnow-0.9.40.dist-info/METADATA,sha256=ssyuxQf4dJU5Mt5dQYr14H52eO9r62X1NIzdfJ7k1jA,20680
+fakesnow-0.9.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fakesnow-0.9.40.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.40.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
+fakesnow-0.9.40.dist-info/RECORD,,