Module: sql - Bijection

Classes

Type Aliases

ApproximateValue

Ƭ ApproximateValue<T, Kind>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`Kind`	extends `"relative"` \| `"rank"`

Type declaration

Name	Type
`estimate`	`T`
`accuracy`	{ `kind`: `Kind` ; `error`: `number` ; `confidence`: `number` }
`accuracy.kind`	`Kind`
`accuracy.error`	`number`
`accuracy.confidence`	`number`

MeasuredValue

Ƭ MeasuredValue<M>: M extends { [measureValue]: [infer V, boolean] } ? V : never Not exported: an exported type refers to it.

Type parameters

Name
`M`

DecimalMeasure

Ƭ DecimalMeasure<M>: M extends { [measureValue]: [unknown, true] } ? true : false Not exported: an exported type refers to it.

Type parameters

Name
`M`

GroupMeasure

Ƭ GroupMeasure<M>: M extends { kind: "approx_count_distinct" } ? ApproximateValue<number, "relative"> : M extends { kind: "approx_percentile" } ? ApproximateValue<MeasuredValue<M> | null, "rank"> : M extends { kind: "count" | "count_distinct" } ? bigint : M extends { kind: StatisticalMeasure } ? number | null : M extends { kind: "collect" } ? readonly Exclude<MeasuredValue<M>, null | undefined>[] : M extends { kind: "average" } ? Exclude<MeasuredValue<M>, null | undefined> extends number ? number | null : string | null : M extends { kind: "decimal_sum" } ? string : M extends { kind: "min" | "max" } ? Exclude<MeasuredValue<M>, undefined> | null : DecimalMeasure<M> extends true ? string : M extends { kind: "sum" } ? Exclude<RelationSum<MeasuredValue<M>>, undefined> : MeasuredValue<M> Not exported: an exported type refers to it.

Type parameters

Name
`M`

Expand

Ƭ Expand<T>: T extends infer O ? { [K in keyof O]: O[K] } : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

PerParentMeasures

Ƭ PerParentMeasures<M>: Expand<{ -readonly [K in keyof M as M[K] extends Object ? never : K]: M[K] extends Object ? Exclude<RelationSum<MeasuredValue<M[K]>>, undefined> : GroupMeasure<M[K]> } & { [K in keyof M as M[K] extends Object ? K : never]?: Exclude<GroupMeasure<M[K]>, undefined> }> Not exported: an exported type refers to it.

Type parameters

Name
`M`

FlinkOptions

Ƭ FlinkOptions: Options & { delivery?: "boundary" | "continuous" } Not exported: an exported type refers to it.

FlinkColumn

Ƭ FlinkColumn: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`name`	`string`
`type`	`string`
`nullable`	`boolean`
`presence?`	`true`

FlinkProject

Ƭ FlinkProject: Readonly<{ name: string ; artifact: Readonly<{ kind: "file" ; path: string ; sha256: string }> ; runtime_digest: string ; toolchain?: unknown ; sources: Readonly<Record<string, Readonly<{ mode?: "append" | "current_state" | "fixed_snapshot" | "refreshable_snapshot" ; contract_digest: string ; columns: readonly FlinkColumn[] ; key?: readonly string[] ; event_time?: unknown }>>> ; sinks: Readonly<Record<string, Readonly<{ mode: "append" | "upsert" ; columns: readonly FlinkColumn[] ; key?: readonly string[] ; deletes?: "existing" | "any" ; late_of?: string }>>> ; compatibility?: unknown }> A Flink project’s generated specification (_generated/flink/<alias>.ts).

MaterializeScalar

Ƭ MaterializeScalar: "string" | "int64" | "float64" | "boolean" Not exported: an exported type refers to it.

MaterializeProject

Ƭ MaterializeProject: Readonly<{ name: string ; artifact: Readonly<{ kind: "file" ; path: string ; sha256: string }> ; runtimeDigest: string ; toolchain?: unknown ; sources: Readonly<Record<string, { schema: Record<string, MaterializeScalar> }>> ; outputs: Readonly<Record<string, { schema: Record<string, MaterializeScalar> ; relation: string ; key: readonly string[] }>> ; policy: Readonly<{ targetIntervalMs: number ; historyMs: number ; maxOutageMs: number ; onHistoryGap: "stop" }> }> A Materialize project’s generated specification.

TemporalGraph

Ƭ TemporalGraph: Readonly<{ program: unknown ; inputs: Readonly<Record<string, GenericValidator>> ; outputs: Readonly<Record<string, GenericValidator>> ; window: Readonly<{ step_us: string ; context_before_us?: string ; context_after_us?: string ; finality: "available" | "settled" }> ; fold?: Readonly<{ state_schema_digest: string ; reset: unknown }> ; runtime?: ProgramArtifact ; equivalence?: Readonly<{ executors: Readonly<Record<string, readonly string[]>> }> }> A temporal graph inferred by temporal.boundary(...), before binding. Its ports are the exact Dataset references its boundary exchanges.

AnalyticalRelationWorkLimits

Ƭ AnalyticalRelationWorkLimits: Readonly<{ profile: "analytical" ; maxRowSteps: number ; maxProcessedBytes: number }>

RetainedRelationWorkLimits

Ƭ RetainedRelationWorkLimits: RelationWorkLimits | AnalyticalRelationWorkLimits

RelationalEngine

Ƭ RelationalEngine: typeof RELATIONAL_ENGINES[number]

RelationalPlanOptions

Ƭ RelationalPlanOptions: Object

Type declaration

Name	Type	Description
`context?`	`ProgramContextReads`	Omission leaves contextual reads unknown and prevents adoption.
`requirements?`	`ExecutionRequirements`	Environment and capacity the executing worker needs, beyond its engine. Compute adds the selected engine’s `relational:<engine>` feature.
`replay?`	`"deterministic"`	A captured plan is a pure function of its exact inputs: declaring deterministic replay lets Compute replace a lost job attempt.
`cost?`	`RelationalCostLimits`	Per-run provider cost limits. Compute runs the plan only on an engine whose provider enforces every declared limit itself (`RELATIONAL_COST_ENFORCEMENT`); other engines are refused at admission.

RelationalCostLimits

Ƭ RelationalCostLimits: Object One declarative per-run cost policy. billedBytes bounds the bytes the provider bills for the whole run; statementDuration bounds each statement the engine runs; totalStatementDuration bounds the summed duration of the run’s statements, each stopped by the provider at what remains of it. None is a run deadline or a cluster size: those are requirements.limits (duration, memory.workers) of the execution host.

Type declaration

Name	Type
`billedBytes?`	`bigint` \| `string`
`statementDuration?`	`ReadDuration`
`totalStatementDuration?`	`ReadDuration`

RelationalInputs

Ƭ RelationalInputs<Args>: { [K in keyof Args]: Infer<Args[K]> extends ResultRef<infer Row, “dataset”> ? RowRelation<Row> : Scalar<Infer<Args[K]>, K & string> } Each dataset argument is a relation over its rows; every other argument is a typed scalar of the plan.

Type parameters

Name	Type
`Args`	extends `PropertyValidators`

RelationalHandler

Ƭ RelationalHandler: Object A job-only adapter: a captured relational plan.

Type declaration

Name	Type
`kind`	`"relational"`
`protocols`	readonly [`"job"`]

SQLKernelProgram

Ƭ SQLKernelProgram: Readonly<{ kind: "lambda_binding" | "regex" | "java_regex" | "geometry" | "spatial" | "geometry_union" | "occurrence" | "numeric" | "collection" | "scalar" ; id: string ; program: string }> Not exported: an exported type refers to it.

RelationalCapability

Ƭ RelationalCapability: RELATIONAL_CAPABILITIES[number]

RelationalArgument

Ƭ RelationalArgument: Omit<TransformationColumn, "name">

RelationalPlan

Ƭ RelationalPlan: Omit<AnalyzedRelation, "expression" | "arguments" | "input_contracts" | "columns" | "closed_types" | "carrier"> & { expression: RelationExpression ; arguments: Record<string, RelationalArgument> ; input_contracts: TransformationSchemas ; columns: TransformationColumn[] ; closed_types: ClosedTypes ; carrier: CarrierPlan } The customer authoring facade narrows transport shapes to its dataset types. Identities, operations, scopes and obligations come from generated core types.

ScalarType

Ƭ ScalarType: Omit<TransformationColumn, "name" | "type"> & { type: TransformationColumn["type"] | "null" | "missing" } Not exported: an exported type refers to it.

ClockObservation

Ƭ ClockObservation: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`every_ms`	`number`
`at_ms`	`number`
`valid_until_ms`	`number`

ColumnHeader

Ƭ ColumnHeader: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`key`	`string`
`name`	`string`

ScalarFailureCode

JsonValue

Ƭ JsonValue: number | string | boolean | JsonValue[] | { [key in string]?: JsonValue } | null Not exported: an exported type refers to it.

SpatialOperation

SpatialEvaluation

Ƭ SpatialEvaluation: Object

Type declaration

Name	Type
`operation`	`SpatialOperation`
`space`	`GeometrySpace`
`operands`	`JsonValue`[]
`allowance?`	`GeometryAllowance`

InterpolationMode

OccurrenceSourceIdentity

Ƭ OccurrenceSourceIdentity: { kind: "content" } | { kind: "native_locator" ; table: string } Not exported: an exported type refers to it.

Finite

Ƭ Finite: number Not exported: an exported type refers to it.

CoordinateMap

Ƭ CoordinateMap: Object

Type declaration

Name	Type
`pipeline`	`string`
`resources`	{ [key in string]?: string }
`source_extent`	[`Finite`, `Finite`, `Finite`, `Finite`] \| `null`
`target_extent`	[`Finite`, `Finite`, `Finite`, `Finite`] \| `null`

GeometryOperand

Ƭ GeometryOperand: "geometry" | "point" | "metres" Not exported: an exported type refers to it.

GeometryResult

Ƭ GeometryResult: "geometry" | "same" | "point" | "polygons" | "number" Not exported: an exported type refers to it.

GeometryOperatorDescription

Ƭ GeometryOperatorDescription: Object

Type declaration

Name	Type
`id`	`string`
`operands`	`GeometryOperand`[]
`result`	`GeometryResult`

BufferCap

Ƭ BufferCap: "round" | "square" | "flat" Not exported: an exported type refers to it.

BufferJoin

Ƭ BufferJoin: "round" | "mitre" | "bevel" Not exported: an exported type refers to it.

Overlay

Ƭ Overlay: "intersection" | "union" | "difference" | "symmetric_difference" Not exported: an exported type refers to it.

GeometryOperation

Ƭ GeometryOperation: { kind: "buffer" ; cap: BufferCap ; join: BufferJoin ; quadrant_segments: number } | { kind: "simplify" } | { kind: "centroid" } | { kind: "standardize" } | { kind: "bijection_hull" } | { kind: "boundary" } | { kind: "area" } | { kind: "length" } | { kind: "perimeter" } | { kind: "overlay" ; operation: Overlay } | { kind: "transform" ; target: GeometrySpace ; mapping: CoordinateMap } | { kind: "ground_projection" } | { kind: "affine_3d" ; matrix: [[Finite, Finite, Finite, Finite], [Finite, Finite, Finite, Finite], [Finite, Finite, Finite, Finite]] } | { kind: "destination" ; bearing_degrees: Finite ; distance_m: Finite }

GeometryDeclaration

Ƭ GeometryDeclaration: Object

Type declaration

Name	Type
`space`	`GeometrySpace`
`size`	`GeometrySize`

GeometryAllowance

Ƭ GeometryAllowance: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`steps`	`number`
`allocated_bytes`	`number`

GeometryRequest

Ƭ GeometryRequest: { operation: "supports" ; operator: GeometryOperation ; space: GeometrySpace ; allowance?: GeometryAllowance } | { operation: "evaluate" ; operator: GeometryOperation ; value: JsonValue ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "measure" ; measurement: Measurement ; value: JsonValue ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "segment_distance" ; space: GeometrySpace ; left: [[number, number], [number, number]] ; right: [[number, number], [number, number]] ; allowance?: GeometryAllowance } | { operation: "geodesic_position" ; start: [number, number] ; end: [number, number] ; fraction: number ; allowance?: GeometryAllowance } | { operation: "bearing" ; from: [number, number] ; to: [number, number] ; allowance?: GeometryAllowance } | { operation: "bounding_cap" ; value: JsonValue ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "local_frame" ; space: GeometrySpace ; centre: [number, number] ; positions: [number, number][] ; allowance?: GeometryAllowance } | { operation: "simplify_trajectory" ; runs: [number, number][][] ; tolerance_m: number ; max_points: number ; allowance?: GeometryAllowance } | { operation: "union" ; values: JsonValue[] ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "from_planar" ; value: JsonValue ; declaration: GeometryDeclaration ; tolerance_m: number ; allowance?: GeometryAllowance } | { operation: "to_planar" ; value: JsonValue ; declaration: GeometryDeclaration ; tolerance_m: number ; allowance?: GeometryAllowance } | { operation: "admit" ; value: JsonValue ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "admit_position" ; value: JsonValue ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "ground_projection" ; value: JsonValue ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "encode" ; value: JsonValue ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance } | { operation: "decode" ; bytes: number[] ; declaration: GeometryDeclaration ; allowance?: GeometryAllowance }

TrajectorySimplification

Ƭ TrajectorySimplification: Object

Type declaration

Name	Type
`tolerance_m`	`number`
`kept`	`number`[][]

Measurement

