sqlscope-rs 0.4.0__tar.gz → 0.5.0__tar.gz

{sqlscope_rs-0.4.0 → sqlscope_rs-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlscope-rs
-Version: 0.4.0
+Version: 0.5.0
 Summary: Scope-aware SQL analysis and rewriting: row filters, CTE injection, table rewrites, column lineage.
 Project-URL: Repository, https://github.com/dcalsky/sqlscope
 License-Expression: MIT

{sqlscope_rs-0.4.0 → sqlscope_rs-0.5.0}/src/sqlscope/__init__.py

@@ -41,7 +41,7 @@ from ._library import (
     load,
 )
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 __all__ = [
     "Clause",
@@ -137,6 +137,7 @@ class Clause(str, Enum):
     UPDATE_SET_VALUE = "UPDATE_SET_VALUE"
     MERGE_ON = "MERGE_ON"
     MERGE_WHEN = "MERGE_WHEN"
+    RETURNING = "RETURNING"
 
     def __str__(self) -> str:
         return self.value
@@ -189,7 +190,8 @@ def apply_row_filter(
     By default every physical table is filtered; ``table_names`` (bare,
     ``schema.table`` or ``catalog.schema.table``), ``table_patterns`` (regular
     expressions) and ``default_db`` restrict the scope. CTE references, table
-    functions and ``DUAL`` are never wrapped. ``predicate`` is parsed as one
+    functions and the ``DUAL`` dummy table (Oracle, the MySQL family,
+    Snowflake) are never wrapped. ``predicate`` is parsed as one
     boolean expression; bind or escape its values before calling. Returns the
     input unchanged when no table is in scope.
     """

{sqlscope_rs-0.4.0 → sqlscope_rs-0.5.0}/tests/test_sqlscope.py

@@ -118,3 +118,56 @@ def test_deep_nesting_in_threads():
     thread.start()
     thread.join()
     assert results == [{"t": ["a"]}]
+
+
+@pytest.mark.parametrize("query", [
+    "WITH a AS (SELECT id FROM orders), b AS (SELECT id FROM a) SELECT * FROM b ORDER BY id",
+    "SELECT orders.id FROM orders WHERE EXISTS (SELECT 1 FROM payments WHERE payments.id = orders.id) ORDER BY orders.id",
+    "SELECT o.id, p.id FROM orders o LEFT JOIN payments p ON o.id = p.id ORDER BY o.id",
+    "SELECT id FROM orders UNION SELECT id FROM payments ORDER BY id",
+])
+def test_row_filter_preserves_sqlite_query_results(query):
+    # SQLite executes both sides independently of sqlscope's parser. The
+    # reference database contains only the rows visible to tenant 7.
+    import sqlite3
+
+    raw = sqlite3.connect(":memory:")
+    visible = sqlite3.connect(":memory:")
+    try:
+        for connection in (raw, visible):
+            connection.executescript("CREATE TABLE orders(id, tenant); CREATE TABLE payments(id, tenant);")
+        orders = [(1, 7), (2, 8), (3, 7)]
+        payments = [(1, 7), (2, 7), (3, 8)]
+        for table, rows in (("orders", orders), ("payments", payments)):
+            raw.executemany(f"INSERT INTO {table} VALUES (?, ?)", rows)
+            visible.executemany(f"INSERT INTO {table} VALUES (?, ?)", [row for row in rows if row[1] == 7])
+        rewritten = sqlscope.apply_row_filter(query, "tenant = 7", dialect="sqlite")
+        assert raw.execute(rewritten).fetchall() == visible.execute(query).fetchall()
+    finally:
+        raw.close()
+        visible.close()
+
+
+def test_rewritten_correlated_query_executes_in_sqlite():
+    import sqlite3
+
+    connection = sqlite3.connect(":memory:")
+    try:
+        connection.executescript(
+            "ATTACH ':memory:' AS s; CREATE TABLE s.t(id); CREATE TABLE safe(id); CREATE TABLE u(id);"
+            "INSERT INTO safe VALUES (1), (2); INSERT INTO u VALUES (2);"
+        )
+        rewritten = sqlscope.rewrite_tables(
+            "SELECT t.id FROM s.t WHERE EXISTS (SELECT 1 FROM u WHERE u.id = t.id)",
+            [TableRewrite("s.t", union=UnionRewrite("renamed", ["id"], [TableRef("safe")]))],
+            dialect="sqlite",
+        )
+        assert connection.execute(rewritten).fetchall() == [(2,)]
+    finally:
+        connection.close()
+
+
+def test_returning_usage():
+    assert ColumnUsage("t", "payload", Clause.RETURNING) in sqlscope.column_usages(
+        "DELETE FROM t WHERE id = 1 RETURNING payload", dialect="postgres"
+    )