Add scalar function overloading, type casting, and review fixes

- Add function overloading by ConstParam count for scalar functions
- Add format_number and make_series overloaded example functions
- Add type casting with debug logging in _validate_single_param_type
- Extract shared _make_series_emit helper to deduplicate process() methods
- Remove dead TopN table-in-out code (never registered, DuckDB unsupported)
- Update catalog interface to support multiple functions per name

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

Author: rustyconover

tests/test_worker.py

@@ -8,9 +8,10 @@
 from vgi_rpc.rpc import OutputCollector
 
 from vgi import Arg, TableInOutFunction, TableInput
-from vgi.arguments import Arguments
+from vgi.arguments import Arguments, ConstParam, Param, Returns
 from vgi.invocation import FunctionType
 from vgi.protocol import BindRequest, TableFunctionCardinalityRequest
+from vgi.scalar_function import ScalarFunction
 from vgi.table_function import (
     BindParams,
     ProcessParams,
@@ -589,3 +590,104 @@ class MyWorker(Worker):
         )
         result = worker.table_function_cardinality(request)
         assert result.estimate == 30
+
+
+class TestScalarOverloading:
+    """Tests for scalar function overloading by ConstParam count."""
+
+    def _make_scalar_candidates(self) -> list[type]:
+        """Create three scalar overloads with 0, 1, and 2 ConstParams."""
+
+        class ZeroConst(ScalarFunction):
+            class Meta:
+                name = "fmt"
+
+            @classmethod
+            def compute(
+                cls,
+                val: Annotated[pa.DoubleArray, Param(doc="Value")],
+            ) -> Annotated[pa.StringArray, Returns()]:
+                return pa.array([str(v) for v in val.to_pylist()], type=pa.string())
+
+        class OneConst(ScalarFunction):
+            class Meta:
+                name = "fmt"
+
+            @classmethod
+            def compute(
+                cls,
+                prec: Annotated[int, ConstParam("Precision")],
+                val: Annotated[pa.DoubleArray, Param(doc="Value")],
+            ) -> Annotated[pa.StringArray, Returns()]:
+                return pa.array([f"{v:.{prec}f}" for v in val.to_pylist()], type=pa.string())
+
+        class TwoConst(ScalarFunction):
+            class Meta:
+                name = "fmt"
+
+            @classmethod
+            def compute(
+                cls,
+                prec: Annotated[int, ConstParam("Precision")],
+                pfx: Annotated[str, ConstParam("Prefix")],
+                val: Annotated[pa.DoubleArray, Param(doc="Value")],
+            ) -> Annotated[pa.StringArray, Returns()]:
+                return pa.array([f"{pfx}{v:.{prec}f}" for v in val.to_pylist()], type=pa.string())
+
+        return [ZeroConst, OneConst, TwoConst]
+
+    def test_match_by_const_param_count(self) -> None:
+        """Scalar overloads are matched by ConstParam count."""
+        candidates = self._make_scalar_candidates()
+
+        # 0 const args -> ZeroConst
+        result = Worker._match_function_arguments(
+            function_name="fmt",
+            arguments=Arguments(positional=()),
+            input_schema=pa.schema([("val", pa.float64())]),
+            candidates=candidates,
+        )
+        assert result is candidates[0]
+
+        # 1 const arg -> OneConst
+        result = Worker._match_function_arguments(
+            function_name="fmt",
+            arguments=Arguments(positional=(pa.scalar(2),)),
+            input_schema=pa.schema([("val", pa.float64())]),
+            candidates=candidates,
+        )
+        assert result is candidates[1]
+
+        # 2 const args -> TwoConst
+        result = Worker._match_function_arguments(
+            function_name="fmt",
+            arguments=Arguments(positional=(pa.scalar(2), pa.scalar("$"))),
+            input_schema=pa.schema([("val", pa.float64())]),
+            candidates=candidates,
+        )
+        assert result is candidates[2]
+
+    def test_zero_const_params_matches(self) -> None:
+        """A scalar function with 0 ConstParams correctly matches 0 positional args."""
+        candidates = self._make_scalar_candidates()
+
+        result = Worker._match_function_arguments(
+            function_name="fmt",
+            arguments=Arguments(positional=()),
+            input_schema=pa.schema([("val", pa.float64())]),
+            candidates=candidates,
+        )
+        # Should match ZeroConst (0 ConstParams), not fail
+        assert result is candidates[0]
+
+    def test_no_match_error_scalar(self) -> None:
+        """Too many const args gives helpful error for scalar overloads."""
+        candidates = self._make_scalar_candidates()
+
+        with pytest.raises(ValueError, match="No matching function"):
+            Worker._match_function_arguments(
+                function_name="fmt",
+                arguments=Arguments(positional=(pa.scalar(1), pa.scalar(2), pa.scalar(3))),
+                input_schema=pa.schema([("val", pa.float64())]),
+                candidates=candidates,
+            )

