Support Expr lists after WHERE

parser.go

@@ -2982,14 +2982,42 @@ func (p *Parser) parseFrameSpec() (_ *FrameSpec, err error) {
 	return &spec, nil
 }
 
-func (p *Parser) parseParenExpr() (_ *ParenExpr, err error) {
-	var expr ParenExpr
-	expr.Lparen, _, _ = p.scan()
-	if expr.X, err = p.ParseExpr(); err != nil {
-		return &expr, err
+func (p *Parser) parseParenExpr() (Expr, error) {
+	lparen, _, _ := p.scan()
+
+	// Parse the first expression
+	x, err := p.ParseExpr()
+	if err != nil {
+		return nil, err
 	}
-	expr.Rparen, _, _ = p.scan()
-	return &expr, nil
+
+	// If there's no comma after the first expression, treat it as a normal parenthesized expression
+	if p.peek() != COMMA {
+		rparen, _, _ := p.scan()
+		return &ParenExpr{Lparen: lparen, X: x, Rparen: rparen}, nil
+	}
+
+	// If there's a comma, we're dealing with an expression list
+	var list ExprList
+	list.Lparen = lparen
+	list.Exprs = append(list.Exprs, x)
+
+	for p.peek() == COMMA {
+		p.scan() // consume the comma
+
+		expr, err := p.ParseExpr()
+		if err != nil {
+			return &list, err
+		}
+		list.Exprs = append(list.Exprs, expr)
+	}
+
+	if p.peek() != RP {
+		return &list, p.errorExpected(p.pos, p.tok, "right paren")
+	}
+	list.Rparen, _, _ = p.scan()
+
+	return &list, nil
 }
 
 func (p *Parser) parseCastExpr() (_ *CastExpr, err error) {

parser_test.go

@@ -2566,6 +2566,53 @@ func TestParser_ParseStatement(t *testing.T) {
 			WhereExpr: &sql.BoolLit{ValuePos: pos(15), Value: true},
 		})
 
+		AssertParseStatement(t, `SELECT 1 WHERE true AND true`, &sql.SelectStatement{
+			Select:  pos(0),
+			Columns: []*sql.ResultColumn{{Expr: &sql.NumberLit{ValuePos: pos(7), Value: "1"}}},
+			Where:   pos(9),
+			WhereExpr: &sql.BinaryExpr{
+				X:     &sql.BoolLit{ValuePos: pos(15), Value: true},
+				OpPos: pos(20),
+				Op:    sql.AND,
+				Y:     &sql.BoolLit{ValuePos: pos(24), Value: true},
+			},
+		})
+
+		AssertParseStatement(t, `SELECT 1 WHERE true AND (0, 1) = (SELECT 2,3)`, &sql.SelectStatement{
+			Select:  pos(0),
+			Columns: []*sql.ResultColumn{{Expr: &sql.NumberLit{ValuePos: pos(7), Value: "1"}}}, Where: pos(9),
+			WhereExpr: &sql.BinaryExpr{
+				X:     &sql.BoolLit{ValuePos: pos(15), Value: true},
+				OpPos: pos(20),
+				Op:    sql.AND,
+				Y: &sql.BinaryExpr{
+					X: &sql.ExprList{
+						Lparen: pos(24),
+						Exprs: []sql.Expr{
+							&sql.NumberLit{ValuePos: pos(25), Value: "0"},
+							&sql.NumberLit{ValuePos: pos(28), Value: "1"},
+						},
+						Rparen: pos(29),
+					},
+					OpPos: pos(31),
+					Op:    sql.EQ,
+					Y: &sql.ParenExpr{
+						Lparen: pos(33),
+						X: sql.SelectExpr{
+							SelectStatement: &sql.SelectStatement{
+								Select: pos(34),
+								Columns: []*sql.ResultColumn{
+									{Expr: &sql.NumberLit{ValuePos: pos(41), Value: "2"}},
+									{Expr: &sql.NumberLit{ValuePos: pos(43), Value: "3"}},
+								},
+							},
+						},
+						Rparen: pos(44),
+					},
+				},
+			},
+		})
+
 		AssertParseStatement(t, `SELECT * GROUP BY foo, bar`, &sql.SelectStatement{
 			Select:  pos(0),
 			Columns: []*sql.ResultColumn{{Star: pos(7)}},