sql: support parsing and executing CROSS JOIN

sql/analyzer/analyzer_test.go

@@ -17,8 +17,10 @@ func TestAnalyzer_Analyze(t *testing.T) {
 	assert := require.New(t)
 
 	table := mem.NewTable("mytable", sql.Schema{{"i", sql.Integer}})
+	table2 := mem.NewTable("mytable2", sql.Schema{{"i2", sql.Integer}})
 	db := mem.NewDatabase("mydb")
 	db.AddTable("mytable", table)
+	db.AddTable("mytable2", table2)
 
 	catalog := &sql.Catalog{Databases: []sql.Database{db}}
 	a := analyzer.New(catalog)
@@ -95,6 +97,27 @@ func TestAnalyzer_Analyze(t *testing.T) {
 	)
 	assert.Nil(err)
 	assert.Equal(expected, analyzed)
+
+	notAnalyzed = plan.NewProject(
+		[]sql.Expression{
+			expression.NewUnresolvedColumn("i"),
+			expression.NewUnresolvedColumn("i2"),
+		},
+		plan.NewCrossJoin(
+			plan.NewUnresolvedTable("mytable"),
+			plan.NewUnresolvedTable("mytable2"),
+		),
+	)
+	analyzed, err = a.Analyze(notAnalyzed)
+	expected = plan.NewProject(
+		[]sql.Expression{
+			expression.NewGetField(0, sql.Integer, "i"),
+			expression.NewGetField(1, sql.Integer, "i2"),
+		},
+		plan.NewCrossJoin(table, table2),
+	)
+	assert.Nil(err)
+	assert.Equal(expected, analyzed)
 }
 
 func TestAnalyzer_Analyze_MaxIterations(t *testing.T) {

sql/analyzer/rules.go

@@ -39,6 +39,7 @@ func resolveColumns(a *Analyzer, n sql.Node) sql.Node {
 
 	child := n.Children()[0]
 
+	//TODO: Fail when there is no unambiguous resolution.
 	colMap := map[string]*expression.GetField{}
 	for idx, child := range child.Schema() {
 		colMap[child.Name] = expression.NewGetField(idx, child.Type, child.Name)

sql/parse/parse.go

@@ -93,11 +93,34 @@ func convertSelect(s *sqlparser.Select) (sql.Node, error) {
 }
 
 func tableExprsToTable(te sqlparser.TableExprs) (sql.Node, error) {
-	if len(te) != 1 {
-		return nil, errUnsupportedFeature("more than one table")
+	if len(te) == 0 {
+		return nil, errUnsupportedFeature("zero tables in FROM")
 	}
 
-	switch t := (te[0]).(type) {
+	var nodes []sql.Node
+	for _, t := range te {
+		n, err := tableExprToTable(t)
+		if err != nil {
+			return nil, err
+		}
+
+		nodes = append(nodes, n)
+	}
+
+	if len(nodes) == 1 {
+		return nodes[0], nil
+	}
+
+	if len(nodes) == 2 {
+		return plan.NewCrossJoin(nodes[0], nodes[1]), nil
+	}
+
+	//TODO: Support N tables in JOIN.
+	return nil, errUnsupportedFeature("more than 2 tables in JOIN")
+}
+
+func tableExprToTable(te sqlparser.TableExpr) (sql.Node, error) {
+	switch t := (te).(type) {
 	default:
 		return nil, errUnsupported(te)
 	case *sqlparser.AliasedTableExpr:

sql/parse/parse_test.go

@@ -117,6 +117,16 @@ var fixtures = map[string]sql.Node{
 			),
 		),
 	),
+	`SELECT foo, bar FROM t1, t2;`: plan.NewProject(
+		[]sql.Expression{
+			expression.NewUnresolvedColumn("foo"),
+			expression.NewUnresolvedColumn("bar"),
+		},
+		plan.NewCrossJoin(
+			plan.NewUnresolvedTable("t1"),
+			plan.NewUnresolvedTable("t2"),
+		),
+	),
 }
 
 func TestParse(t *testing.T) {

sql/plan/cross_join.go

@@ -71,33 +71,34 @@ type crossJoinIterator struct {
 }
 
 func (i *crossJoinIterator) Next() (sql.Row, error) {
-	for {
-		if i.leftRow == nil {
-			lr, err := i.li.Next()
-			if err != nil {
-				return nil, err
-			}
-
-			i.leftRow = lr
+	if len(i.rightRows) == 0 {
+		if err := i.fillRows(); err != io.EOF {
+			return nil, err
 		}
 
 		if len(i.rightRows) == 0 {
-			err := i.fillRows()
-			if err != nil && err != io.EOF {
-				return nil, err
-			}
+			return nil, io.EOF
 		}
+	}
 
-		if i.index <= len(i.rightRows)-1 {
-			fields := append(i.leftRow.Fields(), i.rightRows[i.index].Fields()...)
-			i.index++
-
-			return sql.NewMemoryRow(fields...), nil
+	if i.leftRow == nil {
+		lr, err := i.li.Next()
+		if err != nil {
+			return nil, err
 		}
 
+		i.index = 0
+		i.leftRow = lr
+	}
+
+	fields := append(i.leftRow.Fields(), i.rightRows[i.index].Fields()...)
+	i.index++
+	if i.index >= len(i.rightRows) {
 		i.index = 0
 		i.leftRow = nil
 	}
+
+	return sql.NewMemoryRow(fields...), nil
 }
 
 func (i *crossJoinIterator) fillRows() error {

sql/plan/cross_join_test.go

@@ -10,21 +10,22 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+var lSchema = sql.Schema{
+	sql.Field{"lcol1", sql.String},
+	sql.Field{"lcol2", sql.String},
+	sql.Field{"lcol3", sql.Integer},
+	sql.Field{"lcol4", sql.BigInteger},
+}
+
+var rSchema = sql.Schema{
+	sql.Field{"rcol1", sql.String},
+	sql.Field{"rcol2", sql.String},
+	sql.Field{"rcol3", sql.Integer},
+	sql.Field{"rcol4", sql.BigInteger},
+}
+
 func TestCrossJoin(t *testing.T) {
 	assert := assert.New(t)
-	lSchema := sql.Schema{
-		sql.Field{"lcol1", sql.String},
-		sql.Field{"lcol2", sql.String},
-		sql.Field{"lcol3", sql.Integer},
-		sql.Field{"lcol4", sql.BigInteger},
-	}
-
-	rSchema := sql.Schema{
-		sql.Field{"rcol1", sql.String},
-		sql.Field{"rcol2", sql.String},
-		sql.Field{"rcol3", sql.Integer},
-		sql.Field{"rcol4", sql.BigInteger},
-	}
 
 	resultSchema := sql.Schema{
 		sql.Field{"lcol1", sql.String},
@@ -44,7 +45,7 @@ func TestCrossJoin(t *testing.T) {
 
 	j := NewCrossJoin(ltable, rtable)
 
-	assert.Equal(j.Schema(), resultSchema)
+	assert.Equal(resultSchema, j.Schema())
 
 	iter, err := j.RowIter()
 	assert.Nil(err)
@@ -91,6 +92,38 @@ func TestCrossJoin(t *testing.T) {
 	assert.Nil(row)
 }
 
+func TestCrossJoin_Empty(t *testing.T) {
+	assert := assert.New(t)
+
+	ltable := mem.NewTable("left", lSchema)
+	rtable := mem.NewTable("right", rSchema)
+	insertData(assert, ltable)
+
+	j := NewCrossJoin(ltable, rtable)
+
+	iter, err := j.RowIter()
+	assert.Nil(err)
+	assert.NotNil(iter)
+
+	row, err := iter.Next()
+	assert.Equal(io.EOF, err)
+	assert.Nil(row)
+
+	ltable = mem.NewTable("left", lSchema)
+	rtable = mem.NewTable("right", rSchema)
+	insertData(assert, rtable)
+
+	j = NewCrossJoin(ltable, rtable)
+
+	iter, err = j.RowIter()
+	assert.Nil(err)
+	assert.NotNil(iter)
+
+	row, err = iter.Next()
+	assert.Equal(io.EOF, err)
+	assert.Nil(row)
+}
+
 func insertData(assert *assert.Assertions, table *mem.Table) {
 	err := table.Insert("col1_1", "col2_1", int32(1111), int64(2222))
 	assert.Nil(err)