fakesnow 0.9.11__tar.gz → 0.9.13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.11
+Version: 0.9.13
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -213,7 +213,7 @@ License-File: LICENSE
 Requires-Dist: duckdb~=0.10.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=23.12.2
+Requires-Dist: sqlglot~=23.14.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

{fakesnow-0.9.11 → fakesnow-0.9.13}/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.11 → fakesnow-0.9.13}/fakesnow/fakes.py

@@ -16,6 +16,7 @@ from sqlglot import exp
 if TYPE_CHECKING:
     import pandas as pd
     import pyarrow.lib
+import numpy as np
 import pyarrow
 import snowflake.connector.converter
 import snowflake.connector.errors
@@ -134,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
@@ -501,6 +505,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,
     ):
@@ -512,6 +517,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)
@@ -606,9 +612,7 @@ class FakeSnowflakeConnection:
     def rollback(self) -> None:
         self.cursor().execute("ROLLBACK")
 
-    def _insert_df(
-        self, df: pd.DataFrame, table_name: str, database: str | None = None, schema: str | None = None
-    ) -> int:
+    def _insert_df(self, df: pd.DataFrame, table_name: str) -> int:
         # Objects in dataframes are written as parquet structs, and snowflake loads parquet structs as json strings.
         # Whereas duckdb analyses a dataframe see https://duckdb.org/docs/api/python/data_ingestion.html#pandas-dataframes--object-columns
         # and converts a object to the most specific type possible, eg: dict -> STRUCT, MAP or varchar, and list -> LIST
@@ -630,12 +634,7 @@ class FakeSnowflakeConnection:
             df[col] = df[col].apply(lambda x: json.dumps(x) if isinstance(x, (dict, list)) else x)
 
         escaped_cols = ",".join(f'"{col}"' for col in df.columns.to_list())
-        name = table_name
-        if schema:
-            table_name = f"{schema}.{table_name}"
-        if database:
-            name = f"{database}.{table_name}"
-        self._duck_conn.execute(f"INSERT INTO {name}({escaped_cols}) SELECT * FROM df")
+        self._duck_conn.execute(f"INSERT INTO {table_name}({escaped_cols}) SELECT * FROM df")
 
         return self._duck_conn.fetchall()[0][0]
 
@@ -685,6 +684,15 @@ WritePandasResult = tuple[
 ]
 
 
+def sql_type(dtype: np.dtype) -> str:
+    if str(dtype) == "int64":
+        return "NUMBER"
+    elif str(dtype) == "object":
+        return "VARCHAR"
+    else:
+        raise NotImplementedError(f"sql_type {dtype=}")
+
+
 def write_pandas(
     conn: FakeSnowflakeConnection,
     df: pd.DataFrame,
@@ -702,7 +710,18 @@ def write_pandas(
     table_type: Literal["", "temp", "temporary", "transient"] = "",
     **kwargs: Any,
 ) -> WritePandasResult:
-    count = conn._insert_df(df, table_name, database, schema)  # noqa: SLF001
+    name = table_name
+    if schema:
+        name = f"{schema}.{name}"
+    if database:
+        name = f"{database}.{name}"
+
+    if auto_create_table:
+        cols = [f"{c} {sql_type(t)}" for c, t in df.dtypes.to_dict().items()]
+
+        conn.cursor().execute(f"CREATE TABLE IF NOT EXISTS {name} ({','.join(cols)})")
+
+    count = conn._insert_df(df, name)  # noqa: SLF001
 
     # mocks https://docs.snowflake.com/en/sql-reference/sql/copy-into-table.html#output
     mock_copy_results = [("fakesnow/file0.txt", "LOADED", count, count, 1, 0, None, None, None, None)]

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

@@ -1122,12 +1122,10 @@ def timestamp_ntz_ns(expression: exp.Expression) -> exp.Expression:
 
     if (
         isinstance(expression, exp.DataType)
-        and expression.this == exp.DataType.Type.TIMESTAMP
+        and expression.this == exp.DataType.Type.TIMESTAMPNTZ
         and exp.DataTypeParam(this=exp.Literal(this="9", is_string=False)) in expression.expressions
     ):
-        new = expression.copy()
-        del new.args["expressions"]
-        return new
+        return exp.DataType(this=exp.DataType.Type.TIMESTAMP)
 
     return expression
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.11
+Version: 0.9.13
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -213,7 +213,7 @@ License-File: LICENSE
 Requires-Dist: duckdb~=0.10.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot~=23.12.2
+Requires-Dist: sqlglot~=23.14.0
 Provides-Extra: dev
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"

{fakesnow-0.9.11 → fakesnow-0.9.13}/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.11 → fakesnow-0.9.13}/fakesnow.egg-info/requires.txt

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

{fakesnow-0.9.11 → fakesnow-0.9.13}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "fakesnow"
 description = "Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally."
-version = "0.9.11"
+version = "0.9.13"
 readme = "README.md"
 license = { file = "LICENSE" }
 classifiers = ["License :: OSI Approved :: MIT License"]
@@ -11,7 +11,7 @@ dependencies = [
     "duckdb~=0.10.0",
     "pyarrow",
     "snowflake-connector-python",
-    "sqlglot~=23.12.2",
+    "sqlglot~=23.14.0",
 ]
 
 [project.urls]

{fakesnow-0.9.11 → fakesnow-0.9.13}/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,7 @@ from pandas.testing import assert_frame_equal
 from snowflake.connector.cursor import ResultMetadata
 
 import fakesnow
+from tests.utils import dindent, indent
 
 
 def test_alter_table(cur: snowflake.connector.cursor.SnowflakeCursor):
@@ -871,6 +870,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")
@@ -1500,161 +1505,3 @@ def test_json_extract_cast_as_varchar(dcur: snowflake.connector.cursor.DictCurso
 
     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_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 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 (",", ":"),
-    )

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

@@ -594,6 +594,10 @@ 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
+    )
 
 
 def test_timestamp_ntz_ns() -> None:

fakesnow-0.9.13/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 (",", ":"),
+    )