[binder] hoist projections in certain cases where we can combine with top-level projection (#2813)

* [binder] hoist projections in certain cases where we can combine with top-level projection

* fix plans

* doc comment

* fix build

* better comment

Author: max-hoffman

enginetest/queries/integration_plans.go

@@ -28,6 +28,7 @@ type Project struct {
 	UnaryNode
 	Projections []sql.Expression
 	CanDefer    bool
+	deps        sql.ColSet
 }
 
 var _ sql.Expressioner = (*Project)(nil)
@@ -94,6 +95,25 @@ func unwrapGetField(expr sql.Expression) *expression.GetField {
 	}
 }
 
+// ExprDeps returns a column set of the ids referenced
+// in this list of expressions.
+func ExprDeps(exprs ...sql.Expression) sql.ColSet {
+	var deps sql.ColSet
+	for _, e := range exprs {
+		sql.Inspect(e, func(e sql.Expression) bool {
+			switch e := e.(type) {
+			case sql.IdExpression:
+				deps.Add(e.Id())
+			case *Subquery:
+				deps.Union(e.Correlated())
+			default:
+			}
+			return true
+		})
+	}
+	return deps
+}
+
 // Schema implements the Node interface.
 func (p *Project) Schema() sql.Schema {
 	var s = make(sql.Schema, len(p.Projections))

enginetest/queries/query_plans.go

@@ -220,3 +220,33 @@ func (f *factory) buildDistinct(child sql.Node) sql.Node {
 	}
 	return plan.NewDistinct(child)
 }
+
+func (f *factory) buildSort(child sql.Node, exprs []sql.SortField, deps sql.ColSet, subquery bool) (sql.Node, error) {
+	{
+		// The default binder behavior adds a projection before and after
+		// sort nodes for alias dependency correctness. In many cases the sort
+		// does not reference an alias, and it is beneficial to hoist the inner
+		// projection which lets the optimizer (1) remove redundant projcetions
+		// and usually (2) more aggressively prune table columns.
+		// (proj ->) sort -> proj -> child
+		// =>
+		// (proj ->) proj -> sort -> child
+		// =>
+		// (proj ->) sort -> child
+		if p, ok := child.(*plan.Project); ok {
+			var aliases []sql.Expression
+			for _, p := range p.Projections {
+				if _, ok := p.(*expression.Alias); ok {
+					aliases = append(aliases, p)
+				}
+			}
+			aliasCols := plan.ExprDeps(aliases...)
+			if !aliasCols.Intersects(deps) {
+				newP := plan.NewProject(p.Projections, plan.NewSort(exprs, p.Child))
+				return f.buildProject(newP, subquery)
+			}
+		}
+	}
+
+	return plan.NewSort(exprs, child), nil
+}

enginetest/queries/tpch_plans.go

@@ -22,7 +22,6 @@ import (
 
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
-	"github.com/dolthub/go-mysql-server/sql/plan"
 	"github.com/dolthub/go-mysql-server/sql/transform"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
@@ -199,6 +198,7 @@ func (b *Builder) buildOrderBy(inScope, orderByScope *scope) {
 		return
 	}
 	var sortFields sql.SortFields
+	var deps sql.ColSet
 	for _, c := range orderByScope.cols {
 		so := sql.Ascending
 		if c.descending {
@@ -213,8 +213,12 @@ func (b *Builder) buildOrderBy(inScope, orderByScope *scope) {
 			Order:  so,
 		}
 		sortFields = append(sortFields, sf)
+		deps.Add(sql.ColumnId(c.id))
+	}
+	sort, err := b.f.buildSort(inScope.node, sortFields, deps, inScope.refsSubquery)
+	if err != nil {
+		b.handleErr(err)
 	}
-	sort := plan.NewSort(sortFields, inScope.node)
 	inScope.node = sort
 	return
 }