Ƭ Measurement: "area" | "length" | "perimeter" Not exported: an exported type refers to it.

ScalarOrder

Ƭ ScalarOrder: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`value`	`ScalarId`
`descending`	`boolean`

NormalizedMeasure

Ƭ NormalizedMeasure: { kind: "aggregate" ; operation: AggregateOperation ; value: ScalarId | null ; second: ScalarId | null ; scale: number | null } | { kind: "count_distinct" ; value: ScalarId } | { kind: "collect" ; value: ScalarId ; distinct: boolean ; order: ScalarOrder[] ; max_items: number ; max_bytes: number } | { kind: "sum" ; value: ScalarId } | { kind: "decimal_sum" ; value: ScalarId ; scale: number } | { kind: "minimum" ; value: ScalarId } | { kind: "maximum" ; value: ScalarId } | { kind: "average" ; value: ScalarId ; scale?: number | null } | { kind: "percentile" ; value: ScalarId ; basis_points: number ; decimal_scale: number | null } Not exported: an exported type refers to it.

NormalizedWindow

Ƭ NormalizedWindow: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`order`	`ScalarOrder`[]
`rows`	`number`

CarrierPlan

Ƭ CarrierPlan: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`columns`	`ColumnSource`[]
`references`	(`ColumnReference` \| `null`)[]
`fields`	`ResolvedField`[]

GeometrySize

Ƭ GeometrySize: "standard" | "large" Not exported: an exported type refers to it.

WireDomain

Ƭ WireDomain: { type: "string" } | { type: "reference" ; table: string } | { type: "binary" } | { type: "long" } | { type: "short" } | { type: "int" } | { type: "boolean" } | { type: "double" } | { type: "ieee_double" } | { type: "float" } | { type: "ieee_float" } | { type: "date" } | { type: "timestamp" } | { type: "timestamp_ntz" } | { type: "null" } | { type: "missing" } | { type: "decimal" ; precision: number ; scale: number } | { type: "geometry" ; geometrySpace: GeometrySpace ; geometryTypes: GeometryKind[] } | { type: "position" ; geometrySpace: GeometrySpace } | { type: "struct" ; fields: WireColumn[] } | { type: "list" ; element: WireShape } | { type: "map" ; key: WireShape ; value: WireShape } | { type: "entry_map" ; key: WireShape ; value: WireShape } Not exported: an exported type refers to it.

ClosedTypes

Ƭ ClosedTypes: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`columns`	`WireShape`[]
`scalars`	`WireShape`[]
`fields`	`WireShape`[]

NodeId

Ƭ NodeId: number Not exported: an exported type refers to it.

ColumnId

Ƭ ColumnId: number Not exported: an exported type refers to it.

ScalarId

Ƭ ScalarId: number Not exported: an exported type refers to it.

Guard

Ƭ Guard: { kind: "boolean" ; scalar: ScalarId ; is_true: boolean } | { kind: "absent" ; scalar: ScalarId } Not exported: an exported type refers to it.

Population

Ƭ Population: { kind: "invocation" ; node: NodeId } | { kind: "left_input" ; node: NodeId } | { kind: "right_input" ; node: NodeId } | { kind: "input" ; node: NodeId } | { kind: "output" ; node: NodeId } | { kind: "group_members" ; node: NodeId } | { kind: "join_candidates" ; node: NodeId } | { kind: "array_elements" ; node: NodeId ; scalar: ScalarId } Not exported: an exported type refers to it.

EvaluationScope

Ƭ EvaluationScope: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`population`	`Population`
`guard`	`Guard`[]

ColumnReference

Ƭ ColumnReference: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`column`	`ColumnId`
`path`	`string`[]

SqlCollation

ConditionalBranch

Ƭ ConditionalBranch: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`condition`	`ScalarId`
`value`	`ScalarId`

OffsetPrecision

Ƭ OffsetPrecision: "minutes" | "seconds" Not exported: an exported type refers to it.

TimestampFormatError

Ƭ TimestampFormatError: { reason: "offset_precision" ; offset_seconds: number ; offset_precision: OffsetPrecision } | { reason: "offset_range" ; offset_seconds: number } | { reason: "fraction_precision" ; fraction_digits: number } | { reason: "local_date_range" } Not exported: an exported type refers to it.

CollectionBound

Ƭ CollectionBound: "items" | "bytes" Not exported: an exported type refers to it.

CollectionTooLarge

Ƭ CollectionTooLarge: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`bound`	`CollectionBound`
`limit`	`number`
`observed`	`number`

ScalarExpression

Ƭ ScalarExpression: { kind: "array" ; operation: ArrayOperation ; input: ScalarId ; body: ScalarId ; initial: ScalarId | null } | { kind: "array_binding" ; owner: ScalarId ; binding: ArrayBinding ; path: string[] } | { kind: "native" ; operation: NativeOperation ; arguments: ScalarId[] } | { kind: "read" ; port: string ; arguments: { [key in string]?: ScalarId } } | { kind: "field" ; reference: ColumnReference } | { kind: "argument" ; name: string } | { kind: "literal" ; value: LiteralValue } | { kind: "apply" ; operation: ScalarOperation ; arguments: ScalarId[] } | { kind: "case" ; branches: ConditionalBranch[] ; otherwise: ScalarId } | { kind: "membership" ; value: ScalarId ; members: LiteralValue[] } | { kind: "timestamp" ; operation: TimestampOperation ; value: ScalarId } Not exported: an exported type refers to it.

ScalarArena

Ƭ ScalarArena: { id: ScalarId ; value_type: LogicalValueType ; scope: EvaluationScope ; expression: ScalarExpression }[] Not exported: an exported type refers to it.

LogicalColumn

Ƭ LogicalColumn: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`id`	`ColumnId`
`name`	`string`
`value_type`	`LogicalValueType`
`source`	`ColumnSource`

ColumnSource

Ƭ ColumnSource: { kind: "relation_row" ; node: NodeId } | { kind: "row" ; fields: [string, ColumnReference][] } | { kind: "input" ; field: string } | { kind: "field" ; reference: ColumnReference } | { kind: "scalar" ; value: ScalarId } | { kind: "union" ; left: ColumnId ; right: ColumnId } | { kind: "aggregate" ; operation: AggregateOperation ; input: ColumnReference | null ; second: ColumnReference | null ; scale: number | null ; collection: CollectionPlan | null } | { kind: "element" } | { kind: "row_number" } | { kind: "nearest" ; reference: ColumnReference | null } | { kind: "window" ; operation: WindowOperation } Not exported: an exported type refers to it.

WindowOperation

Ƭ WindowOperation: { kind: "row_number" } | { kind: "rank" } | { kind: "dense_rank" } | { kind: "percent_rank" } | { kind: "cume_dist" } | { kind: "ntile" ; buckets: number } | { kind: "lag" ; input: ColumnReference ; offset: number } | { kind: "lead" ; input: ColumnReference ; offset: number } | { kind: "first" ; input: ColumnReference } | { kind: "last" ; input: ColumnReference } | { kind: "nth" ; input: ColumnReference ; position: number ; ignore_nulls: boolean } | { kind: "collect" ; input: ColumnReference ; distinct: boolean ; order: SortKey[] ; max_items: number ; max_bytes: number } | { kind: "aggregate" ; operation: AggregateOperation ; input: ColumnReference | null ; second: ColumnReference | null ; scale: number | null } Not exported: an exported type refers to it.

FrameExclusion

Ƭ FrameExclusion: "no_others" | "current_row" | "group" | "ties" Not exported: an exported type refers to it.

CollectionPlan

Ƭ CollectionPlan: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`distinct`	`boolean`
`order`	`SortKey`[]
`max_items`	`number`
`max_bytes`	`number`

SortKey

Ƭ SortKey: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`value`	`ColumnReference`
`descending`	`boolean`

RelationOperator

Ƭ RelationOperator: { kind: "unit" } | { kind: "empty" } | { kind: "fixed_point" ; binding: string ; quantifier: RecursionQuantifier } | { kind: "recursive_input" ; binding: string } | { kind: "scan" ; port: string ; arguments: { [key in string]?: ScalarId } ; occurrence: OccurrenceSourceIdentity } | { kind: "alias" ; name: string } | { kind: "filter" ; predicate: ScalarId } | { kind: "assert" ; name: string ; predicate: ScalarId } | { kind: "select" ; fields: { [key in string]?: ScalarId } } | { kind: "extend" ; fields: { [key in string]?: ScalarId } } | { kind: "compute" ; bindings: { [key in string]?: [ColumnId, ScalarId] } } | { kind: "unnest" ; value: ScalarId ; alias: string } | { kind: "union_all" } | { kind: "join" ; join: JoinKind ; keys: [ScalarId, ScalarId][] ; equality: KeyEquality ; cardinality: JoinCardinality ; candidate: ColumnId ; predicate: ScalarId | null ; nearest: NearestSelection<ScalarId> | null } | { kind: "lateral" ; join: JoinKind ; cardinality: JoinCardinality } | { kind: "group" ; keys: { [key in string]?: ScalarId } ; measures: { [key in string]?: NormalizedMeasure } ; empty: EmptyGroup ; window: NormalizedWindow | null } | { kind: "order" ; order: ScalarOrder[] } | { kind: "take" ; count: number } | { kind: "rank" ; partition: ScalarId[] ; order: ScalarOrder[] ; field: string ; ties: OrderingTies } | { kind: "deduplicate" ; key: ScalarId[] ; order: ScalarOrder[] ; ties: OrderingTies } | { kind: "window" ; partition: ScalarId[] ; order: ScalarOrder[] ; frame: WindowFrame ; measures: { [key in string]?: WindowMeasure } ; ties: OrderingTies } | { kind: "temporal" ; operation: TemporalKind ; alias: string ; source: ScalarId ; from: ScalarId ; to: ScalarId ; max_gap: ScalarId ; region: ScalarId | null } Not exported: an exported type refers to it.

TypedNode

Ƭ TypedNode: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`id`	`NodeId`
`row`	`ColumnId`
`inputs`	`NodeId`[]
`operator`	`RelationOperator`
`columns`	`ColumnId`[]

TypedRelation

Ƭ TypedRelation: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`fields`	`ResolvedField`[]
`root`	`NodeId`
`nodes`	`TypedNode`[]
`scalars`	`ScalarArena`
`columns`	`LogicalColumn`[]
`node_paths`	{ [key in string]?: NodeId }
`scalar_paths`	{ [key in string]?: ScalarId }

ResolvedField

Ƭ ResolvedField: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`reference`	`ColumnReference`
`value_type`	`LogicalValueType`

SemanticCheck

SemanticObligation

Ƭ SemanticObligation: Object

Type declaration

Name	Type
`id`	`string`
`node`	`NodeId`
`scalar`	`ScalarId` \| `null`
`column`	`ColumnId` \| `null`
`scope`	`EvaluationScope`
`check`	`SemanticCheck`

Multiplicity

Ƭ Multiplicity: "bag" | "set" Not exported: an exported type refers to it.

KeyEvidence

Ƭ KeyEvidence: "derived" | "asserted" Not exported: an exported type refers to it.

KeyContract

Ƭ KeyContract: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`fields`	`ColumnReference`[]
`evidence`	`KeyEvidence`

RelationContract

Ƭ RelationContract: Object

Type declaration

Name	Type
`row_type`	`LogicalValueType`
`columns`	`ColumnContract`[]
`multiplicity`	`Multiplicity`
`ordering`	`OrderingContract` \| `null`
`keys`	`KeyContract`[]
`occurrence`	`OccurrenceContract`

OccurrenceContract

Ƭ OccurrenceContract: { kind: "source" ; population: NodeId } | { kind: "derived" ; population: NodeId } Not exported: an exported type refers to it.

OrderingContract

Ƭ OrderingContract: { kind: "expressions" ; population: NodeId ; keys: ScalarOrder[] ; ties: OrderingTies } | { kind: "source" ; population: NodeId ; port: string } Not exported: an exported type refers to it.

OrderId

Ƭ OrderId: number Not exported: an exported type refers to it.

RelationProperties

Ƭ RelationProperties: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`ordering`	`OrderId` \| `null`
`occurrence`	`OccurrenceContract`

OrderingTies

Ƭ OrderingTies: "error" | "complete_row" | "occurrence" Not exported: an exported type refers to it.

ColumnContract

Ƭ ColumnContract: Object

Type declaration

Name	Type
`id`	`ColumnId`
`name`	`string`
`value_type`	`LogicalValueType`

SqlSourcePosition

Ƭ SqlSourcePosition: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`line`	`number`
`column`	`number`

SqlSourceSpan

Ƭ SqlSourceSpan: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`language`	`string`
`declaration?`	`string`
`start`	`SqlSourcePosition`
`end`	`SqlSourcePosition`

AnalyzedRelation

Ƭ AnalyzedRelation: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`source_map`	{ [key in string]?: SqlSourceSpan }
`version`	`number`
`clock_intervals`	`number`[]
`admission_time_required`	`boolean`
`profile`	`string`
`profile_data`	`SemanticProfile`
`definition`	`NormalizedDefinition`
`expression`	`JsonValue`
`input_contracts`	`JsonValue`
`arguments`	`JsonValue`
`inputs`	`string`[]
`columns`	`WireColumn`[] \| `null`
`header`	`ColumnHeader`[]
`capabilities`	`string`[]
`operation_requirements`	`OperationRequirement`[]
`output_population`	`boolean`
`contract`	`RelationContract`
`orders`	`OrderingContract`[]
`properties`	`RelationProperties`[]
`ir`	`TypedRelation`
`carrier`	`CarrierPlan` \| `null`
`closed_types`	`ClosedTypes` \| `null`
`obligations`	`SemanticObligation`[]
`definition_id`	`string`

