Make FunctionInfo fields conditional on function type

- stability/null_handling: only set for scalar functions (None for table)
- projection_pushdown/filter_pushdown/order_preservation: only set for
  table functions (None for scalar)

Updated dataclass fields, ARROW_SCHEMA, serialize/deserialize methods,
_function_to_info(), CLI output, and tests to reflect this behavior.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rustyconover

tests/catalog/test_catalog_interface.py

@@ -441,10 +441,7 @@ def test_default_values(self) -> None:
         from vgi.catalog import FunctionType
         from vgi.catalog.catalog_interface import (
             DistinctDependence,
-            FunctionStability,
-            NullHandling,
             OrderDependence,
-            OrderPreservation,
         )
 
         schema_bytes = self._get_empty_schema_bytes()
@@ -458,18 +455,18 @@ def test_default_values(self) -> None:
             tags={},
         )
 
-        # Behavior fields
-        assert info.stability == FunctionStability.CONSISTENT
-        assert info.null_handling == NullHandling.DEFAULT
+        # Scalar behavior fields default to None (set by _function_to_info)
+        assert info.stability is None
+        assert info.null_handling is None
 
         # Documentation fields
         assert info.examples == []
         assert info.categories == []
 
-        # Table function capabilities
-        assert info.projection_pushdown is True
-        assert info.filter_pushdown is False
-        assert info.order_preservation == OrderPreservation.PRESERVES_ORDER
+        # Table function capabilities default to None (set by _function_to_info)
+        assert info.projection_pushdown is None
+        assert info.filter_pushdown is None
+        assert info.order_preservation is None
         assert info.max_workers is None
 
         # Aggregate function fields
@@ -598,10 +595,7 @@ def test_backward_compatibility_without_new_fields(self) -> None:
         from vgi.catalog import FunctionInfo, FunctionType
         from vgi.catalog.catalog_interface import (
             DistinctDependence,
-            FunctionStability,
-            NullHandling,
             OrderDependence,
-            OrderPreservation,
         )
 
         # Create legacy schema without new fields
@@ -645,14 +639,14 @@ def test_backward_compatibility_without_new_fields(self) -> None:
         assert restored.comment == "A legacy function"
         assert restored.tags == {"version": "1.0"}
 
-        # New fields should have defaults
-        assert restored.stability == FunctionStability.CONSISTENT
-        assert restored.null_handling == NullHandling.DEFAULT
+        # Optional fields should be None when not in legacy data
+        assert restored.stability is None
+        assert restored.null_handling is None
         assert restored.examples == []
         assert restored.categories == []
-        assert restored.projection_pushdown is True
-        assert restored.filter_pushdown is False
-        assert restored.order_preservation == OrderPreservation.PRESERVES_ORDER
+        assert restored.projection_pushdown is None
+        assert restored.filter_pushdown is None
+        assert restored.order_preservation is None
         assert restored.max_workers is None
         assert restored.order_dependent == OrderDependence.NOT_ORDER_DEPENDENT
         assert restored.distinct_dependent == DistinctDependence.NOT_DISTINCT_DEPENDENT

vgi/catalog/catalog_interface.py

@@ -347,18 +347,18 @@ class FunctionInfo(CatalogSchemaObject):
     # schema.serialize().to_pybytes()
     output_schema: SerializedSchema
 
-    # Behavior fields
-    stability: FunctionStability = FunctionStability.CONSISTENT
-    null_handling: NullHandling = NullHandling.DEFAULT
+    # Scalar function behavior fields (None for non-scalar functions)
+    stability: FunctionStability | None = None
+    null_handling: NullHandling | None = None
 
     # Documentation fields
     examples: list[str] = field(default_factory=list)
     categories: list[str] = field(default_factory=list)
 
-    # Table function capabilities
-    projection_pushdown: bool = True
-    filter_pushdown: bool = False
-    order_preservation: OrderPreservation = OrderPreservation.PRESERVES_ORDER
+    # Table function capabilities (None for scalar functions)
+    projection_pushdown: bool | None = None
+    filter_pushdown: bool | None = None
+    order_preservation: OrderPreservation | None = None
     max_workers: int | None = None
 
     # Aggregate function fields (future)
@@ -377,16 +377,16 @@ class FunctionInfo(CatalogSchemaObject):
             pa.field("output_schema", pa.binary(), nullable=False),
             pa.field("comment", pa.string(), nullable=True),
             pa.field("tags", pa.map_(pa.string(), pa.string()), nullable=False),
-            # Behavior fields (enum values serialized as strings)
-            pa.field("stability", pa.string(), nullable=False),
-            pa.field("null_handling", pa.string(), nullable=False),
+            # Scalar function behavior fields (nullable for non-scalar functions)
+            pa.field("stability", pa.string(), nullable=True),
+            pa.field("null_handling", pa.string(), nullable=True),
             # Documentation fields
             pa.field("examples", pa.list_(pa.string()), nullable=False),
             pa.field("categories", pa.list_(pa.string()), nullable=False),
-            # Table function capabilities
-            pa.field("projection_pushdown", pa.bool_(), nullable=False),
-            pa.field("filter_pushdown", pa.bool_(), nullable=False),
-            pa.field("order_preservation", pa.string(), nullable=False),
+            # Table function capabilities (nullable for scalar functions)
+            pa.field("projection_pushdown", pa.bool_(), nullable=True),
+            pa.field("filter_pushdown", pa.bool_(), nullable=True),
+            pa.field("order_preservation", pa.string(), nullable=True),
             pa.field("max_workers", pa.int32(), nullable=True),
             # Aggregate function fields
             pa.field("order_dependent", pa.string(), nullable=False),
