vgi-python 0.16.0__tar.gz → 0.16.1__tar.gz

{vgi_python-0.16.0 → vgi_python-0.16.1}/.github/workflows/integration.yml

@@ -32,7 +32,7 @@ env:
   VGI_REF: main
   # The Haybarn release providing the prebuilt haybarn-unittest binary. Must be
   # ABI-compatible with the community-published vgi extension.
-  HAYBARN_RELEASE: haybarn-v1.5.4-rc1
+  HAYBARN_RELEASE: haybarn-v1.5.4-rc3
 
 jobs:
   integration:

{vgi_python-0.16.0 → vgi_python-0.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vgi-python
-Version: 0.16.0
+Version: 0.16.1
 Summary: Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow
 Project-URL: Homepage, https://query.farm
 Project-URL: Repository, https://github.com/Query-farm/vgi-python

{vgi_python-0.16.0 → vgi_python-0.16.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.16.0"
+version = "0.16.1"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [

{vgi_python-0.16.0 → vgi_python-0.16.1}/tests/landing/describe.expected.json

@@ -3,7 +3,7 @@
     {
       "attach_options": [],
       "counts": {
-        "functions": 188,
+        "functions": 203,
         "schemas": 2,
         "tables": 59,
         "views": 3
@@ -655,6 +655,50 @@
               "returns": "binary",
               "type": "scalar"
             },
+            {
+              "args": [
+                {
+                  "desc": "Value",
+                  "name": "value",
+                  "type": "int64"
+                },
+                {
+                  "desc": "Constant addend",
+                  "name": "addend",
+                  "type": "int64"
+                }
+              ],
+              "doc": "value + const addend (advertises vgi.cache.ttl)",
+              "name": "cached_add_const",
+              "returns": "int64",
+              "type": "scalar"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Value to double",
+                  "name": "value",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Doubles a BIGINT value (advertises vgi.cache.ttl for per-value memo)",
+              "name": "cached_double_scalar",
+              "returns": "int64",
+              "type": "scalar"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Value",
+                  "name": "value",
+                  "type": "int64"
+                }
+              ],
+              "doc": "value -> 'lbl-<value>' or NULL for negatives (advertises vgi.cache.ttl)",
+              "name": "cached_label",
+              "returns": "string",
+              "type": "scalar"
+            },
             {
               "args": [
                 {
@@ -1259,6 +1303,18 @@
               "name": "blended_drop",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Fan-out count: emit rows 0..n-1 for this input row",
+                  "name": "n",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Blended 1->N fan-out (emit 0..n-1 per input row) with row provenance",
+              "name": "blended_explode",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -1468,6 +1524,54 @@
               "name": "cache_parallel",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Rows per (region, year) partition",
+                  "name": "rows_per_partition",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable over (region, year) SINGLE_VALUE partition columns",
+              "name": "cache_partition_multicol",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Rows per country partition",
+                  "name": "rows_per_country",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable; work-queue fan-out (parallel capture); one NULL partition",
+              "name": "cache_partition_parallel",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Rows per country partition",
+                  "name": "rows_per_country",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable with projection pushdown + explicit partition_values",
+              "name": "cache_partition_proj",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Rows per country partition",
+                  "name": "rows_per_country",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable single-value-partitioned result (vgi.cache.partition_scope)",
+              "name": "cache_partition_scope",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -1563,6 +1667,42 @@
               "name": "cacheable_numbers",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Input column",
+                  "name": "x",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Cacheable blended map x -> x*2 (advertises vgi.cache.ttl)",
+              "name": "cached_double",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Cacheable classic (TABLE-input) passthrough (advertises vgi.cache.ttl)",
+              "name": "cached_echo",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Input column",
+                  "name": "x",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Blended map x->x*2 with always-revalidate (304 not_modified) contract",
+              "name": "cached_reval_double",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Classic passthrough with always-revalidate (304 not_modified) contract",
+              "name": "cached_reval_echo",
+              "type": "table"
+            },
             {
               "args": [],
               "doc": "Scan colors table (ENUM column)",
@@ -1885,6 +2025,25 @@
               "name": "geo_encode",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Input column (echoed as output)",
+                  "name": "x",
+                  "type": "int64"
+                },
+                {
+                  "default": "\"range\"",
+                  "desc": "range | length | base64",
+                  "name": "mode",
+                  "named": true,
+                  "type": "string"
+                }
+              ],
+              "doc": "Adversarial blended fixture emitting malformed vgi_rpc.parent_row",
+              "name": "hostile_provenance",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -2302,6 +2461,18 @@
               "name": "profiling_demo",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Input column",
+                  "name": "x",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Blended 1->1 map with projection_pushdown + two output columns",
+              "name": "projectable_blended",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -2815,6 +2986,20 @@
               "name": "buffer_input",
               "type": "table_in_out"
             },
+            {
+              "args": [
+                {
+                  "default": "false",
+                  "desc": "Whether to log during processing",
+                  "name": "logging",
+                  "named": true,
+                  "type": "bool"
+                }
+              ],
+              "doc": "Cacheable column-wise sum across all input (advertises vgi.cache.ttl)",
+              "name": "cached_sum_all",
+              "type": "table_in_out"
+            },
             {
               "args": [],
               "doc": "Worker raises during combine (test)",

{vgi_python-0.16.0 → vgi_python-0.16.1}/tests/test_filter_pushdown.py

@@ -1404,3 +1404,88 @@ class TestJoinKeysBatch:
         assert merged.num_columns == 2
         assert merged.column("a").to_pylist() == [1, 2, 3]
         assert merged.column("b").to_pylist() == [10, 20, 30]
+
+
+# =============================================================================
+# TestDegenerateConjunctions
+# =============================================================================
+
+
+class TestDegenerateConjunctions:
+    """An AND whose children all degrade must not render as `WHERE ()`.
+
+    `_parse_filter` returns None for a join-key filter whose keys column cannot
+    be resolved ("graceful degradation — DuckDB filters client-side"). Dropping
+    such a child from an AND is safe on its own, but when *every* child drops the
+    conjunction is left empty, and `f"({' AND '.join([])})"` yields `()` — which
+    reaches the backend as the syntactically invalid `... WHERE () LIMIT n`.
+    """
+
+    def _and_of_join_keys_batch(self) -> pa.RecordBatch:
+        """A filter spec of one AND whose only children are join-key filters.
+
+        No `join_keys` batches are supplied to `deserialize_filters`, so every
+        child resolves to None — the shape observed in production.
+        """
+        spec = json.dumps(
+            [
+                {
+                    "column_name": "trade_canceled",
+                    "column_index": 0,
+                    "type": "and",
+                    "children": [
+                        {
+                            "column_name": "trade_canceled",
+                            "column_index": 0,
+                            "type": "join_keys",
+                            "keys_column": "missing_keys_a",
+                        },
+                        {
+                            "column_name": "_partition_date",
+                            "column_index": 1,
+                            "type": "join_keys",
+                            "keys_column": "missing_keys_b",
+                        },
+                    ],
+                }
+            ]
+        )
+        s = pa.schema([pa.field("filter_spec", pa.string(), metadata={b"vgi_filter_version": b"1"})])
+        return pa.RecordBatch.from_pydict({"filter_spec": [spec]}, schema=s)
+
+    def test_and_with_all_children_dropped_yields_no_filter(self) -> None:
+        """All conjuncts unresolvable -> the AND is dropped entirely, not emptied."""
+        pf = deserialize_filters(self._and_of_join_keys_batch())
+        assert len(pf) == 0
+        assert pf.to_sql() == ("", [])
+
+    def test_and_with_all_children_dropped_never_emits_empty_parens(self) -> None:
+        """Regression: the rendered clause must never be the invalid `()`."""
+        where, params = deserialize_filters(self._and_of_join_keys_batch()).to_sql()
+        assert where != "()"
+        assert not params
+        # A caller appending `WHERE {where}` only when truthy must produce no WHERE.
+        assert not where
+
+    def test_empty_and_renders_as_true(self) -> None:
+        """An empty conjunction is AND's identity: it constrains nothing."""
+        f = AndFilter(column_name="c", column_index=0, children=())
+        assert _filter_to_sql(f, lambda s: f'"{s}"', "?", 0) == ("TRUE", [])
+        assert _filters(f).to_sql() == ("TRUE", [])
+
+    def test_empty_or_renders_as_false(self) -> None:
+        """An empty disjunction admits nothing — it must not widen the result set."""
+        f = OrFilter(column_name="c", column_index=0, children=())
+        assert _filter_to_sql(f, lambda s: f'"{s}"', "?", 0) == ("FALSE", [])
+        assert _filters(f).to_sql() == ("FALSE", [])
+
+    def test_and_keeps_resolvable_children(self) -> None:
+        """Partial degradation still yields a usable (weaker) conjunction."""
+        f = AndFilter(
+            column_name="c",
+            column_index=0,
+            children=(_eq("a", 0, 1), _eq("b", 1, 2)),
+        )
+        where, params = _filters(f).to_sql()
+        assert where == '("a" = ? AND "b" = ?)'
+        assert params == [1, 2]

{vgi_python-0.16.0 → vgi_python-0.16.1}/uv.lock

@@ -2228,7 +2228,7 @@ requires-dist = [
 
 [[package]]
 name = "vgi-python"
-version = "0.16.0"
+version = "0.16.1"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

{vgi_python-0.16.0 → vgi_python-0.16.1}/vgi/_test_fixtures/scalar/__init__.py

@@ -19,6 +19,9 @@ unchanged.
 
 from vgi._test_fixtures.scalar.arithmetic import (
     AddValuesFunction,
+    CachedAddConstScalarFunction,
+    CachedDoubleScalarFunction,
+    CachedLabelScalarFunction,
     ConcatValuesIntFunction,
     ConcatValuesStrFunction,
     DoubleFunction,
@@ -83,6 +86,9 @@ __all__ = [
     "AnyMixedStrFunction",
     "BernoulliFunction",
     "BinaryPacketFunction",
+    "CachedAddConstScalarFunction",
+    "CachedDoubleScalarFunction",
+    "CachedLabelScalarFunction",
     "ConcatValuesIntFunction",
     "ConcatValuesStrFunction",
     "ConditionalMessageFunction",

{vgi_python-0.16.0 → vgi_python-0.16.1}/vgi/_test_fixtures/scalar/arithmetic.py

@@ -11,6 +11,7 @@ import pyarrow.compute as pc
 
 from vgi._test_fixtures.scalar._common import _is_addable_type, _is_multipliable_type, _promote_for_addition
 from vgi.arguments import ConstParam, Param, Returns
+from vgi.cache_control import CacheControl
 from vgi.metadata import FunctionExample
 from vgi.scalar_function import BindParameters, BindResult, ScalarFunction
 
@@ -131,6 +132,82 @@ class DoubleFunction(ScalarFunction):
         return result
 
 
+class CachedDoubleScalarFunction(ScalarFunction):
+    """Doubles a BIGINT value and advertises vgi.cache.* — backs scalar per-value memo tests.
+
+    A deterministic 1:1 map, so opting into the result cache is sound: the extension
+    memoizes the output per distinct input value and serves a fully-warm distinct set
+    without the worker.
+    """
+
+    # Opt into the result cache (per-value memoization on the C++ side).
+    CACHE_CONTROL = CacheControl(ttl=300)
+
+    class Meta:
+        """Function metadata."""
+
+        name = "cached_double_scalar"
+        description = "Doubles a BIGINT value (advertises vgi.cache.ttl for per-value memo)"
+
+    @classmethod
+    def compute(
+        cls,
+        value: Annotated[pa.Int64Array, Param(doc="Value to double")],
+    ) -> Annotated[pa.Int64Array, Returns(pa.int64())]:
+        """Double the input values."""
+        return pc.multiply(value, 2)
+
+
+class CachedAddConstScalarFunction(ScalarFunction):
+    """value + addend (a CONST param), cacheable — backs per-value const-param keying tests.
+
+    Two calls with the same ``value`` but different ``addend`` must NOT cross-serve: the
+    const arg is folded into the cache key.
+    """
+
+    CACHE_CONTROL = CacheControl(ttl=300)
+
+    class Meta:
+        """Function metadata."""
+
+        name = "cached_add_const"
+        description = "value + const addend (advertises vgi.cache.ttl)"
+
+    @classmethod
+    def compute(
+        cls,
+        value: Annotated[pa.Int64Array, Param(doc="Value")],
+        addend: Annotated[pa.Int64Scalar, ConstParam("Constant addend")],
+    ) -> Annotated[pa.Int64Array, Returns(pa.int64())]:
+        """Add the const addend to each value."""
+        return pc.add(value, addend)
+
+
+class CachedLabelScalarFunction(ScalarFunction):
+    """VARCHAR output with NULLs, cacheable — exercises string/null round-trip through the cache.
+
+    Returns ``lbl-<value>`` for value >= 0, NULL otherwise, so a cached per-value entry must
+    round-trip both a heap string and a null.
+    """
+
+    CACHE_CONTROL = CacheControl(ttl=300)
+
+    class Meta:
+        """Function metadata."""
+
+        name = "cached_label"
+        description = "value -> 'lbl-<value>' or NULL for negatives (advertises vgi.cache.ttl)"
+
+    @classmethod
+    def compute(
+        cls,
+        value: Annotated[pa.Int64Array, Param(doc="Value")],
+    ) -> Annotated[pa.StringArray, Returns(pa.string())]:
+        """Label non-negative values; NULL for negatives."""
+        labels = ["lbl-" + str(v.as_py()) if (v.is_valid and v.as_py() >= 0) else None for v in value]
+        return pa.array(labels, type=pa.string())
+
+
 class AddValuesFunction(ScalarFunction):
     """Adds two numeric values together.
 

{vgi_python-0.16.0 → vgi_python-0.16.1}/vgi/_test_fixtures/table/__init__.py

@@ -44,6 +44,10 @@ from vgi._test_fixtures.table.cache import (
     CacheOrderedFunction,
     CacheParallelFunction,
     CachePartitionedFunction,
+    CachePartitionMultiColFunction,
+    CachePartitionParallelFunction,
+    CachePartitionProjFunction,
+    CachePartitionScopeFunction,
     CachePoisonFunction,
     CacheProjectionFunction,
     CacheRevalidatableFunction,
@@ -182,6 +186,10 @@ __all__ = [
     "CacheOrderedFunction",
     "CacheParallelFunction",
     "CachePartitionedFunction",
+    "CachePartitionScopeFunction",
+    "CachePartitionParallelFunction",
+    "CachePartitionMultiColFunction",
+    "CachePartitionProjFunction",
     "CachePoisonFunction",
     "CacheProjectionFunction",
     "CacheTypesFunction",