fakesnow 0.7.1__tar.gz → 0.8.1__tar.gz

{fakesnow-0.7.1/fakesnow.egg-info → fakesnow-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.7.1
+Version: 0.8.1
 Summary: Fake Snowflake Connector for Python. Run Snowflake DB locally.
 License: MIT License
         
@@ -32,7 +32,7 @@ License-File: LICENSE
 Requires-Dist: duckdb~=0.9.2
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=19.5.1
+Requires-Dist: sqlglot~=20.5.0
 Provides-Extra: dev
 Requires-Dist: black~=23.9; extra == "dev"
 Requires-Dist: build~=1.0; extra == "dev"
@@ -63,6 +63,24 @@ pip install fakesnow
 
 ## Usage
 
+Run script.py with fakesnow:
+
+```shell
+fakesnow script.py
+```
+
+Or pytest
+
+```shell
+fakesnow -m pytest
+```
+
+`fakesnow` executes `fakesnow.patch` before running the script or module.
+
+### fakesnow.patch
+
+eg:
+
 ```python
 import fakesnow
 import snowflake.connector
@@ -91,6 +109,8 @@ with fakesnow.patch("mymodule.write_pandas"):
     ...
 ```
 
+### pytest fixtures
+
 pytest [fixtures](fakesnow/fixtures.py) are provided for testing. Example _conftest.py_:
 
 ```python
@@ -146,7 +166,8 @@ For more detail see [tests/test_fakes.py](tests/test_fakes.py)
 
 ## Caveats
 
-- VARCHAR field sizes are not enforced unlike Snowflake which will error with "User character length limit (xxx) exceeded by string" when you try to insert a string longer than the column limit.
+- The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
+- VARCHAR field sizes are not enforced. Unlike Snowflake which errors with "User character length limit (xxx) exceeded by string" when an inserted string the exceeds the column limit.
 
 ## Contributing
 

{fakesnow-0.7.1 → fakesnow-0.8.1}/README.md

@@ -14,6 +14,24 @@ pip install fakesnow
 
 ## Usage
 
+Run script.py with fakesnow:
+
+```shell
+fakesnow script.py
+```
+
+Or pytest
+
+```shell
+fakesnow -m pytest
+```
+
+`fakesnow` executes `fakesnow.patch` before running the script or module.
+
+### fakesnow.patch
+
+eg:
+
 ```python
 import fakesnow
 import snowflake.connector
@@ -42,6 +60,8 @@ with fakesnow.patch("mymodule.write_pandas"):
     ...
 ```
 
+### pytest fixtures
+
 pytest [fixtures](fakesnow/fixtures.py) are provided for testing. Example _conftest.py_:
 
 ```python
@@ -97,7 +117,8 @@ For more detail see [tests/test_fakes.py](tests/test_fakes.py)
 
 ## Caveats
 
-- VARCHAR field sizes are not enforced unlike Snowflake which will error with "User character length limit (xxx) exceeded by string" when you try to insert a string longer than the column limit.
+- The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
+- VARCHAR field sizes are not enforced. Unlike Snowflake which errors with "User character length limit (xxx) exceeded by string" when an inserted string the exceeds the column limit.
 
 ## Contributing
 

fakesnow-0.8.1/fakesnow/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    import fakesnow.cli
+
+    fakesnow.cli.main()

fakesnow-0.8.1/fakesnow/cli.py

@@ -0,0 +1,28 @@
+import runpy
+import sys
+from collections.abc import Sequence
+
+import fakesnow
+
+USAGE = "Usage: fakesnow <path> | -m <module> [<arg>]..."
+
+
+def main(args: Sequence[str] = sys.argv) -> int:
+    if len(args) < 2 or (len(args) == 2 and args[1] == "-m"):
+        print(USAGE, file=sys.stderr)
+        return 42
+
+    with fakesnow.patch():
+        if args[1] == "-m":
+            module = args[2]
+            sys.argv = args[2:]
+
+            # add current directory to path to mimic python -m
+            sys.path.insert(0, "")
+            runpy.run_module(module, run_name="__main__", alter_sys=True)
+        else:
+            path = args[1]
+            sys.argv = args[1:]
+            runpy.run_path(path, run_name="__main__")
+
+    return 0

{fakesnow-0.7.1 → fakesnow-0.8.1}/fakesnow/fakes.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import os
 import re
+import sys
 from collections.abc import Iterable, Iterator, Sequence
+from string import Template
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Literal, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Literal, Optional, cast
 
 import duckdb
 
@@ -26,6 +29,12 @@ import fakesnow.info_schema as info_schema
 import fakesnow.transforms as transforms
 
 SCHEMA_UNSET = "schema_unset"
+SUCCESS_SQL = "SELECT 'Statement executed successfully.' as status"
+DATABASE_CREATED_SQL = Template("SELECT 'Database ${name} successfully created.' as status")
+TABLE_CREATED_SQL = Template("SELECT 'Table ${name} successfully created.' as status")
+DROPPED_SQL = Template("SELECT '${name} successfully dropped.' as status")
+SCHEMA_CREATED_SQL = Template("SELECT 'Schema ${name} successfully created.' as status")
+INSERTED_SQL = Template("SELECT ${count} as 'number of rows inserted'")
 
 
 class FakeSnowflakeCursor:
@@ -49,6 +58,7 @@ class FakeSnowflakeCursor:
         self._last_sql = None
         self._last_params = None
         self._sqlstate = None
+        self._arraysize = 1
         self._converter = snowflake.connector.converter.SnowflakeConverter()
 
     def __enter__(self) -> Self:
@@ -62,6 +72,19 @@ class FakeSnowflakeCursor:
     ) -> bool:
         return False
 
