Merge pull request #186 from erizocosmico/feature/filters-in

gitquery: support IN selectors

Author: erizocosmico

Gopkg.lock

@@ -1,6 +1,6 @@
 [[constraint]]
   name = "gopkg.in/src-d/go-mysql-server.v0"
-  revision = "d517220df27cf67ae67a21b69f5d96118464327c"
+  revision = "6a563e1a2bcdd038830ed6039fb770025fb325c8"
 
 [[constraint]]
   name = "github.com/jessevdk/go-flags"

Gopkg.toml

@@ -57,11 +57,11 @@ func (blobsTable) Schema() sql.Schema {
 	return blobsSchema
 }
 
-func (r *blobsTable) TransformUp(f func(sql.Node) (sql.Node, error)) (sql.Node, error) {
+func (r *blobsTable) TransformUp(f sql.TransformNodeFunc) (sql.Node, error) {
 	return f(r)
 }
 
-func (r *blobsTable) TransformExpressionsUp(f func(sql.Expression) (sql.Expression, error)) (sql.Node, error) {
+func (r *blobsTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql.Node, error) {
 	return r, nil
 }
 

blobs.go

@@ -43,7 +43,7 @@ func (c *CmdServer) buildDatabase() error {
 	}
 
 	c.engine.AddDatabase(gitquery.NewDatabase(c.name, c.pool))
-	function.Register(c.engine.Catalog)
+	c.engine.Catalog.RegisterFunctions(function.Functions)
 	return nil
 }
 

cmd/gitquery/server.go

@@ -47,11 +47,11 @@ func (commitsTable) Schema() sql.Schema {
 	return commitsSchema
 }
 
-func (r *commitsTable) TransformUp(f func(sql.Node) (sql.Node, error)) (sql.Node, error) {
+func (r *commitsTable) TransformUp(f sql.TransformNodeFunc) (sql.Node, error) {
 	return f(r)
 }
 
-func (r *commitsTable) TransformExpressionsUp(f func(sql.Expression) (sql.Expression, error)) (sql.Node, error) {
+func (r *commitsTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql.Node, error) {
 	return r, nil
 }
 

commits.go

@@ -99,6 +99,30 @@ func canHandleEquals(schema sql.Schema, tableName string, eq *expression.Equals)
 	return false
 }
 
+// canHandleIn returns whether the given in expression can be handled as a selector.
+// For that to happen, the left side must be a GetField expression and the right
+// side must be a Tuple expression with only Literal expressions as children.
+// The GetField expr must exist in the schema and match the given table name.
+func canHandleIn(schema sql.Schema, tableName string, in *expression.In) bool {
+	left, ok := in.Left().(*expression.GetField)
+	if !ok || !schema.Contains(left.Name()) || left.Table() != tableName {
+		return false
+	}
+
+	right, ok := in.Right().(expression.Tuple)
+	if !ok {
+		return false
+	}
+
+	for _, elem := range right {
+		if _, ok := elem.(*expression.Literal); !ok {
+			return false
+		}
+	}
+
+	return true
+}
+
 // getEqualityValues returns the field and value of the literal in the
 // given equality expression.
 func getEqualityValues(eq *expression.Equals) (string, interface{}, error) {
@@ -119,6 +143,36 @@ func getEqualityValues(eq *expression.Equals) (string, interface{}, error) {
 	return "", "", nil
 }
 
+// getInValues returns the field and values of the literals in the
+// given in expression.
+func getInValues(in *expression.In) (string, []interface{}, error) {
+	left, ok := in.Left().(*expression.GetField)
+	if !ok {
+		return "", nil, nil
+	}
+
+	right, ok := in.Right().(expression.Tuple)
+	if !ok {
+		return "", nil, nil
+	}
+
+	var values = make([]interface{}, len(right))
+	for i, elem := range right {
+		lit, ok := elem.(*expression.Literal)
+		if !ok {
+			return "", nil, nil
+		}
+
+		var err error
+		values[i], err = lit.Eval(nil, nil)
+		if err != nil {
+			return "", nil, err
+		}
+	}
+
+	return left.Name(), values, nil
+}
+
 // handledFilters returns the set of filters that can be handled with the given
 // schema. That is, all expressions that don't have GetField expressions that
 // don't belong to the given schema.
@@ -174,15 +228,36 @@ func classifyFilters(
 					continue
 				}
 			}
-			// TODO: handle IN when it's implemented
+		case *expression.In:
+			if canHandleIn(schema, table, f) {
+				field, vals, err := getInValues(f)
+				if err != nil {
+					return nil, nil, err
+				}
+
+				if stringContains(handledCols, field) {
+					selectors[field] = append(selectors[field], selector(vals))
+					continue
+				}
+			}
 		case *expression.Or:
 			exprs := unfoldOrs(f)
 			// check all unfolded exprs can be handled, if not we have to
 			// resort to treating them as conditions
 			valid := true
 			for _, e := range exprs {
-				f, ok := e.(*expression.Equals)
-				if !ok || !canHandleEquals(schema, table, f) {
+				switch e := e.(type) {
+				case *expression.Equals:
+					if !canHandleEquals(schema, table, e) {
+						valid = false
+						break
+					}
+				case *expression.In:
+					if !canHandleIn(schema, table, e) {
+						valid = false
+						break
+					}
+				default:
 					valid = false
 					break
 				}
@@ -200,11 +275,9 @@ func classifyFilters(
 			}
 
 			for k, v := range sels {
-				var values = make(selector, len(v))
-				for i, val := range v {
-					if len(val) > 0 {
-						values[i] = val[0]
-					}
+				var values selector
+				for _, vals := range v {
+					values = append(values, vals...)
 				}
 				selectors[k] = append(selectors[k], values)
 			}