|
1 | 1 | package io.getquill.sql.norm |
2 | 2 |
|
3 | 3 | import io.getquill.NamingStrategy |
4 | | -import io.getquill.ast.{Property, Renameable} |
5 | | -import io.getquill.context.sql.{FlattenSqlQuery, SelectValue} |
| 4 | +import io.getquill.ast.Ast.LeafQuat |
| 5 | +import io.getquill.ast.{Ast, CollectAst, Ident, Property, Renameable} |
| 6 | +import io.getquill.context.sql.{FlatJoinContext, FlattenSqlQuery, FromContext, InfixContext, JoinContext, QueryContext, SelectValue, TableContext} |
| 7 | +import io.getquill.norm.{BetaReduction, TypeBehavior} |
| 8 | +import io.getquill.quat.Quat |
| 9 | + |
| 10 | +// If we run this right after SqlQuery we know that in every place with a single select-value it is a leaf clause e.g. `SELECT x FROM (SELECT p.name from Person p)) AS x` |
| 11 | +// in that case we know that SelectValue(x) is a leaf clause that we should expand into a `x.value`. |
| 12 | +// MAKE SURE THIS RUNS BEFORE ExpandNestedQueries otherwise it will be incorrect, it should only run for single-selects from atomic values, |
| 13 | +// if the ExpandNestedQueries ran it could be a single field that is coming from a case class e.g. case class MySingleValue(stuff: Int) that is being selected from |
| 14 | +case class ValueizeSingleLeafSelects(strategy: NamingStrategy) extends StatelessQueryTransformer { |
| 15 | + protected def productize(ast: Ident) = |
| 16 | + Ident(ast.name, Quat.Product("<Value>", "value" -> Quat.Value)) |
| 17 | + |
| 18 | + protected def valueize(ast: Ident) = |
| 19 | + Property(productize(ast), "value") |
| 20 | + |
| 21 | + // Turn every `SELECT primitive-x` into a `SELECT case-class-x.primitive-value` |
| 22 | + override protected def expandNested(q: FlattenSqlQuery, level: QueryLevel): FlattenSqlQuery = { |
| 23 | + // get the alises before we transform (i.e. Valueize) the contexts inside turning the leaf-quat alises into product-quat alises |
| 24 | + val fromContextAliases = collectAliases(q.from).filter(!_.quat.isProduct) |
| 25 | + // now transform the inner clauses |
| 26 | + val from = q.from.map(expandContext(_)) |
| 27 | + |
| 28 | + def containsAlias(ast: Ast): Boolean = |
| 29 | + CollectAst.byType[Ident](ast).exists(id => fromContextAliases.contains(id)) |
| 30 | + |
| 31 | + // If there is one single select clause that has a primitive (i.e. Leaf) quat then we can alias it to "value" |
| 32 | + // This is the case of `SELECT primitive FROM (SELECT p.age from Person p) AS primitive` |
| 33 | + // where we turn it into `SELECT p.name AS value FROM Person p` |
| 34 | + def aliasSelects(selectValues: List[SelectValue]) = |
| 35 | + selectValues match { |
| 36 | + case List(sv @ SelectValue(LeafQuat(ast), _, _)) => List(sv.copy(alias = Some("value"))) |
| 37 | + case other => other |
| 38 | + } |
| 39 | + |
| 40 | + val valuizedQuery = |
| 41 | + q.copy(from = from)(q.quat).mapAsts { ast => |
| 42 | + if (containsAlias(ast)) { |
| 43 | + val reductions = CollectAst.byType[Ident](ast).filter(id => fromContextAliases.contains(id)).map(id => id -> valueize(id)) |
| 44 | + BetaReduction(ast, TypeBehavior.ReplaceWithReduction, reductions: _*) |
| 45 | + } else { |
| 46 | + ast |
| 47 | + } |
| 48 | + } |
| 49 | + |
| 50 | + valuizedQuery.copy(select = aliasSelects(valuizedQuery.select))(q.quat) |
| 51 | + } |
| 52 | + |
| 53 | + // Turn every `FROM primitive-x` into a `FROM case-class(x.primitive)` |
| 54 | + override protected def expandContext(s: FromContext): FromContext = |
| 55 | + super.expandContext(s) match { |
| 56 | + case QueryContext(query, LeafQuat(id: Ident)) => |
| 57 | + QueryContext(query, productize(id)) |
| 58 | + case other => |
| 59 | + other |
| 60 | + } |
| 61 | + |
| 62 | + // protected def expandContext(s: FromContext): FromContext = |
| 63 | + // s match { |
| 64 | + // case QueryContext(q, alias) => |
| 65 | + // QueryContext(apply(q, QueryLevel.Inner), alias) |
| 66 | + // case JoinContext(t, a, b, on) => |
| 67 | + // JoinContext(t, expandContext(a), expandContext(b), on) |
| 68 | + // case FlatJoinContext(t, a, on) => |
| 69 | + // FlatJoinContext(t, expandContext(a), on) |
| 70 | + // case _: TableContext | _: InfixContext => s |
| 71 | + // } |
| 72 | + |
| 73 | + private def collectAliases(contexts: List[FromContext]): List[Ident] = |
| 74 | + contexts.flatMap { |
| 75 | + case c: TableContext => List(c.alias) |
| 76 | + case c: QueryContext => List(c.alias) |
| 77 | + case c: InfixContext => List(c.alias) |
| 78 | + case JoinContext(_, a, b, _) => collectAliases(List(a)) ++ collectAliases(List(b)) |
| 79 | + case FlatJoinContext(_, from, _) => collectAliases(List(from)) |
| 80 | + } |
| 81 | +} |
6 | 82 |
|
7 | 83 | /** |
8 | 84 | * Remove aliases at the top level of the AST since they are not needed (quill |
|
0 commit comments