Have Sort, Case, and GroupBy implement Describable

Author: nicktobey

sql/expression/case.go

@@ -244,3 +244,27 @@ func (c *Case) DebugString() string {
 	buf.WriteString(" END")
 	return buf.String()
 }
+
+func (c *Case) Describe(options sql.DescribeOptions) string {
+	var buf bytes.Buffer
+
+	buf.WriteString("CASE ")
+	if c.Expr != nil {
+		buf.WriteString(sql.Describe(c.Expr, options))
+	}
+
+	for _, b := range c.Branches {
+		buf.WriteString(" WHEN ")
+		buf.WriteString(sql.Describe(b.Cond, options))
+		buf.WriteString(" THEN ")
+		buf.WriteString(sql.Describe(b.Value, options))
+	}
+
+	if c.Else != nil {
+		buf.WriteString(" ELSE ")
+		buf.WriteString(sql.Describe(c.Else, options))
+	}
+
+	buf.WriteString(" END")
+	return buf.String()
+}

sql/plan/group_by.go

@@ -38,6 +38,7 @@ var _ sql.Expressioner = (*GroupBy)(nil)
 var _ sql.Node = (*GroupBy)(nil)
 var _ sql.Projector = (*GroupBy)(nil)
 var _ sql.CollationCoercible = (*GroupBy)(nil)
+var _ sql.Describable = (*GroupBy)(nil)
 
 // NewGroupBy creates a new GroupBy node. Like Project, GroupBy is a top-level node, and contains all the fields that
 // will appear in the output of the query. Some of these fields may be aggregate functions, some may be columns or
@@ -169,6 +170,28 @@ func (g *GroupBy) DebugString() string {
 	return pr.String()
 }
 
+func (g *GroupBy) Describe(options sql.DescribeOptions) string {
+	pr := sql.NewTreePrinter()
+	_ = pr.WriteNode("GroupBy")
+
+	var selectDeps = make([]string, len(g.SelectDeps))
+	for i, e := range g.SelectDeps {
+		selectDeps[i] = sql.Describe(e, options)
+	}
+
+	var grouping = make([]string, len(g.GroupByExprs))
+	for i, g := range g.GroupByExprs {
+		grouping[i] = sql.Describe(g, options)
+	}
+
+	_ = pr.WriteChildren(
+		fmt.Sprintf("select: %s", strings.Join(selectDeps, ", ")),
+		fmt.Sprintf("group: %s", strings.Join(grouping, ", ")),
+		sql.Describe(g.Child, options),
+	)
+	return pr.String()
+}
+
 // Expressions implements the Expressioner interface.
 func (g *GroupBy) Expressions() []sql.Expression {
 	var exprs []sql.Expression

sql/plan/hash_lookup.go

@@ -60,6 +60,7 @@ type HashLookup struct {
 var _ sql.Node = (*HashLookup)(nil)
 var _ sql.Expressioner = (*HashLookup)(nil)
 var _ sql.CollationCoercible = (*HashLookup)(nil)
+var _ sql.Describable = (*HashLookup)(nil)
 
 func (n *HashLookup) Expressions() []sql.Expression {
 	return []sql.Expression{n.RightEntryKey, n.LeftProbeKey}
@@ -102,6 +103,17 @@ func (n *HashLookup) DebugString() string {
 	return pr.String()
 }
 
+func (n *HashLookup) Describe(options sql.DescribeOptions) string {
+	pr := sql.NewTreePrinter()
+	_ = pr.WriteNode("HashLookup")
+	children := make([]string, 3)
+	children[0] = fmt.Sprintf("left-key: %s", sql.Describe(n.LeftProbeKey, options))
+	children[1] = fmt.Sprintf("right-key: %s", sql.Describe(n.RightEntryKey, options))
+	children[2] = sql.Describe(n.Child, options)
+	_ = pr.WriteChildren(children...)
+	return pr.String()
+}
+
 func (n *HashLookup) WithChildren(children ...sql.Node) (sql.Node, error) {
 	if len(children) != 1 {
 		return nil, sql.ErrInvalidChildrenNumber.New(n, len(children), 1)

sql/plan/sort.go

@@ -44,6 +44,7 @@ var _ sql.Expressioner = (*Sort)(nil)
 var _ sql.Node = (*Sort)(nil)
 var _ sql.CollationCoercible = (*Sort)(nil)
 var _ Sortable = (*Sort)(nil)
+var _ sql.Describable = (*Sort)(nil)
 
 // Resolved implements the Resolvable interface.
 func (s *Sort) Resolved() bool {
@@ -70,6 +71,18 @@ func (s *Sort) String() string {
 	return pr.String()
 }
 
+// Describe implements the sql.Describable interface
+func (s *Sort) Describe(options sql.DescribeOptions) string {
+	pr := sql.NewTreePrinter()
+	var fields = make([]string, len(s.SortFields))
+	for i, f := range s.SortFields {
+		fields[i] = sql.Describe(f, options)
+	}
+	_ = pr.WriteNode("Sort(%s)", strings.Join(fields, ", "))
+	_ = pr.WriteChildren(sql.Describe(s.Child, options))
+	return pr.String()
+}
+
 func (s *Sort) DebugString() string {
 	pr := sql.NewTreePrinter()
 	var fields = make([]string, len(s.SortFields))

sql/plan/subqueryalias.go

@@ -45,6 +45,7 @@ var _ sql.Node = (*SubqueryAlias)(nil)
 var _ sql.CollationCoercible = (*SubqueryAlias)(nil)
 var _ sql.RenameableNode = (*SubqueryAlias)(nil)
 var _ sql.OpaqueNode = (*SubqueryAlias)(nil)
+var _ sql.Describable = (*SubqueryAlias)(nil)
 
 // NewSubqueryAlias creates a new SubqueryAlias node.
 func NewSubqueryAlias(name, textDefinition string, node sql.Node) *SubqueryAlias {
@@ -190,6 +191,21 @@ func (sq *SubqueryAlias) DebugString() string {
 	return pr.String()
 }
 
+func (sq *SubqueryAlias) Describe(options sql.DescribeOptions) string {
+	pr := sql.NewTreePrinter()
+	_ = pr.WriteNode("SubqueryAlias")
+	children := make([]string, 7)
+	children[0] = fmt.Sprintf("name: %s", sq.name)
+	children[1] = fmt.Sprintf("outerVisibility: %t", sq.OuterScopeVisibility)
+	children[2] = fmt.Sprintf("isLateral: %t", sq.IsLateral)
+	children[3] = fmt.Sprintf("cacheable: %t", sq.CanCacheResults())
+	children[4] = fmt.Sprintf("colSet: %s", sq.Columns())
+	children[5] = fmt.Sprintf("tableId: %d", sq.Id())
+	children[6] = sql.Describe(sq.Child, options)
+	_ = pr.WriteChildren(children...)
+	return pr.String()
+}
+
 func (sq *SubqueryAlias) WithColumnNames(columns []string) *SubqueryAlias {
 	ret := *sq
 	ret.ColumnNames = columns