fakesnow 0.7.0__tar.gz → 0.8.0__tar.gz

{fakesnow-0.7.0/fakesnow.egg-info → fakesnow-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.7.0
+Version: 0.8.0
 Summary: Fake Snowflake Connector for Python. Run Snowflake DB locally.
 License: MIT License
         
@@ -28,9 +28,24 @@ Keywords: snowflake,snowflakedb,fake,local,mock,testing
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: duckdb~=0.9.2
+Requires-Dist: pyarrow
+Requires-Dist: snowflake-connector-python
+Requires-Dist: sqlglot~=19.5.1
 Provides-Extra: dev
+Requires-Dist: black~=23.9; extra == "dev"
+Requires-Dist: build~=1.0; extra == "dev"
+Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra == "dev"
+Requires-Dist: pre-commit~=3.4; extra == "dev"
+Requires-Dist: pytest~=7.4; extra == "dev"
+Requires-Dist: ruff~=0.1.6; extra == "dev"
+Requires-Dist: twine~=4.0; extra == "dev"
 Provides-Extra: notebook
-License-File: LICENSE
+Requires-Dist: duckdb-engine; extra == "notebook"
+Requires-Dist: ipykernel; extra == "notebook"
+Requires-Dist: jupysql; extra == "notebook"
+Requires-Dist: snowflake-sqlalchemy; extra == "notebook"
 
 # fakesnow ❄️
 

{fakesnow-0.7.0 → fakesnow-0.8.0}/fakesnow/__init__.py

@@ -4,11 +4,8 @@ import contextlib
 import importlib
 import sys
 import unittest.mock as mock
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
-from typing import (
-    Iterator,
-    Sequence,
-)
 
 import duckdb
 import snowflake.connector

{fakesnow-0.7.0 → fakesnow-0.8.0}/fakesnow/fakes.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Iterable, Iterator, Sequence
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, Optional, Sequence, Type, Union, cast
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union, cast
 
 import duckdb
 
@@ -55,9 +56,9 @@ class FakeSnowflakeCursor:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]] = ...,
-        exc_value: Optional[BaseException] = ...,
-        traceback: Optional[TracebackType] = ...,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> bool:
         return False
 
@@ -149,6 +150,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.values_columns)
             .transform(transforms.to_date)
             .transform(transforms.to_decimal)
+            .transform(transforms.to_timestamp)
             .transform(transforms.object_construct)
             .transform(transforms.timestamp_ntz_ns)
             .transform(transforms.float_to_double)
@@ -250,11 +252,11 @@ class FakeSnowflakeCursor:
         reader = self._duck_conn.fetch_record_batch(rows_per_batch=1000)
 
         batches = []
-        while True:
-            try:
+        try:
+            while True:
                 batches.append(FakeResultBatch(self._use_dict_result, reader.read_next_batch()))
-            except StopIteration:
-                break
+        except StopIteration:
+            pass
 
         return batches
 
@@ -320,13 +322,10 @@ class FakeSnowflakeCursor:
                 return ResultMetadata(
                     name=column_name, type_code=12, display_size=None, internal_size=None, precision=0, scale=9, is_nullable=True               # noqa: E501
                 )
-            elif column_type == "JSON[]":
-                return ResultMetadata(
-                    name=column_name, type_code=10, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True               # noqa: E501
-                )
             elif column_type == "JSON":
+                # TODO: correctly map OBJECT and ARRAY see https://github.com/tekumara/fakesnow/issues/26
                 return ResultMetadata(
-                    name=column_name, type_code=9, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True               # noqa: E501
+                    name=column_name, type_code=5, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True               # noqa: E501
                 )
             else:
                 # TODO handle more types
