Update ConstantTableFunction to take count parameter first

Changed signature from constant_table(value) to constant_table(count, value):
- count: number of rows to generate (must be >= 1)
- value: the constant integer value to repeat

Added batching support (BATCH_SIZE=1000) for large counts.

Example usage:
  SELECT * FROM constant_table(3, 42)
  → [{"value": 42}, {"value": 42}, {"value": 42}]

Updated tests for new signature and added test for large counts.

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

Author: rustyconover

tests/table/generator/test_constant_table_function.py

@@ -16,11 +16,19 @@ class TestConstantTableFunctionInProcess:
     """In-process tests for the constant_table function."""
 
     def test_returns_constant_value(self) -> None:
-        """Constant table should return a single row with the given value."""
+        """Constant table should return rows with the given value."""
         assert_table_function_output(
             ConstantTableFunction,
-            args=(42,),
-            expected=[batch(value=[42])],
+            args=(3, 42),  # count=3, value=42
+            expected=[batch(value=[42, 42, 42])],
+        )
+
+    def test_returns_single_row(self) -> None:
+        """Constant table with count=1 should return one row."""
+        assert_table_function_output(
+            ConstantTableFunction,
+            args=(1, 100),
+            expected=[batch(value=[100])],
         )
 
     def test_metadata(self) -> None:
@@ -30,19 +38,19 @@ def test_metadata(self) -> None:
         assert meta.max_workers == 1
 
     def test_cardinality(self) -> None:
-        """Cardinality should always be 1."""
+        """Cardinality should equal the count parameter."""
         invocation = make_invocation(
             function_name="constant_table",
-            arguments=Arguments(positional=(pa.scalar(42),)),
+            arguments=Arguments(positional=(pa.scalar(5), pa.scalar(42))),
         )
         func = ConstantTableFunction(
             invocation=invocation,
             logger=structlog.get_logger(),
         )
         cardinality = func.cardinality
         assert cardinality is not None
-        assert cardinality.estimate == 1
-        assert cardinality.max == 1
+        assert cardinality.estimate == 5
+        assert cardinality.max == 5
 
 
 class TestConstantTableFunctionBothModes:
@@ -52,10 +60,22 @@ class TestConstantTableFunctionBothModes:
     def test_returns_value(
         self, run_table_function_mode: RunnerWithMode, value: int
     ) -> None:
-        """Constant table should return a single row with the given value."""
+        """Constant table should return rows with the given value."""
+        runner, mode = run_table_function_mode
+        count = 3
+        outputs, logs = runner(ConstantTableFunction, (count, value))
+
+        table = pa.Table.from_batches(outputs)
+        assert table.num_rows == count
+        assert table.column("value").to_pylist() == [value] * count
+
+    def test_large_count(self, run_table_function_mode: RunnerWithMode) -> None:
+        """Large counts should work correctly with batching."""
         runner, mode = run_table_function_mode
-        outputs, logs = runner(ConstantTableFunction, (value,))
+        count = 2500  # Larger than default BATCH_SIZE of 1000
+        value = 7
+        outputs, logs = runner(ConstantTableFunction, (count, value))
 
         table = pa.Table.from_batches(outputs)
-        assert table.num_rows == 1
-        assert table.column("value").to_pylist() == [value]
+        assert table.num_rows == count
+        assert all(v == value for v in table.column("value").to_pylist())

vgi/examples/table.py

@@ -234,43 +234,53 @@ def process(self) -> OutputGenerator:
 
 
 class ConstantTableFunction(TableFunctionGenerator):
-    """Returns a constant single-row table with a specified value.
+    """Returns a table with repeated constant values.
 
     USE CASE
     --------
-    Testing, providing configuration values, or creating a single-row
-    lookup table.
+    Testing, providing repeated configuration values, or creating a
+    lookup table with multiple rows of the same value.
 
     SCHEMA
     ------
     Output: {"value": int64}
 
     PARALLELIZATION
     ---------------
-    Single worker (returns exactly one row).
+    Single worker only (max_workers=1).
 
     Example:
     -------
-    SELECT * FROM constant_table(42)
-    Returns: [{"value": 42}]
+    SELECT * FROM constant_table(3, 42)
+    Returns: [{"value": 42}, {"value": 42}, {"value": 42}]
+
+    SELECT * FROM constant_table(1, 100)
+    Returns: [{"value": 100}]
 
     """
 
     class Meta:
         """Metadata for ConstantTableFunction."""
 
         name = "constant_table"
-        description = "Returns a single-row table with a constant value"
+        description = "Returns a table with repeated constant values"
         categories = ["generator", "utility"]
         max_workers = 1
         examples = [
             FunctionExample(
-                sql="SELECT * FROM constant_table(42)",
-                description="Return a table with one row containing 42",
-            )
+                sql="SELECT * FROM constant_table(3, 42)",
+                description="Return a table with 3 rows containing 42",
+            ),
+            FunctionExample(
+                sql="SELECT * FROM constant_table(1, 100)",
+                description="Return a table with one row containing 100",
+            ),
         ]
 
-    value: Annotated[int, Arg(0, doc="The constant value to return")]
+    count: Annotated[int, Arg(0, doc="Number of rows to generate", ge=1)]
+    value: Annotated[int, Arg(1, doc="The constant value to repeat")]
+
+    BATCH_SIZE: int = 1000
 
     @property
     def output_schema(self) -> pa.Schema:
@@ -279,16 +289,20 @@ def output_schema(self) -> pa.Schema:
 
     @property
     def cardinality(self) -> TableCardinality:
-        """Return cardinality of exactly one row."""
-        return TableCardinality(estimate=1, max=1)
+        """Return exact cardinality since we know the count."""
+        return TableCardinality(estimate=self.count, max=self.count)
 
     def process(self) -> OutputGenerator:
-        """Emit a single batch with one row."""
-        yield Output(
-            pa.RecordBatch.from_pydict(
-                {"value": [self.value]}, schema=self.output_schema
+        """Emit batches with constant values."""
+        remaining = self.count
+        while remaining > 0:
+            batch_size = min(remaining, self.BATCH_SIZE)
+            yield Output(
+                pa.RecordBatch.from_pydict(
+                    {"value": [self.value] * batch_size}, schema=self.output_schema
+                )
             )
-        )
+            remaining -= batch_size
 
 
 class GeneratorExceptionFunction(TableFunctionGenerator):