uv.lock

@@ -989,7 +989,7 @@ class ReadOnlyCatalogInterface(CatalogInterface):
     _schema_registry: "dict[str, Schema] | None" = None
     _table_registry: "dict[tuple[str, str], Table] | None" = None
     _view_registry: "dict[tuple[str, str], View] | None" = None
-    _function_registry: "dict[tuple[str, str], type] | None" = None
+    _function_registry: "dict[tuple[str, str], list[type]] | None" = None
     _macro_registry: "dict[tuple[str, str], Macro] | None" = None
 
     def _build_registries(self) -> None:
@@ -1025,9 +1025,9 @@ def _register_view(schema_key: str, view: "View") -> None:
         def _register_function(schema_key: str, func_cls: type) -> None:
             meta = func_cls.get_metadata()  # type: ignore[attr-defined]
             key = (schema_key, meta.name.lower())
-            if key in self._function_registry:  # type: ignore[operator]
-                raise ValueError(f"Duplicate function '{meta.name}' in schema '{schema_key}'")
-            self._function_registry[key] = func_cls  # type: ignore[index]
+            if key not in self._function_registry:  # type: ignore[operator]
+                self._function_registry[key] = []  # type: ignore[index]
+            self._function_registry[key].append(func_cls)  # type: ignore[index]
 
         def _register_macro(schema_key: str, macro: "Macro") -> None:
             key = (schema_key, macro.name.lower())
