ripple-sql 0.1.0__py3-none-any.whl

ripple/engine/tsql_catalog.py

@@ -0,0 +1,83 @@
+"""Documented output columns of SQL Server system objects.
+
+The sys schema is platform surface, not user warehouse: its DMVs and
+table-valued functions have fixed, documented columns, so an unqualified
+read across joined sys objects can be resolved offline the same way an
+ingested warehouse schema would resolve it (InvestigateWaits joins
+sys.dm_xe_session_targets to sys.dm_xe_sessions and reads target_data
+bare; sqlserver_kit, holdout round 8).
+
+Special-case area, one object per rule, each pinned by a test naming the
+motivating case. At about a dozen objects, replace with a generated
+catalog instead of growing this map.
+"""
+
+from __future__ import annotations
+
+_SYS_OBJECT_COLUMNS: dict[str, frozenset[str]] = {
+    "sys.dm_xe_sessions": frozenset(
+        {
+            "address",
+            "name",
+            "pending_buffers",
+            "total_regular_buffers",
+            "regular_buffer_size",
+            "total_large_buffers",
+            "large_buffer_size",
+            "total_buffer_size",
+            "buffer_policy_flags",
+            "buffer_policy_desc",
+            "flags",
+            "flag_desc",
+            "dropped_event_count",
+            "dropped_buffer_count",
+            "blocked_event_fire_time",
+            "create_time",
+            "largest_event_dropped_size",
+            "session_source",
+        }
+    ),
+    "sys.dm_xe_session_targets": frozenset(
+        {
+            "event_session_address",
+            "target_name",
+            "target_package_guid",
+            "execution_count",
+            "execution_duration_ms",
+            "target_data",
+            "bytes_written",
+        }
+    ),
+    "sys.fn_xe_file_target_read_file": frozenset(
+        {
+            "module_guid",
+            "package_guid",
+            "object_name",
+            "event_data",
+            "file_name",
+            "file_offset",
+            "timestamp_utc",
+        }
+    ),
+}
+
+
+def system_catalog_owner(column: str, candidates: list[str], dialect: str) -> str | None:
+    """The one candidate relation whose documented columns include column.
+
+    Fires only when EVERY candidate is a documented sys object: a single
+    unknown relation makes ownership unprovable and the ambiguous refusal
+    stands. The catalog is SQL Server platform surface, so any other
+    dialect gets None (cycle-9 review, F1).
+    """
+    if (dialect or "").lower() != "tsql":
+        return None
+    col = (column or "").lower()
+    owners: list[str] = []
+    for name in dict.fromkeys(candidates):
+        columns = _SYS_OBJECT_COLUMNS.get((name or "").lower())
+        if columns is None:
+            return None
+        if col in columns:
+            owners.append(name)
+    return owners[0] if len(owners) == 1 else None

ripple/engine/tsql_scalar_vars.py

