IntAutoDefineNode -> PaddingNode

Author: xitology

src/link.jl

@@ -121,11 +121,6 @@ function dismantle(n::GroupNode, ctx)
     Group(over = over′, by = by′, name = n.name, label_map = n.label_map)
 end
 
-function dismantle(n::IntAutoDefineNode, ctx)
-    over′ = dismantle(n.over, ctx)
-    IntAutoDefine(over = over′)
-end
-
 function dismantle(n::IterateNode, ctx)
     over′ = dismantle(n.over, ctx)
     iterator′ = dismantle(n.iterator, ctx)
@@ -157,6 +152,11 @@ function dismantle(n::OrderNode, ctx)
     Order(over = over′, by = by′)
 end
 
+function dismantle(n::PaddingNode, ctx)
+    over′ = dismantle(n.over, ctx)
+    Padding(over = over′)
+end
+
 function dismantle(n::PartitionNode, ctx)
     over′ = dismantle(n.over, ctx)
     by′ = dismantle_scalar(n.by, ctx)
@@ -308,19 +308,12 @@ function link(n::GroupNode, ctx)
     end
     over = n.over
     if !isempty(n.by)
-        over = IntAutoDefine(over = over)
+        over = Padding(over = over)
     end
     over′ = Linked(refs, 0, over = link(over, ctx, refs))
     Group(over = over′, by = n.by, name = n.name, label_map = n.label_map)
 end
 
-function link(n::IntAutoDefineNode, ctx)
-    refs = SQLNode[]
-    gather!(ctx.refs, ctx, refs)
-    over′ = Linked(refs, 0, over = link(n.over, ctx, refs))
-    IntAutoDefine(over = over′)
-end
-
 function link(n::IterateNode, ctx)
     iterator′ = n.iterator
     defs = copy(ctx.defs)
@@ -349,7 +342,7 @@ function link(n::IterateNode, ctx)
     iterator′ = Linked(refs, over = iterator′)
     over′ = Linked(refs, over = link(n.over, ctx, refs))
     n′ = Linked(refs, over = Iterate(over = over′, iterator = iterator′))
-    IntAutoDefine(over = n′)
+    Padding(over = n′)
 end
 
 function route(r::JoinRouter, ref::SQLNode)
@@ -412,6 +405,13 @@ function link(n::OrderNode, ctx)
     Order(over = over′, by = n.by)
 end
 
+function link(n::PaddingNode, ctx)
+    refs = SQLNode[]
+    gather!(ctx.refs, ctx, refs)
+    over′ = Linked(refs, 0, over = link(n.over, ctx, refs))
+    Padding(over = over′)
+end
+
 function link(n::PartitionNode, ctx)
     refs = SQLNode[]
     imm_refs = SQLNode[]

src/nodes/internal.jl

@@ -263,19 +263,19 @@ function PrettyPrinting.quoteof(n::IntJoinNode, ctx::QuoteContext)
     ex
 end
 
-# Calculates the keys of a Group node.
-mutable struct IntAutoDefineNode <: TabularNode
+# Calculates the keys of a Group node.  Also used by Iterate.
+mutable struct PaddingNode <: TabularNode
     over::Union{SQLNode, Nothing}
 
-    IntAutoDefineNode(; over = nothing) =
+    PaddingNode(; over = nothing) =
         new(over)
 end
 
-IntAutoDefine(args...; kws...) =
-    IntAutoDefineNode(args...; kws...) |> SQLNode
+Padding(args...; kws...) =
+    PaddingNode(args...; kws...) |> SQLNode
 
-function PrettyPrinting.quoteof(n::IntAutoDefineNode, ctx::QuoteContext)
-    ex = Expr(:call, nameof(IntAutoDefine))
+function PrettyPrinting.quoteof(n::PaddingNode, ctx::QuoteContext)
+    ex = Expr(:call, nameof(Padding))
     if n.over !== nothing
         ex = Expr(:call, :|>, quoteof(n.over, ctx), ex)
     end

src/translate.jl

@@ -635,28 +635,6 @@ function assemble(n::GroupNode, ctx)
     return Assemblage(base.name, c, cols = cols, repl = repl)
 end
 
-function assemble(n::IntAutoDefineNode, ctx)
-    base = assemble(n.over, ctx)
-    if isempty(ctx.refs)
-        return base
-    end
-    if !@dissect(base.clause, SELECT() || UNION())
-        base_alias = nothing
-        c = base.clause
-    else
-        base_alias = allocate_alias(ctx, base)
-        c = FROM(AS(over = complete(base), name = base_alias))
-    end
-    subs = make_subs(base, base_alias)
-    repl = Dict{SQLNode, Symbol}()
-    trns = Pair{SQLNode, SQLClause}[]
-    for ref in ctx.refs
-        push!(trns, ref => translate(ref, ctx, subs))
-    end
-    repl, cols = make_repl_cols(trns)
-    Assemblage(base.name, c, cols = cols, repl = repl)
-end
-
 function assemble(n::IntJoinNode, ctx)
     left = assemble(n.over, ctx)
     if @dissect(left.clause, tail := FROM() || JOIN())
@@ -834,6 +812,28 @@ function assemble(n::OrderNode, ctx)
     Assemblage(base.name, c, cols = cols, repl = repl)
 end
 
+function assemble(n::PaddingNode, ctx)
+    base = assemble(n.over, ctx)
+    if isempty(ctx.refs)
+        return base
+    end
+    if !@dissect(base.clause, SELECT() || UNION())
+        base_alias = nothing
+        c = base.clause
+    else
+        base_alias = allocate_alias(ctx, base)
+        c = FROM(AS(over = complete(base), name = base_alias))
+    end
+    subs = make_subs(base, base_alias)
+    repl = Dict{SQLNode, Symbol}()
+    trns = Pair{SQLNode, SQLClause}[]
+    for ref in ctx.refs
+        push!(trns, ref => translate(ref, ctx, subs))
+    end
+    repl, cols = make_repl_cols(trns)
+    Assemblage(base.name, c, cols = cols, repl = repl)
+end
+
 function assemble(n::PartitionNode, ctx)
     base = assemble(n.over, ctx)
     if @dissect(base.clause, tail := nothing || FROM() || JOIN() || WHERE() || GROUP() || HAVING())