sql: change TransformExpressions signature to return (sql.Node, error) and make Expressioners nodes immutable

Signed-off-by: Manuel Carmona <[email protected]>

Author: mcarmonaa

sql/analyzer/rules.go

@@ -824,7 +824,7 @@ func resolveGetFieldIndexes(ctx *sql.Context, a *Analyzer, node sql.Node) (sql.N
 			return n, nil
 		}
 
-		err := expressioner.TransformExpressions(func(e sql.Expression) (sql.Expression, error) {
+		return expressioner.TransformExpressions(func(e sql.Expression) (sql.Expression, error) {
 			a.Log("transforming expression of type: %T", e)
 			if !e.Resolved() {
 				return e, nil
@@ -866,7 +866,5 @@ func resolveGetFieldIndexes(ctx *sql.Context, a *Analyzer, node sql.Node) (sql.N
 			a.Log("fixed expression %T for %T", field, n)
 			return fixedField, nil
 		})
-
-		return n, err
 	})
 }

sql/core.go

@@ -113,7 +113,7 @@ type Expressioner interface {
 	// TransformExprssions applies for each expression in this node
 	// the expression's TransformUp method with the given function, and
 	// replace those expressions with the resultant expressions.
-	TransformExpressions(TransformExprFunc) error
+	TransformExpressions(TransformExprFunc) (Node, error)
 }
 
 // Table represents a SQL table.

sql/plan/filter.go

@@ -73,14 +73,13 @@ func (p *Filter) Expressions() []sql.Expression {
 }
 
 // TransformExpressions implements the Expressioner interface.
-func (p *Filter) TransformExpressions(f sql.TransformExprFunc) error {
+func (p *Filter) TransformExpressions(f sql.TransformExprFunc) (sql.Node, error) {
 	expression, err := p.Expression.TransformUp(f)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	p.Expression = expression
-	return nil
+	return NewFilter(expression, p.Child), nil
 }
 
 // FilterIter is an iterator that filters another iterator and skips rows that

sql/plan/group_by.go

@@ -138,20 +138,18 @@ func (p *GroupBy) Expressions() []sql.Expression {
 }
 
 // TransformExpressions implements the Expressioner interface.
-func (p *GroupBy) TransformExpressions(f sql.TransformExprFunc) error {
+func (p *GroupBy) TransformExpressions(f sql.TransformExprFunc) (sql.Node, error) {
 	agg, err := transformExpressionsUp(f, p.Aggregate)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	group, err := transformExpressionsUp(f, p.Grouping)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	p.Aggregate = agg
-	p.Grouping = group
-	return nil
+	return NewGroupBy(agg, group, p.Child), nil
 }
 
 type groupByIter struct {

sql/plan/innerjoin.go

@@ -119,12 +119,11 @@ func (j *InnerJoin) Expressions() []sql.Expression {
 }
 
 // TransformExpressions implements the Expressioner interface.
-func (j *InnerJoin) TransformExpressions(f sql.TransformExprFunc) error {
+func (j *InnerJoin) TransformExpressions(f sql.TransformExprFunc) (sql.Node, error) {
 	cond, err := j.Cond.TransformUp(f)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	j.Cond = cond
-	return nil
+	return NewInnerJoin(j.Left, j.Right, cond), nil
 }

sql/plan/project.go

@@ -110,14 +110,13 @@ func (p *Project) Expressions() []sql.Expression {
 }
 
 // TransformExpressions implements the Expressioner interface.
-func (p *Project) TransformExpressions(f sql.TransformExprFunc) error {
+func (p *Project) TransformExpressions(f sql.TransformExprFunc) (sql.Node, error) {
 	projects, err := transformExpressionsUp(f, p.Projections)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	p.Projections = projects
-	return nil
+	return NewProject(projects, p.Child), nil
 }
 
 type iter struct {

sql/plan/pushdown.go

@@ -169,18 +169,20 @@ func (t *PushdownProjectionAndFiltersTable) Expressions() []sql.Expression {
 }
 
 // TransformExpressions implements the Expressioner interface.
-func (t *PushdownProjectionAndFiltersTable) TransformExpressions(f sql.TransformExprFunc) error {
+func (t *PushdownProjectionAndFiltersTable) TransformExpressions(f sql.TransformExprFunc) (sql.Node, error) {
 	cols, err := transformExpressionsUp(f, t.Columns)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	filters, err := transformExpressionsUp(f, t.Filters)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	t.Columns = cols
-	t.Filters = filters
-	return nil
+	return NewPushdownProjectionAndFiltersTable(
+		cols,
+		filters,
+		t.PushdownProjectionAndFiltersTable,
+	), nil
 }

sql/plan/sort.go

@@ -142,25 +142,21 @@ func (s *Sort) Expressions() []sql.Expression {
 }
 
 // TransformExpressions implements the Expressioner interface.
-func (s *Sort) TransformExpressions(f sql.TransformExprFunc) error {
-	var cols = make([]sql.Expression, len(s.SortFields))
-	for i, sortField := range s.SortFields {
-		transformed, err := sortField.Column.TransformUp(f)
+func (s *Sort) TransformExpressions(f sql.TransformExprFunc) (sql.Node, error) {
+	var sortFields = make([]SortField, len(s.SortFields))
+	for i, field := range s.SortFields {
+		transformed, err := field.Column.TransformUp(f)
 		if err != nil {
-			return err
+			return nil, err
 		}
-		cols[i] = transformed
-	}
-
-	for i, f := range s.SortFields {
-		s.SortFields[i] = SortField{
-			Column:       cols[i],
-			Order:        f.Order,
-			NullOrdering: f.NullOrdering,
+		sortFields[i] = SortField{
+			Column:       transformed,
+			Order:        field.Order,
+			NullOrdering: field.NullOrdering,
 		}
 	}
 
-	return nil
+	return NewSort(sortFields, s.Child), nil
 }
 
 type sortIter struct {

sql/plan/values.go

@@ -109,16 +109,15 @@ func (p *Values) Expressions() []sql.Expression {
 }
 
 // TransformExpressions implements the Expressioner interface.
-func (p *Values) TransformExpressions(f sql.TransformExprFunc) error {
+func (p *Values) TransformExpressions(f sql.TransformExprFunc) (sql.Node, error) {
 	tuples := [][]sql.Expression{}
 	for _, tuple := range p.ExpressionTuples {
 		transformed, err := transformExpressionsUp(f, tuple)
 		if err != nil {
-			return err
+			return nil, err
 		}
 		tuples = append(tuples, transformed)
 	}
 
-	p.ExpressionTuples = tuples
-	return nil
+	return NewValues(tuples), nil
 }