fakesnow 0.9.17__tar.gz → 0.9.19__tar.gz

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

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

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

@@ -33,6 +33,7 @@ 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"
 SQL_SUCCESS = "SELECT 'Statement executed successfully.' as 'status'"
@@ -134,6 +135,7 @@ class FakeSnowflakeCursor:
             if os.environ.get("FAKESNOW_DEBUG") == "snowflake":
                 print(f"{command};{params=}" if params else f"{command};", file=sys.stderr)
 
+            command = self._inline_variables(command)
             command, params = self._rewrite_with_params(command, params)
             if self._conn.nop_regexes and any(re.match(p, command, re.IGNORECASE) for p in self._conn.nop_regexes):
                 transformed = transforms.SUCCESS_NOP
@@ -148,6 +150,7 @@ class FakeSnowflakeCursor:
     def _transform(self, expression: exp.Expression) -> exp.Expression:
         return (
             expression.transform(transforms.upper_case_unquoted_identifiers)
+            .transform(transforms.update_variables, variables=self._conn.variables)
             .transform(transforms.set_schema, current_database=self._conn.database)
             .transform(transforms.create_database, db_path=self._conn.db_path)
             .transform(transforms.extract_comment_on_table)
@@ -501,6 +504,9 @@ class FakeSnowflakeCursor:
 
         return command, params
 
+    def _inline_variables(self, sql: str) -> str:
+        return self._conn.variables.inline_variables(sql)
+
 
 class FakeSnowflakeConnection:
     def __init__(
@@ -525,6 +531,7 @@ class FakeSnowflakeConnection:
         self.db_path = Path(db_path) if db_path else None
         self.nop_regexes = nop_regexes
         self._paramstyle = snowflake.connector.paramstyle
+        self.variables = Variables()
 
         create_global_database(duck_conn)
 
@@ -611,7 +618,7 @@ class FakeSnowflakeConnection:
         cursors = [
             self.cursor(cursor_class).execute(e.sql(dialect="snowflake"))
             for e in sqlglot.parse(sql_text, read="snowflake")
-            if e
+            if e and not isinstance(e, exp.Semicolon)  # ignore comments
         ]
         return cursors if return_cursors else []
 

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

@@ -8,6 +8,7 @@ import sqlglot
 from sqlglot import exp
 
 from fakesnow.global_database import USERS_TABLE_FQ_NAME
+from fakesnow.variables import Variables
 
 MISSING_DATABASE = "missing_database"
 SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.'")
@@ -119,9 +120,11 @@ def create_database(expression: exp.Expression, db_path: Path | None = None) ->
         db_name = ident.this
         db_file = f"{db_path/db_name}.db" if db_path else ":memory:"
 
+        if_not_exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
+
         return exp.Command(
             this="ATTACH",
-            expression=exp.Literal(this=f"DATABASE '{db_file}' AS {db_name}", is_string=True),
+            expression=exp.Literal(this=f"{if_not_exists}DATABASE '{db_file}' AS {db_name}", is_string=True),
             create_db_name=db_name,
         )
 
@@ -1405,6 +1408,16 @@ def show_keys(
     return expression
 
 
+def update_variables(
+    expression: exp.Expression,
+    variables: Variables,
+) -> exp.Expression:
+    if Variables.is_variable_modifier(expression):
+        variables.update_variables(expression)
+        return SUCCESS_NOP  # Nothing further to do if its a SET/UNSET operation.
+    return expression
+
+
 class SHA256(exp.Func):
     _sql_names: ClassVar = ["SHA256"]
     arg_types: ClassVar = {"this": True}

fakesnow-0.9.19/fakesnow/variables.py

@@ -0,0 +1,57 @@
+import re
+
+import snowflake.connector.errors
+from sqlglot import exp
+
+
+# Implements snowflake variables: https://docs.snowflake.com/en/sql-reference/session-variables#using-variables-in-sql
+class Variables:
+    @classmethod
+    def is_variable_modifier(cls, expr: exp.Expression) -> bool:
+        return isinstance(expr, exp.Set) or cls._is_unset_expression(expr)
+
+    @classmethod
+    def _is_unset_expression(cls, expr: exp.Expression) -> bool:
+        if isinstance(expr, exp.Alias):
+            this_expr = expr.this.args.get("this")
+            return isinstance(this_expr, exp.Expression) and this_expr.this == "UNSET"
+        return False
+
+    def __init__(self) -> None:
+        self._variables = {}
+
+    def update_variables(self, expr: exp.Expression) -> None:
+        if isinstance(expr, exp.Set):
+            unset = expr.args.get("unset")
+            if not unset:  # SET varname = value;
+                unset_expressions = expr.args.get("expressions")
+                assert unset_expressions, "SET without values in expression(s) is unexpected."
+                eq = unset_expressions[0].this
+                name = eq.this.sql()
+                value = eq.args.get("expression").sql()
+                self._set(name, value)
+            else:
+                # Haven't been able to produce this in tests yet due to UNSET being parsed as an Alias expression.
+                raise NotImplementedError("UNSET not supported yet")
+        elif self._is_unset_expression(expr):  # Unfortunately UNSET varname; is parsed as an Alias expression :(
+            alias = expr.args.get("alias")
+            assert alias, "UNSET without value in alias attribute is unexpected."
+            name = alias.this
+            self._unset(name)
+
+    def _set(self, name: str, value: str) -> None:
+        self._variables[name] = value
+
+    def _unset(self, name: str) -> None:
+        self._variables.pop(name)
+
+    def inline_variables(self, sql: str) -> str:
+        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:
+            raise snowflake.connector.errors.ProgrammingError(
+                msg=f"Session variable '{remaining_variables.group().upper()}' does not exist"
+            )
+        return sql

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

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

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

@@ -13,6 +13,7 @@ fakesnow/info_schema.py
 fakesnow/macros.py
 fakesnow/py.typed
 fakesnow/transforms.py
+fakesnow/variables.py
 fakesnow.egg-info/PKG-INFO
 fakesnow.egg-info/SOURCES.txt
 fakesnow.egg-info/dependency_links.txt

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

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

@@ -4,6 +4,7 @@ from __future__ import annotations
 # pyright: reportOptionalMemberAccess=false
 import datetime
 import json
+import re
 import tempfile
 from decimal import Decimal
 
@@ -15,6 +16,7 @@ import snowflake.connector.cursor
 import snowflake.connector.pandas_tools
 from pandas.testing import assert_frame_equal
 from snowflake.connector.cursor import ResultMetadata
+from snowflake.connector.errors import ProgrammingError
 
 import fakesnow
 from tests.utils import dindent, indent
@@ -342,6 +344,17 @@ def test_connect_with_non_existent_db_or_schema(_fakesnow_no_auto_create: None):
         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()
+        cursor.execute("CREATE DATABASE db2")
+
+        with pytest.raises(ProgrammingError, match='Database "DB2" is already attached with path'):
+            cursor.execute("CREATE DATABASE db2")  # Fails as db already exists.
+
+        cursor.execute("CREATE DATABASE IF NOT EXISTS db2")
+
+
 def test_dateadd_date_cast(dcur: snowflake.connector.DictCursor):
     q = """
     SELECT
@@ -696,11 +709,14 @@ def test_executemany(cur: snowflake.connector.cursor.SnowflakeCursor):
 
 
 def test_execute_string(conn: snowflake.connector.SnowflakeConnection):
-    [_, cur2] = conn.execute_string(
-        """ create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar);
-            select count(*) customers """
+    *_, cur = conn.execute_string(
+        """
+        create table customers (ID int, FIRST_NAME varchar, LAST_NAME varchar);
+        -- test comments are ignored
+        select count(*) customers
+        """
     )
-    assert cur2.fetchall() == [(1,)]
+    assert cur.fetchall() == [(1,)]
 
 
 def test_fetchall(conn: snowflake.connector.SnowflakeConnection):
@@ -1542,6 +1558,53 @@ def test_use_invalid_schema(_fakesnow: None):
         )
 
 
+# Snowflake SQL variables: https://docs.snowflake.com/en/sql-reference/session-variables#using-variables-in-sql
+#
+# Variables are scoped to the session (Eg. The connection, not the cursor)
+# [x] Simple scalar variables: SET var1 = 1;
+# [x] Unset variables: UNSET var1;
+# [x] Simple SQL expression variables: SET INCREMENTAL_DATE = DATEADD( 'DAY', -7, CURRENT_DATE());
+# [x] Basic use of variables in SQL using $ syntax: SELECT $var1;
+# [ ] Multiple variables: SET (var1, var2) = (1, 'hello');
+# [ ] Variables set via 'properties' on the connection https://docs.snowflake.com/en/sql-reference/session-variables#setting-variables-on-connection
+# [ ] Using variables via the IDENTIFIER function: INSERT INTO IDENTIFIER($my_table_name) (i) VALUES (42);
+# [ ] Session variable functions: https://docs.snowflake.com/en/sql-reference/session-variables#session-variable-functions
+def test_variables(conn: snowflake.connector.SnowflakeConnection):
+    with conn.cursor() as cur:
+        cur.execute("SET var1 = 1;")
+        cur.execute("SET var2 = 'hello';")
+        cur.execute("SET var3 = DATEADD( 'DAY', -7, '2024-10-09');")
+
+        cur.execute("select $var1, $var2, $var3;")
+        assert cur.fetchall() == [(1, "hello", datetime.datetime(2024, 10, 2, 0, 0))]
+
+        cur.execute("CREATE TABLE example (id int, name varchar);")
+        cur.execute("INSERT INTO example VALUES (10, 'hello'), (20, 'world');")
+        cur.execute("select id, name from example where name = $var2;")
+        assert cur.fetchall() == [(10, "hello")]
+
+        cur.execute("UNSET var3;")
+        with pytest.raises(
+            snowflake.connector.errors.ProgrammingError, match=re.escape("Session variable '$VAR3' does not exist")
+        ):
+            cur.execute("select $var3;")
+
+    # variables are scoped to the session, so they should be available in a new cursor.
+    with conn.cursor() as cur:
+        cur.execute("select $var1, $var2")
+        assert cur.fetchall() == [(1, "hello")]
+
+    # but not in a new connection.
+    with (
+        snowflake.connector.connect() as conn,
+        conn.cursor() as cur,
+        pytest.raises(
+            snowflake.connector.errors.ProgrammingError, match=re.escape("Session variable '$VAR1' does not exist")
+        ),
+    ):
+        cur.execute("select $var1;")
+
+
 def test_values(conn: snowflake.connector.SnowflakeConnection):
     with conn.cursor(snowflake.connector.cursor.DictCursor) as cur:
         cur.execute("select * from VALUES ('Amsterdam', 1), ('London', 2)")

{fakesnow-0.9.17 → fakesnow-0.9.19}/tests/test_transforms.py

@@ -144,6 +144,13 @@ def test_create_database() -> None:
         == "ATTACH DATABASE '.databases/foobar.db' AS foobar"
     )
 
+    assert (
+        sqlglot.parse_one("create database if not exists foobar")
+        .transform(create_database, db_path=Path(".databases/"))
+        .sql()
+        == "ATTACH IF NOT EXISTS DATABASE '.databases/foobar.db' AS foobar"
+    )
+
 
 def test_describe_table() -> None:
     assert "SELECT" in sqlglot.parse_one("describe table db1.schema1.table1").transform(describe_table).sql()