ValidationClaim

Ƭ ValidationClaim: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`scope`	`EvaluationScope`
`requirement`	`SemanticCheck`
`scalar`	`ScalarId` \| `null`
`columns`	`ColumnId`[]

Kernel

Ƭ Kernel: "portable_checked" Not exported: an exported type refers to it.

ImplementationRule

Ƭ ImplementationRule: "typed_contract" Not exported: an exported type refers to it.

Discharge

Ƭ Discharge: { obligation_id: string } & { by: "check" ; check: number } | { by: "lowering" ; rule: ImplementationRule } | { by: "kernel" ; kernel: Kernel ; profile: string } Not exported: an exported type refers to it.

SQLPlacementInspection

Ƭ SQLPlacementInspection: { state: "refused" ; requirement: string ; node: string ; reason: string } | { state: "requires_preparation" ; lowering: "supported" ; inputs: Record<string, readonly string[]> ; runtime_profiles: readonly { id: string ; revision: string }[] } | { state: "admitted" ; lowering: "supported" ; expires_at: string ; program: TransformationSQL }

SQLQuery

Ƭ SQLQuery: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`sql`	`string`
`dependencies`	`number`[]

SQLRuntimeWindow

Ƭ SQLRuntimeWindow: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`kind`	`"spark_range"`
`node`	`string`
`coordinate_kind`	`string`
`descending`	`boolean`
`exclude`	`FrameExclusion`
`start`	`RangeOffset` \| `null`
`end`	`RangeOffset` \| `null`
`max_rows`	`number`
`max_spill_bytes`	`number`
`max_record_bytes`	`number`
`max_frame_work`	`number`
`measures`	{ `kind`: `string` ; `second_kind`: `string` ; `operation`: `string` ; `parameter`: `number` }[]

SQLDefinition

Ƭ SQLDefinition: SQLQuery & { name: string ; runtime?: SQLRuntimeWindow | SQLRuntimeMaterialization } Not exported: an exported type refers to it.

SQLRuntimeMaterialization

Ƭ SQLRuntimeMaterialization: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`kind`	`"spark_materialized"`
`node`	`string`
`max_rows`	`number`
`max_key_bytes`	`number`
`bytes_field`	`string`

Row

Ƭ Row: Record<string, any> Not exported: an exported type refers to it.

CompiledRelationInputs

Ƭ CompiledRelationInputs: Readonly<Record<string, readonly Row[]>>

CompiledRelation

Ƭ CompiledRelation<T>: Object

Type parameters

Name
`T`

Type declaration

Name	Type
`expression`	`RelationExpression`
`plan`	`RelationalPlan`
`inputs`	`Readonly`<`Record`<`string`, `string`>>
`inspect`	(`parameters?`: `Record`<`string`, `Value`>, `clocks?`: readonly `ClockObservation`[], `admissionTimeMicros?`: `bigint`) => `void`
`evaluate`	(`inputs`: `CompiledRelationInputs`, `parameters?`: `Record`<`string`, `Value`>, `clocks?`: readonly `ClockObservation`[], `admissionTimeMicros?`: `bigint`) => `RelationRow`<`T`>[]

Digest

Ƭ Digest: `sha256:${string}` Not exported: an exported type refers to it.

Toolchain

Ƭ Toolchain: Readonly<{ compilerManifest: Digest ; sourceDigest: Digest ; executionProfile: Digest }> Not exported: an exported type refers to it.

CapturedArtifact

Ƭ CapturedArtifact: Readonly<{ kind: "file" ; path: string ; sha256: string }> Not exported: an exported type refers to it.

CapturedNode

Ƭ CapturedNode: Readonly<{ node: string ; path: string ; dependencies?: readonly string[] ; materialization?: string | null ; selfReference?: boolean ; custom?: { name: string ; path: string ; class: string } | null ; hooks?: Readonly<Record<string, readonly string[]>> | null ; python?: boolean ; parent?: string | null ; group?: boolean ; name?: string ; severity?: string ; columns?: Readonly<Record<string, string | null>> }> Not exported: an exported type refers to it.

Nodes

Ƭ Nodes: Readonly<Record<string, CapturedNode>> Not exported: an exported type refers to it.

DbtSpecification

Ƭ DbtSpecification: Readonly<{ toolchain: Toolchain ; name: string ; engine: string ; artifact: CapturedArtifact ; models: Nodes ; sources: Readonly<Record<string, CapturedNode & { name: string }>> ; tests: Nodes ; hooks?: readonly string[] }> The generated specification of a captured dbt project.

SqlProjectSpecification

Ƭ SqlProjectSpecification: Readonly<{ toolchain: Toolchain ; name: string ; engine: string ; artifact: CapturedArtifact ; interface: Readonly<{ models: Nodes ; sources: Nodes ; checks: Nodes }> }> The generated specification of a captured SQLMesh or Dataform project.

Role

Ƭ Role: "model" | "source" | "check" Not exported: an exported type refers to it.

FrameworkNode

Ƭ FrameworkNode<R>: Readonly<{ kind: SqlFrameworkKind ; project: string ; role: R ; node: string }> A generated reference to one node of one captured project.

Type parameters

Name	Type
`R`	extends `Role` = `Role`

FrameworkRuntime

Ƭ FrameworkRuntime: Readonly<{ id: string ; revision: string }> An installed runtime profile (bijection.integration.<kind>).

References

Ƭ References<Keys, R>: { readonly [Key in Keys]: FrameworkNode<R> } Not exported: an exported type refers to it.

Type parameters

Name	Type
`Keys`	extends `PropertyKey`
`R`	extends `Role`

DbtName

Ƭ DbtName<Key, Project>: Key extends `

\{string}.

{Project}.

\{infer Name}\` ? `Name` : `Key` extends \`

{string}.${infer Qualified}` ? Qualified : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`Key`	`Key`
`Project`	extends `string`

DbtProject

Ƭ DbtProject<Spec>: Readonly<{ kind: "dbt" ; name: Spec["name"] ; engine: Spec["engine"] ; runtime: FrameworkRuntime ; models: References<DbtName<keyof Spec["models"], Spec["name"]>, "model"> ; sources: References<Spec["sources"][keyof Spec["sources"]]["name"], "source"> ; checks: References<DbtName<keyof Spec["tests"], Spec["name"]>, "check"> }>

Type parameters

Name	Type
`Spec`	extends `DbtSpecification`

SqlProject

Ƭ SqlProject<Kind, Spec>: Readonly<{ kind: Kind ; name: Spec["name"] ; engine: Spec["engine"] ; runtime: FrameworkRuntime ; models: References<keyof Spec["interface"]["models"], "model"> ; sources: References<keyof Spec["interface"]["sources"], "source"> ; checks: References<keyof Spec["interface"]["checks"], "check"> }>

Type parameters

Name	Type
`Kind`	extends `"sqlmesh"` \| `"dataform"`
`Spec`	extends `SqlProjectSpecification`

CapturedSqlProject

Ƭ CapturedSqlProject: DbtProject<DbtSpecification> | SqlProject<"sqlmesh" | "dataform", SqlProjectSpecification>

SqlFrameworkBinding

Ƭ SqlFrameworkBinding<Project>: Object How a function binds its captured project.

Type parameters

Name	Type
`Project`	extends `CapturedSqlProject`

Type declaration

Name	Type	Description
`inputs`	`Readonly`<`Record`<`string`, `Project`[`"sources"`][keyof `Project`[`"sources"`]]>>	The dataset argument that supplies each source, bound exactly once; the runner loads the argument’s exact version as the source relation. A dbt function binds the sources its selected models and tests read. SQLMesh, Dataform and dbt projects with hooks bind every project source.
`outputs`	`Readonly`<`Record`<`string`, `Project`[`"models"`][keyof `Project`[`"models"`]]>>	The model that produces each dataset field of the returned object. The model’s attached tests, audits or assertions must pass before the reply.
`checks?`	readonly `Project`[`"checks"`][keyof `Project`[`"checks"`]][]	SQLMesh standalone audits evaluated over the complete output group.
`state?`	`Readonly`<`Record`<`string`, `string`>>	The dataset argument carrying each stateful output’s previous accepted result, keyed by output: dbt incremental models and snapshots (restored in the engine as the model’s relation before building), and SQLMesh `INCREMENTAL_BY_UNIQUE_KEY`, `INCREMENTAL_BY_PARTITION`, `INCREMENTAL_BY_TIME_RANGE`, SCD Type 2 and custom models (restored before SQLMesh evaluates the model using its native materialization strategy). Self-referencing SQLMesh models and SCD models require a state binding; Both require an admitted clock. Custom models may bind predecessor state. Dataform incremental models restore their exact previous relation before Dataform chooses its incremental query and model-local hooks. Stateful dbt and Dataform models in the selected closure must be bound outputs. The run is a pure function of its exact arguments. The engine reads it in place.
`clock?`	`string`	The string argument with the admitted instant for dbt snapshots and the SQLMesh execution time. SQLMesh history, self-reference, Python, custom models and model statements require it even on their first evaluation.
`interval?`	`Readonly`<{ `start`: `string` ; `end`: `string` }>	SQLMesh’s explicit planning interval, supplied by two required string arguments containing ISO 8601 dates or instants with UTC offsets.
`requirements?`	`ExecutionRequirements`	Requirements beyond the framework and its engine, which preparation always captures as the features `<kind>` and `warehouse:<engine>`.
`replay?`	`"deterministic"`	Declared deterministic replay, as for `python(...)`.
`context?`	`ProgramContextReads`	Omission leaves contextual reads unknown and prevents adoption.

SQLInputSource

Ƭ SQLInputSource: { kind: "iceberg_snapshot" ; table: string[] ; snapshot_id: string } | { kind: "versioned_table" ; table: string[] ; version: string } | { kind: "iceberg_metadata" ; metadata_location: string ; snapshot_id: string } | { kind: "pinned_table" ; table: string[] } | { kind: "session_view" ; name: string } | { kind: "cte" ; name: string ; definition_id: string } Where an engine scans one exact input. A derived relation of the same plan is a session_view the runner created in the engine session, or a cte composed into the program before it runs.

SQLColumnEncoding

Ƭ SQLColumnEncoding: Object Native values have the exact declared physical type. An optional nullable value additionally needs a non-null boolean presence column.

Type declaration

Name	Type
`column`	`string`
`field`	`string`
`codec`	typeof `RELATIONAL_CARRIER_PROFILE`

SQLRelationEncoding

Ƭ SQLRelationEncoding: readonly SQLColumnEncoding[]

SQLInputReference

Ƭ SQLInputReference: Object One input as the store resolved it: its Dataset and exact accepted version (null for a derived relation of this plan), its logical columns, their physical carriers and the source the engine scans.

Type declaration

Name	Type
`version`	{ `dataset`: `string` ; `id`: `string` } \| `null`
`columns`	readonly `TransformationColumn`[]
`encoding`	`SQLRelationEncoding`
`source`	`SQLInputSource`

SQLReadOwner

Ƭ SQLReadOwner: { kind: "function" ; receipt: string } | { kind: "resource" ; holder: string }

SQLReadContext

Ƭ SQLReadContext: Object

Type declaration

Name	Type	Description
`owner`	`SQLReadOwner`	The actual invoking owner; structural validation grants no read authority.
`attempt_id`	`string`	-
`deadline_at`	`string`	Exact epoch nanoseconds: the attempt’s run deadline.
`admission_time_us?`	`string`	Original owner admission instant, required by admission-time expressions.
`clocks`	readonly `ClockObservation`[]	Exact captured clock observations projected to this SQL region.
`clock_basis`	`RetainedClockBasis` \| `null`	Original Build fact identity, or null for a live tick.
`profile`	{ `dialect`: `TransformationDialect` ; `revision`: `string` ; `settings`: `Readonly`<`Record`<`string`, `string`>> }	-
`profile.dialect`	`TransformationDialect`	-
`profile.revision`	`string`	-
`profile.settings`	`Readonly`<`Record`<`string`, `string`>>	-
`inputs`	`Readonly`<`Record`<`string`, `SQLInputReference`>>	-

SQLContext

Ƭ SQLContext: Readonly<{ timeZone?: string ; collation?: SqlCollation }> Captured SQL defaults, validated by the pinned shared semantic owner.

CapturedSQLContext

Ƭ CapturedSQLContext: Readonly<{ timeZone: string ; collation: SqlCollation }>

Parameter

Ƭ Parameter: Value | Scalar<Value, string> | ArgumentReference<string> Not exported: an exported type refers to it.

RelationOf

Ƭ RelationOf<T>: T extends Relation<infer R> ? R : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

ParameterArguments

Ƭ ParameterArguments<T>: T extends Scalar<any, infer Args> ? Args : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

SQLRelationType

Ƭ SQLRelationType<Inputs, Parameters, Returns>: Object Not exported: an exported type refers to it.

Type parameters

Name
`Inputs`
`Parameters`
`Returns`

Type declaration

Name	Type
`row`	`Returns` extends `GenericValidator` ? `Infer`<`Returns`> : `Record`<`string`, `Value`>
`identity`	`unknown`
`args`	`RelationArgumentNames`<`RelationOf`<`Inputs`[keyof `Inputs`]>> \| `ParameterArguments`<`Parameters`[keyof `Parameters`]>
`problems`	`ViewOperatorProblem`<`RelationOf`<`Inputs`[keyof `Inputs`]>>
`tables`	`RelationExpressionTables`<`RelationOf`<`Inputs`[keyof `Inputs`]>>
`scan`	`never`