@@ -0,0 +1,248 @@
+"""Order-aware T-SQL scalar variables in plain scripts.
+
+A variable used in an INSERT (a VALUES cell or a SELECT item, alone or
+inside a larger expression) traces to its single reaching definition:
+the last unconditional assignment before the use, with no conditional
+assignment after it. Anything else refuses: no assignment yet (the
+variable is still NULL), an IF-branch assignment that may or may not
+have run, an opaque SET, or a self-referential loop. SELECT @v = expr,
+UPDATE ... SET @v = expr, and DECLARE @v = default are all assignment
+sites; variable-to-variable definitions resolve recursively with a
+cycle guard; multi-row VALUES unions its rows so every row's source is
+cited (ceds_generate metadata scripts, holdout round 12; cycle-13
+review, F6/F7/F12/F13/F14).
+"""
+
+from __future__ import annotations
+
+import re
+
+from sqlglot import exp
+
+from ripple.engine.safe_gen import safe_sql
+
+_OPAQUE_ASSIGN = re.compile(r"@([\w$]+)\s*[-+*/%&|^]?=")
+
+
+class _Def:
+    __slots__ = ("pos", "value", "ctx", "conditional")
+
+    def __init__(self, pos, value, ctx, conditional):
+        self.pos = pos
+        self.value = value
+        self.ctx = ctx
+        self.conditional = conditional
+
+
+def _is_conditional(stmt: exp.Expression) -> bool:
+    meta = getattr(stmt, "_meta", None)
+    return bool(meta and meta.get("ripple_conditional"))
+
+
+def _update_ctx(stmt: exp.Update) -> exp.Select:
+    """A FROM scope for expressions assigned inside an UPDATE, so their
+    column reads stay anchored the way the SET clause saw them."""
+    sel = exp.Select()
+    upd_from = stmt.args.get("from_") or stmt.args.get("from")
+    if upd_from is not None:
+        sel.set("from_", upd_from.copy())
+    elif isinstance(stmt.this, exp.Table):
+        sel.set("from_", exp.From(this=stmt.this.copy()))
+    return sel
+
+
+class _ScalarDefs:
+    def __init__(self, statements: list[exp.Expression], dialect: str | None):
+        self.defs: dict[str, list[_Def]] = {}
+        for pos, stmt in enumerate(statements):
+            cond = _is_conditional(stmt)
+            if isinstance(stmt, exp.Select):
+                eqs = [
+                    e
+                    for e in stmt.expressions
+                    if isinstance(e, exp.EQ) and isinstance(e.this, exp.Parameter)
+                ]
+                if not eqs or len(eqs) != len(stmt.expressions):
+                    continue
+                for eq in eqs:
+                    self._add(pos, eq.this.name, eq.expression, stmt, cond)
+            elif isinstance(stmt, exp.Update):
+                for eq in stmt.expressions:
+                    if (
+                        isinstance(eq, exp.EQ)
+                        and isinstance(eq.this, exp.Parameter)
+                        and eq.expression is not None
+                    ):
+                        self._add(pos, eq.this.name, eq.expression, _update_ctx(stmt), cond)
+            elif isinstance(stmt, exp.Declare):
+                for item in stmt.expressions:
+                    if not isinstance(item, exp.DeclareItem):
+                        continue
+                    default = item.args.get("default")
+                    if not isinstance(default, exp.Expression):
+                        continue
+                    for param in item.this if isinstance(item.this, list) else [item.this]:
+                        if isinstance(param, exp.Parameter) and param.name:
+                            self._add(pos, param.name, default, None, cond)
+            elif isinstance(stmt, (exp.Set, exp.Command)):
+                text = safe_sql(stmt, dialect) or ""
+                for m in _OPAQUE_ASSIGN.finditer(text):
+                    self._add(pos, m.group(1), None, None, cond)
+
+    def _add(self, pos, var, value, ctx, conditional) -> None:
+        self.defs.setdefault(var.lower(), []).append(_Def(pos, value, ctx, conditional))
+
+    def resolve(self, var: str, use_pos: int, seen: frozenset[str]) -> exp.Expression | None:
+        """The variable's value at use_pos as a self-contained expression
+        (typically a scalar subquery), or None when no single reaching
+        definition exists."""
+        var = var.lower()
+        if var in seen:
+            return None
+        before = [d for d in self.defs.get(var, []) if d.pos < use_pos]
+        if not before:
+            return None
+        last_uncond = None
+        for idx, d in enumerate(before):
+            if not d.conditional:
+                last_uncond = idx
+        # reaching definitions: the last unconditional one plus any
+        # conditional ones after it; several possibly-live definitions
+        # (or none that surely ran) refuse rather than guess
+        if last_uncond is None or len(before) - last_uncond != 1:
+            return None
+        d = before[last_uncond]
+        if d.value is None:
+            return None
+        return self._anchored(d, seen | {var})
+
+    def _anchored(self, d: _Def, seen: frozenset[str]) -> exp.Expression | None:
+        value = d.value.copy()
+        if isinstance(value, exp.Parameter):
+            return self.resolve(value.name, d.pos, seen)
+        for param in list(value.find_all(exp.Parameter)):
+            sub = self.resolve(param.name, d.pos, seen)
+            if sub is None:
+                return None
+            param.replace(sub)
+        ctx = d.ctx
+        if ctx is not None and (ctx.args.get("from_") or ctx.args.get("from")):
+            inner = ctx.copy()
+            inner.set("expressions", [value])
+            return exp.Subquery(this=inner)
+        for col in value.find_all(exp.Column):
+            owner = _owning_select_within(col, value)
+            if owner is None or not (owner.args.get("from_") or owner.args.get("from")):
+                return None  # a bare column with no scope to anchor it
+        return value
+
+
+def _owning_select_within(col: exp.Expression, root: exp.Expression) -> exp.Select | None:
+    node = col.parent
+    while node is not None:
+        if isinstance(node, exp.Select):
+            return node
+        if node is root:
+            return None
+        node = node.parent
+    return None
+
+
+def _carries_sources(node: exp.Expression) -> bool:
+    return next(node.find_all(exp.Column), None) is not None
+
+
+def _substituted_cell(
+    cell: exp.Expression, defs: _ScalarDefs, use_pos: int
+) -> tuple[exp.Expression, bool]:
+    """The cell with each resolvable variable replaced by its reaching
+    definition's value; True when a replacement carries real sources."""
+    if isinstance(cell, exp.Parameter):
+        sub = defs.resolve(cell.name, use_pos, frozenset())
+        if sub is None:
+            return cell.copy(), False
+        return sub, _carries_sources(sub)
+    out = cell.copy()
+    traced = False
+    for param in list(out.find_all(exp.Parameter)):
+        sub = defs.resolve(param.name, use_pos, frozenset())
+        if sub is None:
+            continue
+        param.replace(sub)
+        traced = traced or _carries_sources(sub)
+    return out, traced
+
+
+def inline_scalar_params(statements: list[exp.Expression], dialect: str | None) -> None:
+    """Replace resolvable scalar variables inside INSERT ... SELECT items
+    in place, so the generic INSERT path traces the variable's sources
+    through whatever expression surrounds it (cycle-13 review, F13)."""
+    defs = _ScalarDefs(statements, dialect)
+    if not defs.defs:
+        return
+    for pos, stmt in enumerate(statements):
+        if not isinstance(stmt, exp.Insert):
+            continue
+        inner = stmt.expression
+        while isinstance(inner, (exp.Subquery, exp.Paren)):
+            inner = inner.this
+        if not isinstance(inner, exp.Select):
+            continue
+        for item in list(inner.expressions):
+            for param in list(item.find_all(exp.Parameter)):
+                sub = defs.resolve(param.name, pos, frozenset())
+                if sub is not None:
+                    param.replace(sub)
+
+
+def scalar_value_insert_models(statements: list[exp.Expression], dialect: str | None):
+    """ScriptModels for INSERT ... VALUES targets whose rows carry
+    resolvable scalar variables. Each row becomes one union branch with
+    every cell kept, so multi-row inserts cite every row's sources
+    instead of last-row-wins (cycle-13 review, F12)."""
+    from ripple.engine.column_ref import qualified_table_name
+    from ripple.engine.sql_script import ScriptModel, _referenced_tables
+
+    defs = _ScalarDefs(statements, dialect)
+    if not defs.defs:
+        return []
+    models: list[ScriptModel] = []
+    for pos, stmt in enumerate(statements):
+        if not isinstance(stmt, exp.Insert) or not isinstance(stmt.expression, exp.Values):
+            continue
+        schema = stmt.this
+        if not isinstance(schema, exp.Schema) or not isinstance(schema.this, exp.Table):
+            continue
+        if isinstance(schema.this.this, exp.Parameter):
+            continue
+        idents = schema.expressions
+        if not idents or not all(isinstance(c, exp.Identifier) for c in idents):
+            continue
+        branches: list[exp.Select] = []
+        for row in stmt.expression.expressions:
+            if not isinstance(row, exp.Tuple) or len(row.expressions) != len(idents):
+                continue
+            items: list[exp.Alias] = []
+            traced = False
+            for ident, cell in zip(idents, row.expressions, strict=True):
+                new_cell, cell_traced = _substituted_cell(cell, defs, pos)
+                traced = traced or cell_traced
+                items.append(exp.Alias(this=new_cell, alias=ident.copy()))
+            if traced:
+                branches.append(exp.Select(expressions=items))
+        if not branches:
+            continue
+        combined: exp.Expression = branches[0]
+        for branch in branches[1:]:
+            combined = exp.union(combined, branch, distinct=False, copy=False)
+        derived_sql = safe_sql(combined, dialect)
+        if derived_sql is None:
+            continue
+        models.append(
+            ScriptModel(
+                name=qualified_table_name(schema.this) or schema.this.name,
+                sql=derived_sql,
+                parents=_referenced_tables(combined),
+            )
+        )
+    return models