*: implement subquery expressions

SUPPORTED.md

@@ -80,9 +80,6 @@
 - div
 - %
 
-## Subqueries
-- supported only as tables, not as expressions.
-
 ## Functions
 - ARRAY_LENGTH
 - CEIL
@@ -133,3 +130,6 @@
 - WEEKDAY
 - YEAR
 - YEARWEEK
+
+## Subqueries
+Supported both as a table and as expressions but they can't access the parent query scope.

engine.go

@@ -1,4 +1,4 @@
-package sqle // import "github.com/src-d/go-mysql-server"
+package sqle
 
 import (
 	"time"

engine_test.go

@@ -1548,6 +1548,28 @@ var queries = []struct {
 			{int64(5), "there is some text in here"},
 		},
 	},
+	{
+		`SELECT i FROM mytable WHERE i = (SELECT 1)`,
+		[]sql.Row{{int64(1)}},
+	},
+	{
+		`SELECT i FROM mytable WHERE i IN (SELECT i FROM mytable)`,
+		[]sql.Row{
+			{int64(1)},
+			{int64(2)},
+			{int64(3)},
+		},
+	},
+	{
+		`SELECT i FROM mytable WHERE i NOT IN (SELECT i FROM mytable ORDER BY i ASC LIMIT 2)`,
+		[]sql.Row{
+			{int64(3)},
+		},
+	},
+	{
+		`SELECT (SELECT i FROM mytable ORDER BY i ASC LIMIT 1) AS x`,
+		[]sql.Row{{int64(1)}},
+	},
 }
 
 func TestQueries(t *testing.T) {
@@ -1901,7 +1923,7 @@ func TestInsertInto(t *testing.T) {
 			[]sql.Row{{int64(1)}},
 			"SELECT * FROM typestable WHERE id = 999;",
 			[]sql.Row{{
-				int64(999), int64(-math.MaxInt8-1), int64(-math.MaxInt16-1), int64(-math.MaxInt32-1), int64(-math.MaxInt64-1),
+				int64(999), int64(-math.MaxInt8 - 1), int64(-math.MaxInt16 - 1), int64(-math.MaxInt32 - 1), int64(-math.MaxInt64 - 1),
 				int64(0), int64(0), int64(0), int64(0),
 				float64(math.SmallestNonzeroFloat32), float64(math.SmallestNonzeroFloat64),
 				timeParse(sql.TimestampLayout, "0010-04-05 12:51:36"), timeParse(sql.DateLayout, "0101-11-07"),
@@ -1919,7 +1941,7 @@ func TestInsertInto(t *testing.T) {
 			[]sql.Row{{int64(1)}},
 			"SELECT * FROM typestable WHERE id = 999;",
 			[]sql.Row{{
-				int64(999), int64(-math.MaxInt8-1), int64(-math.MaxInt16-1), int64(-math.MaxInt32-1), int64(-math.MaxInt64-1),
+				int64(999), int64(-math.MaxInt8 - 1), int64(-math.MaxInt16 - 1), int64(-math.MaxInt32 - 1), int64(-math.MaxInt64 - 1),
 				int64(0), int64(0), int64(0), int64(0),
 				float64(math.SmallestNonzeroFloat32), float64(math.SmallestNonzeroFloat64),
 				timeParse(sql.TimestampLayout, "0010-04-05 12:51:36"), timeParse(sql.DateLayout, "0101-11-07"),
@@ -2101,7 +2123,7 @@ func TestReplaceInto(t *testing.T) {
 			[]sql.Row{{int64(1)}},
 			"SELECT * FROM typestable WHERE id = 999;",
 			[]sql.Row{{
-				int64(999), int64(-math.MaxInt8-1), int64(-math.MaxInt16-1), int64(-math.MaxInt32-1), int64(-math.MaxInt64-1),
+				int64(999), int64(-math.MaxInt8 - 1), int64(-math.MaxInt16 - 1), int64(-math.MaxInt32 - 1), int64(-math.MaxInt64 - 1),
 				int64(0), int64(0), int64(0), int64(0),
 				float64(math.SmallestNonzeroFloat32), float64(math.SmallestNonzeroFloat64),
 				timeParse(sql.TimestampLayout, "0010-04-05 12:51:36"), timeParse(sql.DateLayout, "0101-11-07"),
@@ -2119,7 +2141,7 @@ func TestReplaceInto(t *testing.T) {
 			[]sql.Row{{int64(1)}},
 			"SELECT * FROM typestable WHERE id = 999;",
 			[]sql.Row{{
-				int64(999), int64(-math.MaxInt8-1), int64(-math.MaxInt16-1), int64(-math.MaxInt32-1), int64(-math.MaxInt64-1),
+				int64(999), int64(-math.MaxInt8 - 1), int64(-math.MaxInt16 - 1), int64(-math.MaxInt32 - 1), int64(-math.MaxInt64 - 1),
 				int64(0), int64(0), int64(0), int64(0),
 				float64(math.SmallestNonzeroFloat32), float64(math.SmallestNonzeroFloat64),
 				timeParse(sql.TimestampLayout, "0010-04-05 12:51:36"), timeParse(sql.DateLayout, "0101-11-07"),

log.go

@@ -1,4 +1,4 @@
-package sqle // import "github.com/src-d/go-mysql-server"
+package sqle
 
 import (
 	"github.com/golang/glog"

server/server.go

@@ -1,4 +1,4 @@
-package server // import "github.com/src-d/go-mysql-server/server"
+package server
 
 import (
 	"time"

sql/analyzer/analyzer.go

@@ -1,4 +1,4 @@
-package analyzer // import "github.com/src-d/go-mysql-server/sql/analyzer"
+package analyzer
 
 import (
 	"os"

sql/analyzer/assign_indexes.go

@@ -759,8 +759,20 @@ func containsColumns(e sql.Expression) bool {
 	return result
 }
 
+func containsSubquery(e sql.Expression) bool {
+	var result bool
+	expression.Inspect(e, func(e sql.Expression) bool {
+		if _, ok := e.(*expression.Subquery); ok {
+			result = true
+			return false
+		}
+		return true
+	})
+	return result
+}
+
 func isEvaluable(e sql.Expression) bool {
-	return !containsColumns(e)
+	return !containsColumns(e) && !containsSubquery(e)
 }
 
 func canMergeIndexes(a, b sql.IndexLookup) bool {

sql/analyzer/resolve_subqueries.go

@@ -2,6 +2,7 @@ package analyzer
 
 import (
 	"github.com/src-d/go-mysql-server/sql"
+	"github.com/src-d/go-mysql-server/sql/expression"
 	"github.com/src-d/go-mysql-server/sql/plan"
 )
 
@@ -10,7 +11,7 @@ func resolveSubqueries(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, err
 	defer span.Finish()
 
 	a.Log("resolving subqueries")
-	return plan.TransformUp(n, func(n sql.Node) (sql.Node, error) {
+	n, err := plan.TransformUp(n, func(n sql.Node) (sql.Node, error) {
 		switch n := n.(type) {
 		case *plan.SubqueryAlias:
 			a.Log("found subquery %q with child of type %T", n.Name(), n.Child)
@@ -24,4 +25,25 @@ func resolveSubqueries(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, err
 			return n, nil
 		}
 	})
+	if err != nil {
+		return nil, err
+	}
+
+	return plan.TransformExpressionsUp(n, func(e sql.Expression) (sql.Expression, error) {
+		s, ok := e.(*expression.Subquery)
+		if !ok || s.Resolved() {
+			return e, nil
+		}
+
+		q, err := a.Analyze(ctx, s.Query)
+		if err != nil {
+			return nil, err
+		}
+
+		if qp, ok := q.(*plan.QueryProcess); ok {
+			q = qp.Child
+		}
+
+		return s.WithQuery(q), nil
+	})
 }

sql/analyzer/validation_rules.go

@@ -20,6 +20,7 @@ const (
 	validateCaseResultTypesRule = "validate_case_result_types"
 	validateIntervalUsageRule   = "validate_interval_usage"
 	validateExplodeUsageRule    = "validate_explode_usage"
+	validateSubqueryColumnsRule = "validate_subquery_columns"
 )
 
 var (
@@ -57,6 +58,12 @@ var (
 	ErrExplodeInvalidUse = errors.NewKind(
 		"using EXPLODE is not supported outside a Project node",
 	)
+
+	// ErrSubqueryColumns is returned when an expression subquery returns
+	// more than a single column.
+	ErrSubqueryColumns = errors.NewKind(
+		"subquery expressions can only return a single column",
+	)
 )
 
 // DefaultValidationRules to apply while analyzing nodes.
@@ -70,6 +77,7 @@ var DefaultValidationRules = []Rule{
 	{validateCaseResultTypesRule, validateCaseResultTypes},
 	{validateIntervalUsageRule, validateIntervalUsage},
 	{validateExplodeUsageRule, validateExplodeUsage},
+	{validateSubqueryColumnsRule, validateSubqueryColumns},
 }
 
 func validateIsResolved(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error) {
@@ -322,6 +330,25 @@ func validateExplodeUsage(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node,
 	return n, nil
 }
 
+func validateSubqueryColumns(ctx *sql.Context, a *Analyzer, n sql.Node) (sql.Node, error) {
+	valid := true
+	plan.InspectExpressions(n, func(e sql.Expression) bool {
+		s, ok := e.(*expression.Subquery)
+		if ok && len(s.Query.Schema()) != 1 {
+			valid = false
+			return false
+		}
+
+		return true
+	})
+
+	if !valid {
+		return nil, ErrSubqueryColumns.New()
+	}
+
+	return n, nil
+}
+
 func stringContains(strs []string, target string) bool {
 	for _, s := range strs {
 		if s == target {

sql/analyzer/validation_rules_test.go

@@ -674,6 +674,37 @@ func TestValidateExplodeUsage(t *testing.T) {
 	}
 }
 
+func TestValidateSubqueryColumns(t *testing.T) {
+	require := require.New(t)
+	ctx := sql.NewEmptyContext()
+
+	node := plan.NewProject([]sql.Expression{
+		expression.NewSubquery(plan.NewProject(
+			[]sql.Expression{
+				lit(1),
+				lit(2),
+			},
+			dummyNode{true},
+		)),
+	}, dummyNode{true})
+
+	_, err := validateSubqueryColumns(ctx, nil, node)
+	require.Error(err)
+	require.True(ErrSubqueryColumns.Is(err))
+
+	node = plan.NewProject([]sql.Expression{
+		expression.NewSubquery(plan.NewProject(
+			[]sql.Expression{
+				lit(1),
+			},
+			dummyNode{true},
+		)),
+	}, dummyNode{true})
+
+	_, err = validateSubqueryColumns(ctx, nil, node)
+	require.NoError(err)
+}
+
 type dummyNode struct{ resolved bool }
 
 func (n dummyNode) String() string                           { return "dummynode" }

sql/core.go

@@ -1,4 +1,4 @@
-package sql // import "github.com/src-d/go-mysql-server/sql"
+package sql
 
 import (
 	"fmt"

sql/expression/comparison.go

@@ -466,7 +466,6 @@ func (in *In) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		return nil, err
 	}
 
-	// TODO: support subqueries
 	switch right := in.Right().(type) {
 	case Tuple:
 		for _, el := range right {
@@ -496,6 +495,34 @@ func (in *In) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 			}
 		}
 
+		return false, nil
+	case *Subquery:
+		if leftElems > 1 {
+			return nil, ErrInvalidOperandColumns.New(leftElems, 1)
+		}
+
+		typ := right.Type()
+		values, err := right.EvalMultiple(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, val := range values {
+			val, err = typ.Convert(val)
+			if err != nil {
+				return nil, err
+			}
+
+			cmp, err := typ.Compare(left, val)
+			if err != nil {
+				return nil, err
+			}
+
+			if cmp == 0 {
+				return true, nil
+			}
+		}
+
 		return false, nil
 	default:
 		return nil, ErrUnsupportedInOperand.New(right)
@@ -547,7 +574,6 @@ func (in *NotIn) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		return nil, err
 	}
 
-	// TODO: support subqueries
 	switch right := in.Right().(type) {
 	case Tuple:
 		for _, el := range right {
@@ -577,6 +603,34 @@ func (in *NotIn) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 			}
 		}
 
+		return true, nil
+	case *Subquery:
+		if leftElems > 1 {
+			return nil, ErrInvalidOperandColumns.New(leftElems, 1)
+		}
+
+		typ := right.Type()
+		values, err := right.EvalMultiple(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, val := range values {
+			val, err = typ.Convert(val)
+			if err != nil {
+				return nil, err
+			}
+
+			cmp, err := typ.Compare(left, val)
+			if err != nil {
+				return nil, err
+			}
+
+			if cmp == 0 {
+				return false, nil
+			}
+		}
+
 		return true, nil
 	default:
 		return nil, ErrUnsupportedInOperand.New(right)