Continue parsing binary operators after parenthesized ORDER BY expressions (#117)

Fixes ORDER BY expressions like `(a + b) * c` being truncated to just `(a + b)`.

- Add isBinaryOperatorToken() to detect binary operators after parenthesized expressions
- Add parseExpressionFrom() to continue Pratt parsing from an existing left operand
- Check for binary operators after parsing parenthesized expressions in ORDER BY

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

parser/expression.go

@@ -133,6 +133,32 @@ func (p *Parser) parseExpressionList() []ast.Expression {
 	return exprs
 }
 
+// isBinaryOperatorToken checks if a token is a binary operator that could continue an expression
+func isBinaryOperatorToken(t token.Token) bool {
+	switch t {
+	case token.PLUS, token.MINUS, token.ASTERISK, token.SLASH, token.PERCENT,
+		token.EQ, token.NEQ, token.LT, token.GT, token.LTE, token.GTE,
+		token.AND, token.OR, token.CONCAT, token.DIV, token.MOD:
+		return true
+	}
+	return false
+}
+
+// parseExpressionFrom continues parsing an expression from an existing left operand
+func (p *Parser) parseExpressionFrom(left ast.Expression, precedence int) ast.Expression {
+	for !p.currentIs(token.EOF) && precedence < p.precedenceForCurrent() {
+		startPos := p.current.Pos
+		left = p.parseInfixExpression(left)
+		if left == nil {
+			return nil
+		}
+		if p.current.Pos == startPos {
+			break
+		}
+	}
+	return left
+}
+
 // parseCreateOrderByExpressions parses expressions for CREATE TABLE ORDER BY clause.
 // Returns the expressions and a boolean indicating if any ASC/DESC modifier was found.
 // This is different from regular expression list parsing because ORDER BY in CREATE TABLE

parser/parser.go

@@ -2627,8 +2627,18 @@ func (p *Parser) parseTableOptions(create *ast.CreateQuery) {
 							Value:    exprs,
 						}}
 					} else {
-						// Single expression in parentheses without modifiers - just extract it
-						create.OrderBy = exprs
+						// Single expression in parentheses without modifiers
+						// Check if there's a binary operator continuing the expression (e.g., (a + b) * c)
+						expr := exprs[0]
+						if isBinaryOperatorToken(p.current.Token) {
+							// Mark the expression as parenthesized and continue parsing
+							if binExpr, ok := expr.(*ast.BinaryExpr); ok {
+								binExpr.Parenthesized = true
+							}
+							// Continue parsing from this expression as left operand
+							expr = p.parseExpressionFrom(expr, LOWEST)
+						}
+						create.OrderBy = []ast.Expression{expr}
 					}
 				} else {
 					// Use ALIAS_PREC to avoid consuming AS keyword (for AS SELECT)

parser/testdata/02911_analyzer_order_by_read_in_order_query_plan/metadata.json

@@ -1,5 +1 @@
-{
-  "explain_todo": {
-    "stmt63": true
-  }
-}
+{}