fakesnow 0.9.15__tar.gz → 0.9.17__tar.gz

{fakesnow-0.9.15 → fakesnow-0.9.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.15
+Version: 0.9.17
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -210,10 +210,10 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: duckdb~=0.10.3
+Requires-Dist: duckdb~=1.0.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=24.1.0
+Requires-Dist: sqlglot~=25.3.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

{fakesnow-0.9.15 → fakesnow-0.9.17}/fakesnow/fakes.py

@@ -158,6 +158,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.tag)
             .transform(transforms.semi_structured_types)
             .transform(transforms.try_parse_json)
+            .transform(transforms.split)
             # NOTE: trim_cast_varchar must be before json_extract_cast_as_varchar
             .transform(transforms.trim_cast_varchar)
             # indices_to_json_extract must be before regex_substr
@@ -165,6 +166,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.json_extract_cast_as_varchar)
             .transform(transforms.json_extract_cased_as_varchar)
             .transform(transforms.json_extract_precedence)
+            .transform(transforms.flatten_value_cast_as_varchar)
             .transform(transforms.flatten)
             .transform(transforms.regex_replace)
             .transform(transforms.regex_substr)
@@ -184,7 +186,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.random)
             .transform(transforms.identifier)
             .transform(transforms.array_agg_within_group)
-            .transform(transforms.array_agg_to_json)
+            .transform(transforms.array_agg)
             .transform(transforms.dateadd_date_cast)
             .transform(transforms.dateadd_string_literal_timestamp_cast)
             .transform(transforms.datediff_string_literal_timestamp_cast)
@@ -520,7 +522,7 @@ class FakeSnowflakeConnection:
         self.schema = schema and schema.upper()
         self.database_set = False
         self.schema_set = False
-        self.db_path = db_path
+        self.db_path = Path(db_path) if db_path else None
         self.nop_regexes = nop_regexes
         self._paramstyle = snowflake.connector.paramstyle
 
@@ -535,7 +537,7 @@ class FakeSnowflakeConnection:
                 where catalog_name = '{self.database}'"""
             ).fetchone()
         ):
-            db_file = f"{Path(db_path)/self.database}.db" if db_path else ":memory:"
+            db_file = f"{self.db_path/self.database}.db" if self.db_path else ":memory:"
             duck_conn.execute(f"ATTACH DATABASE '{db_file}' AS {self.database}")
             duck_conn.execute(info_schema.creation_sql(self.database))
             duck_conn.execute(macros.creation_sql(self.database))

{fakesnow-0.9.15 → fakesnow-0.9.17}/fakesnow/transforms.py

@@ -41,8 +41,11 @@ def array_size(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def array_agg_to_json(expression: exp.Expression) -> exp.Expression:
-    if isinstance(expression, exp.ArrayAgg):
+def array_agg(expression: exp.Expression) -> exp.Expression:
+    if isinstance(expression, exp.ArrayAgg) and not isinstance(expression.parent, exp.Window):
+        return exp.Anonymous(this="TO_JSON", expressions=[expression])
+
+    if isinstance(expression, exp.Window) and isinstance(expression.this, exp.ArrayAgg):
         return exp.Anonymous(this="TO_JSON", expressions=[expression])
 
     return expression
@@ -436,7 +439,7 @@ def flatten(expression: exp.Expression) -> exp.Expression:
         isinstance(expression, exp.Lateral)
         and isinstance(expression.this, exp.Explode)
         and (alias := expression.args.get("alias"))
-        # always true; when no explicit alias provided this will be _flattened
+        # always true; when no explicit alias provided this will be flattened
         and isinstance(alias, exp.TableAlias)
     ):
         explode_expression = expression.this.this.expression
@@ -460,6 +463,25 @@ def flatten(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def flatten_value_cast_as_varchar(expression: exp.Expression) -> exp.Expression:
+    """Return raw unquoted string when flatten VALUE is cast to varchar.
+
+    Returns a raw string using the Duckdb ->> operator, aka the json_extract_string function, see
+    https://duckdb.org/docs/extensions/json#json-extraction-functions
+    """
+    if (
+        isinstance(expression, exp.Cast)
+        and isinstance(expression.this, exp.Column)
+        and expression.this.name.upper() == "VALUE"
+        and expression.to.this in [exp.DataType.Type.VARCHAR, exp.DataType.Type.TEXT]
+        and (select := expression.find_ancestor(exp.Select))
+        and select.find(exp.Explode)
+    ):
+        return exp.JSONExtractScalar(this=expression.this, expression=exp.JSONPath(expressions=[exp.JSONPathRoot()]))
+
+    return expression
+
+
 def float_to_double(expression: exp.Expression) -> exp.Expression:
     """Convert float to double for 64 bit precision.
 
