j-perm-sql 0.1.0__py3-none-any.whl

j_perm_sql/__init__.py

@@ -0,0 +1,48 @@
+"""j_perm_sql — build and execute SQL queries from j-perm constructs.
+
+SQL is described with a tree of ``$``-constructs (``$select``, ``$col``,
+``$val``, predicates, joins, …) and rendered by an **isolated** named pipeline.
+A single top-level operation, ``op: sql``, renders that tree to a parameterized
+``(sql, params)`` pair and hands it to a configurable executor (any ORM's raw
+execute).  The SQL constructs are never visible to the engine's normal value
+pipeline — they only mean anything inside ``op: sql``.
+
+Quick start::
+
+    from j_perm import build_default_engine
+    from j_perm_sql import install_sql
+
+    engine = build_default_engine()
+    install_sql(engine, my_orm_raw_execute, paramstyle="qmark")
+
+    engine.apply(
+        {"op": "sql", "to": "/rows", "query": {"$select": {
+            "columns": [{"$col": {"name": "id"}}],
+            "from": {"table": "users"},
+            "where": {"$gte": [{"$col": {"name": "age"}}, {"$val": 18}]},
+        }}},
+        source={}, dest={},
+    )
+"""
+from .constructs import build_sql_specials
+from .dialect import PLACEHOLDER, RenderOptions
+from .handler import AsyncSqlHandler, SqlHandler, SqlRenderer
+from .install import install_sql
+from .pipeline import SQL_PIPELINE_NAME, build_sql_pipeline
+from .render import fragment, is_fragment, is_query, render
+
+__all__ = [
+    "install_sql",
+    "RenderOptions",
+    "PLACEHOLDER",
+    "SqlHandler",
+    "AsyncSqlHandler",
+    "SqlRenderer",
+    "build_sql_pipeline",
+    "build_sql_specials",
+    "SQL_PIPELINE_NAME",
+    "fragment",
+    "is_fragment",
+    "is_query",
+    "render",
+]

j_perm_sql/constructs.py

@@ -0,0 +1,591 @@
+"""SQL construct handlers — the full standard ``SELECT`` surface.
+
+Each construct is a callable ``(node, ctx) -> fragment`` (built via
+:func:`build_sql_specials`, closing over a :class:`RenderOptions`).  Constructs
+recurse through the isolated SQL pipeline via the helpers in :mod:`.render`.
+
+Values are always bound as parameters (``$val`` and the data sides of ``$in`` /
+``$between`` / ``$values``); identifiers are validated and quoted.  Nothing
+user-supplied is interpolated into the SQL string except validated identifiers,
+function names, types, and a small set of whitelisted keywords.
+"""
+from __future__ import annotations
+
+from functools import partial
+from typing import Any
+
+from .dialect import PLACEHOLDER, RenderOptions
+from .render import (
+    fragment,
+    is_query,
+    join_fragments,
+    render_construct,
+    render_operand,
+    render_operands,
+    render_subquery,
+)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Whitelists (anything user-supplied that reaches the SQL string verbatim)
+# ─────────────────────────────────────────────────────────────────────────────
+
+_COMPARE_SYMBOLS = frozenset({"=", "<>", "!=", "<", "<=", ">", ">="})
+_JOIN_KEYWORDS = {
+    "inner": "INNER JOIN",
+    "left": "LEFT JOIN",
+    "right": "RIGHT JOIN",
+    "full": "FULL JOIN",
+    "cross": "CROSS JOIN",
+}
+_QUANTIFIERS = {"$any": "ANY", "$all": "ALL", "$some": "SOME"}
+_SETOPS = {
+    "$union": "UNION",
+    "$union_all": "UNION ALL",
+    "$intersect": "INTERSECT",
+    "$except": "EXCEPT",
+}
+
+
+def _int_literal(value: Any, what: str) -> int:
+    """Validate an integer literal (LIMIT/OFFSET/frame offsets)."""
+    if not isinstance(value, int) or isinstance(value, bool):
+        raise ValueError(f"{what} must be an integer, got {value!r}")
+    return value
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Leaves: column reference and bound value
+# ─────────────────────────────────────────────────────────────────────────────
+
+def col(node, ctx, *, opts: RenderOptions) -> dict:
+    spec = node["$col"]
+    if isinstance(spec, str):
+        spec = {"name": spec}
+    name = spec["name"]
+    table = spec.get("table")
+    if name == "*":
+        core = (opts.quote_identifier(table) + "." if table else "") + "*"
+    else:
+        parts = ([table] if table else []) + [name]
+        core = ".".join(opts.quote_identifier(p) for p in parts)
+    if spec.get("as"):
+        core += f" AS {opts.quote_identifier(spec['as'])}"
+    return fragment(core)
+
+
+def val(node, ctx, *, opts: RenderOptions) -> dict:
+    value = ctx.engine.process_value(node["$val"], ctx)
+    return fragment(PLACEHOLDER, [value])
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Expressions: functions, cast, case, concat, arithmetic
+# ─────────────────────────────────────────────────────────────────────────────
+
+def func(node, ctx, *, opts: RenderOptions) -> dict:
+    spec = node.get("$func", node.get("$call"))
+    name = opts.validate_func_name(spec["name"])
+    arg_sqls: list[str] = []
+    params: list = []
+    for arg in spec.get("args", []):
+        if arg == "*":
+            arg_sqls.append("*")
+        else:
+            frag = render_operand(arg, ctx, opts)
+            arg_sqls.append(frag["sql"])
+            params += frag["params"]
+    distinct = "DISTINCT " if spec.get("distinct") else ""
+    sql = f"{name}({distinct}{', '.join(arg_sqls)})"
+    if "over" in spec:
+        win = _render_window(spec["over"], ctx, opts)
+        sql += f" OVER ({win['sql']})"
+        params += win["params"]
+    if spec.get("as"):
+        sql += f" AS {opts.quote_identifier(spec['as'])}"
+    return fragment(sql, params)
+
+
+def _render_window(over, ctx, opts: RenderOptions) -> dict:
+    parts: list[str] = []
+    params: list = []
+    if over.get("partition_by"):
+        pf = render_operands(over["partition_by"], ctx, opts)
+        parts.append(f"PARTITION BY {pf['sql']}")
+        params += pf["params"]
+    if over.get("order_by"):
+        of = _render_order_by(over["order_by"], ctx, opts)
+        parts.append(f"ORDER BY {of['sql']}")
+        params += of["params"]
+    if "frame" in over:
+        parts.append(_render_frame(over["frame"]))
+    return fragment(" ".join(parts), params)
+
+
+def _render_frame(frame) -> str:
+    ftype = frame["type"].upper()
+    if ftype not in ("ROWS", "RANGE"):
+        raise ValueError(f"frame type must be ROWS or RANGE, got {frame['type']!r}")
+    start = _frame_bound(frame["start"])
+    if "end" in frame:
+        return f"{ftype} BETWEEN {start} AND {_frame_bound(frame['end'])}"
+    return f"{ftype} {start}"
+
+
+def _frame_bound(bound) -> str:
+    if isinstance(bound, str):
+        norm = bound.strip().lower()
+        if norm in ("unbounded preceding", "unbounded following", "current row"):
+            return norm.upper()
+        raise ValueError(f"invalid frame bound: {bound!r}")
+    if isinstance(bound, dict):
+        if "preceding" in bound:
+            return f"{_int_literal(bound['preceding'], 'frame offset')} PRECEDING"
+        if "following" in bound:
+            return f"{_int_literal(bound['following'], 'frame offset')} FOLLOWING"
+    raise ValueError(f"invalid frame bound: {bound!r}")
+
+
+def cast(node, ctx, *, opts: RenderOptions) -> dict:
+    spec = node["$cast"]
+    expr = render_operand(spec["expr"], ctx, opts)
+    type_str = opts.validate_type(spec["type"])
+    sql = f"CAST({expr['sql']} AS {type_str})"
+    if spec.get("as"):
+        sql += f" AS {opts.quote_identifier(spec['as'])}"
+    return fragment(sql, expr["params"])
+
+
+def case(node, ctx, *, opts: RenderOptions) -> dict:
+    spec = node["$case"]
+    parts = ["CASE"]
+    params: list = []
+    for branch in spec["whens"]:
+        cond = render_construct(branch["when"], ctx)
+        result = render_operand(branch["then"], ctx, opts)
+        parts.append(f"WHEN {cond['sql']} THEN {result['sql']}")
+        params += cond["params"] + result["params"]
+    if "else" in spec:
+        els = render_operand(spec["else"], ctx, opts)
+        parts.append(f"ELSE {els['sql']}")
+        params += els["params"]
+    parts.append("END")
+    sql = " ".join(parts)
+    if spec.get("as"):
+        sql += f" AS {opts.quote_identifier(spec['as'])}"
+    return fragment(sql, params)
+
+
+def concat(node, ctx, *, opts: RenderOptions) -> dict:
+    frag = render_operands(node["$concat"], ctx, opts, sep=f" {opts.concat_operator} ")
+    return fragment(f"({frag['sql']})", frag["params"])
+
+
+def _arith(node, ctx, *, opts: RenderOptions, key: str, symbol: str) -> dict:
+    frag = render_operands(node[key], ctx, opts, sep=f" {symbol} ")
+    return fragment(f"({frag['sql']})", frag["params"])
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Predicates
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _boolean(node, ctx, *, opts: RenderOptions, key: str, word: str) -> dict:
+    preds = node[key]
+    if not preds:
+        raise ValueError(f"{key} requires at least one predicate")
+    frags = [render_construct(p, ctx) for p in preds]
+    joined = f" {word} ".join(f["sql"] for f in frags)
+    params = [p for f in frags for p in f["params"]]
+    return fragment(f"({joined})", params)
+
+
+def not_(node, ctx, *, opts: RenderOptions) -> dict:
+    inner = render_construct(node["$not"], ctx)
+    return fragment(f"NOT ({inner['sql']})", inner["params"])
+
+
+def _cmp(node, ctx, *, opts: RenderOptions, key: str, symbol: str) -> dict:
+    left, right = node[key]
+    lf = render_operand(left, ctx, opts)
+    rf = render_operand(right, ctx, opts)
+    return fragment(f"{lf['sql']} {symbol} {rf['sql']}", lf["params"] + rf["params"])
+
+
+def _in(node, ctx, *, opts: RenderOptions, negate: bool) -> dict:
+    key = "$not_in" if negate else "$in"
+    left, right = node[key]
+    lf = render_operand(left, ctx, opts)
+    kw = "NOT IN" if negate else "IN"
+    if is_query(right):
+        sub = render_subquery(right, ctx)
+        return fragment(f"{lf['sql']} {kw} {sub['sql']}", lf["params"] + sub["params"])
+    values = ctx.engine.process_value(right, ctx)
+    if not isinstance(values, (list, tuple)):
+        values = [values]
+    if not values:
+        raise ValueError(f"{key} requires a non-empty value list")
+    placeholders = ", ".join(PLACEHOLDER for _ in values)
+    return fragment(f"{lf['sql']} {kw} ({placeholders})", lf["params"] + list(values))
+
+
+def _between(node, ctx, *, opts: RenderOptions, negate: bool) -> dict:
+    key = "$not_between" if negate else "$between"
+    expr, low, high = node[key]
+    ef = render_operand(expr, ctx, opts)
+    lf = render_operand(low, ctx, opts)
+    hf = render_operand(high, ctx, opts)
+    kw = "NOT BETWEEN" if negate else "BETWEEN"
+    return fragment(
+        f"{ef['sql']} {kw} {lf['sql']} AND {hf['sql']}",
+        ef["params"] + lf["params"] + hf["params"],
+    )
+
+
+def _like(node, ctx, *, opts: RenderOptions, negate: bool) -> dict:
+    key = "$not_like" if negate else "$like"
+    expr, pattern = node[key]
+    ef = render_operand(expr, ctx, opts)
+    pf = render_operand(pattern, ctx, opts)
+    kw = "NOT LIKE" if negate else "LIKE"
+    sql = f"{ef['sql']} {kw} {pf['sql']}"
+    params = ef["params"] + pf["params"]
+    if "escape" in node:
+        esc = render_operand(node["escape"], ctx, opts)
+        sql += f" ESCAPE {esc['sql']}"
+        params += esc["params"]
+    return fragment(sql, params)
+
+
+def _is_null(node, ctx, *, opts: RenderOptions, negate: bool) -> dict:
+    key = "$is_not_null" if negate else "$is_null"
+    ef = render_operand(node[key], ctx, opts)
+    kw = "IS NOT NULL" if negate else "IS NULL"
+    return fragment(f"{ef['sql']} {kw}", ef["params"])
+
+
+def _exists(node, ctx, *, opts: RenderOptions, negate: bool) -> dict:
+    key = "$not_exists" if negate else "$exists"
+    sub = render_subquery(node[key], ctx)
+    kw = "NOT EXISTS" if negate else "EXISTS"
+    return fragment(f"{kw} {sub['sql']}", sub["params"])
+
+
+def _quantified(node, ctx, *, opts: RenderOptions, key: str) -> dict:
+    left, op, query = node[key]
+    if op not in _COMPARE_SYMBOLS:
+        raise ValueError(f"invalid comparison operator: {op!r}")
+    lf = render_operand(left, ctx, opts)
+    sub = render_subquery(query, ctx)
+    return fragment(
+        f"{lf['sql']} {op} {_QUANTIFIERS[key]} {sub['sql']}",
+        lf["params"] + sub["params"],
+    )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Clause helpers (not registered constructs — they only appear inside $select)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _render_order_by(items, ctx, opts: RenderOptions) -> dict:
+    rendered: list[str] = []
+    params: list = []
+    for item in items:
+        if isinstance(item, dict) and "expr" in item:
+            ef = render_operand(item["expr"], ctx, opts)
+            sql = ef["sql"]
+            params += ef["params"]
+            direction = item.get("dir")
+            if direction is not None:
+                if direction.lower() not in ("asc", "desc"):
+                    raise ValueError(f"order_by dir must be asc/desc, got {direction!r}")
+                sql += f" {direction.upper()}"
+            nulls = item.get("nulls")
+            if nulls is not None:
+                if nulls.lower() not in ("first", "last"):
+                    raise ValueError(f"order_by nulls must be first/last, got {nulls!r}")
+                sql += f" NULLS {nulls.upper()}"
+            rendered.append(sql)
+        else:
+            frag = render_operand(item, ctx, opts)
+            rendered.append(frag["sql"])
+            params += frag["params"]
+    return fragment(", ".join(rendered), params)
+
+
+def _render_group_by(spec, ctx, opts: RenderOptions) -> dict:
+    if isinstance(spec, dict):
+        if "$rollup" in spec:
+            frag = render_operands(spec["$rollup"], ctx, opts)
+            return fragment(f"ROLLUP ({frag['sql']})", frag["params"])
+        if "$cube" in spec:
+            frag = render_operands(spec["$cube"], ctx, opts)
+            return fragment(f"CUBE ({frag['sql']})", frag["params"])
+        if "$grouping_sets" in spec:
+            rendered: list[str] = []
+            params: list = []
+            for group in spec["$grouping_sets"]:
+                gf = render_operands(group, ctx, opts)
+                rendered.append(f"({gf['sql']})")
+                params += gf["params"]
+            return fragment(f"GROUPING SETS ({', '.join(rendered)})", params)
+        raise ValueError(f"invalid group_by spec: {spec!r}")
+    return render_operands(spec, ctx, opts)
+
+
+def _source_dict(spec) -> dict:
+    """Extract the table-source portion from a $join spec."""
+    return {
+        "table": spec["table"],
+        "as": spec.get("as"),
+        "schema": spec.get("schema"),
+        "lateral": spec.get("lateral"),
+    }
+
+
+def _render_table_source(node, ctx, opts: RenderOptions) -> dict:
+    if isinstance(node, str):
+        return fragment(opts.quote_ref(node))
+    table = node["table"]
+    if is_query(table):
+        sub = render_subquery(table, ctx)
+        alias = node.get("as")
+        if not alias:
+            raise ValueError("derived table requires an alias ('as')")
+        lateral = "LATERAL " if node.get("lateral") else ""
+        return fragment(
+            f"{lateral}{sub['sql']} AS {opts.quote_identifier(alias)}", sub["params"]
+        )
+    parts = ([node["schema"]] if node.get("schema") else []) + [table]
+    sql = ".".join(opts.quote_identifier(p) for p in parts)
+    if node.get("as"):
+        sql += f" AS {opts.quote_identifier(node['as'])}"
+    return fragment(sql)
+
+
+def join(node, ctx, *, opts: RenderOptions) -> dict:
+    spec = node["$join"]
+    jtype = spec.get("type", "inner").lower()
+    if jtype not in _JOIN_KEYWORDS:
+        raise ValueError(f"invalid join type: {spec.get('type')!r}")
+    natural = "NATURAL " if spec.get("natural") else ""
+    source = _render_table_source(_source_dict(spec), ctx, opts)
+    sql = f"{natural}{_JOIN_KEYWORDS[jtype]} {source['sql']}"
+    params = list(source["params"])
+    if "on" in spec:
+        cond = render_construct(spec["on"], ctx)
+        sql += f" ON {cond['sql']}"
+        params += cond["params"]
+    elif "using" in spec:
+        cols = ", ".join(opts.quote_identifier(c) for c in spec["using"])
+        sql += f" USING ({cols})"
+    return fragment(sql, params)
+
+
+def _render_with(entries, ctx, opts: RenderOptions) -> dict:
+    recursive = any(e.get("recursive") for e in entries)
+    rendered: list[str] = []
+    params: list = []
+    for entry in entries:
+        name = opts.quote_identifier(entry["name"])
+        columns = ""
+        if entry.get("columns"):
+            cols = ", ".join(opts.quote_identifier(c) for c in entry["columns"])
+            columns = f" ({cols})"
+        sub = render_construct(entry["query"], ctx)
+        rendered.append(f"{name}{columns} AS ({sub['sql']})")
+        params += sub["params"]
+    keyword = "WITH RECURSIVE " if recursive else "WITH "
+    return fragment(keyword + ", ".join(rendered), params)
+
+
+def _render_pagination(spec, opts: RenderOptions) -> str:
+    limit = spec.get("limit")
+    offset = spec.get("offset")
+    fetch = spec.get("fetch")
+    if limit is not None:
+        limit = _int_literal(limit, "limit")
+    if offset is not None:
+        offset = _int_literal(offset, "offset")
+    if fetch is not None:
+        fetch = _int_literal(fetch, "fetch")
+    out: list[str] = []
+    if opts.pagination == "limit":
+        count = limit if limit is not None else fetch
+        if count is not None:
+            out.append(f"LIMIT {count}")
+        if offset is not None:
+            out.append(f"OFFSET {offset}")
+    else:  # fetch
+        if offset is not None:
+            out.append(f"OFFSET {offset} ROWS")
+        count = fetch if fetch is not None else limit
+        if count is not None:
+            out.append(f"FETCH FIRST {count} ROWS ONLY")
+    return " ".join(out)
+
+
+def _render_select_list(columns, ctx, opts: RenderOptions) -> dict:
+    if not columns:
+        return fragment("*")
+    return join_fragments(
+        [_render_projection_item(c, ctx, opts) for c in columns], ", "
+    )
+
+
+def _render_projection_item(item, ctx, opts: RenderOptions) -> dict:
+    if isinstance(item, dict) and "expr" in item:
+        ef = render_operand(item["expr"], ctx, opts)
+        sql = ef["sql"]
+        if item.get("as"):
+            sql += f" AS {opts.quote_identifier(item['as'])}"
+        return fragment(sql, ef["params"])
+    return render_operand(item, ctx, opts)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Top-level query constructs: $select, set operations, $values
+# ─────────────────────────────────────────────────────────────────────────────
+
+def select(node, ctx, *, opts: RenderOptions) -> dict:
+    spec = node["$select"]
+    clauses: list[str] = []
+    params: list = []
+
+    if "with" in spec:
+        w = _render_with(spec["with"], ctx, opts)
+        clauses.append(w["sql"])
+        params += w["params"]
+
+    head = "SELECT DISTINCT" if spec.get("distinct") else "SELECT"
+    cols = _render_select_list(spec.get("columns"), ctx, opts)
+    clauses.append(f"{head} {cols['sql']}")
+    params += cols["params"]
+
+    if "from" in spec:
+        frm = _render_table_source(spec["from"], ctx, opts)
+        clauses.append(f"FROM {frm['sql']}")
+        params += frm["params"]
+
+    for joinspec in spec.get("joins", []):
+        jf = render_construct(joinspec, ctx)
+        clauses.append(jf["sql"])
+        params += jf["params"]
+
+    if "where" in spec:
+        wf = render_construct(spec["where"], ctx)
+        clauses.append(f"WHERE {wf['sql']}")
+        params += wf["params"]
+
+    if "group_by" in spec:
+        gf = _render_group_by(spec["group_by"], ctx, opts)
+        clauses.append(f"GROUP BY {gf['sql']}")
+        params += gf["params"]
+
+    if "having" in spec:
+        hf = render_construct(spec["having"], ctx)
+        clauses.append(f"HAVING {hf['sql']}")
+        params += hf["params"]
+
+    if "order_by" in spec:
+        of = _render_order_by(spec["order_by"], ctx, opts)
+        clauses.append(f"ORDER BY {of['sql']}")
+        params += of["params"]
+
+    pagination = _render_pagination(spec, opts)
+    if pagination:
+        clauses.append(pagination)
+
+    return fragment(" ".join(clauses), params)
+
+
+def _setop(node, ctx, *, opts: RenderOptions, key: str) -> dict:
+    queries = node[key]
+    if not queries:
+        raise ValueError(f"{key} requires at least one query")
+    frags = [render_construct(q, ctx) for q in queries]
+    sql = f" {_SETOPS[key]} ".join(f["sql"] for f in frags)
+    params = [p for f in frags for p in f["params"]]
+    if "order_by" in node:
+        of = _render_order_by(node["order_by"], ctx, opts)
+        sql += f" ORDER BY {of['sql']}"
+        params += of["params"]
+    pagination = _render_pagination(node, opts)
+    if pagination:
+        sql += f" {pagination}"
+    return fragment(sql, params)
+
+
+def values(node, ctx, *, opts: RenderOptions) -> dict:
+    rows = node["$values"]
+    if not rows:
+        raise ValueError("$values requires at least one row")
+    rendered_rows: list[str] = []
+    params: list = []
+    width: int | None = None
+    for row in rows:
+        if width is None:
+            width = len(row)
+        elif len(row) != width:
+            raise ValueError("all $values rows must have the same length")
+        rendered_rows.append("(" + ", ".join(PLACEHOLDER for _ in row) + ")")
+        for cell in row:
+            params.append(ctx.engine.process_value(cell, ctx))
+    return fragment("VALUES " + ", ".join(rendered_rows), params)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Registry assembly
+# ─────────────────────────────────────────────────────────────────────────────
+
+def build_sql_specials(opts: RenderOptions) -> dict:
+    """Build the ``{key: handler}`` mapping for the SQL pipeline.
+
+    Every handler is bound to *opts* so the SQL pipeline renders for one
+    target dialect.
+    """
+    specials: dict = {
+        "$select": select,
+        "$col": col,
+        "$val": val,
+        "$join": join,
+        "$func": func,
+        "$call": func,
+        "$cast": cast,
+        "$case": case,
+        "$concat": concat,
+        "$not": not_,
+        "$values": values,
+    }
+    # comparisons
+    for key, symbol in {
+        "$eq": "=", "$ne": "<>", "$gt": ">", "$gte": ">=", "$lt": "<", "$lte": "<=",
+    }.items():
+        specials[key] = partial(_cmp, key=key, symbol=symbol)
+    # arithmetic
+    for key, symbol in {
+        "$add": "+", "$sub": "-", "$mul": "*", "$div": "/", "$mod": "%",
+    }.items():
+        specials[key] = partial(_arith, key=key, symbol=symbol)
+    # boolean connectives
+    specials["$and"] = partial(_boolean, key="$and", word="AND")
+    specials["$or"] = partial(_boolean, key="$or", word="OR")
+    # in / between / like / null / exists (+ negations)
+    specials["$in"] = partial(_in, negate=False)
+    specials["$not_in"] = partial(_in, negate=True)
+    specials["$between"] = partial(_between, negate=False)
+    specials["$not_between"] = partial(_between, negate=True)
+    specials["$like"] = partial(_like, negate=False)
+    specials["$not_like"] = partial(_like, negate=True)
+    specials["$is_null"] = partial(_is_null, negate=False)
+    specials["$is_not_null"] = partial(_is_null, negate=True)
+    specials["$exists"] = partial(_exists, negate=False)
+    specials["$not_exists"] = partial(_exists, negate=True)
+    # quantified comparisons
+    for key in _QUANTIFIERS:
+        specials[key] = partial(_quantified, key=key)
+    # set operations
+    for key in _SETOPS:
+        specials[key] = partial(_setop, key=key)
+
+    # bind opts into every handler
+    return {key: partial(fn, opts=opts) for key, fn in specials.items()}