@@ -1318,19 +1318,20 @@ def schema_contents(
                     results.append(macro.to_macro_info(schema_name))
         else:
             # SCALAR_FUNCTION or TABLE_FUNCTION
-            for (sn, _), func_cls in self._function_registry.items():
+            for (sn, _), func_classes in self._function_registry.items():
                 if sn != name_lower:
                     continue
-                func_info = self._function_to_info(func_cls, schema_name)
-                # Filter by function type
-                if type_enum == SchemaObjectType.SCALAR_FUNCTION and func_info.function_type != FunctionType.SCALAR:
-                    continue
-                if type_enum == SchemaObjectType.TABLE_FUNCTION and func_info.function_type not in (
-                    FunctionType.TABLE,
-                    FunctionType.AGGREGATE,
-                ):
-                    continue
-                results.append(func_info)
+                for func_cls in func_classes:
+                    func_info = self._function_to_info(func_cls, schema_name)
+                    # Filter by function type
+                    if type_enum == SchemaObjectType.SCALAR_FUNCTION and func_info.function_type != FunctionType.SCALAR:
+                        continue
+                    if type_enum == SchemaObjectType.TABLE_FUNCTION and func_info.function_type not in (
+                        FunctionType.TABLE,
+                        FunctionType.AGGREGATE,
+                    ):
+                        continue
+                    results.append(func_info)
 
         return results
 

vgi/catalog/catalog_interface.py

@@ -46,6 +46,9 @@
 __all__ = [
     "AddValuesFunction",
     "BernoulliFunction",
+    "FormatNumberDefaultFunction",
+    "FormatNumberFullFunction",
+    "FormatNumberPrecisionFunction",
     "HashSeedFunction",
     "BinaryPacketFunction",
     "ConditionalMessageFunction",
@@ -732,3 +735,121 @@ def compute(
             [json.dumps(secret_dict) for _ in range(_length)],
             type=pa.string(),
         )
+
+
+# ============================================================================
+# format_number — overloaded scalar function (3 overloads by ConstParam count)
+# ============================================================================
+
+
+class FormatNumberDefaultFunction(ScalarFunction):
+    """Format a number with default precision (0 decimal places).
+
+    Overload with 0 ConstParams: just a column input.
+
+    Example:
+        SQL:    SELECT format_number(price) FROM products
+        Input:  price=[3.14, 2.718, 100.5]
+        Output: result=['3', '3', '100']
+
+    """
+
+    class Meta:
+        """Function metadata."""
+
+        name = "format_number"
+        description = "Format number with default precision (0 decimals)"
+        examples = [
+            FunctionExample(
+                sql="SELECT format_number(price) FROM products",
+                description="Format prices with no decimal places",
+            ),
+        ]
+
+    @classmethod
+    def compute(
+        cls,
+        value: Annotated[pa.DoubleArray, Param(doc="Number to format")],
+    ) -> Annotated[pa.StringArray, Returns()]:
+        """Format each value with 0 decimal places."""
+        return pa.array(
+            [f"{v:.0f}" if v is not None else None for v in value.to_pylist()],
+            type=pa.string(),
+        )
+
+
+class FormatNumberPrecisionFunction(ScalarFunction):
+    """Format a number with specified precision.
+
+    Overload with 1 ConstParam: precision.
+
+    Example:
+        SQL:    SELECT format_number(2, price) FROM products
+        Input:  price=[3.14159, 2.718, 100.5]
+        Args:   precision=2
+        Output: result=['3.14', '2.72', '100.50']
+
+    """
+
+    class Meta:
+        """Function metadata."""
+
+        name = "format_number"
+        description = "Format number with specified precision"
+        examples = [
+            FunctionExample(
+                sql="SELECT format_number(2, price) FROM products",
+                description="Format prices with 2 decimal places",
+            ),
+        ]
+
+    @classmethod
+    def compute(
+        cls,
+        precision: Annotated[int, ConstParam("Number of decimal places")],
+        value: Annotated[pa.DoubleArray, Param(doc="Number to format")],
+    ) -> Annotated[pa.StringArray, Returns()]:
+        """Format each value with the specified precision."""
+        return pa.array(
+            [f"{v:.{precision}f}" if v is not None else None for v in value.to_pylist()],
+            type=pa.string(),
+        )
+
+
+class FormatNumberFullFunction(ScalarFunction):
+    """Format a number with precision and prefix.
+
+    Overload with 2 ConstParams: precision and prefix.
+
+    Example:
+        SQL:    SELECT format_number(2, '$', price) FROM products
+        Input:  price=[3.14, 2.718, 100.5]
+        Args:   precision=2, prefix='$'
+        Output: result=['$3.14', '$2.72', '$100.50']
+
+    """
+
+    class Meta:
+        """Function metadata."""
+
+        name = "format_number"
+        description = "Format number with precision and prefix"
+        examples = [
+            FunctionExample(
+                sql="SELECT format_number(2, '$', price) FROM products",
+                description="Format prices with dollar sign and 2 decimals",
+            ),
+        ]
+
+    @classmethod
+    def compute(
+        cls,
+        precision: Annotated[int, ConstParam("Number of decimal places")],
+        prefix: Annotated[str, ConstParam("Prefix string")],
+        value: Annotated[pa.DoubleArray, Param(doc="Number to format")],
+    ) -> Annotated[pa.StringArray, Returns()]:
+        """Format each value with prefix and specified precision."""
+        return pa.array(
+            [f"{prefix}{v:.{precision}f}" if v is not None else None for v in value.to_pylist()],
+            type=pa.string(),
+        )