Fixed bug in cross joins involving disjunctions that contain more than one table.

Signed-off-by: Zach Musgrave <zach@liquidata.co>

Author: zachmu

engine_test.go

@@ -30,7 +30,7 @@ type queryTest struct {
 	expected []sql.Row
 }
 
-var queries = []queryTest {
+var queries = []queryTest{
 	{
 		"SELECT i FROM mytable;",
 		[]sql.Row{{int64(1)}, {int64(2)}, {int64(3)}},
@@ -49,20 +49,6 @@ var queries = []queryTest {
 			{"second row", int64(2)},
 			{"third row", int64(3)}},
 	},
-	{
-		"select pk,pk1,pk2 from one_pk,two_pk where pk=0 and pk1=0 or pk2=1 order by 1,2,3",
-		[]sql.Row{
-			{0,0,0},
-			{0,0,1},
-			{0,1,1},
-			{1,0,1},
-			{1,1,1},
-			{2,0,1},
-			{2,1,1},
-			{3,0,1},
-			{3,1,1},
-		},
-	},
 	{
 		"SELECT i + 1 FROM mytable;",
 		[]sql.Row{{int64(2)}, {int64(3)}, {int64(4)}},
@@ -367,7 +353,7 @@ var queries = []queryTest {
 	},
 	{
 		"SELECT s FROM mytable INNER JOIN othertable " +
-			"ON substring(s2, 1, 2) != '' AND i = i2",
+				"ON substring(s2, 1, 2) != '' AND i = i2",
 		[]sql.Row{
 			{"first row"},
 			{"second row"},
@@ -1354,6 +1340,119 @@ var queries = []queryTest {
 			{int64(4)},
 		},
 	},
+	{
+		"select pk,pk1,pk2 from one_pk, two_pk order by 1,2,3",
+		[]sql.Row{
+			{0, 0, 0},
+			{0, 0, 1},
+			{0, 1, 0},
+			{0, 1, 1},
+			{1, 0, 0},
+			{1, 0, 1},
+			{1, 1, 0},
+			{1, 1, 1},
+			{2, 0, 0},
+			{2, 0, 1},
+			{2, 1, 0},
+			{2, 1, 1},
+			{3, 0, 0},
+			{3, 0, 1},
+			{3, 1, 0},
+			{3, 1, 1},
+		},
+	},
+	{
+		"select t1.c1,t2.c2 from one_pk t1, two_pk t2 where pk1=1 and pk2=1 order by 1,2",
+		[]sql.Row{
+			{0, 30},
+			{10, 30},
+			{20, 30},
+			{30, 30},
+		},
+	},
+	{
+		"select t1.c1,t2.c2 from one_pk t1, two_pk t2 where pk1=1 or pk2=1 order by 1,2",
+		[]sql.Row{
+			{0, 10},
+			{0, 20},
+			{0, 30},
+			{10, 10},
+			{10, 20},
+			{10, 30},
+			{20, 10},
+			{20, 20},
+			{20, 30},
+			{30, 10},
+			{30, 20},
+			{30, 30},
+		},
+	},
+	{
+		"select pk,pk2 from one_pk t1, two_pk t2 where pk=1 and pk2=1 order by 1,2",
+		[]sql.Row{
+			{1, 1},
+			{1, 1},
+		},
+	},
+	{
+		"select pk,pk1,pk2 from one_pk,two_pk where pk=0 and pk1=0 or pk2=1 order by 1,2,3",
+		[]sql.Row{
+			{0, 0, 0},
+			{0, 0, 1},
+			{0, 1, 1},
+			{1, 0, 1},
+			{1, 1, 1},
+			{2, 0, 1},
+			{2, 1, 1},
+			{3, 0, 1},
+			{3, 1, 1},
+		},
+	},
+	{
+		"select pk,pk1,pk2 from one_pk,two_pk where one_pk.c1=two_pk.c1 order by 1,2,3",
+		[]sql.Row{
+			{0, 0, 0},
+			{1, 0, 1},
+			{2, 1, 0},
+			{3, 1, 1},
+		},
+	},
+	{
+		"select one_pk.c5,pk1,pk2 from one_pk,two_pk where pk=pk1 order by 1,2,3",
+		[]sql.Row{
+			{0, 0, 0},
+			{0, 0, 1},
+			{10, 1, 0},
+			{10, 1, 1},
+		},
+	},
+	{
+		"select pk,pk1,pk2 from one_pk join two_pk on one_pk.c1=two_pk.c1 where pk=1 order by 1,2,3",
+		[]sql.Row{
+			{1, 0, 1},
+		},
+	},
+	{
+		"select pk,pk1,pk2,one_pk.c1 as foo, two_pk.c1 as bar from one_pk join two_pk on one_pk.c1=two_pk.c1 order by 1,2,3",
+		[]sql.Row{
+			{0, 0, 0, 0, 0},
+			{1, 0, 1, 10, 10},
+			{2, 1, 0, 20, 20},
+			{3, 1, 1, 30, 30},
+		},
+	},
+	{
+		"select pk,pk1,pk2,one_pk.c1 as foo,two_pk.c1 as bar from one_pk join two_pk on one_pk.c1=two_pk.c1 where one_pk.c1=10",
+		[]sql.Row{
+			{1, 0, 1, 10, 10},
+		},
+	},
+	{
+		"select pk,pk1,pk2 from one_pk join two_pk on pk1-pk>0 and pk2<1",
+		[]sql.Row{
+			{0, 1, 0},
+		},
+	},
 }
 
 var infoSchemaQueries = []queryTest {

sql/analyzer/assign_indexes.go

@@ -91,6 +91,13 @@ func getIndexes(e sql.Expression, aliases map[string]sql.Expression, a *Analyzer
 	var result = make(map[string]*indexLookup)
 	switch e := e.(type) {
 	case *expression.Or:
+		// If more than one table is involved in a disjunction, we can't use indexed lookups. This is because we will
+		// inappropriately restrict the iterated values of the indexed table to matching index values, when during a cross
+		// join we must consider every row from each table.
+		if len(findTables(e)) > 1 {
+			return nil, nil
+		}
+
 		leftIndexes, err := getIndexes(e.Left, aliases, a)
 		if err != nil {
 			return nil, err
@@ -299,6 +306,27 @@ func getIndexes(e sql.Expression, aliases map[string]sql.Expression, a *Analyzer
 	return result, nil
 }
 
+// Returns the tables used in the expression given
+func findTables(e sql.Expression) []string {
+	tables := make(map[string]bool)
+	expression.Inspect(e, func(e sql.Expression) bool {
+		switch e := e.(type) {
+		case *expression.GetField:
+			tables[e.Table()] = true
+			return false
+		default:
+			return true
+		}
+	})
+
+	var names []string
+	for table := range tables {
+		names = append(names, table)
+	}
+
+	return names
+}
+
 func unifyExpressions(aliases map[string]sql.Expression, expr ...sql.Expression) []sql.Expression {
 	expressions := make([]sql.Expression, len(expr))