Bound() -> Nested(), etc

Author: xitology

src/link.jl

@@ -14,12 +14,12 @@ struct LinkContext
             Base.ImmutableDict{Tuple{Symbol, Int}, Vector{SQLNode}}(),
             nothing)
 
-    LinkContext(ctx::LinkContext; refs = missing, cte_refs = missing, knot_refs = missing) =
+    LinkContext(ctx::LinkContext; refs = ctx.refs, cte_refs = ctx.cte_refs, knot_refs = ctx.knot_refs) =
         new(ctx.dialect,
             ctx.defs,
-            coalesce(refs, ctx.refs),
-            coalesce(cte_refs, ctx.cte_refs),
-            coalesce(knot_refs, ctx.knot_refs))
+            refs,
+            cte_refs,
+            knot_refs)
 end
 
 function link(n::SQLNode)
@@ -93,9 +93,9 @@ function dismantle_scalar(n::BindNode, ctx)
     BindNode(over = over′, args = args′, label_map = n.label_map)
 end
 
-function dismantle_scalar(n::BoundNode, ctx)
+function dismantle_scalar(n::NestedNode, ctx)
     over′ = dismantle_scalar(n.over, ctx)
-    BoundNode(over = over′, name = n.name)
+    NestedNode(over = over′, name = n.name)
 end
 
 function dismantle(n::DefineNode, ctx)
@@ -219,7 +219,7 @@ end
 function link(n::AsNode, ctx)
     refs = SQLNode[]
     for ref in ctx.refs
-        if @dissect(ref, over |> Bound(name = name))
+        if @dissect(ref, over |> Nested(name = name))
             @assert name == n.name
             push!(refs, over)
         else
@@ -276,13 +276,13 @@ end
 function link(n::FromTableExpressionNode, ctx)
     refs = ctx.cte_refs[(n.name, n.depth)]
     for ref in ctx.refs
-        push!(refs, Bound(over = ref, name = n.name))
+        push!(refs, Nested(over = ref, name = n.name))
     end
     n
 end
 
 function link(n::GroupNode, ctx)
-    has_aggregates = any(ref -> @dissect(ref, Agg() || Agg() |> Bound()), ctx.refs)
+    has_aggregates = any(ref -> @dissect(ref, Agg() || Agg() |> Nested()), ctx.refs)
     if !has_aggregates && isempty(n.by)
         return link(FromNothing(), ctx)
     end
@@ -294,7 +294,7 @@ function link(n::GroupNode, ctx)
     if has_aggregates
         ctx′ = LinkContext(ctx, refs = refs)
         for ref in ctx.refs
-            if (@dissect(ref, nothing |> Agg(args = args, filter = filter) |> Bound(name = name)) && name === n.name) ||
+            if (@dissect(ref, nothing |> Agg(args = args, filter = filter) |> Nested(name = name)) && name === n.name) ||
                (@dissect(ref, nothing |> Agg(args = args, filter = filter)) && n.name === nothing)
                 gather!(args, ctx′)
                 if filter !== nothing
@@ -353,7 +353,7 @@ function link(n::IterateNode, ctx)
 end
 
 function route(r::JoinRouter, ref::SQLNode)
-    if @dissect(ref, over |> Bound(name = name)) && name in r.label_set
+    if @dissect(ref, over |> Nested(name = name)) && name in r.label_set
         return 1
     end
     if @dissect(ref, Get(name = name)) && name in r.label_set
@@ -418,7 +418,7 @@ function link(n::PartitionNode, ctx)
     ctx′ = LinkContext(ctx, refs = imm_refs)
     has_aggregates = false
     for ref in ctx.refs
-        if (@dissect(ref, nothing |> Agg(args = args, filter = filter) |> Bound(name = name)) && name === n.name) ||
+        if (@dissect(ref, nothing |> Agg(args = args, filter = filter) |> Nested(name = name)) && name === n.name) ||
             (@dissect(ref, nothing |> Agg(args = args, filter = filter)) && n.name === nothing)
             gather!(args, ctx′)
             if filter !== nothing
@@ -526,7 +526,7 @@ gather!(n::AbstractSQLNode, ctx) =
 gather!(n, ctx, refs) =
     gather!(n, LinkContext(ctx, refs = refs))
 
-function gather!(n::Union{AggregateNode, GetNode, BoundNode}, ctx)
+function gather!(n::Union{AggregateNode, GetNode, NestedNode}, ctx)
     push!(ctx.refs, n)
     nothing
 end

