fakesnow 0.9.19__tar.gz → 0.9.20__tar.gz

{fakesnow-0.9.19 → fakesnow-0.9.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.19
+Version: 0.9.20
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004

{fakesnow-0.9.19 → fakesnow-0.9.20}/fakesnow/__init__.py

@@ -13,6 +13,7 @@ import snowflake.connector
 import snowflake.connector.pandas_tools
 
 import fakesnow.fakes as fakes
+from fakesnow.global_database import create_global_database
 
 
 @contextmanager
@@ -52,6 +53,7 @@ def patch(
     assert not isinstance(snowflake.connector.connect, mock.MagicMock), "Snowflake connector is already patched"
 
     duck_conn = duckdb.connect(database=":memory:")
+    create_global_database(duck_conn)
 
     fake_fns = {
         # every time we connect, create a new cursor (ie: connection) so we can isolate each connection's

{fakesnow-0.9.19 → fakesnow-0.9.20}/fakesnow/fakes.py

@@ -32,7 +32,6 @@ import fakesnow.expr as expr
 import fakesnow.info_schema as info_schema
 import fakesnow.macros as macros
 import fakesnow.transforms as transforms
-from fakesnow.global_database import create_global_database
 from fakesnow.variables import Variables
 
 SCHEMA_UNSET = "schema_unset"
@@ -533,8 +532,6 @@ class FakeSnowflakeConnection:
         self._paramstyle = snowflake.connector.paramstyle
         self.variables = Variables()
 
-        create_global_database(duck_conn)
-
         # create database if needed
         if (
             create_database

{fakesnow-0.9.19 → fakesnow-0.9.20}/fakesnow/transforms.py

@@ -1402,6 +1402,11 @@ def show_keys(
 
                 if schema:
                     statement += f"AND schema_name = '{schema}' "
+            elif scope_kind == "TABLE":
+                if not table:
+                    raise ValueError(f"SHOW PRIMARY KEYS with {scope_kind} scope requires a table")
+
+                statement += f"AND table_name = '{table.name}' "
             else:
                 raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind} not yet supported")
         return sqlglot.parse_one(statement)

{fakesnow-0.9.19 → fakesnow-0.9.20}/fakesnow/variables.py

@@ -49,8 +49,7 @@ class Variables:
         for name, value in self._variables.items():
             sql = re.sub(rf"\${name}", value, sql, flags=re.IGNORECASE)
 
-        remaining_variables = re.search(r"\$\w+", sql)
-        if remaining_variables:
+        if remaining_variables := re.search(r"(?<!\$)\$\w+", sql):
             raise snowflake.connector.errors.ProgrammingError(
                 msg=f"Session variable '{remaining_variables.group().upper()}' does not exist"
             )

{fakesnow-0.9.19 → fakesnow-0.9.20}/fakesnow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.19
+Version: 0.9.20
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004

{fakesnow-0.9.19 → fakesnow-0.9.20}/fakesnow.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ fakesnow.egg-info/requires.txt
 fakesnow.egg-info/top_level.txt
 tests/test_checks.py
 tests/test_cli.py
+tests/test_connect.py
 tests/test_expr.py
 tests/test_fakes.py
 tests/test_info_schema.py

{fakesnow-0.9.19 → fakesnow-0.9.20}/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.19"
+version = "0.9.20"
 readme = "README.md"
 license = { file = "LICENSE" }
 classifiers = ["License :: OSI Approved :: MIT License"]

fakesnow-0.9.20/tests/test_connect.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import concurrent.futures
+
+# ruff: noqa: E501
+# pyright: reportOptionalMemberAccess=false
+import tempfile
+
+import pytest
+import snowflake.connector
+import snowflake.connector.cursor
+import snowflake.connector.pandas_tools
+
+import fakesnow
+
+
+def test_connect_auto_create(_fakesnow: None):
+    with snowflake.connector.connect(database="db1", schema="schema1"):
+        # creates db1 and schema1
+        pass
+
+    with snowflake.connector.connect(database="db1", schema="schema1"):
+        # connects again and reuses db1 and schema1
+        pass
+
+
+def test_connect_different_sessions_use_database(_fakesnow_no_auto_create: None):
+    # connect without default database and schema
+    with snowflake.connector.connect() as conn1, conn1.cursor() as cur:
+        # use the table's fully qualified name
+        cur.execute("create database marts")
+        cur.execute("create schema marts.jaffles")
+        cur.execute("create table marts.jaffles.customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
+        cur.execute("insert into marts.jaffles.customers values (1, 'Jenny', 'P')")
+
+        # use database and schema
+        cur.execute("use database marts")
+        cur.execute("use schema jaffles")
+        cur.execute("insert into customers values (2, 'Jasper', 'M')")
+
+    # in a separate connection, connect using the database and schema from above
+    with snowflake.connector.connect(database="marts", schema="jaffles") as conn2, conn2.cursor() as cur:
+        cur.execute("select id, first_name, last_name from customers")
+        assert cur.fetchall() == [(1, "Jenny", "P"), (2, "Jasper", "M")]
+
+
+def test_connect_concurrently(_fakesnow: None) -> None:
+    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+        future_a = executor.submit(snowflake.connector.connect)
+        future_b = executor.submit(snowflake.connector.connect)
+
+        futures = [future_a, future_b]
+
+        for future in concurrent.futures.as_completed(futures):
+            # exceptions if any will be raised here. we want to avoid
+            # duckdb.duckdb.TransactionException: TransactionContext Error: Catalog write-write conflict
+            _ = future.result()
+
+
+def test_connect_db_path_can_create_database() -> None:
+    with tempfile.TemporaryDirectory(prefix="fakesnow-test") as db_path, fakesnow.patch(db_path=db_path):
+        cursor = snowflake.connector.connect().cursor()
+        cursor.execute("CREATE DATABASE db2")
+
+
+def test_connect_db_path_reuse():
+    with tempfile.TemporaryDirectory(prefix="fakesnow-test") as db_path:
+        with (
+            fakesnow.patch(db_path=db_path),
+            snowflake.connector.connect(database="db1", schema="schema1") as conn,
+            conn.cursor() as cur,
+        ):
+            # creates db1.schema1.example
+            cur.execute("create table example (x int)")
+            cur.execute("insert into example values (420)")
+
+        # reconnect
+        with (
+            fakesnow.patch(db_path=db_path),
+            snowflake.connector.connect(database="db1", schema="schema1") as conn,
+            conn.cursor() as cur,
+        ):
+            assert cur.execute("select * from example").fetchall() == [(420,)]
+
+
+def test_connect_without_database(_fakesnow_no_auto_create: None):
+    with snowflake.connector.connect() as conn, conn.cursor() as cur:
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("select * from customers")
+
+        # actual snowflake error message is:
+        #
+        # 002003 (42S02): SQL compilation error:
+        # Object 'CUSTOMERS' does not exist or not authorized.
+        # assert (
+        #     "002003 (42S02): Catalog Error: Table with name customers does not exist!"
+        #     in str(excinfo.value)
+        # )
+
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("select * from jaffles.customers")
+
+        assert (
+            "090105 (22000): Cannot perform SELECT. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
+            in str(excinfo.value)
+        )
+
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("create schema jaffles")
+
+        assert (
+            "090105 (22000): Cannot perform CREATE SCHEMA. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
+            in str(excinfo.value)
+        )
+
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("use schema jaffles")
+
+        # assert (
+        #     "002043 (02000): SQL compilation error:\nObject does not exist, or operation cannot be performed."
+        #     in str(excinfo.value)
+        # )
+
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
+
+        assert (
+            "090105 (22000): Cannot perform CREATE TABLE. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
+            in str(excinfo.value)
+        )
+
+        # test description works without database
+        assert cur.execute("SELECT 1").fetchall() == [(1,)]
+        assert cur.description
+
+
+def test_connect_without_schema(_fakesnow: None):
+    # database will be created but not schema
+    with snowflake.connector.connect(database="marts") as conn, conn.cursor() as cur:
+        assert not conn.schema
+
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("select * from customers")
+
+        # actual snowflake error message is:
+        #
+        # 002003 (42S02): SQL compilation error:
+        # Object 'CUSTOMERS' does not exist or not authorized.
+        # assert (
+        #     "002003 (42S02): Catalog Error: Table with name customers does not exist!"
+        #     in str(excinfo.value)
+        # )
+
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
+
+        assert (
+            "090106 (22000): Cannot perform CREATE TABLE. This session does not have a current schema. Call 'USE SCHEMA', or use a qualified name."
+            in str(excinfo.value)
+        )
+
+        # test description works without schema
+        assert cur.execute("SELECT 1").fetchall() == [(1,)]
+        assert cur.description
+
+        conn.execute_string("CREATE SCHEMA schema1; USE SCHEMA schema1;")
+        assert conn.schema == "SCHEMA1"
+
+
+def test_connect_with_non_existent_db_or_schema(_fakesnow_no_auto_create: None):
+    # can connect with db that doesn't exist
+    with snowflake.connector.connect(database="marts") as conn, conn.cursor() as cur:
+        # but no valid database set
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("create table foobar (i int)")
+
+        assert (
+            "090105 (22000): Cannot perform CREATE TABLE. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
+            in str(excinfo.value)
+        )
+
+        # database still present on connection
+        assert conn.database == "MARTS"
+
+        cur.execute("CREATE database marts")
+
+    # can connect with schema that doesn't exist
+    with snowflake.connector.connect(database="marts", schema="jaffles") as conn, conn.cursor() as cur:
+        # but no valid schema set
+        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
+            cur.execute("create table foobar (i int)")
+
+        assert (
+            "090106 (22000): Cannot perform CREATE TABLE. This session does not have a current schema. Call 'USE SCHEMA', or use a qualified name."
+            in str(excinfo.value)
+        )
+
+        # schema still present on connection
+        assert conn.schema == "JAFFLES"

{fakesnow-0.9.19 → fakesnow-0.9.20}/tests/test_fakes.py

@@ -172,178 +172,6 @@ def test_close_cur(conn: snowflake.connector.SnowflakeConnection, cur: snowflake
     assert cur.close() is True
 
 
-def test_connect_auto_create(_fakesnow: None):
-    with snowflake.connector.connect(database="db1", schema="schema1"):
-        # creates db1 and schema1
-        pass
-
-    with snowflake.connector.connect(database="db1", schema="schema1"):
-        # connects again and reuses db1 and schema1
-        pass
-
-
-def test_connect_different_sessions_use_database(_fakesnow_no_auto_create: None):
-    # connect without default database and schema
-    with snowflake.connector.connect() as conn1, conn1.cursor() as cur:
-        # use the table's fully qualified name
-        cur.execute("create database marts")
-        cur.execute("create schema marts.jaffles")
-        cur.execute("create table marts.jaffles.customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
-        cur.execute("insert into marts.jaffles.customers values (1, 'Jenny', 'P')")
-
-        # use database and schema
-        cur.execute("use database marts")
-        cur.execute("use schema jaffles")
-        cur.execute("insert into customers values (2, 'Jasper', 'M')")
-
-    # in a separate connection, connect using the database and schema from above
-    with snowflake.connector.connect(database="marts", schema="jaffles") as conn2, conn2.cursor() as cur:
-        cur.execute("select id, first_name, last_name from customers")
-        assert cur.fetchall() == [(1, "Jenny", "P"), (2, "Jasper", "M")]
-
-
-def test_connect_reuse_db():
-    with tempfile.TemporaryDirectory(prefix="fakesnow-test") as db_path:
-        with (
-            fakesnow.patch(db_path=db_path),
-            snowflake.connector.connect(database="db1", schema="schema1") as conn,
-            conn.cursor() as cur,
-        ):
-            # creates db1.schema1.example
-            cur.execute("create table example (x int)")
-            cur.execute("insert into example values (420)")
-
-        # reconnect
-        with (
-            fakesnow.patch(db_path=db_path),
-            snowflake.connector.connect(database="db1", schema="schema1") as conn,
-            conn.cursor() as cur,
-        ):
-            assert cur.execute("select * from example").fetchall() == [(420,)]
-
-
-def test_connect_db_path_can_create_database() -> None:
-    with tempfile.TemporaryDirectory(prefix="fakesnow-test") as db_path, fakesnow.patch(db_path=db_path):
-        cursor = snowflake.connector.connect().cursor()
-        cursor.execute("CREATE DATABASE db2")
-
-
-def test_connect_without_database(_fakesnow_no_auto_create: None):
-    with snowflake.connector.connect() as conn, conn.cursor() as cur:
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("select * from customers")
-
-        # actual snowflake error message is:
-        #
-        # 002003 (42S02): SQL compilation error:
-        # Object 'CUSTOMERS' does not exist or not authorized.
-        # assert (
-        #     "002003 (42S02): Catalog Error: Table with name customers does not exist!"
-        #     in str(excinfo.value)
-        # )
-
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("select * from jaffles.customers")
-
-        assert (
-            "090105 (22000): Cannot perform SELECT. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
-            in str(excinfo.value)
-        )
-
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("create schema jaffles")
-
-        assert (
-            "090105 (22000): Cannot perform CREATE SCHEMA. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
-            in str(excinfo.value)
-        )
-
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("use schema jaffles")
-
-        # assert (
-        #     "002043 (02000): SQL compilation error:\nObject does not exist, or operation cannot be performed."
-        #     in str(excinfo.value)
-        # )
-
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
-
-        assert (
-            "090105 (22000): Cannot perform CREATE TABLE. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
-            in str(excinfo.value)
-        )
-
-        # test description works without database
-        assert cur.execute("SELECT 1").fetchall() == [(1,)]
-        assert cur.description
-
-
-def test_connect_without_schema(_fakesnow: None):
-    # database will be created but not schema
-    with snowflake.connector.connect(database="marts") as conn, conn.cursor() as cur:
-        assert not conn.schema
-
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("select * from customers")
-
-        # actual snowflake error message is:
-        #
-        # 002003 (42S02): SQL compilation error:
-        # Object 'CUSTOMERS' does not exist or not authorized.
-        # assert (
-        #     "002003 (42S02): Catalog Error: Table with name customers does not exist!"
-        #     in str(excinfo.value)
-        # )
-
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar)")
-
-        assert (
-            "090106 (22000): Cannot perform CREATE TABLE. This session does not have a current schema. Call 'USE SCHEMA', or use a qualified name."
-            in str(excinfo.value)
-        )
-
-        # test description works without schema
-        assert cur.execute("SELECT 1").fetchall() == [(1,)]
-        assert cur.description
-
-        conn.execute_string("CREATE SCHEMA schema1; USE SCHEMA schema1;")
-        assert conn.schema == "SCHEMA1"
-
-
-def test_connect_with_non_existent_db_or_schema(_fakesnow_no_auto_create: None):
-    # can connect with db that doesn't exist
-    with snowflake.connector.connect(database="marts") as conn, conn.cursor() as cur:
-        # but no valid database set
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("create table foobar (i int)")
-
-        assert (
-            "090105 (22000): Cannot perform CREATE TABLE. This session does not have a current database. Call 'USE DATABASE', or use a qualified name."
-            in str(excinfo.value)
-        )
-
-        # database still present on connection
-        assert conn.database == "MARTS"
-
-        cur.execute("CREATE database marts")
-
-    # can connect with schema that doesn't exist
-    with snowflake.connector.connect(database="marts", schema="jaffles") as conn, conn.cursor() as cur:
-        # but no valid schema set
-        with pytest.raises(snowflake.connector.errors.ProgrammingError) as excinfo:
-            cur.execute("create table foobar (i int)")
-
-        assert (
-            "090106 (22000): Cannot perform CREATE TABLE. This session does not have a current schema. Call 'USE SCHEMA', or use a qualified name."
-            in str(excinfo.value)
-        )
-
-        # schema still present on connection
-        assert conn.schema == "JAFFLES"
-
-
 def test_create_database_respects_if_not_exists() -> None:
     with tempfile.TemporaryDirectory(prefix="fakesnow-test") as db_path, fakesnow.patch(db_path=db_path):
         cursor = snowflake.connector.connect().cursor()
@@ -1401,6 +1229,12 @@ def test_sfqid(cur: snowflake.connector.cursor.SnowflakeCursor):
     assert cur.sfqid == "fakesnow"
 
 
+def test_string_constant(cur: snowflake.connector.cursor.SnowflakeCursor):
+    assert cur.execute("""
+        select $$hello
+world$$""").fetchall() == [("hello\nworld",)]
+
+
 def test_tags_noop(cur: snowflake.connector.cursor.SnowflakeCursor):
     cur.execute("CREATE TABLE table1 (id int)")
     cur.execute("ALTER TABLE table1 SET TAG foo='bar'")

{fakesnow-0.9.19 → fakesnow-0.9.20}/tests/test_info_schema.py

@@ -193,3 +193,21 @@ def test_info_schema_views_with_views(conn: snowflake.connector.SnowflakeConnect
                 "comment": None,
             }
         ]
+
+
+def test_info_schema_show_primary_keys_from_table(cur: snowflake.connector.cursor.SnowflakeCursor) -> None:
+    cur.execute(
+        """
+        CREATE TABLE test_table (
+            ID varchar,
+            VERSION varchar,
+            PRIMARY KEY (ID, VERSION)
+        )
+        """
+    )
+
+    cur.execute("SHOW PRIMARY KEYS IN test_table")
+    pk_result = cur.fetchall()
+
+    pk_columns = [result[4] for result in pk_result]
+    assert pk_columns == ["ID", "VERSION"]