Add a vector of output columns to the generated SQLString

Author: xitology

docs/src/test/nodes.md

@@ -3945,7 +3945,8 @@ On the next stage, the query object is converted to a SQL syntax tree.
     │                     ID(:visit_group_1) |> ID(:person_id)),
     │                 left = true) |>
     │            SELECT(ID(:person_2) |> ID(:person_id),
-    │                   ID(:visit_group_1) |> ID(:max) |> AS(:max_visit_start_date)))
+    │                   ID(:visit_group_1) |> ID(:max) |> AS(:max_visit_start_date)),
+    │     columns = [SQLColumn(:person_id), SQLColumn(:max_visit_start_date)])
     └ @ FunSQL …
     =#
 
@@ -3980,6 +3981,7 @@ Finally, the SQL tree is serialized into SQL.
     │         "visit_occurrence_1"."person_id"
     │       FROM "visit_occurrence" AS "visit_occurrence_1"
     │       GROUP BY "visit_occurrence_1"."person_id"
-    │     ) AS "visit_group_1" ON ("person_2"."person_id" = "visit_group_1"."person_id")""")
+    │     ) AS "visit_group_1" ON ("person_2"."person_id" = "visit_group_1"."person_id")""",
+    │     columns = [SQLColumn(:person_id), SQLColumn(:max_visit_start_date)])
     └ @ FunSQL …
     =#

docs/src/test/other.md

@@ -343,6 +343,15 @@ A completely custom dialect can be specified.
     String(sql)
     #-> "SELECT * FROM person"
 
+`SQLString` may carry a vector `columns` describing the output columns of
+the query.
+
+    sql = SQLString("SELECT person_id FROM person", columns = [SQLColumn(:person_id)])
+    #-> SQLString("SELECT person_id FROM person", columns = […1 column…])
+
+    display(sql)
+    #-> SQLString("SELECT person_id FROM person", columns = [SQLColumn(:person_id)])
+
 When the query has parameters, `SQLString` should include a vector of
 parameter names in the order they should appear in `DBInterface.execute` call.
 

src/FunSQL.jl

@@ -96,10 +96,10 @@ end
 
 include("dissect.jl")
 include("quote.jl")
-include("strings.jl")
 include("dialects.jl")
 include("types.jl")
 include("catalogs.jl")
+include("strings.jl")
 include("clauses.jl")
 include("nodes.jl")
 include("connections.jl")

src/clauses/internal.jl

@@ -5,9 +5,10 @@
 mutable struct WithContextClause <: AbstractSQLClause
     over::SQLClause
     dialect::SQLDialect
+    columns::Union{Vector{SQLColumn}, Nothing}
 
-    WithContextClause(; over, dialect) =
-        new(over, dialect)
+    WithContextClause(; over, dialect, columns = nothing) =
+        new(over, dialect, columns)
 end
 
 WITH_CONTEXT(args...; kws...) =
@@ -21,5 +22,8 @@ function PrettyPrinting.quoteof(c::WithContextClause, ctx::QuoteContext)
     if c.dialect !== default_dialect
         push!(ex.args, Expr(:kw, :dialect, quoteof(c.dialect)))
     end
+    if c.columns !== nothing
+        push!(ex.args, Expr(:kw, :columns, Expr(:vect, Any[quoteof(col) for col in c.columns]...)))
+    end
     ex
 end

src/serialize.jl

@@ -12,11 +12,11 @@ mutable struct SerializeContext <: IO
 end
 
 function serialize(c::SQLClause)
-    @dissect(c, WITH_CONTEXT(over = c′, dialect = dialect)) || throw(IllFormedError())
+    @dissect(c, WITH_CONTEXT(over = c′, dialect = dialect, columns = columns)) || throw(IllFormedError())
     ctx = SerializeContext(dialect)
     serialize!(c′, ctx)
     raw = String(take!(ctx.io))
-    SQLString(raw, vars = ctx.vars)
+    SQLString(raw, columns = columns, vars = ctx.vars)
 end
 
 Base.write(ctx::SerializeContext, octet::UInt8) =

src/strings.jl