src/nodes.jl

@@ -460,8 +460,8 @@ struct TransliterateContext
     TransliterateContext(mod::Module, src::LineNumberNode, decl::Bool = false) =
         new(mod, src, decl)
 
-    TransliterateContext(ctx::TransliterateContext; src = missing, decl = missing) =
-        new(ctx.mod, coalesce(src, ctx.src), coalesce(decl, ctx.decl))
+    TransliterateContext(ctx::TransliterateContext; src = ctx.src, decl = ctx.decl) =
+        new(ctx.mod, src, decl)
 end
 
 """

src/nodes/internal.jl

@@ -86,23 +86,23 @@ function PrettyPrinting.quoteof(n::LinkedNode, ctx::QuoteContext)
     ex
 end
 
-# Get(over = Get(:a), name = :b) => Bound(over = Get(:b), name = :a)
-mutable struct BoundNode <: AbstractSQLNode
+# Get(over = Get(:a), name = :b) => Nested(over = Get(:b), name = :a)
+mutable struct NestedNode <: AbstractSQLNode
     over::SQLNode
     name::Symbol
 
-    BoundNode(; over, name) =
+    NestedNode(; over, name) =
         new(over, name)
 end
 
-Bound(args...; kws...) =
-    BoundNode(args...; kws...) |> SQLNode
+Nested(args...; kws...) =
+    NestedNode(args...; kws...) |> SQLNode
 
-dissect(scr::Symbol, ::typeof(Bound), pats::Vector{Any}) =
-    dissect(scr, BoundNode, pats)
+dissect(scr::Symbol, ::typeof(Nested), pats::Vector{Any}) =
+    dissect(scr, NestedNode, pats)
 
-PrettyPrinting.quoteof(n::BoundNode, ctx::QuoteContext) =
-    Expr(:call, nameof(Bound), Expr(:kw, :over, quoteof(n.over, ctx)), Expr(:kw, :name, QuoteNode(n.name)))
+PrettyPrinting.quoteof(n::NestedNode, ctx::QuoteContext) =
+    Expr(:call, nameof(Nested), Expr(:kw, :over, quoteof(n.over, ctx)), Expr(:kw, :name, QuoteNode(n.name)))
 
 # A generic From node is specialized to FromNothing, FromTable,
 # FromTableExpression, FromKnot, FromValues, or FromFunction.

src/resolve.jl

@@ -20,17 +20,17 @@ struct ResolveContext
 
     ResolveContext(
             ctx::ResolveContext;
-            row_type = missing,
-            cte_types = missing,
-            knot_type = missing,
-            implicit_knot = missing) =
+            row_type = ctx.row_type,
+            cte_types = ctx.cte_types,
+            knot_type = ctx.knot_type,
+            implicit_knot = ctx.implicit_knot) =
         new(ctx.dialect,
             ctx.tables,
             ctx.path,
-            coalesce(row_type, ctx.row_type),
-            coalesce(cte_types, ctx.cte_types),
-            coalesce(knot_type, ctx.knot_type),
-            coalesce(implicit_knot, ctx.implicit_knot))
+            row_type,
+            cte_types,
+            knot_type,
+            implicit_knot)
 end
 
 get_path(ctx::ResolveContext) =
@@ -100,9 +100,9 @@ function resolve_scalar(n::TabularNode, ctx)
     Resolved(ScalarType(), over = n′)
 end
 
-function rebind(node, base, ctx)
+function unnest(node, base, ctx)
     while @dissect(node, over |> Get(name = name))
-        base = Bound(over = base, name = name)
+        base = Nested(over = base, name = name)
         node = over
     end
     if node !== nothing
@@ -113,7 +113,7 @@ end
 
 function resolve_scalar(n::AggregateNode, ctx)
     if n.over !== nothing
-        n′ = rebind(n.over, Agg(name = n.name, args = n.args, filter = n.filter), ctx)
+        n′ = unnest(n.over, Agg(name = n.name, args = n.args, filter = n.filter), ctx)
         return resolve_scalar(n′, ctx)
     end
     t = ctx.row_type.group
@@ -179,7 +179,7 @@ function resolve_scalar(n::BindNode, ctx)
     Resolved(type(over′), over = n′)
 end
 
-function resolve_scalar(n::BoundNode, ctx)
+function resolve_scalar(n::NestedNode, ctx)
     t = get(ctx.row_type.fields, n.name, EmptyType())
     if !(t isa RowType)
         error_type =
@@ -189,7 +189,7 @@ function resolve_scalar(n::BoundNode, ctx)
         throw(ReferenceError(error_type, name = n.name, path = get_path(ctx)))
     end
     over′ = resolve_scalar(n.over, ctx, t)
-    n′ = BoundNode(over = over′, name = n.name)
+    n′ = NestedNode(over = over′, name = n.name)
     Resolved(type(over′), over = n′)
 end
 
@@ -284,7 +284,7 @@ end
 
 function resolve_scalar(n::GetNode, ctx)
     if n.over !== nothing
-        n′ = rebind(n.over, Get(name = n.name), ctx)
+        n′ = unnest(n.over, Get(name = n.name), ctx)
         return resolve_scalar(n′, ctx)
     end
     t = get(ctx.row_type.fields, n.name, EmptyType())

src/translate.jl

@@ -160,17 +160,17 @@ struct TranslateContext
             Dict{Symbol, SQLClause}(),
             Dict{Int, SQLClause}())
 
-    function TranslateContext(ctx::TranslateContext; cte_map = missing, knot = missing, refs = missing, vars = missing, subs = missing)
+    function TranslateContext(ctx::TranslateContext; cte_map = ctx.cte_map, knot = ctx.knot, refs = ctx.refs, vars = ctx.vars, subs = ctx.subs)
         new(ctx.dialect,
             ctx.defs,
             ctx.aliases,
             ctx.recursive,
             ctx.ctes,
-            coalesce(cte_map, ctx.cte_map),
-            coalesce(knot, ctx.knot),
-            coalesce(refs, ctx.refs),
-            coalesce(vars, ctx.vars),
-            coalesce(subs, ctx.subs))
+            cte_map,
+            knot,
+            refs,
+            vars,
+            subs)
     end
 end
 
@@ -390,7 +390,7 @@ end
 function assemble(n::AsNode, ctx)
     refs′ = SQLNode[]
     for ref in ctx.refs
-        if @dissect(ref, over |> Bound())
+        if @dissect(ref, over |> Nested())
             push!(refs′, over)
         else
             push!(refs′, ref)
@@ -399,7 +399,7 @@ function assemble(n::AsNode, ctx)
     base = assemble(n.over, TranslateContext(ctx, refs = refs′))
     repl′ = Dict{SQLNode, Symbol}()
     for ref in ctx.refs
-        if @dissect(ref, over |> Bound())
+        if @dissect(ref, over |> Nested())
             repl′[ref] = base.repl[over]
         else
             repl′[ref] = base.repl[ref]
@@ -491,7 +491,7 @@ assemble(::FromNothingNode, ctx) =
 function unwrap_repl(a::Assemblage)
     repl′ = Dict{SQLNode, Symbol}()
     for (ref, name) in a.repl
-        @dissect(ref, over |> Bound()) || error()
+        @dissect(ref, over |> Nested()) || error()
         repl′[over] = name
     end
     Assemblage(a.name, a.clause, cols = a.cols, repl = repl′)
@@ -592,7 +592,7 @@ function assemble(n::FromValuesNode, ctx)
 end
 
 function assemble(n::GroupNode, ctx)
-    has_aggregates = any(ref -> @dissect(ref, Agg() || Agg() |> Bound()), ctx.refs)
+    has_aggregates = any(ref -> @dissect(ref, Agg() || Agg() |> Nested()), ctx.refs)
     if isempty(n.by) && !has_aggregates
         return assemble(nothing, ctx)
     end
@@ -612,7 +612,7 @@ function assemble(n::GroupNode, ctx)
             push!(trns, ref => by[n.label_map[name]])
         elseif @dissect(ref, nothing |> Agg())
             push!(trns, ref => translate(ref, ctx, subs))
-        elseif @dissect(ref, (over := nothing |> Agg()) |> Bound())
+        elseif @dissect(ref, (over := nothing |> Agg()) |> Nested())
             push!(trns, ref => translate(over, ctx, subs))
         end
     end
@@ -852,7 +852,7 @@ function assemble(n::PartitionNode, ctx)
         if @dissect(ref, nothing |> Agg()) && n.name === nothing
             push!(trns, ref => partition |> translate(ref, ctx′))
             has_aggregates = true
-        elseif @dissect(ref, (over := nothing |> Agg()) |> Bound(name = name)) && name === n.name
+        elseif @dissect(ref, (over := nothing |> Agg()) |> Nested(name = name)) && name === n.name
             push!(trns, ref => partition |> translate(over, ctx′))
             has_aggregates = true
         else