j-perm-sql 0.3.0__tar.gz → 0.4.0__tar.gz

{j_perm_sql-0.3.0 → j_perm_sql-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: j-perm-sql
-Version: 0.3.0
+Version: 0.4.0
 Summary: j-perm plugin for SQL
 Author-email: Roman <kuschanow@gmail.com>
 License: MIT
@@ -10,7 +10,7 @@ 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.10.0
+Requires-Dist: j-perm>=1.11.0
 
 # j-perm-sql
 

{j_perm_sql-0.3.0 → j_perm_sql-0.4.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "j-perm-sql"
-version = "0.3.0"
+version = "0.4.0"
 description = "j-perm plugin for SQL"
 authors = [
     { name = "Roman", email = "kuschanow@gmail.com" },
@@ -18,7 +18,7 @@ requires-python = ">=3.10"
 license = { text = "MIT" }
 
 dependencies = [
-    "j-perm>=1.10.0",
+    "j-perm>=1.11.0",
 ]
 
 [tool.pytest.ini_options]

{j_perm_sql-0.3.0 → j_perm_sql-0.4.0}/src/j_perm_sql/constructs.py

@@ -23,6 +23,7 @@ from .render import (
     render_operand,
     render_operands,
     render_subquery,
+    resolve_value,
 )
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -74,7 +75,7 @@ def col(node, ctx, *, opts: RenderOptions) -> dict:
 
 
 def val(node, ctx, *, opts: RenderOptions) -> dict:
-    value = ctx.engine.process_value(node["$val"], ctx)
+    value = resolve_value(node["$val"], ctx)
     return fragment(PLACEHOLDER, [value])
 
 
@@ -219,7 +220,7 @@ def _in(node, ctx, *, opts: RenderOptions, negate: bool) -> dict:
     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)
+    values = resolve_value(right, ctx)
     if not isinstance(values, (list, tuple)):
         values = [values]
     if not values:
@@ -529,7 +530,7 @@ def values(node, ctx, *, opts: RenderOptions) -> dict:
             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))
+            params.append(resolve_value(cell, ctx))
     return fragment("VALUES " + ", ".join(rendered_rows), params)
 
 

{j_perm_sql-0.3.0 → j_perm_sql-0.4.0}/src/j_perm_sql/handler.py

@@ -22,8 +22,10 @@ from j_perm.core import Compound
 from .dialect import RenderOptions
 from .render import (
     ACTIVE_PIPELINE_KEY,
+    ASYNC_VALUE_CACHE_KEY,
     COMPILE_CACHE_KEY,
     SQL_PIPELINE_NAME,
+    _NeedAsyncValue,
     is_fragment,
 )
 
@@ -86,6 +88,43 @@ class SqlRenderer:
         ctx.engine.get_pipeline(self.pipeline_name).run_compiled(compiled_query, render_ctx)
         return self._finalize(render_ctx.dest)
 
