Add Show/Hide combinators

Author: xitology

src/FunSQL.jl

@@ -53,6 +53,7 @@ export
     funsql_from,
     funsql_fun,
     funsql_group,
+    funsql_hide,
     funsql_highlight,
     funsql_in,
     funsql_into,
@@ -81,6 +82,7 @@ export
     funsql_rank,
     funsql_row_number,
     funsql_select,
+    funsql_show,
     funsql_sort,
     funsql_sum,
     funsql_with

src/link.jl

@@ -24,8 +24,10 @@ end
 
 function _select(t::RowType)
     refs = SQLNode[]
+    t.visible || return refs
     for (f, ft) in t.fields
         if ft isa ScalarType
+            ft.visible || continue
             push!(refs, Get(f))
         else
             nested_refs = _select(ft)

src/nodes.jl

@@ -705,6 +705,7 @@ include("nodes/order.jl")
 include("nodes/over.jl")
 include("nodes/partition.jl")
 include("nodes/select.jl")
+include("nodes/show.jl")
 include("nodes/sort.jl")
 include("nodes/variable.jl")
 include("nodes/where.jl")

src/nodes/show.jl

@@ -0,0 +1,47 @@
+# Show/Hide nodes
+
+mutable struct ShowNode <: TabularNode
+    over::Union{SQLNode, Nothing}
+    names::Vector{Symbol}
+    visible::Bool
+    label_map::FunSQL.OrderedDict{Symbol, Int}
+
+    function ShowNode(; over = nothing, names = [], visible = true, label_map = nothing)
+        if label_map !== nothing
+            new(over, names, visible, label_map)
+        else
+            n = new(over, names, visible, FunSQL.OrderedDict{Symbol, Int}())
+            for (i, name) in enumerate(n.names)
+                if name in keys(n.label_map)
+                    err = FunSQL.DuplicateLabelError(name, path = [n])
+                    throw(err)
+                end
+                n.label_map[name] = i
+            end
+            n
+        end
+    end
+end
+
+ShowNode(names...; over = nothing, visible = true) =
+    ShowNode(over = over, names = Symbol[names...], visible = visible)
+
+Show(args...; kws...) =
+    ShowNode(args...; kws...) |> SQLNode
+
+Hide(args...; kws...) =
+    ShowNode(args...; kws..., visible = false) |> SQLNode
+
+const funsql_show = Show
+const funsql_hide = Hide
+
+dissect(scr::Symbol, ::typeof(Show), pats::Vector{Any}) =
+    dissect(scr, ShowNode, pats)
+
+function FunSQL.PrettyPrinting.quoteof(n::ShowNode, ctx::FunSQL.QuoteContext)
+    ex = Expr(:call, nameof(n.visible ? Show : Hide), quoteof(n.names, ctx)...)
+    if n.over !== nothing
+        ex = Expr(:call, :|>, FunSQL.quoteof(n.over, ctx), ex)
+    end
+    ex
+end

src/resolve.jl

@@ -464,6 +464,33 @@ function resolve(n::SelectNode, ctx)
     Resolved(RowType(fields), over = n′)
 end
 
+function resolve(n::ShowNode, ctx)
+    over′ = resolve(n.over, ctx)
+    t = row_type(over′)
+    for name in n.names
+        ft = get(t.fields, name, EmptyType())
+        if ft isa EmptyType
+            throw(
+                ReferenceError(
+                    REFERENCE_ERROR_TYPE.UNDEFINED_NAME,
+                    name = name,
+                    path = get_path(ctx)))
+        end
+    end
+    fields = FieldTypeMap()
+    for (f, ft) in t.fields
+        if f in keys(n.label_map)
+            if ft isa ScalarType
+                ft = ScalarType(visible = n.visible)
+            else
+                ft = RowType(ft.fields, ft.group, visible = n.visible)
+            end
+        end
+        fields[f] = ft
+    end
+    Resolved(RowType(fields, t.group, visible = t.visible), over = over′)
+end
+
 function resolve_scalar(n::SortNode, ctx)
     over′ = resolve_scalar(n.over, ctx)
     n′ = Sort(over = over′, value = n.value, nulls = n.nulls)

src/types.jl

@@ -13,17 +13,27 @@ PrettyPrinting.quoteof(::EmptyType) =
     Expr(:call, nameof(EmptyType))
 
 struct ScalarType <: AbstractSQLType
+    visible::Bool
+
+    ScalarType(; visible = true) =
+        new(visible)
 end
 
-PrettyPrinting.quoteof(::ScalarType) =
-    Expr(:call, nameof(ScalarType))
+function PrettyPrinting.quoteof(::ScalarType)
+    ex = Expr(:call, nameof(ScalarType))
+    if !t.visible
+        push!(ex.args, Expr(:kw, :visible, t.visible))
+    end
+    ex
+end
 
 struct RowType <: AbstractSQLType
     fields::OrderedDict{Symbol, Union{ScalarType, RowType}}
     group::Union{EmptyType, RowType}
+    visible::Bool
 
-    RowType(fields, group = EmptyType()) =
-        new(fields, group)
+    RowType(fields, group = EmptyType(); visible = true) =
+        new(fields, group, visible)
 end
 
 const FieldTypeMap = OrderedDict{Symbol, Union{ScalarType, RowType}}
@@ -43,6 +53,9 @@ function PrettyPrinting.quoteof(t::RowType)
     if !(t.group isa EmptyType)
         push!(ex.args, Expr(:kw, :group, quoteof(t.group)))
     end
+    if !t.visible
+        push!(ex.args, Expr(:kw, :visible, t.visible))
+    end
     ex
 end
 
@@ -54,8 +67,8 @@ const EMPTY_ROW = RowType()
 Base.intersect(::AbstractSQLType, ::AbstractSQLType) =
     EmptyType()
 
-Base.intersect(::ScalarType, ::ScalarType) =
-    ScalarType()
+Base.intersect(t1::ScalarType, t2::ScalarType) =
+    ScalarType(visible = t1.visible || t2.visible)
 
 function Base.intersect(t1::RowType, t2::RowType)
     if t1 === t2
@@ -71,7 +84,7 @@ function Base.intersect(t1::RowType, t2::RowType)
         end
     end
     group = intersect(t1.group, t2.group)
-    RowType(fields, group)
+    RowType(fields, group, visible = t1.visible || t2.visible)
 end
 
 
@@ -98,5 +111,8 @@ function Base.issubset(t1::RowType, t2::RowType)
     if !issubset(t1.group, t2.group)
         return false
     end
+    if !t1.visible && t2.visible
+        return false
+    end
     return true
 end