fakesnow 0.9.16__tar.gz → 0.9.18__tar.gz

{fakesnow-0.9.16 → fakesnow-0.9.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.16
+Version: 0.9.18
 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.16 → fakesnow-0.9.18}/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)
@@ -609,7 +611,7 @@ class FakeSnowflakeConnection:
         cursors = [
             self.cursor(cursor_class).execute(e.sql(dialect="snowflake"))
             for e in sqlglot.parse(sql_text, read="snowflake")
-            if e
+            if e and not isinstance(e, exp.Semicolon)  # ignore comments
         ]
         return cursors if return_cursors else []
 

{fakesnow-0.9.16 → fakesnow-0.9.18}/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
@@ -116,9 +119,11 @@ def create_database(expression: exp.Expression, db_path: Path | None = None) ->
         db_name = ident.this
         db_file = f"{db_path/db_name}.db" if db_path else ":memory:"
 
+        if_not_exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
+
         return exp.Command(
             this="ATTACH",
-            expression=exp.Literal(this=f"DATABASE '{db_file}' AS {db_name}", is_string=True),
+            expression=exp.Literal(this=f"{if_not_exists}DATABASE '{db_file}' AS {db_name}", is_string=True),
             create_db_name=db_name,
         )
 
@@ -436,7 +441,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 +465,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 +955,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.16 → fakesnow-0.9.18}/fakesnow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.16
+Version: 0.9.18
 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.16 → fakesnow-0.9.18}/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.16 → fakesnow-0.9.18}/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.16"
+version = "0.9.18"
 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.16 → fakesnow-0.9.18}/tests/test_fakes.py

@@ -15,6 +15,7 @@ import snowflake.connector.cursor
 import snowflake.connector.pandas_tools
 from pandas.testing import assert_frame_equal
 from snowflake.connector.cursor import ResultMetadata
+from snowflake.connector.errors import ProgrammingError
 
 import fakesnow
 from tests.utils import dindent, indent
@@ -54,7 +55,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 +64,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)")
@@ -324,6 +343,17 @@ def test_connect_with_non_existent_db_or_schema(_fakesnow_no_auto_create: None):
         assert conn.schema == "JAFFLES"
 
 
+def test_create_database_respects_if_not_exists() -> 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")
+
+        with pytest.raises(ProgrammingError, match='Database "DB2" is already attached with path'):
+            cursor.execute("CREATE DATABASE db2")  # Fails as db already exists.
+
+        cursor.execute("CREATE DATABASE IF NOT EXISTS db2")
+
+
 def test_dateadd_date_cast(dcur: snowflake.connector.DictCursor):
     q = """
     SELECT
@@ -678,11 +708,14 @@ def test_executemany(cur: snowflake.connector.cursor.SnowflakeCursor):
 
 
 def test_execute_string(conn: snowflake.connector.SnowflakeConnection):
-    [_, cur2] = conn.execute_string(
-        """ create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar);
-            select count(*) customers """
+    *_, cur = conn.execute_string(
+        """
+        create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar);
+        -- test comments are ignored
+        select count(*) customers
+        """
     )
-    assert cur2.fetchall() == [(1,)]
+    assert cur.fetchall() == [(1,)]
 
 
 def test_fetchall(conn: snowflake.connector.SnowflakeConnection):
@@ -796,6 +829,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)")
@@ -1329,6 +1374,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.16 → fakesnow-0.9.18}/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(
@@ -125,6 +144,13 @@ def test_create_database() -> None:
         == "ATTACH DATABASE '.databases/foobar.db' AS foobar"
     )
 
+    assert (
+        sqlglot.parse_one("create database if not exists foobar")
+        .transform(create_database, db_path=Path(".databases/"))
+        .sql()
+        == "ATTACH IF NOT EXISTS DATABASE '.databases/foobar.db' AS foobar"
+    )
+
 
 def test_describe_table() -> None:
     assert "SELECT" in sqlglot.parse_one("describe table db1.schema1.table1").transform(describe_table).sql()
@@ -400,6 +426,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 +652,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 (