SQLBuildSyntax

Ƭ SQLBuildSyntax: Readonly<{ mode: "create" | "replace" | "append" | "merge" | "update" | "delete" ; target: string ; query: string | null ; keys: readonly string[] ; source: ReturnType<typeof sqlRelationSyntax> ; storage?: Readonly<{ provider?: "iceberg" | "parquet" | "avro" ; partition?: ({ column: string ; transform: "identity" | "year" | "month" | "day" | "hour" } | { column: string ; transform: "bucket" ; count: number } | { column: string ; transform: "truncate" ; width: number })[] ; properties?: Record<string, string> }> ; optimization?: Readonly<{ kind: "zorder" ; columns: readonly string[] }> ; defaults?: Readonly<Record<string, string>> ; columns?: Readonly<ReturnType<typeof relationalColumns>> ; changed?: Readonly<{ query: string ; source: ReturnType<typeof sqlRelationSyntax> }> ; merge?: Readonly<{ source_port: string ; target_port: string ; changes: readonly Readonly<{ query: string ; source: ReturnType<typeof sqlRelationSyntax> }>[] ; branches: readonly Readonly<{ query: string ; source: ReturnType<typeof sqlRelationSyntax> }>[] }> }> One dataset transformation parsed by the shared SQL compiler. This metadata conveys no write permission; the installed dataset publication owner does.

SQLPivotValues

Ƭ SQLPivotValues: Record<string, { json: string ; schema: string }[]> Exact typed values discovered by an authorized, bounded read.

KeysOfUnion

Ƭ KeysOfUnion<T>: T extends unknown ? keyof T : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

PropertyOfUnion

Ƭ PropertyOfUnion<T, K>: T extends unknown ? K extends keyof T ? T[K] : never : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`K`	extends `PropertyKey`

RelationalScalarType

Ƭ RelationalScalarType: Exclude<WireDomain["type"], "struct" | "list" | "null" | "missing"> The authoring facade derives its vocabulary and parameters from the semantic owner’s generated transport. Runtime admission remains shared.

TransformationColumn

Ƭ TransformationColumn: { name: string ; type: Exclude<WireDomain["type"], "null" | "missing"> ; nullable: boolean ; optional?: boolean ; fields?: TransformationColumn[] ; element?: Omit<TransformationColumn, "name" | "optional"> } & { [K in Exclude<KeysOfUnion<WireDomain>, “type” | “fields” | “element”>]?: PropertyOfUnion<WireDomain, K> }

TransformationSchemas

Ƭ TransformationSchemas: Readonly<Record<string, readonly TransformationColumn[]>>

TransformationLiteral

Ƭ TransformationLiteral: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`kind`	`"string"` \| `"int64"` \| `"float64"` \| `"boolean"` \| `"null"` \| `"missing"`
`value`	`string`

TransformationNode

Ƭ TransformationNode: { id: string ; kind: "input" ; table: string } | { id: string ; kind: "filter" ; input: string ; field: string ; comparison: "eq" | "neq" | "lt" | "lte" | "gt" | "gte" ; value: TransformationLiteral } | { id: string ; kind: "project" ; input: string ; fields: { name: string ; from: string }[] } | { id: string ; kind: "calculate" ; input: string ; name: string ; operator: "add" | "sub" | "mul" | "div" ; left: string ; right: { kind: "field" ; field: string } | { kind: "literal" ; value: TransformationLiteral } } | { id: string ; kind: "join" ; input: string ; right: string ; left_field: string ; right_field: string ; alias: string ; join: "left" | "inner" ; at_most_one: boolean } | { id: string ; kind: "group" ; input: string ; keys: string[] ; measures: { name: string ; kind: "count" | "sum" | "count_distinct" ; field?: string }[] }

TransformationGraph

Ƭ TransformationGraph: Object

Type declaration

Name	Type
`version`	`1`
`nodes`	`TransformationNode`[]
`output`	`string`

Compiled

Ƭ Compiled: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`expression`	`RelationExpression`
`columns`	`TransformationColumn`[]

TransformationDialect

Ƭ TransformationDialect: "snowflake" | "databricks" | "bigquery" | "spark" | "duckdb"

TransformationSQL

Ƭ TransformationSQL: Object

Type declaration

Name	Type	Description
`definitions`	`SQLDefinition`[]	-
`query`	`SQLQuery`	-
`validations`	{ `query`: `SQLQuery` ; `checks`: `number`[] }[]	-
`plan_id`	`string`	-
`implementation`	{ `artifact_sha256`: `string` ; `source_sha256`: `string` ; `lowerer_sha256`: `string` }	-
`implementation.artifact_sha256`	`string`	-
`implementation.source_sha256`	`string`	-
`implementation.lowerer_sha256`	`string`	-
`read_context`	`SQLReadContext`	-
`dependencies`	`Readonly`<`Record`<`string`, `string`>>	Must be composed by the execution owner before this fragment is run.
`encoding`	`SQLRelationEncoding`	-
`definition_id`	`string`	-
`contract`	`RelationContract`	-
`checks`	{ `node`: `string` ; `code`: `string` ; `claim`: `ValidationClaim` }[]	-
`discharges`	`Discharge`[]	Every logical obligation has a checked implementation in this placement.
`columns`	`TransformationColumn`[]	-
`capabilities`	`string`[]	The sorted `RELATIONAL_CAPABILITIES` ids the program uses.
`runtime_profiles`	readonly { `id`: `string` ; `revision`: `string` }[]	Exact external kernels required before any statement is evaluated.
`runtime_programs`	readonly `SQLKernelProgram`[]	Closed programs registered before statements; definitions contain no row data.

Camel

Ƭ Camel<S>: S extends `

\{infer Head}\_

{infer Tail}` ? `

\{Head}

{Capitalize<Camel<Tail>>}` : S Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `string`

PublicEnum

Ƭ PublicEnum<S>: S extends "changed_groups" ? "affectedGroups" : S extends "bounded_recomputation" ? "boundedEvaluation" : Camel<S> Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `string`

EnumField

DictionaryField

Ƭ DictionaryField: "series_maintenance" | "spatial_maintenance" Not exported: an exported type refers to it.

OpaqueField

Ƭ OpaqueField: "validator" | "program" | "args_validator" | "logical_columns" Not exported: an exported type refers to it.

PublicExplanation

Ƭ PublicExplanation<T, Field>: 0 extends 1 & T ? T : Field extends OpaqueField ? T : T extends ValidatorJSON ? T : T extends string ? Field extends EnumField | "" ? PublicEnum<T> : T : T extends readonly unknown[] ? { [K in keyof T]: PublicExplanation<T[K], Field> } : T extends object ? { [K in keyof T as Field extends DictionaryField ? K : K extends string ? Camel<K> : K]: PublicExplanation<T[K], Field extends DictionaryField ? “

dictionaryValue" : T extends Object ? K extends "aggregate" ? "

enum” : K & string : K & string> } : T Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`Field`	extends `string` = `""`

ViewPlanNotMaintained

Ƭ ViewPlanNotMaintained: PublicExplanation<wire.ViewPlanNotMaintained>

ViewPlanMaintainedRead

Ƭ ViewPlanMaintainedRead: PublicExplanation<wire.ViewPlanMaintainedRead>

ViewPlanLookup

Ƭ ViewPlanLookup: PublicExplanation<wire.ViewPlanLookup>

ViewPlanUnbackedIndex

Ƭ ViewPlanUnbackedIndex: PublicExplanation<wire.ViewPlanUnbackedIndex>

ViewPlanStoredAuthorization

Ƭ ViewPlanStoredAuthorization: PublicExplanation<wire.ViewPlanStoredAuthorization>

ViewPlanIndexStrategy

Ƭ ViewPlanIndexStrategy: PublicExplanation<wire.ViewPlanIndexStrategy>

ViewPlanIndex

Ƭ ViewPlanIndex: PublicExplanation<wire.ViewPlanIndex>

ViewPlanNavigationRefusal

Ƭ ViewPlanNavigationRefusal: PublicExplanation<wire.ViewPlanNavigationRefusal>

ViewPlanRefusal

Ƭ ViewPlanRefusal: PublicExplanation<wire.ViewPlanRefusal>

ViewPlanMaintenanceAdvice

Ƭ ViewPlanMaintenanceAdvice: PublicExplanation<wire.ViewPlanMaintenanceAdvice>

ViewPlanExplanation

Ƭ ViewPlanExplanation: PublicExplanation<ViewPlanExplanation>

ViewWorkloadEvidence

Ƭ ViewWorkloadEvidence: Object

Type declaration

Name	Type
`format_version`	`number`
`view`	`string`
`view_definition_digest`	`string`
`program_artifact`	`string`
`workload_digest`	`string`
`scope`	`ViewWorkloadScope`
`samples`	`ViewWorkSample`[]

ViewWorkloadScope

Ƭ ViewWorkloadScope: "dependency_capture"

ViewWorkSample

Ƭ ViewWorkSample: Object

Type declaration

Name	Type
`basis_revision`	`string`
`row_steps`	`number`
`processed_bytes`	`number`
`elapsed_ns`	`string`

NavigationLink

Ƭ NavigationLink: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`relations`	`unknown`

NewField

Ƭ NewField<Row, As>: string extends keyof Row ? As : As extends keyof Row ? never : As Not exported: an exported type refers to it.

Type parameters

Name
`Row`
`As`

WithOrder

Ƭ WithOrder<T>: Omit<T, "ordered"> & { ordered: true } Not exported: an exported type refers to it.

Type parameters

Name
`T`

ProblemsOf

Ƭ ProblemsOf<T>: T extends { problems: infer P } ? P : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

TablesOf

Ƭ TablesOf<T>: T extends { tables: infer N } ? N : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

ScanOf

Ƭ ScanOf<T>: T extends { scan: infer S } ? S : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

AliasedOrigins

Ƭ AliasedOrigins<T, As>: 0 extends 1 & OriginsOf<T> ? any : { [K in As]: OriginsOf<T> extends Object ? Source : never } Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`As`	extends `string`

AliasedRelation

Ƭ AliasedRelation<T, As>: As extends string ? Omit<T, "origins"> & { origins: AliasedOrigins<T, As> } : T Not exported: an exported type refers to it.

Type parameters

Name
`T`
`As`

ExistenceJoined

Ƭ ExistenceJoined<T, Right, Problems>: Rel<RelationRow<T>, IdentityOf<T>, RelationArgumentNames<T> | RelationArgumentNames<Right>, ProblemsOf<T> | ProblemsOf<Right> | Problems, TablesOf<T> | TablesOf<Right>, never, RelationOrdering<T>> & { origins?: OriginsOf<T> } Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`Right`	`Right`
`Problems`	extends `string` = `never`

ExecutionContract

Ƭ ExecutionContract: "Execution contracts belong to queries" Not exported: an exported type refers to it.

OrderedRelation

Ƭ OrderedRelation: "Ordered and limited relations belong to queries" Not exported: an exported type refers to it.

RelationalOperator

Ƭ RelationalOperator: "This operator belongs to relational pipelines" Not exported: an exported type refers to it.

UnionOperator

Ƭ UnionOperator: "A union of relations defines a view only through grouping" Not exported: an exported type refers to it.

SameRows

Ƭ SameRows<Left, Right>: 0 extends 1 & Left ? unknown : 0 extends 1 & Right ? unknown : [Left] extends [Right] ? [Right] extends [Left] ? unknown : { unionError: "Union inputs require identical fields" } : { unionError: "Union inputs require identical fields" } Not exported: an exported type refers to it.

Type parameters

Name
`Left`
`Right`

IndexDoc

Ƭ IndexDoc<T>: ScanOf<T> extends { doc: infer Doc } ? Doc : any Not exported: an exported type refers to it.

Type parameters

Name
`T`

IndexesOf

Ƭ IndexesOf<T>: ScanOf<T> extends { indexes: infer Indexes } ? Indexes : never Not exported: an exported type refers to it.

Type parameters

Name
`T`

IndexFields

Ƭ IndexFields<T, Index>: Index extends keyof IndexesOf<T> ? IndexesOf<T>[Index] extends infer Fields ? Fields : string[] : string[] Not exported: an exported type refers to it.

Type parameters

Name
`T`
`Index`

JoinedRow

Ƭ JoinedRow<Right, As>: As extends string ? { [K in As]: Right } : Right Not exported: an exported type refers to it.

Type parameters

Name
`Right`
`As`

LeftJoinedRow

Ƭ LeftJoinedRow<Right, As>: As extends string ? { [K in As]?: Right } : Partial<Right> Not exported: an exported type refers to it.

Type parameters

Name
`Right`
`As`

ViewOperatorProblem

Ƭ ViewOperatorProblem<T>: 0 extends 1 & T ? never : ProblemsOf<T> Not exported: an exported type refers to it.

Type parameters

Name
`T`

Variables

flinkCheckpoint