+    @property
+    def arraysize(self) -> int:
+        return self._arraysize
+
+    @arraysize.setter
+    def arraysize(self, value: int) -> None:
+        self._arraysize = value
+
+    def close(self) -> bool:
+        self._last_sql = None
+        self._last_params = None
+        return True
+
     def describe(self, command: str, *args: Any, **kwargs: Any) -> list[ResultMetadata]:
         """Return the schema of the result without executing the query.
 
@@ -79,8 +102,9 @@ class FakeSnowflakeCursor:
     def description(self) -> list[ResultMetadata]:
         # use a cursor to avoid destroying an unfetched result on the main connection
         with self._duck_conn.cursor() as cur:
-            assert self._conn.database, "Not implemented when database is None"
-            assert self._conn.schema, "Not implemented when schema is None"
+            # TODO: allow sql alchemy connection with no database or schema
+            assert self._conn.database, ".description not implemented when database is None"
+            assert self._conn.schema, ".description not implemented when schema is None"
 
             # match database and schema used on the main connection
             cur.execute(f"SET SCHEMA = '{self._conn.database}.{self._conn.schema}'")
@@ -145,6 +169,8 @@ class FakeSnowflakeCursor:
             .transform(transforms.parse_json)
             # indices_to_json_extract must be before regex_substr
             .transform(transforms.indices_to_json_extract)
+            .transform(transforms.json_extract_as_varchar)
+            .transform(transforms.flatten)
             .transform(transforms.regex_replace)
             .transform(transforms.regex_substr)
             .transform(transforms.values_columns)
@@ -162,7 +188,8 @@ class FakeSnowflakeCursor:
         try:
             self._last_sql = sql
             self._last_params = params
-            # print(f"{sql};")
+            if os.environ.get("FAKESNOW_DEBUG"):
+                print(f"{sql};", file=sys.stderr)
             self._duck_conn.execute(sql, params)
         except duckdb.BinderException as e:
             msg = e.args[0]
@@ -171,6 +198,15 @@ class FakeSnowflakeCursor:
             # minimal processing to make it look like a snowflake exception, message content may differ
             msg = cast(str, e.args[0]).split("\n")[0]
             raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=2003, sqlstate="42S02") from None
+        except duckdb.TransactionException as e:
+            if "cannot rollback - no transaction is active" in str(
+                e
+            ) or "cannot commit - no transaction is active" in str(e):
+                # snowflake doesn't error on rollback or commit outside a tx
+                self._duck_conn.execute(SUCCESS_SQL)
+                self._last_sql = SUCCESS_SQL
+            else:
+                raise e
 
         if cmd == "USE DATABASE" and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
             self._conn.database = ident.this.upper()
@@ -183,6 +219,33 @@ class FakeSnowflakeCursor:
         if create_db_name := transformed.args.get("create_db_name"):
             # we created a new database, so create the info schema extensions
             self._duck_conn.execute(info_schema.creation_sql(create_db_name))
+            created_sql = DATABASE_CREATED_SQL.substitute(name=create_db_name)
+            self._duck_conn.execute(created_sql)
+            self._last_sql = created_sql
+
+        if cmd == "CREATE SCHEMA" and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
+            name = ident.this if ident.quoted else ident.this.upper()
+            created_sql = SCHEMA_CREATED_SQL.substitute(name=name)
+            self._duck_conn.execute(created_sql)
+            self._last_sql = created_sql
+
+        if cmd == "CREATE TABLE" and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
+            name = ident.this if ident.quoted else ident.this.upper()
+            created_sql = TABLE_CREATED_SQL.substitute(name=name)
+            self._duck_conn.execute(created_sql)
+            self._last_sql = created_sql
+
+        if cmd.startswith("DROP") and (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
+            name = ident.this if ident.quoted else ident.this.upper()
+            dropped_sql = DROPPED_SQL.substitute(name=name)
+            self._duck_conn.execute(dropped_sql)
+            self._last_sql = dropped_sql
+
+        if cmd == "INSERT":
+            (count,) = self._duck_conn.fetchall()[0]
+            inserted_sql = INSERTED_SQL.substitute(count=count)
+            self._duck_conn.execute(inserted_sql)
+            self._last_sql = inserted_sql
 
         if table_comment := cast(tuple[exp.Table, str], transformed.args.get("table_comment")):
             # record table comment
@@ -232,19 +295,22 @@ class FakeSnowflakeCursor:
         return self._duck_conn.fetch_df()
 
     def fetchone(self) -> dict | tuple | None:
+        result = self.fetchmany(1)
+        return result[0] if result else None
+
+    def fetchmany(self, size: int | None = None) -> list[tuple] | list[dict]:
+        # https://peps.python.org/pep-0249/#fetchmany
+        size = size or self._arraysize
         if not self._use_dict_result:
-            return cast(Union[tuple, None], self._duck_conn.fetchone())
+            return cast(list[tuple], self._duck_conn.fetchmany(size))
 
         if not self._arrow_table:
             self._arrow_table = self._duck_conn.fetch_arrow_table()
-            self._arrow_table_fetch_one_index = -1
+            self._arrow_table_fetch_index = -size
 
-        self._arrow_table_fetch_one_index += 1
+        self._arrow_table_fetch_index += size
 
-        try:
-            return self._arrow_table.take([self._arrow_table_fetch_one_index]).to_pylist()[0]
-        except pyarrow.lib.ArrowIndexError:
-            return None
+        return self._arrow_table.slice(offset=self._arrow_table_fetch_index, length=size).to_pylist()
 
     def get_result_batches(self) -> list[ResultBatch] | None:
         # rows_per_batch is approximate
@@ -322,13 +388,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

{fakesnow-0.7.1 → fakesnow-0.8.1}/fakesnow/info_schema.py

@@ -1,7 +1,7 @@
-from string import Template
-
 """Info schema extension tables/views used for storing snowflake metadata not captured by duckdb."""
 
+from string import Template
+
 # use ext prefix in columns to disambiguate when joining with information_schema.tables
 SQL_CREATE_INFORMATION_SCHEMA_TABLES_EXT = Template(
     """