@@ -931,6 +953,16 @@ def show_schemas(expression: exp.Expression, current_database: str | None = None
     return expression
 
 
+def split(expression: exp.Expression) -> exp.Expression:
+    """
+    Convert output of duckdb str_split from varchar[] to JSON array to match Snowflake.
+    """
+    if isinstance(expression, exp.Split):
+        return exp.Anonymous(this="to_json", expressions=[expression])
+
+    return expression
+
+
 def tag(expression: exp.Expression) -> exp.Expression:
     """Handle tags. Transfer tags into upserts of the tag table.
 

{fakesnow-0.9.15 → fakesnow-0.9.17}/fakesnow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.15
+Version: 0.9.17
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -210,10 +210,10 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: duckdb~=0.10.3
+Requires-Dist: duckdb~=1.0.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=24.1.0
+Requires-Dist: sqlglot~=25.3.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

{fakesnow-0.9.15 → fakesnow-0.9.17}/fakesnow.egg-info/requires.txt

@@ -1,7 +1,7 @@
-duckdb~=0.10.3
+duckdb~=1.0.0
 pyarrow
 snowflake-connector-python
-sqlglot~=24.1.0
+sqlglot~=25.3.0
 
 [dev]
 build~=1.0

{fakesnow-0.9.15 → fakesnow-0.9.17}/pyproject.toml

@@ -1,17 +1,17 @@
 [project]
 name = "fakesnow"
 description = "Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally."
-version = "0.9.15"
+version = "0.9.17"
 readme = "README.md"
 license = { file = "LICENSE" }
 classifiers = ["License :: OSI Approved :: MIT License"]
 keywords = ["snowflake", "snowflakedb", "fake", "local", "mock", "testing"]
 requires-python = ">=3.9"
 dependencies = [
-    "duckdb~=0.10.3",
+    "duckdb~=1.0.0",
     "pyarrow",
     "snowflake-connector-python",
-    "sqlglot~=24.1.0",
+    "sqlglot~=25.3.0",
 ]
 
 [project.urls]

{fakesnow-0.9.15 → fakesnow-0.9.17}/tests/test_fakes.py

@@ -54,7 +54,7 @@ def test_array_size(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert cur.fetchall() == [(None,)]
 
 
-def test_array_agg_to_json(dcur: snowflake.connector.cursor.DictCursor):
+def test_array_agg(dcur: snowflake.connector.cursor.DictCursor):
     dcur.execute("create table table1 (id number, name varchar)")
     values = [(1, "foo"), (2, "bar"), (1, "baz"), (2, "qux")]
 
@@ -63,6 +63,24 @@ def test_array_agg_to_json(dcur: snowflake.connector.cursor.DictCursor):
     dcur.execute("select array_agg(name) as names from table1")
     assert dindent(dcur.fetchall()) == [{"NAMES": '[\n  "foo",\n  "bar",\n  "baz",\n  "qux"\n]'}]
 
+    # using over
+
+    dcur.execute(
+        """
+            SELECT DISTINCT
+                ID
+                , ANOTHER
+                , ARRAY_AGG(DISTINCT COL) OVER(PARTITION BY ID) AS COLS
+            FROM (select column1 as ID, column2 as COL, column3 as ANOTHER from
+            (VALUES (1, 's1', 'c1'),(1, 's2', 'c1'),(1, 's3', 'c1'),(2, 's1', 'c2'), (2,'s2','c2')))
+            ORDER BY ID
+            """
+    )
+    assert dindent(dcur.fetchall()) == [
+        {"ID": 1, "ANOTHER": "c1", "COLS": '[\n  "s1",\n  "s2",\n  "s3"\n]'},
+        {"ID": 2, "ANOTHER": "c2", "COLS": '[\n  "s1",\n  "s2"\n]'},
+    ]
+
 
 def test_array_agg_within_group(dcur: snowflake.connector.cursor.DictCursor):
     dcur.execute("CREATE TABLE table1 (ID INT, amount INT)")
@@ -202,6 +220,12 @@ def test_connect_reuse_db():
             assert cur.execute("select * from example").fetchall() == [(420,)]
 
 
+def test_connect_db_path_can_create_database() -> None:
+    with tempfile.TemporaryDirectory(prefix="fakesnow-test") as db_path, fakesnow.patch(db_path=db_path):
+        cursor = snowflake.connector.connect().cursor()
+        cursor.execute("CREATE DATABASE db2")
+
+
 def test_connect_without_database(_fakesnow_no_auto_create: None):
     with snowflake.connector.connect() as conn, conn.cursor() as cur:
         with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
@@ -790,6 +814,18 @@ def test_flatten(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert cur.fetchall() == [(1, '"banana"'), (2, '"coconut"'), (2, '"durian"')]
 
 
+def test_flatten_value_cast_as_varchar(cur: snowflake.connector.cursor.SnowflakeCursor):
+    cur.execute(
+        """
+        select id, f.value::varchar as v
+        from (select column1 as id, column2 as col from (values (1, 's1,s2,s3'), (2, 's1,s2'))) as t
+        , lateral flatten(input => split(t.col, ',')) as f order by id
+        """
+    )
+    # should be raw string not json string with double quotes
+    assert cur.fetchall() == [(1, "s1"), (1, "s2"), (1, "s3"), (2, "s1"), (2, "s2")]
+
+
 def test_floats_are_64bit(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("create or replace table example (f float, f4 float4, f8 float8, d double, r real)")
     cur.execute("insert into example values (1.23, 1.23, 1.23, 1.23, 1.23)")
@@ -1323,6 +1359,10 @@ def test_show_primary_keys(dcur: snowflake.connector.cursor.SnowflakeCursor):
     assert result3 == []
 
 
+def test_split(cur: snowflake.connector.cursor.SnowflakeCursor):
+    assert indent(cur.execute("select split('a,b,c', ',')").fetchall()) == [('[\n  "a",\n  "b",\n  "c"\n]',)]
+
+
 def test_sqlglot_regression(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert cur.execute(
         """with SOURCE_TABLE AS (SELECT '2024-01-01' AS start_date)

{fakesnow-0.9.15 → fakesnow-0.9.17}/tests/test_transforms.py

@@ -8,6 +8,7 @@ from fakesnow.transforms import (
     SUCCESS_NOP,
     _get_to_number_args,
     alias_in_join,
+    array_agg,
     array_agg_within_group,
     array_size,
     create_clone,
@@ -21,6 +22,7 @@ from fakesnow.transforms import (
     extract_comment_on_table,
     extract_text_length,
     flatten,
+    flatten_value_cast_as_varchar,
     float_to_double,
     identifier,
     indices_to_json_extract,
@@ -40,6 +42,7 @@ from fakesnow.transforms import (
     sha256,
     show_objects_tables,
     show_schemas,
+    split,
     tag,
     timestamp_ntz,
     to_date,
@@ -78,6 +81,22 @@ def test_array_size() -> None:
     )
 
 
+def test_array_agg() -> None:
+    assert (
+        sqlglot.parse_one("SELECT ARRAY_AGG(name) AS names FROM table1").transform(array_agg).sql(dialect="duckdb")
+        == "SELECT TO_JSON(ARRAY_AGG(name)) AS names FROM table1"
+    )
+
+    assert (
+        sqlglot.parse_one(
+            "SELECT DISTINCT ID, ANOTHER, ARRAY_AGG(DISTINCT COL) OVER(PARTITION BY ID) AS COLS FROM TEST"
+        )
+        .transform(array_agg)
+        .sql(dialect="duckdb")
+        == "SELECT DISTINCT ID, ANOTHER, TO_JSON(ARRAY_AGG(DISTINCT COL) OVER (PARTITION BY ID)) AS COLS FROM TEST"
+    )
+
+
 def test_array_agg_within_group() -> None:
     assert (
         sqlglot.parse_one(
@@ -400,6 +419,22 @@ def test_flatten() -> None:
     )
 
 
+def test_flatten_value_cast_as_varchar() -> None:
+    assert (
+        sqlglot.parse_one(
+            """
+            SELECT ID , F.VALUE::varchar as V
+            FROM TEST AS T
+            , LATERAL FLATTEN(input => SPLIT(T.COL, ',')) AS F;
+            """,
+            read="snowflake",
+        )
+        .transform(flatten_value_cast_as_varchar)
+        .sql(dialect="duckdb")
+        == """SELECT ID, F.VALUE ->> '$' AS V FROM TEST AS T, LATERAL UNNEST(input => STR_SPLIT(T.COL, ',')) AS F(SEQ, KEY, PATH, INDEX, VALUE, THIS)"""  # noqa: E501
+    )
+
+
 def test_float_to_double() -> None:
     assert (
         sqlglot.parse_one("create table example (f float, f4 float4, f8 float8, d double, r real)")
@@ -610,6 +645,12 @@ def test_show_schemas() -> None:
     )
 
 
+def test_split() -> None:
+    assert (
+        sqlglot.parse_one("SELECT split('a,b,c', ',')").transform(split).sql() == "SELECT TO_JSON(SPLIT('a,b,c', ','))"
+    )
+
+
 def test_tag() -> None:
     assert sqlglot.parse_one("ALTER TABLE table1 SET TAG foo='bar'", read="snowflake").transform(tag) == SUCCESS_NOP
     assert (