• Const flinkCheckpoint: VObject<{ lag: Record<string, bigint> ; format: "bijection.flink-checkpoint/v1" ; delivery: "boundary" | "continuous" ; location: string ; sources: Record<string, string> ; job: string ; checkpoint_id: bigint ; supersedes: string ; sinks: Record<string, string> ; cuts: Record<string, string> ; committed_at_ms: bigint }, { format: VLiteral<"bijection.flink-checkpoint/v1", "required"> ; delivery: VUnion<"boundary" | "continuous", [VLiteral<"boundary", "required">, VLiteral<"continuous", "required">], "required", never> ; job: VString<string, "required"> ; checkpoint_id: VInt64<bigint, "required"> ; location: VString<string, "required"> ; supersedes: VString<string, "required"> ; sources: VRecord<Record<string, string>, VString<string, "required">, VString<string, "required">, "required", string> ; sinks: VRecord<Record<string, string>, VString<string, "required">, VString<string, "required">, "required", string> ; cuts: VRecord<Record<string, string>, VString<string, "required">, VString<string, "required">, "required", string> ; committed_at_ms: VInt64<bigint, "required"> ; lag: VRecord<Record<string, bigint>, VString<string, "required">, VInt64<bigint, "required">, "required", string> }, "required", "lag" | "format" | "delivery" | "location" | "sources" | "job" | "checkpoint_id" | "supersedes" | "sinks" | "cuts" | "committed_at_ms" | `lag.

\{string}\` \| \`sources.

{string}` | `sinks.

\{string}\` \| \`cuts.

{string}`> The externalized Flink checkpoint a boundary restores and produces: one accepted commit. The runner restores the job from location, a savepoint it owns (aligned for a boundary; for continuous delivery, the pinned snapshot that is itself the commit) and disposes once a successor superseding it is accepted; sources records the exact admitted input versions it consumed through, cuts each stream’s occurrence ranges, and sinks the output snapshots it staged, so the next boundary continues from exactly this cut.

materializeFrontier

• Const materializeFrontier: VObject<{ format: "bijection.materialize-frontier/v1" ; relations: Record<string, { upper: bigint; since: bigint; }> ; as_of: bigint }, { format: VLiteral<"bijection.materialize-frontier/v1", "required"> ; as_of: VInt64<bigint, "required"> ; relations: VRecord<Record<string, { upper: bigint ; since: bigint }>, VString<string, "required">, VObject<{ upper: bigint ; since: bigint }, { since: VInt64<bigint, "required"> ; upper: VInt64<bigint, "required"> }, "required", "upper" | "since">, "required", string> }, "required", "format" | "relations" | "as_of" | `relations.${string}`> The Materialize timestamp a boundary read its frontier-consistent snapshot at, with each relation’s read frontier observed at that time.

RELATIONAL_ENGINES

• Const RELATIONAL_ENGINES: ["bigquery", "bijection", "databricks", "duckdb", "snowflake", "spark"] Engines a captured plan may run on. bijection is the SDK’s reference evaluator hosted by the Bijection job worker, for bounded runs whose rows pass through the store; the others are exact SQL lowerings the engine runs in place over the store’s input references (DuckDB through iceberg_scan).

RELATIONAL_COST_ENFORCEMENT

• Const RELATIONAL_COST_ENFORCEMENT: Readonly<Partial<Record<RelationalEngine, Readonly<Partial<Record<keyof CapturedRelationalCostLimits, string>>>>>> The provider-native mechanism each engine uses for each captured limit. An engine or limit absent here has no provider enforcement and is refused.

GEOMETRY_OPERATORS

• Const GEOMETRY_OPERATORS: [{ id: "buffer" = “buffer”; operands: ["geometry", "metres"] ; result: "polygons" = “polygons” }, { id: "simplify" = “simplify”; operands: ["geometry", "metres"] ; result: "same" = “same” }, { id: "centroid" = “centroid”; operands: ["geometry"] ; result: "point" = “point” }, { id: "standardize" = “standardize”; operands: ["geometry"] ; result: "same" = “same” }, { id: "bijection_hull" = “bijection_hull”; operands: ["geometry"] ; result: "geometry" = “geometry” }, { id: "boundary" = “boundary”; operands: ["geometry"] ; result: "geometry" = “geometry” }, { id: "area" = “area”; operands: ["geometry"] ; result: "number" = “number” }, { id: "length" = “length”; operands: ["geometry"] ; result: "number" = “number” }, { id: "perimeter" = “perimeter”; operands: ["geometry"] ; result: "number" = “number” }, { id: "overlay" = “overlay”; operands: ["geometry", "geometry"] ; result: "geometry" = “geometry” }, { id: "transform" = “transform”; operands: ["geometry"] ; result: "same" = “same” }, { id: "ground_projection" = “ground_projection”; operands: ["geometry"] ; result: "geometry" = “geometry” }, { id: "affine_3d" = “affine_3d”; operands: ["geometry"] ; result: "same" = “same” }, { id: "destination" = “destination”; operands: ["point"] ; result: "point" = “point” }]

RELATIONAL_IMPLEMENTATION

• Const RELATIONAL_IMPLEMENTATION: Readonly<{ artifact_sha256: "65a3c341dbf9b0b91e57159ce3c5b76bdfad39227c0ce9384268784ec1ce82f7" = “65a3c341dbf9b0b91e57159ce3c5b76bdfad39227c0ce9384268784ec1ce82f7”; source_sha256: "1a70cf6e8d6cb6140c4854b00b4539d19aef825ca04f0673d8e058bc1e03c845" = “1a70cf6e8d6cb6140c4854b00b4539d19aef825ca04f0673d8e058bc1e03c845”; lowerer_sha256: "a030fc937236a06a62b9c09d5a46b541ec376f7bef9ab4600865006aedf062d2" = “a030fc937236a06a62b9c09d5a46b541ec376f7bef9ab4600865006aedf062d2” }>

RELATIONAL_PROFILE

• Const RELATIONAL_PROFILE: "bijection-relational/v117"

RELATIONAL_PROFILE_DATA

• Const RELATIONAL_PROFILE_DATA: Readonly<{ id: "bijection-relational/v117" = “bijection-relational/v117”; source_sha256: "1a70cf6e8d6cb6140c4854b00b4539d19aef825ca04f0673d8e058bc1e03c845" = “1a70cf6e8d6cb6140c4854b00b4539d19aef825ca04f0673d8e058bc1e03c845”; unicode: "17.0.0" = “17.0.0”; timezone: "2026c" = “2026c”; regular_expression: "rust-regex/1.13.1;bijection-java17-regex-subset/v3" = “rust-regex/1.13.1;bijection-java17-regex-subset/v3”; json: "strict-schema-rfc6901-last-key-spark4-jsonpath-first-success-exact-numbers-rfc9535-core-selection/v3" = “strict-schema-rfc6901-last-key-spark4-jsonpath-first-success-exact-numbers-rfc9535-core-selection/v3”; text_order: "utf8" = “utf8”; sql_unicode_ci: "unicode_ci/icu4x-casemap-1.5.1-normalizer-1.5.0/nfc-full-default-fold-nfc/utf8-v1" = “unicode_ci/icu4x-casemap-1.5.1-normalizer-1.5.0/nfc-full-default-fold-nfc/utf8-v1”; sql_unicode_turkic_ci: "unicode_turkic_ci/icu4x-casemap-1.5.1-normalizer-1.5.0/nfc-full-turkic-fold-nfc/utf8-v1" = “unicode_turkic_ci/icu4x-casemap-1.5.1-normalizer-1.5.0/nfc-full-turkic-fold-nfc/utf8-v1”; sql_locale_collations: "icu4x-collator-and-data-2.4.0/sv,de-u-co-phonebk,es-u-co-trad,fr-CA,cs,pl,da,zh-u-co-pinyin/secondary/hex-sort-key-v1" = “icu4x-collator-and-data-2.4.0/sv,de-u-co-phonebk,es-u-co-trad,fr-CA,cs,pl,da,zh-u-co-pinyin/secondary/hex-sort-key-v1”; native_value_order: "convex-value-order/v1" = “convex-value-order/v1”; decimal_precision: 38 = 38; occurrence: "nominal-locators-typed-domains-utf8-length-framed-closed-key-tuples/v5" = “nominal-locators-typed-domains-utf8-length-framed-closed-key-tuples/v5” }>

RELATIONAL_BOUNDS

• Const RELATIONAL_BOUNDS: Readonly<{ max_plan_bytes: 16777216 = 16777216; max_nodes: 100000 = 100000; max_recursion_rounds: 10000 = 10000; max_depth: 128 = 128; max_fields: 65535 = 65535; max_inputs: 65535 = 65535; max_arguments: 65535 = 65535; max_join_candidates: 1000000 = 1000000; max_array_elements: 1000000 = 1000000; max_map_entries: 1024 = 1024; max_scalars: 100000 = 100000; max_type_bytes: 16777216 = 16777216; max_regex_patterns: 16 = 16; max_regex_pattern_bytes: 4096 = 4096; max_json_bytes: 1048576 = 1048576; max_json_pointer_segments: 64 = 64; max_analytical_row_steps: 1000000000 = 1000000000; max_analytical_processed_bytes: 2147483647 = 2147483647; max_analytical_value_bytes: 16777216 = 16777216; max_analytical_value_nodes: 4000000 = 4000000 }>

RELATIONAL_CAPABILITIES

• Const RELATIONAL_CAPABILITIES: readonly Readonly<{ id: "relational.admission_time" = “relational.admission_time”; label: "Admission time" = “Admission time”; description: "Exact original admission microseconds supplied once by the request owner, stable through recovery." = “Exact original admission microseconds supplied once by the request owner, stable through recovery.” } | { id: "relational.approximation" = “relational.approximation”; label: "Explicit approximations" = “Explicit approximations”; description:

"Deterministic bottom-k estimates with requested relative or rank error and confidence; deletions require recomputation."

= “Deterministic bottom-k estimates with requested relative or rank error and confidence; deletions require recomputation.” } | { id: "relational.arithmetic" = “relational.arithmetic”; label: "Arithmetic and comparisons" = “Arithmetic and comparisons”; description: "Exact typed arithmetic and comparisons with checked overflow and explicit numeric domains." = “Exact typed arithmetic and comparisons with checked overflow and explicit numeric domains.” } | { id: "relational.array" = “relational.array”; label: "Array expressions" = “Array expressions”; description:

"Typed construction, access, membership and lexical map, filter and reduction with exact element and presence contracts."

= “Typed construction, access, membership and lexical map, filter and reduction with exact element and presence contracts.” } | { id: "relational.binary" = “relational.binary”; label: "Binary values" = “Binary values”; description: "Opaque bytes, exact equality and unsigned byte ordering, including nested values." = “Opaque bytes, exact equality and unsigned byte ordering, including nested values.” } | { id: "relational.clock" = “relational.clock”; label: "Clock inputs" = “Clock inputs”; description: "Epoch-aligned captured time with an explicit validity boundary; executors never invent wall time." = “Epoch-aligned captured time with an explicit validity boundary; executors never invent wall time.” } | { id: "relational.conditional" = “relational.conditional”; label: "Conditions" = “Conditions”; description: "Conditional values, membership, null and missing tests, coalesce, least and greatest." = “Conditional values, membership, null and missing tests, coalesce, least and greatest.” } | { id: "relational.date" = “relational.date”; label: "Dates" = “Dates”; description: "Calendar date columns, literals, day arithmetic and date parts." = “Calendar date columns, literals, day arithmetic and date parts.” } | { id: "relational.decimal" = “relational.decimal”; label: "Decimals" = “Decimals”; description: "Exact fixed-scale decimals: columns, literals, arithmetic, averages and decimal sums." = “Exact fixed-scale decimals: columns, literals, arithmetic, averages and decimal sums.” } | { id: "relational.deduplicate" = “relational.deduplicate”; label: "Deduplicate" = “Deduplicate”; description: "One row per key, the first under an ordering; unresolved ties fail." = “One row per key, the first under an ordering; unresolved ties fail.” } | { id: "relational.extrema" = “relational.extrema”; label: "Extrema" = “Extrema”; description: "Minimum and maximum of scalar values, ignoring missing and null." = “Minimum and maximum of scalar values, ignoring missing and null.” } | { id: "relational.filter" = “relational.filter”; label: "Filter" = “Filter”; description: "Keep the rows a present boolean predicate holds for." = “Keep the rows a present boolean predicate holds for.” } | { id: "relational.float" = “relational.float”; label: "Binary64" = “Binary64”; description: "Finite binary64 values and exact accumulation with one final rounding." = “Finite binary64 values and exact accumulation with one final rounding.” } | { id: "relational.group" = “relational.group”; label: "Group" = “Group”; description: "Complete keyed reductions, counts, exact sums, averages, percentiles, statistics and bounded collections." = “Complete keyed reductions, counts, exact sums, averages, percentiles, statistics and bounded collections.” } | { id: "relational.guarantee" = “relational.guarantee”; label: "Business guarantees" = “Business guarantees”; description: "Mandatory present boolean predicates over every input row; preserve duplicates and refuse on failure." = “Mandatory present boolean predicates over every input row; preserve duplicates and refuse on failure.” } | { id: "relational.join" = “relational.join”; label: "Join" = “Join”; description: "Inner, left, right, full and cross joins with explicit predicates, multiplicity and cardinality obligations." = “Inner, left, right, full and cross joins with explicit predicates, multiplicity and cardinality obligations.” } | { id: "relational.lateral" = “relational.lateral”; label: "Correlated relations" = “Correlated relations”; description:

"One complete right population per left occurrence, with lexical outer fields, ordinary grouping and explicit empty and cardinality contracts."

= “One complete right population per left occurrence, with lexical outer fields, ordinary grouping and explicit empty and cardinality contracts.” } | { id: "relational.map" = “relational.map”; label: "Typed analytical maps" = “Typed analytical maps”; description:

"Unique ordered scalar or closed composite keys, exact homogeneous values, canonical entry-map carriers, duplicate refusal and typed lookup, keys and values."

= “Unique ordered scalar or closed composite keys, exact homogeneous values, canonical entry-map carriers, duplicate refusal and typed lookup, keys and values.” } | { id: "relational.nested" = “relational.nested”; label: "Nested values" = “Nested values”; description: "Struct and list columns and struct member access." = “Struct and list columns and struct member access.” } | { id: "relational.project" = “relational.project”; label: "Project" = “Project”; description: "Named fields, scalar expressions and literals." = “Named fields, scalar expressions and literals.” } | { id: "relational.rank" = “relational.rank”; label: "Ranking" = “Ranking”; description: "Ordered ranking within each partition; unresolved semantic ties fail." = “Ordered ranking within each partition; unresolved semantic ties fail.” } | { id: "relational.recursion" = “relational.recursion”; label: "Recursive relations" = “Recursive relations”; description:

"Positive least fixed points with complete scalar-row set identity, or bag iteration over the previous frontier with stable occurrence identities; both refuse incomplete results on budget exhaustion."

= “Positive least fixed points with complete scalar-row set identity, or bag iteration over the previous frontier with stable occurrence identities; both refuse incomplete results on budget exhaustion.” } | { id: "relational.reference" = “relational.reference”; label: "Native references" = “Native references”; description:

"Nominal table references preserve identity; complete source populations refuse conflicting rows under one native locator."

= “Nominal table references preserve identity; complete source populations refuse conflicting rows under one native locator.” } | { id: "relational.semi_join" = “relational.semi_join”; label: "Existence join" = “Existence join”; description: "Keep rows that have (or have no) related row; null and missing keys match themselves." = “Keep rows that have (or have no) related row; null and missing keys match themselves.” } | { id: "relational.string" = “relational.string”; label: "Text and structured text" = “Text and structured text”; description: "Unicode text operations, regular expressions and typed JSON parsing with explicit failures." = “Unicode text operations, regular expressions and typed JSON parsing with explicit failures.” } | { id: "relational.struct" = “relational.struct”; label: "Struct expressions" = “Struct expressions”; description: "Typed struct construction and field replacement preserve nested domains and independent null/missing fields." = “Typed struct construction and field replacement preserve nested domains and independent null/missing fields.” } | { id: "relational.timestamp" = “relational.timestamp”; label: "Timestamps" = “Timestamps”; description: "UTC instant columns, literals, pattern parsing and formatting in IANA time zones, microsecond arithmetic." = “UTC instant columns, literals, pattern parsing and formatting in IANA time zones, microsecond arithmetic.” } | { id: "relational.union" = “relational.union”; label: "Union" = “Union”; description: "All occurrences from relations with identical fields; duplicates retain their multiplicity." = “All occurrences from relations with identical fields; duplicates retain their multiplicity.” } | { id: "relational.unnest" = “relational.unnest”; label: "Unnest" = “Unnest”; description: "One row per list element; null, missing and empty lists produce no rows." = “One row per list element; null, missing and empty lists produce no rows.” } | { id: "relational.window" = “relational.window”; label: "Analytical windows" = “Analytical windows”; description: "Ranking, offsets and aggregates over explicit row or exact value-distance frames while retaining every row." = “Ranking, offsets and aggregates over explicit row or exact value-distance frames while retaining every row.” } | { id: "spatial.geometry" = “spatial.geometry”; label: "Geometry operations" = “Geometry operations”; description:

"Typed constructive, measurement, overlay, coordinate transformation and height operations with explicit frames and numerical contracts."

= “Typed constructive, measurement, overlay, coordinate transformation and height operations with explicit frames and numerical contracts.” }>[]

