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

fakesnow/transforms/stage.py

@@ -0,0 +1,163 @@
+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, current_schema: str | None
+) -> exp.Expression:
+    """Transform CREATE STAGE to an INSERT statement for the fake stages table."""
+    if not (
+        isinstance(expression, exp.Create)
+        and (kind := expression.args.get("kind"))
+        and isinstance(kind, str)
+        and kind.upper() == "STAGE"
+        and (table := expression.find(exp.Table))
+    ):
+        return expression
+
+    catalog = table.catalog or current_database
+    schema = table.db or current_schema
+    ident = table.this
+    if isinstance(ident, exp.Placeholder):
+        stage_name = "?"
+    elif isinstance(ident, exp.Identifier):
+        stage_name = ident.this if ident.quoted else ident.this.upper()
+    else:
+        raise ValueError(f"Invalid identifier type {ident.__class__.__name__} for stage name")
+    now = datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+    is_temp = False
+    url = ""
+    properties = expression.args.get("properties") or []
+    for prop in properties:
+        if isinstance(prop, exp.TemporaryProperty):
+            is_temp = True
+        elif (
+            isinstance(prop, exp.Property)
+            and isinstance(prop.this, exp.Var)
+            and isinstance(prop.this.this, str)
+            and prop.this.this.upper() == "URL"
+        ):
+            value = prop.args.get("value")
+            if isinstance(value, exp.Literal):
+                url = value.this
+
+    # Determine cloud provider based on url
+    cloud = "AWS" if url.startswith("s3://") else None
+
+    stage_type = ("EXTERNAL" if url else "INTERNAL") + (" TEMPORARY" if is_temp else "")
+    stage_name_value = stage_name if stage_name == "?" else repr(stage_name)
+
+    insert_sql = f"""
+        INSERT INTO _fs_global._fs_information_schema._fs_stages
+        (created_on, name, database_name, schema_name, url, has_credentials, has_encryption_key, owner,
+        comment, region, type, cloud, notification_channel, storage_integration, endpoint, owner_role_type,
+        directory_enabled)
+        VALUES (
+            '{now}', {stage_name_value}, '{catalog}', '{schema}', '{url}', 'N', 'N', 'SYSADMIN',
+            '', NULL, '{stage_type}', {f"'{cloud}'" if cloud else "NULL"}, NULL, NULL, NULL, 'ROLE',
+            'N'
+        )
+        """
+    transformed = sqlglot.parse_one(insert_sql, read="duckdb")
+    transformed.args["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
@@ -530,8 +548,11 @@ def identifier(expression: exp.Expression) -> exp.Expression:
         and isinstance(expression.this, str)
         and expression.this.upper() == "IDENTIFIER"
     ):
-        expression = exp.Identifier(this=expression.expressions[0].this, quoted=False)
-
+        arg = expression.expressions[0]
+        # ? is parsed as exp.Placeholder
+        if isinstance(arg, exp.Placeholder):
+            return arg
+        return exp.Identifier(this=arg.this, quoted=False)
     return expression
 
 
@@ -569,20 +590,20 @@ def indices_to_json_extract(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def information_schema_fs_columns(expression: exp.Expression) -> exp.Expression:
-    """Redirect to the _FS_COLUMNS view which has metadata that matches snowflake.
-
-    Because duckdb doesn't store character_maximum_length or character_octet_length.
+def information_schema_fs(expression: exp.Expression) -> exp.Expression:
+    """Redirects for
+    * _FS_COLUMNS view which has character_maximum_length or character_octet_length.
+    * _FS_TABLES to access additional metadata columns (eg: comment).
+    * _FS_VIEWS to return Snowflake's version instead of duckdb's
+    * _FS_LOAD_HISTORY table which duckdb doesn't have.
     """
 
     if (
         isinstance(expression, exp.Table)
-        and expression.db
         and expression.db.upper() == "INFORMATION_SCHEMA"
-        and expression.name
-        and expression.name.upper() == "COLUMNS"
+        and expression.name.upper() in {"COLUMNS", "TABLES", "VIEWS", "LOAD_HISTORY"}
     ):
-        expression.set("this", exp.Identifier(this="_FS_COLUMNS", quoted=False))
+        expression.set("this", exp.Identifier(this=f"_FS_{expression.name.upper()}", quoted=False))
         expression.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
 
     return expression
@@ -607,38 +628,6 @@ def information_schema_databases(
     return expression
 
 
-def information_schema_fs_tables(
-    expression: exp.Expression,
-) -> exp.Expression:
-    """Use _FS_TABLES to access additional metadata columns (eg: comment)."""
-
-    if (
-        isinstance(expression, exp.Select)
-        and (tbl := expression.find(exp.Table))
-        and tbl.db.upper() == "INFORMATION_SCHEMA"
-        and tbl.name.upper() == "TABLES"
-    ):
-        tbl.set("this", exp.Identifier(this="_FS_TABLES", quoted=False))
-        tbl.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
-
-    return expression
-
-
-def information_schema_fs_views(expression: exp.Expression) -> exp.Expression:
-    """Use _FS_VIEWS to return Snowflake's version instead of duckdb's."""
-
-    if (
-        isinstance(expression, exp.Select)
-        and (tbl := expression.find(exp.Table))
-        and tbl.db.upper() == "INFORMATION_SCHEMA"
-        and tbl.name.upper() == "VIEWS"
-    ):
-        tbl.set("this", exp.Identifier(this="_FS_VIEWS", quoted=False))
-        tbl.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
-
-    return expression
-
-
 NUMBER_38_0 = [
     exp.DataTypeParam(this=exp.Literal(this="38", is_string=False)),
     exp.DataTypeParam(this=exp.Literal(this="0", is_string=False)),

fakesnow/variables.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakesnow
-Version: 0.9.38
+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.38.dist-info → fakesnow-0.9.40.dist-info}/RECORD

@@ -1,32 +1,33 @@
 fakesnow/__init__.py,sha256=71Rk_3s_4eTDCi7-bbo-xT71WN0E0MAPf5qjsguIeJU,5117
 fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
 fakesnow/arrow.py,sha256=XjTpFyLrD9jULWOtPgpr0RyNMmO6a5yi82y6ivi2CCI,4884
-fakesnow/checks.py,sha256=be-xo0oMoAUVhlMDCu1_Rkoh_L8p_p8qo9P6reJSHIQ,2874
+fakesnow/checks.py,sha256=bOJPMp46AvjJV_bXXjx2njO2dXNjffLrznwRuKyYZ4g,2889
 fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
 fakesnow/conn.py,sha256=diCwcjaCBrlCn9PyjbScfIQTNQjqiPTkQanUTqcvblE,6009
 fakesnow/converter.py,sha256=wPOfsFXIUJNJSx5oFNAxh13udxmAVIIHsLK8BiGkXGA,1635
-fakesnow/copy_into.py,sha256=JT4SpynozlcdmWwzlQwwncPiuHCE5UUv-XGX_CI9s90,7235
-fakesnow/cursor.py,sha256=so8OET_ZLlvRyxanKORfGU8gSiIa71FKILsS45lh0cE,22287
+fakesnow/copy_into.py,sha256=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=AYmTIHxk5Y6xdMTgttgBL1V0VO8qiM2T1-gKwkLmWDs,8720
+fakesnow/info_schema.py,sha256=lqEYD5aWK2MamjALbj6ct7pz_1yyAq3tAk51kLa8NKk,9872
 fakesnow/instance.py,sha256=OKoYXwaI6kL9HQpnHx44yzpON_xNfuIT_F4oJNF_XXQ,2114
 fakesnow/logger.py,sha256=U6EjUENQuTrDeNYqER2hxazoySmXzLmZJ-t-SDZgjkg,363
-fakesnow/macros.py,sha256=bQfZR5ptO4Gk-8fFRK2iksqYWkJUT8e-rPp-000qzu0,999
+fakesnow/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=RHf7ffKYi5xBH9fh8wZr3tEPmnzFWuvUbziCC8UwTh4,6652
-fakesnow/variables.py,sha256=sWWSvuWY6yAhKhsl9KFzE703bCPeMAJruIa_dY8LaKs,3018
-fakesnow/transforms/__init__.py,sha256=jHbn7T6fSxhiu3KVn_Xupi5JwgY9SbjcfGU-0WpdELU,2769
+fakesnow/server.py,sha256=PGNuYEpmI0L0ZrwBCP1pDTc_lnFrtfSnlZ6zyVuCTqk,7173
+fakesnow/variables.py,sha256=BGnD4LAdVByfJ2GXL6qpGBaTF8ZJRjt3pdJsd9sIAcw,3134
+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=0NjuLQjodrukfUw8mcxcAmtBkV_6r02mA3nuE3ad3rE,17458
-fakesnow/transforms/transforms.py,sha256=kjkQGTSkZ5lOJ-G13WQL4uB4yTzoIcsa3qcgBAgPH0c,47985
-fakesnow-0.9.38.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+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.40.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
 tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.38.dist-info/METADATA,sha256=nzZJ-lAiabUJv6a_Mv6xYTJyVvkmZas8bACLfr5xZEE,20680
-fakesnow-0.9.38.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-fakesnow-0.9.38.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.38.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.38.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,,

{fakesnow-0.9.38.dist-info → fakesnow-0.9.40.dist-info}/WHEEL

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