sql/analyzer: fix ambiguous table after natural join

Signed-off-by: Miguel Molina <[email protected]>
(cherry picked from commit ac92402)

Author: erizocosmico

engine_test.go

@@ -160,29 +160,29 @@ var queries = []struct {
 		},
 	},
 	{
-		"SELECT text > 2 FROM tabletest",
+		"SELECT s > 2 FROM tabletest",
 		[]sql.Row{
 			{false},
 			{false},
 			{false},
 		},
 	},
 	{
-		"SELECT * FROM tabletest WHERE text > 0",
+		"SELECT * FROM tabletest WHERE s > 0",
 		nil,
 	},
 	{
-		"SELECT * FROM tabletest WHERE text = 0",
+		"SELECT * FROM tabletest WHERE s = 0",
 		[]sql.Row{
-			{"a", int32(1)},
-			{"b", int32(2)},
-			{"c", int32(3)},
+			{int64(1), "first row"},
+			{int64(2), "second row"},
+			{int64(3), "third row"},
 		},
 	},
 	{
-		"SELECT * FROM tabletest WHERE text = 'a'",
+		"SELECT * FROM tabletest WHERE s = 'first row'",
 		[]sql.Row{
-			{"a", int32(1)},
+			{int64(1), "first row"},
 		},
 	},
 	{
@@ -211,15 +211,15 @@ var queries = []struct {
 	{
 		`SELECT * FROM tabletest, mytable mt INNER JOIN othertable ot ON mt.i = ot.i2`,
 		[]sql.Row{
-			{"a", int32(1), int64(1), "first row", "third", int64(1)},
-			{"a", int32(1), int64(2), "second row", "second", int64(2)},
-			{"a", int32(1), int64(3), "third row", "first", int64(3)},
-			{"b", int32(2), int64(1), "first row", "third", int64(1)},
-			{"b", int32(2), int64(2), "second row", "second", int64(2)},
-			{"b", int32(2), int64(3), "third row", "first", int64(3)},
-			{"c", int32(3), int64(1), "first row", "third", int64(1)},
-			{"c", int32(3), int64(2), "second row", "second", int64(2)},
-			{"c", int32(3), int64(3), "third row", "first", int64(3)},
+			{int64(1), "first row", int64(1), "first row", "third", int64(1)},
+			{int64(1), "first row", int64(2), "second row", "second", int64(2)},
+			{int64(1), "first row", int64(3), "third row", "first", int64(3)},
+			{int64(2), "second row", int64(1), "first row", "third", int64(1)},
+			{int64(2), "second row", int64(2), "second row", "second", int64(2)},
+			{int64(2), "second row", int64(3), "third row", "first", int64(3)},
+			{int64(3), "third row", int64(1), "first row", "third", int64(1)},
+			{int64(3), "third row", int64(2), "second row", "second", int64(2)},
+			{int64(3), "third row", int64(3), "third row", "first", int64(3)},
 		},
 	},
 	{
@@ -741,15 +741,15 @@ func newEngineWithParallelism(t *testing.T, parallelism int) *sqle.Engine {
 	)
 
 	table3 := mem.NewPartitionedTable("tabletest", sql.Schema{
-		{Name: "text", Type: sql.Text, Source: "tabletest"},
-		{Name: "number", Type: sql.Int32, Source: "tabletest"},
+		{Name: "i", Type: sql.Int32, Source: "tabletest"},
+		{Name: "s", Type: sql.Text, Source: "tabletest"},
 	}, testNumPartitions)
 
 	insertRows(
 		t, table3,
-		sql.NewRow("a", int32(1)),
-		sql.NewRow("b", int32(2)),
-		sql.NewRow("c", int32(3)),
+		sql.NewRow(int64(1), "first row"),
+		sql.NewRow(int64(2), "second row"),
+		sql.NewRow(int64(3), "third row"),
 	)
 
 	db := mem.NewDatabase("mydb")

sql/analyzer/resolve_columns.go

@@ -50,6 +50,14 @@ func qualifyColumns(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error)
 		}
 	}
 
+	var projects, seenProjects int
+	plan.Inspect(n, func(n sql.Node) bool {
+		if _, ok := n.(*plan.Project); ok {
+			projects++
+		}
+		return true
+	})
+
 	return n.TransformUp(func(n sql.Node) (sql.Node, error) {
 		a.Log("transforming node of type: %T", n)
 		switch n := n.(type) {
@@ -68,7 +76,7 @@ func qualifyColumns(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error)
 			indexCols(name, n.Schema())
 		}
 
-		return n.TransformExpressionsUp(func(e sql.Expression) (sql.Expression, error) {
+		result, err := n.TransformExpressionsUp(func(e sql.Expression) (sql.Expression, error) {
 			a.Log("transforming expression of type: %T", e)
 			switch col := e.(type) {
 			case *expression.UnresolvedColumn:
@@ -135,6 +143,51 @@ func qualifyColumns(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error)
 
 			return e, nil
 		})
+
+		if err != nil {
+			return nil, err
+		}
+
+		// We should ignore the topmost project, because some nodes are
+		// reordered, such as Sort, and they would not be resolved well.
+		if n, ok := result.(*plan.Project); ok && projects-seenProjects > 1 {
+			seenProjects++
+
+			// We need to modify the indexed columns to only contain what is
+			// projected in this project. If the column is not qualified by any
+			// table, just keep the ones that are currently in the index.
+			// If it is, then just make those tables available for the column.
+			// If we don't do this, columns that are not projected will be
+			// available in this step and may cause false errors or unintended
+			// results.
+			var projected = make(map[string][]string)
+			for _, p := range n.Projections {
+				var table, col string
+				switch p := p.(type) {
+				case column:
+					table = p.Table()
+					col = p.Name()
+				case *expression.GetField:
+					table = p.Table()
+					col = p.Name()
+				default:
+					continue
+				}
+
+				if table != "" {
+					projected[col] = append(projected[col], table)
+				} else {
+					projected[col] = append(projected[col], colIndex[col]...)
+				}
+			}
+
+			colIndex = make(map[string][]string)
+			for col, tables := range projected {
+				colIndex[col] = dedupStrings(tables)
+			}
+		}
+
+		return result, nil
 	})
 }
 

sql/analyzer/resolve_columns_test.go

@@ -11,6 +11,47 @@ import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql/plan"
 )
 
+func TestQualifyColumnsProject(t *testing.T) {
+	require := require.New(t)
+
+	table := mem.NewTable("foo", sql.Schema{
+		{Name: "a", Type: sql.Text, Source: "foo"},
+		{Name: "b", Type: sql.Text, Source: "foo"},
+	})
+
+	node := plan.NewProject(
+		[]sql.Expression{
+			expression.NewUnresolvedColumn("a"),
+			expression.NewUnresolvedColumn("b"),
+		},
+		plan.NewProject(
+			[]sql.Expression{
+				expression.NewUnresolvedQualifiedColumn("foo", "a"),
+			},
+			plan.NewResolvedTable(table),
+		),
+	)
+
+	result, err := qualifyColumns(sql.NewEmptyContext(), NewDefault(nil), node)
+	require.NoError(err)
+
+	expected := plan.NewProject(
+		[]sql.Expression{
+			expression.NewUnresolvedQualifiedColumn("foo", "a"),
+			// b is not qualified because it's not projected
+			expression.NewUnresolvedColumn("b"),
+		},
+		plan.NewProject(
+			[]sql.Expression{
+				expression.NewUnresolvedQualifiedColumn("foo", "a"),
+			},
+			plan.NewResolvedTable(table),
+		),
+	)
+
+	require.Equal(expected, result)
+}
+
 func TestMisusedAlias(t *testing.T) {
 	require := require.New(t)
 	f := getRule("resolve_columns")