+    async def render_async(self, query, ctx) -> tuple:
+        """Async twin of :meth:`render`.
+
+        Renders synchronously, but each embedded engine value (``$val`` etc.) is
+        resolved via ``process_value_async``: an unresolved value raises
+        :class:`~j_perm_sql.render._NeedAsyncValue`, we ``await`` it, cache it by
+        ``id(node)``, and restart the render.  After *k* distinct value nodes the
+        render runs ``k+1`` times (cheap — pure string building over a scratch
+        dest), and never resolves values through the (async) value pipeline
+        synchronously.
+        """
+        cache: dict = {}
+        while True:
+            render_ctx = self._render_ctx(ctx, {ASYNC_VALUE_CACHE_KEY: cache})
+            try:
+                frag = ctx.engine.run_pipeline(self.pipeline_name, query, render_ctx).dest
+                return self._finalize(frag)
+            except _NeedAsyncValue as exc:
+                cache[id(exc.node)] = await ctx.engine.process_value_async(exc.node, render_ctx)
+
+    async def render_compiled_async(self, compiled_query, ctx) -> tuple:
+        """Async twin of :meth:`render_compiled` (same restart protocol)."""
+        node_cache = getattr(compiled_query, _NODE_CACHE_ATTR, None)
+        if node_cache is None:
+            node_cache = {}
+            setattr(compiled_query, _NODE_CACHE_ATTR, node_cache)
+        value_cache: dict = {}
+        pipeline = ctx.engine.get_pipeline(self.pipeline_name)
+        while True:
+            render_ctx = self._render_ctx(
+                ctx, {COMPILE_CACHE_KEY: node_cache, ASYNC_VALUE_CACHE_KEY: value_cache})
+            try:
+                pipeline.run_compiled(compiled_query, render_ctx)
+                return self._finalize(render_ctx.dest)
+            except _NeedAsyncValue as exc:
+                value_cache[id(exc.node)] = await ctx.engine.process_value_async(exc.node, render_ctx)
+
 
 class _SqlCompound(Compound):
     """Mixin marking the ``op: sql`` handlers as compilable.
@@ -111,6 +150,13 @@ def _write_result(step, ctx, result):
     return ctx.dest
 
 
+async def _write_result_async(step, ctx, result):
+    if "to" in step:
+        path = await ctx.engine.process_value_async(step["to"], ctx)
+        ctx.engine.processor.set(path, ctx, result)
+    return ctx.dest
+
+
 class SqlHandler(ActionHandler, _SqlCompound):
     """``op: sql`` with a synchronous executor ``executor(sql, params) -> result``."""
 
@@ -137,11 +183,11 @@ class AsyncSqlHandler(AsyncActionHandler, _SqlCompound):
         self._renderer = renderer
 
     async def execute(self, step, ctx):
-        sql, params = self._renderer.render(step["query"], ctx)
+        sql, params = await self._renderer.render_async(step["query"], ctx)
         result = await self._executor(sql, params)
-        return _write_result(step, ctx, result)
+        return await _write_result_async(step, ctx, result)
 
     async def execute_compiled(self, step, ctx, nested):
-        sql, params = self._renderer.render_compiled(nested["query"], ctx)
+        sql, params = await self._renderer.render_compiled_async(nested["query"], ctx)
         result = await self._executor(sql, params)
-        return _write_result(step, ctx, result)
+        return await _write_result_async(step, ctx, result)

{j_perm_sql-0.3.0 → j_perm_sql-0.4.0}/src/j_perm_sql/render.py

@@ -17,11 +17,19 @@ from __future__ import annotations
 
 from typing import Any
 
+from j_perm.handlers.signals import ControlFlowSignal
+
 from .dialect import PLACEHOLDER, RenderOptions
 
 #: Name the read-only SQL value-pipeline is registered under on the engine.
 SQL_PIPELINE_NAME = "sql"
 
+#: Metadata key carrying the async value cache (``{id(node): resolved}``) on the
+#: *async* render path.  Its presence is what switches :func:`resolve_value` from
+#: resolving inline (sync) to the resolve-on-demand-with-restart protocol used by
+#: :meth:`j_perm_sql.handler.SqlRenderer.render_async`.
+ASYNC_VALUE_CACHE_KEY = "_sql_async_value_cache"
+
 #: Metadata key carrying the name of the pipeline that recursion should dispatch
 #: through.  Set by :class:`~j_perm_sql.handler.SqlRenderer` so a write
 #: statement's sub-parts resolve in the write pipeline; defaults to the read
@@ -41,6 +49,37 @@ _QUERY_KEYS = frozenset(
 )
 
 
+class _NeedAsyncValue(ControlFlowSignal):
+    """Raised mid-render to ask the async driver to resolve a value node.
+
+    Subclasses :class:`~j_perm.handlers.signals.ControlFlowSignal` so it
+    propagates straight up through the (synchronous) SQL pipeline without being
+    annotated or logged, and is caught only by
+    :meth:`j_perm_sql.handler.SqlRenderer.render_async`.
+    """
+
+    def __init__(self, node: Any) -> None:
+        self.node = node
+
+
+def resolve_value(node: Any, ctx) -> Any:
+    """Resolve an embedded engine value (``$val`` / ``$in`` / ``$values`` cell).
+
+    * Sync render (no async cache in metadata) → resolve inline via
+      ``process_value``.
+    * Async render → consult the per-render cache keyed by ``id(node)``; on a
+      miss, raise :class:`_NeedAsyncValue` so the async driver can
+      ``await process_value_async`` and restart the render with the value cached.
+    """
+    cache = ctx.metadata.get(ASYNC_VALUE_CACHE_KEY)
+    if cache is None:
+        return ctx.engine.process_value(node, ctx)
+    key = id(node)
+    if key in cache:
+        return cache[key]
+    raise _NeedAsyncValue(node)
+
+
 def fragment(sql: str, params: list | None = None) -> dict:
     """Build a SQL fragment dict."""
     return {"sql": sql, "params": list(params) if params else []}

{j_perm_sql-0.3.0 → j_perm_sql-0.4.0}/src/j_perm_sql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: j-perm-sql
-Version: 0.3.0
+Version: 0.4.0
 Summary: j-perm plugin for SQL
 Author-email: Roman <kuschanow@gmail.com>
 License: MIT
@@ -10,7 +10,7 @@ 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.10.0
+Requires-Dist: j-perm>=1.11.0
 
 # j-perm-sql
 

j_perm_sql-0.4.0/src/j_perm_sql.egg-info/requires.txt

@@ -0,0 +1 @@
+j-perm>=1.11.0

j_perm_sql-0.3.0/src/j_perm_sql.egg-info/requires.txt

@@ -1 +0,0 @@
-j-perm>=1.10.0