@@ -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.1 → fakesnow-0.8.1}/fakesnow/transforms.py

@@ -155,6 +155,49 @@ def extract_text_length(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def flatten(expression: exp.Expression) -> exp.Expression:
+    """Flatten an array.
+
+    See https://docs.snowflake.com/en/sql-reference/functions/flatten
+
+    TODO: return index.
+    TODO: support objects.
+    """
+    if (
+        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
+        and isinstance(alias, exp.TableAlias)
+    ):
+        explode_expression = expression.this.this.expression
+
+        return exp.Lateral(
+            this=exp.Unnest(
+                expressions=[
+                    exp.Anonymous(
+                        # duckdb unnests in reserve, so we reverse the list to match
+                        # the order of the original array (and snowflake)
+                        this="list_reverse",
+                        expressions=[
+                            exp.Cast(
+                                this=explode_expression,
+                                to=exp.DataType(
+                                    this=exp.DataType.Type.ARRAY,
+                                    expressions=[exp.DataType(this=exp.DataType.Type.JSON, nested=False, prefix=False)],
+                                    nested=True,
+                                ),
+                            )
+                        ],
+                    )
+                ]
+            ),
+            alias=exp.TableAlias(this=alias.this, columns=[exp.Identifier(this="VALUE", quoted=False)]),
+        )
+
+    return expression
+
+
 def float_to_double(expression: exp.Expression) -> exp.Expression:
     """Convert float to double for 64 bit precision.
 
@@ -176,10 +219,10 @@ def indices_to_json_extract(expression: exp.Expression) -> exp.Expression:
     and object indices, see
     https://docs.snowflake.com/en/sql-reference/data-types-semistructured#accessing-elements-of-an-object-by-key
 
-    Duckdb uses the -> operator, or the json_extract function, see
+    Duckdb uses the -> operator, aka the json_extract function, see
     https://duckdb.org/docs/extensions/json#json-extraction-functions
 
-    This works for Snowflake arrays too because we convert them to JSON[] in duckdb.
+    This works for Snowflake arrays too because we convert them to JSON in duckdb.
     """
     if (
         isinstance(expression, exp.Bracket)
@@ -259,6 +302,20 @@ def integer_precision(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def json_extract_as_varchar(expression: exp.Expression) -> exp.Expression:
+    """Return raw unquoted string when casting json extraction to varchar.
+
+    This must run after indices_to_json_extract.
+
+    Duckdb uses the ->> operator, aka the json_extract_string function, see
+    https://duckdb.org/docs/extensions/json#json-extraction-functions
+    """
+    if isinstance(expression, exp.Cast) and (extract := expression.this) and isinstance(extract, exp.JSONExtract):
+        return exp.JSONExtractScalar(this=extract.this, expression=extract.expression)
+
+    return expression
+
+
 def object_construct(expression: exp.Expression) -> exp.Expression:
     """Convert object_construct to return a json string
 
@@ -355,9 +412,13 @@ def regex_substr(expression: exp.Expression) -> exp.Expression:
 
         # which occurrence of the pattern to match
         try:
-            occurrence = expression.args["occurrence"]
+            occurrence = int(expression.args["occurrence"].this)
         except KeyError:
-            occurrence = exp.Literal(this="1", is_string=False)
+            occurrence = 1
+
+        # the duckdb dialect increments bracket (ie: index) expressions by 1 because duckdb is 1-indexed,
+        # so we need to compensate by subtracting 1
+        occurrence = exp.Literal(this=str(occurrence - 1), is_string=False)
 
         try:
             regex_parameters_value = str(expression.args["parameters"].this)
@@ -428,7 +489,7 @@ def set_schema(expression: exp.Expression, current_database: str | None) -> exp.
             name = f"{expression.this.name}.main"
         else:
             # SCHEMA
-            if db := expression.this.args.get("db"):
+            if db := expression.this.args.get("db"):  # noqa: SIM108
                 db_name = db.name
             else:
                 # isn't qualified with a database
@@ -578,15 +639,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.1 → fakesnow-0.8.1/fakesnow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.7.1
+Version: 0.8.1
 Summary: Fake Snowflake Connector for Python. Run Snowflake DB locally.
 License: MIT License
         
@@ -32,7 +32,7 @@ License-File: LICENSE
 Requires-Dist: duckdb~=0.9.2
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=19.5.1
+Requires-Dist: sqlglot~=20.5.0
 Provides-Extra: dev
 Requires-Dist: black~=23.9; extra == "dev"
 Requires-Dist: build~=1.0; extra == "dev"
@@ -63,6 +63,24 @@ pip install fakesnow
 
 ## Usage
 
+Run script.py with fakesnow:
+
+```shell
+fakesnow script.py
+```
+
+Or pytest
+
+```shell
+fakesnow -m pytest
+```
+
+`fakesnow` executes `fakesnow.patch` before running the script or module.
+
+### fakesnow.patch
+
+eg:
+
 ```python
 import fakesnow
 import snowflake.connector
@@ -91,6 +109,8 @@ with fakesnow.patch("mymodule.write_pandas"):
     ...
 ```
 
+### pytest fixtures
+
 pytest [fixtures](fakesnow/fixtures.py) are provided for testing. Example _conftest.py_:
 
 ```python
@@ -146,7 +166,8 @@ For more detail see [tests/test_fakes.py](tests/test_fakes.py)
 
 ## Caveats
 
-- VARCHAR field sizes are not enforced unlike Snowflake which will error with "User character length limit (xxx) exceeded by string" when you try to insert a string longer than the column limit.
+- The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
+- VARCHAR field sizes are not enforced. Unlike Snowflake which errors with "User character length limit (xxx) exceeded by string" when an inserted string the exceeds the column limit.
 
 ## Contributing
 

{fakesnow-0.7.1 → fakesnow-0.8.1}/fakesnow.egg-info/SOURCES.txt

@@ -3,7 +3,9 @@ MANIFEST.in
 README.md
 pyproject.toml
 fakesnow/__init__.py
+fakesnow/__main__.py
 fakesnow/checks.py
+fakesnow/cli.py
 fakesnow/expr.py
 fakesnow/fakes.py
 fakesnow/fixtures.py
@@ -13,9 +15,11 @@ fakesnow/transforms.py
 fakesnow.egg-info/PKG-INFO
 fakesnow.egg-info/SOURCES.txt
 fakesnow.egg-info/dependency_links.txt
+fakesnow.egg-info/entry_points.txt
 fakesnow.egg-info/requires.txt
 fakesnow.egg-info/top_level.txt
 tests/test_checks.py
+tests/test_cli.py
 tests/test_expr.py
 tests/test_fakes.py
 tests/test_patch.py

fakesnow-0.8.1/fakesnow.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fakesnow = fakesnow.cli:main

{fakesnow-0.7.1 → fakesnow-0.8.1}/fakesnow.egg-info/requires.txt

@@ -1,7 +1,7 @@
 duckdb~=0.9.2
 pyarrow
 snowflake-connector-python
-sqlglot~=19.5.1
+sqlglot~=20.5.0
 
 [dev]
 black~=23.9

{fakesnow-0.7.1 → fakesnow-0.8.1}/fakesnow.egg-info/top_level.txt

@@ -1,2 +1,3 @@
 dist
 fakesnow
+notebooks

{fakesnow-0.7.1 → fakesnow-0.8.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "fakesnow"
 description = "Fake Snowflake Connector for Python. Run Snowflake DB locally."
-version = "0.7.1"
+version = "0.8.1"
 readme = "README.md"
 license = { file = "LICENSE" }
 classifiers = ["License :: OSI Approved :: MIT License"]
@@ -11,12 +11,15 @@ dependencies = [
     "duckdb~=0.9.2",
     "pyarrow",
     "snowflake-connector-python",
-    "sqlglot~=19.5.1",
+    "sqlglot~=20.5.0",
 ]
 
 [project.urls]
 homepage = "https://github.com/tekumara/fakesnow"
 
+[project.scripts]
+fakesnow = "fakesnow.cli:main"
+
 [project.optional-dependencies]
 dev = [
     "black~=23.9",
@@ -81,6 +84,8 @@ select = [
     "PERF",
     # ruff-specific
     "RUF",
+    # flake8-simplify
+    "SIM"
 ]
 ignore = [
     # allow untyped self and cls args, and no return type from dunder methods

fakesnow-0.8.1/tests/test_cli.py

@@ -0,0 +1,17 @@
+from pytest import CaptureFixture
+
+import fakesnow.cli
+
+
+def test_run_module(capsys: CaptureFixture) -> None:
+    fakesnow.cli.main(["pytest", "-m", "tests.hello", "frobnitz"])
+
+    captured = capsys.readouterr()
+    assert captured.out == "('Hello fake frobnitz!',)\n"
+
+
+def test_run_path(capsys: CaptureFixture) -> None:
+    fakesnow.cli.main(["pytest", "tests/hello.py", "frobnitz"])
+
+    captured = capsys.readouterr()
+    assert captured.out == "('Hello fake frobnitz!',)\n"

{fakesnow-0.7.1 → fakesnow-0.8.1}/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
@@ -49,6 +50,10 @@ def test_binding_qmark(conn: snowflake.connector.SnowflakeConnection):
         assert cur.fetchall() == [(1, "Jenny", True)]
 
 
+def test_close(cur: snowflake.connector.cursor.SnowflakeCursor):
+    assert cur.close() is True
+
+
 def test_connect_auto_create(_fakesnow: None):
     with snowflake.connector.connect(database="db1", schema="schema1"):
         # creates db1 and schema1
@@ -205,7 +210,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 +238,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 +254,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
@@ -262,6 +282,45 @@ def test_describe_info_schema_columns(cur: snowflake.connector.cursor.SnowflakeC
     assert cur.description == expected_metadata
 
 
+## descriptions are needed for ipython-sql/jupysql which describes every statement
+
+
+def test_description_create_database(dcur: snowflake.connector.cursor.DictCursor):
+    dcur.execute("create database example")
+    assert dcur.fetchall() == [{"status": "Database EXAMPLE successfully created."}]
+    assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+    # TODO: support drop database
+    # dcur.execute("drop database example")
+    # assert dcur.fetchall() == [{"status": "EXAMPLE successfully dropped."}]
+    # assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+
+
+def test_description_create_drop_schema(dcur: snowflake.connector.cursor.DictCursor):
+    dcur.execute("create schema example")
+    assert dcur.fetchall() == [{"status": "Schema EXAMPLE successfully created."}]
+    assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+    dcur.execute("drop schema example")
+    assert dcur.fetchall() == [{"status": "EXAMPLE successfully dropped."}]
+    assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+
+
+def test_description_create_drop_table(dcur: snowflake.connector.cursor.DictCursor):
+    dcur.execute("create table example (X int)")
+    assert dcur.fetchall() == [{"status": "Table EXAMPLE successfully created."}]
+    assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+    dcur.execute("drop table example")
+    assert dcur.fetchall() == [{"status": "EXAMPLE successfully dropped."}]
+    assert dcur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+
+
+def test_description_insert(dcur: snowflake.connector.cursor.DictCursor):
+    dcur.execute("create table example (X int)")
+    dcur.execute("insert into example values (1), (2)")
+    assert dcur.fetchall() == [{"number of rows inserted": 2}]
+    # TODO: Snowflake is actually precision=19, is_nullable=False
+    assert dcur.description == [ResultMetadata(name='number of rows inserted', type_code=0, display_size=None, internal_size=None, precision=38, scale=0, is_nullable=True)]  # fmt: skip
+
+
 def test_executemany(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
 
@@ -280,49 +339,65 @@ def test_execute_string(conn: snowflake.connector.SnowflakeConnection):
     assert [(1,)] == cur2.fetchall()
 
 
-def test_fetchall(cur: snowflake.connector.cursor.SnowflakeCursor):
-    cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
-    cur.execute("insert into customers values (1, 'Jenny', 'P')")
-    cur.execute("insert into customers values (2, 'Jasper', 'M')")
-    cur.execute("select id, first_name, last_name from customers")
-
-    assert cur.fetchall() == [(1, "Jenny", "P"), (2, "Jasper", "M")]
-
-
-def test_fetchall_dict_cursor(conn: snowflake.connector.SnowflakeConnection):
-    with conn.cursor(snowflake.connector.cursor.DictCursor) as cur:
+def test_fetchall(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
         cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
         cur.execute("insert into customers values (1, 'Jenny', 'P')")
         cur.execute("insert into customers values (2, 'Jasper', 'M')")
         cur.execute("select id, first_name, last_name from customers")
 
+        assert cur.fetchall() == [(1, "Jenny", "P"), (2, "Jasper", "M")]
+
+    with conn.cursor(snowflake.connector.cursor.DictCursor) as cur:
+        cur.execute("select id, first_name, last_name from customers")
+
         assert cur.fetchall() == [
             {"ID": 1, "FIRST_NAME": "Jenny", "LAST_NAME": "P"},
             {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M"},
         ]
 
 
-def test_fetchone(cur: snowflake.connector.cursor.SnowflakeCursor):
-    cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
-    cur.execute("insert into customers values (1, 'Jenny', 'P')")
-    cur.execute("insert into customers values (2, 'Jasper', 'M')")
-    cur.execute("select id, first_name, last_name from customers")
-
-    assert cur.fetchone() == (1, "Jenny", "P")
-    assert cur.fetchone() == (2, "Jasper", "M")
-    assert not cur.fetchone()
+def test_fetchone(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
+        cur.execute("insert into customers values (1, 'Jenny', 'P')")
+        cur.execute("insert into customers values (2, 'Jasper', 'M')")
+        cur.execute("select id, first_name, last_name from customers")
 
+        assert cur.fetchone() == (1, "Jenny", "P")
+        assert cur.fetchone() == (2, "Jasper", "M")
+        assert cur.fetchone() is None
 
-def test_fetchone_dict_cursor(conn: snowflake.connector.SnowflakeConnection):
     with conn.cursor(snowflake.connector.cursor.DictCursor) as cur:
+        cur.execute("select id, first_name, last_name from customers")
+
+        assert cur.fetchone() == {"ID": 1, "FIRST_NAME": "Jenny", "LAST_NAME": "P"}
+        assert cur.fetchone() == {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M"}
+        assert cur.fetchone() is None
+
+
+def test_fetchmany(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
         cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
         cur.execute("insert into customers values (1, 'Jenny', 'P')")
         cur.execute("insert into customers values (2, 'Jasper', 'M')")
+        cur.execute("insert into customers values (3, 'Jeremy', 'K')")
         cur.execute("select id, first_name, last_name from customers")
 
-        assert cur.fetchone() == {"ID": 1, "FIRST_NAME": "Jenny", "LAST_NAME": "P"}
-        assert cur.fetchone() == {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M"}
-        assert not cur.fetchone()
+        assert cur.fetchmany(2) == [(1, "Jenny", "P"), (2, "Jasper", "M")]
+        assert cur.fetchmany(2) == [(3, "Jeremy", "K")]
+        assert cur.fetchmany(2) == []
+
+    with conn.cursor(snowflake.connector.cursor.DictCursor) as cur:
+        cur.execute("select id, first_name, last_name from customers")
+        assert cur.fetchmany(2) == [
+            {"ID": 1, "FIRST_NAME": "Jenny", "LAST_NAME": "P"},
+            {"ID": 2, "FIRST_NAME": "Jasper", "LAST_NAME": "M"},
+        ]
+        assert cur.fetchmany(2) == [
+            {"ID": 3, "FIRST_NAME": "Jeremy", "LAST_NAME": "K"},
+        ]
+        assert cur.fetchmany(2) == []
 
 
 def test_fetch_pandas_all(cur: snowflake.connector.cursor.SnowflakeCursor):
@@ -341,6 +416,23 @@ def test_fetch_pandas_all(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert_frame_equal(cur.fetch_pandas_all(), expected_df)
 
 
+def test_flatten(cur: snowflake.connector.cursor.SnowflakeCursor):
+    cur.execute(
+        """
+        select t.id, flat.value:fruit from
+        (
+            select 1, parse_json('[{"fruit":"banana"}]')
+            union
+            select 2, parse_json('[{"fruit":"coconut"}, {"fruit":"durian"}]')
+        ) as t(id, fruits), lateral flatten(input => t.fruits) AS flat
+        order by id
+        """
+        # duckdb lateral join order is non-deterministic so order by id
+        # within an id the order of fruits should match the json array
+    )
+    assert cur.fetchall() == [(1, '"banana"'), (2, '"coconut"'), (2, '"durian"')]
+
+
 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)")
@@ -349,6 +441,12 @@ def test_floats_are_64bit(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert cur.fetchall() == [(1.23, 1.23, 1.23, 1.23, 1.23)]
 
 
+def test_get_path_as_varchar(cur: snowflake.connector.cursor.SnowflakeCursor):
+    cur.execute("""select parse_json('{"fruit":"banana"}'):fruit::varchar""")
+    # converting json to varchar returns unquoted string
+    assert cur.fetchall() == [("banana",)]
+
+
 def test_get_result_batches(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
     cur.execute("insert into customers values (1, 'Jenny', 'P')")
@@ -420,7 +518,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 +536,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 +647,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"',)]
@@ -632,21 +739,6 @@ def test_to_decimal(cur: snowflake.connector.cursor.SnowflakeCursor):
     ]
 
 
-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_transactions(conn: snowflake.connector.SnowflakeConnection):
     conn.execute_string(
         """CREATE TABLE table1 (i int);
@@ -663,6 +755,17 @@ def test_transactions(conn: snowflake.connector.SnowflakeConnection):
         cur.execute("SELECT * FROM table1")
         assert cur.fetchall() == [(2,)]
 
+    # check rollback and commit without transaction is a success (to mimic snowflake)
+    # also check description can be retrieved, needed for ipython-sql/jupysql which runs description implicitly
+    with conn.cursor() as cur:
+        cur.execute("COMMIT")
+        assert cur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+        assert cur.fetchall() == [("Statement executed successfully.",)]
+
+        cur.execute("ROLLBACK")
+        assert cur.description == [ResultMetadata(name='status', type_code=2, display_size=None, internal_size=16777216, precision=None, scale=None, is_nullable=True)]  # fmt: skip
+        assert cur.fetchall() == [("Statement executed successfully.",)]
+
 
 def test_unquoted_identifiers_are_upper_cased(conn: snowflake.connector.SnowflakeConnection):
     with conn.cursor(snowflake.connector.cursor.DictCursor) as cur:
@@ -728,12 +831,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")
@@ -743,6 +846,21 @@ def test_write_pandas(conn: snowflake.connector.SnowflakeConnection):
         assert cur.fetchall() == [(1, "Jenny", "P"), (2, "Jasper", "M")]
 
 
+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)")

{fakesnow-0.7.1 → fakesnow-0.8.1}/tests/test_patch.py

@@ -39,7 +39,7 @@ def test_patch_other_unloaded_module() -> None:
 def test_cannot_patch_twice(_fakesnow_no_auto_create: None) -> None:
     # _fakesnow is the first patch
 
-    with pytest.raises(AssertionError) as excinfo:
+    with pytest.raises(AssertionError) as excinfo:  # noqa: SIM117
         # second patch will fail
         with fakesnow.patch():
             pass

{fakesnow-0.7.1 → fakesnow-0.8.1}/tests/test_transforms.py

@@ -7,11 +7,13 @@ from fakesnow.transforms import (
     drop_schema_cascade,
     extract_comment,
     extract_text_length,
+    flatten,
     float_to_double,
     indices_to_json_extract,
     information_schema_columns_snowflake,
     information_schema_tables_ext,
     integer_precision,
+    json_extract_as_varchar,
     object_construct,
     parse_json,
     regex_replace,
@@ -67,6 +69,25 @@ def test_extract_text_length() -> None:
     assert e.args["text_lengths"] == [("t1", 16777216), ("t2", 10), ("t3", 20)]
 
 
+def test_flatten() -> None:
+    assert (
+        sqlglot.parse_one(
+            """
+            select t.id, flat.value:fruit from
+            (
+                select 1, parse_json('[{"fruit":"banana"}]')
+                union
+                select 2, parse_json('[{"fruit":"coconut"}, {"fruit":"durian"}]')
+            ) as t(id, fruits), lateral flatten(input => t.fruits) AS flat
+            """,
+            read="snowflake",
+        ).transform(flatten)
+        # needed to transform flat.value:fruit to flat.value -> '$.fruit'
+        .transform(indices_to_json_extract).sql(dialect="duckdb")
+        == """SELECT t.id, flat.value -> '$.fruit' FROM (SELECT 1, JSON('[{"fruit":"banana"}]') UNION SELECT 2, JSON('[{"fruit":"coconut"}, {"fruit":"durian"}]')) AS t(id, fruits), LATERAL UNNEST(LIST_REVERSE(CAST(t.fruits AS JSON[]))) AS flat(VALUE)"""  # 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)")
@@ -121,6 +142,18 @@ def test_information_schema_tables_ext() -> None:
     )
 
 
+def test_json_extract_as_varchar() -> None:
+    assert (
+        sqlglot.parse_one(
+            """select parse_json('{"fruit":"banana"}'):fruit::varchar""",
+            read="snowflake",
+        )
+        # needed first
+        .transform(indices_to_json_extract).transform(json_extract_as_varchar).sql(dialect="duckdb")
+        == """SELECT JSON('{"fruit":"banana"}') ->> '$.fruit'"""
+    )
+
+
 def test_object_construct() -> None:
     assert (
         sqlglot.parse_one("SELECT OBJECT_CONSTRUCT('a',1,'b','BBBB', 'c',null)", read="snowflake")
@@ -150,7 +183,7 @@ def test_regex_substr() -> None:
     assert (
         sqlglot.parse_one("SELECT regexp_substr(string1, 'the\\\\W+\\\\w+')", read="snowflake")
         .transform(regex_substr)
-        .sql()
+        .sql(dialect="duckdb")
         == "SELECT REGEXP_EXTRACT_ALL(string1[1 : ], 'the\\W+\\w+', 0, '')[1]"
     )
 
@@ -163,7 +196,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 (
@@ -188,7 +221,7 @@ def test_timestamp_ntz_ns() -> None:
 def test_to_date() -> None:
     assert (
         sqlglot.parse_one("SELECT to_date(to_timestamp(0))").transform(to_date).sql()
-        == "SELECT CAST(DATE_TRUNC('day', TO_TIMESTAMP(0)) AS DATE)"
+        == "SELECT CAST(DATE_TRUNC('DAY', TO_TIMESTAMP(0)) AS DATE)"
     )