feat: value type for table rows

Author: jrentlez

libs/execution/src/lib/types/value-types/internal-representation-parsing.ts

@@ -124,6 +124,10 @@ class InternalRepresentationParserVisitor extends ValueTypeVisitor<
     return new InvalidValue(`Cannot parse collections into internal values`);
   }
 
+  override visitTableRow(): InvalidValue {
+    return new InvalidValue(`Cannot parse table rows into internal values`);
+  }
+
   override visitConstraint(): InvalidValue {
     return new InvalidValue(`Cannot parse constraints into internal values`);
   }

libs/execution/src/lib/types/value-types/value-representation-validity.ts

@@ -6,6 +6,7 @@
 import { strict as assert } from 'assert';
 
 import {
+  type TableRowValueType,
   type AtomicValueType,
   type BooleanValuetype,
   type CellRangeValuetype,
@@ -130,6 +131,10 @@ class ValueRepresentationValidityVisitor extends ValueTypeVisitor<boolean> {
     return this.isValidForPrimitiveValuetype(valueType);
   }
 
+  override visitTableRow(valueType: TableRowValueType): boolean {
+    return this.isValidForPrimitiveValuetype(valueType);
+  }
+
   override visitTransform(valueType: TransformValuetype): boolean {
     return this.isValidForPrimitiveValuetype(valueType);
   }

libs/execution/src/lib/types/value-types/visitors/sql-column-type-visitor.ts

@@ -76,6 +76,12 @@ export class SQLColumnTypeVisitor extends ValueTypeVisitor<string> {
     );
   }
 
+  override visitTableRow(): string {
+    throw new Error(
+      'No visit implementation given for table rows. Cannot be the type of a column.',
+    );
+  }
+
   override visitTransform(): string {
     throw new Error(
       'No visit implementation given for transforms. Cannot be the type of a column.',

libs/execution/src/lib/types/value-types/visitors/sql-value-representation-visitor.ts

@@ -130,6 +130,14 @@ export class SQLValueRepresentationVisitor extends ValueTypeVisitor<
     );
   }
 