j_perm_sql/dialect.py

@@ -0,0 +1,120 @@
+"""Dialect / rendering options for the SQL plugin.
+
+Everything that genuinely differs between SQL databases lives here so the
+construct handlers can stay dialect-agnostic:
+
+* ``paramstyle``       – how bound parameters appear (PEP 249 styles).
+* ``identifier_quote`` – the character used to quote identifiers.
+* ``pagination``       – ``"limit"`` (``LIMIT n OFFSET m``) or ``"fetch"``
+  (``OFFSET m ROWS FETCH FIRST n ROWS ONLY``).
+* ``concat_operator``  – string concatenation operator (``||`` or ``+``).
+
+The construct handlers render with a single neutral placeholder token
+(:data:`PLACEHOLDER`, ``"?"``) and :meth:`RenderOptions.finalize` rewrites
+those into the configured ``paramstyle`` at the very end.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+#: Neutral placeholder emitted during rendering; rewritten by ``finalize``.
+PLACEHOLDER = "?"
+
+_PARAMSTYLES = frozenset({"qmark", "format", "numeric", "named"})
+_PAGINATIONS = frozenset({"limit", "fetch"})
+
+# A single, unqualified identifier part.  Conservative on purpose: the strict
+# charset both prevents SQL injection through identifiers and guarantees the
+# rendered SQL never contains a stray ``?`` (so ``finalize`` can rewrite
+# placeholders by a simple left-to-right scan).
+_IDENT_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+# A SQL type expression for ``CAST`` (e.g. ``VARCHAR(255)``, ``DECIMAL(10, 2)``).
+_TYPE_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_ ,()]*$")
+
+# A bare function name (rendered as-is, never quoted).
+_FUNC_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+@dataclass(frozen=True)
+class RenderOptions:
+    """Immutable knobs controlling how SQL is rendered for a target dialect."""
+
+    paramstyle: str = "qmark"
+    identifier_quote: str = '"'
+    pagination: str = "limit"
+    concat_operator: str = "||"
+
+    def __post_init__(self) -> None:
+        if self.paramstyle not in _PARAMSTYLES:
+            raise ValueError(
+                f"paramstyle must be one of {sorted(_PARAMSTYLES)}, got {self.paramstyle!r}"
+            )
+        if self.pagination not in _PAGINATIONS:
+            raise ValueError(
+                f"pagination must be one of {sorted(_PAGINATIONS)}, got {self.pagination!r}"
+            )
+        if len(self.identifier_quote) != 1:
+            raise ValueError("identifier_quote must be a single character")
+
+    # -- identifiers --------------------------------------------------------
+
+    def quote_identifier(self, name: str) -> str:
+        """Validate and quote a single identifier part (e.g. a column name)."""
+        if not isinstance(name, str) or not _IDENT_RE.match(name):
+            raise ValueError(f"invalid SQL identifier: {name!r}")
+        q = self.identifier_quote
+        return f"{q}{name}{q}"
+
+    def quote_ref(self, ref: str) -> str:
+        """Quote a possibly dotted/star reference (e.g. ``u.id``, ``u.*``, ``*``)."""
+        if ref == "*":
+            return "*"
+        parts = ref.split(".")
+        out = [p if p == "*" else self.quote_identifier(p) for p in parts]
+        return ".".join(out)
+
+    def validate_type(self, type_str: str) -> str:
+        """Validate a CAST target type string and return it unchanged."""
+        if not isinstance(type_str, str) or not _TYPE_RE.match(type_str):
+            raise ValueError(f"invalid SQL type: {type_str!r}")
+        return type_str
+
+    def validate_func_name(self, name: str) -> str:
+        """Validate a function name and return it unchanged (never quoted)."""
+        if not isinstance(name, str) or not _FUNC_RE.match(name):
+            raise ValueError(f"invalid SQL function name: {name!r}")
+        return name
+
+    # -- placeholders -------------------------------------------------------
+
+    def finalize(self, sql: str, params: list) -> tuple[str, list | dict]:
+        """Rewrite neutral ``?`` placeholders into the configured paramstyle.
+
+        Returns ``(sql, params)`` where *params* is a list for positional
+        styles and a dict for ``named``.
+        """
+        count = sql.count(PLACEHOLDER)
+        if count != len(params):
+            raise ValueError(
+                f"placeholder/param mismatch: {count} placeholders, {len(params)} params"
+            )
+        if self.paramstyle == "qmark":
+            return sql, list(params)
+        if self.paramstyle == "format":
+            return sql.replace(PLACEHOLDER, "%s"), list(params)
+
+        # numeric / named — rewrite each placeholder positionally
+        out: list[str] = []
+        idx = 0
+        for ch in sql:
+            if ch == PLACEHOLDER:
+                idx += 1
+                out.append(f"${idx}" if self.paramstyle == "numeric" else f":p{idx}")
+            else:
+                out.append(ch)
+        rewritten = "".join(out)
+        if self.paramstyle == "numeric":
+            return rewritten, list(params)
+        return rewritten, {f"p{i + 1}": v for i, v in enumerate(params)}

j_perm_sql/handler.py

@@ -0,0 +1,75 @@
+"""The single top-level ``op: sql`` operation (sync + async).
+
+Schema::
+
+    {"op": "sql", "query": <SQL construct tree>, "to": "/dest/path"}
+
+* ``query`` — the SQL construct tree (rendered via the isolated SQL pipeline).
+* ``to``    — optional destination pointer; the executor's result is written
+              there (template-expanded).  If omitted, the result is discarded.
+
+Rendering is identical for sync and async; only the executor call differs
+(call vs ``await``).  A single class can't expose both a sync and an async
+``execute`` (same method name), and ``Pipeline.run_async`` dispatches to the
+async path only for :class:`AsyncActionHandler` — hence two classes over one
+shared :class:`SqlRenderer`.
+"""
+from __future__ import annotations
+
+from j_perm import ActionHandler, AsyncActionHandler
+
+from .dialect import RenderOptions
+from .render import SQL_PIPELINE_NAME, is_fragment
+
+
+class SqlRenderer:
+    """Render a SQL construct tree to ``(sql, params)`` for a target dialect."""
+
+    def __init__(self, opts: RenderOptions) -> None:
+        self.opts = opts
+
+    def render(self, query, ctx) -> tuple:
+        # Render against a scratch dest so the real document is never clobbered,
+        # but expose the real dest under _real_dest so @: pointers inside $val
+        # can still read the document being built.
+        render_ctx = ctx.copy(
+            new_dest={},
+            new_metadata={**ctx.metadata, "_real_dest": ctx.dest},
+        )
+        frag = ctx.engine.run_pipeline(SQL_PIPELINE_NAME, query, render_ctx).dest
+        if not is_fragment(frag):
+            raise ValueError("top-level SQL query must be a SQL construct")
+        return self.opts.finalize(frag["sql"], frag["params"])
+
+
+def _write_result(step, ctx, result):
+    if "to" in step:
+        path = ctx.engine.process_value(step["to"], ctx)
+        ctx.engine.processor.set(path, ctx, result)
+    return ctx.dest
+
+
+class SqlHandler(ActionHandler):
+    """``op: sql`` with a synchronous executor ``executor(sql, params) -> result``."""
+
+    def __init__(self, executor, renderer: SqlRenderer) -> None:
+        self._executor = executor
+        self._renderer = renderer
+
+    def execute(self, step, ctx):
+        sql, params = self._renderer.render(step["query"], ctx)
+        result = self._executor(sql, params)
+        return _write_result(step, ctx, result)
+
+
+class AsyncSqlHandler(AsyncActionHandler):
+    """``op: sql`` with an async executor ``await executor(sql, params) -> result``."""
+
+    def __init__(self, executor, renderer: SqlRenderer) -> None:
+        self._executor = executor
+        self._renderer = renderer
+
+    async def execute(self, step, ctx):
+        sql, params = self._renderer.render(step["query"], ctx)
+        result = await self._executor(sql, params)
+        return _write_result(step, ctx, result)

j_perm_sql/install.py

@@ -0,0 +1,47 @@
+"""``install_sql`` — patch an existing engine with SQL support.
+
+Rather than building a new engine, this registers the isolated SQL pipeline
+and adds the single ``op: sql`` top-level operation to an already-built
+``Engine``.  It composes with any engine (and any other plugins).
+"""
+from __future__ import annotations
+
+import asyncio
+
+from j_perm import ActionNode, OpMatcher
+
+from .dialect import RenderOptions
+from .handler import AsyncSqlHandler, SqlHandler, SqlRenderer
+from .pipeline import build_sql_pipeline
+from .render import SQL_PIPELINE_NAME
+
+__all__ = ["install_sql"]
+
+
+def install_sql(engine, executor, *, paramstyle: str = "qmark", dialect=None, op: str = "sql"):
+    """Install SQL support into *engine*.
+
+    Args:
+        engine:    a built ``j_perm`` engine (e.g. from ``build_default_engine``).
+        executor:  ``executor(sql, params) -> result``.  If it is a coroutine
+                   function, the async ``op: sql`` handler is registered (use
+                   with ``engine.apply_async``); otherwise the sync handler.
+        paramstyle: placeholder style when *dialect* is not given
+                    (``qmark`` | ``format`` | ``numeric`` | ``named``).
+        dialect:   an explicit :class:`RenderOptions`; overrides *paramstyle*.
+        op:        the operation name to register (default ``"sql"``).
+
+    Returns:
+        The same *engine*, for chaining.
+    """
+    opts = dialect if dialect is not None else RenderOptions(paramstyle=paramstyle)
+    engine.register_pipeline(SQL_PIPELINE_NAME, build_sql_pipeline(opts))
+    renderer = SqlRenderer(opts)
+    if asyncio.iscoroutinefunction(executor):
+        handler = AsyncSqlHandler(executor, renderer)
+    else:
+        handler = SqlHandler(executor, renderer)
+    engine.main_pipeline.registry.register(
+        ActionNode(name=op, priority=10, matcher=OpMatcher(op), handler=handler)
+    )
+    return engine

j_perm_sql/pipeline.py

@@ -0,0 +1,47 @@
+"""Assembly of the isolated, named SQL value-pipeline.
+
+The SQL constructs live **only** in this pipeline's ``SpecialMatcher`` — they are
+never registered in the engine's default ``value_pipeline``.  So ``{"$select": …}``
+outside of the ``sql`` operation is just a plain dict, not a construct.
+"""
+from __future__ import annotations
+
+from j_perm import (
+    ActionNode,
+    ActionTypeRegistry,
+    AlwaysMatcher,
+    IdentityHandler,
+    Pipeline,
+    SpecialMatcher,
+    SpecialResolveHandler,
+)
+
+from .constructs import build_sql_specials
+from .dialect import RenderOptions
+from .render import SQL_PIPELINE_NAME
+
+__all__ = ["build_sql_pipeline", "SQL_PIPELINE_NAME"]
+
+
+def build_sql_pipeline(opts: RenderOptions | None = None) -> Pipeline:
+    """Build the isolated SQL pipeline for the given dialect options."""
+    opts = opts if opts is not None else RenderOptions()
+    specials = build_sql_specials(opts)
+    registry = ActionTypeRegistry()
+    registry.register(
+        ActionNode(
+            name="sql_special",
+            priority=10,
+            matcher=SpecialMatcher(set(specials)),
+            handler=SpecialResolveHandler(specials),
+        )
+    )
+    registry.register(
+        ActionNode(
+            name="sql_identity",
+            priority=-999,
+            matcher=AlwaysMatcher(),
+            handler=IdentityHandler(),
+        )
+    )
+    return Pipeline(registry=registry, track_execution=True)

j_perm_sql/render.py

@@ -0,0 +1,97 @@
+"""Rendering primitives shared by the SQL construct handlers.
+
+A *fragment* is the unit every construct produces::
+
+    {"sql": "<sql text>", "params": [<bound values>]}
+
+Values are always bound as parameters (never interpolated), so the rendered
+``sql`` only ever contains the neutral ``?`` placeholder for data.
+
+Recursion happens through the isolated, named SQL pipeline: :func:`render`
+dispatches a node back through ``engine.run_pipeline`` so nested constructs
+resolve via the same handlers.  The pipeline is invoked over the caller's
+context as-is (j-perm's ``run_pipeline`` is passthrough), which keeps recursion
+cheap — no per-node deep copy.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .dialect import PLACEHOLDER, RenderOptions
+
+#: Name the SQL value-pipeline is registered under on the engine.
+SQL_PIPELINE_NAME = "sql"
+
+#: Keys whose presence marks a node as a *query* (must be parenthesised when
+#: used as an operand, subquery, or derived table).
+_QUERY_KEYS = frozenset(
+    {"$select", "$union", "$union_all", "$intersect", "$except", "$values"}
+)
+
+
+def fragment(sql: str, params: list | None = None) -> dict:
+    """Build a SQL fragment dict."""
+    return {"sql": sql, "params": list(params) if params else []}
+
+
+def is_fragment(value: Any) -> bool:
+    """True if *value* is a rendered SQL fragment."""
+    return isinstance(value, dict) and "sql" in value and "params" in value
+
+
+def is_query(node: Any) -> bool:
+    """True if *node* is a query construct (``$select``/set-op/``$values``)."""
+    return isinstance(node, dict) and any(k in node for k in _QUERY_KEYS)
+
+
+def render(node: Any, ctx) -> Any:
+    """Dispatch *node* through the isolated SQL pipeline and return the result."""
+    return ctx.engine.run_pipeline(SQL_PIPELINE_NAME, node, ctx).dest
+
+
+def render_construct(node: Any, ctx) -> dict:
+    """Render *node*, asserting it produced a fragment."""
+    result = render(node, ctx)
+    if not is_fragment(result):
+        raise ValueError(f"expected a SQL construct, got {node!r}")
+    return result
+
+
+def render_subquery(node: Any, ctx) -> dict:
+    """Render a query construct and wrap it in parentheses."""
+    frag = render_construct(node, ctx)
+    return fragment(f"({frag['sql']})", frag["params"])
+
+
+def render_operand(node: Any, ctx, opts: RenderOptions) -> dict:
+    """Render a value/expression operand.
+
+    * ``str`` → a (possibly dotted, possibly ``*``) column reference.
+    * query construct → a parenthesised scalar subquery.
+    * other construct dict → rendered fragment.
+    * anything else → error (use ``$val`` to bind a data value).
+    """
+    if isinstance(node, str):
+        return fragment(opts.quote_ref(node))
+    if isinstance(node, dict):
+        if is_query(node):
+            return render_subquery(node, ctx)
+        return render_construct(node, ctx)
+    raise TypeError(f"invalid SQL operand: {node!r}; use {{'$val': ...}} for data values")
+
+
+def join_fragments(frags: list[dict], sep: str) -> dict:
+    """Join rendered fragments' SQL with *sep*, concatenating their params."""
+    sql = sep.join(f["sql"] for f in frags)
+    params = [p for f in frags for p in f["params"]]
+    return fragment(sql, params)
+
+
+def render_operands(items: list, ctx, opts: RenderOptions, sep: str = ", ") -> dict:
+    """Render a list of operands and join them with *sep*."""
+    return join_fragments([render_operand(it, ctx, opts) for it in items], sep)
+
+
+def bind_value(value: Any) -> dict:
+    """Bind a concrete Python value as a single placeholder."""
+    return fragment(PLACEHOLDER, [value])

j_perm_sql-0.1.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: j-perm-sql
+Version: 0.1.0
+Summary: j-perm plugin for SQL
+Author-email: Roman <kuschanow@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/kuschanow/j-perm
+Project-URL: Source, https://github.com/kuschanow/j-perm
+Project-URL: Tracker, https://github.com/kuschanow/j-perm/issues
+Project-URL: Documentation, https://github.com/kuschanow/j-perm
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: j-perm>=1.9.0
+
+# j-perm-sql
+
+A [j-perm](https://github.com/kuschanow/j-perm) plugin that builds and executes
+**SQL `SELECT` queries** from j-perm constructs.
+
+* SQL is described with a tree of `$`-constructs (`$select`, `$col`, `$val`,
+  predicates, joins, …).
+* A single new top-level operation — `op: sql` — renders that tree to a
+  **parameterized** `(sql, params)` pair and hands it to a configurable
+  executor (any ORM's raw-execute function).
+* The SQL constructs live in an **isolated** named pipeline: they mean nothing
+  outside `op: sql`. `{"$select": …}` used as an ordinary value is just a dict.
+
+> v1 scope: the full standard **`SELECT`** surface (read-only). DDL/DML
+> (`CREATE`/`ALTER`/`INSERT`/`UPDATE`/`DELETE`) is intentionally out of scope.
+
+## Install
+
+```bash
+pip install j-perm-sql
+```
+
+Requires `j-perm >= 1.9.0` (the version that made `run_pipeline` a passthrough
+invoker, which this plugin relies on).
+
+## Quick start
+
+```python
+from j_perm import build_default_engine
+from j_perm_sql import install_sql
+
+def run_sql(sql, params):
+    # any ORM's raw execute: cursor.execute(sql, params); return rows
+    ...
+
+engine = build_default_engine()
+install_sql(engine, run_sql, paramstyle="qmark")
+
+engine.apply(
+    {"op": "sql", "to": "/rows", "query": {"$select": {
+        "columns": [{"$col": {"name": "id"}}, {"$col": {"name": "name"}}],
+        "from": {"table": "users"},
+        "where": {"$gte": [{"$col": {"name": "age"}}, {"$val": 18}]},
+        "order_by": [{"expr": {"$col": {"name": "name"}}}],
+        "limit": 50,
+    }}},
+    source={}, dest={},
+)
+# run_sql receives:  ('SELECT "id", "name" FROM "users" WHERE "age" >= ? ORDER BY "name" LIMIT 50', [18])
+# result is written to dest at /rows
+```
+
+`install_sql` **patches an existing engine** — it registers the isolated SQL
+pipeline and the `op: sql` operation. It composes with any engine and any other
+plugins.
+
+## The `op: sql` operation
+
+```js
+{"op": "sql", "query": <SQL construct tree>, "to": "/dest/path"}
+```
+
+* `query` — the SQL construct tree.
+* `to` — optional destination pointer (template-expanded); the executor's
+  result is written there. If omitted, the result is discarded.
+
+## Parameterization & injection safety
+
+Data values are **always bound as parameters**, never interpolated:
+
+* `$val` (and the data sides of `$in`, `$between`, `$values`) emit a placeholder
+  and add the value to `params`.
+* Identifiers (table/column/alias names) are validated against a conservative
+  charset and quoted.
+* Function names, CAST types, join types, sort directions, etc. are validated
+  against whitelists.
+
+```python
+{"$eq": [{"$col": {"name": "name"}}, {"$val": {"$ref": "/user_input"}}]}
+# → '"name" = ?'   with the (possibly malicious) value safely in params
+```
+
+Inside `$val`, the value expression is resolved with j-perm's normal value
+pipeline, so `$ref`, `${…}` templates, and `@:` dest-pointers all work.
+
+## Dialect / `RenderOptions`
+
+Everything that genuinely differs between databases is configurable:
+
+```python
+from j_perm_sql import RenderOptions
+
+install_sql(engine, run_sql, dialect=RenderOptions(
+    paramstyle="numeric",      # qmark (?) | format (%s) | numeric ($1) | named (:p1)
+    identifier_quote='"',      # e.g. "`" for MySQL
+    pagination="fetch",        # "limit" (LIMIT n OFFSET m) | "fetch" (OFFSET m ROWS FETCH FIRST n ROWS ONLY)
+    concat_operator="||",      # "||" or "+"
+))
+```
+
+## Sync & async
+
+`install_sql` inspects the executor: a coroutine function registers the async
+handler (use with `engine.apply_async`); a regular function registers the sync
+handler (use with `engine.apply`).
+
+```python
+async def run_sql(sql, params): ...
+install_sql(engine, run_sql)                  # async
+await engine.apply_async(spec, source=…, dest=…)
+```
+
+## Construct reference
+
+**Query**
+
+| Construct | Form |
+|---|---|
+| `$select` | `{with?, distinct?, columns?, from?, joins?, where?, group_by?, having?, order_by?, limit?/offset? \| fetch?}` |
+| `$union` / `$union_all` / `$intersect` / `$except` | `{"$union": [q1, q2, …], order_by?, limit?…}` |
+| `$values` | `{"$values": [[…row…], …]}` (table source or `IN`) |
+
+**Projection / expressions**
+
+| Construct | Renders |
+|---|---|
+| `$col` | `"t"."name" [AS "alias"]`; `"id"`; `*`; `"t".*` |
+| `$val` | a bound parameter |
+| `$func` / `$call` | `NAME([DISTINCT ]args)[ OVER (…)][ AS "alias"]` (use `"*"` for `COUNT(*)`) |
+| `$cast` | `CAST(expr AS TYPE)` |
+| `$case` | searched `CASE WHEN … THEN … [ELSE …] END` |
+| `$concat` | `(a || b …)` |
+| `$add` `$sub` `$mul` `$div` `$mod` | `(a op b …)` |
+
+Projection items may also be `{"expr": <operand>, "as": "alias"}`.
+
+**Predicates** (WHERE / HAVING / ON)
+
+`$and` `$or` `$not` · `$eq` `$ne` `$gt` `$gte` `$lt` `$lte` ·
+`$in`/`$not_in` (list or subquery) · `$between`/`$not_between` ·
+`$like`/`$not_like` (+ `escape`) · `$is_null`/`$is_not_null` ·
+`$exists`/`$not_exists` · `$any`/`$all`/`$some` (quantified).
+
+**FROM / JOIN** — *table source* = a table name (string), a
+`{table, as?, schema?}` dict, a nested `$select`/`$values` (derived table, needs
+`as`), or `lateral: true`. `$join`: `{type, table, as?, on? | using?, natural?}`
+with type `inner`/`left`/`right`/`full`/`cross`.
+
+**Windows** — `over` on `$func`: `{partition_by?, order_by?, frame?}` where
+`frame` is `{type: "rows"|"range", start, end?}` and a bound is
+`"unbounded preceding" | "unbounded following" | "current row" |
+{preceding: n} | {following: n}`.
+
+**GROUP BY** — a list of expressions, or `{"$rollup": […]}` /
+`{"$cube": […]}` / `{"$grouping_sets": [[…], …]}`.
+
+**CTE** — `with`: `[{name, columns?, recursive?, query: $select}]`.
+
+See `tests/` for end-to-end examples.
+
+## Portability caveats
+
+The DSL renders standard SQL and does **not** validate that a target database
+supports every feature — portability is the query author's responsibility:
+
+* `LIMIT/OFFSET` vs `OFFSET/FETCH`, `RIGHT/FULL JOIN`, `INTERSECT/EXCEPT`,
+  `NATURAL JOIN`, `NULLS FIRST/LAST`, `LATERAL`, `GROUPING SETS/ROLLUP/CUBE`,
+  and the concatenation operator (`||` vs `+`) are not universal.
+* CTEs and window functions are standard but require recent versions
+  (e.g. MySQL ≥ 8, SQLite ≥ 3.25 for windows / ≥ 3.8.3 for CTEs).
+
+Use `RenderOptions` to match the target dialect's placeholder style, identifier
+quoting, pagination form, and concatenation operator.
+
+## License
+
+MIT

j_perm_sql-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+j_perm_sql/__init__.py,sha256=I1crEuewdx0qeKD3PSBroaF1mgmCvqDU3m1_mO-duq8,1597
+j_perm_sql/constructs.py,sha256=qcJ77Dn3wYPhTO5na1SyCoRVZZlE9J0ymxyBff9CQkE,23996
+j_perm_sql/dialect.py,sha256=a-YtIQbUVeZ2Q5uSywVYOP1IVh7dEPTEEZVQCmTyb4I,4922
+j_perm_sql/handler.py,sha256=NvRg4RST2LH9aLYHZgZOkZ0uTi-gtPiNwmYxZ-edMxM,2830
+j_perm_sql/install.py,sha256=pXpXRnv2WobBm0YWhX7UAb5KijniY5rSENK23BvVSB4,1899
+j_perm_sql/pipeline.py,sha256=G5ymliR8CdQpYBbuJDhf3nDWIRHIncEX44JpGLW382c,1429
+j_perm_sql/render.py,sha256=GfwgQXRuhZmrW3UwzAdS-xsit-rvIPb83ZYYSP0grJA,3586
+j_perm_sql-0.1.0.dist-info/METADATA,sha256=H3V3VY23T5_HH6RcKEiLG4PcEvb9Co15SxGr4doF_vA,6887
+j_perm_sql-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+j_perm_sql-0.1.0.dist-info/top_level.txt,sha256=kO4wcHOQQ9US4Kqf_eZlZP4yrTPfc7bQO0zistK00Fg,11
+j_perm_sql-0.1.0.dist-info/RECORD,,

j_perm_sql-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

j_perm_sql-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+j_perm_sql