Package org.partiql.plan

Types

Agg

data class Agg(signature: FunctionSignature.Aggregation) : PlanNode

Catalog

data class Catalog(name: String, symbols: List<Catalog.Symbol>) : PlanNode

data class Fn(signature: FunctionSignature.Scalar) : PlanNode

Identifier

sealed class Identifier : PlanNode

PartiQLPlan

data class PartiQLPlan(catalogs: List<Catalog>, statement: Statement) : PlanNode

PlanNode

abstract class PlanNode

Rel

data class Rel(type: Rel.Type, op: Rel.Op) : PlanNode

Rex

data class Rex(type: StaticType, op: Rex.Op) : PlanNode

Statement

sealed class Statement : PlanNode

Functions

agg

fun agg(signature: FunctionSignature.Aggregation): Agg

catalog

fun catalog(name: String, symbols: List<Catalog.Symbol>): Catalog

catalogSymbol

fun catalogSymbol(path: List<String>, type: StaticType): Catalog.Symbol

catalogSymbolRef

fun catalogSymbolRef(catalog: Int, symbol: Int): Catalog.Symbol.Ref

fun fn(signature: FunctionSignature.Scalar): Fn

identifierQualified

fun identifierQualified(root: Identifier.Symbol, steps: List<Identifier.Symbol>): Identifier.Qualified

identifierSymbol

fun identifierSymbol(symbol: String, caseSensitivity: Identifier.CaseSensitivity): Identifier.Symbol

partiQLPlan

fun partiQLPlan(catalogs: List<Catalog>, statement: Statement): PartiQLPlan

rel

fun rel(type: Rel.Type, op: Rel.Op): Rel

relBinding

fun relBinding(name: String, type: StaticType): Rel.Binding

relOpAggregate

fun relOpAggregate(input: Rel, strategy: Rel.Op.Aggregate.Strategy, calls: List<Rel.Op.Aggregate.Call>, groups: List<Rex>): Rel.Op.Aggregate

relOpAggregateCall

fun relOpAggregateCall(agg: Agg, args: List<Rex>): Rel.Op.Aggregate.Call

relOpDistinct

fun relOpDistinct(input: Rel): Rel.Op.Distinct

relOpErr

fun relOpErr(message: String): Rel.Op.Err

relOpExcept

fun relOpExcept(lhs: Rel, rhs: Rel): Rel.Op.Except

relOpExclude

fun relOpExclude(input: Rel, items: List<Rel.Op.Exclude.Item>): Rel.Op.Exclude

relOpExcludeItem

fun relOpExcludeItem(root: Rex.Op.Var, steps: List<Rel.Op.Exclude.Step>): Rel.Op.Exclude.Item

relOpExcludeStepCollIndex

fun relOpExcludeStepCollIndex(index: Int): Rel.Op.Exclude.Step.CollIndex

relOpExcludeStepCollWildcard

fun relOpExcludeStepCollWildcard(): Rel.Op.Exclude.Step.CollWildcard

relOpExcludeStepStructField

fun relOpExcludeStepStructField(symbol: Identifier.Symbol): Rel.Op.Exclude.Step.StructField

relOpExcludeStepStructWildcard

fun relOpExcludeStepStructWildcard(): Rel.Op.Exclude.Step.StructWildcard

relOpFilter

fun relOpFilter(input: Rel, predicate: Rex): Rel.Op.Filter

relOpIntersect

fun relOpIntersect(lhs: Rel, rhs: Rel): Rel.Op.Intersect

relOpJoin

fun relOpJoin(lhs: Rel, rhs: Rel, rex: Rex, type: Rel.Op.Join.Type): Rel.Op.Join

relOpLimit

fun relOpLimit(input: Rel, limit: Rex): Rel.Op.Limit

relOpOffset

fun relOpOffset(input: Rel, offset: Rex): Rel.Op.Offset

relOpProject

fun relOpProject(input: Rel, projections: List<Rex>): Rel.Op.Project

relOpScan

fun relOpScan(rex: Rex): Rel.Op.Scan

relOpScanIndexed

fun relOpScanIndexed(rex: Rex): Rel.Op.ScanIndexed

relOpSort

fun relOpSort(input: Rel, specs: List<Rel.Op.Sort.Spec>): Rel.Op.Sort

relOpSortSpec

fun relOpSortSpec(rex: Rex, order: Rel.Op.Sort.Order): Rel.Op.Sort.Spec

relOpUnion

fun relOpUnion(lhs: Rel, rhs: Rel): Rel.Op.Union

relOpUnpivot

fun relOpUnpivot(rex: Rex): Rel.Op.Unpivot

relType

fun relType(schema: List<Rel.Binding>, props: Set<Rel.Prop>): Rel.Type

rex

fun rex(type: StaticType, op: Rex.Op): Rex

rexOpCallDynamic

fun rexOpCallDynamic(args: List<Rex>, candidates: List<Rex.Op.Call.Dynamic.Candidate>): Rex.Op.Call.Dynamic

rexOpCallDynamicCandidate

fun rexOpCallDynamicCandidate(fn: Fn, coercions: List<Fn?>): Rex.Op.Call.Dynamic.Candidate

rexOpCallStatic

fun rexOpCallStatic(fn: Fn, args: List<Rex>): Rex.Op.Call.Static

rexOpCase

fun rexOpCase(branches: List<Rex.Op.Case.Branch>, default: Rex): Rex.Op.Case

rexOpCaseBranch

fun rexOpCaseBranch(condition: Rex, rex: Rex): Rex.Op.Case.Branch

rexOpCoalesce

fun rexOpCoalesce(args: List<Rex>): Rex.Op.Coalesce

rexOpCollection

fun rexOpCollection(values: List<Rex>): Rex.Op.Collection

rexOpErr

fun rexOpErr(message: String): Rex.Op.Err

rexOpGlobal

fun rexOpGlobal(ref: Catalog.Symbol.Ref): Rex.Op.Global

rexOpLit

fun rexOpLit(value: PartiQLValue): Rex.Op.Lit

rexOpNullif

fun rexOpNullif(value: Rex, nullifier: Rex): Rex.Op.Nullif

rexOpPathIndex

fun rexOpPathIndex(root: Rex, key: Rex): Rex.Op.Path.Index

rexOpPathKey

fun rexOpPathKey(root: Rex, key: Rex): Rex.Op.Path.Key

rexOpPathSymbol

fun rexOpPathSymbol(root: Rex, key: String): Rex.Op.Path.Symbol

rexOpPivot

fun rexOpPivot(key: Rex, value: Rex, rel: Rel): Rex.Op.Pivot

rexOpSelect

fun rexOpSelect(constructor: Rex, rel: Rel): Rex.Op.Select

rexOpStruct

fun rexOpStruct(fields: List<Rex.Op.Struct.Field>): Rex.Op.Struct

rexOpStructField

fun rexOpStructField(k: Rex, v: Rex): Rex.Op.Struct.Field

rexOpSubquery

fun rexOpSubquery(select: Rex.Op.Select, coercion: Rex.Op.Subquery.Coercion): Rex.Op.Subquery

rexOpTupleUnion

fun rexOpTupleUnion(args: List<Rex>): Rex.Op.TupleUnion

rexOpVar

fun rexOpVar(ref: Int): Rex.Op.Var

statementQuery

fun statementQuery(root: Rex): Statement.Query