sqlscope-rs 0.4.1__tar.gz → 0.6.0__tar.gz

{sqlscope_rs-0.4.1 → sqlscope_rs-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlscope-rs
-Version: 0.4.1
+Version: 0.6.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.1 → sqlscope_rs-0.6.0}/src/sqlscope/__init__.py

@@ -5,7 +5,7 @@ Function               Purpose
 =====================  ==========================================================
 apply_row_filter       Filter every in-scope table by a predicate.
 inject_ctes            Prepend CTE definitions to a query's root ``WITH``.
-rewrite_tables         Replace table references with derived tables.
+rewrite_tables         Replace table references with other tables or derived tables.
 column_origins         Source columns whose values reach the result (lineage).
 output_columns         Names of the columns a statement outputs.
 referenced_columns     Columns referenced anywhere, per table.
@@ -41,7 +41,7 @@ from ._library import (
     load,
 )
 
-__version__ = "0.4.1"
+__version__ = "0.6.0"
 
 __all__ = [
     "Clause",
@@ -107,12 +107,15 @@ class UnionRewrite:
 class TableRewrite:
     """Replaces references to ``match_key`` (``schema.table``).
 
-    Set exactly one of ``inline`` (``(SELECT * FROM inline)``) or ``union``.
+    Set exactly one of ``inline``, ``union``, or ``rename``. Optional ``columns``
+    selects identifier values from the inline target (empty selects all).
     """
 
     match_key: str
     inline: Optional[TableRef] = None
     union: Optional[UnionRewrite] = None
+    columns: Optional[Sequence[str]] = None
+    rename: Optional[TableRef] = None
 
 
 class Clause(str, Enum):
@@ -190,7 +193,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.
     """
@@ -238,7 +242,7 @@ def rewrite_tables(
 ) -> str:
     """Replace physical table references according to ``rewrites``.
 
-    Matched references become derived tables that keep their alias (or bare
+    Matched references keep their alias (or bare
     name); qualified column references are rebound onto it. Catalogs listed in
     ``strip_catalogs`` are transparent while matching. Returns the input
     unchanged when nothing matches.
@@ -247,6 +251,8 @@ def rewrite_tables(
         {
             "matchKey": rewrite.match_key,
             "inline": _table(rewrite.inline) if rewrite.inline is not None else None,
+            **({"columns": list(rewrite.columns)} if rewrite.columns else {}),
+            **({"rename": _table(rewrite.rename)} if rewrite.rename is not None else {}),
             "union": {
                 "tableAlias": rewrite.union.table_alias,
                 "columns": list(rewrite.union.columns),

{sqlscope_rs-0.4.1 → sqlscope_rs-0.6.0}/tests/test_sqlscope.py

@@ -40,6 +40,21 @@ def test_rewrite_tables():
     )
 
 
+def test_project_from_injected_cte():
+    query = sqlscope.rewrite_tables("SELECT t.a FROM s.t", [
+        TableRewrite("s.t", inline=TableRef("permitted"), columns=["a", "end"])
+    ])
+    query = sqlscope.inject_ctes(query, [CteDef("permitted", "SELECT * FROM src.t")])
+    assert query == 'WITH permitted AS (SELECT * FROM src.t) SELECT t.a FROM (SELECT a, "end" FROM permitted) AS t'
+
+
+def test_rename_table_argument():
+    query = sqlscope.rewrite_tables("SELECT * FROM ML.PREDICT(MODEL s.t, TABLE s.t)", [
+        TableRewrite("s.t", rename=TableRef("u", "v"))
+    ], dialect="bigquery")
+    assert query == "SELECT * FROM ML.PREDICT(MODEL s.t, TABLE v.u)"
+
+
 def test_rewrite_tables_requires_one_target():
     with pytest.raises(sqlscope.InvalidArgumentError):
         sqlscope.rewrite_tables("SELECT 1", [TableRewrite("s.t")])