sql/analyzer: resolve GetField indexes in the resolveColumns rule

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

Author: mcarmonaa

sql/analyzer/rules.go

@@ -20,7 +20,6 @@ var DefaultRules = []Rule{
 	{"resolve_database", resolveDatabase},
 	{"resolve_star", resolveStar},
 	{"resolve_functions", resolveFunctions},
-	{"resolve_getfield_indexes", resolveGetFieldIndexes},
 	{"reorder_projection", reorderProjection},
 	{"pushdown", pushdown},
 	{"optimize_distinct", optimizeDistinct},
@@ -326,8 +325,6 @@ type column interface {
 	sql.Expression
 }
 
-const unresolvedGetFieldIndex = -1
-
 func resolveColumns(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error) {
 	span, ctx := ctx.Span("resolve_columns")
 	defer span.Finish()
@@ -350,7 +347,12 @@ func resolveColumns(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error)
 			}
 		}
 
-		return n.TransformExpressionsUp(func(e sql.Expression) (sql.Expression, error) {
+		expressioner, ok := n.(sql.Expressioner)
+		if !ok {
+			return n, nil
+		}
+
+		return expressioner.TransformExpressions(func(e sql.Expression) (sql.Expression, error) {
 			a.Log("transforming expression of type: %T", e)
 			if n.Resolved() {
 				return e, nil
@@ -398,10 +400,26 @@ func resolveColumns(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error)
 				}
 			}
 
+			var schema sql.Schema
+			switch n := n.(type) {
+			// If expressioner and unary node we must take the
+			// child's schema to correctly select the indexes
+			// in the row is going to be evaluated in this node
+			case *plan.Project, *plan.Filter, *plan.GroupBy, *plan.Sort:
+				schema = n.Children()[0].Schema()
+			default:
+				schema = n.Schema()
+			}
+
+			idx, ok := schema.Contains(col.Name, col.Source)
+			if !ok {
+				return nil, ErrColumnNotFound.New(col.Name)
+			}
+
 			a.Log("column resolved to %q.%q", col.Source, col.Name)
 
 			return expression.NewGetFieldWithTable(
-				unresolvedGetFieldIndex,
+				idx,
 				col.Type,
 				col.Source,
 				col.Name,
@@ -805,66 +823,3 @@ func fixFieldIndexes(schema sql.Schema, exp sql.Expression) (sql.Expression, err
 		return e, nil
 	})
 }
-
-// resolveGetFieldIndexes set the index attribute for each GetField expression with a value referring to
-// the node containing this expression. It should be run after resolveColumns
-func resolveGetFieldIndexes(ctx *sql.Context, a *Analyzer, node sql.Node) (sql.Node, error) {
-	span, ctx := ctx.Span("fix join fields")
-	defer span.Finish()
-
-	a.Log("fix join fields, node of type: %T", node)
-	return node.TransformUp(func(n sql.Node) (sql.Node, error) {
-		a.Log("transforming node of type: %T", n)
-		if !n.Resolved() {
-			return n, nil
-		}
-
-		expressioner, ok := n.(sql.Expressioner)
-		if !ok {
-			return n, nil
-		}
-
-		return expressioner.TransformExpressions(func(e sql.Expression) (sql.Expression, error) {
-			a.Log("transforming expression of type: %T", e)
-			if !e.Resolved() {
-				return e, nil
-			}
-
-			field, ok := e.(*expression.GetField)
-			if !ok {
-				return e, nil
-			}
-
-			if field.Index() != unresolvedGetFieldIndex {
-				return e, nil
-			}
-
-			var schema sql.Schema
-			switch n := n.(type) {
-			// If expressioner and unary node we must take the
-			// child's schema to correctly select the indexes
-			// in the row is going to be evaluated in this node
-			case *plan.Project, *plan.Filter, *plan.GroupBy, *plan.Sort:
-				schema = n.Children()[0].Schema()
-			default:
-				schema = n.Schema()
-			}
-
-			idx, ok := schema.Contains(field.Name(), field.Table())
-			if !ok {
-				return nil, ErrColumnNotFound.New(field.Name())
-			}
-
-			fixedField := expression.NewGetFieldWithTable(
-				idx,
-				field.Type(),
-				field.Table(),
-				field.Name(),
-				field.IsNullable(),
-			)
-
-			a.Log("fixed expression %T for %T", field, n)
-			return fixedField, nil
-		})
-	})
-}

sql/analyzer/rules_test.go

@@ -472,21 +472,21 @@ func TestReorderProjection(t *testing.T) {
 			expression.NewGetField(1, sql.Int64, "bar", false),
 		},
 		plan.NewSort(
-			[]plan.SortField{{Column: expression.NewGetField(unresolvedGetFieldIndex, sql.Int64, "foo", false)}},
+			[]plan.SortField{{Column: expression.NewGetField(2, sql.Int64, "foo", false)}},
 			plan.NewProject(
 				[]sql.Expression{
-					expression.NewGetFieldWithTable(unresolvedGetFieldIndex, sql.Int64, "mytable", "i", false),
-					expression.NewGetField(unresolvedGetFieldIndex, sql.Int64, "bar", false),
+					expression.NewGetFieldWithTable(0, sql.Int64, "mytable", "i", false),
+					expression.NewGetField(1, sql.Int64, "bar", false),
 					expression.NewAlias(expression.NewLiteral(1, sql.Int64), "foo"),
 				},
 				plan.NewFilter(
 					expression.NewEquals(
 						expression.NewLiteral(1, sql.Int64),
-						expression.NewGetField(unresolvedGetFieldIndex, sql.Int64, "bar", false),
+						expression.NewGetField(1, sql.Int64, "bar", false),
 					),
 					plan.NewProject(
 						[]sql.Expression{
-							expression.NewGetFieldWithTable(unresolvedGetFieldIndex, sql.Int64, "mytable", "i", false),
+							expression.NewGetFieldWithTable(0, sql.Int64, "mytable", "i", false),
 							expression.NewAlias(expression.NewLiteral(2, sql.Int64), "bar"),
 						},
 						table,
@@ -498,6 +498,7 @@ func TestReorderProjection(t *testing.T) {
 
 	result, err := f.Apply(sql.NewEmptyContext(), New(nil), node)
 	require.NoError(err)
+
 	require.Equal(expected, result)
 }
 

sql/plan/filter.go

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