feat: introduction of simple table functions

extensions/functions_table.yaml

@@ -0,0 +1,92 @@
+%YAML 1.2
+---
+# Table functions: Functions that produce relations (zero or more records).
+# Currently, only 0-input functions are supported - these take constant arguments
+# and generate data as leaf operators.
+urn: extension:io.substrait:functions_table
+table_functions:
+  - name: "generate_series"
+    description: >-
+      Generates a series of integer values from start to stop, incrementing by step.
+
+      Takes constant arguments and produces zero or more records containing a single
+      integer value. The series includes both the start and stop values if they fall
+      on a step boundary. If step is positive, stops when the value exceeds stop.
+      If step is negative, stops when the value is less than stop. Returns empty if
+      step is zero or if the step direction doesn't allow reaching stop from start.
+    impls:
+      - args:
+          - name: start
+            value: i64
+            description: The starting value of the series
+          - name: stop
+            value: i64
+            description: The ending value of the series (inclusive)
+          - name: step
+            value: i64
+            description: The increment between values
+            constant: true
+        return:
+          names:
+            - value
+          struct:
+            types:
+              - i64
+      - args:
+          - name: start
+            value: i32
+            description: The starting value of the series
+          - name: stop
+            value: i32
+            description: The ending value of the series (inclusive)
+          - name: step
+            value: i32
+            description: The increment between values
+            constant: true
+        return:
+          names:
+            - value
+          struct:
+            types:
+              - i32
+      - args:
+          - name: start
+            value: i64
+            description: The starting value of the series
+          - name: stop
+            value: i64
+            description: The ending value of the series (inclusive)
+        return:
+          names:
+            - value
+          struct:
+            types:
+              - i64
+      - args:
+          - name: start
+            value: i32
+            description: The starting value of the series
+          - name: stop
+            value: i32
+            description: The ending value of the series (inclusive)
+        return:
+          names:
+            - value
+          struct:
+            types:
+              - i32
+  - name: "unnest"
+    description: Expands a list expression into a set of rows, one row per element.
+    impls:
+      - args:
+          - name: input
+            value: list<T>
+            description: The list to unnest
+        # Schema references type parameter T from list<T>
+        # The field type is derived from the list element type
+        return:
+          names:
+            - element
+          struct:
+            types:
+              - T

proto/substrait/algebra.proto

@@ -552,6 +552,61 @@ message ExpandRel {
   }
 }
 
+// Invokes a table-valued function that produces a relation (zero or more records).
+//
+//
+// Table functions produce a table with a schema that can be:
+//   - Statically defined (concrete types in YAML)
+//   - Type-parameterized (derived from argument types, e.g., unnest(list<T>) -> {element: T})
+//   - Runtime-dependent (determined by inspecting data content, use derived: false)
+//
+// Future extensions may add an optional input field to support transformation
+// table functions that operate on input relations.
+message TableFunctionRel {
+  RelCommon common = 1;
+
+  // Points to a function_anchor defined in this plan, which must refer
+  // to a table function in the associated YAML file. Avoid using
+  // anchor/reference zero.
+  uint32 function_reference = 2;
+
+  // The arguments to be bound to the function. This must have exactly the
+  // number of arguments specified in the function definition from the YAML file,
+  // and the argument types must also match exactly:
+  //  - Value arguments must be bound using FunctionArgument.value.
+  //    Currently (0-input functions only), expressions must be constants
+  //    (literals or expressions evaluable without input data).
+  //  - Type arguments must be bound using FunctionArgument.type.
+  //  - Enum arguments must be bound using FunctionArgument.enum with a
+  //    string that case-insensitively matches one of the allowed options.
+  repeated FunctionArgument arguments = 3;
+
+  // Options to specify behavior for corner cases, or leave behavior
+  // unspecified if the consumer does not need specific behavior in these
+  // cases.
+  repeated FunctionOption options = 5;
+
+  // Indicates whether the schema was derived from the YAML function definition:
+  // - If true: the table_schema was computed from the ExpressionNamedStruct in the
+  //   YAML file by evaluating it with the bound argument types. This includes:
+  //   * Static schemas (concrete field types)
+  //   * Type-parameterized schemas (e.g., T from list<T>)
+  // - If false: the table_schema was determined by the plan producer based on runtime
+  //   data inspection (YAML omits the return field)
+  //
+  // This value must be true if and only if a return field is provided in the YAML
+  // definition of this function.
+  bool derived = 6;
+
+  // The concrete output schema of the relation. For derived schemas (derived=true),
+  // this must match the schema computed by evaluating the YAML ExpressionNamedStruct
+  // with the bound argument types. For runtime-dependent schemas (derived=false),
+  // this is provided by the plan producer.
+  NamedStruct table_schema = 7;
+
+  substrait.extensions.AdvancedExtension advanced_extension = 8;
+}
+
 // A relation with output field names.
 //
 // This is for use at the root of a `Rel` tree.
@@ -581,6 +636,7 @@ message Rel {
     WriteRel write = 19;
     DdlRel ddl = 20;
     UpdateRel update = 22;
+    TableFunctionRel table_function = 23;
     // Physical relations
     HashJoinRel hash_join = 13;
     MergeJoinRel merge_join = 14;

proto/substrait/function.proto

@@ -106,6 +106,21 @@ message FunctionSignature {
     }
   }
 
+  message Table {
+    repeated Argument arguments = 2;
+    repeated string name = 3;
+    Description description = 4;
+
+    // The schema expression that defines the output relation structure.
+    // This must be an ExpressionNamedStruct since table functions always
+    // produce relations with named fields. The struct can be:
+    // - Static (concrete field types)
+    // - Type-parameterized (field types derived from argument types)
+    DerivationExpression.ExpressionNamedStruct schema = 5;
+
+    repeated Implementation implementations = 6;
+  }
+
   message Description {
     string language = 1;
     string body = 2;