transformationParameters

• Const transformationParameters: VObject<{ graph: { version: 1; output: string; nodes: ({ kind: “input”; id: string; table: string; } | { kind: “filter”; id: string; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; }; field: string; input: string; comparison: “eq” | … 4 more … | “neq”; } | { …; } | { …; } | { … }, { graph: VObject<{ version: 1 ; output: string ; nodes: ({ kind: “input”; id: string; table: string; } | { kind: “filter”; id: string; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; }; field: string; input: string; comparison: “eq” | “lt” | “lte” | “gt” | “gte” | “neq”; } | { kind: “project”; id: string; fields: { name: string; from: string; }[]; input: string; } | { kind: “calculate”; name: string; id: string; left: string; right: { kind: “field”; field: string; } | { kind: “literal”; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; }; }; input: string; operator: “sub” | … 2 more … | “div”; } | { kind: “join”; id: string; join: “inner” | “left”; alias: string; right: string; at_most_one: boolean; input: string; left_field: string; right_field: string; } | { kind: “group”; id: string; keys: string[]; input: string; measures: { field?: string; kind: “sum” | “count” | “count_distinct”; name: string; }[]; })[] }, { version: VLiteral<1, "required"> ; output: VString<string, "required"> ; nodes: VArray<({ kind: "input" ; id: string ; table: string } | { kind: "filter" ; id: string ; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; } ; field: string ; input: string ; comparison: "eq" | "lt" | "lte" | "gt" | "gte" | "neq" } | { kind: "project" ; id: string ; fields: { name: string; from: string; }[] ; input: string } | { kind: "calculate" ; name: string ; id: string ; left: string ; right: { kind: “field”; field: string; } | { kind: “literal”; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; }; } ; input: string ; operator: "sub" | "add" | "mul" | "div" } | { kind: "join" ; id: string ; join: "inner" | "left" ; alias: string ; right: string ; at_most_one: boolean ; input: string ; left_field: string ; right_field: string } | { kind: "group" ; id: string ; keys: string[] ; input: string ; measures: { field?: string; kind: “sum” | “count” | “count_distinct”; name: string; }[] })[], VUnion<{ kind: "input" ; id: string ; table: string } | { kind: "filter" ; id: string ; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; } ; field: string ; input: string ; comparison: "eq" | "lt" | "lte" | "gt" | "gte" | "neq" } | { kind: "project" ; id: string ; fields: { name: string; from: string; }[] ; input: string } | { kind: "calculate" ; name: string ; id: string ; left: string ; right: { kind: “field”; field: string; } | { kind: “literal”; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; }; } ; input: string ; operator: "sub" | "add" | "mul" | "div" } | { kind: "join" ; id: string ; join: "inner" | "left" ; alias: string ; right: string ; at_most_one: boolean ; input: string ; left_field: string ; right_field: string } | { kind: "group" ; id: string ; keys: string[] ; input: string ; measures: { field?: string; kind: “sum” | “count” | “count_distinct”; name: string; }[] }, [VObject<{ kind: "input" ; id: string ; table: string }, { id: VString<string, "required"> ; kind: VLiteral<"input", "required"> ; table: VString<string, "required"> }, "required", "kind" | "id" | "table">, VObject<{ kind: "filter" ; id: string ; value: { kind: “string” | “boolean” | “float64” | “int64” | “null” | “missing”; value: string; } ; field: string ; input: string ; comparison: "eq" | "lt" | "lte" | "gt" | "gte" | "neq" }, { id: VString<string, "required"> ; kind: VLiteral<"filter", "required"> ; input: VString<string, "required"> ; field: VString<string, "required"> ; comparison: VUnion<"eq" | "lt" | "lte" | "gt" | "gte" | "neq", [VLiteral<"eq", "required">, VLiteral<"neq", "required">, VLiteral<"lt", "required">, VLiteral<"lte", "required">, VLiteral<"gt", "required">, VLiteral<"gte", "required">], "required", never> ; value: VObject<{ kind: "string" | "boolean" | "float64" | "int64" | "null" | "missing" ; value: string }, { kind: VUnion<"string" | "boolean" | "float64" | "int64" | "null" | "missing", [VLiteral<"string", "required">, VLiteral<"int64", "required">, VLiteral<"float64", "required">, VLiteral<"boolean", "required">, VLiteral<"null", "required">, VLiteral<"missing", "required">], "required", never> ; value: VString<string, "required"> }, "required", "kind" | "value"> = literal }, "required", "kind" | "id" | "value" | "field" | "input" | "comparison" | "value.kind" | "value.value">, VObject<{ kind: "project" ; id: string ; fields: { name: string; from: string; }[] ; input: string }, { id: VString<string, "required"> ; kind: VLiteral<"project", "required"> ; input: VString<string, "required"> ; fields: VArray<{ name: string ; from: string }[], VObject<{ name: string ; from: string }, { name: VString<string, "required"> ; from: VString<string, "required"> }, "required", "name" | "from">, "required"> }, "required", "kind" | "id" | "fields" | "input">], "required", "kind" | "name" | "id" | "join" | "keys" | "fields" | "value" | "field" | "table" | "alias" | "left" | "right" | "at_most_one" | "input" | "measures" | "operator" | "comparison" | "value.kind" | "value.value" | "right.kind" | "right.value" | "right.field" | "right.value.kind" | "right.value.value" | "left_field" | "right_field">, "required"> }, "required", "version" | "output" | "nodes"> }, "required", "graph" | "graph.version" | "graph.output" | "graph.nodes"> Parameters are immutable at evaluation admission; they are not a mutable second program registry. The worker validates the complete graph again.

Functions

flink

▸ flink(spec, declared): JobHandler<"flink"> Run a captured Flink project as continuous boundaries on customer Flink. The function’s arguments are the project’s sources (each an exact dataset version: a stream’s native archive cut or a snapshot) plus the checkpoint; its results are the project’s sinks plus the checkpoint. One warm session job keeps the Flink job across boundaries; each boundary restores from the previous checkpoint, consumes through its cut, and replies with its sink versions and the new aligned checkpoint, which commit together. With delivery: "continuous" stream sources are not arguments: the job reads the broker unpaused and each boundary accepts its newest transactional commit with the cut its checkpoint witnessed.

Parameters

Name	Type
`spec`	`FlinkProject`
`declared`	`FlinkOptions`

Returns

JobHandler<"flink">

materializeRelations

▸ materializeRelations(spec, declared): JobHandler<"materialize"> Read a captured Materialize project’s maintained relations at one timestamp. Materialize keeps the views incrementally on customer compute; a boundary does not step its dataflow. It reads every output at the function’s as_of cut, retains native Dataset references in place, and replies with the new frontier checkpoint. A cut behind a relation’s read frontier is refused rather than restarted (onHistoryGap: "stop").

Parameters

Name	Type
`spec`	`MaterializeProject`
`declared`	`Options`

Returns

JobHandler<"materialize">

materializePage

▸ materializePage(spec, member): Object A bounded page of one accepted native Materialize cut. The input is an exact Dataset reference; keyset cursors stay on that cut. The customer runner reduces and limits the query in Materialize before returning at most 128 rows and 16 KiB through the ordinary Compute result.

Parameters

Name	Type
`spec`	`MaterializeProject`
`member`	`string`

Returns

Object

Name	Type
`args`	{ `source`: `VObject`<{ `reference`: `string` ; `kind`: `"dataset"` ; `owner`: `string` ; `contract`: `string` ; `version`: `string` ; `digest`: `string` }, { `kind`: `VLiteral`<`"dataset"`, `"required"`> ; `owner`: `VString`<`string`, `"required"`> \| `VLiteral`<`string`, `"required"`> ; `reference`: `VString`<`string`, `"required"`> ; `version`: `VString`<`string`, `"required"`> ; `digest`: `VString`<`string`, `"required"`> ; `contract`: `VLiteral`<`string`, `"required"`> }, `"required"`, `"reference"` \| `"kind"` \| `"owner"` \| `"contract"` \| `"version"` \| `"digest"`> & { `type`: `ResultRef`<{}, `"dataset"`> } ; `cursor`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> ; `limit`: `VInt64`<`bigint`, `"required"`> }
`args.source`	`VObject`<{ `reference`: `string` ; `kind`: `"dataset"` ; `owner`: `string` ; `contract`: `string` ; `version`: `string` ; `digest`: `string` }, { `kind`: `VLiteral`<`"dataset"`, `"required"`> ; `owner`: `VString`<`string`, `"required"`> \| `VLiteral`<`string`, `"required"`> ; `reference`: `VString`<`string`, `"required"`> ; `version`: `VString`<`string`, `"required"`> ; `digest`: `VString`<`string`, `"required"`> ; `contract`: `VLiteral`<`string`, `"required"`> }, `"required"`, `"reference"` \| `"kind"` \| `"owner"` \| `"contract"` \| `"version"` \| `"digest"`> & { `type`: `ResultRef`<{}, `"dataset"`> }
`args.cursor`	`VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`>
`args.limit`	`VInt64`<`bigint`, `"required"`>
`returns`	`VObject`<{ `cursor`: `null` \| `string` ; `rows`: { [x: string]: string \| number \| bigint \| boolean; [x: number]: string \| number \| bigint \| boolean; }[] }, { `rows`: `VArray`<{}[], `VObject`<{}, { `[k: string]`: `T`; }, `"required"`, `string`>, `"required"`> ; `cursor`: `VUnion`<`null` \| `string`, [`VNull`<`null`, `"required"`>, `VString`<`string`, `"required"`>], `"required"`, `never`> }, `"required"`, `"cursor"` \| `"rows"`>
`handler`	`JobHandler`<`"materialize"`>

relational

▸ relational<Fields, Expr>(definition): <Model, Schema>(ctx: BijectionQueryCtx<Model, Schema>, args: ArgsArrayToObject<DefaultArgsForOptionalValidator<Fields>>) => Promise<ResultRow<Expr>[]> Reuse a captured relation as an ordinary transactional query handler. Native reads retain their dependency tracking, policies and work bounds. Analytical or external work belongs in an action adapter.

