fakesnow 0.9.13__tar.gz → 0.9.14__tar.gz

{fakesnow-0.9.13 → fakesnow-0.9.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.13
+Version: 0.9.14
 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.0
+Requires-Dist: duckdb~=0.10.3
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=23.14.0
+Requires-Dist: sqlglot~=24.1.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

{fakesnow-0.9.13 → fakesnow-0.9.14}/fakesnow/fakes.py

@@ -175,7 +175,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.to_timestamp_ntz)
             .transform(transforms.to_timestamp)
             .transform(transforms.object_construct)
-            .transform(transforms.timestamp_ntz_ns)
+            .transform(transforms.timestamp_ntz)
             .transform(transforms.float_to_double)
             .transform(transforms.integer_precision)
             .transform(transforms.extract_text_length)
@@ -198,6 +198,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.create_user)
             .transform(transforms.sha256)
             .transform(transforms.create_clone)
+            .transform(transforms.alias_in_join)
         )
 
     def _execute(

{fakesnow-0.9.13 → fakesnow-0.9.14}/fakesnow/transforms.py

@@ -13,6 +13,25 @@ MISSING_DATABASE = "missing_database"
 SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.'")
 
 
+def alias_in_join(expression: exp.Expression) -> exp.Expression:
+    if (
+        isinstance(expression, exp.Select)
+        and (aliases := {e.args.get("alias"): e for e in expression.expressions if isinstance(e, exp.Alias)})
+        and (joins := expression.args.get("joins"))
+    ):
+        j: exp.Join
+        for j in joins:
+            if (
+                (on := j.args.get("on"))
+                and (col := on.this)
+                and (isinstance(col, exp.Column))
+                and (alias := aliases.get(col.this))
+            ):
+                col.args["this"] = alias.this
+
+    return expression
+
+
 def array_size(expression: exp.Expression) -> exp.Expression:
     if isinstance(expression, exp.ArraySize):
         # case is used to convert 0 to null, because null is returned by duckdb when no case matches
@@ -350,17 +369,13 @@ def extract_comment_on_table(expression: exp.Expression) -> exp.Expression:
         return new
     elif (
         isinstance(expression, exp.AlterTable)
-        and (sexp := expression.find(exp.Set))
-        and not sexp.args["tag"]
-        and (eq := sexp.find(exp.EQ))
-        and (eid := eq.find(exp.Identifier))
-        and isinstance(eid.this, str)
-        and eid.this.upper() == "COMMENT"
-        and (lit := eq.find(exp.Literal))
+        and (sexp := expression.find(exp.AlterSet))
+        and (scp := sexp.find(exp.SchemaCommentProperty))
+        and isinstance(scp.this, exp.Literal)
         and (table := expression.find(exp.Table))
     ):
         new = SUCCESS_NOP.copy()
-        new.args["table_comment"] = (table, lit.this)
+        new.args["table_comment"] = (table, scp.this.this)
         return new
 
     return expression
@@ -596,15 +611,12 @@ def json_extract_cast_as_varchar(expression: exp.Expression) -> exp.Expression:
     """
     if (
         isinstance(expression, exp.Cast)
-        and (to := expression.to)
-        and isinstance(to, exp.DataType)
-        and to.this in {exp.DataType.Type.VARCHAR, exp.DataType.Type.TEXT}
         and (je := expression.this)
         and isinstance(je, exp.JSONExtract)
         and (path := je.expression)
         and isinstance(path, exp.JSONPath)
     ):
-        return exp.JSONExtractScalar(this=je.this, expression=path)
+        je.replace(exp.JSONExtractScalar(this=je.this, expression=path))
     return expression
 
 
@@ -937,7 +949,7 @@ def tag(expression: exp.Expression) -> exp.Expression:
 
     if isinstance(expression, exp.AlterTable) and (actions := expression.args.get("actions")):
         for a in actions:
-            if isinstance(a, exp.Set) and a.args["tag"]:
+            if isinstance(a, exp.AlterSet) and a.args.get("tag"):
                 return SUCCESS_NOP
     elif (
         isinstance(expression, exp.Command)
@@ -947,6 +959,13 @@ def tag(expression: exp.Expression) -> exp.Expression:
     ):
         # alter table modify column set tag
         return SUCCESS_NOP
+    elif (
+        isinstance(expression, exp.Create)
+        and (kind := expression.args.get("kind"))
+        and isinstance(kind, str)
+        and kind.upper() == "TAG"
+    ):
+        return SUCCESS_NOP
 
     return expression
 
@@ -1114,17 +1133,15 @@ def to_timestamp_ntz(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def timestamp_ntz_ns(expression: exp.Expression) -> exp.Expression:
-    """Convert timestamp_ntz(9) to timestamp_ntz.
+def timestamp_ntz(expression: exp.Expression) -> exp.Expression:
+    """Convert timestamp_ntz (snowflake) to timestamp (duckdb).
 
-    To compensate for https://github.com/duckdb/duckdb/issues/7980
+    NB: timestamp_ntz defaults to nanosecond precision (ie: NTZ(9)). The duckdb equivalent is TIMESTAMP_NS.
+    However we use TIMESTAMP (ie: microsecond precision) here rather than TIMESTAMP_NS to avoid
+    https://github.com/duckdb/duckdb/issues/7980 in test_write_pandas_timestamp_ntz.
     """
 
-    if (
-        isinstance(expression, exp.DataType)
-        and expression.this == exp.DataType.Type.TIMESTAMPNTZ
-        and exp.DataTypeParam(this=exp.Literal(this="9", is_string=False)) in expression.expressions
-    ):
+    if isinstance(expression, exp.DataType) and expression.this == exp.DataType.Type.TIMESTAMPNTZ:
         return exp.DataType(this=exp.DataType.Type.TIMESTAMP)
 
     return expression
@@ -1173,7 +1190,6 @@ def try_parse_json(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-# sqlglot.parse_one("create table example(date TIMESTAMP_NTZ(9));", read="snowflake")
 def semi_structured_types(expression: exp.Expression) -> exp.Expression:
     """Convert OBJECT, ARRAY, and VARIANT types to duckdb compatible types.
 

{fakesnow-0.9.13 → fakesnow-0.9.14}/fakesnow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.13
+Version: 0.9.14
 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.0
+Requires-Dist: duckdb~=0.10.3
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=23.14.0
+Requires-Dist: sqlglot~=24.1.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

{fakesnow-0.9.13 → fakesnow-0.9.14}/fakesnow.egg-info/requires.txt

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

{fakesnow-0.9.13 → fakesnow-0.9.14}/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.13"
+version = "0.9.14"
 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.0",
+    "duckdb~=0.10.3",
     "pyarrow",
     "snowflake-connector-python",
-    "sqlglot~=23.14.0",
+    "sqlglot~=24.1.0",
 ]
 
 [project.urls]

{fakesnow-0.9.13 → fakesnow-0.9.14}/tests/test_fakes.py

@@ -20,6 +20,25 @@ import fakesnow
 from tests.utils import dindent, indent
 
 
+def test_alias_on_join(conn: snowflake.connector.SnowflakeConnection):
+    *_, cur = conn.execute_string(
+        """
+        CREATE OR REPLACE TEMPORARY TABLE TEST (COL VARCHAR);
+        INSERT INTO TEST (COL) VALUES ('VARCHAR1'), ('VARCHAR2');
+        CREATE OR REPLACE TEMPORARY TABLE JOINED (COL VARCHAR, ANOTHER VARCHAR);
+        INSERT INTO JOINED (COL, ANOTHER) VALUES ('CHAR1', 'JOIN');
+        SELECT
+            T.COL
+            , SUBSTR(T.COL, 4) AS ALIAS
+            , J.ANOTHER
+        FROM TEST AS T
+        LEFT JOIN JOINED AS J
+        ON ALIAS = J.COL;
+        """
+    )
+    assert cur.fetchall() == [("VARCHAR1", "CHAR1", "JOIN"), ("VARCHAR2", "CHAR2", None)]
+
+
 def test_alter_table(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("create table table1 (id int)")
     cur.execute("alter table table1 add column name varchar(20)")
@@ -401,7 +420,7 @@ def test_describe(cur: snowflake.connector.cursor.SnowflakeCursor):
             XNUMBER82 NUMBER(8,2), XNUMBER NUMBER, XDECIMAL DECIMAL, XNUMERIC NUMERIC,
             XINT INT, XINTEGER INTEGER, XBIGINT BIGINT, XSMALLINT SMALLINT, XTINYINT TINYINT, XBYTEINT BYTEINT,
             XVARCHAR20 VARCHAR(20), XVARCHAR VARCHAR, XTEXT TEXT,
-            XTIMESTAMP TIMESTAMP, XTIMESTAMP_NTZ9 TIMESTAMP_NTZ(9), XTIMESTAMP_TZ TIMESTAMP_TZ, XDATE DATE, XTIME TIME,
+            XTIMESTAMP TIMESTAMP, XTIMESTAMP_NTZ TIMESTAMP_NTZ, XTIMESTAMP_NTZ9 TIMESTAMP_NTZ(9), XTIMESTAMP_TZ TIMESTAMP_TZ, XDATE DATE, XTIME TIME,
             XBINARY BINARY, /* XARRAY ARRAY, XOBJECT OBJECT */ XVARIANT VARIANT
         )
         """
@@ -426,6 +445,7 @@ def test_describe(cur: snowflake.connector.cursor.SnowflakeCursor):
         ResultMetadata(name='XVARCHAR', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
         ResultMetadata(name='XTEXT', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
         ResultMetadata(name='XTIMESTAMP', type_code=8, display_size=None, internal_size=None, precision=0, scale=9, is_nullable=True),
+        ResultMetadata(name='XTIMESTAMP_NTZ', type_code=8, display_size=None, internal_size=None, precision=0, scale=9, is_nullable=True),
         ResultMetadata(name='XTIMESTAMP_NTZ9', type_code=8, display_size=None, internal_size=None, precision=0, scale=9, is_nullable=True),
         ResultMetadata(name='XTIMESTAMP_TZ', type_code=7, display_size=None, internal_size=None, precision=0, scale=9, is_nullable=True),
         ResultMetadata(name='XDATE', type_code=3, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
@@ -469,7 +489,7 @@ def test_describe_table(dcur: snowflake.connector.cursor.DictCursor):
             XNUMBER82 NUMBER(8,2), XNUMBER NUMBER, XDECIMAL DECIMAL, XNUMERIC NUMERIC,
             XINT INT, XINTEGER INTEGER, XBIGINT BIGINT, XSMALLINT SMALLINT, XTINYINT TINYINT, XBYTEINT BYTEINT,
             XVARCHAR20 VARCHAR(20), XVARCHAR VARCHAR, XTEXT TEXT,
-            XTIMESTAMP TIMESTAMP, XTIMESTAMP_NTZ9 TIMESTAMP_NTZ(9), XTIMESTAMP_TZ TIMESTAMP_TZ, XDATE DATE, XTIME TIME,
+            XTIMESTAMP TIMESTAMP, XTIMESTAMP_NTZ TIMESTAMP_NTZ, XTIMESTAMP_NTZ9 TIMESTAMP_NTZ(9), XTIMESTAMP_TZ TIMESTAMP_TZ, XDATE DATE, XTIME TIME,
             XBINARY BINARY, /* XARRAY ARRAY, XOBJECT OBJECT */ XVARIANT VARIANT
         )
         """
@@ -507,6 +527,7 @@ def test_describe_table(dcur: snowflake.connector.cursor.DictCursor):
         {"name": "XVARCHAR", "type": "VARCHAR(16777216)", **common},
         {"name": "XTEXT", "type": "VARCHAR(16777216)", **common},
         {"name": "XTIMESTAMP", "type": "TIMESTAMP_NTZ(9)", **common},
+        {"name": "XTIMESTAMP_NTZ", "type": "TIMESTAMP_NTZ(9)", **common},
         {"name": "XTIMESTAMP_NTZ9", "type": "TIMESTAMP_NTZ(9)", **common},
         {"name": "XTIMESTAMP_TZ", "type": "TIMESTAMP_TZ(9)", **common},
         {"name": "XDATE", "type": "DATE", **common},
@@ -1325,6 +1346,7 @@ def test_tags_noop(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("CREATE TABLE table1 (id int)")
     cur.execute("ALTER TABLE table1 SET TAG foo='bar'")
     cur.execute("ALTER TABLE table1 MODIFY COLUMN name1 SET TAG foo='bar'")
+    cur.execute("CREATE TAG cost_center COMMENT = 'cost_center tag'")
 
 
 def test_to_timestamp(cur: snowflake.connector.cursor.SnowflakeCursor):
@@ -1498,10 +1520,10 @@ def test_values(conn: snowflake.connector.SnowflakeConnection):
 
 def test_json_extract_cast_as_varchar(dcur: snowflake.connector.cursor.DictCursor):
     dcur.execute("CREATE TABLE example (j VARIANT)")
-    dcur.execute("""INSERT INTO example SELECT PARSE_JSON('{"str": "100", "number" : 100}')""")
+    dcur.execute("""INSERT INTO example SELECT PARSE_JSON('{"str": "100", "num" : 200}')""")
 
-    dcur.execute("SELECT j:str::varchar as c_str_varchar, j:number::varchar as c_num_varchar  FROM example")
-    assert dcur.fetchall() == [{"C_STR_VARCHAR": "100", "C_NUM_VARCHAR": "100"}]
+    dcur.execute("SELECT j:str::varchar as j_str_varchar, j:num::varchar as j_num_varchar FROM example")
+    assert dcur.fetchall() == [{"J_STR_VARCHAR": "100", "J_NUM_VARCHAR": "200"}]
 
-    dcur.execute("SELECT j:str::number as c_str_number, j:number::number as c_num_number  FROM example")
-    assert dcur.fetchall() == [{"C_STR_NUMBER": 100, "C_NUM_NUMBER": 100}]
+    dcur.execute("SELECT j:str::number as j_str_number, j:num::number as j_num_number FROM example")
+    assert dcur.fetchall() == [{"J_STR_NUMBER": 100, "J_NUM_NUMBER": 200}]

{fakesnow-0.9.13 → fakesnow-0.9.14}/tests/test_info_schema.py

@@ -79,7 +79,7 @@ def test_info_schema_columns_other(cur: snowflake.connector.cursor.SnowflakeCurs
     cur.execute(
         """
         create or replace table example (
-            XTIMESTAMP TIMESTAMP, XTIMESTAMP_NTZ9 TIMESTAMP_NTZ(9), XTIMESTAMP_TZ TIMESTAMP_TZ, XDATE DATE, XTIME TIME,
+            XTIMESTAMP TIMESTAMP, XTIMESTAMP_NTZ TIMESTAMP_NTZ, XTIMESTAMP_NTZ9 TIMESTAMP_NTZ(9), XTIMESTAMP_TZ TIMESTAMP_TZ, XDATE DATE, XTIME TIME,
             XBINARY BINARY, /* XARRAY ARRAY, XOBJECT OBJECT */ XVARIANT VARIANT
         )
         """
@@ -94,6 +94,7 @@ def test_info_schema_columns_other(cur: snowflake.connector.cursor.SnowflakeCurs
 
     assert cur.fetchall() == [
         ("XTIMESTAMP", "TIMESTAMP_NTZ"),
+        ("XTIMESTAMP_NTZ", "TIMESTAMP_NTZ"),
         ("XTIMESTAMP_NTZ9", "TIMESTAMP_NTZ"),
         ("XTIMESTAMP_TZ", "TIMESTAMP_TZ"),
         ("XDATE", "DATE"),
@@ -180,7 +181,7 @@ def test_info_schema_views_with_views(conn: snowflake.connector.SnowflakeConnect
                 "table_schema": "SCHEMA1",
                 "table_name": "BAR",
                 "table_owner": "SYSADMIN",
-                "view_definition": "CREATE VIEW SCHEMA1.BAR AS SELECT * FROM FOO WHERE (ID > 5);\n",
+                "view_definition": "CREATE VIEW SCHEMA1.BAR AS SELECT * FROM FOO WHERE (ID > 5);",
                 "check_option": "NONE",
                 "is_updatable": "NO",
                 "insertable_into": "NO",

{fakesnow-0.9.13 → fakesnow-0.9.14}/tests/test_transforms.py

@@ -7,6 +7,7 @@ from sqlglot import exp
 from fakesnow.transforms import (
     SUCCESS_NOP,
     _get_to_number_args,
+    alias_in_join,
     array_agg_within_group,
     array_size,
     create_clone,
@@ -40,7 +41,7 @@ from fakesnow.transforms import (
     show_objects_tables,
     show_schemas,
     tag,
-    timestamp_ntz_ns,
+    timestamp_ntz,
     to_date,
     to_decimal,
     to_timestamp,
@@ -53,6 +54,23 @@ from fakesnow.transforms import (
 )
 
 
+def test_alias_in_join() -> None:
+    assert (
+        sqlglot.parse_one("""
+            SELECT
+                T.COL
+                , SUBSTR(T.COL, 4) AS ALIAS
+                , J.ANOTHER
+            FROM TEST AS T
+            LEFT JOIN JOINED AS J
+            ON ALIAS = J.COL
+        """)
+        .transform(alias_in_join)
+        .sql()
+        == "SELECT T.COL, SUBSTR(T.COL, 4) AS ALIAS, J.ANOTHER FROM TEST AS T LEFT JOIN JOINED AS J ON SUBSTR(T.COL, 4) = J.COL"  # noqa: E501
+    )
+
+
 def test_array_size() -> None:
     assert (
         sqlglot.parse_one("""select array_size(parse_json('["a","b"]'))""").transform(array_size).sql(dialect="duckdb")
@@ -114,7 +132,7 @@ def test_describe_table() -> None:
 
 def test_drop_schema_cascade() -> None:
     assert (
-        sqlglot.parse_one("drop schema schema1").transform(drop_schema_cascade).sql() == "DROP schema schema1 CASCADE"
+        sqlglot.parse_one("drop schema schema1").transform(drop_schema_cascade).sql() == "DROP SCHEMA schema1 CASCADE"
     )
 
 
@@ -422,7 +440,7 @@ def test_integer_precision() -> None:
         )
         .transform(integer_precision)
         .sql(dialect="duckdb")
-        == "CREATE TABLE example (XNUMBER82 DECIMAL(8, 2), XNUMBER BIGINT, XDECIMAL BIGINT, XNUMERIC BIGINT, XINT BIGINT, XINTEGER BIGINT, XBIGINT BIGINT, XSMALLINT BIGINT, XTINYINT BIGINT, XBYTEINT BIGINT)"  # noqa: E501
+        == "CREATE TABLE example (XNUMBER82 DECIMAL(8, 2), XNUMBER DECIMAL(38, 0), XDECIMAL DECIMAL(38, 0), XNUMERIC DECIMAL(38, 0), XINT BIGINT, XINTEGER BIGINT, XBIGINT BIGINT, XSMALLINT BIGINT, XTINYINT BIGINT, XBYTEINT BIGINT)"  # noqa: E501
     )
 
 
@@ -471,17 +489,17 @@ def test_json_extract_cast_as_varchar() -> None:
         )
         .transform(json_extract_cast_as_varchar)
         .sql(dialect="duckdb")
-        == """SELECT JSON('{"fruit":"banana"}') ->> '$.fruit'"""
+        == """SELECT CAST(JSON('{"fruit":"banana"}') ->> '$.fruit' AS TEXT)"""
     )
 
     assert (
         sqlglot.parse_one(
-            """select parse_json('{"fruit":"9000"}'):fruit::number""",
+            """select parse_json('{"count":"9000"}'):count::number""",
             read="snowflake",
         )
         .transform(json_extract_cast_as_varchar)
         .sql(dialect="duckdb")
-        == """SELECT CAST(JSON('{"fruit":"9000"}') -> '$.fruit' AS DECIMAL)"""
+        == """SELECT CAST(JSON('{"count":"9000"}') ->> '$.count' AS DECIMAL(38, 0))"""
     )
 
 
@@ -598,12 +616,20 @@ def test_tag() -> None:
         sqlglot.parse_one("ALTER TABLE db1.schema1.table1 SET TAG foo.bar='baz'", read="snowflake").transform(tag)
         == SUCCESS_NOP
     )
+    assert (
+        sqlglot.parse_one("ALTER TABLE table1 MODIFY COLUMN name1 SET TAG foo='bar'", read="snowflake").transform(tag)
+        == SUCCESS_NOP
+    )
+    assert (
+        sqlglot.parse_one("CREATE TAG cost_center COMMENT = 'cost_center tag'", read="snowflake").transform(tag)
+        == SUCCESS_NOP
+    )
 
 
 def test_timestamp_ntz_ns() -> None:
     assert (
         sqlglot.parse_one("CREATE TABLE table1(ts TIMESTAMP_NTZ(9))", read="snowflake")
-        .transform(timestamp_ntz_ns)
+        .transform(timestamp_ntz)
         .sql(dialect="duckdb")
         == "CREATE TABLE table1 (ts TIMESTAMP)"
     )