@@ -408,16 +408,22 @@ def serialize(self) -> bytes:
                     "output_schema": self.output_schema,
                     "comment": self.comment,
                     "tags": self.tags,
-                    # Behavior fields (enums serialized as name strings)
-                    "stability": self.stability.name,
-                    "null_handling": self.null_handling.name,
+                    # Scalar function behavior fields (None for non-scalar)
+                    "stability": self.stability.name if self.stability else None,
+                    "null_handling": (
+                        self.null_handling.name if self.null_handling else None
+                    ),
                     # Documentation fields
                     "examples": self.examples,
                     "categories": self.categories,
-                    # Table function capabilities
+                    # Table function capabilities (None for scalar)
                     "projection_pushdown": self.projection_pushdown,
                     "filter_pushdown": self.filter_pushdown,
-                    "order_preservation": self.order_preservation.name,
+                    "order_preservation": (
+                        self.order_preservation.name
+                        if self.order_preservation
+                        else None
+                    ),
                     "max_workers": self.max_workers,
                     # Aggregate function fields
                     "order_dependent": self.order_dependent.name,
@@ -457,18 +463,28 @@ def deserialize(cls, batch: pa.RecordBatch) -> Self:
             output_schema=SerializedSchema(row["output_schema"]),
             comment=row.get("comment"),
             tags=dict(row["tags"]) if row["tags"] else {},
-            # Behavior fields (with backward-compatible defaults)
-            stability=FunctionStability[row.get("stability", "CONSISTENT")],
-            null_handling=NullHandling[row.get("null_handling", "DEFAULT")],
+            # Scalar function behavior fields (None for non-scalar functions)
+            stability=(
+                FunctionStability[row["stability"]]
+                if row.get("stability") is not None
+                else None
+            ),
+            null_handling=(
+                NullHandling[row["null_handling"]]
+                if row.get("null_handling") is not None
+                else None
+            ),
             # Documentation fields
             examples=list(row.get("examples") or []),
             categories=list(row.get("categories") or []),
-            # Table function capabilities
-            projection_pushdown=row.get("projection_pushdown", True),
-            filter_pushdown=row.get("filter_pushdown", False),
-            order_preservation=OrderPreservation[
-                row.get("order_preservation", "PRESERVES_ORDER")
-            ],
+            # Table function capabilities (None for scalar functions)
+            projection_pushdown=row.get("projection_pushdown"),
+            filter_pushdown=row.get("filter_pushdown"),
+            order_preservation=(
+                OrderPreservation[row["order_preservation"]]
+                if row.get("order_preservation") is not None
+                else None
+            ),
             max_workers=row.get("max_workers"),
             # Aggregate function fields
             order_dependent=OrderDependence[
@@ -1149,6 +1165,8 @@ def _function_to_info(self, func_cls: type, schema_name: str) -> FunctionInfo:
             output_schema = func_cls.catalog_output_schema()  # type: ignore[attr-defined]
         output_bytes = SerializedSchema(output_schema.serialize().to_pybytes())
 
+        is_scalar = func_type == FunctionType.SCALAR
+
         return FunctionInfo(
             name=meta.name,
             schema_name=schema_name,
@@ -1157,17 +1175,17 @@ def _function_to_info(self, func_cls: type, schema_name: str) -> FunctionInfo:
             output_schema=output_bytes,
             comment=meta.description or None,
             tags={},
-            # Behavior fields
-            stability=meta.stability,
-            null_handling=meta.null_handling,
+            # Scalar function behavior fields (None for non-scalar)
+            stability=meta.stability if is_scalar else None,
+            null_handling=meta.null_handling if is_scalar else None,
             # Documentation fields
             examples=[ex.sql for ex in meta.examples],
             categories=meta.categories,
-            # Table function capabilities
-            projection_pushdown=meta.projection_pushdown,
-            filter_pushdown=meta.filter_pushdown,
-            order_preservation=meta.preserves_order,
-            max_workers=meta.max_workers,
+            # Table function capabilities (None for scalar)
+            projection_pushdown=None if is_scalar else meta.projection_pushdown,
+            filter_pushdown=None if is_scalar else meta.filter_pushdown,
+            order_preservation=None if is_scalar else meta.preserves_order,
+            max_workers=None if is_scalar else meta.max_workers,
             # Aggregate function fields
             order_dependent=meta.order_dependent,
             distinct_dependent=meta.distinct_dependent,

vgi/client/cli_utils.py

@@ -299,16 +299,24 @@ def function_info_to_dict(function_info: Any) -> dict[str, Any]:
         "arguments": arrow_schema_to_json(function_info.arguments),
         "comment": function_info.comment,
         "tags": function_info.tags,
-        # Behavior fields
-        "stability": function_info.stability.name,
-        "null_handling": function_info.null_handling.name,
+        # Scalar function behavior fields (None for non-scalar)
+        "stability": (
+            function_info.stability.name if function_info.stability else None
+        ),
+        "null_handling": (
+            function_info.null_handling.name if function_info.null_handling else None
+        ),
         # Documentation fields
         "examples": function_info.examples,
         "categories": function_info.categories,
-        # Table function capabilities
+        # Table function capabilities (None for scalar)
         "projection_pushdown": function_info.projection_pushdown,
         "filter_pushdown": function_info.filter_pushdown,
-        "order_preservation": function_info.order_preservation.name,
+        "order_preservation": (
+            function_info.order_preservation.name
+            if function_info.order_preservation
+            else None
+        ),
         "max_workers": function_info.max_workers,
         # Aggregate function fields
         "order_dependent": function_info.order_dependent.name,