Type parameters

Name	Type
`Fields`	extends `PropertyValidators`
`Expr`	`Expr`

Parameters

Name	Type
`definition`	`RelationDefinition`<`Fields`, `Expr`>

Returns

fn ▸ <Model, Schema>(ctx, args): Promise<ResultRow<Expr>[]>

Type parameters

Name	Type
`Model`	extends `GenericDataModel`
`Schema`	extends `GenericSchema`

Parameters

Name	Type
`ctx`	`BijectionQueryCtx`<`Model`, `Schema`>
`args`	`ArgsArrayToObject`<`DefaultArgsForOptionalValidator`<`Fields`>>

Returns

Promise<ResultRow<Expr>[]>

relationalPlan

▸ relationalPlan<Args>(args, build, options?): RelationalHandler Capture a relational plan as the action’s implementation. Pass the action’s own args object: dataset arguments become relation inputs and the rest become scalar plan arguments. build returns one relation for a dataset(row) return, or an object of relations for an object of datasets. Verification belongs to the function’s store (functionResources(\{ verify \})), placement to Compute’s execution target.

Type parameters

Name	Type
`Args`	extends `PropertyValidators`

Parameters

Name	Type
`args`	`Args`
`build`	(`inputs`: `RelationalInputs`<`Args`>) => `unknown`
`options`	`RelationalPlanOptions`

Returns

RelationalHandler

analyzeRelation

▸ analyzeRelation(relation, inputContracts, argumentContracts?): RelationalPlan Semantic analysis is independent of placement, encodings and SQL rendering.

Parameters

Name	Type
`relation`	`Relation`<`any`> \| `RelationExpression`
`inputContracts`	`TransformationSchemas`
`argumentContracts`	`Record`<`string`, `RelationalArgument`>

Returns

RelationalPlan

validateRelationalPlan

▸ validateRelationalPlan(plan, schemas?): RelationalPlan Serialized plans are untrusted. Reconstruct all inferred metadata.

Parameters

Name	Type
`plan`	`RelationalPlan`
`schemas?`	`TransformationSchemas`

Returns

RelationalPlan

relationalSQLLoweringCapabilities

▸ relationalSQLLoweringCapabilities(dialect): string[] Static implementation support; installation and input qualification are separate.

Parameters

Name	Type
`dialect`	`TransformationDialect`

Returns

string[]

relationalSQLRequirements

▸ relationalSQLRequirements(plan, dialect): { node: string ; operation: string ; kernel: null | Readonly<{ kind: "collection" | "occurrence" | "scalar" | "geometry" | "numeric" | "spatial" | "geometry_union" | "lambda_binding" | "regex" | "java_regex" ; id: string ; program: string }> ; operands: ScalarType[] ; result: ScalarType[] ; mode: "full" ; refusal: null | { requirement: string ; reason: string } }[] Operation-level support over the authoritative IR, before physical binding. Families describe vocabulary; these entries describe the concrete operations, domains and semantic data needed by this program on one adapter.

Parameters

Name	Type
`plan`	`RelationalPlan`
`dialect`	`TransformationDialect`

Returns

{ node: string ; operation: string ; kernel: null | Readonly<{ kind: "collection" | "occurrence" | "scalar" | "geometry" | "numeric" | "spatial" | "geometry_union" | "lambda_binding" | "regex" | "java_regex" ; id: string ; program: string }> ; operands: ScalarType[] ; result: ScalarType[] ; mode: "full" ; refusal: null | { requirement: string ; reason: string } }[]

compileRelationalSQL

▸ compileRelationalSQL(plan, dialect, reads, sourceNodes?, parameters?): TransformationSQL TypeScript and editor definitions both lower through this implementation.

Parameters

Name	Type
`plan`	`RelationalPlan`
`dialect`	`TransformationDialect`
`reads`	`SQLReadContext`
`sourceNodes`	`ReadonlyMap`<`string`, `string`>
`parameters?`	`Record`<`string`, `Value` \| `undefined`>

Returns

TransformationSQL

inspectRelationalSQL

▸ inspectRelationalSQL(plan, dialect, reads?, parameters?): SQLPlacementInspection Uses the exact lowerer, including obligation coverage. Symbolic inspection neither grants a read nor exposes a program that can be executed.

Parameters

Name	Type
`plan`	`RelationalPlan`
`dialect`	`TransformationDialect`
`reads?`	`SQLReadContext`
`parameters?`	`Record`<`string`, `Value` \| `undefined`>

Returns

SQLPlacementInspection

relationalSQLRuntimeProfiles

▸ relationalSQLRuntimeProfiles(plan, dialect): (Readonly<{ id: "spark.lambda_bindings" = “spark.lambda_bindings”; revision: "912ce5f6324cdf3d2feff04b7a07795d586c9d21bf76994286d647583ef8df70" = “912ce5f6324cdf3d2feff04b7a07795d586c9d21bf76994286d647583ef8df70” }> | Readonly<{ id: "spark.regex" = “spark.regex”; revision: "1b00f55bd56478878dfed12a89b06b03f1ccf6d5fdd51d1248db2e2dabc4621a" = “1b00f55bd56478878dfed12a89b06b03f1ccf6d5fdd51d1248db2e2dabc4621a” }> | Readonly<{ id: "spark.java_regex" = “spark.java_regex”; revision: "6c7ca434d25560ec251042b90afc156480563cfebf0006a30552942a078ebf3b" = “6c7ca434d25560ec251042b90afc156480563cfebf0006a30552942a078ebf3b” }> | Readonly<{ id: "spark.format_string" = “spark.format_string”; revision: "1cc11f8904d641fb1500fbae1250654a31b1d91598ed05132d51a76670764eb8" = “1cc11f8904d641fb1500fbae1250654a31b1d91598ed05132d51a76670764eb8” }> | Readonly<{ id: "spark.json" = “spark.json”; revision: "e41a3ce7d670e6489c9d1d66dcb845fad1a8931427217fa624d299b2baa5da69" = “e41a3ce7d670e6489c9d1d66dcb845fad1a8931427217fa624d299b2baa5da69” }> | Readonly<{ id: "spark.observed_percentile" = “spark.observed_percentile”; revision: "9eaf5cad18e98cf3bb28ae8360e36e60c0f20070502a5b09fd7fde56a376b08d" = “9eaf5cad18e98cf3bb28ae8360e36e60c0f20070502a5b09fd7fde56a376b08d” }> | Readonly<{ id: "spark.statistics" = “spark.statistics”; revision: "08eccf7ee30de1320a4eb2b8be0d9a92e2498a0e20607b0ebe1671be6aea5bcb" = “08eccf7ee30de1320a4eb2b8be0d9a92e2498a0e20607b0ebe1671be6aea5bcb” }> | Readonly<{ id: "spark.binary64" = “spark.binary64”; revision: "aa592453d374ef7ecd6d5a5d94e2ad865eb79d7fa5b3ba25dd40f6160103686c" = “aa592453d374ef7ecd6d5a5d94e2ad865eb79d7fa5b3ba25dd40f6160103686c” }>)[] Required external kernels are part of checked execution admission.

Parameters

Name	Type
`plan`	`RelationalPlan`
`dialect`	`TransformationDialect`

Returns

(Readonly<{ id: "spark.lambda_bindings" = “spark.lambda_bindings”; revision: "912ce5f6324cdf3d2feff04b7a07795d586c9d21bf76994286d647583ef8df70" = “912ce5f6324cdf3d2feff04b7a07795d586c9d21bf76994286d647583ef8df70” }> | Readonly<{ id: "spark.regex" = “spark.regex”; revision: "1b00f55bd56478878dfed12a89b06b03f1ccf6d5fdd51d1248db2e2dabc4621a" = “1b00f55bd56478878dfed12a89b06b03f1ccf6d5fdd51d1248db2e2dabc4621a” }> | Readonly<{ id: "spark.java_regex" = “spark.java_regex”; revision: "6c7ca434d25560ec251042b90afc156480563cfebf0006a30552942a078ebf3b" = “6c7ca434d25560ec251042b90afc156480563cfebf0006a30552942a078ebf3b” }> | Readonly<{ id: "spark.format_string" = “spark.format_string”; revision: "1cc11f8904d641fb1500fbae1250654a31b1d91598ed05132d51a76670764eb8" = “1cc11f8904d641fb1500fbae1250654a31b1d91598ed05132d51a76670764eb8” }> | Readonly<{ id: "spark.json" = “spark.json”; revision: "e41a3ce7d670e6489c9d1d66dcb845fad1a8931427217fa624d299b2baa5da69" = “e41a3ce7d670e6489c9d1d66dcb845fad1a8931427217fa624d299b2baa5da69” }> | Readonly<{ id: "spark.observed_percentile" = “spark.observed_percentile”; revision: "9eaf5cad18e98cf3bb28ae8360e36e60c0f20070502a5b09fd7fde56a376b08d" = “9eaf5cad18e98cf3bb28ae8360e36e60c0f20070502a5b09fd7fde56a376b08d” }> | Readonly<{ id: "spark.statistics" = “spark.statistics”; revision: "08eccf7ee30de1320a4eb2b8be0d9a92e2498a0e20607b0ebe1671be6aea5bcb" = “08eccf7ee30de1320a4eb2b8be0d9a92e2498a0e20607b0ebe1671be6aea5bcb” }> | Readonly<{ id: "spark.binary64" = “spark.binary64”; revision: "aa592453d374ef7ecd6d5a5d94e2ad865eb79d7fa5b3ba25dd40f6160103686c" = “aa592453d374ef7ecd6d5a5d94e2ad865eb79d7fa5b3ba25dd40f6160103686c” }>)[]

compileRelation

▸ compileRelation<T>(options): CompiledRelation<T>

Type parameters

Name
`T`

Parameters

Name	Type
`options`	`Object`
`options.relation`	`Relation`<`T`>
`options.inputs`	`Readonly`<`Record`<`string`, `string`>>
`options.limits?`	`RetainedRelationWorkLimits`
`options.schemas`	`TransformationSchemas`
`options.arguments?`	`Record`<`string`, `RelationalArgument`>

Returns

CompiledRelation<T>

sqlFrameworkProject

▸ sqlFrameworkProject<Kind, Spec>(kind, specification): SqlProject<Kind, Spec>

Type parameters

Name	Type
`Kind`	extends `"sqlmesh"` \| `"dataform"`
`Spec`	extends `SqlProjectSpecification`

Parameters

Name	Type
`kind`	`Kind`
`specification`	`Spec`

Returns

SqlProject<Kind, Spec>

dbt

▸ dbt<Project>(project, binding): JobHandler<"dbt"> Run the function as a captured dbt project.

Type parameters

Name	Type
`Project`	extends `DbtProject`<`DbtSpecification`>

Parameters

Name	Type
`project`	`Project`
`binding`	`SqlFrameworkBinding`<`Project`>

Returns

JobHandler<"dbt">

sqlmesh

▸ sqlmesh<Project>(project, binding): JobHandler<"sqlmesh"> Run the function as a captured SQLMesh project.

Type parameters

Name	Type
`Project`	extends `SqlProject`<`"sqlmesh"`, `SqlProjectSpecification`>

Parameters

Name	Type
`project`	`Project`
`binding`	`SqlFrameworkBinding`<`Project`>

Returns

JobHandler<"sqlmesh">

dataform

▸ dataform<Project>(project, binding): JobHandler<"dataform"> Run the function as a captured Dataform project on BigQuery.

Type parameters

Name	Type
`Project`	extends `SqlProject`<`"dataform"`, `SqlProjectSpecification`>

Parameters

Name	Type
`project`	`Project`
`binding`	`SqlFrameworkBinding`<`Project`>

Returns

JobHandler<"dataform">

decodeSQLParameterValues

▸ decodeSQLParameterValues(text): Record<string, Value> Decode analytical parameters after the ordinary function boundary. A wire string keeps large arrays out of inherited native record/array carriers.

Parameters

Name	Type
`text`	`string`

Returns

Record<string, Value>

describeSQLProgram

▸ describeSQLProgram(sql, program, argsValidator?): Promise<{ program_json: string = programJSON; expected_inputs_digest: string ; validator_json: string ; columns: { key: string ; name: string ; type: ValidatorJSON = field.fieldType; optional: boolean = field.optional; logical_type: unknown = logical.value_type }[] ; compiler_revision: string ; source_map: any = schema.source_map; semantic_profile: any = schema.semantic_profile; operation_requirements: any = schema.operation_requirements }>

Parameters

Name	Type
`sql`	`string`
`program`	`Pick`<`RelationalProgram`, `"program"`>
`argsValidator`	`ValidatorJSON`

Returns

Promise<{ program_json: string = programJSON; expected_inputs_digest: string ; validator_json: string ; columns: { key: string ; name: string ; type: ValidatorJSON = field.fieldType; optional: boolean = field.optional; logical_type: unknown = logical.value_type }[] ; compiler_revision: string ; source_map: any = schema.source_map; semantic_profile: any = schema.semantic_profile; operation_requirements: any = schema.operation_requirements }>

bindSQLProgramParameters

▸ bindSQLProgramParameters(sql, program, types, values): Promise<{ program_json: string = programJSON; expected_inputs_digest: string ; validator_json: string ; columns: { key: string ; name: string ; type: ValidatorJSON = field.fieldType; optional: boolean = field.optional; logical_type: unknown = logical.value_type }[] ; compiler_revision: string ; source_map: any = schema.source_map; semantic_profile: any = schema.semantic_profile; operation_requirements: any = schema.operation_requirements }> Close negotiated parameters before native description and admission.