+  override visitTableRow(): (
+    value: InternalValidValueRepresentation | InternalErrorValueRepresentation,
+  ) => string {
+    throw new Error(
+      'No visit implementation given for table rows. Cannot be the type of a column.',
+    );
+  }
+
   override visitTransform(): (
     value: InternalValidValueRepresentation | InternalErrorValueRepresentation,
   ) => string {

libs/language-server/src/lib/ast/expressions/type-inference.ts

@@ -29,6 +29,7 @@ import {
   isNumericLiteral,
   isReferenceLiteral,
   isRegexLiteral,
+  isTableRowLiteral,
   isTernaryExpression,
   isTextLiteral,
   isTransformDefinition,
@@ -39,10 +40,12 @@ import {
   isValueTypeProperty,
   isValuetypeAssignmentLiteral,
   isValuetypeDefinition,
+  type TableRowLiteral,
 } from '../generated/ast';
 import { getNextAstNodeContainer } from '../model-util';
 import {
   isAtomicValueType,
+  type TableRowValueType,
   type ValueType,
   type ValueTypeProvider,
   type WrapperFactoryProvider,
@@ -186,6 +189,13 @@ function inferTypeFromExpressionLiteral(
         valueTypeProvider,
         wrapperFactories,
       );
+    } else if (isTableRowLiteral(expression)) {
+      return inferTableRowType(
+        expression,
+        validationContext,
+        valueTypeProvider,
+        wrapperFactories,
+      );
     } else if (isErrorLiteral(expression)) {
       return undefined;
     }
@@ -297,6 +307,28 @@ function inferCollectionElementTypes(
   return undefined;
 }
 
+function inferTableRowType(
+  tableRow: TableRowLiteral,
+  validationContext: ValidationContext,
+  valueTypeProvider: ValueTypeProvider,
+  wrapperFactories: WrapperFactoryProvider,
+): TableRowValueType | undefined {
+  const cellValueTypes = new Map<string, ValueType>();
+  for (const cell of tableRow.cells) {
+    const cellValueType = inferExpressionType(
+      cell.expression,
+      validationContext,
+      valueTypeProvider,
+      wrapperFactories,
+    );
+    if (cellValueType === undefined) {
+      return undefined;
+    }
+    cellValueTypes.set(cell.name, cellValueType);
+  }
+  return valueTypeProvider.createTableRowValueTypeOf(cellValueTypes);
+}
+
 function inferTypeFromValueKeyword(
   expression: ValueKeywordLiteral,
   validationContext: ValidationContext,

libs/language-server/src/lib/ast/wrappers/value-type/primitive/index.ts

@@ -18,10 +18,11 @@ export { type ConstraintValuetype } from './constraint-value-type';
 export { type DecimalValuetype } from './decimal-value-type';
 export { type IntegerValuetype } from './integer-value-type';
 export { type RegexValuetype } from './regex-value-type';
+export { type TableRowValueType } from './table-row-value-type';
 export { type TextValuetype } from './text-value-type';
+export { type TransformValuetype } from './transform-value-type';
 export { type ValuetypeAssignmentValuetype } from './value-type-assignment-value-type';
 export { type ValuetypeDefinitionValuetype } from './value-type-definition-value-type';
-export { type TransformValuetype } from './transform-value-type';
 
 export {
   ValueTypeProvider,

libs/language-server/src/lib/ast/wrappers/value-type/primitive/primitive-value-type-provider.ts

@@ -18,6 +18,7 @@ import { TextValuetype } from './text-value-type';
 import { TransformValuetype } from './transform-value-type';
 import { ValuetypeAssignmentValuetype } from './value-type-assignment-value-type';
 import { ValuetypeDefinitionValuetype } from './value-type-definition-value-type';
+import { TableRowValueType } from './table-row-value-type';
 
 /**
  * Should be created as singleton due to the equality comparison of primitive value types.
@@ -32,6 +33,10 @@ export class ValueTypeProvider {
   ): CollectionValueType<I> {
     return new CollectionValueType(input);
   }
+
+  createTableRowValueTypeOf(input: Map<string, ValueType>): TableRowValueType {
+    return new TableRowValueType(input);
+  }
 }
 
 export class PrimitiveValueTypeProvider {

libs/language-server/src/lib/ast/wrappers/value-type/primitive/table-row-value-type.ts

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: 2026 Friedrich-Alexander-Universitat Erlangen-Nurnberg
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import {
+  type TableRow,
+  type InternalValidValueRepresentation,
+} from '../../../expressions/internal-value-representation';
+import { type ValueType, type ValueTypeVisitor } from '../value-type';
+
+import { PrimitiveValueType } from './primitive-value-type';
+import { TABLEROW_TYPEGUARD } from '../../../expressions';
+
+export class TableRowValueType extends PrimitiveValueType<TableRow> {
+  constructor(private schema: Map<string, ValueType>) {
+    super();
+  }
+
+  acceptVisitor<R>(visitor: ValueTypeVisitor<R>): R {
+    return visitor.visitTableRow(this);
+  }
+
+  override isAllowedAsRuntimeParameter(): boolean {
+    return false;
+  }
+
+  override getName(): 'TableRow' {
+    return 'TableRow';
+  }
+
+  private equalSchema(otherSchema: Map<string, ValueType>): boolean {
+    if (this.schema.size !== otherSchema.size) {
+      return false;
+    }
+    for (const [columnName, cellValue] of this.schema) {
+      const otherCellValue = otherSchema.get(columnName);
+      if (cellValue !== otherCellValue) {
+        return false;
+      }
+      if (otherCellValue === undefined && !otherSchema.has(columnName)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  override equals(target: ValueType): boolean {
+    return (
+      target instanceof TableRowValueType && this.equalSchema(target.schema)
+    );
+  }
+
+  override isInternalValidValueRepresentation(
+    operandValue: InternalValidValueRepresentation,
+  ): operandValue is TableRow {
+    return TABLEROW_TYPEGUARD(operandValue);
+  }
+}

libs/language-server/src/lib/ast/wrappers/value-type/value-type.ts

@@ -13,6 +13,7 @@ import {
   type BooleanValuetype,
   type CellRangeValuetype,
   type CollectionValueType,
+  type TableRowValueType,
   type ConstraintValuetype,
   type DecimalValuetype,
   type EmptyCollectionValueType,
@@ -90,6 +91,7 @@ export abstract class ValueTypeVisitor<R = unknown> {
   abstract visitCollection(
     valueType: CollectionValueType | EmptyCollectionValueType,
   ): R;
+  abstract visitTableRow(valueType: TableRowValueType): R;
   abstract visitTransform(valueType: TransformValuetype): R;
 
   abstract visitAtomicValueType(valueType: AtomicValueType): R;