fakesnow 0.9.12__tar.gz → 0.9.14__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.12
+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.12.2
+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.12 → fakesnow-0.9.14}/fakesnow/__init__.py

@@ -21,6 +21,7 @@ def patch(
     create_database_on_connect: bool = True,
     create_schema_on_connect: bool = True,
     db_path: str | os.PathLike | None = None,
+    nop_regexes: list[str] | None = None,
 ) -> Iterator[None]:
     """Patch snowflake targets with fakes.
 
@@ -36,8 +37,11 @@ def patch(
 
         create_database_on_connect (bool, optional): Create database if provided in connection. Defaults to True.
         create_schema_on_connect (bool, optional): Create schema if provided in connection. Defaults to True.
-        db_path (str | os.PathLike | None, optional): _description_. Use existing database files from this path
+        db_path (str | os.PathLike | None, optional): Use existing database files from this path
             or create them here if they don't already exist. If None databases are in-memory. Defaults to None.
+        nop_regexes (list[str] | None, optional): SQL statements matching these regexes (case-insensitive) will return
+            the success response without being run. Useful to skip over SQL commands that aren't implemented yet.
+            Defaults to None.
 
     Yields:
         Iterator[None]: None.
@@ -57,6 +61,7 @@ def patch(
             create_database=create_database_on_connect,
             create_schema=create_schema_on_connect,
             db_path=db_path,
+            nop_regexes=nop_regexes,
             **kwargs,
         ),
         snowflake.connector.pandas_tools.write_pandas: fakes.write_pandas,

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

@@ -135,8 +135,11 @@ class FakeSnowflakeCursor:
                 print(f"{command};{params=}" if params else f"{command};", file=sys.stderr)
 
             command, params = self._rewrite_with_params(command, params)
-            expression = parse_one(command, read="snowflake")
-            transformed = self._transform(expression)
+            if self._conn.nop_regexes and any(re.match(p, command, re.IGNORECASE) for p in self._conn.nop_regexes):
+                transformed = transforms.SUCCESS_NOP
+            else:
+                expression = parse_one(command, read="snowflake")
+                transformed = self._transform(expression)
             return self._execute(transformed, params)
         except snowflake.connector.errors.ProgrammingError as e:
             self._sqlstate = e.sqlstate
@@ -172,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)
@@ -195,6 +198,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.create_user)
             .transform(transforms.sha256)
             .transform(transforms.create_clone)
+            .transform(transforms.alias_in_join)
         )
 
     def _execute(
@@ -502,6 +506,7 @@ class FakeSnowflakeConnection:
         create_database: bool = True,
         create_schema: bool = True,
         db_path: str | os.PathLike | None = None,
+        nop_regexes: list[str] | None = None,
         *args: Any,
         **kwargs: Any,
     ):
@@ -513,6 +518,7 @@ class FakeSnowflakeConnection:
         self.database_set = False
         self.schema_set = False
         self.db_path = db_path
+        self.nop_regexes = nop_regexes
         self._paramstyle = snowflake.connector.paramstyle
 
         create_global_database(duck_conn)

{fakesnow-0.9.12 → 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,20 +1133,16 @@ 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.TIMESTAMP
-        and exp.DataTypeParam(this=exp.Literal(this="9", is_string=False)) in expression.expressions
-    ):
-        new = expression.copy()
-        del new.args["expressions"]
-        return new
+    if isinstance(expression, exp.DataType) and expression.this == exp.DataType.Type.TIMESTAMPNTZ:
+        return exp.DataType(this=exp.DataType.Type.TIMESTAMP)
 
     return expression
 
@@ -1175,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.12 → fakesnow-0.9.14}/fakesnow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.12
+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.12.2
+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.12 → fakesnow-0.9.14}/fakesnow.egg-info/SOURCES.txt

@@ -27,4 +27,5 @@ tests/test_info_schema.py
 tests/test_patch.py
 tests/test_sqlalchemy.py
 tests/test_transforms.py
-tests/test_users.py
+tests/test_users.py
+tests/test_write_pandas.py

{fakesnow-0.9.12 → 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.12.2
+sqlglot~=24.1.0
 
 [dev]
 build~=1.0

{fakesnow-0.9.12 → 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.12"
+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.12.2",
+    "sqlglot~=24.1.0",
 ]
 
 [project.urls]

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

@@ -5,9 +5,7 @@ from __future__ import annotations
 import datetime
 import json
 import tempfile
-from collections.abc import Sequence
 from decimal import Decimal
-from typing import cast
 
 import pandas as pd
 import pytest
@@ -19,6 +17,26 @@ from pandas.testing import assert_frame_equal
 from snowflake.connector.cursor import ResultMetadata
 
 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):
@@ -402,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
         )
         """
