feat(engine): add substituteSelect and substituteGroupingSpec
This commit is contained in:
dualfroz committed
1 parent
020a3c09ed
commit
d6b9462677
1 file changed
+213
@@ -156,3 +156,216 @@ internal object ParameterSubstitution {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private fun substituteSelect(select: SelectStatement, boundValues: List<Value>): SelectStatement = select.copy(
|
||||||
|
from = substituteFromItem(select.from, boundValues),
|
||||||
|
joins = select.joins.map { join ->
|
||||||
|
join.copy(
|
||||||
|
from = substituteFromItem(join.from, boundValues),
|
||||||
|
on = join.on?.let { substituteExpression(it, boundValues) }
|
||||||
|
)
|
||||||
|
},
|
||||||
|
where = select.where?.let { substituteExpression(it, boundValues) },
|
||||||
|
groupBy = select.groupBy.map { substituteExpression(it, boundValues) },
|
||||||
|
groupingSpec = select.groupingSpec?.let { substituteGroupingSpec(it, boundValues) },
|
||||||
|
having = select.having?.let { substituteExpression(it, boundValues) },
|
||||||
|
projection = substituteProjection(select.projection, boundValues),
|
||||||
|
orderBy = select.orderBy?.let { substituteOrderBy(it, boundValues) },
|
||||||
|
distinctOn = select.distinctOn.map { substituteExpression(it, boundValues) }
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun substituteGroupingSpec(spec: GroupingSpec, boundValues: List<Value>): GroupingSpec = when (spec) {
|
||||||
|
is RollupSpec -> spec.copy(expressions = spec.expressions.map { substituteExpression(it, boundValues) })
|
||||||
|
is CubeSpec -> spec.copy(expressions = spec.expressions.map { substituteExpression(it, boundValues) })
|
||||||
|
is GroupingSetsSpec -> spec.copy(sets = spec.sets.map { set -> set.map { substituteExpression(it, boundValues) } })
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun substituteFromItem(item: FromItem, boundValues: List<Value>): FromItem = when (item) {
|
||||||
|
is TableSource -> item
|
||||||
|
is SubquerySource -> item.copy(select = substituteQuery(item.select, boundValues))
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun substituteProjection(projection: Projection, boundValues: List<Value>): Projection = when (projection) {
|
||||||
|
StarProjection -> projection
|
||||||
|
is ExpressionProjection ->
|
||||||
|
projection.copy(items = projection.items.map { it.copy(expression = substituteExpression(it.expression, boundValues)) })
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun substituteOrderBy(orderBy: OrderBy, boundValues: List<Value>): OrderBy =
|
||||||
|
orderBy.copy(keys = orderBy.keys.map { it.copy(expression = substituteExpression(it.expression, boundValues)) })
|
||||||
|
|
||||||
|
private fun substituteExpression(expression: Expression, boundValues: List<Value>): Expression = when (expression) {
|
||||||
|
is ParameterExpression -> LiteralExpression(boundValueAt(expression.index, boundValues))
|
||||||
|
is ScalarSubqueryExpression -> expression.copy(select = substituteSelect(expression.select, boundValues))
|
||||||
|
is ExistsExpression -> expression.copy(select = substituteSelect(expression.select, boundValues))
|
||||||
|
is InSubqueryExpression -> expression.copy(
|
||||||
|
operand = substituteExpression(expression.operand, boundValues),
|
||||||
|
select = substituteSelect(expression.select, boundValues)
|
||||||
|
)
|
||||||
|
is BinaryExpression -> expression.copy(
|
||||||
|
left = substituteExpression(expression.left, boundValues),
|
||||||
|
right = substituteExpression(expression.right, boundValues)
|
||||||
|
)
|
||||||
|
is UnaryExpression -> expression.copy(operand = substituteExpression(expression.operand, boundValues))
|
||||||
|
is CallExpression -> expression.copy(arguments = expression.arguments.map { substituteExpression(it, boundValues) })
|
||||||
|
is IsNullExpression -> expression.copy(operand = substituteExpression(expression.operand, boundValues))
|
||||||
|
is InExpression -> expression.copy(
|
||||||
|
operand = substituteExpression(expression.operand, boundValues),
|
||||||
|
values = expression.values.map { substituteExpression(it, boundValues) }
|
||||||
|
)
|
||||||
|
is BetweenExpression -> expression.copy(
|
||||||
|
operand = substituteExpression(expression.operand, boundValues),
|
||||||
|
low = substituteExpression(expression.low, boundValues),
|
||||||
|
high = substituteExpression(expression.high, boundValues)
|
||||||
|
)
|
||||||
|
is LikeExpression -> expression.copy(
|
||||||
|
operand = substituteExpression(expression.operand, boundValues),
|
||||||
|
pattern = substituteExpression(expression.pattern, boundValues)
|
||||||
|
)
|
||||||
|
is CaseExpression -> expression.copy(
|
||||||
|
operand = expression.operand?.let { substituteExpression(it, boundValues) },
|
||||||
|
branches = expression.branches.map {
|
||||||
|
it.copy(condition = substituteExpression(it.condition, boundValues), result = substituteExpression(it.result, boundValues))
|
||||||
|
},
|
||||||
|
elseExpression = expression.elseExpression?.let { substituteExpression(it, boundValues) }
|
||||||
|
)
|
||||||
|
is CastExpression -> expression.copy(operand = substituteExpression(expression.operand, boundValues))
|
||||||
|
is CollateExpression -> expression.copy(operand = substituteExpression(expression.operand, boundValues))
|
||||||
|
is FunctionExpression -> expression.copy(
|
||||||
|
argument = expression.argument?.let { substituteExpression(it, boundValues) },
|
||||||
|
separator = expression.separator?.let { substituteExpression(it, boundValues) },
|
||||||
|
orderBy = expression.orderBy.map { it.copy(expression = substituteExpression(it.expression, boundValues)) },
|
||||||
|
filter = expression.filter?.let { substituteExpression(it, boundValues) }
|
||||||
|
)
|
||||||
|
is WindowExpression -> expression.copy(
|
||||||
|
argument = expression.argument?.let { substituteExpression(it, boundValues) },
|
||||||
|
partitionBy = expression.partitionBy.map { substituteExpression(it, boundValues) },
|
||||||
|
orderBy = expression.orderBy.map { it.copy(expression = substituteExpression(it.expression, boundValues)) },
|
||||||
|
offset = expression.offset?.let { substituteExpression(it, boundValues) },
|
||||||
|
defaultValue = expression.defaultValue?.let { substituteExpression(it, boundValues) },
|
||||||
|
frame = expression.frame?.let { frame ->
|
||||||
|
frame.copy(
|
||||||
|
start = substituteFrameBound(frame.start, boundValues),
|
||||||
|
end = substituteFrameBound(frame.end, boundValues)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
)
|
||||||
|
is ColumnExpression, is LiteralExpression, is NextValueExpression, is CurrentValueExpression,
|
||||||
|
is MergeActionExpression -> expression
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun substituteFrameBound(bound: FrameBound, boundValues: List<Value>): FrameBound =
|
||||||
|
bound.copy(offset = bound.offset?.let { substituteExpression(it, boundValues) })
|
||||||
|
|
||||||
|
private fun boundValueAt(index: Int, boundValues: List<Value>): Value =
|
||||||
|
boundValues.getOrNull(index - 1) ?: throw KestrelException("no value supplied for parameter \$$index")
|
||||||
|
|
||||||
|
// --- parameterCount's twin walk: same shape as substitute above, but only tracks the max index seen. ---
|
||||||
|
|
||||||
|
private fun maxIndexInAssignments(assignments: List<Assignment>): Int =
|
||||||
|
assignments.maxOfOrNull { it.value?.let(::maxIndexInExpression) ?: 0 } ?: 0
|
||||||
|
|
||||||
|
private fun maxIndexInOnConflict(clause: OnConflictClause): Int = when (val action = clause.action) {
|
||||||
|
ConflictDoNothing -> 0
|
||||||
|
is ConflictDoUpdate -> maxOf(maxIndexInAssignments(action.assignments), action.where?.let(::maxIndexInExpression) ?: 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun maxIndexInWhenClause(clause: MergeWhenClause): Int = when (clause) {
|
||||||
|
is MergeMatchedUpdate -> maxOf(
|
||||||
|
clause.condition?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
maxIndexInAssignments(clause.assignments)
|
||||||
|
)
|
||||||
|
is MergeMatchedDelete -> clause.condition?.let(::maxIndexInExpression) ?: 0
|
||||||
|
is MergeNotMatchedInsert -> maxOf(
|
||||||
|
clause.condition?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
clause.values.maxOfOrNull { it?.let(::maxIndexInExpression) ?: 0 } ?: 0
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun maxIndexInQuery(query: QueryStatement): Int = when (query) {
|
||||||
|
is SelectStatement -> maxIndexInSelect(query)
|
||||||
|
is SetOperationStatement -> maxOf(
|
||||||
|
maxIndexInQuery(query.left),
|
||||||
|
maxIndexInQuery(query.right),
|
||||||
|
query.orderBy?.let(::maxIndexInOrderBy) ?: 0
|
||||||
|
)
|
||||||
|
is WithQuery -> maxOf(
|
||||||
|
query.ctes.maxOfOrNull { maxIndexInQuery(it.query) } ?: 0,
|
||||||
|
maxIndexInQuery(query.body)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun maxIndexInSelect(select: SelectStatement): Int = maxOf(
|
||||||
|
maxIndexInFromItem(select.from),
|
||||||
|
select.joins.maxOfOrNull { join -> maxOf(maxIndexInFromItem(join.from), join.on?.let(::maxIndexInExpression) ?: 0) } ?: 0,
|
||||||
|
select.where?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
select.groupBy.maxOfOrNull(::maxIndexInExpression) ?: 0,
|
||||||
|
select.groupingSpec?.let(::maxIndexInGroupingSpec) ?: 0,
|
||||||
|
select.having?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
maxIndexInProjection(select.projection),
|
||||||
|
select.orderBy?.let(::maxIndexInOrderBy) ?: 0,
|
||||||
|
select.distinctOn.maxOfOrNull(::maxIndexInExpression) ?: 0
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun maxIndexInGroupingSpec(spec: GroupingSpec): Int = when (spec) {
|
||||||
|
is RollupSpec -> spec.expressions.maxOfOrNull(::maxIndexInExpression) ?: 0
|
||||||
|
is CubeSpec -> spec.expressions.maxOfOrNull(::maxIndexInExpression) ?: 0
|
||||||
|
is GroupingSetsSpec -> spec.sets.maxOfOrNull { set -> set.maxOfOrNull(::maxIndexInExpression) ?: 0 } ?: 0
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun maxIndexInFromItem(item: FromItem): Int = when (item) {
|
||||||
|
is TableSource -> 0
|
||||||
|
is SubquerySource -> maxIndexInQuery(item.select)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun maxIndexInProjection(projection: Projection): Int = when (projection) {
|
||||||
|
StarProjection -> 0
|
||||||
|
is ExpressionProjection -> projection.items.maxOfOrNull { maxIndexInExpression(it.expression) } ?: 0
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun maxIndexInOrderBy(orderBy: OrderBy): Int = orderBy.keys.maxOfOrNull { maxIndexInExpression(it.expression) } ?: 0
|
||||||
|
|
||||||
|
private fun maxIndexInExpression(expression: Expression): Int = when (expression) {
|
||||||
|
is ParameterExpression -> expression.index
|
||||||
|
is ScalarSubqueryExpression -> maxIndexInSelect(expression.select)
|
||||||
|
is ExistsExpression -> maxIndexInSelect(expression.select)
|
||||||
|
is InSubqueryExpression -> maxOf(maxIndexInExpression(expression.operand), maxIndexInSelect(expression.select))
|
||||||
|
is BinaryExpression -> maxOf(maxIndexInExpression(expression.left), maxIndexInExpression(expression.right))
|
||||||
|
is UnaryExpression -> maxIndexInExpression(expression.operand)
|
||||||
|
is CallExpression -> expression.arguments.maxOfOrNull(::maxIndexInExpression) ?: 0
|
||||||
|
is IsNullExpression -> maxIndexInExpression(expression.operand)
|
||||||
|
is InExpression -> maxOf(
|
||||||
|
maxIndexInExpression(expression.operand),
|
||||||
|
expression.values.maxOfOrNull(::maxIndexInExpression) ?: 0
|
||||||
|
)
|
||||||
|
is BetweenExpression -> maxOf(
|
||||||
|
maxIndexInExpression(expression.operand),
|
||||||
|
maxIndexInExpression(expression.low),
|
||||||
|
maxIndexInExpression(expression.high)
|
||||||
|
)
|
||||||
|
is LikeExpression -> maxOf(maxIndexInExpression(expression.operand), maxIndexInExpression(expression.pattern))
|
||||||
|
is CaseExpression -> maxOf(
|
||||||
|
expression.operand?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.branches.maxOfOrNull { maxOf(maxIndexInExpression(it.condition), maxIndexInExpression(it.result)) } ?: 0,
|
||||||
|
expression.elseExpression?.let(::maxIndexInExpression) ?: 0
|
||||||
|
)
|
||||||
|
is CastExpression -> maxIndexInExpression(expression.operand)
|
||||||
|
is CollateExpression -> maxIndexInExpression(expression.operand)
|
||||||
|
is FunctionExpression -> maxOf(
|
||||||
|
expression.argument?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.separator?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.orderBy.maxOfOrNull { maxIndexInExpression(it.expression) } ?: 0,
|
||||||
|
expression.filter?.let(::maxIndexInExpression) ?: 0
|
||||||
|
)
|
||||||
|
is WindowExpression -> maxOf(
|
||||||
|
expression.argument?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.partitionBy.maxOfOrNull(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.orderBy.maxOfOrNull { maxIndexInExpression(it.expression) } ?: 0,
|
||||||
|
expression.offset?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.defaultValue?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.frame?.start?.offset?.let(::maxIndexInExpression) ?: 0,
|
||||||
|
expression.frame?.end?.offset?.let(::maxIndexInExpression) ?: 0
|
||||||
|
)
|
||||||
|
is ColumnExpression, is LiteralExpression, is NextValueExpression, is CurrentValueExpression,
|
||||||
|
is MergeActionExpression -> 0
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in new issue
Block a user