Add XOR operator support.

go/vt/sqlparser/ast.go

@@ -578,6 +578,11 @@ type (
 		Left, Right Expr
 	}
 
+	// XorExpr represents an XOR expression.
+	XorExpr struct {
+		Left, Right Expr
+	}
+
 	// NotExpr represents a NOT expression.
 	NotExpr struct {
 		Expr Expr
@@ -759,6 +764,7 @@ type (
 // iExpr ensures that only expressions nodes can be assigned to a Expr
 func (*AndExpr) iExpr()           {}
 func (*OrExpr) iExpr()            {}
+func (*XorExpr) iExpr()           {}
 func (*NotExpr) iExpr()           {}
 func (*ComparisonExpr) iExpr()    {}
 func (*RangeCond) iExpr()         {}
@@ -1538,6 +1544,11 @@ func (node *OrExpr) Format(buf *TrackedBuffer) {
 	buf.astPrintf(node, "%v or %v", node.Left, node.Right)
 }
 
+// Format formats the node.
+func (node *XorExpr) Format(buf *TrackedBuffer) {
+	buf.astPrintf(node, "%v xor %v", node.Left, node.Right)
+}
+
 // Format formats the node.
 func (node *NotExpr) Format(buf *TrackedBuffer) {
 	buf.astPrintf(node, "not %v", node.Expr)

go/vt/sqlparser/parse_test.go

@@ -635,6 +635,16 @@ var (
 	}, {
 		input:  "select /* OR in select columns */ (a or b) from t where c = 5",
 		output: "select /* OR in select columns */ a or b from t where c = 5",
+	}, {
+		input: "select /* XOR of columns in where */ * from t where a xor b",
+	}, {
+		input: "select /* XOR of mixed columns in where */ * from t where a = 5 xor b and c is not null",
+	}, {
+		input:  "select /* XOR in select columns */ (a xor b) from t where c = 5",
+		output: "select /* XOR in select columns */ a xor b from t where c = 5",
+	}, {
+		input:  "select /* XOR in select columns */ * from t where (1 xor c1 > 0)",
+		output: "select /* XOR in select columns */ * from t where 1 xor c1 > 0",
 	}, {
 		input: "select /* bool as select value */ a, true from t",
 	}, {

go/vt/sqlparser/precedence.go

@@ -49,8 +49,8 @@ func precedenceFor(in Expr) Precendence {
 	switch node := in.(type) {
 	case *OrExpr:
 		return P16
-	//case *XorExpr: TODO add parser support for XOR
-	//	return P15
+	case *XorExpr:
+		return P15
 	case *AndExpr:
 		return P14
 	case *NotExpr:

go/vt/sqlparser/precedence_test.go

@@ -30,6 +30,8 @@ func readable(node Expr) string {
 		return fmt.Sprintf("(%s or %s)", readable(node.Left), readable(node.Right))
 	case *AndExpr:
 		return fmt.Sprintf("(%s and %s)", readable(node.Left), readable(node.Right))
+	case *XorExpr:
+		return fmt.Sprintf("(%s xor %s)", readable(node.Left), readable(node.Right))
 	case *BinaryExpr:
 		return fmt.Sprintf("(%s %s %s)", readable(node.Left), node.Operator, readable(node.Right))
 	case *IsExpr:

go/vt/sqlparser/random_expr.go

@@ -86,6 +86,7 @@ func (g *generator) booleanExpr() Expr {
 
 	options := []exprF{
 		func() Expr { return g.andExpr() },
+		func() Expr { return g.xorExpr() },
 		func() Expr { return g.orExpr() },
 		func() Expr { return g.comparison(g.intExpr) },
 		func() Expr { return g.comparison(g.stringExpr) },
@@ -250,6 +251,15 @@ func (g *generator) orExpr() Expr {
 	}
 }
 
+func (g *generator) xorExpr() Expr {
+	g.enter()
+	defer g.exit()
+	return &XorExpr{
+		Left:  g.booleanExpr(),
+		Right: g.booleanExpr(),
+	}
+}
+
 func (g *generator) notExpr() Expr {
 	g.enter()
 	defer g.exit()