@@ -1,10 +1,12 @@
 # Serialized SQL query with parameter mapping.
 
 """
-    SQLString(raw, vars = Symbol[])
+    SQLString(raw; columns = nothing, vars = Symbol[])
 
 Serialized SQL query.
 
+Parameter `columns` is a vector describing the output columns.
+
 Parameter `vars` is a vector of query parameters (created with [`Var`](@ref))
 in the order they are expected by the `DBInterface.execute()` function.
 
@@ -20,7 +22,8 @@ SQLString(\"""
           SELECT
             "person_1"."person_id",
             "person_1"."year_of_birth"
-          FROM "person" AS "person_1\\"\""")
+          FROM "person" AS "person_1\\"\""",
+          columns = [SQLColumn(:person_id), SQLColumn(:year_of_birth)])
 
 julia> q = From(person) |> Where(Fun.and(Get.year_of_birth .>= Var.YEAR,
                                          Get.year_of_birth .< Var.YEAR .+ 10));
@@ -34,6 +37,7 @@ SQLString(\"""
           WHERE
             (`person_1`.`year_of_birth` >= ?) AND
             (`person_1`.`year_of_birth` < (? + 10))\""",
+          columns = [SQLColumn(:person_id), SQLColumn(:year_of_birth)],
           vars = [:YEAR, :YEAR])
 
 julia> render(q, dialect = :postgresql)
@@ -45,15 +49,17 @@ SQLString(\"""
           WHERE
             ("person_1"."year_of_birth" >= \$1) AND
             ("person_1"."year_of_birth" < (\$1 + 10))\""",
+          columns = [SQLColumn(:person_id), SQLColumn(:year_of_birth)],
           vars = [:YEAR])
 ```
 """
 struct SQLString <: AbstractString
     raw::String
+    columns::Union{Vector{SQLColumn}, Nothing}
     vars::Vector{Symbol}
 
-    SQLString(raw; vars = Symbol[]) =
-        new(raw, vars)
+    SQLString(raw; columns = nothing, vars = Symbol[]) =
+        new(raw, columns, vars)
 end
 
 Base.ncodeunits(sql::SQLString) =
@@ -82,6 +88,9 @@ Base.write(io::IO, sql::SQLString) =
 
 function PrettyPrinting.quoteof(sql::SQLString)
     ex = Expr(:call, nameof(SQLString), sql.raw)
+    if sql.columns !== nothing
+        push!(ex.args, Expr(:kw, :columns, Expr(:vect, Any[quoteof(col) for col in sql.columns]...)))
+    end
     if !isempty(sql.vars)
         push!(ex.args, Expr(:kw, :vars, quoteof(sql.vars)))
     end
@@ -91,6 +100,11 @@ end
 function Base.show(io::IO, sql::SQLString)
     print(io, "SQLString(")
     show(io, sql.raw)
+    if sql.columns !== nothing
+        print(io, ", columns = ")
+        l = length(sql.columns)
+        print(io, l == 0 ? "[]" : l == 1 ? "[…1 column…]" : "[…$l columns…]")
+    end
     if !isempty(sql.vars)
         print(io, ", vars = ")
         show(io, sql.vars)

src/translate.jl

@@ -184,9 +184,14 @@ function allocate_alias(ctx::TranslateContext, alias::Symbol)
 end
 
 function translate(n::SQLNode)
-    @dissect(n, WithContext(over = n′, catalog = catalog, defs = defs)) || throw(IllFormedError())
+    @dissect(n, WithContext(over = Linked(over = n′, refs = refs), catalog = catalog, defs = defs)) || throw(IllFormedError())
     ctx = TranslateContext(catalog = catalog, defs = defs)
-    c = translate(n′, ctx)
+    base = assemble(n′, TranslateContext(ctx, refs = refs))
+    columns = nothing
+    if !isempty(base.cols)
+        columns = [SQLColumn(col) for col in keys(base.cols)]
+    end
+    c = complete(base)
     with_args = SQLClause[]
     for cte_a in ctx.ctes
         !cte_a.external || continue
@@ -205,7 +210,7 @@ function translate(n::SQLNode)
     if !isempty(with_args)
         c = WITH(over = c, args = with_args, recursive = ctx.recursive[])
     end
-    WITH_CONTEXT(over = c, dialect = ctx.catalog.dialect)
+    WITH_CONTEXT(over = c, dialect = ctx.catalog.dialect, columns = columns)
 end
 
 function translate(n::SQLNode, ctx)