updated vitess api (to gitql-0.2 tag) (#114)

Author: smola

sql/parse/parse.go

@@ -142,7 +142,7 @@ func tableExprToTable(te sqlparser.TableExpr) (sql.Node, error) {
 }
 
 func whereToFilter(w *sqlparser.Where, child sql.Node) (*plan.Filter, error) {
-	c, err := boolExprToExpression(w.Expr)
+	c, err := exprToExpression(w.Expr)
 	if err != nil {
 		return nil, err
 	}
@@ -153,7 +153,7 @@ func whereToFilter(w *sqlparser.Where, child sql.Node) (*plan.Filter, error) {
 func orderByToSort(ob sqlparser.OrderBy, child sql.Node) (*plan.Sort, error) {
 	var sortFields []plan.SortField
 	for _, o := range ob {
-		e, err := valExprToExpression(o.Expr)
+		e, err := exprToExpression(o.Expr)
 		if err != nil {
 			return nil, err
 		}
@@ -175,8 +175,8 @@ func orderByToSort(ob sqlparser.OrderBy, child sql.Node) (*plan.Sort, error) {
 	return plan.NewSort(sortFields, child), nil
 }
 
-func limitToLimit(o sqlparser.ValExpr, child sql.Node) (*plan.Limit, error) {
-	e, err := valExprToExpression(o)
+func limitToLimit(o sqlparser.Expr, child sql.Node) (*plan.Limit, error) {
+	e, err := exprToExpression(o)
 	if err != nil {
 		return nil, err
 	}
@@ -232,49 +232,61 @@ func selectExprsToExpressions(se sqlparser.SelectExprs) ([]sql.Expression, error
 }
 
 func exprToExpression(e sqlparser.Expr) (sql.Expression, error) {
-	be, ok := e.(sqlparser.BoolExpr)
-	if ok {
-		return boolExprToExpression(be)
-	}
-
-	c, ok := e.(*sqlparser.ComparisonExpr)
-	if ok {
-		return comparisonExprToExpression(c)
-	}
-
-	v, ok := e.(sqlparser.ValExpr)
-	if ok {
-		return valExprToExpression(v)
-	}
-
-	return nil, errUnsupported(e)
-}
-
-func boolExprToExpression(be sqlparser.BoolExpr) (sql.Expression, error) {
-	switch b := be.(type) {
+	switch v := e.(type) {
 	default:
-		return nil, errUnsupported(b)
+		return nil, errUnsupported(e)
 	case *sqlparser.ComparisonExpr:
-		return comparisonExprToExpression(b)
+		return comparisonExprToExpression(v)
 	case *sqlparser.NotExpr:
-		c, err := boolExprToExpression(b.Expr)
+		c, err := exprToExpression(v.Expr)
 		if err != nil {
 			return nil, err
 		}
 
 		return expression.NewNot(c), nil
+	case *sqlparser.SQLVal:
+		switch v.Type {
+		case sqlparser.StrVal:
+			return expression.NewLiteral(string(v.Val), sql.String), nil
+		case sqlparser.IntVal:
+			//TODO: Use smallest integer representation and widen later.
+			n, _ := strconv.ParseInt(string(v.Val), 10, 64)
+			return expression.NewLiteral(n, sql.BigInteger), nil
+		case sqlparser.HexVal:
+			//TODO
+			return nil, errUnsupported(v)
+		default:
+			//TODO
+			return nil, errUnsupported(v)
+		}
+	case sqlparser.BoolVal:
+		return expression.NewLiteral(bool(v), sql.Boolean), nil
+	case *sqlparser.NullVal:
+		//TODO
+		return expression.NewLiteral(nil, sql.Null), nil
+	case *sqlparser.ColName:
+		//TODO: add handling of case sensitiveness.
+		return expression.NewUnresolvedColumn(v.Name.Lowered()), nil
+	case *sqlparser.FuncExpr:
+		exprs, err := selectExprsToExpressions(v.Exprs)
+		if err != nil {
+			return nil, err
+		}
+
+		return expression.NewUnresolvedFunction(v.Name.Lowered(),
+			v.IsAggregate(), exprs...), nil
 	}
 }
 
 func comparisonExprToExpression(c *sqlparser.ComparisonExpr) (sql.Expression,
 	error) {
 
-	left, err := valExprToExpression(c.Left)
+	left, err := exprToExpression(c.Left)
 	if err != nil {
 		return nil, err
 	}
 
-	right, err := valExprToExpression(c.Right)
+	right, err := exprToExpression(c.Right)
 	if err != nil {
 		return nil, err
 	}
@@ -302,7 +314,7 @@ func comparisonExprToExpression(c *sqlparser.ComparisonExpr) (sql.Expression,
 func groupByToExpressions(g sqlparser.GroupBy) ([]sql.Expression, error) {
 	es := make([]sql.Expression, len(g))
 	for i, ve := range g {
-		e, err := valExprToExpression(ve)
+		e, err := exprToExpression(ve)
 		if err != nil {
 			return nil, err
 		}
@@ -313,44 +325,6 @@ func groupByToExpressions(g sqlparser.GroupBy) ([]sql.Expression, error) {
 	return es, nil
 }
 
-func valExprToExpression(ve sqlparser.ValExpr) (sql.Expression, error) {
-	switch v := ve.(type) {
-	default:
-		return nil, errUnsupported(v)
-	case *sqlparser.SQLVal:
-		switch v.Type {
-		case sqlparser.StrVal:
-			return expression.NewLiteral(string(v.Val), sql.String), nil
-		case sqlparser.IntVal:
-			//TODO: Use smallest integer representation and widen later.
-			n, _ := strconv.ParseInt(string(v.Val), 10, 64)
-			return expression.NewLiteral(n, sql.BigInteger), nil
-		case sqlparser.HexVal:
-			//TODO
-			return nil, errUnsupported(v)
-		default:
-			//TODO
-			return nil, errUnsupported(v)
-		}
-	case sqlparser.BoolVal:
-		return expression.NewLiteral(bool(v), sql.Boolean), nil
-	case *sqlparser.NullVal:
-		//TODO
-		return expression.NewLiteral(nil, sql.Null), nil
-	case *sqlparser.ColName:
-		//TODO: add handling of case sensitiveness.
-		return expression.NewUnresolvedColumn(v.Name.Lowered()), nil
-	case *sqlparser.FuncExpr:
-		exprs, err := selectExprsToExpressions(v.Exprs)
-		if err != nil {
-			return nil, err
-		}
-
-		return expression.NewUnresolvedFunction(v.Name.Lowered(),
-			v.IsAggregate(), exprs...), nil
-	}
-}
-
 func selectExprToExpression(se sqlparser.SelectExpr) (sql.Expression, error) {
 	switch e := se.(type) {
 	default: