org.partiql.lang.domains.PartiqlAst.generated.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of partiql-lang-kotlin Show documentation
Show all versions of partiql-lang-kotlin Show documentation
An implementation of PartiQL for the JVM written in Kotlin.
/**
* This code was generated by the PartiQL I.R. Generator.
* Do not modify this file.
*/
@file:Suppress("unused", "MemberVisibilityCanBePrivate", "FunctionName",
"CanBePrimaryConstructorProperty", "UNNECESSARY_SAFE_CALL",
"USELESS_ELVIS", "RemoveRedundantQualifierName", "LocalVariableName")
package org.partiql.lang.domains
import com.amazon.ionelement.api.*
import org.partiql.pig.runtime.*
class PartiqlAst private constructor() {
/////////////////////////////////////////////////////////////////////////////
// Builder
/////////////////////////////////////////////////////////////////////////////
companion object {
@JvmStatic
fun BUILDER() : Builder = PartiqlAstBuilder
fun build(block: Builder.() -> T) =
PartiqlAstBuilder.block()
fun transform(element: AnyElement): PartiqlAstNode =
transform(element.asSexp())
fun transform(element: SexpElement): PartiqlAstNode =
IonElementTransformer().transform(element)
}
interface Builder {
fun newMetaContainer() = emptyMetaContainer()
// Tuples
/**
* Creates an instance of [PartiqlAst.TimeValue].
*/
fun timeValue(
hour: Long,
minute: Long,
second: Long,
nano: Long,
precision: Long,
withTimeZone: Boolean,
tzMinutes: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.TimeValue =
PartiqlAst.TimeValue(
hour = hour.asPrimitive(),
minute = minute.asPrimitive(),
second = second.asPrimitive(),
nano = nano.asPrimitive(),
precision = precision.asPrimitive(),
withTimeZone = withTimeZone.asPrimitive(),
tzMinutes = tzMinutes?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.TimeValue].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun timeValue_(
hour: org.partiql.pig.runtime.LongPrimitive,
minute: org.partiql.pig.runtime.LongPrimitive,
second: org.partiql.pig.runtime.LongPrimitive,
nano: org.partiql.pig.runtime.LongPrimitive,
precision: org.partiql.pig.runtime.LongPrimitive,
withTimeZone: org.partiql.pig.runtime.BoolPrimitive,
tzMinutes: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.TimeValue =
PartiqlAst.TimeValue(
hour = hour,
minute = minute,
second = second,
nano = nano,
precision = precision,
withTimeZone = withTimeZone,
tzMinutes = tzMinutes,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Let].
*/
fun let(
letBindings: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Let =
PartiqlAst.Let(
letBindings = letBindings,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Let].
*/
fun let(
letBindings0: LetBinding,
vararg letBindings: LetBinding,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Let =
PartiqlAst.Let(
letBindings = listOf(letBindings0) + letBindings.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.LetBinding].
*/
fun letBinding(
expr: Expr,
name: String,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.LetBinding =
PartiqlAst.LetBinding(
expr = expr,
name = name.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.LetBinding].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun letBinding_(
expr: Expr,
name: org.partiql.pig.runtime.SymbolPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.LetBinding =
PartiqlAst.LetBinding(
expr = expr,
name = name,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchQuantifier].
*/
fun graphMatchQuantifier(
lower: Long,
upper: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchQuantifier =
PartiqlAst.GraphMatchQuantifier(
lower = lower.asPrimitive(),
upper = upper?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchQuantifier].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun graphMatchQuantifier_(
lower: org.partiql.pig.runtime.LongPrimitive,
upper: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchQuantifier =
PartiqlAst.GraphMatchQuantifier(
lower = lower,
upper = upper,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPattern].
*/
fun graphMatchPattern(
restrictor: GraphMatchRestrictor? = null,
prefilter: Expr? = null,
variable: String? = null,
quantifier: GraphMatchQuantifier? = null,
parts: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPattern =
PartiqlAst.GraphMatchPattern(
restrictor = restrictor,
prefilter = prefilter,
variable = variable?.asPrimitive(),
quantifier = quantifier,
parts = parts,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPattern].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun graphMatchPattern_(
restrictor: GraphMatchRestrictor? = null,
prefilter: Expr? = null,
variable: org.partiql.pig.runtime.SymbolPrimitive? = null,
quantifier: GraphMatchQuantifier? = null,
parts: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPattern =
PartiqlAst.GraphMatchPattern(
restrictor = restrictor,
prefilter = prefilter,
variable = variable,
quantifier = quantifier,
parts = parts,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPattern].
*/
fun graphMatchPattern(
restrictor: GraphMatchRestrictor? = null,
prefilter: Expr? = null,
variable: String? = null,
quantifier: GraphMatchQuantifier? = null,
parts0: GraphMatchPatternPart,
vararg parts: GraphMatchPatternPart,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPattern =
PartiqlAst.GraphMatchPattern(
restrictor = restrictor,
prefilter = prefilter,
variable = variable?.asPrimitive(),
quantifier = quantifier,
parts = listOf(parts0) + parts.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPattern].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun graphMatchPattern_(
restrictor: GraphMatchRestrictor? = null,
prefilter: Expr? = null,
variable: org.partiql.pig.runtime.SymbolPrimitive? = null,
quantifier: GraphMatchQuantifier? = null,
parts0: GraphMatchPatternPart,
vararg parts: GraphMatchPatternPart,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPattern =
PartiqlAst.GraphMatchPattern(
restrictor = restrictor,
prefilter = prefilter,
variable = variable,
quantifier = quantifier,
parts = listOf(parts0) + parts.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GpmlPattern].
*/
fun gpmlPattern(
selector: GraphMatchSelector? = null,
patterns: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GpmlPattern =
PartiqlAst.GpmlPattern(
selector = selector,
patterns = patterns,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GpmlPattern].
*/
fun gpmlPattern(
selector: GraphMatchSelector? = null,
patterns0: GraphMatchPattern,
vararg patterns: GraphMatchPattern,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GpmlPattern =
PartiqlAst.GpmlPattern(
selector = selector,
patterns = listOf(patterns0) + patterns.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ExprPair].
*/
fun exprPair(
first: Expr,
second: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ExprPair =
PartiqlAst.ExprPair(
first = first,
second = second,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ExprPairList].
*/
fun exprPairList(
pairs: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ExprPairList =
PartiqlAst.ExprPairList(
pairs = pairs,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ExprPairList].
*/
fun exprPairList(
vararg pairs: ExprPair,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ExprPairList =
PartiqlAst.ExprPairList(
pairs = pairs.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GroupBy].
*/
fun groupBy(
strategy: GroupingStrategy,
keyList: GroupKeyList,
groupAsAlias: String? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupBy =
PartiqlAst.GroupBy(
strategy = strategy,
keyList = keyList,
groupAsAlias = groupAsAlias?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GroupBy].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun groupBy_(
strategy: GroupingStrategy,
keyList: GroupKeyList,
groupAsAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupBy =
PartiqlAst.GroupBy(
strategy = strategy,
keyList = keyList,
groupAsAlias = groupAsAlias,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GroupKeyList].
*/
fun groupKeyList(
keys: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupKeyList =
PartiqlAst.GroupKeyList(
keys = keys,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GroupKeyList].
*/
fun groupKeyList(
keys0: GroupKey,
vararg keys: GroupKey,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupKeyList =
PartiqlAst.GroupKeyList(
keys = listOf(keys0) + keys.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GroupKey].
*/
fun groupKey(
expr: Expr,
asAlias: String? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupKey =
PartiqlAst.GroupKey(
expr = expr,
asAlias = asAlias?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GroupKey].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun groupKey_(
expr: Expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupKey =
PartiqlAst.GroupKey(
expr = expr,
asAlias = asAlias,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.OrderBy].
*/
fun orderBy(
sortSpecs: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.OrderBy =
PartiqlAst.OrderBy(
sortSpecs = sortSpecs,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.OrderBy].
*/
fun orderBy(
sortSpecs0: SortSpec,
vararg sortSpecs: SortSpec,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.OrderBy =
PartiqlAst.OrderBy(
sortSpecs = listOf(sortSpecs0) + sortSpecs.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.SortSpec].
*/
fun sortSpec(
expr: Expr,
orderingSpec: OrderingSpec? = null,
nullsSpec: NullsSpec? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.SortSpec =
PartiqlAst.SortSpec(
expr = expr,
orderingSpec = orderingSpec,
nullsSpec = nullsSpec,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Over].
*/
fun over(
partitionBy: WindowPartitionList? = null,
orderBy: WindowSortSpecList? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Over =
PartiqlAst.Over(
partitionBy = partitionBy,
orderBy = orderBy,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.WindowPartitionList].
*/
fun windowPartitionList(
exprs: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.WindowPartitionList =
PartiqlAst.WindowPartitionList(
exprs = exprs,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.WindowPartitionList].
*/
fun windowPartitionList(
exprs0: Expr,
vararg exprs: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.WindowPartitionList =
PartiqlAst.WindowPartitionList(
exprs = listOf(exprs0) + exprs.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.WindowSortSpecList].
*/
fun windowSortSpecList(
sortSpecs: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.WindowSortSpecList =
PartiqlAst.WindowSortSpecList(
sortSpecs = sortSpecs,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.WindowSortSpecList].
*/
fun windowSortSpecList(
sortSpecs0: SortSpec,
vararg sortSpecs: SortSpec,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.WindowSortSpecList =
PartiqlAst.WindowSortSpecList(
sortSpecs = listOf(sortSpecs0) + sortSpecs.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DmlOpList].
*/
fun dmlOpList(
ops: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DmlOpList =
PartiqlAst.DmlOpList(
ops = ops,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DmlOpList].
*/
fun dmlOpList(
ops0: DmlOp,
vararg ops: DmlOp,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DmlOpList =
PartiqlAst.DmlOpList(
ops = listOf(ops0) + ops.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.OnConflict].
*/
fun onConflict(
expr: Expr,
conflictAction: ConflictAction,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.OnConflict =
PartiqlAst.OnConflict(
expr = expr,
conflictAction = conflictAction,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ReturningExpr].
*/
fun returningExpr(
elems: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ReturningExpr =
PartiqlAst.ReturningExpr(
elems = elems,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ReturningExpr].
*/
fun returningExpr(
elems0: ReturningElem,
vararg elems: ReturningElem,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ReturningExpr =
PartiqlAst.ReturningExpr(
elems = listOf(elems0) + elems.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ReturningElem].
*/
fun returningElem(
mapping: ReturningMapping,
column: ColumnComponent,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ReturningElem =
PartiqlAst.ReturningElem(
mapping = mapping,
column = column,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Identifier].
*/
fun identifier(
name: String,
case: CaseSensitivity,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Identifier =
PartiqlAst.Identifier(
name = name.asPrimitive(),
case = case,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Identifier].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun identifier_(
name: org.partiql.pig.runtime.SymbolPrimitive,
case: CaseSensitivity,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Identifier =
PartiqlAst.Identifier(
name = name,
case = case,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Assignment].
*/
fun assignment(
target: Expr,
value: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Assignment =
PartiqlAst.Assignment(
target = target,
value = value,
metas = newMetaContainer() + metas
)
// Variants for Sum: Statement
/**
* Creates an instance of [PartiqlAst.Statement.Query].
*/
fun query(
expr: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Query =
PartiqlAst.Statement.Query(
expr = expr,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Statement.Dml].
*/
fun dml(
operations: DmlOpList,
from: FromSource? = null,
where: Expr? = null,
returning: ReturningExpr? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Dml =
PartiqlAst.Statement.Dml(
operations = operations,
from = from,
where = where,
returning = returning,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Statement.Ddl].
*/
fun ddl(
op: DdlOp,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Ddl =
PartiqlAst.Statement.Ddl(
op = op,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Statement.Exec].
*/
fun exec(
procedureName: String,
args: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Exec =
PartiqlAst.Statement.Exec(
procedureName = procedureName.asPrimitive(),
args = args,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Statement.Exec].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun exec_(
procedureName: org.partiql.pig.runtime.SymbolPrimitive,
args: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Exec =
PartiqlAst.Statement.Exec(
procedureName = procedureName,
args = args,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Statement.Exec].
*/
fun exec(
procedureName: String,
vararg args: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Exec =
PartiqlAst.Statement.Exec(
procedureName = procedureName?.asPrimitive(),
args = args.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Statement.Exec].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun exec_(
procedureName: org.partiql.pig.runtime.SymbolPrimitive,
vararg args: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Exec =
PartiqlAst.Statement.Exec(
procedureName = procedureName,
args = args.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Statement.Explain].
*/
fun explain(
target: ExplainTarget,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Statement.Explain =
PartiqlAst.Statement.Explain(
target = target,
metas = newMetaContainer() + metas
)
// Variants for Sum: ExplainTarget
/**
* Creates an instance of [PartiqlAst.ExplainTarget.Domain].
*/
fun domain(
statement: Statement,
type: String? = null,
format: String? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ExplainTarget.Domain =
PartiqlAst.ExplainTarget.Domain(
statement = statement,
type = type?.asPrimitive(),
format = format?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ExplainTarget.Domain].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun domain_(
statement: Statement,
type: org.partiql.pig.runtime.SymbolPrimitive? = null,
format: org.partiql.pig.runtime.SymbolPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ExplainTarget.Domain =
PartiqlAst.ExplainTarget.Domain(
statement = statement,
type = type,
format = format,
metas = newMetaContainer() + metas
)
// Variants for Sum: Expr
/**
* Creates an instance of [PartiqlAst.Expr.Missing].
*/
fun missing(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Missing =
PartiqlAst.Expr.Missing(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Lit].
*/
fun lit(
value: com.amazon.ionelement.api.IonElement,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Lit =
PartiqlAst.Expr.Lit(
value = value.asAnyElement(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Id].
*/
fun id(
name: String,
case: CaseSensitivity,
qualifier: ScopeQualifier,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Id =
PartiqlAst.Expr.Id(
name = name.asPrimitive(),
case = case,
qualifier = qualifier,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Id].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun id_(
name: org.partiql.pig.runtime.SymbolPrimitive,
case: CaseSensitivity,
qualifier: ScopeQualifier,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Id =
PartiqlAst.Expr.Id(
name = name,
case = case,
qualifier = qualifier,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Parameter].
*/
fun parameter(
index: Long,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Parameter =
PartiqlAst.Expr.Parameter(
index = index.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Parameter].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun parameter_(
index: org.partiql.pig.runtime.LongPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Parameter =
PartiqlAst.Expr.Parameter(
index = index,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Not].
*/
fun not(
expr: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Not =
PartiqlAst.Expr.Not(
expr = expr,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Pos].
*/
fun pos(
expr: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Pos =
PartiqlAst.Expr.Pos(
expr = expr,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Neg].
*/
fun neg(
expr: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Neg =
PartiqlAst.Expr.Neg(
expr = expr,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Plus].
*/
fun plus(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Plus =
PartiqlAst.Expr.Plus(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Plus].
*/
fun plus(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Plus =
PartiqlAst.Expr.Plus(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Minus].
*/
fun minus(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Minus =
PartiqlAst.Expr.Minus(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Minus].
*/
fun minus(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Minus =
PartiqlAst.Expr.Minus(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Times].
*/
fun times(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Times =
PartiqlAst.Expr.Times(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Times].
*/
fun times(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Times =
PartiqlAst.Expr.Times(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Divide].
*/
fun divide(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Divide =
PartiqlAst.Expr.Divide(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Divide].
*/
fun divide(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Divide =
PartiqlAst.Expr.Divide(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Modulo].
*/
fun modulo(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Modulo =
PartiqlAst.Expr.Modulo(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Modulo].
*/
fun modulo(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Modulo =
PartiqlAst.Expr.Modulo(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Concat].
*/
fun concat(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Concat =
PartiqlAst.Expr.Concat(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Concat].
*/
fun concat(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Concat =
PartiqlAst.Expr.Concat(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.And].
*/
fun and(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.And =
PartiqlAst.Expr.And(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.And].
*/
fun and(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.And =
PartiqlAst.Expr.And(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Or].
*/
fun or(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Or =
PartiqlAst.Expr.Or(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Or].
*/
fun or(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Or =
PartiqlAst.Expr.Or(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Eq].
*/
fun eq(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Eq =
PartiqlAst.Expr.Eq(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Eq].
*/
fun eq(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Eq =
PartiqlAst.Expr.Eq(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Ne].
*/
fun ne(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Ne =
PartiqlAst.Expr.Ne(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Ne].
*/
fun ne(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Ne =
PartiqlAst.Expr.Ne(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Gt].
*/
fun gt(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Gt =
PartiqlAst.Expr.Gt(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Gt].
*/
fun gt(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Gt =
PartiqlAst.Expr.Gt(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Gte].
*/
fun gte(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Gte =
PartiqlAst.Expr.Gte(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Gte].
*/
fun gte(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Gte =
PartiqlAst.Expr.Gte(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Lt].
*/
fun lt(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Lt =
PartiqlAst.Expr.Lt(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Lt].
*/
fun lt(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Lt =
PartiqlAst.Expr.Lt(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Lte].
*/
fun lte(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Lte =
PartiqlAst.Expr.Lte(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Lte].
*/
fun lte(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Lte =
PartiqlAst.Expr.Lte(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Like].
*/
fun like(
value: Expr,
pattern: Expr,
escape: Expr? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Like =
PartiqlAst.Expr.Like(
value = value,
pattern = pattern,
escape = escape,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Between].
*/
fun between(
value: Expr,
from: Expr,
to: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Between =
PartiqlAst.Expr.Between(
value = value,
from = from,
to = to,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.InCollection].
*/
fun inCollection(
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.InCollection =
PartiqlAst.Expr.InCollection(
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.InCollection].
*/
fun inCollection(
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.InCollection =
PartiqlAst.Expr.InCollection(
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.IsType].
*/
fun isType(
value: Expr,
type: Type,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.IsType =
PartiqlAst.Expr.IsType(
value = value,
type = type,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.SimpleCase].
*/
fun simpleCase(
expr: Expr,
cases: ExprPairList,
default: Expr? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.SimpleCase =
PartiqlAst.Expr.SimpleCase(
expr = expr,
cases = cases,
default = default,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.SearchedCase].
*/
fun searchedCase(
cases: ExprPairList,
default: Expr? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.SearchedCase =
PartiqlAst.Expr.SearchedCase(
cases = cases,
default = default,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Struct].
*/
fun struct(
fields: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Struct =
PartiqlAst.Expr.Struct(
fields = fields,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Struct].
*/
fun struct(
vararg fields: ExprPair,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Struct =
PartiqlAst.Expr.Struct(
fields = fields.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Bag].
*/
fun bag(
values: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Bag =
PartiqlAst.Expr.Bag(
values = values,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Bag].
*/
fun bag(
vararg values: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Bag =
PartiqlAst.Expr.Bag(
values = values.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.List].
*/
fun list(
values: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.List =
PartiqlAst.Expr.List(
values = values,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.List].
*/
fun list(
vararg values: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.List =
PartiqlAst.Expr.List(
values = values.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Sexp].
*/
fun sexp(
values: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Sexp =
PartiqlAst.Expr.Sexp(
values = values,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Sexp].
*/
fun sexp(
vararg values: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Sexp =
PartiqlAst.Expr.Sexp(
values = values.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Date].
*/
fun date(
year: Long,
month: Long,
day: Long,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Date =
PartiqlAst.Expr.Date(
year = year.asPrimitive(),
month = month.asPrimitive(),
day = day.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Date].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun date_(
year: org.partiql.pig.runtime.LongPrimitive,
month: org.partiql.pig.runtime.LongPrimitive,
day: org.partiql.pig.runtime.LongPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Date =
PartiqlAst.Expr.Date(
year = year,
month = month,
day = day,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.LitTime].
*/
fun litTime(
value: TimeValue,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.LitTime =
PartiqlAst.Expr.LitTime(
value = value,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.BagOp].
*/
fun bagOp(
op: BagOpType,
quantifier: SetQuantifier,
operands: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.BagOp =
PartiqlAst.Expr.BagOp(
op = op,
quantifier = quantifier,
operands = operands,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.BagOp].
*/
fun bagOp(
op: BagOpType,
quantifier: SetQuantifier,
operands0: Expr,
operands1: Expr,
vararg operands: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.BagOp =
PartiqlAst.Expr.BagOp(
op = op,
quantifier = quantifier,
operands = listOf(operands0, operands1) + operands.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.GraphMatch].
*/
fun graphMatch(
expr: Expr,
gpmlPattern: GpmlPattern,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.GraphMatch =
PartiqlAst.Expr.GraphMatch(
expr = expr,
gpmlPattern = gpmlPattern,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Path].
*/
fun path(
root: Expr,
steps: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Path =
PartiqlAst.Expr.Path(
root = root,
steps = steps,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Path].
*/
fun path(
root: Expr,
steps0: PathStep,
vararg steps: PathStep,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Path =
PartiqlAst.Expr.Path(
root = root,
steps = listOf(steps0) + steps.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Call].
*/
fun call(
funcName: String,
args: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Call =
PartiqlAst.Expr.Call(
funcName = funcName.asPrimitive(),
args = args,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Call].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun call_(
funcName: org.partiql.pig.runtime.SymbolPrimitive,
args: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Call =
PartiqlAst.Expr.Call(
funcName = funcName,
args = args,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Call].
*/
fun call(
funcName: String,
args0: Expr,
vararg args: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Call =
PartiqlAst.Expr.Call(
funcName = funcName?.asPrimitive(),
args = listOf(args0) + args.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Call].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun call_(
funcName: org.partiql.pig.runtime.SymbolPrimitive,
args0: Expr,
vararg args: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Call =
PartiqlAst.Expr.Call(
funcName = funcName,
args = listOf(args0) + args.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CallAgg].
*/
fun callAgg(
setq: SetQuantifier,
funcName: String,
arg: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CallAgg =
PartiqlAst.Expr.CallAgg(
setq = setq,
funcName = funcName.asPrimitive(),
arg = arg,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CallAgg].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun callAgg_(
setq: SetQuantifier,
funcName: org.partiql.pig.runtime.SymbolPrimitive,
arg: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CallAgg =
PartiqlAst.Expr.CallAgg(
setq = setq,
funcName = funcName,
arg = arg,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CallWindow].
*/
fun callWindow(
funcName: String,
over: Over,
args: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CallWindow =
PartiqlAst.Expr.CallWindow(
funcName = funcName.asPrimitive(),
over = over,
args = args,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CallWindow].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun callWindow_(
funcName: org.partiql.pig.runtime.SymbolPrimitive,
over: Over,
args: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CallWindow =
PartiqlAst.Expr.CallWindow(
funcName = funcName,
over = over,
args = args,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CallWindow].
*/
fun callWindow(
funcName: String,
over: Over,
args0: Expr,
vararg args: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CallWindow =
PartiqlAst.Expr.CallWindow(
funcName = funcName?.asPrimitive(),
over = over,
args = listOf(args0) + args.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CallWindow].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun callWindow_(
funcName: org.partiql.pig.runtime.SymbolPrimitive,
over: Over,
args0: Expr,
vararg args: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CallWindow =
PartiqlAst.Expr.CallWindow(
funcName = funcName,
over = over,
args = listOf(args0) + args.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Cast].
*/
fun cast(
value: Expr,
asType: Type,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Cast =
PartiqlAst.Expr.Cast(
value = value,
asType = asType,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CanCast].
*/
fun canCast(
value: Expr,
asType: Type,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CanCast =
PartiqlAst.Expr.CanCast(
value = value,
asType = asType,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.CanLosslessCast].
*/
fun canLosslessCast(
value: Expr,
asType: Type,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.CanLosslessCast =
PartiqlAst.Expr.CanLosslessCast(
value = value,
asType = asType,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.NullIf].
*/
fun nullIf(
expr1: Expr,
expr2: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.NullIf =
PartiqlAst.Expr.NullIf(
expr1 = expr1,
expr2 = expr2,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Coalesce].
*/
fun coalesce(
args: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Coalesce =
PartiqlAst.Expr.Coalesce(
args = args,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Coalesce].
*/
fun coalesce(
args0: Expr,
vararg args: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Coalesce =
PartiqlAst.Expr.Coalesce(
args = listOf(args0) + args.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Expr.Select].
*/
fun select(
setq: SetQuantifier? = null,
project: Projection,
from: FromSource,
fromLet: Let? = null,
where: Expr? = null,
group: GroupBy? = null,
having: Expr? = null,
order: OrderBy? = null,
limit: Expr? = null,
offset: Expr? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Expr.Select =
PartiqlAst.Expr.Select(
setq = setq,
project = project,
from = from,
fromLet = fromLet,
where = where,
group = group,
having = having,
order = order,
limit = limit,
offset = offset,
metas = newMetaContainer() + metas
)
// Variants for Sum: PathStep
/**
* Creates an instance of [PartiqlAst.PathStep.PathExpr].
*/
fun pathExpr(
index: Expr,
case: CaseSensitivity,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.PathStep.PathExpr =
PartiqlAst.PathStep.PathExpr(
index = index,
case = case,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.PathStep.PathWildcard].
*/
fun pathWildcard(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.PathStep.PathWildcard =
PartiqlAst.PathStep.PathWildcard(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.PathStep.PathUnpivot].
*/
fun pathUnpivot(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.PathStep.PathUnpivot =
PartiqlAst.PathStep.PathUnpivot(
metas = newMetaContainer() + metas
)
// Variants for Sum: Projection
/**
* Creates an instance of [PartiqlAst.Projection.ProjectStar].
*/
fun projectStar(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Projection.ProjectStar =
PartiqlAst.Projection.ProjectStar(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Projection.ProjectList].
*/
fun projectList(
projectItems: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Projection.ProjectList =
PartiqlAst.Projection.ProjectList(
projectItems = projectItems,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Projection.ProjectList].
*/
fun projectList(
projectItems0: ProjectItem,
vararg projectItems: ProjectItem,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Projection.ProjectList =
PartiqlAst.Projection.ProjectList(
projectItems = listOf(projectItems0) + projectItems.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Projection.ProjectPivot].
*/
fun projectPivot(
value: Expr,
key: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Projection.ProjectPivot =
PartiqlAst.Projection.ProjectPivot(
value = value,
key = key,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Projection.ProjectValue].
*/
fun projectValue(
value: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Projection.ProjectValue =
PartiqlAst.Projection.ProjectValue(
value = value,
metas = newMetaContainer() + metas
)
// Variants for Sum: ProjectItem
/**
* Creates an instance of [PartiqlAst.ProjectItem.ProjectAll].
*/
fun projectAll(
expr: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ProjectItem.ProjectAll =
PartiqlAst.ProjectItem.ProjectAll(
expr = expr,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ProjectItem.ProjectExpr].
*/
fun projectExpr(
expr: Expr,
asAlias: String? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ProjectItem.ProjectExpr =
PartiqlAst.ProjectItem.ProjectExpr(
expr = expr,
asAlias = asAlias?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ProjectItem.ProjectExpr].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun projectExpr_(
expr: Expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ProjectItem.ProjectExpr =
PartiqlAst.ProjectItem.ProjectExpr(
expr = expr,
asAlias = asAlias,
metas = newMetaContainer() + metas
)
// Variants for Sum: FromSource
/**
* Creates an instance of [PartiqlAst.FromSource.Scan].
*/
fun scan(
expr: Expr,
asAlias: String? = null,
atAlias: String? = null,
byAlias: String? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.FromSource.Scan =
PartiqlAst.FromSource.Scan(
expr = expr,
asAlias = asAlias?.asPrimitive(),
atAlias = atAlias?.asPrimitive(),
byAlias = byAlias?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.FromSource.Scan].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun scan_(
expr: Expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
atAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
byAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.FromSource.Scan =
PartiqlAst.FromSource.Scan(
expr = expr,
asAlias = asAlias,
atAlias = atAlias,
byAlias = byAlias,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.FromSource.Unpivot].
*/
fun unpivot(
expr: Expr,
asAlias: String? = null,
atAlias: String? = null,
byAlias: String? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.FromSource.Unpivot =
PartiqlAst.FromSource.Unpivot(
expr = expr,
asAlias = asAlias?.asPrimitive(),
atAlias = atAlias?.asPrimitive(),
byAlias = byAlias?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.FromSource.Unpivot].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun unpivot_(
expr: Expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
atAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
byAlias: org.partiql.pig.runtime.SymbolPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.FromSource.Unpivot =
PartiqlAst.FromSource.Unpivot(
expr = expr,
asAlias = asAlias,
atAlias = atAlias,
byAlias = byAlias,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.FromSource.Join].
*/
fun join(
type: JoinType,
left: FromSource,
right: FromSource,
predicate: Expr? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.FromSource.Join =
PartiqlAst.FromSource.Join(
type = type,
left = left,
right = right,
predicate = predicate,
metas = newMetaContainer() + metas
)
// Variants for Sum: JoinType
/**
* Creates an instance of [PartiqlAst.JoinType.Inner].
*/
fun inner(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.JoinType.Inner =
PartiqlAst.JoinType.Inner(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.JoinType.Left].
*/
fun left(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.JoinType.Left =
PartiqlAst.JoinType.Left(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.JoinType.Right].
*/
fun right(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.JoinType.Right =
PartiqlAst.JoinType.Right(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.JoinType.Full].
*/
fun full(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.JoinType.Full =
PartiqlAst.JoinType.Full(
metas = newMetaContainer() + metas
)
// Variants for Sum: GraphMatchDirection
/**
* Creates an instance of [PartiqlAst.GraphMatchDirection.EdgeLeft].
*/
fun edgeLeft(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchDirection.EdgeLeft =
PartiqlAst.GraphMatchDirection.EdgeLeft(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchDirection.EdgeUndirected].
*/
fun edgeUndirected(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchDirection.EdgeUndirected =
PartiqlAst.GraphMatchDirection.EdgeUndirected(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchDirection.EdgeRight].
*/
fun edgeRight(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchDirection.EdgeRight =
PartiqlAst.GraphMatchDirection.EdgeRight(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirected].
*/
fun edgeLeftOrUndirected(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirected =
PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirected(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchDirection.EdgeUndirectedOrRight].
*/
fun edgeUndirectedOrRight(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchDirection.EdgeUndirectedOrRight =
PartiqlAst.GraphMatchDirection.EdgeUndirectedOrRight(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchDirection.EdgeLeftOrRight].
*/
fun edgeLeftOrRight(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchDirection.EdgeLeftOrRight =
PartiqlAst.GraphMatchDirection.EdgeLeftOrRight(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirectedOrRight].
*/
fun edgeLeftOrUndirectedOrRight(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirectedOrRight =
PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirectedOrRight(
metas = newMetaContainer() + metas
)
// Variants for Sum: GraphMatchPatternPart
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Node].
*/
fun node(
prefilter: Expr? = null,
variable: String? = null,
label: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Node =
PartiqlAst.GraphMatchPatternPart.Node(
prefilter = prefilter,
variable = variable?.asPrimitive(),
label = label.map { it.asPrimitive() },
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Node].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun node_(
prefilter: Expr? = null,
variable: org.partiql.pig.runtime.SymbolPrimitive? = null,
label: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Node =
PartiqlAst.GraphMatchPatternPart.Node(
prefilter = prefilter,
variable = variable,
label = label,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Node].
*/
fun node(
prefilter: Expr? = null,
variable: String? = null,
vararg label: String,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Node =
PartiqlAst.GraphMatchPatternPart.Node(
prefilter = prefilter,
variable = variable?.asPrimitive(),
label = label.map { it.asPrimitive() },
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Node].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun node_(
prefilter: Expr? = null,
variable: org.partiql.pig.runtime.SymbolPrimitive? = null,
vararg label: org.partiql.pig.runtime.SymbolPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Node =
PartiqlAst.GraphMatchPatternPart.Node(
prefilter = prefilter,
variable = variable,
label = label.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Edge].
*/
fun edge(
direction: GraphMatchDirection,
quantifier: GraphMatchQuantifier? = null,
prefilter: Expr? = null,
variable: String? = null,
label: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Edge =
PartiqlAst.GraphMatchPatternPart.Edge(
direction = direction,
quantifier = quantifier,
prefilter = prefilter,
variable = variable?.asPrimitive(),
label = label.map { it.asPrimitive() },
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Edge].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun edge_(
direction: GraphMatchDirection,
quantifier: GraphMatchQuantifier? = null,
prefilter: Expr? = null,
variable: org.partiql.pig.runtime.SymbolPrimitive? = null,
label: kotlin.collections.List = emptyList(),
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Edge =
PartiqlAst.GraphMatchPatternPart.Edge(
direction = direction,
quantifier = quantifier,
prefilter = prefilter,
variable = variable,
label = label,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Edge].
*/
fun edge(
direction: GraphMatchDirection,
quantifier: GraphMatchQuantifier? = null,
prefilter: Expr? = null,
variable: String? = null,
vararg label: String,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Edge =
PartiqlAst.GraphMatchPatternPart.Edge(
direction = direction,
quantifier = quantifier,
prefilter = prefilter,
variable = variable?.asPrimitive(),
label = label.map { it.asPrimitive() },
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Edge].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun edge_(
direction: GraphMatchDirection,
quantifier: GraphMatchQuantifier? = null,
prefilter: Expr? = null,
variable: org.partiql.pig.runtime.SymbolPrimitive? = null,
vararg label: org.partiql.pig.runtime.SymbolPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Edge =
PartiqlAst.GraphMatchPatternPart.Edge(
direction = direction,
quantifier = quantifier,
prefilter = prefilter,
variable = variable,
label = label.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchPatternPart.Pattern].
*/
fun pattern(
pattern: GraphMatchPattern,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchPatternPart.Pattern =
PartiqlAst.GraphMatchPatternPart.Pattern(
pattern = pattern,
metas = newMetaContainer() + metas
)
// Variants for Sum: GraphMatchRestrictor
/**
* Creates an instance of [PartiqlAst.GraphMatchRestrictor.RestrictorTrail].
*/
fun restrictorTrail(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchRestrictor.RestrictorTrail =
PartiqlAst.GraphMatchRestrictor.RestrictorTrail(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchRestrictor.RestrictorAcyclic].
*/
fun restrictorAcyclic(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchRestrictor.RestrictorAcyclic =
PartiqlAst.GraphMatchRestrictor.RestrictorAcyclic(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchRestrictor.RestrictorSimple].
*/
fun restrictorSimple(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchRestrictor.RestrictorSimple =
PartiqlAst.GraphMatchRestrictor.RestrictorSimple(
metas = newMetaContainer() + metas
)
// Variants for Sum: GraphMatchSelector
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorAnyShortest].
*/
fun selectorAnyShortest(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorAnyShortest =
PartiqlAst.GraphMatchSelector.SelectorAnyShortest(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorAllShortest].
*/
fun selectorAllShortest(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorAllShortest =
PartiqlAst.GraphMatchSelector.SelectorAllShortest(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorAny].
*/
fun selectorAny(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorAny =
PartiqlAst.GraphMatchSelector.SelectorAny(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorAnyK].
*/
fun selectorAnyK(
k: Long,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorAnyK =
PartiqlAst.GraphMatchSelector.SelectorAnyK(
k = k.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorAnyK].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun selectorAnyK_(
k: org.partiql.pig.runtime.LongPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorAnyK =
PartiqlAst.GraphMatchSelector.SelectorAnyK(
k = k,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorShortestK].
*/
fun selectorShortestK(
k: Long,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorShortestK =
PartiqlAst.GraphMatchSelector.SelectorShortestK(
k = k.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorShortestK].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun selectorShortestK_(
k: org.partiql.pig.runtime.LongPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorShortestK =
PartiqlAst.GraphMatchSelector.SelectorShortestK(
k = k,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorShortestKGroup].
*/
fun selectorShortestKGroup(
k: Long,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorShortestKGroup =
PartiqlAst.GraphMatchSelector.SelectorShortestKGroup(
k = k.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GraphMatchSelector.SelectorShortestKGroup].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun selectorShortestKGroup_(
k: org.partiql.pig.runtime.LongPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GraphMatchSelector.SelectorShortestKGroup =
PartiqlAst.GraphMatchSelector.SelectorShortestKGroup(
k = k,
metas = newMetaContainer() + metas
)
// Variants for Sum: GroupingStrategy
/**
* Creates an instance of [PartiqlAst.GroupingStrategy.GroupFull].
*/
fun groupFull(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupingStrategy.GroupFull =
PartiqlAst.GroupingStrategy.GroupFull(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.GroupingStrategy.GroupPartial].
*/
fun groupPartial(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.GroupingStrategy.GroupPartial =
PartiqlAst.GroupingStrategy.GroupPartial(
metas = newMetaContainer() + metas
)
// Variants for Sum: OrderingSpec
/**
* Creates an instance of [PartiqlAst.OrderingSpec.Asc].
*/
fun asc(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.OrderingSpec.Asc =
PartiqlAst.OrderingSpec.Asc(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.OrderingSpec.Desc].
*/
fun desc(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.OrderingSpec.Desc =
PartiqlAst.OrderingSpec.Desc(
metas = newMetaContainer() + metas
)
// Variants for Sum: NullsSpec
/**
* Creates an instance of [PartiqlAst.NullsSpec.NullsFirst].
*/
fun nullsFirst(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.NullsSpec.NullsFirst =
PartiqlAst.NullsSpec.NullsFirst(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.NullsSpec.NullsLast].
*/
fun nullsLast(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.NullsSpec.NullsLast =
PartiqlAst.NullsSpec.NullsLast(
metas = newMetaContainer() + metas
)
// Variants for Sum: CaseSensitivity
/**
* Creates an instance of [PartiqlAst.CaseSensitivity.CaseSensitive].
*/
fun caseSensitive(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.CaseSensitivity.CaseSensitive =
PartiqlAst.CaseSensitivity.CaseSensitive(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.CaseSensitivity.CaseInsensitive].
*/
fun caseInsensitive(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.CaseSensitivity.CaseInsensitive =
PartiqlAst.CaseSensitivity.CaseInsensitive(
metas = newMetaContainer() + metas
)
// Variants for Sum: ScopeQualifier
/**
* Creates an instance of [PartiqlAst.ScopeQualifier.Unqualified].
*/
fun unqualified(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ScopeQualifier.Unqualified =
PartiqlAst.ScopeQualifier.Unqualified(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ScopeQualifier.LocalsFirst].
*/
fun localsFirst(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ScopeQualifier.LocalsFirst =
PartiqlAst.ScopeQualifier.LocalsFirst(
metas = newMetaContainer() + metas
)
// Variants for Sum: SetQuantifier
/**
* Creates an instance of [PartiqlAst.SetQuantifier.All].
*/
fun all(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.SetQuantifier.All =
PartiqlAst.SetQuantifier.All(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.SetQuantifier.Distinct].
*/
fun distinct(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.SetQuantifier.Distinct =
PartiqlAst.SetQuantifier.Distinct(
metas = newMetaContainer() + metas
)
// Variants for Sum: BagOpType
/**
* Creates an instance of [PartiqlAst.BagOpType.Union].
*/
fun union(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.BagOpType.Union =
PartiqlAst.BagOpType.Union(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.BagOpType.Intersect].
*/
fun intersect(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.BagOpType.Intersect =
PartiqlAst.BagOpType.Intersect(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.BagOpType.Except].
*/
fun except(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.BagOpType.Except =
PartiqlAst.BagOpType.Except(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.BagOpType.OuterUnion].
*/
fun outerUnion(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.BagOpType.OuterUnion =
PartiqlAst.BagOpType.OuterUnion(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.BagOpType.OuterIntersect].
*/
fun outerIntersect(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.BagOpType.OuterIntersect =
PartiqlAst.BagOpType.OuterIntersect(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.BagOpType.OuterExcept].
*/
fun outerExcept(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.BagOpType.OuterExcept =
PartiqlAst.BagOpType.OuterExcept(
metas = newMetaContainer() + metas
)
// Variants for Sum: DmlOp
/**
* Creates an instance of [PartiqlAst.DmlOp.Insert].
*/
fun insert(
target: Expr,
values: Expr,
conflictAction: ConflictAction? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DmlOp.Insert =
PartiqlAst.DmlOp.Insert(
target = target,
values = values,
conflictAction = conflictAction,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DmlOp.InsertValue].
*/
fun insertValue(
target: Expr,
value: Expr,
index: Expr? = null,
onConflict: OnConflict? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DmlOp.InsertValue =
PartiqlAst.DmlOp.InsertValue(
target = target,
value = value,
index = index,
onConflict = onConflict,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DmlOp.Set].
*/
fun set(
assignment: Assignment,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DmlOp.Set =
PartiqlAst.DmlOp.Set(
assignment = assignment,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DmlOp.Remove].
*/
fun remove(
target: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DmlOp.Remove =
PartiqlAst.DmlOp.Remove(
target = target,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DmlOp.Delete].
*/
fun delete(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DmlOp.Delete =
PartiqlAst.DmlOp.Delete(
metas = newMetaContainer() + metas
)
// Variants for Sum: ConflictAction
/**
* Creates an instance of [PartiqlAst.ConflictAction.DoReplace].
*/
fun doReplace(
value: OnConflictValue,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ConflictAction.DoReplace =
PartiqlAst.ConflictAction.DoReplace(
value = value,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ConflictAction.DoUpdate].
*/
fun doUpdate(
value: OnConflictValue,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ConflictAction.DoUpdate =
PartiqlAst.ConflictAction.DoUpdate(
value = value,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ConflictAction.DoNothing].
*/
fun doNothing(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ConflictAction.DoNothing =
PartiqlAst.ConflictAction.DoNothing(
metas = newMetaContainer() + metas
)
// Variants for Sum: OnConflictValue
/**
* Creates an instance of [PartiqlAst.OnConflictValue.Excluded].
*/
fun excluded(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.OnConflictValue.Excluded =
PartiqlAst.OnConflictValue.Excluded(
metas = newMetaContainer() + metas
)
// Variants for Sum: DdlOp
/**
* Creates an instance of [PartiqlAst.DdlOp.CreateTable].
*/
fun createTable(
tableName: String,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DdlOp.CreateTable =
PartiqlAst.DdlOp.CreateTable(
tableName = tableName.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DdlOp.CreateTable].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun createTable_(
tableName: org.partiql.pig.runtime.SymbolPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DdlOp.CreateTable =
PartiqlAst.DdlOp.CreateTable(
tableName = tableName,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DdlOp.DropTable].
*/
fun dropTable(
tableName: Identifier,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DdlOp.DropTable =
PartiqlAst.DdlOp.DropTable(
tableName = tableName,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DdlOp.CreateIndex].
*/
fun createIndex(
indexName: Identifier,
fields: kotlin.collections.List,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DdlOp.CreateIndex =
PartiqlAst.DdlOp.CreateIndex(
indexName = indexName,
fields = fields,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DdlOp.CreateIndex].
*/
fun createIndex(
indexName: Identifier,
fields0: Expr,
vararg fields: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DdlOp.CreateIndex =
PartiqlAst.DdlOp.CreateIndex(
indexName = indexName,
fields = listOf(fields0) + fields.toList(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.DdlOp.DropIndex].
*/
fun dropIndex(
table: Identifier,
keys: Identifier,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.DdlOp.DropIndex =
PartiqlAst.DdlOp.DropIndex(
table = table,
keys = keys,
metas = newMetaContainer() + metas
)
// Variants for Sum: ColumnComponent
/**
* Creates an instance of [PartiqlAst.ColumnComponent.ReturningWildcard].
*/
fun returningWildcard(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ColumnComponent.ReturningWildcard =
PartiqlAst.ColumnComponent.ReturningWildcard(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ColumnComponent.ReturningColumn].
*/
fun returningColumn(
expr: Expr,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ColumnComponent.ReturningColumn =
PartiqlAst.ColumnComponent.ReturningColumn(
expr = expr,
metas = newMetaContainer() + metas
)
// Variants for Sum: ReturningMapping
/**
* Creates an instance of [PartiqlAst.ReturningMapping.ModifiedNew].
*/
fun modifiedNew(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ReturningMapping.ModifiedNew =
PartiqlAst.ReturningMapping.ModifiedNew(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ReturningMapping.ModifiedOld].
*/
fun modifiedOld(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ReturningMapping.ModifiedOld =
PartiqlAst.ReturningMapping.ModifiedOld(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ReturningMapping.AllNew].
*/
fun allNew(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ReturningMapping.AllNew =
PartiqlAst.ReturningMapping.AllNew(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.ReturningMapping.AllOld].
*/
fun allOld(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.ReturningMapping.AllOld =
PartiqlAst.ReturningMapping.AllOld(
metas = newMetaContainer() + metas
)
// Variants for Sum: Type
/**
* Creates an instance of [PartiqlAst.Type.NullType].
*/
fun nullType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.NullType =
PartiqlAst.Type.NullType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.BooleanType].
*/
fun booleanType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.BooleanType =
PartiqlAst.Type.BooleanType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.SmallintType].
*/
fun smallintType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.SmallintType =
PartiqlAst.Type.SmallintType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.Integer4Type].
*/
fun integer4Type(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.Integer4Type =
PartiqlAst.Type.Integer4Type(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.Integer8Type].
*/
fun integer8Type(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.Integer8Type =
PartiqlAst.Type.Integer8Type(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.IntegerType].
*/
fun integerType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.IntegerType =
PartiqlAst.Type.IntegerType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.FloatType].
*/
fun floatType(
precision: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.FloatType =
PartiqlAst.Type.FloatType(
precision = precision?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.FloatType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun floatType_(
precision: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.FloatType =
PartiqlAst.Type.FloatType(
precision = precision,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.RealType].
*/
fun realType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.RealType =
PartiqlAst.Type.RealType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.DoublePrecisionType].
*/
fun doublePrecisionType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.DoublePrecisionType =
PartiqlAst.Type.DoublePrecisionType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.DecimalType].
*/
fun decimalType(
precision: Long? = null,
scale: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.DecimalType =
PartiqlAst.Type.DecimalType(
precision = precision?.asPrimitive(),
scale = scale?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.DecimalType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun decimalType_(
precision: org.partiql.pig.runtime.LongPrimitive? = null,
scale: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.DecimalType =
PartiqlAst.Type.DecimalType(
precision = precision,
scale = scale,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.NumericType].
*/
fun numericType(
precision: Long? = null,
scale: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.NumericType =
PartiqlAst.Type.NumericType(
precision = precision?.asPrimitive(),
scale = scale?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.NumericType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun numericType_(
precision: org.partiql.pig.runtime.LongPrimitive? = null,
scale: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.NumericType =
PartiqlAst.Type.NumericType(
precision = precision,
scale = scale,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.TimestampType].
*/
fun timestampType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.TimestampType =
PartiqlAst.Type.TimestampType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.CharacterType].
*/
fun characterType(
length: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.CharacterType =
PartiqlAst.Type.CharacterType(
length = length?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.CharacterType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun characterType_(
length: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.CharacterType =
PartiqlAst.Type.CharacterType(
length = length,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.CharacterVaryingType].
*/
fun characterVaryingType(
length: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.CharacterVaryingType =
PartiqlAst.Type.CharacterVaryingType(
length = length?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.CharacterVaryingType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun characterVaryingType_(
length: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.CharacterVaryingType =
PartiqlAst.Type.CharacterVaryingType(
length = length,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.MissingType].
*/
fun missingType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.MissingType =
PartiqlAst.Type.MissingType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.StringType].
*/
fun stringType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.StringType =
PartiqlAst.Type.StringType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.SymbolType].
*/
fun symbolType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.SymbolType =
PartiqlAst.Type.SymbolType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.BlobType].
*/
fun blobType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.BlobType =
PartiqlAst.Type.BlobType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.ClobType].
*/
fun clobType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.ClobType =
PartiqlAst.Type.ClobType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.DateType].
*/
fun dateType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.DateType =
PartiqlAst.Type.DateType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.TimeType].
*/
fun timeType(
precision: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.TimeType =
PartiqlAst.Type.TimeType(
precision = precision?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.TimeType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun timeType_(
precision: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.TimeType =
PartiqlAst.Type.TimeType(
precision = precision,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.TimeWithTimeZoneType].
*/
fun timeWithTimeZoneType(
precision: Long? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.TimeWithTimeZoneType =
PartiqlAst.Type.TimeWithTimeZoneType(
precision = precision?.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.TimeWithTimeZoneType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun timeWithTimeZoneType_(
precision: org.partiql.pig.runtime.LongPrimitive? = null,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.TimeWithTimeZoneType =
PartiqlAst.Type.TimeWithTimeZoneType(
precision = precision,
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.StructType].
*/
fun structType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.StructType =
PartiqlAst.Type.StructType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.TupleType].
*/
fun tupleType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.TupleType =
PartiqlAst.Type.TupleType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.ListType].
*/
fun listType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.ListType =
PartiqlAst.Type.ListType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.SexpType].
*/
fun sexpType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.SexpType =
PartiqlAst.Type.SexpType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.BagType].
*/
fun bagType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.BagType =
PartiqlAst.Type.BagType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.AnyType].
*/
fun anyType(
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.AnyType =
PartiqlAst.Type.AnyType(
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.CustomType].
*/
fun customType(
name: String,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.CustomType =
PartiqlAst.Type.CustomType(
name = name.asPrimitive(),
metas = newMetaContainer() + metas
)
/**
* Creates an instance of [PartiqlAst.Type.CustomType].
*
* Use this variant when metas must be passed to primitive child elements.
*
* (The "_" suffix is needed to work-around conflicts due to type erasure and ambiguities with null arguments.)
*/
fun customType_(
name: org.partiql.pig.runtime.SymbolPrimitive,
metas: MetaContainer = emptyMetaContainer()
): PartiqlAst.Type.CustomType =
PartiqlAst.Type.CustomType(
name = name,
metas = newMetaContainer() + metas
)
}
/** Default implementation of [Builder] that uses all default method implementations. */
private object PartiqlAstBuilder : Builder
/** Base class for all PartiqlAst types. */
abstract class PartiqlAstNode : DomainNode {
abstract override fun copy(metas: MetaContainer): PartiqlAstNode
override fun toString() = toIonElement().toString()
abstract override fun withMeta(metaKey: String, metaValue: Any): PartiqlAstNode
abstract override fun toIonElement(): SexpElement
}
/////////////////////////////////////////////////////////////////////////////
// Tuple Types
/////////////////////////////////////////////////////////////////////////////
class TimeValue(
val hour: org.partiql.pig.runtime.LongPrimitive,
val minute: org.partiql.pig.runtime.LongPrimitive,
val second: org.partiql.pig.runtime.LongPrimitive,
val nano: org.partiql.pig.runtime.LongPrimitive,
val precision: org.partiql.pig.runtime.LongPrimitive,
val withTimeZone: org.partiql.pig.runtime.BoolPrimitive,
val tzMinutes: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): TimeValue =
TimeValue(
hour = hour,
minute = minute,
second = second,
nano = nano,
precision = precision,
withTimeZone = withTimeZone,
tzMinutes = tzMinutes,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): TimeValue =
TimeValue(
hour = hour,
minute = minute,
second = second,
nano = nano,
precision = precision,
withTimeZone = withTimeZone,
tzMinutes = tzMinutes,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("time_value"),
hour.toIonElement(),
minute.toIonElement(),
second.toIonElement(),
nano.toIonElement(),
precision.toIonElement(),
withTimeZone.toIonElement(),
tzMinutes?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
hour: org.partiql.pig.runtime.LongPrimitive = this.hour,
minute: org.partiql.pig.runtime.LongPrimitive = this.minute,
second: org.partiql.pig.runtime.LongPrimitive = this.second,
nano: org.partiql.pig.runtime.LongPrimitive = this.nano,
precision: org.partiql.pig.runtime.LongPrimitive = this.precision,
withTimeZone: org.partiql.pig.runtime.BoolPrimitive = this.withTimeZone,
tzMinutes: org.partiql.pig.runtime.LongPrimitive? = this.tzMinutes,
metas: MetaContainer = this.metas
) =
TimeValue(
hour,
minute,
second,
nano,
precision,
withTimeZone,
tzMinutes,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != TimeValue::class.java) return false
other as TimeValue
if (hour != other.hour) return false
if (minute != other.minute) return false
if (second != other.second) return false
if (nano != other.nano) return false
if (precision != other.precision) return false
if (withTimeZone != other.withTimeZone) return false
if (tzMinutes != other.tzMinutes) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = hour.hashCode()
hc = 31 * hc + minute.hashCode()
hc = 31 * hc + second.hashCode()
hc = 31 * hc + nano.hashCode()
hc = 31 * hc + precision.hashCode()
hc = 31 * hc + withTimeZone.hashCode()
hc = 31 * hc + tzMinutes.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Let(
val letBindings: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): Let =
Let(
letBindings = letBindings,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Let =
Let(
letBindings = letBindings,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("let"),
*letBindings.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
letBindings: kotlin.collections.List = this.letBindings,
metas: MetaContainer = this.metas
) =
Let(
letBindings,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Let::class.java) return false
other as Let
if (letBindings != other.letBindings) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = letBindings.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class LetBinding(
val expr: Expr,
val name: org.partiql.pig.runtime.SymbolPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): LetBinding =
LetBinding(
expr = expr,
name = name,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): LetBinding =
LetBinding(
expr = expr,
name = name,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("let_binding"),
expr.toIonElement(),
name.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
name: org.partiql.pig.runtime.SymbolPrimitive = this.name,
metas: MetaContainer = this.metas
) =
LetBinding(
expr,
name,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != LetBinding::class.java) return false
other as LetBinding
if (expr != other.expr) return false
if (name != other.name) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + name.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class GraphMatchQuantifier(
val lower: org.partiql.pig.runtime.LongPrimitive,
val upper: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): GraphMatchQuantifier =
GraphMatchQuantifier(
lower = lower,
upper = upper,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GraphMatchQuantifier =
GraphMatchQuantifier(
lower = lower,
upper = upper,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("graph_match_quantifier"),
lower.toIonElement(),
upper?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
lower: org.partiql.pig.runtime.LongPrimitive = this.lower,
upper: org.partiql.pig.runtime.LongPrimitive? = this.upper,
metas: MetaContainer = this.metas
) =
GraphMatchQuantifier(
lower,
upper,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GraphMatchQuantifier::class.java) return false
other as GraphMatchQuantifier
if (lower != other.lower) return false
if (upper != other.upper) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = lower.hashCode()
hc = 31 * hc + upper.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class GraphMatchPattern(
val restrictor: GraphMatchRestrictor?,
val prefilter: Expr?,
val variable: org.partiql.pig.runtime.SymbolPrimitive?,
val quantifier: GraphMatchQuantifier?,
val parts: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): GraphMatchPattern =
GraphMatchPattern(
restrictor = restrictor,
prefilter = prefilter,
variable = variable,
quantifier = quantifier,
parts = parts,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GraphMatchPattern =
GraphMatchPattern(
restrictor = restrictor,
prefilter = prefilter,
variable = variable,
quantifier = quantifier,
parts = parts,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("graph_match_pattern"),
restrictor?.toIonElement() ?: ionNull(),
prefilter?.toIonElement() ?: ionNull(),
variable?.toIonElement() ?: ionNull(),
quantifier?.toIonElement() ?: ionNull(),
*parts.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
restrictor: GraphMatchRestrictor? = this.restrictor,
prefilter: Expr? = this.prefilter,
variable: org.partiql.pig.runtime.SymbolPrimitive? = this.variable,
quantifier: GraphMatchQuantifier? = this.quantifier,
parts: kotlin.collections.List = this.parts,
metas: MetaContainer = this.metas
) =
GraphMatchPattern(
restrictor,
prefilter,
variable,
quantifier,
parts,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GraphMatchPattern::class.java) return false
other as GraphMatchPattern
if (restrictor != other.restrictor) return false
if (prefilter != other.prefilter) return false
if (variable != other.variable) return false
if (quantifier != other.quantifier) return false
if (parts != other.parts) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = restrictor.hashCode()
hc = 31 * hc + prefilter.hashCode()
hc = 31 * hc + variable.hashCode()
hc = 31 * hc + quantifier.hashCode()
hc = 31 * hc + parts.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class GpmlPattern(
val selector: GraphMatchSelector?,
val patterns: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): GpmlPattern =
GpmlPattern(
selector = selector,
patterns = patterns,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GpmlPattern =
GpmlPattern(
selector = selector,
patterns = patterns,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("gpml_pattern"),
selector?.toIonElement() ?: ionNull(),
*patterns.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
selector: GraphMatchSelector? = this.selector,
patterns: kotlin.collections.List = this.patterns,
metas: MetaContainer = this.metas
) =
GpmlPattern(
selector,
patterns,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GpmlPattern::class.java) return false
other as GpmlPattern
if (selector != other.selector) return false
if (patterns != other.patterns) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = selector.hashCode()
hc = 31 * hc + patterns.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class ExprPair(
val first: Expr,
val second: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): ExprPair =
ExprPair(
first = first,
second = second,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ExprPair =
ExprPair(
first = first,
second = second,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("expr_pair"),
first.toIonElement(),
second.toIonElement(),
metas = metas)
return elements
}
fun copy(
first: Expr = this.first,
second: Expr = this.second,
metas: MetaContainer = this.metas
) =
ExprPair(
first,
second,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ExprPair::class.java) return false
other as ExprPair
if (first != other.first) return false
if (second != other.second) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = first.hashCode()
hc = 31 * hc + second.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class ExprPairList(
val pairs: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): ExprPairList =
ExprPairList(
pairs = pairs,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ExprPairList =
ExprPairList(
pairs = pairs,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("expr_pair_list"),
*pairs.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
pairs: kotlin.collections.List = this.pairs,
metas: MetaContainer = this.metas
) =
ExprPairList(
pairs,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ExprPairList::class.java) return false
other as ExprPairList
if (pairs != other.pairs) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = pairs.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class GroupBy(
val strategy: GroupingStrategy,
val keyList: GroupKeyList,
val groupAsAlias: org.partiql.pig.runtime.SymbolPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): GroupBy =
GroupBy(
strategy = strategy,
keyList = keyList,
groupAsAlias = groupAsAlias,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GroupBy =
GroupBy(
strategy = strategy,
keyList = keyList,
groupAsAlias = groupAsAlias,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("group_by"),
strategy.toIonElement(),
keyList.toIonElement(),
groupAsAlias?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
strategy: GroupingStrategy = this.strategy,
keyList: GroupKeyList = this.keyList,
groupAsAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.groupAsAlias,
metas: MetaContainer = this.metas
) =
GroupBy(
strategy,
keyList,
groupAsAlias,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GroupBy::class.java) return false
other as GroupBy
if (strategy != other.strategy) return false
if (keyList != other.keyList) return false
if (groupAsAlias != other.groupAsAlias) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = strategy.hashCode()
hc = 31 * hc + keyList.hashCode()
hc = 31 * hc + groupAsAlias.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class GroupKeyList(
val keys: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): GroupKeyList =
GroupKeyList(
keys = keys,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GroupKeyList =
GroupKeyList(
keys = keys,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("group_key_list"),
*keys.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
keys: kotlin.collections.List = this.keys,
metas: MetaContainer = this.metas
) =
GroupKeyList(
keys,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GroupKeyList::class.java) return false
other as GroupKeyList
if (keys != other.keys) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = keys.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class GroupKey(
val expr: Expr,
val asAlias: org.partiql.pig.runtime.SymbolPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): GroupKey =
GroupKey(
expr = expr,
asAlias = asAlias,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GroupKey =
GroupKey(
expr = expr,
asAlias = asAlias,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("group_key"),
expr.toIonElement(),
asAlias?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.asAlias,
metas: MetaContainer = this.metas
) =
GroupKey(
expr,
asAlias,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GroupKey::class.java) return false
other as GroupKey
if (expr != other.expr) return false
if (asAlias != other.asAlias) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + asAlias.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class OrderBy(
val sortSpecs: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): OrderBy =
OrderBy(
sortSpecs = sortSpecs,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): OrderBy =
OrderBy(
sortSpecs = sortSpecs,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("order_by"),
*sortSpecs.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
sortSpecs: kotlin.collections.List = this.sortSpecs,
metas: MetaContainer = this.metas
) =
OrderBy(
sortSpecs,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != OrderBy::class.java) return false
other as OrderBy
if (sortSpecs != other.sortSpecs) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = sortSpecs.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class SortSpec(
val expr: Expr,
val orderingSpec: OrderingSpec?,
val nullsSpec: NullsSpec?,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): SortSpec =
SortSpec(
expr = expr,
orderingSpec = orderingSpec,
nullsSpec = nullsSpec,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SortSpec =
SortSpec(
expr = expr,
orderingSpec = orderingSpec,
nullsSpec = nullsSpec,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("sort_spec"),
expr.toIonElement(),
orderingSpec?.toIonElement() ?: ionNull(),
nullsSpec?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
orderingSpec: OrderingSpec? = this.orderingSpec,
nullsSpec: NullsSpec? = this.nullsSpec,
metas: MetaContainer = this.metas
) =
SortSpec(
expr,
orderingSpec,
nullsSpec,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SortSpec::class.java) return false
other as SortSpec
if (expr != other.expr) return false
if (orderingSpec != other.orderingSpec) return false
if (nullsSpec != other.nullsSpec) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + orderingSpec.hashCode()
hc = 31 * hc + nullsSpec.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Over(
val partitionBy: WindowPartitionList?,
val orderBy: WindowSortSpecList?,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): Over =
Over(
partitionBy = partitionBy,
orderBy = orderBy,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Over =
Over(
partitionBy = partitionBy,
orderBy = orderBy,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("over"),
partitionBy?.toIonElement() ?: ionNull(),
orderBy?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
partitionBy: WindowPartitionList? = this.partitionBy,
orderBy: WindowSortSpecList? = this.orderBy,
metas: MetaContainer = this.metas
) =
Over(
partitionBy,
orderBy,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Over::class.java) return false
other as Over
if (partitionBy != other.partitionBy) return false
if (orderBy != other.orderBy) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = partitionBy.hashCode()
hc = 31 * hc + orderBy.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class WindowPartitionList(
val exprs: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): WindowPartitionList =
WindowPartitionList(
exprs = exprs,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): WindowPartitionList =
WindowPartitionList(
exprs = exprs,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("window_partition_list"),
*exprs.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
exprs: kotlin.collections.List = this.exprs,
metas: MetaContainer = this.metas
) =
WindowPartitionList(
exprs,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != WindowPartitionList::class.java) return false
other as WindowPartitionList
if (exprs != other.exprs) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = exprs.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class WindowSortSpecList(
val sortSpecs: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): WindowSortSpecList =
WindowSortSpecList(
sortSpecs = sortSpecs,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): WindowSortSpecList =
WindowSortSpecList(
sortSpecs = sortSpecs,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("window_sort_spec_list"),
*sortSpecs.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
sortSpecs: kotlin.collections.List = this.sortSpecs,
metas: MetaContainer = this.metas
) =
WindowSortSpecList(
sortSpecs,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != WindowSortSpecList::class.java) return false
other as WindowSortSpecList
if (sortSpecs != other.sortSpecs) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = sortSpecs.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class DmlOpList(
val ops: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): DmlOpList =
DmlOpList(
ops = ops,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DmlOpList =
DmlOpList(
ops = ops,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("dml_op_list"),
*ops.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
ops: kotlin.collections.List = this.ops,
metas: MetaContainer = this.metas
) =
DmlOpList(
ops,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DmlOpList::class.java) return false
other as DmlOpList
if (ops != other.ops) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = ops.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class OnConflict(
val expr: Expr,
val conflictAction: ConflictAction,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): OnConflict =
OnConflict(
expr = expr,
conflictAction = conflictAction,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): OnConflict =
OnConflict(
expr = expr,
conflictAction = conflictAction,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("on_conflict"),
expr.toIonElement(),
conflictAction.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
conflictAction: ConflictAction = this.conflictAction,
metas: MetaContainer = this.metas
) =
OnConflict(
expr,
conflictAction,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != OnConflict::class.java) return false
other as OnConflict
if (expr != other.expr) return false
if (conflictAction != other.conflictAction) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + conflictAction.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class ReturningExpr(
val elems: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): ReturningExpr =
ReturningExpr(
elems = elems,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ReturningExpr =
ReturningExpr(
elems = elems,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("returning_expr"),
*elems.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
elems: kotlin.collections.List = this.elems,
metas: MetaContainer = this.metas
) =
ReturningExpr(
elems,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ReturningExpr::class.java) return false
other as ReturningExpr
if (elems != other.elems) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = elems.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class ReturningElem(
val mapping: ReturningMapping,
val column: ColumnComponent,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): ReturningElem =
ReturningElem(
mapping = mapping,
column = column,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ReturningElem =
ReturningElem(
mapping = mapping,
column = column,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("returning_elem"),
mapping.toIonElement(),
column.toIonElement(),
metas = metas)
return elements
}
fun copy(
mapping: ReturningMapping = this.mapping,
column: ColumnComponent = this.column,
metas: MetaContainer = this.metas
) =
ReturningElem(
mapping,
column,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ReturningElem::class.java) return false
other as ReturningElem
if (mapping != other.mapping) return false
if (column != other.column) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = mapping.hashCode()
hc = 31 * hc + column.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Identifier(
val name: org.partiql.pig.runtime.SymbolPrimitive,
val case: CaseSensitivity,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): Identifier =
Identifier(
name = name,
case = case,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Identifier =
Identifier(
name = name,
case = case,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("identifier"),
name.toIonElement(),
case.toIonElement(),
metas = metas)
return elements
}
fun copy(
name: org.partiql.pig.runtime.SymbolPrimitive = this.name,
case: CaseSensitivity = this.case,
metas: MetaContainer = this.metas
) =
Identifier(
name,
case,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Identifier::class.java) return false
other as Identifier
if (name != other.name) return false
if (case != other.case) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = name.hashCode()
hc = 31 * hc + case.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Assignment(
val target: Expr,
val value: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): PartiqlAstNode() {
override fun copy(metas: MetaContainer): Assignment =
Assignment(
target = target,
value = value,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Assignment =
Assignment(
target = target,
value = value,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("assignment"),
target.toIonElement(),
value.toIonElement(),
metas = metas)
return elements
}
fun copy(
target: Expr = this.target,
value: Expr = this.value,
metas: MetaContainer = this.metas
) =
Assignment(
target,
value,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Assignment::class.java) return false
other as Assignment
if (target != other.target) return false
if (value != other.value) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = target.hashCode()
hc = 31 * hc + value.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/////////////////////////////////////////////////////////////////////////////
// Sum Types
/////////////////////////////////////////////////////////////////////////////
sealed class Statement(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): Statement =
when (this) {
is Query -> copy(metas = metas)
is Dml -> copy(metas = metas)
is Ddl -> copy(metas = metas)
is Exec -> copy(metas = metas)
is Explain -> copy(metas = metas)
}
class Query(
val expr: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Statement() {
override fun copy(metas: MetaContainer): Query =
Query(
expr = expr,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Query =
Query(
expr = expr,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("query"),
expr.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
metas: MetaContainer = this.metas
) =
Query(
expr,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Query::class.java) return false
other as Query
if (expr != other.expr) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Dml(
val operations: DmlOpList,
val from: FromSource?,
val where: Expr?,
val returning: ReturningExpr?,
override val metas: MetaContainer = emptyMetaContainer()
): Statement() {
override fun copy(metas: MetaContainer): Dml =
Dml(
operations = operations,
from = from,
where = where,
returning = returning,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Dml =
Dml(
operations = operations,
from = from,
where = where,
returning = returning,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = listOfNotNull(
ionSymbol("dml"),
operations?.let { ionSexpOf(ionSymbol("operations"), it.toIonElement()) },
from?.let { ionSexpOf(ionSymbol("from"), it.toIonElement()) },
where?.let { ionSexpOf(ionSymbol("where"), it.toIonElement()) },
returning?.let { ionSexpOf(ionSymbol("returning"), it.toIonElement()) }
)
return ionSexpOf(elements, metas = metas)
}
fun copy(
operations: DmlOpList = this.operations,
from: FromSource? = this.from,
where: Expr? = this.where,
returning: ReturningExpr? = this.returning,
metas: MetaContainer = this.metas
) =
Dml(
operations,
from,
where,
returning,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Dml::class.java) return false
other as Dml
if (operations != other.operations) return false
if (from != other.from) return false
if (where != other.where) return false
if (returning != other.returning) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operations.hashCode()
hc = 31 * hc + from.hashCode()
hc = 31 * hc + where.hashCode()
hc = 31 * hc + returning.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Ddl(
val op: DdlOp,
override val metas: MetaContainer = emptyMetaContainer()
): Statement() {
override fun copy(metas: MetaContainer): Ddl =
Ddl(
op = op,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Ddl =
Ddl(
op = op,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("ddl"),
op.toIonElement(),
metas = metas)
return elements
}
fun copy(
op: DdlOp = this.op,
metas: MetaContainer = this.metas
) =
Ddl(
op,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Ddl::class.java) return false
other as Ddl
if (op != other.op) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = op.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Exec(
val procedureName: org.partiql.pig.runtime.SymbolPrimitive,
val args: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Statement() {
override fun copy(metas: MetaContainer): Exec =
Exec(
procedureName = procedureName,
args = args,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Exec =
Exec(
procedureName = procedureName,
args = args,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("exec"),
procedureName.toIonElement(),
*args.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
procedureName: org.partiql.pig.runtime.SymbolPrimitive = this.procedureName,
args: kotlin.collections.List = this.args,
metas: MetaContainer = this.metas
) =
Exec(
procedureName,
args,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Exec::class.java) return false
other as Exec
if (procedureName != other.procedureName) return false
if (args != other.args) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = procedureName.hashCode()
hc = 31 * hc + args.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Explain(
val target: ExplainTarget,
override val metas: MetaContainer = emptyMetaContainer()
): Statement() {
override fun copy(metas: MetaContainer): Explain =
Explain(
target = target,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Explain =
Explain(
target = target,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("explain"),
target.toIonElement(),
metas = metas)
return elements
}
fun copy(
target: ExplainTarget = this.target,
metas: MetaContainer = this.metas
) =
Explain(
target,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Explain::class.java) return false
other as Explain
if (target != other.target) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = target.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.Statement] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.Statement): T = when(node) {
is PartiqlAst.Statement.Query -> convertQuery(node)
is PartiqlAst.Statement.Dml -> convertDml(node)
is PartiqlAst.Statement.Ddl -> convertDdl(node)
is PartiqlAst.Statement.Exec -> convertExec(node)
is PartiqlAst.Statement.Explain -> convertExplain(node)
}
fun convertQuery(node: PartiqlAst.Statement.Query): T
fun convertDml(node: PartiqlAst.Statement.Dml): T
fun convertDdl(node: PartiqlAst.Statement.Ddl): T
fun convertExec(node: PartiqlAst.Statement.Exec): T
fun convertExplain(node: PartiqlAst.Statement.Explain): T
}
}
sealed class ExplainTarget(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): ExplainTarget =
when (this) {
is Domain -> copy(metas = metas)
}
class Domain(
val statement: Statement,
val type: org.partiql.pig.runtime.SymbolPrimitive?,
val format: org.partiql.pig.runtime.SymbolPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): ExplainTarget() {
override fun copy(metas: MetaContainer): Domain =
Domain(
statement = statement,
type = type,
format = format,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Domain =
Domain(
statement = statement,
type = type,
format = format,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("domain"),
statement.toIonElement(),
type?.toIonElement() ?: ionNull(),
format?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
statement: Statement = this.statement,
type: org.partiql.pig.runtime.SymbolPrimitive? = this.type,
format: org.partiql.pig.runtime.SymbolPrimitive? = this.format,
metas: MetaContainer = this.metas
) =
Domain(
statement,
type,
format,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Domain::class.java) return false
other as Domain
if (statement != other.statement) return false
if (type != other.type) return false
if (format != other.format) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = statement.hashCode()
hc = 31 * hc + type.hashCode()
hc = 31 * hc + format.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.ExplainTarget] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.ExplainTarget): T = when(node) {
is PartiqlAst.ExplainTarget.Domain -> convertDomain(node)
}
fun convertDomain(node: PartiqlAst.ExplainTarget.Domain): T
}
}
sealed class Expr(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): Expr =
when (this) {
is Missing -> copy(metas = metas)
is Lit -> copy(metas = metas)
is Id -> copy(metas = metas)
is Parameter -> copy(metas = metas)
is Not -> copy(metas = metas)
is Pos -> copy(metas = metas)
is Neg -> copy(metas = metas)
is Plus -> copy(metas = metas)
is Minus -> copy(metas = metas)
is Times -> copy(metas = metas)
is Divide -> copy(metas = metas)
is Modulo -> copy(metas = metas)
is Concat -> copy(metas = metas)
is And -> copy(metas = metas)
is Or -> copy(metas = metas)
is Eq -> copy(metas = metas)
is Ne -> copy(metas = metas)
is Gt -> copy(metas = metas)
is Gte -> copy(metas = metas)
is Lt -> copy(metas = metas)
is Lte -> copy(metas = metas)
is Like -> copy(metas = metas)
is Between -> copy(metas = metas)
is InCollection -> copy(metas = metas)
is IsType -> copy(metas = metas)
is SimpleCase -> copy(metas = metas)
is SearchedCase -> copy(metas = metas)
is Struct -> copy(metas = metas)
is Bag -> copy(metas = metas)
is List -> copy(metas = metas)
is Sexp -> copy(metas = metas)
is Date -> copy(metas = metas)
is LitTime -> copy(metas = metas)
is BagOp -> copy(metas = metas)
is GraphMatch -> copy(metas = metas)
is Path -> copy(metas = metas)
is Call -> copy(metas = metas)
is CallAgg -> copy(metas = metas)
is CallWindow -> copy(metas = metas)
is Cast -> copy(metas = metas)
is CanCast -> copy(metas = metas)
is CanLosslessCast -> copy(metas = metas)
is NullIf -> copy(metas = metas)
is Coalesce -> copy(metas = metas)
is Select -> copy(metas = metas)
}
class Missing(
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Missing =
Missing(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Missing =
Missing(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("missing"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Missing::class.java) return false
return true
}
override fun hashCode(): Int = 3000
}
class Lit(
val value: com.amazon.ionelement.api.AnyElement,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Lit =
Lit(
value = value,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Lit =
Lit(
value = value,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("lit"),
value.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: com.amazon.ionelement.api.AnyElement = this.value,
metas: MetaContainer = this.metas
) =
Lit(
value,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Lit::class.java) return false
other as Lit
if (value != other.value) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Id(
val name: org.partiql.pig.runtime.SymbolPrimitive,
val case: CaseSensitivity,
val qualifier: ScopeQualifier,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Id =
Id(
name = name,
case = case,
qualifier = qualifier,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Id =
Id(
name = name,
case = case,
qualifier = qualifier,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("id"),
name.toIonElement(),
case.toIonElement(),
qualifier.toIonElement(),
metas = metas)
return elements
}
fun copy(
name: org.partiql.pig.runtime.SymbolPrimitive = this.name,
case: CaseSensitivity = this.case,
qualifier: ScopeQualifier = this.qualifier,
metas: MetaContainer = this.metas
) =
Id(
name,
case,
qualifier,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Id::class.java) return false
other as Id
if (name != other.name) return false
if (case != other.case) return false
if (qualifier != other.qualifier) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = name.hashCode()
hc = 31 * hc + case.hashCode()
hc = 31 * hc + qualifier.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Parameter(
val index: org.partiql.pig.runtime.LongPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Parameter =
Parameter(
index = index,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Parameter =
Parameter(
index = index,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("parameter"),
index.toIonElement(),
metas = metas)
return elements
}
fun copy(
index: org.partiql.pig.runtime.LongPrimitive = this.index,
metas: MetaContainer = this.metas
) =
Parameter(
index,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Parameter::class.java) return false
other as Parameter
if (index != other.index) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = index.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Not(
val expr: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Not =
Not(
expr = expr,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Not =
Not(
expr = expr,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("not"),
expr.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
metas: MetaContainer = this.metas
) =
Not(
expr,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Not::class.java) return false
other as Not
if (expr != other.expr) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Pos(
val expr: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Pos =
Pos(
expr = expr,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Pos =
Pos(
expr = expr,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("pos"),
expr.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
metas: MetaContainer = this.metas
) =
Pos(
expr,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Pos::class.java) return false
other as Pos
if (expr != other.expr) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Neg(
val expr: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Neg =
Neg(
expr = expr,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Neg =
Neg(
expr = expr,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("neg"),
expr.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
metas: MetaContainer = this.metas
) =
Neg(
expr,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Neg::class.java) return false
other as Neg
if (expr != other.expr) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Plus(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Plus =
Plus(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Plus =
Plus(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("plus"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Plus(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Plus::class.java) return false
other as Plus
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Minus(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Minus =
Minus(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Minus =
Minus(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("minus"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Minus(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Minus::class.java) return false
other as Minus
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Times(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Times =
Times(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Times =
Times(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("times"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Times(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Times::class.java) return false
other as Times
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Divide(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Divide =
Divide(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Divide =
Divide(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("divide"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Divide(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Divide::class.java) return false
other as Divide
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Modulo(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Modulo =
Modulo(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Modulo =
Modulo(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("modulo"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Modulo(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Modulo::class.java) return false
other as Modulo
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Concat(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Concat =
Concat(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Concat =
Concat(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("concat"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Concat(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Concat::class.java) return false
other as Concat
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class And(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): And =
And(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): And =
And(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("and"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
And(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != And::class.java) return false
other as And
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Or(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Or =
Or(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Or =
Or(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("or"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Or(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Or::class.java) return false
other as Or
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Eq(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Eq =
Eq(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Eq =
Eq(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("eq"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Eq(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Eq::class.java) return false
other as Eq
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Ne(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Ne =
Ne(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Ne =
Ne(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("ne"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Ne(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Ne::class.java) return false
other as Ne
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Gt(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Gt =
Gt(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Gt =
Gt(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("gt"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Gt(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Gt::class.java) return false
other as Gt
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Gte(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Gte =
Gte(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Gte =
Gte(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("gte"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Gte(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Gte::class.java) return false
other as Gte
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Lt(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Lt =
Lt(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Lt =
Lt(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("lt"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Lt(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Lt::class.java) return false
other as Lt
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Lte(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Lte =
Lte(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Lte =
Lte(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("lte"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
Lte(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Lte::class.java) return false
other as Lte
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Like(
val value: Expr,
val pattern: Expr,
val escape: Expr?,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Like =
Like(
value = value,
pattern = pattern,
escape = escape,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Like =
Like(
value = value,
pattern = pattern,
escape = escape,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("like"),
value.toIonElement(),
pattern.toIonElement(),
escape?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
pattern: Expr = this.pattern,
escape: Expr? = this.escape,
metas: MetaContainer = this.metas
) =
Like(
value,
pattern,
escape,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Like::class.java) return false
other as Like
if (value != other.value) return false
if (pattern != other.pattern) return false
if (escape != other.escape) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc = 31 * hc + pattern.hashCode()
hc = 31 * hc + escape.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Between(
val value: Expr,
val from: Expr,
val to: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Between =
Between(
value = value,
from = from,
to = to,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Between =
Between(
value = value,
from = from,
to = to,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("between"),
value.toIonElement(),
from.toIonElement(),
to.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
from: Expr = this.from,
to: Expr = this.to,
metas: MetaContainer = this.metas
) =
Between(
value,
from,
to,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Between::class.java) return false
other as Between
if (value != other.value) return false
if (from != other.from) return false
if (to != other.to) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc = 31 * hc + from.hashCode()
hc = 31 * hc + to.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class InCollection(
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): InCollection =
InCollection(
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): InCollection =
InCollection(
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("in_collection"),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
InCollection(
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != InCollection::class.java) return false
other as InCollection
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class IsType(
val value: Expr,
val type: Type,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): IsType =
IsType(
value = value,
type = type,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): IsType =
IsType(
value = value,
type = type,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("is_type"),
value.toIonElement(),
type.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
type: Type = this.type,
metas: MetaContainer = this.metas
) =
IsType(
value,
type,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != IsType::class.java) return false
other as IsType
if (value != other.value) return false
if (type != other.type) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc = 31 * hc + type.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class SimpleCase(
val expr: Expr,
val cases: ExprPairList,
val default: Expr?,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): SimpleCase =
SimpleCase(
expr = expr,
cases = cases,
default = default,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SimpleCase =
SimpleCase(
expr = expr,
cases = cases,
default = default,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("simple_case"),
expr.toIonElement(),
cases.toIonElement(),
default?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
cases: ExprPairList = this.cases,
default: Expr? = this.default,
metas: MetaContainer = this.metas
) =
SimpleCase(
expr,
cases,
default,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SimpleCase::class.java) return false
other as SimpleCase
if (expr != other.expr) return false
if (cases != other.cases) return false
if (default != other.default) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + cases.hashCode()
hc = 31 * hc + default.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class SearchedCase(
val cases: ExprPairList,
val default: Expr?,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): SearchedCase =
SearchedCase(
cases = cases,
default = default,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SearchedCase =
SearchedCase(
cases = cases,
default = default,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("searched_case"),
cases.toIonElement(),
default?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
cases: ExprPairList = this.cases,
default: Expr? = this.default,
metas: MetaContainer = this.metas
) =
SearchedCase(
cases,
default,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SearchedCase::class.java) return false
other as SearchedCase
if (cases != other.cases) return false
if (default != other.default) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = cases.hashCode()
hc = 31 * hc + default.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Struct(
val fields: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Struct =
Struct(
fields = fields,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Struct =
Struct(
fields = fields,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("struct"),
*fields.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
fields: kotlin.collections.List = this.fields,
metas: MetaContainer = this.metas
) =
Struct(
fields,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Struct::class.java) return false
other as Struct
if (fields != other.fields) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = fields.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Bag(
val values: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Bag =
Bag(
values = values,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Bag =
Bag(
values = values,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("bag"),
*values.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
values: kotlin.collections.List = this.values,
metas: MetaContainer = this.metas
) =
Bag(
values,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Bag::class.java) return false
other as Bag
if (values != other.values) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = values.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class List(
val values: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): List =
List(
values = values,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): List =
List(
values = values,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("list"),
*values.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
values: kotlin.collections.List = this.values,
metas: MetaContainer = this.metas
) =
List(
values,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != List::class.java) return false
other as List
if (values != other.values) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = values.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Sexp(
val values: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Sexp =
Sexp(
values = values,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Sexp =
Sexp(
values = values,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("sexp"),
*values.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
values: kotlin.collections.List = this.values,
metas: MetaContainer = this.metas
) =
Sexp(
values,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Sexp::class.java) return false
other as Sexp
if (values != other.values) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = values.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Date(
val year: org.partiql.pig.runtime.LongPrimitive,
val month: org.partiql.pig.runtime.LongPrimitive,
val day: org.partiql.pig.runtime.LongPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Date =
Date(
year = year,
month = month,
day = day,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Date =
Date(
year = year,
month = month,
day = day,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("date"),
year.toIonElement(),
month.toIonElement(),
day.toIonElement(),
metas = metas)
return elements
}
fun copy(
year: org.partiql.pig.runtime.LongPrimitive = this.year,
month: org.partiql.pig.runtime.LongPrimitive = this.month,
day: org.partiql.pig.runtime.LongPrimitive = this.day,
metas: MetaContainer = this.metas
) =
Date(
year,
month,
day,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Date::class.java) return false
other as Date
if (year != other.year) return false
if (month != other.month) return false
if (day != other.day) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = year.hashCode()
hc = 31 * hc + month.hashCode()
hc = 31 * hc + day.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class LitTime(
val value: TimeValue,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): LitTime =
LitTime(
value = value,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): LitTime =
LitTime(
value = value,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("lit_time"),
value.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: TimeValue = this.value,
metas: MetaContainer = this.metas
) =
LitTime(
value,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != LitTime::class.java) return false
other as LitTime
if (value != other.value) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class BagOp(
val op: BagOpType,
val quantifier: SetQuantifier,
val operands: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): BagOp =
BagOp(
op = op,
quantifier = quantifier,
operands = operands,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): BagOp =
BagOp(
op = op,
quantifier = quantifier,
operands = operands,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("bag_op"),
op.toIonElement(),
quantifier.toIonElement(),
*operands.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
op: BagOpType = this.op,
quantifier: SetQuantifier = this.quantifier,
operands: kotlin.collections.List = this.operands,
metas: MetaContainer = this.metas
) =
BagOp(
op,
quantifier,
operands,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != BagOp::class.java) return false
other as BagOp
if (op != other.op) return false
if (quantifier != other.quantifier) return false
if (operands != other.operands) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = op.hashCode()
hc = 31 * hc + quantifier.hashCode()
hc = 31 * hc + operands.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class GraphMatch(
val expr: Expr,
val gpmlPattern: GpmlPattern,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): GraphMatch =
GraphMatch(
expr = expr,
gpmlPattern = gpmlPattern,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GraphMatch =
GraphMatch(
expr = expr,
gpmlPattern = gpmlPattern,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("graph_match"),
expr.toIonElement(),
gpmlPattern.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
gpmlPattern: GpmlPattern = this.gpmlPattern,
metas: MetaContainer = this.metas
) =
GraphMatch(
expr,
gpmlPattern,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GraphMatch::class.java) return false
other as GraphMatch
if (expr != other.expr) return false
if (gpmlPattern != other.gpmlPattern) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + gpmlPattern.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Path(
val root: Expr,
val steps: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Path =
Path(
root = root,
steps = steps,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Path =
Path(
root = root,
steps = steps,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("path"),
root.toIonElement(),
*steps.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
root: Expr = this.root,
steps: kotlin.collections.List = this.steps,
metas: MetaContainer = this.metas
) =
Path(
root,
steps,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Path::class.java) return false
other as Path
if (root != other.root) return false
if (steps != other.steps) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = root.hashCode()
hc = 31 * hc + steps.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Call(
val funcName: org.partiql.pig.runtime.SymbolPrimitive,
val args: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Call =
Call(
funcName = funcName,
args = args,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Call =
Call(
funcName = funcName,
args = args,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("call"),
funcName.toIonElement(),
*args.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
funcName: org.partiql.pig.runtime.SymbolPrimitive = this.funcName,
args: kotlin.collections.List = this.args,
metas: MetaContainer = this.metas
) =
Call(
funcName,
args,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Call::class.java) return false
other as Call
if (funcName != other.funcName) return false
if (args != other.args) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = funcName.hashCode()
hc = 31 * hc + args.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class CallAgg(
val setq: SetQuantifier,
val funcName: org.partiql.pig.runtime.SymbolPrimitive,
val arg: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): CallAgg =
CallAgg(
setq = setq,
funcName = funcName,
arg = arg,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CallAgg =
CallAgg(
setq = setq,
funcName = funcName,
arg = arg,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("call_agg"),
setq.toIonElement(),
funcName.toIonElement(),
arg.toIonElement(),
metas = metas)
return elements
}
fun copy(
setq: SetQuantifier = this.setq,
funcName: org.partiql.pig.runtime.SymbolPrimitive = this.funcName,
arg: Expr = this.arg,
metas: MetaContainer = this.metas
) =
CallAgg(
setq,
funcName,
arg,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CallAgg::class.java) return false
other as CallAgg
if (setq != other.setq) return false
if (funcName != other.funcName) return false
if (arg != other.arg) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = setq.hashCode()
hc = 31 * hc + funcName.hashCode()
hc = 31 * hc + arg.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class CallWindow(
val funcName: org.partiql.pig.runtime.SymbolPrimitive,
val over: Over,
val args: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): CallWindow =
CallWindow(
funcName = funcName,
over = over,
args = args,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CallWindow =
CallWindow(
funcName = funcName,
over = over,
args = args,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("call_window"),
funcName.toIonElement(),
over.toIonElement(),
*args.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
funcName: org.partiql.pig.runtime.SymbolPrimitive = this.funcName,
over: Over = this.over,
args: kotlin.collections.List = this.args,
metas: MetaContainer = this.metas
) =
CallWindow(
funcName,
over,
args,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CallWindow::class.java) return false
other as CallWindow
if (funcName != other.funcName) return false
if (over != other.over) return false
if (args != other.args) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = funcName.hashCode()
hc = 31 * hc + over.hashCode()
hc = 31 * hc + args.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Cast(
val value: Expr,
val asType: Type,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Cast =
Cast(
value = value,
asType = asType,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Cast =
Cast(
value = value,
asType = asType,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("cast"),
value.toIonElement(),
asType.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
asType: Type = this.asType,
metas: MetaContainer = this.metas
) =
Cast(
value,
asType,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Cast::class.java) return false
other as Cast
if (value != other.value) return false
if (asType != other.asType) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc = 31 * hc + asType.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class CanCast(
val value: Expr,
val asType: Type,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): CanCast =
CanCast(
value = value,
asType = asType,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CanCast =
CanCast(
value = value,
asType = asType,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("can_cast"),
value.toIonElement(),
asType.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
asType: Type = this.asType,
metas: MetaContainer = this.metas
) =
CanCast(
value,
asType,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CanCast::class.java) return false
other as CanCast
if (value != other.value) return false
if (asType != other.asType) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc = 31 * hc + asType.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class CanLosslessCast(
val value: Expr,
val asType: Type,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): CanLosslessCast =
CanLosslessCast(
value = value,
asType = asType,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CanLosslessCast =
CanLosslessCast(
value = value,
asType = asType,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("can_lossless_cast"),
value.toIonElement(),
asType.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
asType: Type = this.asType,
metas: MetaContainer = this.metas
) =
CanLosslessCast(
value,
asType,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CanLosslessCast::class.java) return false
other as CanLosslessCast
if (value != other.value) return false
if (asType != other.asType) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc = 31 * hc + asType.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class NullIf(
val expr1: Expr,
val expr2: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): NullIf =
NullIf(
expr1 = expr1,
expr2 = expr2,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): NullIf =
NullIf(
expr1 = expr1,
expr2 = expr2,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("null_if"),
expr1.toIonElement(),
expr2.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr1: Expr = this.expr1,
expr2: Expr = this.expr2,
metas: MetaContainer = this.metas
) =
NullIf(
expr1,
expr2,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != NullIf::class.java) return false
other as NullIf
if (expr1 != other.expr1) return false
if (expr2 != other.expr2) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr1.hashCode()
hc = 31 * hc + expr2.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Coalesce(
val args: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Coalesce =
Coalesce(
args = args,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Coalesce =
Coalesce(
args = args,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("coalesce"),
*args.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
args: kotlin.collections.List = this.args,
metas: MetaContainer = this.metas
) =
Coalesce(
args,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Coalesce::class.java) return false
other as Coalesce
if (args != other.args) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = args.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Select(
val setq: SetQuantifier?,
val project: Projection,
val from: FromSource,
val fromLet: Let?,
val where: Expr?,
val group: GroupBy?,
val having: Expr?,
val order: OrderBy?,
val limit: Expr?,
val offset: Expr?,
override val metas: MetaContainer = emptyMetaContainer()
): Expr() {
override fun copy(metas: MetaContainer): Select =
Select(
setq = setq,
project = project,
from = from,
fromLet = fromLet,
where = where,
group = group,
having = having,
order = order,
limit = limit,
offset = offset,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Select =
Select(
setq = setq,
project = project,
from = from,
fromLet = fromLet,
where = where,
group = group,
having = having,
order = order,
limit = limit,
offset = offset,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = listOfNotNull(
ionSymbol("select"),
setq?.let { ionSexpOf(ionSymbol("setq"), it.toIonElement()) },
project?.let { ionSexpOf(ionSymbol("project"), it.toIonElement()) },
from?.let { ionSexpOf(ionSymbol("from"), it.toIonElement()) },
fromLet?.let { ionSexpOf(ionSymbol("from_let"), it.toIonElement()) },
where?.let { ionSexpOf(ionSymbol("where"), it.toIonElement()) },
group?.let { ionSexpOf(ionSymbol("group"), it.toIonElement()) },
having?.let { ionSexpOf(ionSymbol("having"), it.toIonElement()) },
order?.let { ionSexpOf(ionSymbol("order"), it.toIonElement()) },
limit?.let { ionSexpOf(ionSymbol("limit"), it.toIonElement()) },
offset?.let { ionSexpOf(ionSymbol("offset"), it.toIonElement()) }
)
return ionSexpOf(elements, metas = metas)
}
fun copy(
setq: SetQuantifier? = this.setq,
project: Projection = this.project,
from: FromSource = this.from,
fromLet: Let? = this.fromLet,
where: Expr? = this.where,
group: GroupBy? = this.group,
having: Expr? = this.having,
order: OrderBy? = this.order,
limit: Expr? = this.limit,
offset: Expr? = this.offset,
metas: MetaContainer = this.metas
) =
Select(
setq,
project,
from,
fromLet,
where,
group,
having,
order,
limit,
offset,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Select::class.java) return false
other as Select
if (setq != other.setq) return false
if (project != other.project) return false
if (from != other.from) return false
if (fromLet != other.fromLet) return false
if (where != other.where) return false
if (group != other.group) return false
if (having != other.having) return false
if (order != other.order) return false
if (limit != other.limit) return false
if (offset != other.offset) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = setq.hashCode()
hc = 31 * hc + project.hashCode()
hc = 31 * hc + from.hashCode()
hc = 31 * hc + fromLet.hashCode()
hc = 31 * hc + where.hashCode()
hc = 31 * hc + group.hashCode()
hc = 31 * hc + having.hashCode()
hc = 31 * hc + order.hashCode()
hc = 31 * hc + limit.hashCode()
hc = 31 * hc + offset.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.Expr] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.Expr): T = when(node) {
is PartiqlAst.Expr.Missing -> convertMissing(node)
is PartiqlAst.Expr.Lit -> convertLit(node)
is PartiqlAst.Expr.Id -> convertId(node)
is PartiqlAst.Expr.Parameter -> convertParameter(node)
is PartiqlAst.Expr.Not -> convertNot(node)
is PartiqlAst.Expr.Pos -> convertPos(node)
is PartiqlAst.Expr.Neg -> convertNeg(node)
is PartiqlAst.Expr.Plus -> convertPlus(node)
is PartiqlAst.Expr.Minus -> convertMinus(node)
is PartiqlAst.Expr.Times -> convertTimes(node)
is PartiqlAst.Expr.Divide -> convertDivide(node)
is PartiqlAst.Expr.Modulo -> convertModulo(node)
is PartiqlAst.Expr.Concat -> convertConcat(node)
is PartiqlAst.Expr.And -> convertAnd(node)
is PartiqlAst.Expr.Or -> convertOr(node)
is PartiqlAst.Expr.Eq -> convertEq(node)
is PartiqlAst.Expr.Ne -> convertNe(node)
is PartiqlAst.Expr.Gt -> convertGt(node)
is PartiqlAst.Expr.Gte -> convertGte(node)
is PartiqlAst.Expr.Lt -> convertLt(node)
is PartiqlAst.Expr.Lte -> convertLte(node)
is PartiqlAst.Expr.Like -> convertLike(node)
is PartiqlAst.Expr.Between -> convertBetween(node)
is PartiqlAst.Expr.InCollection -> convertInCollection(node)
is PartiqlAst.Expr.IsType -> convertIsType(node)
is PartiqlAst.Expr.SimpleCase -> convertSimpleCase(node)
is PartiqlAst.Expr.SearchedCase -> convertSearchedCase(node)
is PartiqlAst.Expr.Struct -> convertStruct(node)
is PartiqlAst.Expr.Bag -> convertBag(node)
is PartiqlAst.Expr.List -> convertList(node)
is PartiqlAst.Expr.Sexp -> convertSexp(node)
is PartiqlAst.Expr.Date -> convertDate(node)
is PartiqlAst.Expr.LitTime -> convertLitTime(node)
is PartiqlAst.Expr.BagOp -> convertBagOp(node)
is PartiqlAst.Expr.GraphMatch -> convertGraphMatch(node)
is PartiqlAst.Expr.Path -> convertPath(node)
is PartiqlAst.Expr.Call -> convertCall(node)
is PartiqlAst.Expr.CallAgg -> convertCallAgg(node)
is PartiqlAst.Expr.CallWindow -> convertCallWindow(node)
is PartiqlAst.Expr.Cast -> convertCast(node)
is PartiqlAst.Expr.CanCast -> convertCanCast(node)
is PartiqlAst.Expr.CanLosslessCast -> convertCanLosslessCast(node)
is PartiqlAst.Expr.NullIf -> convertNullIf(node)
is PartiqlAst.Expr.Coalesce -> convertCoalesce(node)
is PartiqlAst.Expr.Select -> convertSelect(node)
}
fun convertMissing(node: PartiqlAst.Expr.Missing): T
fun convertLit(node: PartiqlAst.Expr.Lit): T
fun convertId(node: PartiqlAst.Expr.Id): T
fun convertParameter(node: PartiqlAst.Expr.Parameter): T
fun convertNot(node: PartiqlAst.Expr.Not): T
fun convertPos(node: PartiqlAst.Expr.Pos): T
fun convertNeg(node: PartiqlAst.Expr.Neg): T
fun convertPlus(node: PartiqlAst.Expr.Plus): T
fun convertMinus(node: PartiqlAst.Expr.Minus): T
fun convertTimes(node: PartiqlAst.Expr.Times): T
fun convertDivide(node: PartiqlAst.Expr.Divide): T
fun convertModulo(node: PartiqlAst.Expr.Modulo): T
fun convertConcat(node: PartiqlAst.Expr.Concat): T
fun convertAnd(node: PartiqlAst.Expr.And): T
fun convertOr(node: PartiqlAst.Expr.Or): T
fun convertEq(node: PartiqlAst.Expr.Eq): T
fun convertNe(node: PartiqlAst.Expr.Ne): T
fun convertGt(node: PartiqlAst.Expr.Gt): T
fun convertGte(node: PartiqlAst.Expr.Gte): T
fun convertLt(node: PartiqlAst.Expr.Lt): T
fun convertLte(node: PartiqlAst.Expr.Lte): T
fun convertLike(node: PartiqlAst.Expr.Like): T
fun convertBetween(node: PartiqlAst.Expr.Between): T
fun convertInCollection(node: PartiqlAst.Expr.InCollection): T
fun convertIsType(node: PartiqlAst.Expr.IsType): T
fun convertSimpleCase(node: PartiqlAst.Expr.SimpleCase): T
fun convertSearchedCase(node: PartiqlAst.Expr.SearchedCase): T
fun convertStruct(node: PartiqlAst.Expr.Struct): T
fun convertBag(node: PartiqlAst.Expr.Bag): T
fun convertList(node: PartiqlAst.Expr.List): T
fun convertSexp(node: PartiqlAst.Expr.Sexp): T
fun convertDate(node: PartiqlAst.Expr.Date): T
fun convertLitTime(node: PartiqlAst.Expr.LitTime): T
fun convertBagOp(node: PartiqlAst.Expr.BagOp): T
fun convertGraphMatch(node: PartiqlAst.Expr.GraphMatch): T
fun convertPath(node: PartiqlAst.Expr.Path): T
fun convertCall(node: PartiqlAst.Expr.Call): T
fun convertCallAgg(node: PartiqlAst.Expr.CallAgg): T
fun convertCallWindow(node: PartiqlAst.Expr.CallWindow): T
fun convertCast(node: PartiqlAst.Expr.Cast): T
fun convertCanCast(node: PartiqlAst.Expr.CanCast): T
fun convertCanLosslessCast(node: PartiqlAst.Expr.CanLosslessCast): T
fun convertNullIf(node: PartiqlAst.Expr.NullIf): T
fun convertCoalesce(node: PartiqlAst.Expr.Coalesce): T
fun convertSelect(node: PartiqlAst.Expr.Select): T
}
}
sealed class PathStep(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): PathStep =
when (this) {
is PathExpr -> copy(metas = metas)
is PathWildcard -> copy(metas = metas)
is PathUnpivot -> copy(metas = metas)
}
class PathExpr(
val index: Expr,
val case: CaseSensitivity,
override val metas: MetaContainer = emptyMetaContainer()
): PathStep() {
override fun copy(metas: MetaContainer): PathExpr =
PathExpr(
index = index,
case = case,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): PathExpr =
PathExpr(
index = index,
case = case,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("path_expr"),
index.toIonElement(),
case.toIonElement(),
metas = metas)
return elements
}
fun copy(
index: Expr = this.index,
case: CaseSensitivity = this.case,
metas: MetaContainer = this.metas
) =
PathExpr(
index,
case,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != PathExpr::class.java) return false
other as PathExpr
if (index != other.index) return false
if (case != other.case) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = index.hashCode()
hc = 31 * hc + case.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class PathWildcard(
override val metas: MetaContainer = emptyMetaContainer()
): PathStep() {
override fun copy(metas: MetaContainer): PathWildcard =
PathWildcard(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): PathWildcard =
PathWildcard(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("path_wildcard"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != PathWildcard::class.java) return false
return true
}
override fun hashCode(): Int = 4001
}
class PathUnpivot(
override val metas: MetaContainer = emptyMetaContainer()
): PathStep() {
override fun copy(metas: MetaContainer): PathUnpivot =
PathUnpivot(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): PathUnpivot =
PathUnpivot(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("path_unpivot"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != PathUnpivot::class.java) return false
return true
}
override fun hashCode(): Int = 4002
}
/** Converts instances of [PartiqlAst.PathStep] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.PathStep): T = when(node) {
is PartiqlAst.PathStep.PathExpr -> convertPathExpr(node)
is PartiqlAst.PathStep.PathWildcard -> convertPathWildcard(node)
is PartiqlAst.PathStep.PathUnpivot -> convertPathUnpivot(node)
}
fun convertPathExpr(node: PartiqlAst.PathStep.PathExpr): T
fun convertPathWildcard(node: PartiqlAst.PathStep.PathWildcard): T
fun convertPathUnpivot(node: PartiqlAst.PathStep.PathUnpivot): T
}
}
sealed class Projection(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): Projection =
when (this) {
is ProjectStar -> copy(metas = metas)
is ProjectList -> copy(metas = metas)
is ProjectPivot -> copy(metas = metas)
is ProjectValue -> copy(metas = metas)
}
class ProjectStar(
override val metas: MetaContainer = emptyMetaContainer()
): Projection() {
override fun copy(metas: MetaContainer): ProjectStar =
ProjectStar(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ProjectStar =
ProjectStar(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("project_star"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ProjectStar::class.java) return false
return true
}
override fun hashCode(): Int = 5000
}
class ProjectList(
val projectItems: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): Projection() {
override fun copy(metas: MetaContainer): ProjectList =
ProjectList(
projectItems = projectItems,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ProjectList =
ProjectList(
projectItems = projectItems,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("project_list"),
*projectItems.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
projectItems: kotlin.collections.List = this.projectItems,
metas: MetaContainer = this.metas
) =
ProjectList(
projectItems,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ProjectList::class.java) return false
other as ProjectList
if (projectItems != other.projectItems) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = projectItems.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class ProjectPivot(
val value: Expr,
val key: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Projection() {
override fun copy(metas: MetaContainer): ProjectPivot =
ProjectPivot(
value = value,
key = key,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ProjectPivot =
ProjectPivot(
value = value,
key = key,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("project_pivot"),
value.toIonElement(),
key.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
key: Expr = this.key,
metas: MetaContainer = this.metas
) =
ProjectPivot(
value,
key,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ProjectPivot::class.java) return false
other as ProjectPivot
if (value != other.value) return false
if (key != other.key) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc = 31 * hc + key.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class ProjectValue(
val value: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): Projection() {
override fun copy(metas: MetaContainer): ProjectValue =
ProjectValue(
value = value,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ProjectValue =
ProjectValue(
value = value,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("project_value"),
value.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: Expr = this.value,
metas: MetaContainer = this.metas
) =
ProjectValue(
value,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ProjectValue::class.java) return false
other as ProjectValue
if (value != other.value) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.Projection] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.Projection): T = when(node) {
is PartiqlAst.Projection.ProjectStar -> convertProjectStar(node)
is PartiqlAst.Projection.ProjectList -> convertProjectList(node)
is PartiqlAst.Projection.ProjectPivot -> convertProjectPivot(node)
is PartiqlAst.Projection.ProjectValue -> convertProjectValue(node)
}
fun convertProjectStar(node: PartiqlAst.Projection.ProjectStar): T
fun convertProjectList(node: PartiqlAst.Projection.ProjectList): T
fun convertProjectPivot(node: PartiqlAst.Projection.ProjectPivot): T
fun convertProjectValue(node: PartiqlAst.Projection.ProjectValue): T
}
}
sealed class ProjectItem(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): ProjectItem =
when (this) {
is ProjectAll -> copy(metas = metas)
is ProjectExpr -> copy(metas = metas)
}
class ProjectAll(
val expr: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): ProjectItem() {
override fun copy(metas: MetaContainer): ProjectAll =
ProjectAll(
expr = expr,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ProjectAll =
ProjectAll(
expr = expr,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("project_all"),
expr.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
metas: MetaContainer = this.metas
) =
ProjectAll(
expr,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ProjectAll::class.java) return false
other as ProjectAll
if (expr != other.expr) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class ProjectExpr(
val expr: Expr,
val asAlias: org.partiql.pig.runtime.SymbolPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): ProjectItem() {
override fun copy(metas: MetaContainer): ProjectExpr =
ProjectExpr(
expr = expr,
asAlias = asAlias,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ProjectExpr =
ProjectExpr(
expr = expr,
asAlias = asAlias,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("project_expr"),
expr.toIonElement(),
asAlias?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.asAlias,
metas: MetaContainer = this.metas
) =
ProjectExpr(
expr,
asAlias,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ProjectExpr::class.java) return false
other as ProjectExpr
if (expr != other.expr) return false
if (asAlias != other.asAlias) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + asAlias.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.ProjectItem] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.ProjectItem): T = when(node) {
is PartiqlAst.ProjectItem.ProjectAll -> convertProjectAll(node)
is PartiqlAst.ProjectItem.ProjectExpr -> convertProjectExpr(node)
}
fun convertProjectAll(node: PartiqlAst.ProjectItem.ProjectAll): T
fun convertProjectExpr(node: PartiqlAst.ProjectItem.ProjectExpr): T
}
}
sealed class FromSource(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): FromSource =
when (this) {
is Scan -> copy(metas = metas)
is Unpivot -> copy(metas = metas)
is Join -> copy(metas = metas)
}
class Scan(
val expr: Expr,
val asAlias: org.partiql.pig.runtime.SymbolPrimitive?,
val atAlias: org.partiql.pig.runtime.SymbolPrimitive?,
val byAlias: org.partiql.pig.runtime.SymbolPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): FromSource() {
override fun copy(metas: MetaContainer): Scan =
Scan(
expr = expr,
asAlias = asAlias,
atAlias = atAlias,
byAlias = byAlias,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Scan =
Scan(
expr = expr,
asAlias = asAlias,
atAlias = atAlias,
byAlias = byAlias,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("scan"),
expr.toIonElement(),
asAlias?.toIonElement() ?: ionNull(),
atAlias?.toIonElement() ?: ionNull(),
byAlias?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.asAlias,
atAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.atAlias,
byAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.byAlias,
metas: MetaContainer = this.metas
) =
Scan(
expr,
asAlias,
atAlias,
byAlias,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Scan::class.java) return false
other as Scan
if (expr != other.expr) return false
if (asAlias != other.asAlias) return false
if (atAlias != other.atAlias) return false
if (byAlias != other.byAlias) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + asAlias.hashCode()
hc = 31 * hc + atAlias.hashCode()
hc = 31 * hc + byAlias.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Unpivot(
val expr: Expr,
val asAlias: org.partiql.pig.runtime.SymbolPrimitive?,
val atAlias: org.partiql.pig.runtime.SymbolPrimitive?,
val byAlias: org.partiql.pig.runtime.SymbolPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): FromSource() {
override fun copy(metas: MetaContainer): Unpivot =
Unpivot(
expr = expr,
asAlias = asAlias,
atAlias = atAlias,
byAlias = byAlias,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Unpivot =
Unpivot(
expr = expr,
asAlias = asAlias,
atAlias = atAlias,
byAlias = byAlias,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("unpivot"),
expr.toIonElement(),
asAlias?.toIonElement() ?: ionNull(),
atAlias?.toIonElement() ?: ionNull(),
byAlias?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
asAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.asAlias,
atAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.atAlias,
byAlias: org.partiql.pig.runtime.SymbolPrimitive? = this.byAlias,
metas: MetaContainer = this.metas
) =
Unpivot(
expr,
asAlias,
atAlias,
byAlias,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Unpivot::class.java) return false
other as Unpivot
if (expr != other.expr) return false
if (asAlias != other.asAlias) return false
if (atAlias != other.atAlias) return false
if (byAlias != other.byAlias) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc = 31 * hc + asAlias.hashCode()
hc = 31 * hc + atAlias.hashCode()
hc = 31 * hc + byAlias.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Join(
val type: JoinType,
val left: FromSource,
val right: FromSource,
val predicate: Expr?,
override val metas: MetaContainer = emptyMetaContainer()
): FromSource() {
override fun copy(metas: MetaContainer): Join =
Join(
type = type,
left = left,
right = right,
predicate = predicate,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Join =
Join(
type = type,
left = left,
right = right,
predicate = predicate,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("join"),
type.toIonElement(),
left.toIonElement(),
right.toIonElement(),
predicate?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
type: JoinType = this.type,
left: FromSource = this.left,
right: FromSource = this.right,
predicate: Expr? = this.predicate,
metas: MetaContainer = this.metas
) =
Join(
type,
left,
right,
predicate,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Join::class.java) return false
other as Join
if (type != other.type) return false
if (left != other.left) return false
if (right != other.right) return false
if (predicate != other.predicate) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = type.hashCode()
hc = 31 * hc + left.hashCode()
hc = 31 * hc + right.hashCode()
hc = 31 * hc + predicate.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.FromSource] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.FromSource): T = when(node) {
is PartiqlAst.FromSource.Scan -> convertScan(node)
is PartiqlAst.FromSource.Unpivot -> convertUnpivot(node)
is PartiqlAst.FromSource.Join -> convertJoin(node)
}
fun convertScan(node: PartiqlAst.FromSource.Scan): T
fun convertUnpivot(node: PartiqlAst.FromSource.Unpivot): T
fun convertJoin(node: PartiqlAst.FromSource.Join): T
}
}
sealed class JoinType(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): JoinType =
when (this) {
is Inner -> copy(metas = metas)
is Left -> copy(metas = metas)
is Right -> copy(metas = metas)
is Full -> copy(metas = metas)
}
class Inner(
override val metas: MetaContainer = emptyMetaContainer()
): JoinType() {
override fun copy(metas: MetaContainer): Inner =
Inner(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Inner =
Inner(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("inner"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Inner::class.java) return false
return true
}
override fun hashCode(): Int = 8000
}
class Left(
override val metas: MetaContainer = emptyMetaContainer()
): JoinType() {
override fun copy(metas: MetaContainer): Left =
Left(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Left =
Left(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("left"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Left::class.java) return false
return true
}
override fun hashCode(): Int = 8001
}
class Right(
override val metas: MetaContainer = emptyMetaContainer()
): JoinType() {
override fun copy(metas: MetaContainer): Right =
Right(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Right =
Right(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("right"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Right::class.java) return false
return true
}
override fun hashCode(): Int = 8002
}
class Full(
override val metas: MetaContainer = emptyMetaContainer()
): JoinType() {
override fun copy(metas: MetaContainer): Full =
Full(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Full =
Full(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("full"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Full::class.java) return false
return true
}
override fun hashCode(): Int = 8003
}
/** Converts instances of [PartiqlAst.JoinType] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.JoinType): T = when(node) {
is PartiqlAst.JoinType.Inner -> convertInner(node)
is PartiqlAst.JoinType.Left -> convertLeft(node)
is PartiqlAst.JoinType.Right -> convertRight(node)
is PartiqlAst.JoinType.Full -> convertFull(node)
}
fun convertInner(node: PartiqlAst.JoinType.Inner): T
fun convertLeft(node: PartiqlAst.JoinType.Left): T
fun convertRight(node: PartiqlAst.JoinType.Right): T
fun convertFull(node: PartiqlAst.JoinType.Full): T
}
}
sealed class GraphMatchDirection(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): GraphMatchDirection =
when (this) {
is EdgeLeft -> copy(metas = metas)
is EdgeUndirected -> copy(metas = metas)
is EdgeRight -> copy(metas = metas)
is EdgeLeftOrUndirected -> copy(metas = metas)
is EdgeUndirectedOrRight -> copy(metas = metas)
is EdgeLeftOrRight -> copy(metas = metas)
is EdgeLeftOrUndirectedOrRight -> copy(metas = metas)
}
class EdgeLeft(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchDirection() {
override fun copy(metas: MetaContainer): EdgeLeft =
EdgeLeft(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): EdgeLeft =
EdgeLeft(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge_left"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != EdgeLeft::class.java) return false
return true
}
override fun hashCode(): Int = 9000
}
class EdgeUndirected(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchDirection() {
override fun copy(metas: MetaContainer): EdgeUndirected =
EdgeUndirected(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): EdgeUndirected =
EdgeUndirected(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge_undirected"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != EdgeUndirected::class.java) return false
return true
}
override fun hashCode(): Int = 9001
}
class EdgeRight(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchDirection() {
override fun copy(metas: MetaContainer): EdgeRight =
EdgeRight(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): EdgeRight =
EdgeRight(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge_right"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != EdgeRight::class.java) return false
return true
}
override fun hashCode(): Int = 9002
}
class EdgeLeftOrUndirected(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchDirection() {
override fun copy(metas: MetaContainer): EdgeLeftOrUndirected =
EdgeLeftOrUndirected(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): EdgeLeftOrUndirected =
EdgeLeftOrUndirected(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge_left_or_undirected"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != EdgeLeftOrUndirected::class.java) return false
return true
}
override fun hashCode(): Int = 9003
}
class EdgeUndirectedOrRight(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchDirection() {
override fun copy(metas: MetaContainer): EdgeUndirectedOrRight =
EdgeUndirectedOrRight(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): EdgeUndirectedOrRight =
EdgeUndirectedOrRight(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge_undirected_or_right"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != EdgeUndirectedOrRight::class.java) return false
return true
}
override fun hashCode(): Int = 9004
}
class EdgeLeftOrRight(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchDirection() {
override fun copy(metas: MetaContainer): EdgeLeftOrRight =
EdgeLeftOrRight(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): EdgeLeftOrRight =
EdgeLeftOrRight(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge_left_or_right"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != EdgeLeftOrRight::class.java) return false
return true
}
override fun hashCode(): Int = 9005
}
class EdgeLeftOrUndirectedOrRight(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchDirection() {
override fun copy(metas: MetaContainer): EdgeLeftOrUndirectedOrRight =
EdgeLeftOrUndirectedOrRight(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): EdgeLeftOrUndirectedOrRight =
EdgeLeftOrUndirectedOrRight(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge_left_or_undirected_or_right"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != EdgeLeftOrUndirectedOrRight::class.java) return false
return true
}
override fun hashCode(): Int = 9006
}
/** Converts instances of [PartiqlAst.GraphMatchDirection] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.GraphMatchDirection): T = when(node) {
is PartiqlAst.GraphMatchDirection.EdgeLeft -> convertEdgeLeft(node)
is PartiqlAst.GraphMatchDirection.EdgeUndirected -> convertEdgeUndirected(node)
is PartiqlAst.GraphMatchDirection.EdgeRight -> convertEdgeRight(node)
is PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirected -> convertEdgeLeftOrUndirected(node)
is PartiqlAst.GraphMatchDirection.EdgeUndirectedOrRight -> convertEdgeUndirectedOrRight(node)
is PartiqlAst.GraphMatchDirection.EdgeLeftOrRight -> convertEdgeLeftOrRight(node)
is PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirectedOrRight -> convertEdgeLeftOrUndirectedOrRight(node)
}
fun convertEdgeLeft(node: PartiqlAst.GraphMatchDirection.EdgeLeft): T
fun convertEdgeUndirected(node: PartiqlAst.GraphMatchDirection.EdgeUndirected): T
fun convertEdgeRight(node: PartiqlAst.GraphMatchDirection.EdgeRight): T
fun convertEdgeLeftOrUndirected(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirected): T
fun convertEdgeUndirectedOrRight(node: PartiqlAst.GraphMatchDirection.EdgeUndirectedOrRight): T
fun convertEdgeLeftOrRight(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrRight): T
fun convertEdgeLeftOrUndirectedOrRight(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirectedOrRight): T
}
}
sealed class GraphMatchPatternPart(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): GraphMatchPatternPart =
when (this) {
is Node -> copy(metas = metas)
is Edge -> copy(metas = metas)
is Pattern -> copy(metas = metas)
}
class Node(
val prefilter: Expr?,
val variable: org.partiql.pig.runtime.SymbolPrimitive?,
val label: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchPatternPart() {
override fun copy(metas: MetaContainer): Node =
Node(
prefilter = prefilter,
variable = variable,
label = label,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Node =
Node(
prefilter = prefilter,
variable = variable,
label = label,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("node"),
prefilter?.toIonElement() ?: ionNull(),
variable?.toIonElement() ?: ionNull(),
*label.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
prefilter: Expr? = this.prefilter,
variable: org.partiql.pig.runtime.SymbolPrimitive? = this.variable,
label: kotlin.collections.List = this.label,
metas: MetaContainer = this.metas
) =
Node(
prefilter,
variable,
label,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Node::class.java) return false
other as Node
if (prefilter != other.prefilter) return false
if (variable != other.variable) return false
if (label != other.label) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = prefilter.hashCode()
hc = 31 * hc + variable.hashCode()
hc = 31 * hc + label.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Edge(
val direction: GraphMatchDirection,
val quantifier: GraphMatchQuantifier?,
val prefilter: Expr?,
val variable: org.partiql.pig.runtime.SymbolPrimitive?,
val label: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchPatternPart() {
override fun copy(metas: MetaContainer): Edge =
Edge(
direction = direction,
quantifier = quantifier,
prefilter = prefilter,
variable = variable,
label = label,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Edge =
Edge(
direction = direction,
quantifier = quantifier,
prefilter = prefilter,
variable = variable,
label = label,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("edge"),
direction.toIonElement(),
quantifier?.toIonElement() ?: ionNull(),
prefilter?.toIonElement() ?: ionNull(),
variable?.toIonElement() ?: ionNull(),
*label.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
direction: GraphMatchDirection = this.direction,
quantifier: GraphMatchQuantifier? = this.quantifier,
prefilter: Expr? = this.prefilter,
variable: org.partiql.pig.runtime.SymbolPrimitive? = this.variable,
label: kotlin.collections.List = this.label,
metas: MetaContainer = this.metas
) =
Edge(
direction,
quantifier,
prefilter,
variable,
label,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Edge::class.java) return false
other as Edge
if (direction != other.direction) return false
if (quantifier != other.quantifier) return false
if (prefilter != other.prefilter) return false
if (variable != other.variable) return false
if (label != other.label) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = direction.hashCode()
hc = 31 * hc + quantifier.hashCode()
hc = 31 * hc + prefilter.hashCode()
hc = 31 * hc + variable.hashCode()
hc = 31 * hc + label.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Pattern(
val pattern: GraphMatchPattern,
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchPatternPart() {
override fun copy(metas: MetaContainer): Pattern =
Pattern(
pattern = pattern,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Pattern =
Pattern(
pattern = pattern,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("pattern"),
pattern.toIonElement(),
metas = metas)
return elements
}
fun copy(
pattern: GraphMatchPattern = this.pattern,
metas: MetaContainer = this.metas
) =
Pattern(
pattern,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Pattern::class.java) return false
other as Pattern
if (pattern != other.pattern) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = pattern.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.GraphMatchPatternPart] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.GraphMatchPatternPart): T = when(node) {
is PartiqlAst.GraphMatchPatternPart.Node -> convertNode(node)
is PartiqlAst.GraphMatchPatternPart.Edge -> convertEdge(node)
is PartiqlAst.GraphMatchPatternPart.Pattern -> convertPattern(node)
}
fun convertNode(node: PartiqlAst.GraphMatchPatternPart.Node): T
fun convertEdge(node: PartiqlAst.GraphMatchPatternPart.Edge): T
fun convertPattern(node: PartiqlAst.GraphMatchPatternPart.Pattern): T
}
}
sealed class GraphMatchRestrictor(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): GraphMatchRestrictor =
when (this) {
is RestrictorTrail -> copy(metas = metas)
is RestrictorAcyclic -> copy(metas = metas)
is RestrictorSimple -> copy(metas = metas)
}
class RestrictorTrail(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchRestrictor() {
override fun copy(metas: MetaContainer): RestrictorTrail =
RestrictorTrail(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): RestrictorTrail =
RestrictorTrail(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("restrictor_trail"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != RestrictorTrail::class.java) return false
return true
}
override fun hashCode(): Int = 11000
}
class RestrictorAcyclic(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchRestrictor() {
override fun copy(metas: MetaContainer): RestrictorAcyclic =
RestrictorAcyclic(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): RestrictorAcyclic =
RestrictorAcyclic(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("restrictor_acyclic"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != RestrictorAcyclic::class.java) return false
return true
}
override fun hashCode(): Int = 11001
}
class RestrictorSimple(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchRestrictor() {
override fun copy(metas: MetaContainer): RestrictorSimple =
RestrictorSimple(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): RestrictorSimple =
RestrictorSimple(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("restrictor_simple"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != RestrictorSimple::class.java) return false
return true
}
override fun hashCode(): Int = 11002
}
/** Converts instances of [PartiqlAst.GraphMatchRestrictor] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.GraphMatchRestrictor): T = when(node) {
is PartiqlAst.GraphMatchRestrictor.RestrictorTrail -> convertRestrictorTrail(node)
is PartiqlAst.GraphMatchRestrictor.RestrictorAcyclic -> convertRestrictorAcyclic(node)
is PartiqlAst.GraphMatchRestrictor.RestrictorSimple -> convertRestrictorSimple(node)
}
fun convertRestrictorTrail(node: PartiqlAst.GraphMatchRestrictor.RestrictorTrail): T
fun convertRestrictorAcyclic(node: PartiqlAst.GraphMatchRestrictor.RestrictorAcyclic): T
fun convertRestrictorSimple(node: PartiqlAst.GraphMatchRestrictor.RestrictorSimple): T
}
}
sealed class GraphMatchSelector(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): GraphMatchSelector =
when (this) {
is SelectorAnyShortest -> copy(metas = metas)
is SelectorAllShortest -> copy(metas = metas)
is SelectorAny -> copy(metas = metas)
is SelectorAnyK -> copy(metas = metas)
is SelectorShortestK -> copy(metas = metas)
is SelectorShortestKGroup -> copy(metas = metas)
}
class SelectorAnyShortest(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchSelector() {
override fun copy(metas: MetaContainer): SelectorAnyShortest =
SelectorAnyShortest(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SelectorAnyShortest =
SelectorAnyShortest(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("selector_any_shortest"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SelectorAnyShortest::class.java) return false
return true
}
override fun hashCode(): Int = 12000
}
class SelectorAllShortest(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchSelector() {
override fun copy(metas: MetaContainer): SelectorAllShortest =
SelectorAllShortest(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SelectorAllShortest =
SelectorAllShortest(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("selector_all_shortest"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SelectorAllShortest::class.java) return false
return true
}
override fun hashCode(): Int = 12001
}
class SelectorAny(
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchSelector() {
override fun copy(metas: MetaContainer): SelectorAny =
SelectorAny(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SelectorAny =
SelectorAny(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("selector_any"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SelectorAny::class.java) return false
return true
}
override fun hashCode(): Int = 12002
}
class SelectorAnyK(
val k: org.partiql.pig.runtime.LongPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchSelector() {
override fun copy(metas: MetaContainer): SelectorAnyK =
SelectorAnyK(
k = k,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SelectorAnyK =
SelectorAnyK(
k = k,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("selector_any_k"),
k.toIonElement(),
metas = metas)
return elements
}
fun copy(
k: org.partiql.pig.runtime.LongPrimitive = this.k,
metas: MetaContainer = this.metas
) =
SelectorAnyK(
k,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SelectorAnyK::class.java) return false
other as SelectorAnyK
if (k != other.k) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = k.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class SelectorShortestK(
val k: org.partiql.pig.runtime.LongPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchSelector() {
override fun copy(metas: MetaContainer): SelectorShortestK =
SelectorShortestK(
k = k,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SelectorShortestK =
SelectorShortestK(
k = k,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("selector_shortest_k"),
k.toIonElement(),
metas = metas)
return elements
}
fun copy(
k: org.partiql.pig.runtime.LongPrimitive = this.k,
metas: MetaContainer = this.metas
) =
SelectorShortestK(
k,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SelectorShortestK::class.java) return false
other as SelectorShortestK
if (k != other.k) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = k.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class SelectorShortestKGroup(
val k: org.partiql.pig.runtime.LongPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): GraphMatchSelector() {
override fun copy(metas: MetaContainer): SelectorShortestKGroup =
SelectorShortestKGroup(
k = k,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SelectorShortestKGroup =
SelectorShortestKGroup(
k = k,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("selector_shortest_k_group"),
k.toIonElement(),
metas = metas)
return elements
}
fun copy(
k: org.partiql.pig.runtime.LongPrimitive = this.k,
metas: MetaContainer = this.metas
) =
SelectorShortestKGroup(
k,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SelectorShortestKGroup::class.java) return false
other as SelectorShortestKGroup
if (k != other.k) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = k.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.GraphMatchSelector] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.GraphMatchSelector): T = when(node) {
is PartiqlAst.GraphMatchSelector.SelectorAnyShortest -> convertSelectorAnyShortest(node)
is PartiqlAst.GraphMatchSelector.SelectorAllShortest -> convertSelectorAllShortest(node)
is PartiqlAst.GraphMatchSelector.SelectorAny -> convertSelectorAny(node)
is PartiqlAst.GraphMatchSelector.SelectorAnyK -> convertSelectorAnyK(node)
is PartiqlAst.GraphMatchSelector.SelectorShortestK -> convertSelectorShortestK(node)
is PartiqlAst.GraphMatchSelector.SelectorShortestKGroup -> convertSelectorShortestKGroup(node)
}
fun convertSelectorAnyShortest(node: PartiqlAst.GraphMatchSelector.SelectorAnyShortest): T
fun convertSelectorAllShortest(node: PartiqlAst.GraphMatchSelector.SelectorAllShortest): T
fun convertSelectorAny(node: PartiqlAst.GraphMatchSelector.SelectorAny): T
fun convertSelectorAnyK(node: PartiqlAst.GraphMatchSelector.SelectorAnyK): T
fun convertSelectorShortestK(node: PartiqlAst.GraphMatchSelector.SelectorShortestK): T
fun convertSelectorShortestKGroup(node: PartiqlAst.GraphMatchSelector.SelectorShortestKGroup): T
}
}
sealed class GroupingStrategy(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): GroupingStrategy =
when (this) {
is GroupFull -> copy(metas = metas)
is GroupPartial -> copy(metas = metas)
}
class GroupFull(
override val metas: MetaContainer = emptyMetaContainer()
): GroupingStrategy() {
override fun copy(metas: MetaContainer): GroupFull =
GroupFull(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GroupFull =
GroupFull(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("group_full"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GroupFull::class.java) return false
return true
}
override fun hashCode(): Int = 13000
}
class GroupPartial(
override val metas: MetaContainer = emptyMetaContainer()
): GroupingStrategy() {
override fun copy(metas: MetaContainer): GroupPartial =
GroupPartial(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): GroupPartial =
GroupPartial(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("group_partial"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != GroupPartial::class.java) return false
return true
}
override fun hashCode(): Int = 13001
}
/** Converts instances of [PartiqlAst.GroupingStrategy] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.GroupingStrategy): T = when(node) {
is PartiqlAst.GroupingStrategy.GroupFull -> convertGroupFull(node)
is PartiqlAst.GroupingStrategy.GroupPartial -> convertGroupPartial(node)
}
fun convertGroupFull(node: PartiqlAst.GroupingStrategy.GroupFull): T
fun convertGroupPartial(node: PartiqlAst.GroupingStrategy.GroupPartial): T
}
}
sealed class OrderingSpec(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): OrderingSpec =
when (this) {
is Asc -> copy(metas = metas)
is Desc -> copy(metas = metas)
}
class Asc(
override val metas: MetaContainer = emptyMetaContainer()
): OrderingSpec() {
override fun copy(metas: MetaContainer): Asc =
Asc(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Asc =
Asc(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("asc"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Asc::class.java) return false
return true
}
override fun hashCode(): Int = 14000
}
class Desc(
override val metas: MetaContainer = emptyMetaContainer()
): OrderingSpec() {
override fun copy(metas: MetaContainer): Desc =
Desc(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Desc =
Desc(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("desc"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Desc::class.java) return false
return true
}
override fun hashCode(): Int = 14001
}
/** Converts instances of [PartiqlAst.OrderingSpec] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.OrderingSpec): T = when(node) {
is PartiqlAst.OrderingSpec.Asc -> convertAsc(node)
is PartiqlAst.OrderingSpec.Desc -> convertDesc(node)
}
fun convertAsc(node: PartiqlAst.OrderingSpec.Asc): T
fun convertDesc(node: PartiqlAst.OrderingSpec.Desc): T
}
}
sealed class NullsSpec(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): NullsSpec =
when (this) {
is NullsFirst -> copy(metas = metas)
is NullsLast -> copy(metas = metas)
}
class NullsFirst(
override val metas: MetaContainer = emptyMetaContainer()
): NullsSpec() {
override fun copy(metas: MetaContainer): NullsFirst =
NullsFirst(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): NullsFirst =
NullsFirst(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("nulls_first"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != NullsFirst::class.java) return false
return true
}
override fun hashCode(): Int = 15000
}
class NullsLast(
override val metas: MetaContainer = emptyMetaContainer()
): NullsSpec() {
override fun copy(metas: MetaContainer): NullsLast =
NullsLast(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): NullsLast =
NullsLast(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("nulls_last"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != NullsLast::class.java) return false
return true
}
override fun hashCode(): Int = 15001
}
/** Converts instances of [PartiqlAst.NullsSpec] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.NullsSpec): T = when(node) {
is PartiqlAst.NullsSpec.NullsFirst -> convertNullsFirst(node)
is PartiqlAst.NullsSpec.NullsLast -> convertNullsLast(node)
}
fun convertNullsFirst(node: PartiqlAst.NullsSpec.NullsFirst): T
fun convertNullsLast(node: PartiqlAst.NullsSpec.NullsLast): T
}
}
sealed class CaseSensitivity(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): CaseSensitivity =
when (this) {
is CaseSensitive -> copy(metas = metas)
is CaseInsensitive -> copy(metas = metas)
}
class CaseSensitive(
override val metas: MetaContainer = emptyMetaContainer()
): CaseSensitivity() {
override fun copy(metas: MetaContainer): CaseSensitive =
CaseSensitive(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CaseSensitive =
CaseSensitive(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("case_sensitive"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CaseSensitive::class.java) return false
return true
}
override fun hashCode(): Int = 16000
}
class CaseInsensitive(
override val metas: MetaContainer = emptyMetaContainer()
): CaseSensitivity() {
override fun copy(metas: MetaContainer): CaseInsensitive =
CaseInsensitive(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CaseInsensitive =
CaseInsensitive(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("case_insensitive"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CaseInsensitive::class.java) return false
return true
}
override fun hashCode(): Int = 16001
}
/** Converts instances of [PartiqlAst.CaseSensitivity] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.CaseSensitivity): T = when(node) {
is PartiqlAst.CaseSensitivity.CaseSensitive -> convertCaseSensitive(node)
is PartiqlAst.CaseSensitivity.CaseInsensitive -> convertCaseInsensitive(node)
}
fun convertCaseSensitive(node: PartiqlAst.CaseSensitivity.CaseSensitive): T
fun convertCaseInsensitive(node: PartiqlAst.CaseSensitivity.CaseInsensitive): T
}
}
sealed class ScopeQualifier(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): ScopeQualifier =
when (this) {
is Unqualified -> copy(metas = metas)
is LocalsFirst -> copy(metas = metas)
}
class Unqualified(
override val metas: MetaContainer = emptyMetaContainer()
): ScopeQualifier() {
override fun copy(metas: MetaContainer): Unqualified =
Unqualified(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Unqualified =
Unqualified(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("unqualified"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Unqualified::class.java) return false
return true
}
override fun hashCode(): Int = 17000
}
class LocalsFirst(
override val metas: MetaContainer = emptyMetaContainer()
): ScopeQualifier() {
override fun copy(metas: MetaContainer): LocalsFirst =
LocalsFirst(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): LocalsFirst =
LocalsFirst(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("locals_first"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != LocalsFirst::class.java) return false
return true
}
override fun hashCode(): Int = 17001
}
/** Converts instances of [PartiqlAst.ScopeQualifier] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.ScopeQualifier): T = when(node) {
is PartiqlAst.ScopeQualifier.Unqualified -> convertUnqualified(node)
is PartiqlAst.ScopeQualifier.LocalsFirst -> convertLocalsFirst(node)
}
fun convertUnqualified(node: PartiqlAst.ScopeQualifier.Unqualified): T
fun convertLocalsFirst(node: PartiqlAst.ScopeQualifier.LocalsFirst): T
}
}
sealed class SetQuantifier(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): SetQuantifier =
when (this) {
is All -> copy(metas = metas)
is Distinct -> copy(metas = metas)
}
class All(
override val metas: MetaContainer = emptyMetaContainer()
): SetQuantifier() {
override fun copy(metas: MetaContainer): All =
All(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): All =
All(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("all"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != All::class.java) return false
return true
}
override fun hashCode(): Int = 18000
}
class Distinct(
override val metas: MetaContainer = emptyMetaContainer()
): SetQuantifier() {
override fun copy(metas: MetaContainer): Distinct =
Distinct(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Distinct =
Distinct(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("distinct"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Distinct::class.java) return false
return true
}
override fun hashCode(): Int = 18001
}
/** Converts instances of [PartiqlAst.SetQuantifier] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.SetQuantifier): T = when(node) {
is PartiqlAst.SetQuantifier.All -> convertAll(node)
is PartiqlAst.SetQuantifier.Distinct -> convertDistinct(node)
}
fun convertAll(node: PartiqlAst.SetQuantifier.All): T
fun convertDistinct(node: PartiqlAst.SetQuantifier.Distinct): T
}
}
sealed class BagOpType(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): BagOpType =
when (this) {
is Union -> copy(metas = metas)
is Intersect -> copy(metas = metas)
is Except -> copy(metas = metas)
is OuterUnion -> copy(metas = metas)
is OuterIntersect -> copy(metas = metas)
is OuterExcept -> copy(metas = metas)
}
class Union(
override val metas: MetaContainer = emptyMetaContainer()
): BagOpType() {
override fun copy(metas: MetaContainer): Union =
Union(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Union =
Union(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("union"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Union::class.java) return false
return true
}
override fun hashCode(): Int = 19000
}
class Intersect(
override val metas: MetaContainer = emptyMetaContainer()
): BagOpType() {
override fun copy(metas: MetaContainer): Intersect =
Intersect(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Intersect =
Intersect(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("intersect"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Intersect::class.java) return false
return true
}
override fun hashCode(): Int = 19001
}
class Except(
override val metas: MetaContainer = emptyMetaContainer()
): BagOpType() {
override fun copy(metas: MetaContainer): Except =
Except(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Except =
Except(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("except"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Except::class.java) return false
return true
}
override fun hashCode(): Int = 19002
}
class OuterUnion(
override val metas: MetaContainer = emptyMetaContainer()
): BagOpType() {
override fun copy(metas: MetaContainer): OuterUnion =
OuterUnion(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): OuterUnion =
OuterUnion(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("outer_union"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != OuterUnion::class.java) return false
return true
}
override fun hashCode(): Int = 19003
}
class OuterIntersect(
override val metas: MetaContainer = emptyMetaContainer()
): BagOpType() {
override fun copy(metas: MetaContainer): OuterIntersect =
OuterIntersect(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): OuterIntersect =
OuterIntersect(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("outer_intersect"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != OuterIntersect::class.java) return false
return true
}
override fun hashCode(): Int = 19004
}
class OuterExcept(
override val metas: MetaContainer = emptyMetaContainer()
): BagOpType() {
override fun copy(metas: MetaContainer): OuterExcept =
OuterExcept(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): OuterExcept =
OuterExcept(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("outer_except"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != OuterExcept::class.java) return false
return true
}
override fun hashCode(): Int = 19005
}
/** Converts instances of [PartiqlAst.BagOpType] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.BagOpType): T = when(node) {
is PartiqlAst.BagOpType.Union -> convertUnion(node)
is PartiqlAst.BagOpType.Intersect -> convertIntersect(node)
is PartiqlAst.BagOpType.Except -> convertExcept(node)
is PartiqlAst.BagOpType.OuterUnion -> convertOuterUnion(node)
is PartiqlAst.BagOpType.OuterIntersect -> convertOuterIntersect(node)
is PartiqlAst.BagOpType.OuterExcept -> convertOuterExcept(node)
}
fun convertUnion(node: PartiqlAst.BagOpType.Union): T
fun convertIntersect(node: PartiqlAst.BagOpType.Intersect): T
fun convertExcept(node: PartiqlAst.BagOpType.Except): T
fun convertOuterUnion(node: PartiqlAst.BagOpType.OuterUnion): T
fun convertOuterIntersect(node: PartiqlAst.BagOpType.OuterIntersect): T
fun convertOuterExcept(node: PartiqlAst.BagOpType.OuterExcept): T
}
}
sealed class DmlOp(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): DmlOp =
when (this) {
is Insert -> copy(metas = metas)
is InsertValue -> copy(metas = metas)
is Set -> copy(metas = metas)
is Remove -> copy(metas = metas)
is Delete -> copy(metas = metas)
}
class Insert(
val target: Expr,
val values: Expr,
val conflictAction: ConflictAction?,
override val metas: MetaContainer = emptyMetaContainer()
): DmlOp() {
override fun copy(metas: MetaContainer): Insert =
Insert(
target = target,
values = values,
conflictAction = conflictAction,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Insert =
Insert(
target = target,
values = values,
conflictAction = conflictAction,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("insert"),
target.toIonElement(),
values.toIonElement(),
conflictAction?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
target: Expr = this.target,
values: Expr = this.values,
conflictAction: ConflictAction? = this.conflictAction,
metas: MetaContainer = this.metas
) =
Insert(
target,
values,
conflictAction,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Insert::class.java) return false
other as Insert
if (target != other.target) return false
if (values != other.values) return false
if (conflictAction != other.conflictAction) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = target.hashCode()
hc = 31 * hc + values.hashCode()
hc = 31 * hc + conflictAction.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class InsertValue(
val target: Expr,
val value: Expr,
val index: Expr?,
val onConflict: OnConflict?,
override val metas: MetaContainer = emptyMetaContainer()
): DmlOp() {
override fun copy(metas: MetaContainer): InsertValue =
InsertValue(
target = target,
value = value,
index = index,
onConflict = onConflict,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): InsertValue =
InsertValue(
target = target,
value = value,
index = index,
onConflict = onConflict,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("insert_value"),
target.toIonElement(),
value.toIonElement(),
index?.toIonElement() ?: ionNull(),
onConflict?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
target: Expr = this.target,
value: Expr = this.value,
index: Expr? = this.index,
onConflict: OnConflict? = this.onConflict,
metas: MetaContainer = this.metas
) =
InsertValue(
target,
value,
index,
onConflict,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != InsertValue::class.java) return false
other as InsertValue
if (target != other.target) return false
if (value != other.value) return false
if (index != other.index) return false
if (onConflict != other.onConflict) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = target.hashCode()
hc = 31 * hc + value.hashCode()
hc = 31 * hc + index.hashCode()
hc = 31 * hc + onConflict.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Set(
val assignment: Assignment,
override val metas: MetaContainer = emptyMetaContainer()
): DmlOp() {
override fun copy(metas: MetaContainer): Set =
Set(
assignment = assignment,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Set =
Set(
assignment = assignment,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("set"),
assignment.toIonElement(),
metas = metas)
return elements
}
fun copy(
assignment: Assignment = this.assignment,
metas: MetaContainer = this.metas
) =
Set(
assignment,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Set::class.java) return false
other as Set
if (assignment != other.assignment) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = assignment.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Remove(
val target: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): DmlOp() {
override fun copy(metas: MetaContainer): Remove =
Remove(
target = target,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Remove =
Remove(
target = target,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("remove"),
target.toIonElement(),
metas = metas)
return elements
}
fun copy(
target: Expr = this.target,
metas: MetaContainer = this.metas
) =
Remove(
target,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Remove::class.java) return false
other as Remove
if (target != other.target) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = target.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class Delete(
override val metas: MetaContainer = emptyMetaContainer()
): DmlOp() {
override fun copy(metas: MetaContainer): Delete =
Delete(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Delete =
Delete(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("delete"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Delete::class.java) return false
return true
}
override fun hashCode(): Int = 20004
}
/** Converts instances of [PartiqlAst.DmlOp] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.DmlOp): T = when(node) {
is PartiqlAst.DmlOp.Insert -> convertInsert(node)
is PartiqlAst.DmlOp.InsertValue -> convertInsertValue(node)
is PartiqlAst.DmlOp.Set -> convertSet(node)
is PartiqlAst.DmlOp.Remove -> convertRemove(node)
is PartiqlAst.DmlOp.Delete -> convertDelete(node)
}
fun convertInsert(node: PartiqlAst.DmlOp.Insert): T
fun convertInsertValue(node: PartiqlAst.DmlOp.InsertValue): T
fun convertSet(node: PartiqlAst.DmlOp.Set): T
fun convertRemove(node: PartiqlAst.DmlOp.Remove): T
fun convertDelete(node: PartiqlAst.DmlOp.Delete): T
}
}
sealed class ConflictAction(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): ConflictAction =
when (this) {
is DoReplace -> copy(metas = metas)
is DoUpdate -> copy(metas = metas)
is DoNothing -> copy(metas = metas)
}
class DoReplace(
val value: OnConflictValue,
override val metas: MetaContainer = emptyMetaContainer()
): ConflictAction() {
override fun copy(metas: MetaContainer): DoReplace =
DoReplace(
value = value,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DoReplace =
DoReplace(
value = value,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("do_replace"),
value.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: OnConflictValue = this.value,
metas: MetaContainer = this.metas
) =
DoReplace(
value,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DoReplace::class.java) return false
other as DoReplace
if (value != other.value) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class DoUpdate(
val value: OnConflictValue,
override val metas: MetaContainer = emptyMetaContainer()
): ConflictAction() {
override fun copy(metas: MetaContainer): DoUpdate =
DoUpdate(
value = value,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DoUpdate =
DoUpdate(
value = value,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("do_update"),
value.toIonElement(),
metas = metas)
return elements
}
fun copy(
value: OnConflictValue = this.value,
metas: MetaContainer = this.metas
) =
DoUpdate(
value,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DoUpdate::class.java) return false
other as DoUpdate
if (value != other.value) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = value.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class DoNothing(
override val metas: MetaContainer = emptyMetaContainer()
): ConflictAction() {
override fun copy(metas: MetaContainer): DoNothing =
DoNothing(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DoNothing =
DoNothing(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("do_nothing"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DoNothing::class.java) return false
return true
}
override fun hashCode(): Int = 21002
}
/** Converts instances of [PartiqlAst.ConflictAction] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.ConflictAction): T = when(node) {
is PartiqlAst.ConflictAction.DoReplace -> convertDoReplace(node)
is PartiqlAst.ConflictAction.DoUpdate -> convertDoUpdate(node)
is PartiqlAst.ConflictAction.DoNothing -> convertDoNothing(node)
}
fun convertDoReplace(node: PartiqlAst.ConflictAction.DoReplace): T
fun convertDoUpdate(node: PartiqlAst.ConflictAction.DoUpdate): T
fun convertDoNothing(node: PartiqlAst.ConflictAction.DoNothing): T
}
}
sealed class OnConflictValue(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): OnConflictValue =
when (this) {
is Excluded -> copy(metas = metas)
}
class Excluded(
override val metas: MetaContainer = emptyMetaContainer()
): OnConflictValue() {
override fun copy(metas: MetaContainer): Excluded =
Excluded(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Excluded =
Excluded(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("excluded"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Excluded::class.java) return false
return true
}
override fun hashCode(): Int = 22000
}
/** Converts instances of [PartiqlAst.OnConflictValue] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.OnConflictValue): T = when(node) {
is PartiqlAst.OnConflictValue.Excluded -> convertExcluded(node)
}
fun convertExcluded(node: PartiqlAst.OnConflictValue.Excluded): T
}
}
sealed class DdlOp(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): DdlOp =
when (this) {
is CreateTable -> copy(metas = metas)
is DropTable -> copy(metas = metas)
is CreateIndex -> copy(metas = metas)
is DropIndex -> copy(metas = metas)
}
class CreateTable(
val tableName: org.partiql.pig.runtime.SymbolPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): DdlOp() {
override fun copy(metas: MetaContainer): CreateTable =
CreateTable(
tableName = tableName,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CreateTable =
CreateTable(
tableName = tableName,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("create_table"),
tableName.toIonElement(),
metas = metas)
return elements
}
fun copy(
tableName: org.partiql.pig.runtime.SymbolPrimitive = this.tableName,
metas: MetaContainer = this.metas
) =
CreateTable(
tableName,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CreateTable::class.java) return false
other as CreateTable
if (tableName != other.tableName) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = tableName.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class DropTable(
val tableName: Identifier,
override val metas: MetaContainer = emptyMetaContainer()
): DdlOp() {
override fun copy(metas: MetaContainer): DropTable =
DropTable(
tableName = tableName,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DropTable =
DropTable(
tableName = tableName,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("drop_table"),
tableName.toIonElement(),
metas = metas)
return elements
}
fun copy(
tableName: Identifier = this.tableName,
metas: MetaContainer = this.metas
) =
DropTable(
tableName,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DropTable::class.java) return false
other as DropTable
if (tableName != other.tableName) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = tableName.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class CreateIndex(
val indexName: Identifier,
val fields: kotlin.collections.List,
override val metas: MetaContainer = emptyMetaContainer()
): DdlOp() {
override fun copy(metas: MetaContainer): CreateIndex =
CreateIndex(
indexName = indexName,
fields = fields,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CreateIndex =
CreateIndex(
indexName = indexName,
fields = fields,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("create_index"),
indexName.toIonElement(),
*fields.map { it.toIonElement() }.toTypedArray(),
metas = metas)
return elements
}
fun copy(
indexName: Identifier = this.indexName,
fields: kotlin.collections.List = this.fields,
metas: MetaContainer = this.metas
) =
CreateIndex(
indexName,
fields,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CreateIndex::class.java) return false
other as CreateIndex
if (indexName != other.indexName) return false
if (fields != other.fields) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = indexName.hashCode()
hc = 31 * hc + fields.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class DropIndex(
val table: Identifier,
val keys: Identifier,
override val metas: MetaContainer = emptyMetaContainer()
): DdlOp() {
override fun copy(metas: MetaContainer): DropIndex =
DropIndex(
table = table,
keys = keys,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DropIndex =
DropIndex(
table = table,
keys = keys,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = listOfNotNull(
ionSymbol("drop_index"),
table?.let { ionSexpOf(ionSymbol("table"), it.toIonElement()) },
keys?.let { ionSexpOf(ionSymbol("keys"), it.toIonElement()) }
)
return ionSexpOf(elements, metas = metas)
}
fun copy(
table: Identifier = this.table,
keys: Identifier = this.keys,
metas: MetaContainer = this.metas
) =
DropIndex(
table,
keys,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DropIndex::class.java) return false
other as DropIndex
if (table != other.table) return false
if (keys != other.keys) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = table.hashCode()
hc = 31 * hc + keys.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.DdlOp] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.DdlOp): T = when(node) {
is PartiqlAst.DdlOp.CreateTable -> convertCreateTable(node)
is PartiqlAst.DdlOp.DropTable -> convertDropTable(node)
is PartiqlAst.DdlOp.CreateIndex -> convertCreateIndex(node)
is PartiqlAst.DdlOp.DropIndex -> convertDropIndex(node)
}
fun convertCreateTable(node: PartiqlAst.DdlOp.CreateTable): T
fun convertDropTable(node: PartiqlAst.DdlOp.DropTable): T
fun convertCreateIndex(node: PartiqlAst.DdlOp.CreateIndex): T
fun convertDropIndex(node: PartiqlAst.DdlOp.DropIndex): T
}
}
sealed class ColumnComponent(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): ColumnComponent =
when (this) {
is ReturningWildcard -> copy(metas = metas)
is ReturningColumn -> copy(metas = metas)
}
class ReturningWildcard(
override val metas: MetaContainer = emptyMetaContainer()
): ColumnComponent() {
override fun copy(metas: MetaContainer): ReturningWildcard =
ReturningWildcard(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ReturningWildcard =
ReturningWildcard(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("returning_wildcard"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ReturningWildcard::class.java) return false
return true
}
override fun hashCode(): Int = 24000
}
class ReturningColumn(
val expr: Expr,
override val metas: MetaContainer = emptyMetaContainer()
): ColumnComponent() {
override fun copy(metas: MetaContainer): ReturningColumn =
ReturningColumn(
expr = expr,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ReturningColumn =
ReturningColumn(
expr = expr,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("returning_column"),
expr.toIonElement(),
metas = metas)
return elements
}
fun copy(
expr: Expr = this.expr,
metas: MetaContainer = this.metas
) =
ReturningColumn(
expr,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ReturningColumn::class.java) return false
other as ReturningColumn
if (expr != other.expr) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = expr.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.ColumnComponent] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.ColumnComponent): T = when(node) {
is PartiqlAst.ColumnComponent.ReturningWildcard -> convertReturningWildcard(node)
is PartiqlAst.ColumnComponent.ReturningColumn -> convertReturningColumn(node)
}
fun convertReturningWildcard(node: PartiqlAst.ColumnComponent.ReturningWildcard): T
fun convertReturningColumn(node: PartiqlAst.ColumnComponent.ReturningColumn): T
}
}
sealed class ReturningMapping(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): ReturningMapping =
when (this) {
is ModifiedNew -> copy(metas = metas)
is ModifiedOld -> copy(metas = metas)
is AllNew -> copy(metas = metas)
is AllOld -> copy(metas = metas)
}
class ModifiedNew(
override val metas: MetaContainer = emptyMetaContainer()
): ReturningMapping() {
override fun copy(metas: MetaContainer): ModifiedNew =
ModifiedNew(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ModifiedNew =
ModifiedNew(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("modified_new"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ModifiedNew::class.java) return false
return true
}
override fun hashCode(): Int = 25000
}
class ModifiedOld(
override val metas: MetaContainer = emptyMetaContainer()
): ReturningMapping() {
override fun copy(metas: MetaContainer): ModifiedOld =
ModifiedOld(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ModifiedOld =
ModifiedOld(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("modified_old"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ModifiedOld::class.java) return false
return true
}
override fun hashCode(): Int = 25001
}
class AllNew(
override val metas: MetaContainer = emptyMetaContainer()
): ReturningMapping() {
override fun copy(metas: MetaContainer): AllNew =
AllNew(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): AllNew =
AllNew(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("all_new"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != AllNew::class.java) return false
return true
}
override fun hashCode(): Int = 25002
}
class AllOld(
override val metas: MetaContainer = emptyMetaContainer()
): ReturningMapping() {
override fun copy(metas: MetaContainer): AllOld =
AllOld(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): AllOld =
AllOld(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("all_old"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != AllOld::class.java) return false
return true
}
override fun hashCode(): Int = 25003
}
/** Converts instances of [PartiqlAst.ReturningMapping] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.ReturningMapping): T = when(node) {
is PartiqlAst.ReturningMapping.ModifiedNew -> convertModifiedNew(node)
is PartiqlAst.ReturningMapping.ModifiedOld -> convertModifiedOld(node)
is PartiqlAst.ReturningMapping.AllNew -> convertAllNew(node)
is PartiqlAst.ReturningMapping.AllOld -> convertAllOld(node)
}
fun convertModifiedNew(node: PartiqlAst.ReturningMapping.ModifiedNew): T
fun convertModifiedOld(node: PartiqlAst.ReturningMapping.ModifiedOld): T
fun convertAllNew(node: PartiqlAst.ReturningMapping.AllNew): T
fun convertAllOld(node: PartiqlAst.ReturningMapping.AllOld): T
}
}
sealed class Type(override val metas: MetaContainer = emptyMetaContainer()) : PartiqlAstNode() {
override fun copy(metas: MetaContainer): Type =
when (this) {
is NullType -> copy(metas = metas)
is BooleanType -> copy(metas = metas)
is SmallintType -> copy(metas = metas)
is Integer4Type -> copy(metas = metas)
is Integer8Type -> copy(metas = metas)
is IntegerType -> copy(metas = metas)
is FloatType -> copy(metas = metas)
is RealType -> copy(metas = metas)
is DoublePrecisionType -> copy(metas = metas)
is DecimalType -> copy(metas = metas)
is NumericType -> copy(metas = metas)
is TimestampType -> copy(metas = metas)
is CharacterType -> copy(metas = metas)
is CharacterVaryingType -> copy(metas = metas)
is MissingType -> copy(metas = metas)
is StringType -> copy(metas = metas)
is SymbolType -> copy(metas = metas)
is BlobType -> copy(metas = metas)
is ClobType -> copy(metas = metas)
is DateType -> copy(metas = metas)
is TimeType -> copy(metas = metas)
is TimeWithTimeZoneType -> copy(metas = metas)
is StructType -> copy(metas = metas)
is TupleType -> copy(metas = metas)
is ListType -> copy(metas = metas)
is SexpType -> copy(metas = metas)
is BagType -> copy(metas = metas)
is AnyType -> copy(metas = metas)
is CustomType -> copy(metas = metas)
}
class NullType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): NullType =
NullType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): NullType =
NullType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("null_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != NullType::class.java) return false
return true
}
override fun hashCode(): Int = 26000
}
class BooleanType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): BooleanType =
BooleanType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): BooleanType =
BooleanType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("boolean_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != BooleanType::class.java) return false
return true
}
override fun hashCode(): Int = 26001
}
class SmallintType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): SmallintType =
SmallintType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SmallintType =
SmallintType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("smallint_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SmallintType::class.java) return false
return true
}
override fun hashCode(): Int = 26002
}
class Integer4Type(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): Integer4Type =
Integer4Type(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Integer4Type =
Integer4Type(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("integer4_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Integer4Type::class.java) return false
return true
}
override fun hashCode(): Int = 26003
}
class Integer8Type(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): Integer8Type =
Integer8Type(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): Integer8Type =
Integer8Type(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("integer8_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != Integer8Type::class.java) return false
return true
}
override fun hashCode(): Int = 26004
}
class IntegerType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): IntegerType =
IntegerType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): IntegerType =
IntegerType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("integer_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != IntegerType::class.java) return false
return true
}
override fun hashCode(): Int = 26005
}
class FloatType(
val precision: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): FloatType =
FloatType(
precision = precision,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): FloatType =
FloatType(
precision = precision,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("float_type"),
precision?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
precision: org.partiql.pig.runtime.LongPrimitive? = this.precision,
metas: MetaContainer = this.metas
) =
FloatType(
precision,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != FloatType::class.java) return false
other as FloatType
if (precision != other.precision) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = precision.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class RealType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): RealType =
RealType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): RealType =
RealType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("real_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != RealType::class.java) return false
return true
}
override fun hashCode(): Int = 26007
}
class DoublePrecisionType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): DoublePrecisionType =
DoublePrecisionType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DoublePrecisionType =
DoublePrecisionType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("double_precision_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DoublePrecisionType::class.java) return false
return true
}
override fun hashCode(): Int = 26008
}
class DecimalType(
val precision: org.partiql.pig.runtime.LongPrimitive?,
val scale: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): DecimalType =
DecimalType(
precision = precision,
scale = scale,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DecimalType =
DecimalType(
precision = precision,
scale = scale,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("decimal_type"),
precision?.toIonElement() ?: ionNull(),
scale?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
precision: org.partiql.pig.runtime.LongPrimitive? = this.precision,
scale: org.partiql.pig.runtime.LongPrimitive? = this.scale,
metas: MetaContainer = this.metas
) =
DecimalType(
precision,
scale,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DecimalType::class.java) return false
other as DecimalType
if (precision != other.precision) return false
if (scale != other.scale) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = precision.hashCode()
hc = 31 * hc + scale.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class NumericType(
val precision: org.partiql.pig.runtime.LongPrimitive?,
val scale: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): NumericType =
NumericType(
precision = precision,
scale = scale,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): NumericType =
NumericType(
precision = precision,
scale = scale,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("numeric_type"),
precision?.toIonElement() ?: ionNull(),
scale?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
precision: org.partiql.pig.runtime.LongPrimitive? = this.precision,
scale: org.partiql.pig.runtime.LongPrimitive? = this.scale,
metas: MetaContainer = this.metas
) =
NumericType(
precision,
scale,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != NumericType::class.java) return false
other as NumericType
if (precision != other.precision) return false
if (scale != other.scale) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = precision.hashCode()
hc = 31 * hc + scale.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class TimestampType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): TimestampType =
TimestampType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): TimestampType =
TimestampType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("timestamp_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != TimestampType::class.java) return false
return true
}
override fun hashCode(): Int = 26011
}
class CharacterType(
val length: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): CharacterType =
CharacterType(
length = length,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CharacterType =
CharacterType(
length = length,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("character_type"),
length?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
length: org.partiql.pig.runtime.LongPrimitive? = this.length,
metas: MetaContainer = this.metas
) =
CharacterType(
length,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CharacterType::class.java) return false
other as CharacterType
if (length != other.length) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = length.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class CharacterVaryingType(
val length: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): CharacterVaryingType =
CharacterVaryingType(
length = length,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CharacterVaryingType =
CharacterVaryingType(
length = length,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("character_varying_type"),
length?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
length: org.partiql.pig.runtime.LongPrimitive? = this.length,
metas: MetaContainer = this.metas
) =
CharacterVaryingType(
length,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CharacterVaryingType::class.java) return false
other as CharacterVaryingType
if (length != other.length) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = length.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class MissingType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): MissingType =
MissingType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): MissingType =
MissingType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("missing_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != MissingType::class.java) return false
return true
}
override fun hashCode(): Int = 26014
}
class StringType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): StringType =
StringType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): StringType =
StringType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("string_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != StringType::class.java) return false
return true
}
override fun hashCode(): Int = 26015
}
class SymbolType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): SymbolType =
SymbolType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SymbolType =
SymbolType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("symbol_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SymbolType::class.java) return false
return true
}
override fun hashCode(): Int = 26016
}
class BlobType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): BlobType =
BlobType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): BlobType =
BlobType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("blob_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != BlobType::class.java) return false
return true
}
override fun hashCode(): Int = 26017
}
class ClobType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): ClobType =
ClobType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ClobType =
ClobType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("clob_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ClobType::class.java) return false
return true
}
override fun hashCode(): Int = 26018
}
class DateType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): DateType =
DateType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): DateType =
DateType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("date_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != DateType::class.java) return false
return true
}
override fun hashCode(): Int = 26019
}
class TimeType(
val precision: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): TimeType =
TimeType(
precision = precision,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): TimeType =
TimeType(
precision = precision,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("time_type"),
precision?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
precision: org.partiql.pig.runtime.LongPrimitive? = this.precision,
metas: MetaContainer = this.metas
) =
TimeType(
precision,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != TimeType::class.java) return false
other as TimeType
if (precision != other.precision) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = precision.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class TimeWithTimeZoneType(
val precision: org.partiql.pig.runtime.LongPrimitive?,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): TimeWithTimeZoneType =
TimeWithTimeZoneType(
precision = precision,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): TimeWithTimeZoneType =
TimeWithTimeZoneType(
precision = precision,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("time_with_time_zone_type"),
precision?.toIonElement() ?: ionNull(),
metas = metas)
return elements
}
fun copy(
precision: org.partiql.pig.runtime.LongPrimitive? = this.precision,
metas: MetaContainer = this.metas
) =
TimeWithTimeZoneType(
precision,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != TimeWithTimeZoneType::class.java) return false
other as TimeWithTimeZoneType
if (precision != other.precision) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = precision.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
class StructType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): StructType =
StructType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): StructType =
StructType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("struct_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != StructType::class.java) return false
return true
}
override fun hashCode(): Int = 26022
}
class TupleType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): TupleType =
TupleType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): TupleType =
TupleType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("tuple_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != TupleType::class.java) return false
return true
}
override fun hashCode(): Int = 26023
}
class ListType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): ListType =
ListType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): ListType =
ListType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("list_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != ListType::class.java) return false
return true
}
override fun hashCode(): Int = 26024
}
class SexpType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): SexpType =
SexpType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): SexpType =
SexpType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("sexp_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != SexpType::class.java) return false
return true
}
override fun hashCode(): Int = 26025
}
class BagType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): BagType =
BagType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): BagType =
BagType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("bag_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != BagType::class.java) return false
return true
}
override fun hashCode(): Int = 26026
}
class AnyType(
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): AnyType =
AnyType(
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): AnyType =
AnyType(
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("any_type"),
metas = metas)
return elements
}
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != AnyType::class.java) return false
return true
}
override fun hashCode(): Int = 26027
}
class CustomType(
val name: org.partiql.pig.runtime.SymbolPrimitive,
override val metas: MetaContainer = emptyMetaContainer()
): Type() {
override fun copy(metas: MetaContainer): CustomType =
CustomType(
name = name,
metas = metas)
override fun withMeta(metaKey: String, metaValue: Any): CustomType =
CustomType(
name = name,
metas = metas + metaContainerOf(metaKey to metaValue))
override fun toIonElement(): SexpElement {
val elements = ionSexpOf(
ionSymbol("custom_type"),
name.toIonElement(),
metas = metas)
return elements
}
fun copy(
name: org.partiql.pig.runtime.SymbolPrimitive = this.name,
metas: MetaContainer = this.metas
) =
CustomType(
name,
metas)
override fun equals(other: Any?): Boolean {
if (other == null) return false
if (this === other) return true
if (other.javaClass != CustomType::class.java) return false
other as CustomType
if (name != other.name) return false
return true
}
private val myHashCode by lazy(LazyThreadSafetyMode.PUBLICATION) {
var hc = name.hashCode()
hc
}
override fun hashCode(): Int = myHashCode
}
/** Converts instances of [PartiqlAst.Type] to any [T]. */
interface Converter {
fun convert(node: PartiqlAst.Type): T = when(node) {
is PartiqlAst.Type.NullType -> convertNullType(node)
is PartiqlAst.Type.BooleanType -> convertBooleanType(node)
is PartiqlAst.Type.SmallintType -> convertSmallintType(node)
is PartiqlAst.Type.Integer4Type -> convertInteger4Type(node)
is PartiqlAst.Type.Integer8Type -> convertInteger8Type(node)
is PartiqlAst.Type.IntegerType -> convertIntegerType(node)
is PartiqlAst.Type.FloatType -> convertFloatType(node)
is PartiqlAst.Type.RealType -> convertRealType(node)
is PartiqlAst.Type.DoublePrecisionType -> convertDoublePrecisionType(node)
is PartiqlAst.Type.DecimalType -> convertDecimalType(node)
is PartiqlAst.Type.NumericType -> convertNumericType(node)
is PartiqlAst.Type.TimestampType -> convertTimestampType(node)
is PartiqlAst.Type.CharacterType -> convertCharacterType(node)
is PartiqlAst.Type.CharacterVaryingType -> convertCharacterVaryingType(node)
is PartiqlAst.Type.MissingType -> convertMissingType(node)
is PartiqlAst.Type.StringType -> convertStringType(node)
is PartiqlAst.Type.SymbolType -> convertSymbolType(node)
is PartiqlAst.Type.BlobType -> convertBlobType(node)
is PartiqlAst.Type.ClobType -> convertClobType(node)
is PartiqlAst.Type.DateType -> convertDateType(node)
is PartiqlAst.Type.TimeType -> convertTimeType(node)
is PartiqlAst.Type.TimeWithTimeZoneType -> convertTimeWithTimeZoneType(node)
is PartiqlAst.Type.StructType -> convertStructType(node)
is PartiqlAst.Type.TupleType -> convertTupleType(node)
is PartiqlAst.Type.ListType -> convertListType(node)
is PartiqlAst.Type.SexpType -> convertSexpType(node)
is PartiqlAst.Type.BagType -> convertBagType(node)
is PartiqlAst.Type.AnyType -> convertAnyType(node)
is PartiqlAst.Type.CustomType -> convertCustomType(node)
}
fun convertNullType(node: PartiqlAst.Type.NullType): T
fun convertBooleanType(node: PartiqlAst.Type.BooleanType): T
fun convertSmallintType(node: PartiqlAst.Type.SmallintType): T
fun convertInteger4Type(node: PartiqlAst.Type.Integer4Type): T
fun convertInteger8Type(node: PartiqlAst.Type.Integer8Type): T
fun convertIntegerType(node: PartiqlAst.Type.IntegerType): T
fun convertFloatType(node: PartiqlAst.Type.FloatType): T
fun convertRealType(node: PartiqlAst.Type.RealType): T
fun convertDoublePrecisionType(node: PartiqlAst.Type.DoublePrecisionType): T
fun convertDecimalType(node: PartiqlAst.Type.DecimalType): T
fun convertNumericType(node: PartiqlAst.Type.NumericType): T
fun convertTimestampType(node: PartiqlAst.Type.TimestampType): T
fun convertCharacterType(node: PartiqlAst.Type.CharacterType): T
fun convertCharacterVaryingType(node: PartiqlAst.Type.CharacterVaryingType): T
fun convertMissingType(node: PartiqlAst.Type.MissingType): T
fun convertStringType(node: PartiqlAst.Type.StringType): T
fun convertSymbolType(node: PartiqlAst.Type.SymbolType): T
fun convertBlobType(node: PartiqlAst.Type.BlobType): T
fun convertClobType(node: PartiqlAst.Type.ClobType): T
fun convertDateType(node: PartiqlAst.Type.DateType): T
fun convertTimeType(node: PartiqlAst.Type.TimeType): T
fun convertTimeWithTimeZoneType(node: PartiqlAst.Type.TimeWithTimeZoneType): T
fun convertStructType(node: PartiqlAst.Type.StructType): T
fun convertTupleType(node: PartiqlAst.Type.TupleType): T
fun convertListType(node: PartiqlAst.Type.ListType): T
fun convertSexpType(node: PartiqlAst.Type.SexpType): T
fun convertBagType(node: PartiqlAst.Type.BagType): T
fun convertAnyType(node: PartiqlAst.Type.AnyType): T
fun convertCustomType(node: PartiqlAst.Type.CustomType): T
}
}
/////////////////////////////////////////////////////////////////////////////
// IonElementTransformer
/////////////////////////////////////////////////////////////////////////////
private class IonElementTransformer : IonElementTransformerBase() {
override fun innerTransform(sexp: SexpElement): PartiqlAstNode {
return when(sexp.tag) {
//////////////////////////////////////
// Tuple Types
//////////////////////////////////////
"time_value" -> {
sexp.requireArityOrMalformed(IntRange(6, 7))
val hour = sexp.getRequired(0).toLongPrimitive()
val minute = sexp.getRequired(1).toLongPrimitive()
val second = sexp.getRequired(2).toLongPrimitive()
val nano = sexp.getRequired(3).toLongPrimitive()
val precision = sexp.getRequired(4).toLongPrimitive()
val withTimeZone = sexp.getRequired(5).toBoolPrimitive()
val tzMinutes = sexp.getOptional(6)?.toLongPrimitive()
PartiqlAst.TimeValue(
hour,
minute,
second,
nano,
precision,
withTimeZone,
tzMinutes,
metas = sexp.metas)
}
"let" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val letBindings = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Let(
letBindings,
metas = sexp.metas)
}
"let_binding" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val expr = sexp.getRequired(0).transformExpect()
val name = sexp.getRequired(1).toSymbolPrimitive()
PartiqlAst.LetBinding(
expr,
name,
metas = sexp.metas)
}
"graph_match_quantifier" -> {
sexp.requireArityOrMalformed(IntRange(1, 2))
val lower = sexp.getRequired(0).toLongPrimitive()
val upper = sexp.getOptional(1)?.toLongPrimitive()
PartiqlAst.GraphMatchQuantifier(
lower,
upper,
metas = sexp.metas)
}
"graph_match_pattern" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val restrictor = sexp.getOptional(0)?.transformExpect()
val prefilter = sexp.getOptional(1)?.transformExpect()
val variable = sexp.getOptional(2)?.toSymbolPrimitive()
val quantifier = sexp.getOptional(3)?.transformExpect()
val parts = sexp.values.drop(5).map { it.transformExpect() }
PartiqlAst.GraphMatchPattern(
restrictor,
prefilter,
variable,
quantifier,
parts,
metas = sexp.metas)
}
"gpml_pattern" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val selector = sexp.getOptional(0)?.transformExpect()
val patterns = sexp.values.drop(2).map { it.transformExpect() }
PartiqlAst.GpmlPattern(
selector,
patterns,
metas = sexp.metas)
}
"expr_pair" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val first = sexp.getRequired(0).transformExpect()
val second = sexp.getRequired(1).transformExpect()
PartiqlAst.ExprPair(
first,
second,
metas = sexp.metas)
}
"expr_pair_list" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val pairs = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.ExprPairList(
pairs,
metas = sexp.metas)
}
"group_by" -> {
sexp.requireArityOrMalformed(IntRange(2, 3))
val strategy = sexp.getRequired(0).transformExpect()
val keyList = sexp.getRequired(1).transformExpect()
val groupAsAlias = sexp.getOptional(2)?.toSymbolPrimitive()
PartiqlAst.GroupBy(
strategy,
keyList,
groupAsAlias,
metas = sexp.metas)
}
"group_key_list" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val keys = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.GroupKeyList(
keys,
metas = sexp.metas)
}
"group_key" -> {
sexp.requireArityOrMalformed(IntRange(1, 2))
val expr = sexp.getRequired(0).transformExpect()
val asAlias = sexp.getOptional(1)?.toSymbolPrimitive()
PartiqlAst.GroupKey(
expr,
asAlias,
metas = sexp.metas)
}
"order_by" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val sortSpecs = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.OrderBy(
sortSpecs,
metas = sexp.metas)
}
"sort_spec" -> {
sexp.requireArityOrMalformed(IntRange(1, 3))
val expr = sexp.getRequired(0).transformExpect()
val orderingSpec = sexp.getOptional(1)?.transformExpect()
val nullsSpec = sexp.getOptional(2)?.transformExpect()
PartiqlAst.SortSpec(
expr,
orderingSpec,
nullsSpec,
metas = sexp.metas)
}
"over" -> {
sexp.requireArityOrMalformed(IntRange(0, 2))
val partitionBy = sexp.getOptional(0)?.transformExpect()
val orderBy = sexp.getOptional(1)?.transformExpect()
PartiqlAst.Over(
partitionBy,
orderBy,
metas = sexp.metas)
}
"window_partition_list" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val exprs = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.WindowPartitionList(
exprs,
metas = sexp.metas)
}
"window_sort_spec_list" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val sortSpecs = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.WindowSortSpecList(
sortSpecs,
metas = sexp.metas)
}
"dml_op_list" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val ops = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.DmlOpList(
ops,
metas = sexp.metas)
}
"on_conflict" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val expr = sexp.getRequired(0).transformExpect()
val conflictAction = sexp.getRequired(1).transformExpect()
PartiqlAst.OnConflict(
expr,
conflictAction,
metas = sexp.metas)
}
"returning_expr" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val elems = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.ReturningExpr(
elems,
metas = sexp.metas)
}
"returning_elem" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val mapping = sexp.getRequired(0).transformExpect()
val column = sexp.getRequired(1).transformExpect()
PartiqlAst.ReturningElem(
mapping,
column,
metas = sexp.metas)
}
"identifier" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val name = sexp.getRequired(0).toSymbolPrimitive()
val case = sexp.getRequired(1).transformExpect()
PartiqlAst.Identifier(
name,
case,
metas = sexp.metas)
}
"assignment" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val target = sexp.getRequired(0).transformExpect()
val value = sexp.getRequired(1).transformExpect()
PartiqlAst.Assignment(
target,
value,
metas = sexp.metas)
}
//////////////////////////////////////
// Variants for Sum Type 'Statement'
//////////////////////////////////////
"query" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val expr = sexp.getRequired(0).transformExpect()
PartiqlAst.Statement.Query(
expr,
metas = sexp.metas)
}
"dml" -> {
val ir = sexp.transformToIntermediateRecord()
val operations = ir.processRequiredField("operations") { it.transformExpect() }
val from = ir.processOptionalField("from") { it.transformExpect() }
val where = ir.processOptionalField("where") { it.transformExpect() }
val returning = ir.processOptionalField("returning") { it.transformExpect() }
ir.malformedIfAnyUnprocessedFieldsRemain()
Statement.Dml(operations, from, where, returning, metas = sexp.metas)
}
"ddl" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val op = sexp.getRequired(0).transformExpect()
PartiqlAst.Statement.Ddl(
op,
metas = sexp.metas)
}
"exec" -> {
sexp.requireArityOrMalformed(IntRange(1, 2147483647))
val procedureName = sexp.getRequired(0).toSymbolPrimitive()
val args = sexp.values.drop(2).map { it.transformExpect() }
PartiqlAst.Statement.Exec(
procedureName,
args,
metas = sexp.metas)
}
"explain" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val target = sexp.getRequired(0).transformExpect()
PartiqlAst.Statement.Explain(
target,
metas = sexp.metas)
}
//////////////////////////////////////
// Variants for Sum Type 'ExplainTarget'
//////////////////////////////////////
"domain" -> {
sexp.requireArityOrMalformed(IntRange(1, 3))
val statement = sexp.getRequired(0).transformExpect()
val type = sexp.getOptional(1)?.toSymbolPrimitive()
val format = sexp.getOptional(2)?.toSymbolPrimitive()
PartiqlAst.ExplainTarget.Domain(
statement,
type,
format,
metas = sexp.metas)
}
//////////////////////////////////////
// Variants for Sum Type 'Expr'
//////////////////////////////////////
"missing" -> {
sexp.requireArityOrMalformed(IntRange(0, 0))
PartiqlAst.Expr.Missing(
metas = sexp.metas)
}
"lit" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val value = sexp.getRequiredIon(0)
PartiqlAst.Expr.Lit(
value,
metas = sexp.metas)
}
"id" -> {
sexp.requireArityOrMalformed(IntRange(3, 3))
val name = sexp.getRequired(0).toSymbolPrimitive()
val case = sexp.getRequired(1).transformExpect()
val qualifier = sexp.getRequired(2).transformExpect()
PartiqlAst.Expr.Id(
name,
case,
qualifier,
metas = sexp.metas)
}
"parameter" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val index = sexp.getRequired(0).toLongPrimitive()
PartiqlAst.Expr.Parameter(
index,
metas = sexp.metas)
}
"not" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val expr = sexp.getRequired(0).transformExpect()
PartiqlAst.Expr.Not(
expr,
metas = sexp.metas)
}
"pos" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val expr = sexp.getRequired(0).transformExpect()
PartiqlAst.Expr.Pos(
expr,
metas = sexp.metas)
}
"neg" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val expr = sexp.getRequired(0).transformExpect()
PartiqlAst.Expr.Neg(
expr,
metas = sexp.metas)
}
"plus" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Plus(
operands,
metas = sexp.metas)
}
"minus" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Minus(
operands,
metas = sexp.metas)
}
"times" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Times(
operands,
metas = sexp.metas)
}
"divide" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Divide(
operands,
metas = sexp.metas)
}
"modulo" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Modulo(
operands,
metas = sexp.metas)
}
"concat" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Concat(
operands,
metas = sexp.metas)
}
"and" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.And(
operands,
metas = sexp.metas)
}
"or" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Or(
operands,
metas = sexp.metas)
}
"eq" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Eq(
operands,
metas = sexp.metas)
}
"ne" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Ne(
operands,
metas = sexp.metas)
}
"gt" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Gt(
operands,
metas = sexp.metas)
}
"gte" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Gte(
operands,
metas = sexp.metas)
}
"lt" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Lt(
operands,
metas = sexp.metas)
}
"lte" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Lte(
operands,
metas = sexp.metas)
}
"like" -> {
sexp.requireArityOrMalformed(IntRange(2, 3))
val value = sexp.getRequired(0).transformExpect()
val pattern = sexp.getRequired(1).transformExpect()
val escape = sexp.getOptional(2)?.transformExpect()
PartiqlAst.Expr.Like(
value,
pattern,
escape,
metas = sexp.metas)
}
"between" -> {
sexp.requireArityOrMalformed(IntRange(3, 3))
val value = sexp.getRequired(0).transformExpect()
val from = sexp.getRequired(1).transformExpect()
val to = sexp.getRequired(2).transformExpect()
PartiqlAst.Expr.Between(
value,
from,
to,
metas = sexp.metas)
}
"in_collection" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val operands = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.InCollection(
operands,
metas = sexp.metas)
}
"is_type" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val value = sexp.getRequired(0).transformExpect()
val type = sexp.getRequired(1).transformExpect()
PartiqlAst.Expr.IsType(
value,
type,
metas = sexp.metas)
}
"simple_case" -> {
sexp.requireArityOrMalformed(IntRange(2, 3))
val expr = sexp.getRequired(0).transformExpect()
val cases = sexp.getRequired(1).transformExpect()
val default = sexp.getOptional(2)?.transformExpect()
PartiqlAst.Expr.SimpleCase(
expr,
cases,
default,
metas = sexp.metas)
}
"searched_case" -> {
sexp.requireArityOrMalformed(IntRange(1, 2))
val cases = sexp.getRequired(0).transformExpect()
val default = sexp.getOptional(1)?.transformExpect()
PartiqlAst.Expr.SearchedCase(
cases,
default,
metas = sexp.metas)
}
"struct" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val fields = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Struct(
fields,
metas = sexp.metas)
}
"bag" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val values = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Bag(
values,
metas = sexp.metas)
}
"list" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val values = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.List(
values,
metas = sexp.metas)
}
"sexp" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val values = sexp.values.drop(1).map { it.transformExpect() }
PartiqlAst.Expr.Sexp(
values,
metas = sexp.metas)
}
"date" -> {
sexp.requireArityOrMalformed(IntRange(3, 3))
val year = sexp.getRequired(0).toLongPrimitive()
val month = sexp.getRequired(1).toLongPrimitive()
val day = sexp.getRequired(2).toLongPrimitive()
PartiqlAst.Expr.Date(
year,
month,
day,
metas = sexp.metas)
}
"lit_time" -> {
sexp.requireArityOrMalformed(IntRange(1, 1))
val value = sexp.getRequired(0).transformExpect()
PartiqlAst.Expr.LitTime(
value,
metas = sexp.metas)
}
"bag_op" -> {
sexp.requireArityOrMalformed(IntRange(2, 2147483647))
val op = sexp.getRequired(0).transformExpect()
val quantifier = sexp.getRequired(1).transformExpect()
val operands = sexp.values.drop(3).map { it.transformExpect() }
PartiqlAst.Expr.BagOp(
op,
quantifier,
operands,
metas = sexp.metas)
}
"graph_match" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val expr = sexp.getRequired(0).transformExpect()
val gpmlPattern = sexp.getRequired(1).transformExpect()
PartiqlAst.Expr.GraphMatch(
expr,
gpmlPattern,
metas = sexp.metas)
}
"path" -> {
sexp.requireArityOrMalformed(IntRange(1, 2147483647))
val root = sexp.getRequired(0).transformExpect()
val steps = sexp.values.drop(2).map { it.transformExpect() }
PartiqlAst.Expr.Path(
root,
steps,
metas = sexp.metas)
}
"call" -> {
sexp.requireArityOrMalformed(IntRange(1, 2147483647))
val funcName = sexp.getRequired(0).toSymbolPrimitive()
val args = sexp.values.drop(2).map { it.transformExpect() }
PartiqlAst.Expr.Call(
funcName,
args,
metas = sexp.metas)
}
"call_agg" -> {
sexp.requireArityOrMalformed(IntRange(3, 3))
val setq = sexp.getRequired(0).transformExpect()
val funcName = sexp.getRequired(1).toSymbolPrimitive()
val arg = sexp.getRequired(2).transformExpect()
PartiqlAst.Expr.CallAgg(
setq,
funcName,
arg,
metas = sexp.metas)
}
"call_window" -> {
sexp.requireArityOrMalformed(IntRange(2, 2147483647))
val funcName = sexp.getRequired(0).toSymbolPrimitive()
val over = sexp.getRequired(1).transformExpect()
val args = sexp.values.drop(3).map { it.transformExpect() }
PartiqlAst.Expr.CallWindow(
funcName,
over,
args,
metas = sexp.metas)
}
"cast" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val value = sexp.getRequired(0).transformExpect()
val asType = sexp.getRequired(1).transformExpect()
PartiqlAst.Expr.Cast(
value,
asType,
metas = sexp.metas)
}
"can_cast" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val value = sexp.getRequired(0).transformExpect()
val asType = sexp.getRequired(1).transformExpect()
PartiqlAst.Expr.CanCast(
value,
asType,
metas = sexp.metas)
}
"can_lossless_cast" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val value = sexp.getRequired(0).transformExpect()
val asType = sexp.getRequired(1).transformExpect()
PartiqlAst.Expr.CanLosslessCast(
value,
asType,
metas = sexp.metas)
}
"null_if" -> {
sexp.requireArityOrMalformed(IntRange(2, 2))
val expr1 = sexp.getRequired(0).transformExpect()
val expr2 = sexp.getRequired(1).transformExpect()
PartiqlAst.Expr.NullIf(
expr1,
expr2,
metas = sexp.metas)
}
"coalesce" -> {
sexp.requireArityOrMalformed(IntRange(0, 2147483647))
val args = sexp.values.drop(1).map { it.transformExpect