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