@quereus/quereus 0.6.4 → 0.6.6

package/src/planner/building/constraint-builder.ts

@@ -1,173 +1,178 @@
-import type { PlanningContext } from '../planning-context.js';
-import type { TableSchema, RowConstraintSchema } from '../../schema/table.js';
-import type { RowOpFlag } from '../../schema/table.js';
-import type { Attribute, RowDescriptor } from '../nodes/plan-node.js';
-import type { ConstraintCheck } from '../nodes/constraint-check-node.js';
-import { RegisteredScope } from '../scopes/registered.js';
-import { buildExpression } from './expression.js';
-import { PlanNodeType } from '../nodes/plan-node-type.js';
-import { ColumnReferenceNode } from '../nodes/reference.js';
-import type { ScalarPlanNode } from '../nodes/plan-node.js';
-import * as AST from '../../parser/ast.js';
-
-/**
- * Determines if a constraint should be checked for the given operation
- */
-function shouldCheckConstraint(constraint: RowConstraintSchema, operation: RowOpFlag): boolean {
-  // Check if the current operation is in the constraint's operations bitmask
-  return (constraint.operations & operation) !== 0;
-}
-
-/**
- * Builds constraint check expressions at plan time.
- * This allows the optimizer to see and optimize constraint expressions.
- */
-export function buildConstraintChecks(
-  ctx: PlanningContext,
-  tableSchema: TableSchema,
-  operation: RowOpFlag,
-  oldAttributes: Attribute[],
-  newAttributes: Attribute[],
-  _flatRowDescriptor: RowDescriptor,
-  contextAttributes: Attribute[] = []
-): ConstraintCheck[] {
-  // Build attribute ID mappings for column registration
-  const newAttrIdByCol: Record<string, number> = {};
-  const oldAttrIdByCol: Record<string, number> = {};
-
-  newAttributes.forEach((attr, columnIndex) => {
-    if (columnIndex < tableSchema.columns.length) {
-      const column = tableSchema.columns[columnIndex];
-      newAttrIdByCol[column.name.toLowerCase()] = attr.id;
-    }
-  });
-
-  oldAttributes.forEach((attr, columnIndex) => {
-    if (columnIndex < tableSchema.columns.length) {
-      const column = tableSchema.columns[columnIndex];
-      oldAttrIdByCol[column.name.toLowerCase()] = attr.id;
-    }
-  });
-
-  // Filter constraints by operation
-  const applicableConstraints = tableSchema.checkConstraints
-    .filter(constraint => shouldCheckConstraint(constraint, operation));
-
-  // Build expression nodes for each constraint
-  return applicableConstraints.map(constraint => {
-    // Create scope with OLD/NEW column access for constraint evaluation
-    const constraintScope = new RegisteredScope(ctx.scope);
-
-    // Register mutation context variables FIRST (so they shadow column names if conflicts exist)
-    contextAttributes.forEach((attr, contextVarIndex) => {
-      if (contextVarIndex < (tableSchema.mutationContext?.length || 0)) {
-        const contextVar = tableSchema.mutationContext![contextVarIndex];
-        const varNameLower = contextVar.name.toLowerCase();
-
-        // Register both unqualified and qualified names
-        constraintScope.subscribeFactory(varNameLower, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, contextVarIndex)
-        );
-        constraintScope.subscribeFactory(`context.${varNameLower}`, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, contextVarIndex)
-        );
-      }
-    });
-
-    // Register column symbols (similar to current emitConstraintCheck logic)
-    tableSchema.columns.forEach((tableColumn, tableColIndex) => {
-      const colNameLower = tableColumn.name.toLowerCase();
-
-      // Register NEW.col and unqualified col (defaults to NEW for INSERT/UPDATE, OLD for DELETE)
-      const newAttrId = newAttrIdByCol[colNameLower];
-      if (newAttrId !== undefined) {
-        const newColumnType = {
-          typeClass: 'scalar' as const,
-          logicalType: tableColumn.logicalType,
-          nullable: !tableColumn.notNull,
-          isReadOnly: false
-        };
-
-        // NEW.column
-        constraintScope.registerSymbol(`new.${colNameLower}`, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
-
-        // For INSERT/UPDATE, unqualified column defaults to NEW
-        if (operation === 1 || operation === 2) { // INSERT or UPDATE
-          constraintScope.registerSymbol(colNameLower, (exp, s) =>
-            new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
-        }
-      }
-
-      // Register OLD.col
-      const oldAttrId = oldAttrIdByCol[colNameLower];
-      if (oldAttrId !== undefined) {
-        const oldColumnType = {
-          typeClass: 'scalar' as const,
-          logicalType: tableColumn.logicalType,
-          nullable: true, // OLD values can be NULL (especially for INSERT)
-          isReadOnly: false
-        };
-
-        // OLD.column
-        constraintScope.registerSymbol(`old.${colNameLower}`, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
-
-        // For DELETE, unqualified column defaults to OLD
-        if (operation === 4) { // DELETE
-          constraintScope.registerSymbol(colNameLower, (exp, s) =>
-            new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
-        }
-      }
-    });
-
-    // Build the constraint expression using the specialized scope
-    // Temporarily set the current schema to match the table's schema
-    // This ensures unqualified table references in CHECK constraints resolve correctly
-    const originalCurrentSchema = ctx.schemaManager.getCurrentSchemaName();
-    const needsSchemaSwitch = tableSchema.schemaName !== originalCurrentSchema;
-
-    if (needsSchemaSwitch) {
-      ctx.schemaManager.setCurrentSchema(tableSchema.schemaName);
-    }
-
-    try {
-      const expression = buildExpression(
-        { ...ctx, scope: constraintScope },
-        constraint.expr
-      ) as ScalarPlanNode;
-
-      // Heuristic: auto-defer if the expression contains a subquery
-      // or references a different relation via attribute bindings (NEW/OLD already localized).
-      const needsDeferred = containsSubquery(expression);
-
-      return {
-        constraint,
-        expression,
-        deferrable: needsDeferred,
-        initiallyDeferred: needsDeferred,
-        containsSubquery: needsDeferred
-      } satisfies ConstraintCheck;
-    } finally {
-      // Restore original schema context
-      if (needsSchemaSwitch) {
-        ctx.schemaManager.setCurrentSchema(originalCurrentSchema);
-      }
-    }
-  });
-}
-
-function containsSubquery(expr: ScalarPlanNode): boolean {
-  const stack: ScalarPlanNode[] = [expr];
-  while (stack.length) {
-    const n = stack.pop()!;
-    if (n.nodeType === PlanNodeType.ScalarSubquery || n.nodeType === PlanNodeType.Exists) {
-      return true;
-    }
-    for (const c of n.getChildren()) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      stack.push(c as any);
-    }
-  }
-  return false;
-}
+import type { PlanningContext } from '../planning-context.js';
+import type { TableSchema, RowConstraintSchema } from '../../schema/table.js';
+import type { RowOpFlag } from '../../schema/table.js';
+import type { Attribute, RowDescriptor } from '../nodes/plan-node.js';
+import type { ConstraintCheck } from '../nodes/constraint-check-node.js';
+import { RegisteredScope } from '../scopes/registered.js';
+import { buildExpression } from './expression.js';
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+import { ColumnReferenceNode } from '../nodes/reference.js';
+import type { ScalarPlanNode } from '../nodes/plan-node.js';
+import * as AST from '../../parser/ast.js';
+import { validateDeterministicConstraint } from '../validation/determinism-validator.js';
+
+/**
+ * Determines if a constraint should be checked for the given operation
+ */
+function shouldCheckConstraint(constraint: RowConstraintSchema, operation: RowOpFlag): boolean {
+  // Check if the current operation is in the constraint's operations bitmask
+  return (constraint.operations & operation) !== 0;
+}
+
+/**
+ * Builds constraint check expressions at plan time.
+ * This allows the optimizer to see and optimize constraint expressions.
+ */
+export function buildConstraintChecks(
+  ctx: PlanningContext,
+  tableSchema: TableSchema,
+  operation: RowOpFlag,
+  oldAttributes: Attribute[],
+  newAttributes: Attribute[],
+  _flatRowDescriptor: RowDescriptor,
+  contextAttributes: Attribute[] = []
+): ConstraintCheck[] {
+  // Build attribute ID mappings for column registration
+  const newAttrIdByCol: Record<string, number> = {};
+  const oldAttrIdByCol: Record<string, number> = {};
+
+  newAttributes.forEach((attr, columnIndex) => {
+    if (columnIndex < tableSchema.columns.length) {
+      const column = tableSchema.columns[columnIndex];
+      newAttrIdByCol[column.name.toLowerCase()] = attr.id;
+    }
+  });
+
+  oldAttributes.forEach((attr, columnIndex) => {
+    if (columnIndex < tableSchema.columns.length) {
+      const column = tableSchema.columns[columnIndex];
+      oldAttrIdByCol[column.name.toLowerCase()] = attr.id;
+    }
+  });
+
+  // Filter constraints by operation
+  const applicableConstraints = tableSchema.checkConstraints
+    .filter(constraint => shouldCheckConstraint(constraint, operation));
+
+  // Build expression nodes for each constraint
+  return applicableConstraints.map(constraint => {
+    // Create scope with OLD/NEW column access for constraint evaluation
+    const constraintScope = new RegisteredScope(ctx.scope);
+
+    // Register mutation context variables FIRST (so they shadow column names if conflicts exist)
+    contextAttributes.forEach((attr, contextVarIndex) => {
+      if (contextVarIndex < (tableSchema.mutationContext?.length || 0)) {
+        const contextVar = tableSchema.mutationContext![contextVarIndex];
+        const varNameLower = contextVar.name.toLowerCase();
+
+        // Register both unqualified and qualified names
+        constraintScope.subscribeFactory(varNameLower, (exp, s) =>
+          new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, contextVarIndex)
+        );
+        constraintScope.subscribeFactory(`context.${varNameLower}`, (exp, s) =>
+          new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, contextVarIndex)
+        );
+      }
+    });
+
+    // Register column symbols (similar to current emitConstraintCheck logic)
+    tableSchema.columns.forEach((tableColumn, tableColIndex) => {
+      const colNameLower = tableColumn.name.toLowerCase();
+
+      // Register NEW.col and unqualified col (defaults to NEW for INSERT/UPDATE, OLD for DELETE)
+      const newAttrId = newAttrIdByCol[colNameLower];
+      if (newAttrId !== undefined) {
+        const newColumnType = {
+          typeClass: 'scalar' as const,
+          logicalType: tableColumn.logicalType,
+          nullable: !tableColumn.notNull,
+          isReadOnly: false
+        };
+
+        // NEW.column
+        constraintScope.registerSymbol(`new.${colNameLower}`, (exp, s) =>
+          new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
+
+        // For INSERT/UPDATE, unqualified column defaults to NEW
+        if (operation === 1 || operation === 2) { // INSERT or UPDATE
+          constraintScope.registerSymbol(colNameLower, (exp, s) =>
+            new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
+        }
+      }
+
+      // Register OLD.col
+      const oldAttrId = oldAttrIdByCol[colNameLower];
+      if (oldAttrId !== undefined) {
+        const oldColumnType = {
+          typeClass: 'scalar' as const,
+          logicalType: tableColumn.logicalType,
+          nullable: true, // OLD values can be NULL (especially for INSERT)
+          isReadOnly: false
+        };
+
+        // OLD.column
+        constraintScope.registerSymbol(`old.${colNameLower}`, (exp, s) =>
+          new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
+
+        // For DELETE, unqualified column defaults to OLD
+        if (operation === 4) { // DELETE
+          constraintScope.registerSymbol(colNameLower, (exp, s) =>
+            new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
+        }
+      }
+    });
+
+    // Build the constraint expression using the specialized scope
+    // Temporarily set the current schema to match the table's schema
+    // This ensures unqualified table references in CHECK constraints resolve correctly
+    const originalCurrentSchema = ctx.schemaManager.getCurrentSchemaName();
+    const needsSchemaSwitch = tableSchema.schemaName !== originalCurrentSchema;
+
+    if (needsSchemaSwitch) {
+      ctx.schemaManager.setCurrentSchema(tableSchema.schemaName);
+    }
+
+    try {
+      const expression = buildExpression(
+        { ...ctx, scope: constraintScope },
+        constraint.expr
+      ) as ScalarPlanNode;
+
+      // Validate that the constraint expression is deterministic
+      const constraintName = constraint.name ?? `_check_${tableSchema.name}`;
+      validateDeterministicConstraint(expression, constraintName, tableSchema.name);
+
+      // Heuristic: auto-defer if the expression contains a subquery
+      // or references a different relation via attribute bindings (NEW/OLD already localized).
+      const needsDeferred = containsSubquery(expression);
+
+      return {
+        constraint,
+        expression,
+        deferrable: needsDeferred,
+        initiallyDeferred: needsDeferred,
+        containsSubquery: needsDeferred
+      } satisfies ConstraintCheck;
+    } finally {
+      // Restore original schema context
+      if (needsSchemaSwitch) {
+        ctx.schemaManager.setCurrentSchema(originalCurrentSchema);
+      }
+    }
+  });
+}
+
+function containsSubquery(expr: ScalarPlanNode): boolean {
+  const stack: ScalarPlanNode[] = [expr];
+  while (stack.length) {
+    const n = stack.pop()!;
+    if (n.nodeType === PlanNodeType.ScalarSubquery || n.nodeType === PlanNodeType.Exists) {
+      return true;
+    }
+    for (const c of n.getChildren()) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      stack.push(c as any);
+    }
+  }
+  return false;
+}

package/src/planner/building/delete.ts

@@ -148,7 +148,11 @@ export function buildDeleteStmt(
     deleteCtx.scope,
     deleteNode,
     tableReference,
-    'delete'
+    'delete',
+    undefined, // onConflict not used for DELETE
+    mutationContextValues.size > 0 ? mutationContextValues : undefined,
+    contextAttributes.length > 0 ? contextAttributes : undefined,
+    contextDescriptor
   );
 
   const resultNode: RelationalPlanNode = dmlExecutorNode;

package/src/planner/building/insert.ts

@@ -22,6 +22,7 @@ import { ProjectNode, type Projection } from '../nodes/project-node.js';
 import { buildOldNewRowDescriptors } from '../../util/row-descriptor.js';
 import { DmlExecutorNode } from '../nodes/dml-executor-node.js';
 import { buildConstraintChecks } from './constraint-builder.js';
+import { validateDeterministicDefault } from '../validation/determinism-validator.js';
 
 /**
  * Creates a uniform row expansion projection that maps any relational source
@@ -103,6 +104,9 @@ function createRowExpansionProjection(
 				if (typeof tableColumn.defaultValue === 'object' && tableColumn.defaultValue !== null && 'type' in tableColumn.defaultValue) {
 					// It's an AST.Expression - build it into a plan node with context scope
 					defaultNode = buildExpression(defaultCtx, tableColumn.defaultValue as AST.Expression) as ScalarPlanNode;
+
+					// Validate that the default expression is deterministic
+					validateDeterministicDefault(defaultNode, tableColumn.name, tableSchema.name);
 				} else {
 					// Literal default value
 					defaultNode = buildExpression(defaultCtx, { type: 'literal', value: tableColumn.defaultValue }) as ScalarPlanNode;
@@ -358,7 +362,10 @@ export function buildInsertStmt(
 		constraintCheckNode,
 		tableReference,
 		'insert',
-		stmt.onConflict
+		stmt.onConflict,
+		mutationContextValues.size > 0 ? mutationContextValues : undefined,
+		contextAttributes.length > 0 ? contextAttributes : undefined,
+		contextDescriptor
 	);
 
 	const resultNode: RelationalPlanNode = dmlExecutorNode;

package/src/planner/building/update.ts

@@ -270,7 +270,11 @@ export function buildUpdateStmt(
       updateCtx.scope,
       constraintCheckNode,
       tableReference,
-      'update'
+      'update',
+      undefined, // onConflict not used for UPDATE
+      mutationContextValues.size > 0 ? mutationContextValues : undefined,
+      contextAttributes.length > 0 ? contextAttributes : undefined,
+      contextDescriptor
     );
 
     // Return the RETURNING results from the executed update
@@ -312,7 +316,11 @@ export function buildUpdateStmt(
     updateCtx.scope,
     constraintCheckNode,
     tableReference,
-    'update'
+    'update',
+    undefined, // onConflict not used for UPDATE
+    mutationContextValues.size > 0 ? mutationContextValues : undefined,
+    contextAttributes.length > 0 ? contextAttributes : undefined,
+    contextDescriptor
   );
 
   return new SinkNode(updateCtx.scope, updateExecutorNode, 'update');

package/src/planner/nodes/dml-executor-node.ts

@@ -1,5 +1,5 @@
 import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type Attribute, type PhysicalProperties, isRelationalNode } from './plan-node.js';
+import { PlanNode, type RelationalPlanNode, type Attribute, type PhysicalProperties, type ScalarPlanNode, type RowDescriptor, isRelationalNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { TableReferenceNode } from './reference.js';
 import type { RelationType } from '../../common/datatype.js';
@@ -20,6 +20,9 @@ export class DmlExecutorNode extends PlanNode implements RelationalPlanNode {
     public readonly table: TableReferenceNode,
     public readonly operation: RowOp,
     public readonly onConflict?: ConflictResolution, // Used for INSERT operations
+    public readonly mutationContextValues?: Map<string, ScalarPlanNode>, // Mutation context value expressions
+    public readonly contextAttributes?: Attribute[], // Mutation context attributes
+    public readonly contextDescriptor?: RowDescriptor, // Mutation context row descriptor
   ) {
     super(scope);
   }
@@ -63,7 +66,10 @@ export class DmlExecutorNode extends PlanNode implements RelationalPlanNode {
       newSource as RelationalPlanNode,
       this.table,
       this.operation,
-      this.onConflict
+      this.onConflict,
+      this.mutationContextValues,
+      this.contextAttributes,
+      this.contextDescriptor
     );
   }
 

package/src/planner/validation/determinism-validator.ts

@@ -0,0 +1,104 @@
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import type { ScalarPlanNode } from '../nodes/plan-node.js';
+import { createLogger } from '../../common/logger.js';
+
+const log = createLogger('planner:validation:determinism');
+
+/**
+ * Result of determinism validation. If valid, `error` is undefined.
+ * If invalid, contains the information needed to construct an error message.
+ */
+export interface DeterminismValidationResult {
+	/** True if the expression is deterministic */
+	valid: boolean;
+	/** String representation of the offending expression (if invalid) */
+	expression?: string;
+}
+
+/**
+ * Checks if an expression is deterministic (suitable for constraints and defaults).
+ * Returns a result object instead of throwing, allowing the caller to decide how to handle.
+ *
+ * @param expr The expression plan node to check
+ * @returns Validation result indicating if deterministic
+ */
+export function checkDeterministic(expr: ScalarPlanNode): DeterminismValidationResult {
+	const physical = expr.physical;
+
+	if (physical.deterministic === false) {
+		log('Non-deterministic expression detected: %s', expr.toString());
+		return {
+			valid: false,
+			expression: expr.toString()
+		};
+	}
+
+	return { valid: true };
+}
+
+/**
+ * Validates that an expression is deterministic (suitable for constraints and defaults).
+ * Non-deterministic expressions must be passed via mutation context instead.
+ *
+ * @param expr The expression plan node to validate
+ * @param context Description of where the expression is used (e.g., "DEFAULT for column 'created_at'")
+ * @throws QuereusError if the expression is non-deterministic
+ */
+export function validateDeterministicExpression(
+	expr: ScalarPlanNode,
+	context: string
+): void {
+	log('Validating determinism for: %s', context);
+
+	const result = checkDeterministic(expr);
+
+	if (!result.valid) {
+		throw new QuereusError(
+			`Non-deterministic expression not allowed in ${context}. ` +
+			`Expression: ${result.expression}. ` +
+			`Use mutation context to pass non-deterministic values (e.g., WITH CONTEXT (timestamp = datetime('now'))).`,
+			StatusCode.ERROR
+		);
+	}
+
+	log('Expression is deterministic: %s', expr.toString());
+}
+
+/**
+ * Validates that a CHECK constraint expression is deterministic.
+ *
+ * @param expr The constraint expression plan node
+ * @param constraintName The name of the constraint (for error messages)
+ * @param tableName The name of the table (for error messages)
+ * @throws QuereusError if the expression is non-deterministic
+ */
+export function validateDeterministicConstraint(
+	expr: ScalarPlanNode,
+	constraintName: string,
+	tableName: string
+): void {
+	validateDeterministicExpression(
+		expr,
+		`CHECK constraint '${constraintName}' on table '${tableName}'`
+	);
+}
+
+/**
+ * Validates that a DEFAULT expression is deterministic.
+ *
+ * @param expr The default value expression plan node
+ * @param columnName The name of the column (for error messages)
+ * @param tableName The name of the table (for error messages)
+ * @throws QuereusError if the expression is non-deterministic
+ */
+export function validateDeterministicDefault(
+	expr: ScalarPlanNode,
+	columnName: string,
+	tableName: string
+): void {
+	validateDeterministicExpression(
+		expr,
+		`DEFAULT for column '${columnName}' in table '${tableName}'`
+	);
+}

package/src/runtime/async-util.ts

@@ -5,6 +5,7 @@
 
 import type { MaybePromise, Row } from '../common/types.js';
 import { createLogger } from '../common/logger.js';
+import { getAsyncIterator } from './utils.js';
 
 const log = createLogger('runtime:async-util');
 
@@ -52,7 +53,7 @@ export function tee<T>(src: AsyncIterable<T>): [AsyncIterable<T>, AsyncIterable<
 		}
 
 		if (!srcIterator) {
-			srcIterator = src[Symbol.asyncIterator]();
+			srcIterator = getAsyncIterator(src);
 		}
 
 		while (buffer.length <= targetIndex && !srcDone) {
@@ -124,7 +125,7 @@ export async function* buffered<T>(
 	maxBuffer: number
 ): AsyncIterable<T> {
 	const buffer: T[] = [];
-	const srcIterator = src[Symbol.asyncIterator]();
+	const srcIterator = getAsyncIterator(src);
 	let srcDone = false;
 	let fillPromise: Promise<void> | null = null;
 
@@ -217,7 +218,7 @@ export async function collect<T>(src: AsyncIterable<T>): Promise<T[]> {
  * Items are yielded as soon as they become available from any source
  */
 export async function* merge<T>(...sources: AsyncIterable<T>[]): AsyncIterable<T> {
-	const iterators = sources.map(src => src[Symbol.asyncIterator]());
+	const iterators = sources.map(src => getAsyncIterator(src));
 	const pending = new Map<number, Promise<IteratorResult<T>>>();
 
 	// Start initial reads

package/src/runtime/emit/add-constraint.ts

@@ -31,6 +31,9 @@ export function emitAddConstraint(plan: AddConstraintNode, _ctx: EmissionContext
 		}
 
 		// Create the constraint schema object
+		// Note: We don't validate determinism here because constraints may reference NEW/OLD
+		// which require special scoping. Determinism is validated at INSERT/UPDATE plan time
+		// in constraint-builder.ts when the constraint is actually checked.
 		const constraintSchema: RowConstraintSchema = {
 			name: constraint.name || `check_${tableSchema.checkConstraints.length}`,
 			expr: constraint.expr,