org.partiql.lang.domains.PartiqlLogicalToPartiqlLogicalResolved.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.*
abstract class PartiqlLogicalToPartiqlLogicalResolvedVisitorTransform : DomainVisitorTransformBase() {
//////////////////////////////////////
// Tuple Types
//////////////////////////////////////
// Tuple TimeValue
open fun transformTimeValue(node: PartiqlLogical.TimeValue): PartiqlLogicalResolved.TimeValue {
val new_hour = transformTimeValue_hour(node)
val new_minute = transformTimeValue_minute(node)
val new_second = transformTimeValue_second(node)
val new_nano = transformTimeValue_nano(node)
val new_precision = transformTimeValue_precision(node)
val new_withTimeZone = transformTimeValue_withTimeZone(node)
val new_tzMinutes = transformTimeValue_tzMinutes(node)
val new_metas = transformTimeValue_metas(node)
return PartiqlLogicalResolved.TimeValue(
hour = new_hour,
minute = new_minute,
second = new_second,
nano = new_nano,
precision = new_precision,
withTimeZone = new_withTimeZone,
tzMinutes = new_tzMinutes,
metas = new_metas
)
}
open fun transformTimeValue_hour(node: PartiqlLogical.TimeValue) =
transformLongPrimitive(node.hour)
open fun transformTimeValue_minute(node: PartiqlLogical.TimeValue) =
transformLongPrimitive(node.minute)
open fun transformTimeValue_second(node: PartiqlLogical.TimeValue) =
transformLongPrimitive(node.second)
open fun transformTimeValue_nano(node: PartiqlLogical.TimeValue) =
transformLongPrimitive(node.nano)
open fun transformTimeValue_precision(node: PartiqlLogical.TimeValue) =
transformLongPrimitive(node.precision)
open fun transformTimeValue_withTimeZone(node: PartiqlLogical.TimeValue) =
transformBoolPrimitive(node.withTimeZone)
open fun transformTimeValue_tzMinutes(node: PartiqlLogical.TimeValue) =
node.tzMinutes?.let { transformLongPrimitive(it) }
open fun transformTimeValue_metas(node: PartiqlLogical.TimeValue) =
transformMetas(node.metas)
// Tuple GraphMatchQuantifier
open fun transformGraphMatchQuantifier(node: PartiqlLogical.GraphMatchQuantifier): PartiqlLogicalResolved.GraphMatchQuantifier {
val new_lower = transformGraphMatchQuantifier_lower(node)
val new_upper = transformGraphMatchQuantifier_upper(node)
val new_metas = transformGraphMatchQuantifier_metas(node)
return PartiqlLogicalResolved.GraphMatchQuantifier(
lower = new_lower,
upper = new_upper,
metas = new_metas
)
}
open fun transformGraphMatchQuantifier_lower(node: PartiqlLogical.GraphMatchQuantifier) =
transformLongPrimitive(node.lower)
open fun transformGraphMatchQuantifier_upper(node: PartiqlLogical.GraphMatchQuantifier) =
node.upper?.let { transformLongPrimitive(it) }
open fun transformGraphMatchQuantifier_metas(node: PartiqlLogical.GraphMatchQuantifier) =
transformMetas(node.metas)
// Tuple GraphMatchPattern
open fun transformGraphMatchPattern(node: PartiqlLogical.GraphMatchPattern): PartiqlLogicalResolved.GraphMatchPattern {
val new_restrictor = transformGraphMatchPattern_restrictor(node)
val new_prefilter = transformGraphMatchPattern_prefilter(node)
val new_variable = transformGraphMatchPattern_variable(node)
val new_quantifier = transformGraphMatchPattern_quantifier(node)
val new_parts = transformGraphMatchPattern_parts(node)
val new_metas = transformGraphMatchPattern_metas(node)
return PartiqlLogicalResolved.GraphMatchPattern(
restrictor = new_restrictor,
prefilter = new_prefilter,
variable = new_variable,
quantifier = new_quantifier,
parts = new_parts,
metas = new_metas
)
}
open fun transformGraphMatchPattern_restrictor(node: PartiqlLogical.GraphMatchPattern) =
node.restrictor?.let { transformGraphMatchRestrictor(it) }
open fun transformGraphMatchPattern_prefilter(node: PartiqlLogical.GraphMatchPattern) =
node.prefilter?.let { transformExpr(it) }
open fun transformGraphMatchPattern_variable(node: PartiqlLogical.GraphMatchPattern) =
node.variable?.let { transformSymbolPrimitive(it) }
open fun transformGraphMatchPattern_quantifier(node: PartiqlLogical.GraphMatchPattern) =
node.quantifier?.let { transformGraphMatchQuantifier(it) }
open fun transformGraphMatchPattern_parts(node: PartiqlLogical.GraphMatchPattern) =
node.parts.map { transformGraphMatchPatternPart(it) }
open fun transformGraphMatchPattern_metas(node: PartiqlLogical.GraphMatchPattern) =
transformMetas(node.metas)
// Tuple GpmlPattern
open fun transformGpmlPattern(node: PartiqlLogical.GpmlPattern): PartiqlLogicalResolved.GpmlPattern {
val new_selector = transformGpmlPattern_selector(node)
val new_patterns = transformGpmlPattern_patterns(node)
val new_metas = transformGpmlPattern_metas(node)
return PartiqlLogicalResolved.GpmlPattern(
selector = new_selector,
patterns = new_patterns,
metas = new_metas
)
}
open fun transformGpmlPattern_selector(node: PartiqlLogical.GpmlPattern) =
node.selector?.let { transformGraphMatchSelector(it) }
open fun transformGpmlPattern_patterns(node: PartiqlLogical.GpmlPattern) =
node.patterns.map { transformGraphMatchPattern(it) }
open fun transformGpmlPattern_metas(node: PartiqlLogical.GpmlPattern) =
transformMetas(node.metas)
// Tuple ExprPair
open fun transformExprPair(node: PartiqlLogical.ExprPair): PartiqlLogicalResolved.ExprPair {
val new_first = transformExprPair_first(node)
val new_second = transformExprPair_second(node)
val new_metas = transformExprPair_metas(node)
return PartiqlLogicalResolved.ExprPair(
first = new_first,
second = new_second,
metas = new_metas
)
}
open fun transformExprPair_first(node: PartiqlLogical.ExprPair) =
transformExpr(node.first)
open fun transformExprPair_second(node: PartiqlLogical.ExprPair) =
transformExpr(node.second)
open fun transformExprPair_metas(node: PartiqlLogical.ExprPair) =
transformMetas(node.metas)
// Tuple ExprPairList
open fun transformExprPairList(node: PartiqlLogical.ExprPairList): PartiqlLogicalResolved.ExprPairList {
val new_pairs = transformExprPairList_pairs(node)
val new_metas = transformExprPairList_metas(node)
return PartiqlLogicalResolved.ExprPairList(
pairs = new_pairs,
metas = new_metas
)
}
open fun transformExprPairList_pairs(node: PartiqlLogical.ExprPairList) =
node.pairs.map { transformExprPair(it) }
open fun transformExprPairList_metas(node: PartiqlLogical.ExprPairList) =
transformMetas(node.metas)
// Tuple SortSpec
open fun transformSortSpec(node: PartiqlLogical.SortSpec): PartiqlLogicalResolved.SortSpec {
val new_expr = transformSortSpec_expr(node)
val new_orderingSpec = transformSortSpec_orderingSpec(node)
val new_nullsSpec = transformSortSpec_nullsSpec(node)
val new_metas = transformSortSpec_metas(node)
return PartiqlLogicalResolved.SortSpec(
expr = new_expr,
orderingSpec = new_orderingSpec,
nullsSpec = new_nullsSpec,
metas = new_metas
)
}
open fun transformSortSpec_expr(node: PartiqlLogical.SortSpec) =
transformExpr(node.expr)
open fun transformSortSpec_orderingSpec(node: PartiqlLogical.SortSpec) =
node.orderingSpec?.let { transformOrderingSpec(it) }
open fun transformSortSpec_nullsSpec(node: PartiqlLogical.SortSpec) =
node.nullsSpec?.let { transformNullsSpec(it) }
open fun transformSortSpec_metas(node: PartiqlLogical.SortSpec) =
transformMetas(node.metas)
// Tuple Over
open fun transformOver(node: PartiqlLogical.Over): PartiqlLogicalResolved.Over {
val new_partitionBy = transformOver_partitionBy(node)
val new_orderBy = transformOver_orderBy(node)
val new_metas = transformOver_metas(node)
return PartiqlLogicalResolved.Over(
partitionBy = new_partitionBy,
orderBy = new_orderBy,
metas = new_metas
)
}
open fun transformOver_partitionBy(node: PartiqlLogical.Over) =
node.partitionBy?.let { transformWindowPartitionList(it) }
open fun transformOver_orderBy(node: PartiqlLogical.Over) =
node.orderBy?.let { transformWindowSortSpecList(it) }
open fun transformOver_metas(node: PartiqlLogical.Over) =
transformMetas(node.metas)
// Tuple WindowPartitionList
open fun transformWindowPartitionList(node: PartiqlLogical.WindowPartitionList): PartiqlLogicalResolved.WindowPartitionList {
val new_exprs = transformWindowPartitionList_exprs(node)
val new_metas = transformWindowPartitionList_metas(node)
return PartiqlLogicalResolved.WindowPartitionList(
exprs = new_exprs,
metas = new_metas
)
}
open fun transformWindowPartitionList_exprs(node: PartiqlLogical.WindowPartitionList) =
node.exprs.map { transformExpr(it) }
open fun transformWindowPartitionList_metas(node: PartiqlLogical.WindowPartitionList) =
transformMetas(node.metas)
// Tuple WindowSortSpecList
open fun transformWindowSortSpecList(node: PartiqlLogical.WindowSortSpecList): PartiqlLogicalResolved.WindowSortSpecList {
val new_sortSpecs = transformWindowSortSpecList_sortSpecs(node)
val new_metas = transformWindowSortSpecList_metas(node)
return PartiqlLogicalResolved.WindowSortSpecList(
sortSpecs = new_sortSpecs,
metas = new_metas
)
}
open fun transformWindowSortSpecList_sortSpecs(node: PartiqlLogical.WindowSortSpecList) =
node.sortSpecs.map { transformSortSpec(it) }
open fun transformWindowSortSpecList_metas(node: PartiqlLogical.WindowSortSpecList) =
transformMetas(node.metas)
// Tuple Identifier
open fun transformIdentifier(node: PartiqlLogical.Identifier): PartiqlLogicalResolved.Identifier {
val new_name = transformIdentifier_name(node)
val new_case = transformIdentifier_case(node)
val new_metas = transformIdentifier_metas(node)
return PartiqlLogicalResolved.Identifier(
name = new_name,
case = new_case,
metas = new_metas
)
}
open fun transformIdentifier_name(node: PartiqlLogical.Identifier) =
transformSymbolPrimitive(node.name)
open fun transformIdentifier_case(node: PartiqlLogical.Identifier) =
transformCaseSensitivity(node.case)
open fun transformIdentifier_metas(node: PartiqlLogical.Identifier) =
transformMetas(node.metas)
abstract fun transformPlan(node:PartiqlLogical.Plan): PartiqlLogicalResolved.Plan
// Tuple LetBinding
open fun transformLetBinding(node: PartiqlLogical.LetBinding): PartiqlLogicalResolved.LetBinding {
val new_value = transformLetBinding_value(node)
val new_decl = transformLetBinding_decl(node)
val new_metas = transformLetBinding_metas(node)
return PartiqlLogicalResolved.LetBinding(
value = new_value,
decl = new_decl,
metas = new_metas
)
}
open fun transformLetBinding_value(node: PartiqlLogical.LetBinding) =
transformExpr(node.value)
open fun transformLetBinding_decl(node: PartiqlLogical.LetBinding) =
transformVarDecl(node.decl)
open fun transformLetBinding_metas(node: PartiqlLogical.LetBinding) =
transformMetas(node.metas)
// Tuple GroupKey
open fun transformGroupKey(node: PartiqlLogical.GroupKey): PartiqlLogicalResolved.GroupKey {
val new_expr = transformGroupKey_expr(node)
val new_asVar = transformGroupKey_asVar(node)
val new_metas = transformGroupKey_metas(node)
return PartiqlLogicalResolved.GroupKey(
expr = new_expr,
asVar = new_asVar,
metas = new_metas
)
}
open fun transformGroupKey_expr(node: PartiqlLogical.GroupKey) =
transformExpr(node.expr)
open fun transformGroupKey_asVar(node: PartiqlLogical.GroupKey) =
transformVarDecl(node.asVar)
open fun transformGroupKey_metas(node: PartiqlLogical.GroupKey) =
transformMetas(node.metas)
// Tuple GroupKeyList
open fun transformGroupKeyList(node: PartiqlLogical.GroupKeyList): PartiqlLogicalResolved.GroupKeyList {
val new_keys = transformGroupKeyList_keys(node)
val new_metas = transformGroupKeyList_metas(node)
return PartiqlLogicalResolved.GroupKeyList(
keys = new_keys,
metas = new_metas
)
}
open fun transformGroupKeyList_keys(node: PartiqlLogical.GroupKeyList) =
node.keys.map { transformGroupKey(it) }
open fun transformGroupKeyList_metas(node: PartiqlLogical.GroupKeyList) =
transformMetas(node.metas)
// Tuple AggregateFunction
open fun transformAggregateFunction(node: PartiqlLogical.AggregateFunction): PartiqlLogicalResolved.AggregateFunction {
val new_quantifier = transformAggregateFunction_quantifier(node)
val new_name = transformAggregateFunction_name(node)
val new_arg = transformAggregateFunction_arg(node)
val new_asVar = transformAggregateFunction_asVar(node)
val new_metas = transformAggregateFunction_metas(node)
return PartiqlLogicalResolved.AggregateFunction(
quantifier = new_quantifier,
name = new_name,
arg = new_arg,
asVar = new_asVar,
metas = new_metas
)
}
open fun transformAggregateFunction_quantifier(node: PartiqlLogical.AggregateFunction) =
transformSetQuantifier(node.quantifier)
open fun transformAggregateFunction_name(node: PartiqlLogical.AggregateFunction) =
transformSymbolPrimitive(node.name)
open fun transformAggregateFunction_arg(node: PartiqlLogical.AggregateFunction) =
transformExpr(node.arg)
open fun transformAggregateFunction_asVar(node: PartiqlLogical.AggregateFunction) =
transformVarDecl(node.asVar)
open fun transformAggregateFunction_metas(node: PartiqlLogical.AggregateFunction) =
transformMetas(node.metas)
// Tuple AggregateFunctionList
open fun transformAggregateFunctionList(node: PartiqlLogical.AggregateFunctionList): PartiqlLogicalResolved.AggregateFunctionList {
val new_functions = transformAggregateFunctionList_functions(node)
val new_metas = transformAggregateFunctionList_metas(node)
return PartiqlLogicalResolved.AggregateFunctionList(
functions = new_functions,
metas = new_metas
)
}
open fun transformAggregateFunctionList_functions(node: PartiqlLogical.AggregateFunctionList) =
node.functions.map { transformAggregateFunction(it) }
open fun transformAggregateFunctionList_metas(node: PartiqlLogical.AggregateFunctionList) =
transformMetas(node.metas)
// Tuple WindowExpression
open fun transformWindowExpression(node: PartiqlLogical.WindowExpression): PartiqlLogicalResolved.WindowExpression {
val new_decl = transformWindowExpression_decl(node)
val new_funcName = transformWindowExpression_funcName(node)
val new_args = transformWindowExpression_args(node)
val new_metas = transformWindowExpression_metas(node)
return PartiqlLogicalResolved.WindowExpression(
decl = new_decl,
funcName = new_funcName,
args = new_args,
metas = new_metas
)
}
open fun transformWindowExpression_decl(node: PartiqlLogical.WindowExpression) =
transformVarDecl(node.decl)
open fun transformWindowExpression_funcName(node: PartiqlLogical.WindowExpression) =
transformSymbolPrimitive(node.funcName)
open fun transformWindowExpression_args(node: PartiqlLogical.WindowExpression) =
node.args.map { transformExpr(it) }
open fun transformWindowExpression_metas(node: PartiqlLogical.WindowExpression) =
transformMetas(node.metas)
abstract fun transformVarDecl(node:PartiqlLogical.VarDecl): PartiqlLogicalResolved.VarDecl
//////////////////////////////////////
// Sum Type: ExplainTarget
//////////////////////////////////////
open fun transformExplainTarget(node: PartiqlLogical.ExplainTarget): PartiqlLogicalResolved.ExplainTarget =
when(node) {
is PartiqlLogical.ExplainTarget.Domain -> transformExplainTargetDomain(node)
}
// Variant ExplainTargetDomain
open fun transformExplainTargetDomain(node: PartiqlLogical.ExplainTarget.Domain): PartiqlLogicalResolved.ExplainTarget {
val new_statement = transformExplainTargetDomain_statement(node)
val new_type = transformExplainTargetDomain_type(node)
val new_format = transformExplainTargetDomain_format(node)
val new_metas = transformExplainTargetDomain_metas(node)
return PartiqlLogicalResolved.ExplainTarget.Domain(
statement = new_statement,
type = new_type,
format = new_format,
metas = new_metas
)
}
open fun transformExplainTargetDomain_statement(node: PartiqlLogical.ExplainTarget.Domain) =
transformStatement(node.statement)
open fun transformExplainTargetDomain_type(node: PartiqlLogical.ExplainTarget.Domain) =
node.type?.let { transformSymbolPrimitive(it) }
open fun transformExplainTargetDomain_format(node: PartiqlLogical.ExplainTarget.Domain) =
node.format?.let { transformSymbolPrimitive(it) }
open fun transformExplainTargetDomain_metas(node: PartiqlLogical.ExplainTarget.Domain) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: PathStep
//////////////////////////////////////
open fun transformPathStep(node: PartiqlLogical.PathStep): PartiqlLogicalResolved.PathStep =
when(node) {
is PartiqlLogical.PathStep.PathExpr -> transformPathStepPathExpr(node)
is PartiqlLogical.PathStep.PathWildcard -> transformPathStepPathWildcard(node)
is PartiqlLogical.PathStep.PathUnpivot -> transformPathStepPathUnpivot(node)
}
// Variant PathStepPathExpr
open fun transformPathStepPathExpr(node: PartiqlLogical.PathStep.PathExpr): PartiqlLogicalResolved.PathStep {
val new_index = transformPathStepPathExpr_index(node)
val new_case = transformPathStepPathExpr_case(node)
val new_metas = transformPathStepPathExpr_metas(node)
return PartiqlLogicalResolved.PathStep.PathExpr(
index = new_index,
case = new_case,
metas = new_metas
)
}
open fun transformPathStepPathExpr_index(node: PartiqlLogical.PathStep.PathExpr) =
transformExpr(node.index)
open fun transformPathStepPathExpr_case(node: PartiqlLogical.PathStep.PathExpr) =
transformCaseSensitivity(node.case)
open fun transformPathStepPathExpr_metas(node: PartiqlLogical.PathStep.PathExpr) =
transformMetas(node.metas)
// Variant PathStepPathWildcard
open fun transformPathStepPathWildcard(node: PartiqlLogical.PathStep.PathWildcard): PartiqlLogicalResolved.PathStep {
val new_metas = transformPathStepPathWildcard_metas(node)
return PartiqlLogicalResolved.PathStep.PathWildcard(
metas = new_metas
)
}
open fun transformPathStepPathWildcard_metas(node: PartiqlLogical.PathStep.PathWildcard) =
transformMetas(node.metas)
// Variant PathStepPathUnpivot
open fun transformPathStepPathUnpivot(node: PartiqlLogical.PathStep.PathUnpivot): PartiqlLogicalResolved.PathStep {
val new_metas = transformPathStepPathUnpivot_metas(node)
return PartiqlLogicalResolved.PathStep.PathUnpivot(
metas = new_metas
)
}
open fun transformPathStepPathUnpivot_metas(node: PartiqlLogical.PathStep.PathUnpivot) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: JoinType
//////////////////////////////////////
open fun transformJoinType(node: PartiqlLogical.JoinType): PartiqlLogicalResolved.JoinType =
when(node) {
is PartiqlLogical.JoinType.Inner -> transformJoinTypeInner(node)
is PartiqlLogical.JoinType.Left -> transformJoinTypeLeft(node)
is PartiqlLogical.JoinType.Right -> transformJoinTypeRight(node)
is PartiqlLogical.JoinType.Full -> transformJoinTypeFull(node)
}
// Variant JoinTypeInner
open fun transformJoinTypeInner(node: PartiqlLogical.JoinType.Inner): PartiqlLogicalResolved.JoinType {
val new_metas = transformJoinTypeInner_metas(node)
return PartiqlLogicalResolved.JoinType.Inner(
metas = new_metas
)
}
open fun transformJoinTypeInner_metas(node: PartiqlLogical.JoinType.Inner) =
transformMetas(node.metas)
// Variant JoinTypeLeft
open fun transformJoinTypeLeft(node: PartiqlLogical.JoinType.Left): PartiqlLogicalResolved.JoinType {
val new_metas = transformJoinTypeLeft_metas(node)
return PartiqlLogicalResolved.JoinType.Left(
metas = new_metas
)
}
open fun transformJoinTypeLeft_metas(node: PartiqlLogical.JoinType.Left) =
transformMetas(node.metas)
// Variant JoinTypeRight
open fun transformJoinTypeRight(node: PartiqlLogical.JoinType.Right): PartiqlLogicalResolved.JoinType {
val new_metas = transformJoinTypeRight_metas(node)
return PartiqlLogicalResolved.JoinType.Right(
metas = new_metas
)
}
open fun transformJoinTypeRight_metas(node: PartiqlLogical.JoinType.Right) =
transformMetas(node.metas)
// Variant JoinTypeFull
open fun transformJoinTypeFull(node: PartiqlLogical.JoinType.Full): PartiqlLogicalResolved.JoinType {
val new_metas = transformJoinTypeFull_metas(node)
return PartiqlLogicalResolved.JoinType.Full(
metas = new_metas
)
}
open fun transformJoinTypeFull_metas(node: PartiqlLogical.JoinType.Full) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: GraphMatchDirection
//////////////////////////////////////
open fun transformGraphMatchDirection(node: PartiqlLogical.GraphMatchDirection): PartiqlLogicalResolved.GraphMatchDirection =
when(node) {
is PartiqlLogical.GraphMatchDirection.EdgeLeft -> transformGraphMatchDirectionEdgeLeft(node)
is PartiqlLogical.GraphMatchDirection.EdgeUndirected -> transformGraphMatchDirectionEdgeUndirected(node)
is PartiqlLogical.GraphMatchDirection.EdgeRight -> transformGraphMatchDirectionEdgeRight(node)
is PartiqlLogical.GraphMatchDirection.EdgeLeftOrUndirected -> transformGraphMatchDirectionEdgeLeftOrUndirected(node)
is PartiqlLogical.GraphMatchDirection.EdgeUndirectedOrRight -> transformGraphMatchDirectionEdgeUndirectedOrRight(node)
is PartiqlLogical.GraphMatchDirection.EdgeLeftOrRight -> transformGraphMatchDirectionEdgeLeftOrRight(node)
is PartiqlLogical.GraphMatchDirection.EdgeLeftOrUndirectedOrRight -> transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight(node)
}
// Variant GraphMatchDirectionEdgeLeft
open fun transformGraphMatchDirectionEdgeLeft(node: PartiqlLogical.GraphMatchDirection.EdgeLeft): PartiqlLogicalResolved.GraphMatchDirection {
val new_metas = transformGraphMatchDirectionEdgeLeft_metas(node)
return PartiqlLogicalResolved.GraphMatchDirection.EdgeLeft(
metas = new_metas
)
}
open fun transformGraphMatchDirectionEdgeLeft_metas(node: PartiqlLogical.GraphMatchDirection.EdgeLeft) =
transformMetas(node.metas)
// Variant GraphMatchDirectionEdgeUndirected
open fun transformGraphMatchDirectionEdgeUndirected(node: PartiqlLogical.GraphMatchDirection.EdgeUndirected): PartiqlLogicalResolved.GraphMatchDirection {
val new_metas = transformGraphMatchDirectionEdgeUndirected_metas(node)
return PartiqlLogicalResolved.GraphMatchDirection.EdgeUndirected(
metas = new_metas
)
}
open fun transformGraphMatchDirectionEdgeUndirected_metas(node: PartiqlLogical.GraphMatchDirection.EdgeUndirected) =
transformMetas(node.metas)
// Variant GraphMatchDirectionEdgeRight
open fun transformGraphMatchDirectionEdgeRight(node: PartiqlLogical.GraphMatchDirection.EdgeRight): PartiqlLogicalResolved.GraphMatchDirection {
val new_metas = transformGraphMatchDirectionEdgeRight_metas(node)
return PartiqlLogicalResolved.GraphMatchDirection.EdgeRight(
metas = new_metas
)
}
open fun transformGraphMatchDirectionEdgeRight_metas(node: PartiqlLogical.GraphMatchDirection.EdgeRight) =
transformMetas(node.metas)
// Variant GraphMatchDirectionEdgeLeftOrUndirected
open fun transformGraphMatchDirectionEdgeLeftOrUndirected(node: PartiqlLogical.GraphMatchDirection.EdgeLeftOrUndirected): PartiqlLogicalResolved.GraphMatchDirection {
val new_metas = transformGraphMatchDirectionEdgeLeftOrUndirected_metas(node)
return PartiqlLogicalResolved.GraphMatchDirection.EdgeLeftOrUndirected(
metas = new_metas
)
}
open fun transformGraphMatchDirectionEdgeLeftOrUndirected_metas(node: PartiqlLogical.GraphMatchDirection.EdgeLeftOrUndirected) =
transformMetas(node.metas)
// Variant GraphMatchDirectionEdgeUndirectedOrRight
open fun transformGraphMatchDirectionEdgeUndirectedOrRight(node: PartiqlLogical.GraphMatchDirection.EdgeUndirectedOrRight): PartiqlLogicalResolved.GraphMatchDirection {
val new_metas = transformGraphMatchDirectionEdgeUndirectedOrRight_metas(node)
return PartiqlLogicalResolved.GraphMatchDirection.EdgeUndirectedOrRight(
metas = new_metas
)
}
open fun transformGraphMatchDirectionEdgeUndirectedOrRight_metas(node: PartiqlLogical.GraphMatchDirection.EdgeUndirectedOrRight) =
transformMetas(node.metas)
// Variant GraphMatchDirectionEdgeLeftOrRight
open fun transformGraphMatchDirectionEdgeLeftOrRight(node: PartiqlLogical.GraphMatchDirection.EdgeLeftOrRight): PartiqlLogicalResolved.GraphMatchDirection {
val new_metas = transformGraphMatchDirectionEdgeLeftOrRight_metas(node)
return PartiqlLogicalResolved.GraphMatchDirection.EdgeLeftOrRight(
metas = new_metas
)
}
open fun transformGraphMatchDirectionEdgeLeftOrRight_metas(node: PartiqlLogical.GraphMatchDirection.EdgeLeftOrRight) =
transformMetas(node.metas)
// Variant GraphMatchDirectionEdgeLeftOrUndirectedOrRight
open fun transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight(node: PartiqlLogical.GraphMatchDirection.EdgeLeftOrUndirectedOrRight): PartiqlLogicalResolved.GraphMatchDirection {
val new_metas = transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight_metas(node)
return PartiqlLogicalResolved.GraphMatchDirection.EdgeLeftOrUndirectedOrRight(
metas = new_metas
)
}
open fun transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight_metas(node: PartiqlLogical.GraphMatchDirection.EdgeLeftOrUndirectedOrRight) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: GraphMatchPatternPart
//////////////////////////////////////
open fun transformGraphMatchPatternPart(node: PartiqlLogical.GraphMatchPatternPart): PartiqlLogicalResolved.GraphMatchPatternPart =
when(node) {
is PartiqlLogical.GraphMatchPatternPart.Node -> transformGraphMatchPatternPartNode(node)
is PartiqlLogical.GraphMatchPatternPart.Edge -> transformGraphMatchPatternPartEdge(node)
is PartiqlLogical.GraphMatchPatternPart.Pattern -> transformGraphMatchPatternPartPattern(node)
}
// Variant GraphMatchPatternPartNode
open fun transformGraphMatchPatternPartNode(node: PartiqlLogical.GraphMatchPatternPart.Node): PartiqlLogicalResolved.GraphMatchPatternPart {
val new_prefilter = transformGraphMatchPatternPartNode_prefilter(node)
val new_variable = transformGraphMatchPatternPartNode_variable(node)
val new_label = transformGraphMatchPatternPartNode_label(node)
val new_metas = transformGraphMatchPatternPartNode_metas(node)
return PartiqlLogicalResolved.GraphMatchPatternPart.Node(
prefilter = new_prefilter,
variable = new_variable,
label = new_label,
metas = new_metas
)
}
open fun transformGraphMatchPatternPartNode_prefilter(node: PartiqlLogical.GraphMatchPatternPart.Node) =
node.prefilter?.let { transformExpr(it) }
open fun transformGraphMatchPatternPartNode_variable(node: PartiqlLogical.GraphMatchPatternPart.Node) =
node.variable?.let { transformSymbolPrimitive(it) }
open fun transformGraphMatchPatternPartNode_label(node: PartiqlLogical.GraphMatchPatternPart.Node) =
node.label.map { transformSymbolPrimitive(it) }
open fun transformGraphMatchPatternPartNode_metas(node: PartiqlLogical.GraphMatchPatternPart.Node) =
transformMetas(node.metas)
// Variant GraphMatchPatternPartEdge
open fun transformGraphMatchPatternPartEdge(node: PartiqlLogical.GraphMatchPatternPart.Edge): PartiqlLogicalResolved.GraphMatchPatternPart {
val new_direction = transformGraphMatchPatternPartEdge_direction(node)
val new_quantifier = transformGraphMatchPatternPartEdge_quantifier(node)
val new_prefilter = transformGraphMatchPatternPartEdge_prefilter(node)
val new_variable = transformGraphMatchPatternPartEdge_variable(node)
val new_label = transformGraphMatchPatternPartEdge_label(node)
val new_metas = transformGraphMatchPatternPartEdge_metas(node)
return PartiqlLogicalResolved.GraphMatchPatternPart.Edge(
direction = new_direction,
quantifier = new_quantifier,
prefilter = new_prefilter,
variable = new_variable,
label = new_label,
metas = new_metas
)
}
open fun transformGraphMatchPatternPartEdge_direction(node: PartiqlLogical.GraphMatchPatternPart.Edge) =
transformGraphMatchDirection(node.direction)
open fun transformGraphMatchPatternPartEdge_quantifier(node: PartiqlLogical.GraphMatchPatternPart.Edge) =
node.quantifier?.let { transformGraphMatchQuantifier(it) }
open fun transformGraphMatchPatternPartEdge_prefilter(node: PartiqlLogical.GraphMatchPatternPart.Edge) =
node.prefilter?.let { transformExpr(it) }
open fun transformGraphMatchPatternPartEdge_variable(node: PartiqlLogical.GraphMatchPatternPart.Edge) =
node.variable?.let { transformSymbolPrimitive(it) }
open fun transformGraphMatchPatternPartEdge_label(node: PartiqlLogical.GraphMatchPatternPart.Edge) =
node.label.map { transformSymbolPrimitive(it) }
open fun transformGraphMatchPatternPartEdge_metas(node: PartiqlLogical.GraphMatchPatternPart.Edge) =
transformMetas(node.metas)
// Variant GraphMatchPatternPartPattern
open fun transformGraphMatchPatternPartPattern(node: PartiqlLogical.GraphMatchPatternPart.Pattern): PartiqlLogicalResolved.GraphMatchPatternPart {
val new_pattern = transformGraphMatchPatternPartPattern_pattern(node)
val new_metas = transformGraphMatchPatternPartPattern_metas(node)
return PartiqlLogicalResolved.GraphMatchPatternPart.Pattern(
pattern = new_pattern,
metas = new_metas
)
}
open fun transformGraphMatchPatternPartPattern_pattern(node: PartiqlLogical.GraphMatchPatternPart.Pattern) =
transformGraphMatchPattern(node.pattern)
open fun transformGraphMatchPatternPartPattern_metas(node: PartiqlLogical.GraphMatchPatternPart.Pattern) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: GraphMatchRestrictor
//////////////////////////////////////
open fun transformGraphMatchRestrictor(node: PartiqlLogical.GraphMatchRestrictor): PartiqlLogicalResolved.GraphMatchRestrictor =
when(node) {
is PartiqlLogical.GraphMatchRestrictor.RestrictorTrail -> transformGraphMatchRestrictorRestrictorTrail(node)
is PartiqlLogical.GraphMatchRestrictor.RestrictorAcyclic -> transformGraphMatchRestrictorRestrictorAcyclic(node)
is PartiqlLogical.GraphMatchRestrictor.RestrictorSimple -> transformGraphMatchRestrictorRestrictorSimple(node)
}
// Variant GraphMatchRestrictorRestrictorTrail
open fun transformGraphMatchRestrictorRestrictorTrail(node: PartiqlLogical.GraphMatchRestrictor.RestrictorTrail): PartiqlLogicalResolved.GraphMatchRestrictor {
val new_metas = transformGraphMatchRestrictorRestrictorTrail_metas(node)
return PartiqlLogicalResolved.GraphMatchRestrictor.RestrictorTrail(
metas = new_metas
)
}
open fun transformGraphMatchRestrictorRestrictorTrail_metas(node: PartiqlLogical.GraphMatchRestrictor.RestrictorTrail) =
transformMetas(node.metas)
// Variant GraphMatchRestrictorRestrictorAcyclic
open fun transformGraphMatchRestrictorRestrictorAcyclic(node: PartiqlLogical.GraphMatchRestrictor.RestrictorAcyclic): PartiqlLogicalResolved.GraphMatchRestrictor {
val new_metas = transformGraphMatchRestrictorRestrictorAcyclic_metas(node)
return PartiqlLogicalResolved.GraphMatchRestrictor.RestrictorAcyclic(
metas = new_metas
)
}
open fun transformGraphMatchRestrictorRestrictorAcyclic_metas(node: PartiqlLogical.GraphMatchRestrictor.RestrictorAcyclic) =
transformMetas(node.metas)
// Variant GraphMatchRestrictorRestrictorSimple
open fun transformGraphMatchRestrictorRestrictorSimple(node: PartiqlLogical.GraphMatchRestrictor.RestrictorSimple): PartiqlLogicalResolved.GraphMatchRestrictor {
val new_metas = transformGraphMatchRestrictorRestrictorSimple_metas(node)
return PartiqlLogicalResolved.GraphMatchRestrictor.RestrictorSimple(
metas = new_metas
)
}
open fun transformGraphMatchRestrictorRestrictorSimple_metas(node: PartiqlLogical.GraphMatchRestrictor.RestrictorSimple) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: GraphMatchSelector
//////////////////////////////////////
open fun transformGraphMatchSelector(node: PartiqlLogical.GraphMatchSelector): PartiqlLogicalResolved.GraphMatchSelector =
when(node) {
is PartiqlLogical.GraphMatchSelector.SelectorAnyShortest -> transformGraphMatchSelectorSelectorAnyShortest(node)
is PartiqlLogical.GraphMatchSelector.SelectorAllShortest -> transformGraphMatchSelectorSelectorAllShortest(node)
is PartiqlLogical.GraphMatchSelector.SelectorAny -> transformGraphMatchSelectorSelectorAny(node)
is PartiqlLogical.GraphMatchSelector.SelectorAnyK -> transformGraphMatchSelectorSelectorAnyK(node)
is PartiqlLogical.GraphMatchSelector.SelectorShortestK -> transformGraphMatchSelectorSelectorShortestK(node)
is PartiqlLogical.GraphMatchSelector.SelectorShortestKGroup -> transformGraphMatchSelectorSelectorShortestKGroup(node)
}
// Variant GraphMatchSelectorSelectorAnyShortest
open fun transformGraphMatchSelectorSelectorAnyShortest(node: PartiqlLogical.GraphMatchSelector.SelectorAnyShortest): PartiqlLogicalResolved.GraphMatchSelector {
val new_metas = transformGraphMatchSelectorSelectorAnyShortest_metas(node)
return PartiqlLogicalResolved.GraphMatchSelector.SelectorAnyShortest(
metas = new_metas
)
}
open fun transformGraphMatchSelectorSelectorAnyShortest_metas(node: PartiqlLogical.GraphMatchSelector.SelectorAnyShortest) =
transformMetas(node.metas)
// Variant GraphMatchSelectorSelectorAllShortest
open fun transformGraphMatchSelectorSelectorAllShortest(node: PartiqlLogical.GraphMatchSelector.SelectorAllShortest): PartiqlLogicalResolved.GraphMatchSelector {
val new_metas = transformGraphMatchSelectorSelectorAllShortest_metas(node)
return PartiqlLogicalResolved.GraphMatchSelector.SelectorAllShortest(
metas = new_metas
)
}
open fun transformGraphMatchSelectorSelectorAllShortest_metas(node: PartiqlLogical.GraphMatchSelector.SelectorAllShortest) =
transformMetas(node.metas)
// Variant GraphMatchSelectorSelectorAny
open fun transformGraphMatchSelectorSelectorAny(node: PartiqlLogical.GraphMatchSelector.SelectorAny): PartiqlLogicalResolved.GraphMatchSelector {
val new_metas = transformGraphMatchSelectorSelectorAny_metas(node)
return PartiqlLogicalResolved.GraphMatchSelector.SelectorAny(
metas = new_metas
)
}
open fun transformGraphMatchSelectorSelectorAny_metas(node: PartiqlLogical.GraphMatchSelector.SelectorAny) =
transformMetas(node.metas)
// Variant GraphMatchSelectorSelectorAnyK
open fun transformGraphMatchSelectorSelectorAnyK(node: PartiqlLogical.GraphMatchSelector.SelectorAnyK): PartiqlLogicalResolved.GraphMatchSelector {
val new_k = transformGraphMatchSelectorSelectorAnyK_k(node)
val new_metas = transformGraphMatchSelectorSelectorAnyK_metas(node)
return PartiqlLogicalResolved.GraphMatchSelector.SelectorAnyK(
k = new_k,
metas = new_metas
)
}
open fun transformGraphMatchSelectorSelectorAnyK_k(node: PartiqlLogical.GraphMatchSelector.SelectorAnyK) =
transformLongPrimitive(node.k)
open fun transformGraphMatchSelectorSelectorAnyK_metas(node: PartiqlLogical.GraphMatchSelector.SelectorAnyK) =
transformMetas(node.metas)
// Variant GraphMatchSelectorSelectorShortestK
open fun transformGraphMatchSelectorSelectorShortestK(node: PartiqlLogical.GraphMatchSelector.SelectorShortestK): PartiqlLogicalResolved.GraphMatchSelector {
val new_k = transformGraphMatchSelectorSelectorShortestK_k(node)
val new_metas = transformGraphMatchSelectorSelectorShortestK_metas(node)
return PartiqlLogicalResolved.GraphMatchSelector.SelectorShortestK(
k = new_k,
metas = new_metas
)
}
open fun transformGraphMatchSelectorSelectorShortestK_k(node: PartiqlLogical.GraphMatchSelector.SelectorShortestK) =
transformLongPrimitive(node.k)
open fun transformGraphMatchSelectorSelectorShortestK_metas(node: PartiqlLogical.GraphMatchSelector.SelectorShortestK) =
transformMetas(node.metas)
// Variant GraphMatchSelectorSelectorShortestKGroup
open fun transformGraphMatchSelectorSelectorShortestKGroup(node: PartiqlLogical.GraphMatchSelector.SelectorShortestKGroup): PartiqlLogicalResolved.GraphMatchSelector {
val new_k = transformGraphMatchSelectorSelectorShortestKGroup_k(node)
val new_metas = transformGraphMatchSelectorSelectorShortestKGroup_metas(node)
return PartiqlLogicalResolved.GraphMatchSelector.SelectorShortestKGroup(
k = new_k,
metas = new_metas
)
}
open fun transformGraphMatchSelectorSelectorShortestKGroup_k(node: PartiqlLogical.GraphMatchSelector.SelectorShortestKGroup) =
transformLongPrimitive(node.k)
open fun transformGraphMatchSelectorSelectorShortestKGroup_metas(node: PartiqlLogical.GraphMatchSelector.SelectorShortestKGroup) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: GroupingStrategy
//////////////////////////////////////
open fun transformGroupingStrategy(node: PartiqlLogical.GroupingStrategy): PartiqlLogicalResolved.GroupingStrategy =
when(node) {
is PartiqlLogical.GroupingStrategy.GroupFull -> transformGroupingStrategyGroupFull(node)
is PartiqlLogical.GroupingStrategy.GroupPartial -> transformGroupingStrategyGroupPartial(node)
}
// Variant GroupingStrategyGroupFull
open fun transformGroupingStrategyGroupFull(node: PartiqlLogical.GroupingStrategy.GroupFull): PartiqlLogicalResolved.GroupingStrategy {
val new_metas = transformGroupingStrategyGroupFull_metas(node)
return PartiqlLogicalResolved.GroupingStrategy.GroupFull(
metas = new_metas
)
}
open fun transformGroupingStrategyGroupFull_metas(node: PartiqlLogical.GroupingStrategy.GroupFull) =
transformMetas(node.metas)
// Variant GroupingStrategyGroupPartial
open fun transformGroupingStrategyGroupPartial(node: PartiqlLogical.GroupingStrategy.GroupPartial): PartiqlLogicalResolved.GroupingStrategy {
val new_metas = transformGroupingStrategyGroupPartial_metas(node)
return PartiqlLogicalResolved.GroupingStrategy.GroupPartial(
metas = new_metas
)
}
open fun transformGroupingStrategyGroupPartial_metas(node: PartiqlLogical.GroupingStrategy.GroupPartial) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: OrderingSpec
//////////////////////////////////////
open fun transformOrderingSpec(node: PartiqlLogical.OrderingSpec): PartiqlLogicalResolved.OrderingSpec =
when(node) {
is PartiqlLogical.OrderingSpec.Asc -> transformOrderingSpecAsc(node)
is PartiqlLogical.OrderingSpec.Desc -> transformOrderingSpecDesc(node)
}
// Variant OrderingSpecAsc
open fun transformOrderingSpecAsc(node: PartiqlLogical.OrderingSpec.Asc): PartiqlLogicalResolved.OrderingSpec {
val new_metas = transformOrderingSpecAsc_metas(node)
return PartiqlLogicalResolved.OrderingSpec.Asc(
metas = new_metas
)
}
open fun transformOrderingSpecAsc_metas(node: PartiqlLogical.OrderingSpec.Asc) =
transformMetas(node.metas)
// Variant OrderingSpecDesc
open fun transformOrderingSpecDesc(node: PartiqlLogical.OrderingSpec.Desc): PartiqlLogicalResolved.OrderingSpec {
val new_metas = transformOrderingSpecDesc_metas(node)
return PartiqlLogicalResolved.OrderingSpec.Desc(
metas = new_metas
)
}
open fun transformOrderingSpecDesc_metas(node: PartiqlLogical.OrderingSpec.Desc) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: NullsSpec
//////////////////////////////////////
open fun transformNullsSpec(node: PartiqlLogical.NullsSpec): PartiqlLogicalResolved.NullsSpec =
when(node) {
is PartiqlLogical.NullsSpec.NullsFirst -> transformNullsSpecNullsFirst(node)
is PartiqlLogical.NullsSpec.NullsLast -> transformNullsSpecNullsLast(node)
}
// Variant NullsSpecNullsFirst
open fun transformNullsSpecNullsFirst(node: PartiqlLogical.NullsSpec.NullsFirst): PartiqlLogicalResolved.NullsSpec {
val new_metas = transformNullsSpecNullsFirst_metas(node)
return PartiqlLogicalResolved.NullsSpec.NullsFirst(
metas = new_metas
)
}
open fun transformNullsSpecNullsFirst_metas(node: PartiqlLogical.NullsSpec.NullsFirst) =
transformMetas(node.metas)
// Variant NullsSpecNullsLast
open fun transformNullsSpecNullsLast(node: PartiqlLogical.NullsSpec.NullsLast): PartiqlLogicalResolved.NullsSpec {
val new_metas = transformNullsSpecNullsLast_metas(node)
return PartiqlLogicalResolved.NullsSpec.NullsLast(
metas = new_metas
)
}
open fun transformNullsSpecNullsLast_metas(node: PartiqlLogical.NullsSpec.NullsLast) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: CaseSensitivity
//////////////////////////////////////
open fun transformCaseSensitivity(node: PartiqlLogical.CaseSensitivity): PartiqlLogicalResolved.CaseSensitivity =
when(node) {
is PartiqlLogical.CaseSensitivity.CaseSensitive -> transformCaseSensitivityCaseSensitive(node)
is PartiqlLogical.CaseSensitivity.CaseInsensitive -> transformCaseSensitivityCaseInsensitive(node)
}
// Variant CaseSensitivityCaseSensitive
open fun transformCaseSensitivityCaseSensitive(node: PartiqlLogical.CaseSensitivity.CaseSensitive): PartiqlLogicalResolved.CaseSensitivity {
val new_metas = transformCaseSensitivityCaseSensitive_metas(node)
return PartiqlLogicalResolved.CaseSensitivity.CaseSensitive(
metas = new_metas
)
}
open fun transformCaseSensitivityCaseSensitive_metas(node: PartiqlLogical.CaseSensitivity.CaseSensitive) =
transformMetas(node.metas)
// Variant CaseSensitivityCaseInsensitive
open fun transformCaseSensitivityCaseInsensitive(node: PartiqlLogical.CaseSensitivity.CaseInsensitive): PartiqlLogicalResolved.CaseSensitivity {
val new_metas = transformCaseSensitivityCaseInsensitive_metas(node)
return PartiqlLogicalResolved.CaseSensitivity.CaseInsensitive(
metas = new_metas
)
}
open fun transformCaseSensitivityCaseInsensitive_metas(node: PartiqlLogical.CaseSensitivity.CaseInsensitive) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: SetQuantifier
//////////////////////////////////////
open fun transformSetQuantifier(node: PartiqlLogical.SetQuantifier): PartiqlLogicalResolved.SetQuantifier =
when(node) {
is PartiqlLogical.SetQuantifier.All -> transformSetQuantifierAll(node)
is PartiqlLogical.SetQuantifier.Distinct -> transformSetQuantifierDistinct(node)
}
// Variant SetQuantifierAll
open fun transformSetQuantifierAll(node: PartiqlLogical.SetQuantifier.All): PartiqlLogicalResolved.SetQuantifier {
val new_metas = transformSetQuantifierAll_metas(node)
return PartiqlLogicalResolved.SetQuantifier.All(
metas = new_metas
)
}
open fun transformSetQuantifierAll_metas(node: PartiqlLogical.SetQuantifier.All) =
transformMetas(node.metas)
// Variant SetQuantifierDistinct
open fun transformSetQuantifierDistinct(node: PartiqlLogical.SetQuantifier.Distinct): PartiqlLogicalResolved.SetQuantifier {
val new_metas = transformSetQuantifierDistinct_metas(node)
return PartiqlLogicalResolved.SetQuantifier.Distinct(
metas = new_metas
)
}
open fun transformSetQuantifierDistinct_metas(node: PartiqlLogical.SetQuantifier.Distinct) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: BagOpType
//////////////////////////////////////
open fun transformBagOpType(node: PartiqlLogical.BagOpType): PartiqlLogicalResolved.BagOpType =
when(node) {
is PartiqlLogical.BagOpType.Union -> transformBagOpTypeUnion(node)
is PartiqlLogical.BagOpType.Intersect -> transformBagOpTypeIntersect(node)
is PartiqlLogical.BagOpType.Except -> transformBagOpTypeExcept(node)
is PartiqlLogical.BagOpType.OuterUnion -> transformBagOpTypeOuterUnion(node)
is PartiqlLogical.BagOpType.OuterIntersect -> transformBagOpTypeOuterIntersect(node)
is PartiqlLogical.BagOpType.OuterExcept -> transformBagOpTypeOuterExcept(node)
}
// Variant BagOpTypeUnion
open fun transformBagOpTypeUnion(node: PartiqlLogical.BagOpType.Union): PartiqlLogicalResolved.BagOpType {
val new_metas = transformBagOpTypeUnion_metas(node)
return PartiqlLogicalResolved.BagOpType.Union(
metas = new_metas
)
}
open fun transformBagOpTypeUnion_metas(node: PartiqlLogical.BagOpType.Union) =
transformMetas(node.metas)
// Variant BagOpTypeIntersect
open fun transformBagOpTypeIntersect(node: PartiqlLogical.BagOpType.Intersect): PartiqlLogicalResolved.BagOpType {
val new_metas = transformBagOpTypeIntersect_metas(node)
return PartiqlLogicalResolved.BagOpType.Intersect(
metas = new_metas
)
}
open fun transformBagOpTypeIntersect_metas(node: PartiqlLogical.BagOpType.Intersect) =
transformMetas(node.metas)
// Variant BagOpTypeExcept
open fun transformBagOpTypeExcept(node: PartiqlLogical.BagOpType.Except): PartiqlLogicalResolved.BagOpType {
val new_metas = transformBagOpTypeExcept_metas(node)
return PartiqlLogicalResolved.BagOpType.Except(
metas = new_metas
)
}
open fun transformBagOpTypeExcept_metas(node: PartiqlLogical.BagOpType.Except) =
transformMetas(node.metas)
// Variant BagOpTypeOuterUnion
open fun transformBagOpTypeOuterUnion(node: PartiqlLogical.BagOpType.OuterUnion): PartiqlLogicalResolved.BagOpType {
val new_metas = transformBagOpTypeOuterUnion_metas(node)
return PartiqlLogicalResolved.BagOpType.OuterUnion(
metas = new_metas
)
}
open fun transformBagOpTypeOuterUnion_metas(node: PartiqlLogical.BagOpType.OuterUnion) =
transformMetas(node.metas)
// Variant BagOpTypeOuterIntersect
open fun transformBagOpTypeOuterIntersect(node: PartiqlLogical.BagOpType.OuterIntersect): PartiqlLogicalResolved.BagOpType {
val new_metas = transformBagOpTypeOuterIntersect_metas(node)
return PartiqlLogicalResolved.BagOpType.OuterIntersect(
metas = new_metas
)
}
open fun transformBagOpTypeOuterIntersect_metas(node: PartiqlLogical.BagOpType.OuterIntersect) =
transformMetas(node.metas)
// Variant BagOpTypeOuterExcept
open fun transformBagOpTypeOuterExcept(node: PartiqlLogical.BagOpType.OuterExcept): PartiqlLogicalResolved.BagOpType {
val new_metas = transformBagOpTypeOuterExcept_metas(node)
return PartiqlLogicalResolved.BagOpType.OuterExcept(
metas = new_metas
)
}
open fun transformBagOpTypeOuterExcept_metas(node: PartiqlLogical.BagOpType.OuterExcept) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: OnConflictValue
//////////////////////////////////////
open fun transformOnConflictValue(node: PartiqlLogical.OnConflictValue): PartiqlLogicalResolved.OnConflictValue =
when(node) {
is PartiqlLogical.OnConflictValue.Excluded -> transformOnConflictValueExcluded(node)
}
// Variant OnConflictValueExcluded
open fun transformOnConflictValueExcluded(node: PartiqlLogical.OnConflictValue.Excluded): PartiqlLogicalResolved.OnConflictValue {
val new_metas = transformOnConflictValueExcluded_metas(node)
return PartiqlLogicalResolved.OnConflictValue.Excluded(
metas = new_metas
)
}
open fun transformOnConflictValueExcluded_metas(node: PartiqlLogical.OnConflictValue.Excluded) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: Type
//////////////////////////////////////
open fun transformType(node: PartiqlLogical.Type): PartiqlLogicalResolved.Type =
when(node) {
is PartiqlLogical.Type.NullType -> transformTypeNullType(node)
is PartiqlLogical.Type.BooleanType -> transformTypeBooleanType(node)
is PartiqlLogical.Type.SmallintType -> transformTypeSmallintType(node)
is PartiqlLogical.Type.Integer4Type -> transformTypeInteger4Type(node)
is PartiqlLogical.Type.Integer8Type -> transformTypeInteger8Type(node)
is PartiqlLogical.Type.IntegerType -> transformTypeIntegerType(node)
is PartiqlLogical.Type.FloatType -> transformTypeFloatType(node)
is PartiqlLogical.Type.RealType -> transformTypeRealType(node)
is PartiqlLogical.Type.DoublePrecisionType -> transformTypeDoublePrecisionType(node)
is PartiqlLogical.Type.DecimalType -> transformTypeDecimalType(node)
is PartiqlLogical.Type.NumericType -> transformTypeNumericType(node)
is PartiqlLogical.Type.TimestampType -> transformTypeTimestampType(node)
is PartiqlLogical.Type.CharacterType -> transformTypeCharacterType(node)
is PartiqlLogical.Type.CharacterVaryingType -> transformTypeCharacterVaryingType(node)
is PartiqlLogical.Type.MissingType -> transformTypeMissingType(node)
is PartiqlLogical.Type.StringType -> transformTypeStringType(node)
is PartiqlLogical.Type.SymbolType -> transformTypeSymbolType(node)
is PartiqlLogical.Type.BlobType -> transformTypeBlobType(node)
is PartiqlLogical.Type.ClobType -> transformTypeClobType(node)
is PartiqlLogical.Type.DateType -> transformTypeDateType(node)
is PartiqlLogical.Type.TimeType -> transformTypeTimeType(node)
is PartiqlLogical.Type.TimeWithTimeZoneType -> transformTypeTimeWithTimeZoneType(node)
is PartiqlLogical.Type.StructType -> transformTypeStructType(node)
is PartiqlLogical.Type.TupleType -> transformTypeTupleType(node)
is PartiqlLogical.Type.ListType -> transformTypeListType(node)
is PartiqlLogical.Type.SexpType -> transformTypeSexpType(node)
is PartiqlLogical.Type.BagType -> transformTypeBagType(node)
is PartiqlLogical.Type.AnyType -> transformTypeAnyType(node)
is PartiqlLogical.Type.CustomType -> transformTypeCustomType(node)
}
// Variant TypeNullType
open fun transformTypeNullType(node: PartiqlLogical.Type.NullType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeNullType_metas(node)
return PartiqlLogicalResolved.Type.NullType(
metas = new_metas
)
}
open fun transformTypeNullType_metas(node: PartiqlLogical.Type.NullType) =
transformMetas(node.metas)
// Variant TypeBooleanType
open fun transformTypeBooleanType(node: PartiqlLogical.Type.BooleanType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeBooleanType_metas(node)
return PartiqlLogicalResolved.Type.BooleanType(
metas = new_metas
)
}
open fun transformTypeBooleanType_metas(node: PartiqlLogical.Type.BooleanType) =
transformMetas(node.metas)
// Variant TypeSmallintType
open fun transformTypeSmallintType(node: PartiqlLogical.Type.SmallintType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeSmallintType_metas(node)
return PartiqlLogicalResolved.Type.SmallintType(
metas = new_metas
)
}
open fun transformTypeSmallintType_metas(node: PartiqlLogical.Type.SmallintType) =
transformMetas(node.metas)
// Variant TypeInteger4Type
open fun transformTypeInteger4Type(node: PartiqlLogical.Type.Integer4Type): PartiqlLogicalResolved.Type {
val new_metas = transformTypeInteger4Type_metas(node)
return PartiqlLogicalResolved.Type.Integer4Type(
metas = new_metas
)
}
open fun transformTypeInteger4Type_metas(node: PartiqlLogical.Type.Integer4Type) =
transformMetas(node.metas)
// Variant TypeInteger8Type
open fun transformTypeInteger8Type(node: PartiqlLogical.Type.Integer8Type): PartiqlLogicalResolved.Type {
val new_metas = transformTypeInteger8Type_metas(node)
return PartiqlLogicalResolved.Type.Integer8Type(
metas = new_metas
)
}
open fun transformTypeInteger8Type_metas(node: PartiqlLogical.Type.Integer8Type) =
transformMetas(node.metas)
// Variant TypeIntegerType
open fun transformTypeIntegerType(node: PartiqlLogical.Type.IntegerType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeIntegerType_metas(node)
return PartiqlLogicalResolved.Type.IntegerType(
metas = new_metas
)
}
open fun transformTypeIntegerType_metas(node: PartiqlLogical.Type.IntegerType) =
transformMetas(node.metas)
// Variant TypeFloatType
open fun transformTypeFloatType(node: PartiqlLogical.Type.FloatType): PartiqlLogicalResolved.Type {
val new_precision = transformTypeFloatType_precision(node)
val new_metas = transformTypeFloatType_metas(node)
return PartiqlLogicalResolved.Type.FloatType(
precision = new_precision,
metas = new_metas
)
}
open fun transformTypeFloatType_precision(node: PartiqlLogical.Type.FloatType) =
node.precision?.let { transformLongPrimitive(it) }
open fun transformTypeFloatType_metas(node: PartiqlLogical.Type.FloatType) =
transformMetas(node.metas)
// Variant TypeRealType
open fun transformTypeRealType(node: PartiqlLogical.Type.RealType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeRealType_metas(node)
return PartiqlLogicalResolved.Type.RealType(
metas = new_metas
)
}
open fun transformTypeRealType_metas(node: PartiqlLogical.Type.RealType) =
transformMetas(node.metas)
// Variant TypeDoublePrecisionType
open fun transformTypeDoublePrecisionType(node: PartiqlLogical.Type.DoublePrecisionType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeDoublePrecisionType_metas(node)
return PartiqlLogicalResolved.Type.DoublePrecisionType(
metas = new_metas
)
}
open fun transformTypeDoublePrecisionType_metas(node: PartiqlLogical.Type.DoublePrecisionType) =
transformMetas(node.metas)
// Variant TypeDecimalType
open fun transformTypeDecimalType(node: PartiqlLogical.Type.DecimalType): PartiqlLogicalResolved.Type {
val new_precision = transformTypeDecimalType_precision(node)
val new_scale = transformTypeDecimalType_scale(node)
val new_metas = transformTypeDecimalType_metas(node)
return PartiqlLogicalResolved.Type.DecimalType(
precision = new_precision,
scale = new_scale,
metas = new_metas
)
}
open fun transformTypeDecimalType_precision(node: PartiqlLogical.Type.DecimalType) =
node.precision?.let { transformLongPrimitive(it) }
open fun transformTypeDecimalType_scale(node: PartiqlLogical.Type.DecimalType) =
node.scale?.let { transformLongPrimitive(it) }
open fun transformTypeDecimalType_metas(node: PartiqlLogical.Type.DecimalType) =
transformMetas(node.metas)
// Variant TypeNumericType
open fun transformTypeNumericType(node: PartiqlLogical.Type.NumericType): PartiqlLogicalResolved.Type {
val new_precision = transformTypeNumericType_precision(node)
val new_scale = transformTypeNumericType_scale(node)
val new_metas = transformTypeNumericType_metas(node)
return PartiqlLogicalResolved.Type.NumericType(
precision = new_precision,
scale = new_scale,
metas = new_metas
)
}
open fun transformTypeNumericType_precision(node: PartiqlLogical.Type.NumericType) =
node.precision?.let { transformLongPrimitive(it) }
open fun transformTypeNumericType_scale(node: PartiqlLogical.Type.NumericType) =
node.scale?.let { transformLongPrimitive(it) }
open fun transformTypeNumericType_metas(node: PartiqlLogical.Type.NumericType) =
transformMetas(node.metas)
// Variant TypeTimestampType
open fun transformTypeTimestampType(node: PartiqlLogical.Type.TimestampType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeTimestampType_metas(node)
return PartiqlLogicalResolved.Type.TimestampType(
metas = new_metas
)
}
open fun transformTypeTimestampType_metas(node: PartiqlLogical.Type.TimestampType) =
transformMetas(node.metas)
// Variant TypeCharacterType
open fun transformTypeCharacterType(node: PartiqlLogical.Type.CharacterType): PartiqlLogicalResolved.Type {
val new_length = transformTypeCharacterType_length(node)
val new_metas = transformTypeCharacterType_metas(node)
return PartiqlLogicalResolved.Type.CharacterType(
length = new_length,
metas = new_metas
)
}
open fun transformTypeCharacterType_length(node: PartiqlLogical.Type.CharacterType) =
node.length?.let { transformLongPrimitive(it) }
open fun transformTypeCharacterType_metas(node: PartiqlLogical.Type.CharacterType) =
transformMetas(node.metas)
// Variant TypeCharacterVaryingType
open fun transformTypeCharacterVaryingType(node: PartiqlLogical.Type.CharacterVaryingType): PartiqlLogicalResolved.Type {
val new_length = transformTypeCharacterVaryingType_length(node)
val new_metas = transformTypeCharacterVaryingType_metas(node)
return PartiqlLogicalResolved.Type.CharacterVaryingType(
length = new_length,
metas = new_metas
)
}
open fun transformTypeCharacterVaryingType_length(node: PartiqlLogical.Type.CharacterVaryingType) =
node.length?.let { transformLongPrimitive(it) }
open fun transformTypeCharacterVaryingType_metas(node: PartiqlLogical.Type.CharacterVaryingType) =
transformMetas(node.metas)
// Variant TypeMissingType
open fun transformTypeMissingType(node: PartiqlLogical.Type.MissingType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeMissingType_metas(node)
return PartiqlLogicalResolved.Type.MissingType(
metas = new_metas
)
}
open fun transformTypeMissingType_metas(node: PartiqlLogical.Type.MissingType) =
transformMetas(node.metas)
// Variant TypeStringType
open fun transformTypeStringType(node: PartiqlLogical.Type.StringType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeStringType_metas(node)
return PartiqlLogicalResolved.Type.StringType(
metas = new_metas
)
}
open fun transformTypeStringType_metas(node: PartiqlLogical.Type.StringType) =
transformMetas(node.metas)
// Variant TypeSymbolType
open fun transformTypeSymbolType(node: PartiqlLogical.Type.SymbolType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeSymbolType_metas(node)
return PartiqlLogicalResolved.Type.SymbolType(
metas = new_metas
)
}
open fun transformTypeSymbolType_metas(node: PartiqlLogical.Type.SymbolType) =
transformMetas(node.metas)
// Variant TypeBlobType
open fun transformTypeBlobType(node: PartiqlLogical.Type.BlobType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeBlobType_metas(node)
return PartiqlLogicalResolved.Type.BlobType(
metas = new_metas
)
}
open fun transformTypeBlobType_metas(node: PartiqlLogical.Type.BlobType) =
transformMetas(node.metas)
// Variant TypeClobType
open fun transformTypeClobType(node: PartiqlLogical.Type.ClobType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeClobType_metas(node)
return PartiqlLogicalResolved.Type.ClobType(
metas = new_metas
)
}
open fun transformTypeClobType_metas(node: PartiqlLogical.Type.ClobType) =
transformMetas(node.metas)
// Variant TypeDateType
open fun transformTypeDateType(node: PartiqlLogical.Type.DateType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeDateType_metas(node)
return PartiqlLogicalResolved.Type.DateType(
metas = new_metas
)
}
open fun transformTypeDateType_metas(node: PartiqlLogical.Type.DateType) =
transformMetas(node.metas)
// Variant TypeTimeType
open fun transformTypeTimeType(node: PartiqlLogical.Type.TimeType): PartiqlLogicalResolved.Type {
val new_precision = transformTypeTimeType_precision(node)
val new_metas = transformTypeTimeType_metas(node)
return PartiqlLogicalResolved.Type.TimeType(
precision = new_precision,
metas = new_metas
)
}
open fun transformTypeTimeType_precision(node: PartiqlLogical.Type.TimeType) =
node.precision?.let { transformLongPrimitive(it) }
open fun transformTypeTimeType_metas(node: PartiqlLogical.Type.TimeType) =
transformMetas(node.metas)
// Variant TypeTimeWithTimeZoneType
open fun transformTypeTimeWithTimeZoneType(node: PartiqlLogical.Type.TimeWithTimeZoneType): PartiqlLogicalResolved.Type {
val new_precision = transformTypeTimeWithTimeZoneType_precision(node)
val new_metas = transformTypeTimeWithTimeZoneType_metas(node)
return PartiqlLogicalResolved.Type.TimeWithTimeZoneType(
precision = new_precision,
metas = new_metas
)
}
open fun transformTypeTimeWithTimeZoneType_precision(node: PartiqlLogical.Type.TimeWithTimeZoneType) =
node.precision?.let { transformLongPrimitive(it) }
open fun transformTypeTimeWithTimeZoneType_metas(node: PartiqlLogical.Type.TimeWithTimeZoneType) =
transformMetas(node.metas)
// Variant TypeStructType
open fun transformTypeStructType(node: PartiqlLogical.Type.StructType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeStructType_metas(node)
return PartiqlLogicalResolved.Type.StructType(
metas = new_metas
)
}
open fun transformTypeStructType_metas(node: PartiqlLogical.Type.StructType) =
transformMetas(node.metas)
// Variant TypeTupleType
open fun transformTypeTupleType(node: PartiqlLogical.Type.TupleType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeTupleType_metas(node)
return PartiqlLogicalResolved.Type.TupleType(
metas = new_metas
)
}
open fun transformTypeTupleType_metas(node: PartiqlLogical.Type.TupleType) =
transformMetas(node.metas)
// Variant TypeListType
open fun transformTypeListType(node: PartiqlLogical.Type.ListType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeListType_metas(node)
return PartiqlLogicalResolved.Type.ListType(
metas = new_metas
)
}
open fun transformTypeListType_metas(node: PartiqlLogical.Type.ListType) =
transformMetas(node.metas)
// Variant TypeSexpType
open fun transformTypeSexpType(node: PartiqlLogical.Type.SexpType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeSexpType_metas(node)
return PartiqlLogicalResolved.Type.SexpType(
metas = new_metas
)
}
open fun transformTypeSexpType_metas(node: PartiqlLogical.Type.SexpType) =
transformMetas(node.metas)
// Variant TypeBagType
open fun transformTypeBagType(node: PartiqlLogical.Type.BagType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeBagType_metas(node)
return PartiqlLogicalResolved.Type.BagType(
metas = new_metas
)
}
open fun transformTypeBagType_metas(node: PartiqlLogical.Type.BagType) =
transformMetas(node.metas)
// Variant TypeAnyType
open fun transformTypeAnyType(node: PartiqlLogical.Type.AnyType): PartiqlLogicalResolved.Type {
val new_metas = transformTypeAnyType_metas(node)
return PartiqlLogicalResolved.Type.AnyType(
metas = new_metas
)
}
open fun transformTypeAnyType_metas(node: PartiqlLogical.Type.AnyType) =
transformMetas(node.metas)
// Variant TypeCustomType
open fun transformTypeCustomType(node: PartiqlLogical.Type.CustomType): PartiqlLogicalResolved.Type {
val new_name = transformTypeCustomType_name(node)
val new_metas = transformTypeCustomType_metas(node)
return PartiqlLogicalResolved.Type.CustomType(
name = new_name,
metas = new_metas
)
}
open fun transformTypeCustomType_name(node: PartiqlLogical.Type.CustomType) =
transformSymbolPrimitive(node.name)
open fun transformTypeCustomType_metas(node: PartiqlLogical.Type.CustomType) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: Expr
//////////////////////////////////////
open fun transformExpr(node: PartiqlLogical.Expr): PartiqlLogicalResolved.Expr =
when(node) {
is PartiqlLogical.Expr.Missing -> transformExprMissing(node)
is PartiqlLogical.Expr.Lit -> transformExprLit(node)
is PartiqlLogical.Expr.Id -> transformExprId(node)
is PartiqlLogical.Expr.Parameter -> transformExprParameter(node)
is PartiqlLogical.Expr.Not -> transformExprNot(node)
is PartiqlLogical.Expr.Pos -> transformExprPos(node)
is PartiqlLogical.Expr.Neg -> transformExprNeg(node)
is PartiqlLogical.Expr.Plus -> transformExprPlus(node)
is PartiqlLogical.Expr.Minus -> transformExprMinus(node)
is PartiqlLogical.Expr.Times -> transformExprTimes(node)
is PartiqlLogical.Expr.Divide -> transformExprDivide(node)
is PartiqlLogical.Expr.Modulo -> transformExprModulo(node)
is PartiqlLogical.Expr.Concat -> transformExprConcat(node)
is PartiqlLogical.Expr.And -> transformExprAnd(node)
is PartiqlLogical.Expr.Or -> transformExprOr(node)
is PartiqlLogical.Expr.Eq -> transformExprEq(node)
is PartiqlLogical.Expr.Ne -> transformExprNe(node)
is PartiqlLogical.Expr.Gt -> transformExprGt(node)
is PartiqlLogical.Expr.Gte -> transformExprGte(node)
is PartiqlLogical.Expr.Lt -> transformExprLt(node)
is PartiqlLogical.Expr.Lte -> transformExprLte(node)
is PartiqlLogical.Expr.Like -> transformExprLike(node)
is PartiqlLogical.Expr.Between -> transformExprBetween(node)
is PartiqlLogical.Expr.InCollection -> transformExprInCollection(node)
is PartiqlLogical.Expr.IsType -> transformExprIsType(node)
is PartiqlLogical.Expr.SimpleCase -> transformExprSimpleCase(node)
is PartiqlLogical.Expr.SearchedCase -> transformExprSearchedCase(node)
is PartiqlLogical.Expr.Bag -> transformExprBag(node)
is PartiqlLogical.Expr.List -> transformExprList(node)
is PartiqlLogical.Expr.Sexp -> transformExprSexp(node)
is PartiqlLogical.Expr.Date -> transformExprDate(node)
is PartiqlLogical.Expr.LitTime -> transformExprLitTime(node)
is PartiqlLogical.Expr.BagOp -> transformExprBagOp(node)
is PartiqlLogical.Expr.GraphMatch -> transformExprGraphMatch(node)
is PartiqlLogical.Expr.Path -> transformExprPath(node)
is PartiqlLogical.Expr.Call -> transformExprCall(node)
is PartiqlLogical.Expr.Cast -> transformExprCast(node)
is PartiqlLogical.Expr.CanCast -> transformExprCanCast(node)
is PartiqlLogical.Expr.CanLosslessCast -> transformExprCanLosslessCast(node)
is PartiqlLogical.Expr.NullIf -> transformExprNullIf(node)
is PartiqlLogical.Expr.Coalesce -> transformExprCoalesce(node)
is PartiqlLogical.Expr.BindingsToValues -> transformExprBindingsToValues(node)
is PartiqlLogical.Expr.Struct -> transformExprStruct(node)
is PartiqlLogical.Expr.Pivot -> transformExprPivot(node)
}
// Variant ExprMissing
open fun transformExprMissing(node: PartiqlLogical.Expr.Missing): PartiqlLogicalResolved.Expr {
val new_metas = transformExprMissing_metas(node)
return PartiqlLogicalResolved.Expr.Missing(
metas = new_metas
)
}
open fun transformExprMissing_metas(node: PartiqlLogical.Expr.Missing) =
transformMetas(node.metas)
// Variant ExprLit
open fun transformExprLit(node: PartiqlLogical.Expr.Lit): PartiqlLogicalResolved.Expr {
val new_value = transformExprLit_value(node)
val new_metas = transformExprLit_metas(node)
return PartiqlLogicalResolved.Expr.Lit(
value = new_value,
metas = new_metas
)
}
open fun transformExprLit_value(node: PartiqlLogical.Expr.Lit) =
transformAnyElement(node.value)
open fun transformExprLit_metas(node: PartiqlLogical.Expr.Lit) =
transformMetas(node.metas)
// Variant ExprId
abstract fun transformExprId(node: PartiqlLogical.Expr.Id): PartiqlLogicalResolved.Expr
// Variant ExprParameter
open fun transformExprParameter(node: PartiqlLogical.Expr.Parameter): PartiqlLogicalResolved.Expr {
val new_index = transformExprParameter_index(node)
val new_metas = transformExprParameter_metas(node)
return PartiqlLogicalResolved.Expr.Parameter(
index = new_index,
metas = new_metas
)
}
open fun transformExprParameter_index(node: PartiqlLogical.Expr.Parameter) =
transformLongPrimitive(node.index)
open fun transformExprParameter_metas(node: PartiqlLogical.Expr.Parameter) =
transformMetas(node.metas)
// Variant ExprNot
open fun transformExprNot(node: PartiqlLogical.Expr.Not): PartiqlLogicalResolved.Expr {
val new_expr = transformExprNot_expr(node)
val new_metas = transformExprNot_metas(node)
return PartiqlLogicalResolved.Expr.Not(
expr = new_expr,
metas = new_metas
)
}
open fun transformExprNot_expr(node: PartiqlLogical.Expr.Not) =
transformExpr(node.expr)
open fun transformExprNot_metas(node: PartiqlLogical.Expr.Not) =
transformMetas(node.metas)
// Variant ExprPos
open fun transformExprPos(node: PartiqlLogical.Expr.Pos): PartiqlLogicalResolved.Expr {
val new_expr = transformExprPos_expr(node)
val new_metas = transformExprPos_metas(node)
return PartiqlLogicalResolved.Expr.Pos(
expr = new_expr,
metas = new_metas
)
}
open fun transformExprPos_expr(node: PartiqlLogical.Expr.Pos) =
transformExpr(node.expr)
open fun transformExprPos_metas(node: PartiqlLogical.Expr.Pos) =
transformMetas(node.metas)
// Variant ExprNeg
open fun transformExprNeg(node: PartiqlLogical.Expr.Neg): PartiqlLogicalResolved.Expr {
val new_expr = transformExprNeg_expr(node)
val new_metas = transformExprNeg_metas(node)
return PartiqlLogicalResolved.Expr.Neg(
expr = new_expr,
metas = new_metas
)
}
open fun transformExprNeg_expr(node: PartiqlLogical.Expr.Neg) =
transformExpr(node.expr)
open fun transformExprNeg_metas(node: PartiqlLogical.Expr.Neg) =
transformMetas(node.metas)
// Variant ExprPlus
open fun transformExprPlus(node: PartiqlLogical.Expr.Plus): PartiqlLogicalResolved.Expr {
val new_operands = transformExprPlus_operands(node)
val new_metas = transformExprPlus_metas(node)
return PartiqlLogicalResolved.Expr.Plus(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprPlus_operands(node: PartiqlLogical.Expr.Plus) =
node.operands.map { transformExpr(it) }
open fun transformExprPlus_metas(node: PartiqlLogical.Expr.Plus) =
transformMetas(node.metas)
// Variant ExprMinus
open fun transformExprMinus(node: PartiqlLogical.Expr.Minus): PartiqlLogicalResolved.Expr {
val new_operands = transformExprMinus_operands(node)
val new_metas = transformExprMinus_metas(node)
return PartiqlLogicalResolved.Expr.Minus(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprMinus_operands(node: PartiqlLogical.Expr.Minus) =
node.operands.map { transformExpr(it) }
open fun transformExprMinus_metas(node: PartiqlLogical.Expr.Minus) =
transformMetas(node.metas)
// Variant ExprTimes
open fun transformExprTimes(node: PartiqlLogical.Expr.Times): PartiqlLogicalResolved.Expr {
val new_operands = transformExprTimes_operands(node)
val new_metas = transformExprTimes_metas(node)
return PartiqlLogicalResolved.Expr.Times(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprTimes_operands(node: PartiqlLogical.Expr.Times) =
node.operands.map { transformExpr(it) }
open fun transformExprTimes_metas(node: PartiqlLogical.Expr.Times) =
transformMetas(node.metas)
// Variant ExprDivide
open fun transformExprDivide(node: PartiqlLogical.Expr.Divide): PartiqlLogicalResolved.Expr {
val new_operands = transformExprDivide_operands(node)
val new_metas = transformExprDivide_metas(node)
return PartiqlLogicalResolved.Expr.Divide(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprDivide_operands(node: PartiqlLogical.Expr.Divide) =
node.operands.map { transformExpr(it) }
open fun transformExprDivide_metas(node: PartiqlLogical.Expr.Divide) =
transformMetas(node.metas)
// Variant ExprModulo
open fun transformExprModulo(node: PartiqlLogical.Expr.Modulo): PartiqlLogicalResolved.Expr {
val new_operands = transformExprModulo_operands(node)
val new_metas = transformExprModulo_metas(node)
return PartiqlLogicalResolved.Expr.Modulo(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprModulo_operands(node: PartiqlLogical.Expr.Modulo) =
node.operands.map { transformExpr(it) }
open fun transformExprModulo_metas(node: PartiqlLogical.Expr.Modulo) =
transformMetas(node.metas)
// Variant ExprConcat
open fun transformExprConcat(node: PartiqlLogical.Expr.Concat): PartiqlLogicalResolved.Expr {
val new_operands = transformExprConcat_operands(node)
val new_metas = transformExprConcat_metas(node)
return PartiqlLogicalResolved.Expr.Concat(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprConcat_operands(node: PartiqlLogical.Expr.Concat) =
node.operands.map { transformExpr(it) }
open fun transformExprConcat_metas(node: PartiqlLogical.Expr.Concat) =
transformMetas(node.metas)
// Variant ExprAnd
open fun transformExprAnd(node: PartiqlLogical.Expr.And): PartiqlLogicalResolved.Expr {
val new_operands = transformExprAnd_operands(node)
val new_metas = transformExprAnd_metas(node)
return PartiqlLogicalResolved.Expr.And(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprAnd_operands(node: PartiqlLogical.Expr.And) =
node.operands.map { transformExpr(it) }
open fun transformExprAnd_metas(node: PartiqlLogical.Expr.And) =
transformMetas(node.metas)
// Variant ExprOr
open fun transformExprOr(node: PartiqlLogical.Expr.Or): PartiqlLogicalResolved.Expr {
val new_operands = transformExprOr_operands(node)
val new_metas = transformExprOr_metas(node)
return PartiqlLogicalResolved.Expr.Or(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprOr_operands(node: PartiqlLogical.Expr.Or) =
node.operands.map { transformExpr(it) }
open fun transformExprOr_metas(node: PartiqlLogical.Expr.Or) =
transformMetas(node.metas)
// Variant ExprEq
open fun transformExprEq(node: PartiqlLogical.Expr.Eq): PartiqlLogicalResolved.Expr {
val new_operands = transformExprEq_operands(node)
val new_metas = transformExprEq_metas(node)
return PartiqlLogicalResolved.Expr.Eq(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprEq_operands(node: PartiqlLogical.Expr.Eq) =
node.operands.map { transformExpr(it) }
open fun transformExprEq_metas(node: PartiqlLogical.Expr.Eq) =
transformMetas(node.metas)
// Variant ExprNe
open fun transformExprNe(node: PartiqlLogical.Expr.Ne): PartiqlLogicalResolved.Expr {
val new_operands = transformExprNe_operands(node)
val new_metas = transformExprNe_metas(node)
return PartiqlLogicalResolved.Expr.Ne(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprNe_operands(node: PartiqlLogical.Expr.Ne) =
node.operands.map { transformExpr(it) }
open fun transformExprNe_metas(node: PartiqlLogical.Expr.Ne) =
transformMetas(node.metas)
// Variant ExprGt
open fun transformExprGt(node: PartiqlLogical.Expr.Gt): PartiqlLogicalResolved.Expr {
val new_operands = transformExprGt_operands(node)
val new_metas = transformExprGt_metas(node)
return PartiqlLogicalResolved.Expr.Gt(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprGt_operands(node: PartiqlLogical.Expr.Gt) =
node.operands.map { transformExpr(it) }
open fun transformExprGt_metas(node: PartiqlLogical.Expr.Gt) =
transformMetas(node.metas)
// Variant ExprGte
open fun transformExprGte(node: PartiqlLogical.Expr.Gte): PartiqlLogicalResolved.Expr {
val new_operands = transformExprGte_operands(node)
val new_metas = transformExprGte_metas(node)
return PartiqlLogicalResolved.Expr.Gte(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprGte_operands(node: PartiqlLogical.Expr.Gte) =
node.operands.map { transformExpr(it) }
open fun transformExprGte_metas(node: PartiqlLogical.Expr.Gte) =
transformMetas(node.metas)
// Variant ExprLt
open fun transformExprLt(node: PartiqlLogical.Expr.Lt): PartiqlLogicalResolved.Expr {
val new_operands = transformExprLt_operands(node)
val new_metas = transformExprLt_metas(node)
return PartiqlLogicalResolved.Expr.Lt(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprLt_operands(node: PartiqlLogical.Expr.Lt) =
node.operands.map { transformExpr(it) }
open fun transformExprLt_metas(node: PartiqlLogical.Expr.Lt) =
transformMetas(node.metas)
// Variant ExprLte
open fun transformExprLte(node: PartiqlLogical.Expr.Lte): PartiqlLogicalResolved.Expr {
val new_operands = transformExprLte_operands(node)
val new_metas = transformExprLte_metas(node)
return PartiqlLogicalResolved.Expr.Lte(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprLte_operands(node: PartiqlLogical.Expr.Lte) =
node.operands.map { transformExpr(it) }
open fun transformExprLte_metas(node: PartiqlLogical.Expr.Lte) =
transformMetas(node.metas)
// Variant ExprLike
open fun transformExprLike(node: PartiqlLogical.Expr.Like): PartiqlLogicalResolved.Expr {
val new_value = transformExprLike_value(node)
val new_pattern = transformExprLike_pattern(node)
val new_escape = transformExprLike_escape(node)
val new_metas = transformExprLike_metas(node)
return PartiqlLogicalResolved.Expr.Like(
value = new_value,
pattern = new_pattern,
escape = new_escape,
metas = new_metas
)
}
open fun transformExprLike_value(node: PartiqlLogical.Expr.Like) =
transformExpr(node.value)
open fun transformExprLike_pattern(node: PartiqlLogical.Expr.Like) =
transformExpr(node.pattern)
open fun transformExprLike_escape(node: PartiqlLogical.Expr.Like) =
node.escape?.let { transformExpr(it) }
open fun transformExprLike_metas(node: PartiqlLogical.Expr.Like) =
transformMetas(node.metas)
// Variant ExprBetween
open fun transformExprBetween(node: PartiqlLogical.Expr.Between): PartiqlLogicalResolved.Expr {
val new_value = transformExprBetween_value(node)
val new_from = transformExprBetween_from(node)
val new_to = transformExprBetween_to(node)
val new_metas = transformExprBetween_metas(node)
return PartiqlLogicalResolved.Expr.Between(
value = new_value,
from = new_from,
to = new_to,
metas = new_metas
)
}
open fun transformExprBetween_value(node: PartiqlLogical.Expr.Between) =
transformExpr(node.value)
open fun transformExprBetween_from(node: PartiqlLogical.Expr.Between) =
transformExpr(node.from)
open fun transformExprBetween_to(node: PartiqlLogical.Expr.Between) =
transformExpr(node.to)
open fun transformExprBetween_metas(node: PartiqlLogical.Expr.Between) =
transformMetas(node.metas)
// Variant ExprInCollection
open fun transformExprInCollection(node: PartiqlLogical.Expr.InCollection): PartiqlLogicalResolved.Expr {
val new_operands = transformExprInCollection_operands(node)
val new_metas = transformExprInCollection_metas(node)
return PartiqlLogicalResolved.Expr.InCollection(
operands = new_operands,
metas = new_metas
)
}
open fun transformExprInCollection_operands(node: PartiqlLogical.Expr.InCollection) =
node.operands.map { transformExpr(it) }
open fun transformExprInCollection_metas(node: PartiqlLogical.Expr.InCollection) =
transformMetas(node.metas)
// Variant ExprIsType
open fun transformExprIsType(node: PartiqlLogical.Expr.IsType): PartiqlLogicalResolved.Expr {
val new_value = transformExprIsType_value(node)
val new_type = transformExprIsType_type(node)
val new_metas = transformExprIsType_metas(node)
return PartiqlLogicalResolved.Expr.IsType(
value = new_value,
type = new_type,
metas = new_metas
)
}
open fun transformExprIsType_value(node: PartiqlLogical.Expr.IsType) =
transformExpr(node.value)
open fun transformExprIsType_type(node: PartiqlLogical.Expr.IsType) =
transformType(node.type)
open fun transformExprIsType_metas(node: PartiqlLogical.Expr.IsType) =
transformMetas(node.metas)
// Variant ExprSimpleCase
open fun transformExprSimpleCase(node: PartiqlLogical.Expr.SimpleCase): PartiqlLogicalResolved.Expr {
val new_expr = transformExprSimpleCase_expr(node)
val new_cases = transformExprSimpleCase_cases(node)
val new_default = transformExprSimpleCase_default(node)
val new_metas = transformExprSimpleCase_metas(node)
return PartiqlLogicalResolved.Expr.SimpleCase(
expr = new_expr,
cases = new_cases,
default = new_default,
metas = new_metas
)
}
open fun transformExprSimpleCase_expr(node: PartiqlLogical.Expr.SimpleCase) =
transformExpr(node.expr)
open fun transformExprSimpleCase_cases(node: PartiqlLogical.Expr.SimpleCase) =
transformExprPairList(node.cases)
open fun transformExprSimpleCase_default(node: PartiqlLogical.Expr.SimpleCase) =
node.default?.let { transformExpr(it) }
open fun transformExprSimpleCase_metas(node: PartiqlLogical.Expr.SimpleCase) =
transformMetas(node.metas)
// Variant ExprSearchedCase
open fun transformExprSearchedCase(node: PartiqlLogical.Expr.SearchedCase): PartiqlLogicalResolved.Expr {
val new_cases = transformExprSearchedCase_cases(node)
val new_default = transformExprSearchedCase_default(node)
val new_metas = transformExprSearchedCase_metas(node)
return PartiqlLogicalResolved.Expr.SearchedCase(
cases = new_cases,
default = new_default,
metas = new_metas
)
}
open fun transformExprSearchedCase_cases(node: PartiqlLogical.Expr.SearchedCase) =
transformExprPairList(node.cases)
open fun transformExprSearchedCase_default(node: PartiqlLogical.Expr.SearchedCase) =
node.default?.let { transformExpr(it) }
open fun transformExprSearchedCase_metas(node: PartiqlLogical.Expr.SearchedCase) =
transformMetas(node.metas)
// Variant ExprBag
open fun transformExprBag(node: PartiqlLogical.Expr.Bag): PartiqlLogicalResolved.Expr {
val new_values = transformExprBag_values(node)
val new_metas = transformExprBag_metas(node)
return PartiqlLogicalResolved.Expr.Bag(
values = new_values,
metas = new_metas
)
}
open fun transformExprBag_values(node: PartiqlLogical.Expr.Bag) =
node.values.map { transformExpr(it) }
open fun transformExprBag_metas(node: PartiqlLogical.Expr.Bag) =
transformMetas(node.metas)
// Variant ExprList
open fun transformExprList(node: PartiqlLogical.Expr.List): PartiqlLogicalResolved.Expr {
val new_values = transformExprList_values(node)
val new_metas = transformExprList_metas(node)
return PartiqlLogicalResolved.Expr.List(
values = new_values,
metas = new_metas
)
}
open fun transformExprList_values(node: PartiqlLogical.Expr.List) =
node.values.map { transformExpr(it) }
open fun transformExprList_metas(node: PartiqlLogical.Expr.List) =
transformMetas(node.metas)
// Variant ExprSexp
open fun transformExprSexp(node: PartiqlLogical.Expr.Sexp): PartiqlLogicalResolved.Expr {
val new_values = transformExprSexp_values(node)
val new_metas = transformExprSexp_metas(node)
return PartiqlLogicalResolved.Expr.Sexp(
values = new_values,
metas = new_metas
)
}
open fun transformExprSexp_values(node: PartiqlLogical.Expr.Sexp) =
node.values.map { transformExpr(it) }
open fun transformExprSexp_metas(node: PartiqlLogical.Expr.Sexp) =
transformMetas(node.metas)
// Variant ExprDate
open fun transformExprDate(node: PartiqlLogical.Expr.Date): PartiqlLogicalResolved.Expr {
val new_year = transformExprDate_year(node)
val new_month = transformExprDate_month(node)
val new_day = transformExprDate_day(node)
val new_metas = transformExprDate_metas(node)
return PartiqlLogicalResolved.Expr.Date(
year = new_year,
month = new_month,
day = new_day,
metas = new_metas
)
}
open fun transformExprDate_year(node: PartiqlLogical.Expr.Date) =
transformLongPrimitive(node.year)
open fun transformExprDate_month(node: PartiqlLogical.Expr.Date) =
transformLongPrimitive(node.month)
open fun transformExprDate_day(node: PartiqlLogical.Expr.Date) =
transformLongPrimitive(node.day)
open fun transformExprDate_metas(node: PartiqlLogical.Expr.Date) =
transformMetas(node.metas)
// Variant ExprLitTime
open fun transformExprLitTime(node: PartiqlLogical.Expr.LitTime): PartiqlLogicalResolved.Expr {
val new_value = transformExprLitTime_value(node)
val new_metas = transformExprLitTime_metas(node)
return PartiqlLogicalResolved.Expr.LitTime(
value = new_value,
metas = new_metas
)
}
open fun transformExprLitTime_value(node: PartiqlLogical.Expr.LitTime) =
transformTimeValue(node.value)
open fun transformExprLitTime_metas(node: PartiqlLogical.Expr.LitTime) =
transformMetas(node.metas)
// Variant ExprBagOp
open fun transformExprBagOp(node: PartiqlLogical.Expr.BagOp): PartiqlLogicalResolved.Expr {
val new_op = transformExprBagOp_op(node)
val new_quantifier = transformExprBagOp_quantifier(node)
val new_operands = transformExprBagOp_operands(node)
val new_metas = transformExprBagOp_metas(node)
return PartiqlLogicalResolved.Expr.BagOp(
op = new_op,
quantifier = new_quantifier,
operands = new_operands,
metas = new_metas
)
}
open fun transformExprBagOp_op(node: PartiqlLogical.Expr.BagOp) =
transformBagOpType(node.op)
open fun transformExprBagOp_quantifier(node: PartiqlLogical.Expr.BagOp) =
transformSetQuantifier(node.quantifier)
open fun transformExprBagOp_operands(node: PartiqlLogical.Expr.BagOp) =
node.operands.map { transformExpr(it) }
open fun transformExprBagOp_metas(node: PartiqlLogical.Expr.BagOp) =
transformMetas(node.metas)
// Variant ExprGraphMatch
open fun transformExprGraphMatch(node: PartiqlLogical.Expr.GraphMatch): PartiqlLogicalResolved.Expr {
val new_expr = transformExprGraphMatch_expr(node)
val new_gpmlPattern = transformExprGraphMatch_gpmlPattern(node)
val new_metas = transformExprGraphMatch_metas(node)
return PartiqlLogicalResolved.Expr.GraphMatch(
expr = new_expr,
gpmlPattern = new_gpmlPattern,
metas = new_metas
)
}
open fun transformExprGraphMatch_expr(node: PartiqlLogical.Expr.GraphMatch) =
transformExpr(node.expr)
open fun transformExprGraphMatch_gpmlPattern(node: PartiqlLogical.Expr.GraphMatch) =
transformGpmlPattern(node.gpmlPattern)
open fun transformExprGraphMatch_metas(node: PartiqlLogical.Expr.GraphMatch) =
transformMetas(node.metas)
// Variant ExprPath
open fun transformExprPath(node: PartiqlLogical.Expr.Path): PartiqlLogicalResolved.Expr {
val new_root = transformExprPath_root(node)
val new_steps = transformExprPath_steps(node)
val new_metas = transformExprPath_metas(node)
return PartiqlLogicalResolved.Expr.Path(
root = new_root,
steps = new_steps,
metas = new_metas
)
}
open fun transformExprPath_root(node: PartiqlLogical.Expr.Path) =
transformExpr(node.root)
open fun transformExprPath_steps(node: PartiqlLogical.Expr.Path) =
node.steps.map { transformPathStep(it) }
open fun transformExprPath_metas(node: PartiqlLogical.Expr.Path) =
transformMetas(node.metas)
// Variant ExprCall
open fun transformExprCall(node: PartiqlLogical.Expr.Call): PartiqlLogicalResolved.Expr {
val new_funcName = transformExprCall_funcName(node)
val new_args = transformExprCall_args(node)
val new_metas = transformExprCall_metas(node)
return PartiqlLogicalResolved.Expr.Call(
funcName = new_funcName,
args = new_args,
metas = new_metas
)
}
open fun transformExprCall_funcName(node: PartiqlLogical.Expr.Call) =
transformSymbolPrimitive(node.funcName)
open fun transformExprCall_args(node: PartiqlLogical.Expr.Call) =
node.args.map { transformExpr(it) }
open fun transformExprCall_metas(node: PartiqlLogical.Expr.Call) =
transformMetas(node.metas)
// Variant ExprCast
open fun transformExprCast(node: PartiqlLogical.Expr.Cast): PartiqlLogicalResolved.Expr {
val new_value = transformExprCast_value(node)
val new_asType = transformExprCast_asType(node)
val new_metas = transformExprCast_metas(node)
return PartiqlLogicalResolved.Expr.Cast(
value = new_value,
asType = new_asType,
metas = new_metas
)
}
open fun transformExprCast_value(node: PartiqlLogical.Expr.Cast) =
transformExpr(node.value)
open fun transformExprCast_asType(node: PartiqlLogical.Expr.Cast) =
transformType(node.asType)
open fun transformExprCast_metas(node: PartiqlLogical.Expr.Cast) =
transformMetas(node.metas)
// Variant ExprCanCast
open fun transformExprCanCast(node: PartiqlLogical.Expr.CanCast): PartiqlLogicalResolved.Expr {
val new_value = transformExprCanCast_value(node)
val new_asType = transformExprCanCast_asType(node)
val new_metas = transformExprCanCast_metas(node)
return PartiqlLogicalResolved.Expr.CanCast(
value = new_value,
asType = new_asType,
metas = new_metas
)
}
open fun transformExprCanCast_value(node: PartiqlLogical.Expr.CanCast) =
transformExpr(node.value)
open fun transformExprCanCast_asType(node: PartiqlLogical.Expr.CanCast) =
transformType(node.asType)
open fun transformExprCanCast_metas(node: PartiqlLogical.Expr.CanCast) =
transformMetas(node.metas)
// Variant ExprCanLosslessCast
open fun transformExprCanLosslessCast(node: PartiqlLogical.Expr.CanLosslessCast): PartiqlLogicalResolved.Expr {
val new_value = transformExprCanLosslessCast_value(node)
val new_asType = transformExprCanLosslessCast_asType(node)
val new_metas = transformExprCanLosslessCast_metas(node)
return PartiqlLogicalResolved.Expr.CanLosslessCast(
value = new_value,
asType = new_asType,
metas = new_metas
)
}
open fun transformExprCanLosslessCast_value(node: PartiqlLogical.Expr.CanLosslessCast) =
transformExpr(node.value)
open fun transformExprCanLosslessCast_asType(node: PartiqlLogical.Expr.CanLosslessCast) =
transformType(node.asType)
open fun transformExprCanLosslessCast_metas(node: PartiqlLogical.Expr.CanLosslessCast) =
transformMetas(node.metas)
// Variant ExprNullIf
open fun transformExprNullIf(node: PartiqlLogical.Expr.NullIf): PartiqlLogicalResolved.Expr {
val new_expr1 = transformExprNullIf_expr1(node)
val new_expr2 = transformExprNullIf_expr2(node)
val new_metas = transformExprNullIf_metas(node)
return PartiqlLogicalResolved.Expr.NullIf(
expr1 = new_expr1,
expr2 = new_expr2,
metas = new_metas
)
}
open fun transformExprNullIf_expr1(node: PartiqlLogical.Expr.NullIf) =
transformExpr(node.expr1)
open fun transformExprNullIf_expr2(node: PartiqlLogical.Expr.NullIf) =
transformExpr(node.expr2)
open fun transformExprNullIf_metas(node: PartiqlLogical.Expr.NullIf) =
transformMetas(node.metas)
// Variant ExprCoalesce
open fun transformExprCoalesce(node: PartiqlLogical.Expr.Coalesce): PartiqlLogicalResolved.Expr {
val new_args = transformExprCoalesce_args(node)
val new_metas = transformExprCoalesce_metas(node)
return PartiqlLogicalResolved.Expr.Coalesce(
args = new_args,
metas = new_metas
)
}
open fun transformExprCoalesce_args(node: PartiqlLogical.Expr.Coalesce) =
node.args.map { transformExpr(it) }
open fun transformExprCoalesce_metas(node: PartiqlLogical.Expr.Coalesce) =
transformMetas(node.metas)
// Variant ExprBindingsToValues
open fun transformExprBindingsToValues(node: PartiqlLogical.Expr.BindingsToValues): PartiqlLogicalResolved.Expr {
val new_exp = transformExprBindingsToValues_exp(node)
val new_query = transformExprBindingsToValues_query(node)
val new_metas = transformExprBindingsToValues_metas(node)
return PartiqlLogicalResolved.Expr.BindingsToValues(
exp = new_exp,
query = new_query,
metas = new_metas
)
}
open fun transformExprBindingsToValues_exp(node: PartiqlLogical.Expr.BindingsToValues) =
transformExpr(node.exp)
open fun transformExprBindingsToValues_query(node: PartiqlLogical.Expr.BindingsToValues) =
transformBexpr(node.query)
open fun transformExprBindingsToValues_metas(node: PartiqlLogical.Expr.BindingsToValues) =
transformMetas(node.metas)
// Variant ExprStruct
open fun transformExprStruct(node: PartiqlLogical.Expr.Struct): PartiqlLogicalResolved.Expr {
val new_parts = transformExprStruct_parts(node)
val new_metas = transformExprStruct_metas(node)
return PartiqlLogicalResolved.Expr.Struct(
parts = new_parts,
metas = new_metas
)
}
open fun transformExprStruct_parts(node: PartiqlLogical.Expr.Struct) =
node.parts.map { transformStructPart(it) }
open fun transformExprStruct_metas(node: PartiqlLogical.Expr.Struct) =
transformMetas(node.metas)
// Variant ExprPivot
open fun transformExprPivot(node: PartiqlLogical.Expr.Pivot): PartiqlLogicalResolved.Expr {
val new_input = transformExprPivot_input(node)
val new_key = transformExprPivot_key(node)
val new_value = transformExprPivot_value(node)
val new_metas = transformExprPivot_metas(node)
return PartiqlLogicalResolved.Expr.Pivot(
input = new_input,
key = new_key,
value = new_value,
metas = new_metas
)
}
open fun transformExprPivot_input(node: PartiqlLogical.Expr.Pivot) =
transformBexpr(node.input)
open fun transformExprPivot_key(node: PartiqlLogical.Expr.Pivot) =
transformExpr(node.key)
open fun transformExprPivot_value(node: PartiqlLogical.Expr.Pivot) =
transformExpr(node.value)
open fun transformExprPivot_metas(node: PartiqlLogical.Expr.Pivot) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: Statement
//////////////////////////////////////
open fun transformStatement(node: PartiqlLogical.Statement): PartiqlLogicalResolved.Statement =
when(node) {
is PartiqlLogical.Statement.Query -> transformStatementQuery(node)
is PartiqlLogical.Statement.Exec -> transformStatementExec(node)
is PartiqlLogical.Statement.Explain -> transformStatementExplain(node)
is PartiqlLogical.Statement.Dml -> transformStatementDml(node)
}
// Variant StatementQuery
open fun transformStatementQuery(node: PartiqlLogical.Statement.Query): PartiqlLogicalResolved.Statement {
val new_expr = transformStatementQuery_expr(node)
val new_metas = transformStatementQuery_metas(node)
return PartiqlLogicalResolved.Statement.Query(
expr = new_expr,
metas = new_metas
)
}
open fun transformStatementQuery_expr(node: PartiqlLogical.Statement.Query) =
transformExpr(node.expr)
open fun transformStatementQuery_metas(node: PartiqlLogical.Statement.Query) =
transformMetas(node.metas)
// Variant StatementExec
open fun transformStatementExec(node: PartiqlLogical.Statement.Exec): PartiqlLogicalResolved.Statement {
val new_procedureName = transformStatementExec_procedureName(node)
val new_args = transformStatementExec_args(node)
val new_metas = transformStatementExec_metas(node)
return PartiqlLogicalResolved.Statement.Exec(
procedureName = new_procedureName,
args = new_args,
metas = new_metas
)
}
open fun transformStatementExec_procedureName(node: PartiqlLogical.Statement.Exec) =
transformSymbolPrimitive(node.procedureName)
open fun transformStatementExec_args(node: PartiqlLogical.Statement.Exec) =
node.args.map { transformExpr(it) }
open fun transformStatementExec_metas(node: PartiqlLogical.Statement.Exec) =
transformMetas(node.metas)
// Variant StatementExplain
open fun transformStatementExplain(node: PartiqlLogical.Statement.Explain): PartiqlLogicalResolved.Statement {
val new_target = transformStatementExplain_target(node)
val new_metas = transformStatementExplain_metas(node)
return PartiqlLogicalResolved.Statement.Explain(
target = new_target,
metas = new_metas
)
}
open fun transformStatementExplain_target(node: PartiqlLogical.Statement.Explain) =
transformExplainTarget(node.target)
open fun transformStatementExplain_metas(node: PartiqlLogical.Statement.Explain) =
transformMetas(node.metas)
// Variant StatementDml
abstract fun transformStatementDml(node: PartiqlLogical.Statement.Dml): PartiqlLogicalResolved.Statement
//////////////////////////////////////
// Sum Type: StructPart
//////////////////////////////////////
open fun transformStructPart(node: PartiqlLogical.StructPart): PartiqlLogicalResolved.StructPart =
when(node) {
is PartiqlLogical.StructPart.StructFields -> transformStructPartStructFields(node)
is PartiqlLogical.StructPart.StructField -> transformStructPartStructField(node)
}
// Variant StructPartStructFields
open fun transformStructPartStructFields(node: PartiqlLogical.StructPart.StructFields): PartiqlLogicalResolved.StructPart {
val new_partExpr = transformStructPartStructFields_partExpr(node)
val new_metas = transformStructPartStructFields_metas(node)
return PartiqlLogicalResolved.StructPart.StructFields(
partExpr = new_partExpr,
metas = new_metas
)
}
open fun transformStructPartStructFields_partExpr(node: PartiqlLogical.StructPart.StructFields) =
transformExpr(node.partExpr)
open fun transformStructPartStructFields_metas(node: PartiqlLogical.StructPart.StructFields) =
transformMetas(node.metas)
// Variant StructPartStructField
open fun transformStructPartStructField(node: PartiqlLogical.StructPart.StructField): PartiqlLogicalResolved.StructPart {
val new_fieldName = transformStructPartStructField_fieldName(node)
val new_value = transformStructPartStructField_value(node)
val new_metas = transformStructPartStructField_metas(node)
return PartiqlLogicalResolved.StructPart.StructField(
fieldName = new_fieldName,
value = new_value,
metas = new_metas
)
}
open fun transformStructPartStructField_fieldName(node: PartiqlLogical.StructPart.StructField) =
transformExpr(node.fieldName)
open fun transformStructPartStructField_value(node: PartiqlLogical.StructPart.StructField) =
transformExpr(node.value)
open fun transformStructPartStructField_metas(node: PartiqlLogical.StructPart.StructField) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: Bexpr
//////////////////////////////////////
open fun transformBexpr(node: PartiqlLogical.Bexpr): PartiqlLogicalResolved.Bexpr =
when(node) {
is PartiqlLogical.Bexpr.Scan -> transformBexprScan(node)
is PartiqlLogical.Bexpr.Unpivot -> transformBexprUnpivot(node)
is PartiqlLogical.Bexpr.Filter -> transformBexprFilter(node)
is PartiqlLogical.Bexpr.Aggregate -> transformBexprAggregate(node)
is PartiqlLogical.Bexpr.Join -> transformBexprJoin(node)
is PartiqlLogical.Bexpr.Window -> transformBexprWindow(node)
is PartiqlLogical.Bexpr.Sort -> transformBexprSort(node)
is PartiqlLogical.Bexpr.Offset -> transformBexprOffset(node)
is PartiqlLogical.Bexpr.Limit -> transformBexprLimit(node)
is PartiqlLogical.Bexpr.Let -> transformBexprLet(node)
}
// Variant BexprScan
open fun transformBexprScan(node: PartiqlLogical.Bexpr.Scan): PartiqlLogicalResolved.Bexpr {
val new_expr = transformBexprScan_expr(node)
val new_asDecl = transformBexprScan_asDecl(node)
val new_atDecl = transformBexprScan_atDecl(node)
val new_byDecl = transformBexprScan_byDecl(node)
val new_metas = transformBexprScan_metas(node)
return PartiqlLogicalResolved.Bexpr.Scan(
expr = new_expr,
asDecl = new_asDecl,
atDecl = new_atDecl,
byDecl = new_byDecl,
metas = new_metas
)
}
open fun transformBexprScan_expr(node: PartiqlLogical.Bexpr.Scan) =
transformExpr(node.expr)
open fun transformBexprScan_asDecl(node: PartiqlLogical.Bexpr.Scan) =
transformVarDecl(node.asDecl)
open fun transformBexprScan_atDecl(node: PartiqlLogical.Bexpr.Scan) =
node.atDecl?.let { transformVarDecl(it) }
open fun transformBexprScan_byDecl(node: PartiqlLogical.Bexpr.Scan) =
node.byDecl?.let { transformVarDecl(it) }
open fun transformBexprScan_metas(node: PartiqlLogical.Bexpr.Scan) =
transformMetas(node.metas)
// Variant BexprUnpivot
open fun transformBexprUnpivot(node: PartiqlLogical.Bexpr.Unpivot): PartiqlLogicalResolved.Bexpr {
val new_expr = transformBexprUnpivot_expr(node)
val new_asDecl = transformBexprUnpivot_asDecl(node)
val new_atDecl = transformBexprUnpivot_atDecl(node)
val new_byDecl = transformBexprUnpivot_byDecl(node)
val new_metas = transformBexprUnpivot_metas(node)
return PartiqlLogicalResolved.Bexpr.Unpivot(
expr = new_expr,
asDecl = new_asDecl,
atDecl = new_atDecl,
byDecl = new_byDecl,
metas = new_metas
)
}
open fun transformBexprUnpivot_expr(node: PartiqlLogical.Bexpr.Unpivot) =
transformExpr(node.expr)
open fun transformBexprUnpivot_asDecl(node: PartiqlLogical.Bexpr.Unpivot) =
transformVarDecl(node.asDecl)
open fun transformBexprUnpivot_atDecl(node: PartiqlLogical.Bexpr.Unpivot) =
node.atDecl?.let { transformVarDecl(it) }
open fun transformBexprUnpivot_byDecl(node: PartiqlLogical.Bexpr.Unpivot) =
node.byDecl?.let { transformVarDecl(it) }
open fun transformBexprUnpivot_metas(node: PartiqlLogical.Bexpr.Unpivot) =
transformMetas(node.metas)
// Variant BexprFilter
open fun transformBexprFilter(node: PartiqlLogical.Bexpr.Filter): PartiqlLogicalResolved.Bexpr {
val new_predicate = transformBexprFilter_predicate(node)
val new_source = transformBexprFilter_source(node)
val new_metas = transformBexprFilter_metas(node)
return PartiqlLogicalResolved.Bexpr.Filter(
predicate = new_predicate,
source = new_source,
metas = new_metas
)
}
open fun transformBexprFilter_predicate(node: PartiqlLogical.Bexpr.Filter) =
transformExpr(node.predicate)
open fun transformBexprFilter_source(node: PartiqlLogical.Bexpr.Filter) =
transformBexpr(node.source)
open fun transformBexprFilter_metas(node: PartiqlLogical.Bexpr.Filter) =
transformMetas(node.metas)
// Variant BexprAggregate
open fun transformBexprAggregate(node: PartiqlLogical.Bexpr.Aggregate): PartiqlLogicalResolved.Bexpr {
val new_source = transformBexprAggregate_source(node)
val new_strategy = transformBexprAggregate_strategy(node)
val new_groupList = transformBexprAggregate_groupList(node)
val new_functionList = transformBexprAggregate_functionList(node)
val new_metas = transformBexprAggregate_metas(node)
return PartiqlLogicalResolved.Bexpr.Aggregate(
source = new_source,
strategy = new_strategy,
groupList = new_groupList,
functionList = new_functionList,
metas = new_metas
)
}
open fun transformBexprAggregate_source(node: PartiqlLogical.Bexpr.Aggregate) =
transformBexpr(node.source)
open fun transformBexprAggregate_strategy(node: PartiqlLogical.Bexpr.Aggregate) =
transformGroupingStrategy(node.strategy)
open fun transformBexprAggregate_groupList(node: PartiqlLogical.Bexpr.Aggregate) =
transformGroupKeyList(node.groupList)
open fun transformBexprAggregate_functionList(node: PartiqlLogical.Bexpr.Aggregate) =
transformAggregateFunctionList(node.functionList)
open fun transformBexprAggregate_metas(node: PartiqlLogical.Bexpr.Aggregate) =
transformMetas(node.metas)
// Variant BexprJoin
open fun transformBexprJoin(node: PartiqlLogical.Bexpr.Join): PartiqlLogicalResolved.Bexpr {
val new_joinType = transformBexprJoin_joinType(node)
val new_left = transformBexprJoin_left(node)
val new_right = transformBexprJoin_right(node)
val new_predicate = transformBexprJoin_predicate(node)
val new_metas = transformBexprJoin_metas(node)
return PartiqlLogicalResolved.Bexpr.Join(
joinType = new_joinType,
left = new_left,
right = new_right,
predicate = new_predicate,
metas = new_metas
)
}
open fun transformBexprJoin_joinType(node: PartiqlLogical.Bexpr.Join) =
transformJoinType(node.joinType)
open fun transformBexprJoin_left(node: PartiqlLogical.Bexpr.Join) =
transformBexpr(node.left)
open fun transformBexprJoin_right(node: PartiqlLogical.Bexpr.Join) =
transformBexpr(node.right)
open fun transformBexprJoin_predicate(node: PartiqlLogical.Bexpr.Join) =
node.predicate?.let { transformExpr(it) }
open fun transformBexprJoin_metas(node: PartiqlLogical.Bexpr.Join) =
transformMetas(node.metas)
// Variant BexprWindow
open fun transformBexprWindow(node: PartiqlLogical.Bexpr.Window): PartiqlLogicalResolved.Bexpr {
val new_source = transformBexprWindow_source(node)
val new_windowSpecification = transformBexprWindow_windowSpecification(node)
val new_windowExpressionList = transformBexprWindow_windowExpressionList(node)
val new_metas = transformBexprWindow_metas(node)
return PartiqlLogicalResolved.Bexpr.Window(
source = new_source,
windowSpecification = new_windowSpecification,
windowExpressionList = new_windowExpressionList,
metas = new_metas
)
}
open fun transformBexprWindow_source(node: PartiqlLogical.Bexpr.Window) =
transformBexpr(node.source)
open fun transformBexprWindow_windowSpecification(node: PartiqlLogical.Bexpr.Window) =
transformOver(node.windowSpecification)
open fun transformBexprWindow_windowExpressionList(node: PartiqlLogical.Bexpr.Window) =
node.windowExpressionList.map { transformWindowExpression(it) }
open fun transformBexprWindow_metas(node: PartiqlLogical.Bexpr.Window) =
transformMetas(node.metas)
// Variant BexprSort
open fun transformBexprSort(node: PartiqlLogical.Bexpr.Sort): PartiqlLogicalResolved.Bexpr {
val new_source = transformBexprSort_source(node)
val new_sortSpecs = transformBexprSort_sortSpecs(node)
val new_metas = transformBexprSort_metas(node)
return PartiqlLogicalResolved.Bexpr.Sort(
source = new_source,
sortSpecs = new_sortSpecs,
metas = new_metas
)
}
open fun transformBexprSort_source(node: PartiqlLogical.Bexpr.Sort) =
transformBexpr(node.source)
open fun transformBexprSort_sortSpecs(node: PartiqlLogical.Bexpr.Sort) =
node.sortSpecs.map { transformSortSpec(it) }
open fun transformBexprSort_metas(node: PartiqlLogical.Bexpr.Sort) =
transformMetas(node.metas)
// Variant BexprOffset
open fun transformBexprOffset(node: PartiqlLogical.Bexpr.Offset): PartiqlLogicalResolved.Bexpr {
val new_rowCount = transformBexprOffset_rowCount(node)
val new_source = transformBexprOffset_source(node)
val new_metas = transformBexprOffset_metas(node)
return PartiqlLogicalResolved.Bexpr.Offset(
rowCount = new_rowCount,
source = new_source,
metas = new_metas
)
}
open fun transformBexprOffset_rowCount(node: PartiqlLogical.Bexpr.Offset) =
transformExpr(node.rowCount)
open fun transformBexprOffset_source(node: PartiqlLogical.Bexpr.Offset) =
transformBexpr(node.source)
open fun transformBexprOffset_metas(node: PartiqlLogical.Bexpr.Offset) =
transformMetas(node.metas)
// Variant BexprLimit
open fun transformBexprLimit(node: PartiqlLogical.Bexpr.Limit): PartiqlLogicalResolved.Bexpr {
val new_rowCount = transformBexprLimit_rowCount(node)
val new_source = transformBexprLimit_source(node)
val new_metas = transformBexprLimit_metas(node)
return PartiqlLogicalResolved.Bexpr.Limit(
rowCount = new_rowCount,
source = new_source,
metas = new_metas
)
}
open fun transformBexprLimit_rowCount(node: PartiqlLogical.Bexpr.Limit) =
transformExpr(node.rowCount)
open fun transformBexprLimit_source(node: PartiqlLogical.Bexpr.Limit) =
transformBexpr(node.source)
open fun transformBexprLimit_metas(node: PartiqlLogical.Bexpr.Limit) =
transformMetas(node.metas)
// Variant BexprLet
open fun transformBexprLet(node: PartiqlLogical.Bexpr.Let): PartiqlLogicalResolved.Bexpr {
val new_source = transformBexprLet_source(node)
val new_bindings = transformBexprLet_bindings(node)
val new_metas = transformBexprLet_metas(node)
return PartiqlLogicalResolved.Bexpr.Let(
source = new_source,
bindings = new_bindings,
metas = new_metas
)
}
open fun transformBexprLet_source(node: PartiqlLogical.Bexpr.Let) =
transformBexpr(node.source)
open fun transformBexprLet_bindings(node: PartiqlLogical.Bexpr.Let) =
node.bindings.map { transformLetBinding(it) }
open fun transformBexprLet_metas(node: PartiqlLogical.Bexpr.Let) =
transformMetas(node.metas)
//////////////////////////////////////
// Sum Type: DmlOperation
//////////////////////////////////////
open fun transformDmlOperation(node: PartiqlLogical.DmlOperation): PartiqlLogicalResolved.DmlOperation =
when(node) {
is PartiqlLogical.DmlOperation.DmlInsert -> transformDmlOperationDmlInsert(node)
is PartiqlLogical.DmlOperation.DmlDelete -> transformDmlOperationDmlDelete(node)
is PartiqlLogical.DmlOperation.DmlReplace -> transformDmlOperationDmlReplace(node)
is PartiqlLogical.DmlOperation.DmlUpdate -> transformDmlOperationDmlUpdate(node)
}
// Variant DmlOperationDmlInsert
open fun transformDmlOperationDmlInsert(node: PartiqlLogical.DmlOperation.DmlInsert): PartiqlLogicalResolved.DmlOperation {
val new_metas = transformDmlOperationDmlInsert_metas(node)
return PartiqlLogicalResolved.DmlOperation.DmlInsert(
metas = new_metas
)
}
open fun transformDmlOperationDmlInsert_metas(node: PartiqlLogical.DmlOperation.DmlInsert) =
transformMetas(node.metas)
// Variant DmlOperationDmlDelete
open fun transformDmlOperationDmlDelete(node: PartiqlLogical.DmlOperation.DmlDelete): PartiqlLogicalResolved.DmlOperation {
val new_metas = transformDmlOperationDmlDelete_metas(node)
return PartiqlLogicalResolved.DmlOperation.DmlDelete(
metas = new_metas
)
}
open fun transformDmlOperationDmlDelete_metas(node: PartiqlLogical.DmlOperation.DmlDelete) =
transformMetas(node.metas)
// Variant DmlOperationDmlReplace
open fun transformDmlOperationDmlReplace(node: PartiqlLogical.DmlOperation.DmlReplace): PartiqlLogicalResolved.DmlOperation {
val new_metas = transformDmlOperationDmlReplace_metas(node)
return PartiqlLogicalResolved.DmlOperation.DmlReplace(
metas = new_metas
)
}
open fun transformDmlOperationDmlReplace_metas(node: PartiqlLogical.DmlOperation.DmlReplace) =
transformMetas(node.metas)
// Variant DmlOperationDmlUpdate
open fun transformDmlOperationDmlUpdate(node: PartiqlLogical.DmlOperation.DmlUpdate): PartiqlLogicalResolved.DmlOperation {
val new_metas = transformDmlOperationDmlUpdate_metas(node)
return PartiqlLogicalResolved.DmlOperation.DmlUpdate(
metas = new_metas
)
}
open fun transformDmlOperationDmlUpdate_metas(node: PartiqlLogical.DmlOperation.DmlUpdate) =
transformMetas(node.metas)
}