@@ -365,8 +364,8 @@ class FakeSnowflakeConnection:
     def __init__(
         self,
         duck_conn: DuckDBPyConnection,
-        database: Optional[str] = None,
-        schema: Optional[str] = None,
+        database: str | None = None,
+        schema: str | None = None,
         create_database: bool = True,
         create_schema: bool = True,
         *args: Any,
@@ -435,16 +434,16 @@ class FakeSnowflakeConnection:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]] = ...,
-        exc_value: Optional[BaseException] = ...,
-        traceback: Optional[TracebackType] = ...,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> bool:
         return False
 
     def commit(self) -> None:
         self.cursor().execute("COMMIT")
 
-    def cursor(self, cursor_class: Type[SnowflakeCursor] = SnowflakeCursor) -> FakeSnowflakeCursor:
+    def cursor(self, cursor_class: type[SnowflakeCursor] = SnowflakeCursor) -> FakeSnowflakeCursor:
         return FakeSnowflakeCursor(conn=self, duck_conn=self._duck_conn, use_dict_result=cursor_class == DictCursor)
 
     def execute_string(
@@ -452,7 +451,7 @@ class FakeSnowflakeConnection:
         sql_text: str,
         remove_comments: bool = False,
         return_cursors: bool = True,
-        cursor_class: Type[SnowflakeCursor] = SnowflakeCursor,
+        cursor_class: type[SnowflakeCursor] = SnowflakeCursor,
         **kwargs: dict[str, Any],
     ) -> Iterable[FakeSnowflakeCursor]:
         cursors = [

{fakesnow-0.7.0 → fakesnow-0.8.0}/fakesnow/fixtures.py

@@ -1,4 +1,4 @@
-from typing import Iterator
+from collections.abc import Iterator
 
 import pytest
 

{fakesnow-0.7.0 → fakesnow-0.8.0}/fakesnow/info_schema.py

@@ -40,8 +40,7 @@ case when starts_with(data_type, 'DECIMAL') or data_type='BIGINT' then 'NUMBER'
      when data_type='DOUBLE' then 'FLOAT'
      when data_type='BLOB' then 'BINARY'
      when data_type='TIMESTAMP' then 'TIMESTAMP_NTZ'
-     when data_type='JSON[]' then 'ARRAY'
-     when data_type='JSON' then 'OBJECT'
+     when data_type='JSON' then 'VARIANT'
      else data_type end as data_type,
 ext_character_maximum_length as character_maximum_length, ext_character_octet_length as character_octet_length,
 case when data_type='BIGINT' then 38

{fakesnow-0.7.0 → fakesnow-0.8.0}/fakesnow/transforms.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import cast
 
-import snowflake.connector
 import sqlglot
 from sqlglot import exp
 
@@ -140,7 +139,7 @@ def extract_text_length(expression: exp.Expression) -> exp.Expression:
         for dt in expression.find_all(exp.DataType):
             if dt.this in (exp.DataType.Type.VARCHAR, exp.DataType.Type.TEXT):
                 col_name = dt.parent and dt.parent.this and dt.parent.this.this
-                if dt_size := dt.find(exp.DataTypeSize):
+                if dt_size := dt.find(exp.DataTypeParam):
                     size = (
                         isinstance(dt_size.this, exp.Literal)
                         and isinstance(dt_size.this.this, str)
@@ -311,14 +310,8 @@ def parse_json(expression: exp.Expression) -> exp.Expression:
 def regex_replace(expression: exp.Expression) -> exp.Expression:
     """Transform regex_replace expressions from snowflake to duckdb."""
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "REGEXP_REPLACE"
-    ):
-        expressions = expression.expressions
-
-        if len(expressions) > 3:
+    if isinstance(expression, exp.RegexpReplace) and isinstance(expression.expression, exp.Literal):
+        if len(expression.args) > 3:
             # see https://docs.snowflake.com/en/sql-reference/functions/regexp_replace
             raise NotImplementedError(
                 "REGEXP_REPLACE with additional parameters (eg: <position>, <occurrence>, <parameters>) not supported"
@@ -326,64 +319,56 @@ def regex_replace(expression: exp.Expression) -> exp.Expression:
 
         # pattern: snowflake requires escaping backslashes in single-quoted string constants, but duckdb doesn't
         # see https://docs.snowflake.com/en/sql-reference/functions-regexp#label-regexp-escape-character-caveats
-        expressions[1].args["this"] = expressions[1].this.replace("\\\\", "\\")
+        expression.args["expression"] = exp.Literal(
+            this=expression.expression.this.replace("\\\\", "\\"), is_string=True
+        )
 
-        if len(expressions) == 2:
+        if not expression.args.get("replacement"):
             # if no replacement string, the snowflake default is ''
-            expressions.append(exp.Literal(this="", is_string=True))
+            expression.args["replacement"] = exp.Literal(this="", is_string=True)
 
         # snowflake regex replacements are global
-        expressions.append(exp.Literal(this="g", is_string=True))
+        expression.args["modifiers"] = exp.Literal(this="g", is_string=True)
 
     return expression
 
 
 def regex_substr(expression: exp.Expression) -> exp.Expression:
-    """Transform regex_substr expressions from snowflake to duckdb."""
-
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "REGEXP_SUBSTR"
-    ):
-        expressions = expression.expressions
+    """Transform regex_substr expressions from snowflake to duckdb.
 
-        if len(expressions) < 2:
-            raise snowflake.connector.errors.ProgrammingError(
-                msg=f"SQL compilation error:\nnot enough arguments for function [{expression.sql()}], expected 2, got {len(expressions)}",  # noqa: E501
-                errno=938,
-                sqlstate="22023",
-            )
+    See https://docs.snowflake.com/en/sql-reference/functions/regexp_substr
+    """
 
-        subject = expressions[0]
+    if isinstance(expression, exp.RegexpExtract):
+        subject = expression.this
 
         # pattern: snowflake requires escaping backslashes in single-quoted string constants, but duckdb doesn't
         # see https://docs.snowflake.com/en/sql-reference/functions-regexp#label-regexp-escape-character-caveats
-        pattern = expressions[1]
+        pattern = expression.expression
         pattern.args["this"] = pattern.this.replace("\\\\", "\\")
 
         # number of characters from the beginning of the string where the function starts searching for matches
         try:
-            position = expressions[2]
-        except IndexError:
+            position = expression.args["position"]
+        except KeyError:
             position = exp.Literal(this="1", is_string=False)
 
         # which occurrence of the pattern to match
         try:
-            occurrence = expressions[3]
-        except IndexError:
+            occurrence = expression.args["occurrence"]
+        except KeyError:
             occurrence = exp.Literal(this="1", is_string=False)
 
         try:
-            regex_parameters_value = str(expressions[4].this)
+            regex_parameters_value = str(expression.args["parameters"].this)
             # 'e' parameter doesn't make sense for duckdb
             regex_parameters = exp.Literal(this=regex_parameters_value.replace("e", ""), is_string=True)
-        except IndexError:
+        except KeyError:
             regex_parameters = exp.Literal(is_string=True)
 
         try:
-            group_num = expressions[5]
-        except IndexError:
+            group_num = expression.args["group"]
+        except KeyError:
             if isinstance(regex_parameters.this, str) and "e" in regex_parameters.this:
                 group_num = exp.Literal(this="1", is_string=False)
             else:
@@ -546,6 +531,20 @@ def to_decimal(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def to_timestamp(expression: exp.Expression) -> exp.Expression:
+    """Convert to_timestamp(seconds) to timestamp without timezone (ie: TIMESTAMP_NTZ).
+
+    See https://docs.snowflake.com/en/sql-reference/functions/to_timestamp
+    """
+
+    if isinstance(expression, exp.UnixToTime):
+        return exp.Cast(
+            this=expression,
+            to=exp.DataType(this=exp.DataType.Type.TIMESTAMP, nested=False, prefix=False),
+        )
+    return expression
+
+
 def timestamp_ntz_ns(expression: exp.Expression) -> exp.Expression:
     """Convert timestamp_ntz(9) to timestamp_ntz.
 
@@ -555,7 +554,7 @@ def timestamp_ntz_ns(expression: exp.Expression) -> exp.Expression:
     if (
         isinstance(expression, exp.DataType)
         and expression.this == exp.DataType.Type.TIMESTAMP
-        and exp.DataTypeSize(this=exp.Literal(this="9", is_string=False)) in expression.expressions
+        and exp.DataTypeParam(this=exp.Literal(this="9", is_string=False)) in expression.expressions
     ):
         new = expression.copy()
         del new.args["expressions"]
@@ -579,15 +578,14 @@ def semi_structured_types(expression: exp.Expression) -> exp.Expression:
         exp.Expression: The transformed expression.
     """
 
-    if isinstance(expression, exp.DataType):
-        if expression.this in [exp.DataType.Type.OBJECT, exp.DataType.Type.VARIANT]:
-            new = expression.copy()
-            new.args["this"] = exp.DataType.Type.JSON
-            return new
-        elif expression.this == exp.DataType.Type.ARRAY:
-            new = expression.copy()
-            new.set("expressions", [exp.DataType(this=exp.DataType.Type.JSON)])
-            return new
+    if isinstance(expression, exp.DataType) and expression.this in [
+        exp.DataType.Type.ARRAY,
+        exp.DataType.Type.OBJECT,
+        exp.DataType.Type.VARIANT,
+    ]:
+        new = expression.copy()
+        new.args["this"] = exp.DataType.Type.JSON
+        return new
 
     return expression
 

{fakesnow-0.7.0 → fakesnow-0.8.0/fakesnow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.7.0
+Version: 0.8.0
 Summary: Fake Snowflake Connector for Python. Run Snowflake DB locally.
 License: MIT License
         
@@ -28,9 +28,24 @@ Keywords: snowflake,snowflakedb,fake,local,mock,testing
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: duckdb~=0.9.2
+Requires-Dist: pyarrow
+Requires-Dist: snowflake-connector-python
+Requires-Dist: sqlglot~=19.5.1
 Provides-Extra: dev
+Requires-Dist: black~=23.9; extra == "dev"
+Requires-Dist: build~=1.0; extra == "dev"
+Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra == "dev"
+Requires-Dist: pre-commit~=3.4; extra == "dev"
+Requires-Dist: pytest~=7.4; extra == "dev"
+Requires-Dist: ruff~=0.1.6; extra == "dev"
+Requires-Dist: twine~=4.0; extra == "dev"
 Provides-Extra: notebook
-License-File: LICENSE
+Requires-Dist: duckdb-engine; extra == "notebook"
+Requires-Dist: ipykernel; extra == "notebook"
+Requires-Dist: jupysql; extra == "notebook"
+Requires-Dist: snowflake-sqlalchemy; extra == "notebook"
 
 # fakesnow ❄️
 

{fakesnow-0.7.0 → fakesnow-0.8.0}/fakesnow.egg-info/requires.txt

@@ -1,15 +1,15 @@
-duckdb~=0.8.0
+duckdb~=0.9.2
 pyarrow
 snowflake-connector-python
-sqlglot~=16.8.1
+sqlglot~=19.5.1
 
 [dev]
-black~=23.3
-build~=0.10
+black~=23.9
+build~=1.0
 snowflake-connector-python[pandas,secure-local-storage]
-pre-commit~=3.2
-pytest~=7.3
-ruff~=0.0.285
+pre-commit~=3.4
+pytest~=7.4
+ruff~=0.1.6
 twine~=4.0
 
 [notebook]

{fakesnow-0.7.0 → fakesnow-0.8.0}/pyproject.toml

@@ -1,17 +1,17 @@
 [project]
 name = "fakesnow"
 description = "Fake Snowflake Connector for Python. Run Snowflake DB locally."
-version = "0.7.0"
+version = "0.8.0"
 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.8.0",
+    "duckdb~=0.9.2",
     "pyarrow",
     "snowflake-connector-python",
-    "sqlglot~=16.8.1",
+    "sqlglot~=19.5.1",
 ]
 
 [project.urls]
@@ -19,27 +19,27 @@ homepage = "https://github.com/tekumara/fakesnow"
 
 [project.optional-dependencies]
 dev = [
-    "black~=23.3",
-    "build~=0.10",
+    "black~=23.9",
+    "build~=1.0",
     # include compatible version of pandas, and secure-local-storage for token caching
     "snowflake-connector-python[pandas, secure-local-storage]",
-    "pre-commit~=3.2",
-    "pytest~=7.3",
-    "ruff~=0.0.285",
+    "pre-commit~=3.4",
+    "pytest~=7.4",
+    "ruff~=0.1.6",
     "twine~=4.0",
 ]
 # for debugging, see https://duckdb.org/docs/guides/python/jupyter.html
 notebook = ["duckdb-engine", "ipykernel", "jupysql", "snowflake-sqlalchemy"]
 
-[build-system]
-requires = ["setuptools~=67.7", "wheel~=0.40"]
-
 [tool.setuptools.packages.find]
 where = ["."]
 exclude = ["tests*"]
 
-# use PyCharm default line length of 120
+[build-system]
+requires = ["setuptools~=68.2", "wheel~=0.40"]
+
 [tool.black]
+# use PyCharm default line length of 120
 line-length = 120
 
 [tool.pyright]
@@ -52,6 +52,8 @@ strictParameterNoneValue = true
 reportTypedDictNotRequiredAccess = false
 
 [tool.ruff]
+# Compatibility between Ruff and Black
+# https://beta.ruff.rs/docs/faq/#is-ruff-compatible-with-black
 line-length = 120
 
 # rules to enable/ignore
@@ -73,6 +75,10 @@ select = [
     # "ARG",
     # flake8-self
     "SLF",
+    # pyupgrade
+    "UP",
+    # perflint
+    "PERF",
     # ruff-specific
     "RUF",
 ]
@@ -89,9 +95,11 @@ src = ["."]
 fix = true
 show-fixes = true
 
+[tool.ruff.isort]
+combine-as-imports = true
+force-wrap-aliases = true
+
 [tool.ruff.per-file-ignores]
-# imports in __init__.py don't need to be used in __init__.py
-"__init__.py" = ["F401"]
 # test functions don't need return types
 "tests/*" = ["ANN201", "ANN202"]
 

{fakesnow-0.7.0 → fakesnow-0.8.0}/tests/test_fakes.py

@@ -2,6 +2,7 @@
 
 import datetime
 import json
+from collections.abc import Sequence
 from decimal import Decimal
 
 import pandas as pd
@@ -205,7 +206,7 @@ def test_describe(cur: snowflake.connector.cursor.SnowflakeCursor):
             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), XDATE DATE, XTIME TIME,
-            XBINARY BINARY, XARRAY ARRAY, XOBJECT OBJECT
+            XBINARY BINARY, /* XARRAY ARRAY, XOBJECT OBJECT */ XVARIANT VARIANT
         )
         """
     )
@@ -233,8 +234,10 @@ def test_describe(cur: snowflake.connector.cursor.SnowflakeCursor):
         ResultMetadata(name='XDATE', type_code=3, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
         ResultMetadata(name='XTIME', type_code=12, display_size=None, internal_size=None, precision=0, scale=9, is_nullable=True),
         ResultMetadata(name='XBINARY', type_code=11, display_size=None, internal_size=8388608, precision=None, scale=None, is_nullable=True),
-        ResultMetadata(name='XARRAY', type_code=10, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
-        ResultMetadata(name='XOBJECT', type_code=9, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
+        # TODO: handle ARRAY and OBJECT see https://github.com/tekumara/fakesnow/issues/26
+        # ResultMetadata(name='XARRAY', type_code=10, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True),
+        # ResultMetadata(name='XOBJECT', type_code=9, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
+        ResultMetadata(name='XVARIANT', type_code=5, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
     ]
     # fmt: on
 
@@ -247,6 +250,19 @@ def test_describe(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("select * from example where XNUMBER = %s", (1,))
     assert cur.description == expected_metadata
 
+    # test semi-structured ops return variant ie: type_code=5
+    # fmt: off
+    assert (
+        cur.describe("SELECT ['A', 'B'][0] as array_index, OBJECT_CONSTRUCT('k','v1')['k'] as object_key, ARRAY_CONSTRUCT('foo')::VARIANT[0] as variant_key")
+        == [
+            # NB: snowflake returns internal_size = 16777216 for all columns
+            ResultMetadata(name="ARRAY_INDEX", type_code=5, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
+            ResultMetadata(name="OBJECT_KEY", type_code=5, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True),
+            ResultMetadata(name="VARIANT_KEY", type_code=5, display_size=None, internal_size=None, precision=None, scale=None, is_nullable=True)
+        ]
+    )
+    # fmt: on
+
 
 def test_describe_info_schema_columns(cur: snowflake.connector.cursor.SnowflakeCursor):
     # test we can handle the column types returned from the info schema, which are created by duckdb
@@ -420,7 +436,7 @@ def test_information_schema_columns_other(cur: snowflake.connector.cursor.Snowfl
         """
         create or replace table example (
             XTIMESTAMP TIMESTAMP, XTIMESTAMP_NTZ9 TIMESTAMP_NTZ(9), XDATE DATE, XTIME TIME,
-            XBINARY BINARY, XARRAY ARRAY, XOBJECT OBJECT
+            XBINARY BINARY, /* XARRAY ARRAY, XOBJECT OBJECT */ XVARIANT VARIANT
         )
         """
     )
@@ -438,8 +454,10 @@ def test_information_schema_columns_other(cur: snowflake.connector.cursor.Snowfl
         ("XDATE", "DATE"),
         ("XTIME", "TIME"),
         ("XBINARY", "BINARY"),
-        ("XARRAY", "ARRAY"),
-        ("XOBJECT", "OBJECT"),
+        # TODO: support these types https://github.com/tekumara/fakesnow/issues/27
+        # ("XARRAY", "ARRAY"),
+        # ("XOBJECT", "OBJECT"),
+        ("XVARIANT", "VARIANT"),
     ]
 
 
@@ -547,18 +565,25 @@ def test_schema_drop(cur: snowflake.connector.cursor.SnowflakeCursor):
 
 
 def test_semi_structured_types(cur: snowflake.connector.cursor.SnowflakeCursor):
-    cur.execute("create table semis (emails array, name object, notes variant)")
+    def indent(rows: Sequence[tuple]) -> list[tuple]:
+        # indent duckdb json strings to match snowflake json strings
+        return [(json.dumps(json.loads(r[0]), indent=2), *r[1:]) for r in rows]
+
+    cur.execute("create or replace table semis (emails array, name object, notes variant)")
     cur.execute(
-        """insert into semis(emails, name, notes) SELECT [1, 2], parse_json('{"k": "v1"}'), parse_json('["foo"]')"""
+        """insert into semis(emails, name, notes) SELECT ['A', 'B'], OBJECT_CONSTRUCT('k','v1'), ARRAY_CONSTRUCT('foo')::VARIANT"""
     )
     cur.execute(
-        """insert into semis(emails, name, notes) VALUES ([3,4], parse_json('{"k": "v2"}'), parse_json('{"b": "ar"}'))"""
+        """insert into semis(emails, name, notes) SELECT ['C','D'], parse_json('{"k": "v2"}'), parse_json('{"b": "ar"}')"""
     )
 
     # results are returned as strings, because the underlying type is JSON (duckdb) / VARIANT (snowflake)
 
+    cur.execute("select emails from semis")
+    assert indent(cur.fetchall()) == [('[\n  "A",\n  "B"\n]',), ('[\n  "C",\n  "D"\n]',)]  # type: ignore
+
     cur.execute("select emails[0] from semis")
-    assert cur.fetchall() == [("1",), ("3",)]
+    assert cur.fetchall() == [('"A"',), ('"C"',)]
 
     cur.execute("select name['k'] from semis")
     assert cur.fetchall() == [('"v1"',), ('"v2"',)]
@@ -606,10 +631,14 @@ def test_tags_noop(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("ALTER TABLE table1 MODIFY COLUMN name1 SET TAG foo='bar'")
 
 
-def test_timestamp(cur: snowflake.connector.cursor.SnowflakeCursor):
+def test_to_timestamp(cur: snowflake.connector.cursor.SnowflakeCursor):
+    # snowflake returns naive timestamps (ie: no timezone)
     cur.execute("SELECT to_timestamp(0)")
     assert cur.fetchall() == [(datetime.datetime(1970, 1, 1, 0, 0),)]
 
+    cur.execute("SELECT to_timestamp('2013-04-05 01:02:03')")
+    assert cur.fetchall() == [(datetime.datetime(2013, 4, 5, 1, 2, 3),)]
+
 
 def test_timestamp_to_date(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("SELECT to_date(to_timestamp(0)), to_date(cast(to_timestamp(0) as timestamp(9)))")
@@ -724,12 +753,12 @@ def test_values(conn: snowflake.connector.SnowflakeConnection):
 
 def test_write_pandas(conn: snowflake.connector.SnowflakeConnection):
     with conn.cursor() as cur:
-        cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
+        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"},
-                {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M"},
+                {"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")

{fakesnow-0.7.0 → fakesnow-0.8.0}/tests/test_transforms.py

@@ -22,6 +22,7 @@ from fakesnow.transforms import (
     timestamp_ntz_ns,
     to_date,
     to_decimal,
+    to_timestamp,
     upper_case_unquoted_identifiers,
     values_columns,
 )
@@ -133,7 +134,7 @@ def test_parse_json() -> None:
     assert (
         sqlglot.parse_one("""insert into table1 (name) select parse_json('{"first":"foo", "last":"bar"}')""")
         .transform(parse_json)
-        .sql()
+        .sql(dialect="duckdb")
         == """INSERT INTO table1 (name) SELECT JSON('{"first":"foo", "last":"bar"}')"""
     )
 
@@ -147,7 +148,9 @@ def test_regex_replace() -> None:
 
 def test_regex_substr() -> None:
     assert (
-        sqlglot.parse_one("SELECT regexp_substr(string1, 'the\\\\W+\\\\w+')").transform(regex_substr).sql()
+        sqlglot.parse_one("SELECT regexp_substr(string1, 'the\\\\W+\\\\w+')", read="snowflake")
+        .transform(regex_substr)
+        .sql()
         == "SELECT REGEXP_EXTRACT_ALL(string1[1 : ], 'the\\W+\\w+', 0, '')[1]"
     )
 
@@ -160,7 +163,7 @@ def test_semi_structured_types() -> None:
 
     assert (
         sqlglot.parse_one("CREATE TABLE table1 (name array)").transform(semi_structured_types).sql(dialect="duckdb")
-        == "CREATE TABLE table1 (name JSON[])"
+        == "CREATE TABLE table1 (name JSON)"
     )
 
     assert (
@@ -196,6 +199,13 @@ def test_to_decimal() -> None:
     )
 
 
+def test_to_timestamp() -> None:
+    assert (
+        sqlglot.parse_one("SELECT to_timestamp(0)", read="snowflake").transform(to_timestamp).sql(dialect="duckdb")
+        == "SELECT CAST(TO_TIMESTAMP(0) AS TIMESTAMP)"
+    )
+
+
 def test_use() -> None:
     assert (
         sqlglot.parse_one("use database marts").transform(set_schema, current_database=None).sql()