@@ -427,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),
@@ -470,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
         )
         """
@@ -508,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},
@@ -871,6 +891,12 @@ def test_identifier(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert cur.fetchall() == [(1,)]
 
 
+def test_nop_regexes():
+    with fakesnow.patch(nop_regexes=["^CALL.*"]), snowflake.connector.connect() as conn, conn.cursor() as cur:
+        cur.execute("call this_procedure_does_not_exist('foo', 'bar);")
+        assert cur.fetchall() == [("Statement executed successfully.",)]
+
+
 def test_non_existent_table_throws_snowflake_exception(cur: snowflake.connector.cursor.SnowflakeCursor):
     with pytest.raises(snowflake.connector.errors.ProgrammingError) as _:
         cur.execute("select * from this_table_does_not_exist")
@@ -1320,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):
@@ -1493,183 +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("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::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}]
-
-
-def test_write_pandas_auto_create(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor() as cur:
-        df = pd.DataFrame.from_records(
-            [
-                {"ID": 1, "FIRST_NAME": "Jenny"},
-                {"ID": 2, "FIRST_NAME": "Jasper"},
-            ]
-        )
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS", auto_create_table=True)
-
-        cur.execute("select id, first_name from customers")
-
-        assert cur.fetchall() == [(1, "Jenny"), (2, "Jasper")]
-
-
-def test_write_pandas_quoted_column_names(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor(snowflake.connector.cursor.DictCursor) as dcur:
-        # colunmn names with spaces
-        dcur.execute('create table customers (id int, "first name" varchar)')
-        df = pd.DataFrame.from_records(
-            [
-                {"ID": 1, "first name": "Jenny"},
-                {"ID": 2, "first name": "Jasper"},
-            ]
-        )
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
-
-        dcur.execute("select * from customers")
-
-        assert dcur.fetchall() == [
-            {"ID": 1, "first name": "Jenny"},
-            {"ID": 2, "first name": "Jasper"},
-        ]
-
-
-def test_write_pandas_array(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor() as cur:
-        cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar, ORDERS array)")
-
-        df = pd.DataFrame.from_records(
-            [
-                {"ID": 1, "FIRST_NAME": "Jenny", "LAST_NAME": "P", "ORDERS": ["A", "B"]},
-                {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M", "ORDERS": ["C", "D"]},
-            ]
-        )
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
-
-        cur.execute("select * from customers")
-
-        assert indent(cur.fetchall()) == [
-            (1, "Jenny", "P", '[\n  "A",\n  "B"\n]'),
-            (2, "Jasper", "M", '[\n  "C",\n  "D"\n]'),
-        ]
-
-
-def test_write_pandas_timestamp_ntz(conn: snowflake.connector.SnowflakeConnection):
-    # compensate for https://github.com/duckdb/duckdb/issues/7980
-    with conn.cursor() as cur:
-        cur.execute("create table example (UPDATE_AT_NTZ timestamp_ntz(9))")
-        # cur.execute("create table example (UPDATE_AT_NTZ timestamp)")
-
-        now_utc = datetime.datetime.now(pytz.utc)
-        df = pd.DataFrame([(now_utc,)], columns=["UPDATE_AT_NTZ"])
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "EXAMPLE")
-
-        cur.execute("select * from example")
-
-        assert cur.fetchall() == [(now_utc.replace(tzinfo=None),)]
-
+    dcur.execute("""INSERT INTO example SELECT PARSE_JSON('{"str": "100", "num" : 200}')""")
 
-def test_write_pandas_partial_columns(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor() as cur:
-        cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
-
-        df = pd.DataFrame.from_records(
-            [
-                {"ID": 1, "FIRST_NAME": "Jenny"},
-                {"ID": 2, "FIRST_NAME": "Jasper"},
-            ]
-        )
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
-
-        cur.execute("select id, first_name, last_name from customers")
-
-        # columns not in dataframe will receive their default value
-        assert cur.fetchall() == [(1, "Jenny", None), (2, "Jasper", None)]
-
-
-def test_write_pandas_dict_as_varchar(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor() as cur:
-        cur.execute("create or replace table example (vc varchar, o object)")
-
-        df = pd.DataFrame([({"kind": "vc", "count": 1}, {"kind": "obj", "amount": 2})], columns=["VC", "O"])
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "EXAMPLE")
-
-        cur.execute("select * from example")
-
-        # returned values are valid json strings
-        # NB: snowflake orders object keys alphabetically, we don't
-        r = cur.fetchall()
-        assert [(sort_keys(r[0][0], indent=None), sort_keys(r[0][1], indent=2))] == [
-            ('{"count":1,"kind":"vc"}', '{\n  "amount": 2,\n  "kind": "obj"\n}')
-        ]
-
-
-def test_write_pandas_dict_different_keys(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor() as cur:
-        cur.execute("create or replace table customers (notes variant)")
-
-        df = pd.DataFrame.from_records(
-            [
-                # rows have dicts with unique keys and values
-                {"NOTES": {"k": "v1"}},
-                # test single and double quoting
-                {"NOTES": {"k2": ["v'2", 'v"3']}},
-            ]
-        )
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
+    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"}]
 
-        cur.execute("select * from customers")
-
-        assert indent(cur.fetchall()) == [('{\n  "k": "v1"\n}',), ('{\n  "k2": [\n    "v\'2",\n    "v\\"3"\n  ]\n}',)]
-
-
-def test_write_pandas_db_schema(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor() as cur:
-        cur.execute("create database db2")
-        cur.execute("create schema db2.schema2")
-        cur.execute("create or replace table db2.schema2.customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
-
-        df = pd.DataFrame.from_records(
-            [
-                {"ID": 1, "FIRST_NAME": "Jenny"},
-                {"ID": 2, "FIRST_NAME": "Jasper"},
-            ]
-        )
-        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS", "DB2", "SCHEMA2")
-
-        cur.execute("select id, first_name, last_name from db2.schema2.customers")
-
-        # columns not in dataframe will receive their default value
-        assert cur.fetchall() == [(1, "Jenny", None), (2, "Jasper", None)]
-
-
-def indent(rows: Sequence[tuple] | Sequence[dict]) -> list[tuple]:
-    # indent duckdb json strings tuple values to match snowflake json strings
-    assert isinstance(rows[0], tuple)
-    return [
-        (*[json.dumps(json.loads(c), indent=2) if (isinstance(c, str) and c.startswith(("[", "{"))) else c for c in r],)
-        for r in rows
-    ]
-
-
-def dindent(rows: Sequence[tuple] | Sequence[dict]) -> list[dict]:
-    # indent duckdb json strings dict values to match snowflake json strings
-    assert isinstance(rows[0], dict)
-    return [
-        {
-            k: json.dumps(json.loads(v), indent=2) if (isinstance(v, str) and v.startswith(("[", "{"))) else v
-            for k, v in cast(dict, r).items()
-        }
-        for r in rows
-    ]
-
-
-def sort_keys(sdict: str, indent: int | None = 2) -> str:
-    return json.dumps(
-        json.loads(sdict, object_pairs_hook=lambda x: dict(sorted(x))),
-        indent=indent,
-        separators=None if indent else (",", ":"),
-    )
+    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.12 → 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.12 → 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))"""
     )
 
 