Parameters

Name	Type
`sql`	`string`
`program`	`RelationalProgram`[`"program"`]
`types`	`Record`<`string`, `WireShape`>
`values`	`Record`<`string`, `Value`>

Returns

validateSQLReadContext

▸ validateSQLReadContext(dialect, context, contracts, now_at?): void

Parameters

Name	Type
`dialect`	`TransformationDialect`
`context`	`SQLReadContext`
`contracts`	`Readonly`<`Record`<`string`, readonly `TransformationColumn`[]>>
`now_at`	`string`

Returns

void

renderRelationalSQL

▸ renderRelationalSQL(program, query?): string Render only the definition closure needed by this statement.

Parameters

Name	Type	Default value
`program`	`TransformationSQL`	`undefined`
`query`	`SQLQuery`	`program.query`

Returns

string

sqlContext

▸ sqlContext(context?): CapturedSQLContext Normalize SQL defaults before authoring, session admission or preparation.

Parameters

Name	Type
`context`	`SQLContext`

Returns

CapturedSQLContext

sqlRelation

▸ sqlRelation<Inputs, Parameters, Returns>(definition): Relation<SQLRelationType<Inputs, Parameters, Returns>> Author a read-only SQL relation. Inputs are ordinary relations and named :parameters are bounded values or lexical declaration arguments. SQL cannot discover tables, load functions, run scripts or invoke an external engine. The shared native/WASM frontend checks syntax at capture. Admission binds column names against input contracts and expands SQL into ordinary relational operators before planning. Wildcards require closed schemas. Unquoted names fold to lowercase; double-quoted names are exact. SQL collapses missing cells to NULL and uses three-valued predicates. Integers and decimals stay exact. returns supplies TypeScript inference and an output contract checked during analysis; it cannot override the analyzed types. Placement and access checks are the same as for the equivalent SDK-authored relation.

Type parameters

Name	Type
`Inputs`	extends `Record`<`string`, `Relation`<`any`>>
`Parameters`	extends `Record`<`string`, `Parameter`> = `Record`<`never`, `never`>
`Returns`	extends `GenericValidator` \| `undefined` = `undefined`

Parameters

Name	Type
`definition`	`Object`
`definition.sql`	`string`
`definition.sourceFile?`	`string`
`definition.context?`	`SQLContext`
`definition.pivots?`	`SQLPivotValues`
`definition.inputs`	`Inputs`
`definition.parameters?`	`Parameters`
`definition.returns?`	`Returns`

Returns

Relation<SQLRelationType<Inputs, Parameters, Returns>>

sqlBuildSyntax

▸ sqlBuildSyntax(sql, columns?, defaults?): SQLBuildSyntax Parse a dataset transformation without executing it or reading a catalog. Schema-only CREATE becomes an empty typed candidate. INSERT column lists assign values by position and use the declared target order; omitted values use declared constant defaults or typed NULLs. UPDATE and DELETE use declared columns, never sampled rows. The dataset’s existing output contract and publication owner enforce writes.

Parameters

Name	Type	Default value
`sql`	`string`	`undefined`
`columns`	readonly `string`[]	`[]`
`defaults`	`Readonly`<`Record`<`string`, `string`>>	`{}`

Returns

SQLBuildSyntax

sqlTransactionSyntax

▸ sqlTransactionSyntax(sql, targets, defaults?): Readonly<{ revision: string ; statements: readonly SQLBuildSyntax[] }> Compile one atomic dataset transaction. Each write is still an inert read plan; the dataset owner supplies the single publication boundary.

Parameters

Name	Type
`sql`	`string`
`targets`	`Readonly`<`Record`<`string`, readonly `string`[]>>
`defaults`	`Readonly`<`Record`<`string`, `Readonly`<`Record`<`string`, `string`>>>>

Returns

Readonly<{ revision: string ; statements: readonly SQLBuildSyntax[] }>

sqlPivotSyntax

▸ sqlPivotSyntax(sql, pivots?): Object Describe the next discovery round without reading a Dataset. Pass the resulting frozen values to sqlRelation; execution asserts the complete value population still agrees.

Parameters

Name	Type
`sql`	`string`
`pivots`	`SQLPivotValues`

Returns

Object

Name	Type
`complete`	`boolean`
`sql`	`string`
`discoveries`	{ `id`: `string` ; `sql`: `string` ; `limit`: `number` }[]

sqlRelationSyntax

▸ sqlRelationSyntax(sql): Object

Parameters

Name	Type
`sql`	`string`

Returns

Object

Name	Type
`revision`	`string`
`inputs`	`string`[]
`parameters`	`string`[]
`table_parameters?`	`Record`<`string`, { `collection`: `string` }>
`metadata_filters?`	`Record`<`string`, `Record`<`string`, `JSONValue`>>
`functions`	{ `name`: `string` ; `canonical_name`: `string` ; `kind`: `"scalar"` \| `"aggregate"` \| `"window"` \| `"table"` \| `"generator"` ; `signature`: `string` ; `evaluation`: `"pure"` \| `"captured_context"` \| `"occurrence_dependent"` \| `"exact_bounded_fallback"` \| `"explicit_evidence"` \| `"exact_bounded_fallback_or_explicit_evidence"` ; `overloads`: { `minimum_arguments`: `number` ; `maximum_arguments`: `number` ; `argument_step`: `number` ; `parameters`: { `index`: `number` ; `name`: `string` ; `domain`: `string` ; `constant_per_request`: `boolean` }[] ; `contexts`: (`"scalar"` \| `"group"` \| `"grouping"` \| `"window"` \| `"table"` \| `"select_generator"`)[] ; `evaluation`: `"pure"` \| `"captured_context"` \| `"occurrence_dependent"` \| `"exact_bounded_fallback"` \| `"explicit_evidence"` ; `type_rules`: `"shared_semantic_binding"` }[] }[]
`features`	{ `semantic_profile`: `string` ; `verification`: { `kind`: `string` ; `reason`: `string` } ; `features`: { `id`: `string` ; `contract`: `string` ; `native`: `string` ; `external`: `string` ; `availability`: `string` }[] }
`features.semantic_profile`	`string`
`features.verification`	{ `kind`: `string` ; `reason`: `string` }
`features.verification.kind`	`string`
`features.verification.reason`	`string`
`features.features`	{ `id`: `string` ; `contract`: `string` ; `native`: `string` ; `external`: `string` ; `availability`: `string` }[]
`limits`	{ `bytes`: `number` ; `tokens`: `number` ; `depth`: `number` ; `nodes`: `number` ; `fields`: `number` ; `inputs`: `number` }
`limits.bytes`	`number`
`limits.tokens`	`number`
`limits.depth`	`number`
`limits.nodes`	`number`
`limits.fields`	`number`
`limits.inputs`	`number`

sqlWireValidator

▸ sqlWireValidator(shape): ValidatorJSON

Parameters

Name	Type
`shape`	`WireShape`

Returns

ValidatorJSON

compileTransformation

▸ compileTransformation(graph, schemas): Compiled & { sourceNodes: ReadonlyMap<RelationExpression, string> } Validate every reachable node, infer its schema, then lower to the same q expression used by native views. No sample rows or engine credentials enter it.

Parameters

Name	Type
`graph`	`TransformationGraph`
`schemas`	`TransformationSchemas`

Returns

Compiled & { sourceNodes: ReadonlyMap<RelationExpression, string> }

validateTransformationOutput

▸ validateTransformationOutput(actual, expected): void A fixed output dataset cannot silently change its contract on deployment.

Parameters

Name	Type
`actual`	readonly `TransformationColumn`[]
`expected`	readonly `TransformationColumn`[]

Returns

void

compileTransformationSQL

▸ compileTransformationSQL(graph, schemas, dialect, reads): TransformationSQL Editor graphs normalize to the canonical relation algebra before SQL lowering.

Parameters

Name	Type
`graph`	`TransformationGraph`
`schemas`	`TransformationSchemas`
`dialect`	`TransformationDialect`
`reads`	`SQLReadContext`

Returns

TransformationSQL

notMaintainedReason

▸ notMaintainedReason(...args): ReturnType<typeof wire.notMaintainedReason>

Parameters

Name	Type
`...args`	[reason: ViewPlanNotMaintained]

Returns

ReturnType<typeof wire.notMaintainedReason>

lookupStrategyLabel

▸ lookupStrategyLabel(...args): ReturnType<typeof wire.lookupStrategyLabel>

Parameters

Name	Type
`...args`	[lookup: ViewPlanLookup]

Returns

ReturnType<typeof wire.lookupStrategyLabel>

indexStrategyLabel

▸ indexStrategyLabel(...args): ReturnType<typeof wire.indexStrategyLabel>

Parameters

Name	Type
`...args`	[plan: ViewPlanExplanation, index: ViewPlanIndex]

Returns

ReturnType<typeof wire.indexStrategyLabel>

refusalReason

▸ refusalReason(...args): ReturnType<typeof wire.refusalReason>

Parameters

Name	Type
`...args`	[refusal: ViewPlanRefusal]

Returns

ReturnType<typeof wire.refusalReason>

viewPlanIsIndexed

▸ viewPlanIsIndexed(...args): ReturnType<typeof wire.viewPlanIsIndexed>

Parameters

Name	Type
`...args`	[plan: ViewPlanExplanation]

Returns

ReturnType<typeof wire.viewPlanIsIndexed>

viewPlanLines

▸ viewPlanLines(...args): ReturnType<typeof wire.viewPlanLines>

Parameters

Name	Type
`...args`	[plan: ViewPlanExplanation]

Returns

ReturnType<typeof wire.viewPlanLines>

viewPlanEvidence

▸ viewPlanEvidence(...args): ReturnType<typeof wire.viewPlanEvidence>

Parameters

Name	Type
`...args`	[plan: ViewPlanExplanation]

Returns

ReturnType<typeof wire.viewPlanEvidence>

viewWorkloadLines

▸ viewWorkloadLines(plan, value): string[]

Parameters

Name	Type
`plan`	`ViewPlanExplanation`
`value`	`unknown`

Returns

string[]

readViewWorkloadEvidence

▸ readViewWorkloadEvidence(value): ViewWorkloadEvidence Validate a supplied native workload artifact. It establishes no current program, provider guarantee or authorization.

Parameters

Name	Type
`value`	`unknown`

Returns

ViewWorkloadEvidence

​Classes

​Type Aliases

​ApproximateValue

​Type parameters

​Type declaration

​MeasuredValue

​Type parameters

​DecimalMeasure

​Type parameters

​GroupMeasure

​Type parameters

​Expand

​Type parameters

​PerParentMeasures

​Type parameters

​FlinkOptions

​FlinkColumn

​Type declaration

​FlinkProject

​MaterializeScalar

​MaterializeProject

​TemporalGraph

​AnalyticalRelationWorkLimits

​RetainedRelationWorkLimits

​RelationalEngine

​RelationalPlanOptions

​Type declaration

​RelationalCostLimits

​Type declaration

​RelationalInputs

​Type parameters

​RelationalHandler

​Type declaration

​SQLKernelProgram

​RelationalCapability

​RelationalArgument

​RelationalPlan

​ScalarType

​ClockObservation

​Type declaration

​ColumnHeader

​Type declaration

​ScalarFailureCode

​JsonValue

​SpatialOperation

​SpatialEvaluation

​Type declaration

​InterpolationMode

​OccurrenceSourceIdentity

​Finite

​CoordinateMap

​Type declaration

​GeometryOperand

​GeometryResult

​GeometryOperatorDescription

​Type declaration

​BufferCap

​BufferJoin

​Overlay

​GeometryOperation

​GeometryDeclaration

​Type declaration

​GeometryAllowance

​Type declaration

​GeometryRequest

​TrajectorySimplification

​Type declaration

​Measurement

​ScalarOrder

​Type declaration

​NormalizedMeasure

​NormalizedWindow

​Type declaration

​CarrierPlan

​Type declaration

​GeometrySize

​WireDomain

​ClosedTypes

​Type declaration

​NodeId

Classes

Type Aliases

ApproximateValue

Type parameters

Type declaration

MeasuredValue

Type parameters

DecimalMeasure

Type parameters

GroupMeasure

Type parameters

Expand

Type parameters

PerParentMeasures

Type parameters

FlinkOptions

FlinkColumn

Type declaration

FlinkProject

MaterializeScalar

MaterializeProject

TemporalGraph

AnalyticalRelationWorkLimits

RetainedRelationWorkLimits

RelationalEngine

RelationalPlanOptions

Type declaration

RelationalCostLimits

Type declaration

RelationalInputs

Type parameters

RelationalHandler

Type declaration

SQLKernelProgram

RelationalCapability

RelationalArgument

RelationalPlan

ScalarType

ClockObservation

Type declaration

ColumnHeader

Type declaration

ScalarFailureCode

JsonValue

SpatialOperation

SpatialEvaluation

Type declaration

InterpolationMode

OccurrenceSourceIdentity

Finite

CoordinateMap

Type declaration

GeometryOperand

GeometryResult

GeometryOperatorDescription

Type declaration

BufferCap

BufferJoin

Overlay

GeometryOperation

GeometryDeclaration

Type declaration

GeometryAllowance

Type declaration

GeometryRequest

TrajectorySimplification

Type declaration

Measurement

ScalarOrder

Type declaration

NormalizedMeasure

NormalizedWindow

Type declaration

CarrierPlan

Type declaration

GeometrySize

WireDomain

ClosedTypes

Type declaration

NodeId