@@ -594,12 +612,24 @@ def test_show_schemas() -> None:
 
 def test_tag() -> None:
     assert sqlglot.parse_one("ALTER TABLE table1 SET TAG foo='bar'", read="snowflake").transform(tag) == SUCCESS_NOP
+    assert (
+        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)"
     )

fakesnow-0.9.14/tests/test_write_pandas.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import datetime
+import json
+
+import pandas as pd
+import pytz
+import snowflake.connector
+import snowflake.connector.cursor
+import snowflake.connector.pandas_tools
+
+from tests.utils import indent
+
+
+def test_write_pandas_auto_create(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        df = pd.DataFrame.from_records(
+            [
+                {"ID": 1, "FIRST_NAME": "Jenny"},
+                {"ID": 2, "FIRST_NAME": "Jasper"},
+            ]
+        )
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS", auto_create_table=True)
+
+        cur.execute("select id, first_name from customers")
+
+        assert cur.fetchall() == [(1, "Jenny"), (2, "Jasper")]
+
+
+def test_write_pandas_quoted_column_names(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor(snowflake.connector.cursor.DictCursor) as dcur:
+        # colunmn names with spaces
+        dcur.execute('create table customers (id int, "first name" varchar)')
+        df = pd.DataFrame.from_records(
+            [
+                {"ID": 1, "first name": "Jenny"},
+                {"ID": 2, "first name": "Jasper"},
+            ]
+        )
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
+
+        dcur.execute("select * from customers")
+
+        assert dcur.fetchall() == [
+            {"ID": 1, "first name": "Jenny"},
+            {"ID": 2, "first name": "Jasper"},
+        ]
+
+
+def test_write_pandas_array(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar, ORDERS array)")
+
+        df = pd.DataFrame.from_records(
+            [
+                {"ID": 1, "FIRST_NAME": "Jenny", "LAST_NAME": "P", "ORDERS": ["A", "B"]},
+                {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M", "ORDERS": ["C", "D"]},
+            ]
+        )
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
+
+        cur.execute("select * from customers")
+
+        assert indent(cur.fetchall()) == [
+            (1, "Jenny", "P", '[\n  "A",\n  "B"\n]'),
+            (2, "Jasper", "M", '[\n  "C",\n  "D"\n]'),
+        ]
+
+
+def test_write_pandas_timestamp_ntz(conn: snowflake.connector.SnowflakeConnection):
+    # compensate for https://github.com/duckdb/duckdb/issues/7980
+    with conn.cursor() as cur:
+        cur.execute("create table example (UPDATE_AT_NTZ timestamp_ntz(9))")
+        # cur.execute("create table example (UPDATE_AT_NTZ timestamp)")
+
+        now_utc = datetime.datetime.now(pytz.utc)
+        df = pd.DataFrame([(now_utc,)], columns=["UPDATE_AT_NTZ"])
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "EXAMPLE")
+
+        cur.execute("select * from example")
+
+        assert cur.fetchall() == [(now_utc.replace(tzinfo=None),)]
+
+
+def test_write_pandas_partial_columns(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
+
+        df = pd.DataFrame.from_records(
+            [
+                {"ID": 1, "FIRST_NAME": "Jenny"},
+                {"ID": 2, "FIRST_NAME": "Jasper"},
+            ]
+        )
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
+
+        cur.execute("select id, first_name, last_name from customers")
+
+        # columns not in dataframe will receive their default value
+        assert cur.fetchall() == [(1, "Jenny", None), (2, "Jasper", None)]
+
+
+def test_write_pandas_dict_as_varchar(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        cur.execute("create or replace table example (vc varchar, o object)")
+
+        df = pd.DataFrame([({"kind": "vc", "count": 1}, {"kind": "obj", "amount": 2})], columns=["VC", "O"])
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "EXAMPLE")
+
+        cur.execute("select * from example")
+
+        # returned values are valid json strings
+        # NB: snowflake orders object keys alphabetically, we don't
+        r = cur.fetchall()
+        assert [(sort_keys(r[0][0], indent=None), sort_keys(r[0][1], indent=2))] == [
+            ('{"count":1,"kind":"vc"}', '{\n  "amount": 2,\n  "kind": "obj"\n}')
+        ]
+
+
+def test_write_pandas_dict_different_keys(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        cur.execute("create or replace table customers (notes variant)")
+
+        df = pd.DataFrame.from_records(
+            [
+                # rows have dicts with unique keys and values
+                {"NOTES": {"k": "v1"}},
+                # test single and double quoting
+                {"NOTES": {"k2": ["v'2", 'v"3']}},
+            ]
+        )
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS")
+
+        cur.execute("select * from customers")
+
+        assert indent(cur.fetchall()) == [('{\n  "k": "v1"\n}',), ('{\n  "k2": [\n    "v\'2",\n    "v\\"3"\n  ]\n}',)]
+
+
+def test_write_pandas_db_schema(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        cur.execute("create database db2")
+        cur.execute("create schema db2.schema2")
+        cur.execute("create or replace table db2.schema2.customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
+
+        df = pd.DataFrame.from_records(
+            [
+                {"ID": 1, "FIRST_NAME": "Jenny"},
+                {"ID": 2, "FIRST_NAME": "Jasper"},
+            ]
+        )
+        snowflake.connector.pandas_tools.write_pandas(conn, df, "CUSTOMERS", "DB2", "SCHEMA2")
+
+        cur.execute("select id, first_name, last_name from db2.schema2.customers")
+
+        # columns not in dataframe will receive their default value
+        assert cur.fetchall() == [(1, "Jenny", None), (2, "Jasper", None)]
+
+
+def sort_keys(sdict: str, indent: int | None = 2) -> str:
+    return json.dumps(
+        json.loads(sdict, object_pairs_hook=lambda x: dict(sorted(x))),
+        indent=indent,
+        separators=None if indent else (",", ":"),
+    )