feat: implement comprehensive subquery and expression parsing

Parser Features:
- Add subquery support in WHERE clause (scalar subqueries)
- Add EXISTS/NOT EXISTS subquery expressions
- Add IN/NOT IN with subquery support
- Add ANY/ALL subquery operators (= ANY, > ALL, etc.)
- Add CASE expression parsing (simple and searched forms)
- Add BETWEEN/NOT BETWEEN operator parsing
- Add LIKE/NOT LIKE/ILIKE pattern matching
- Add IS NULL/IS NOT NULL postfix operators
- Add parenthesized expression handling
- Add NULL literal support

AST Changes:
- Add SubqueryExpression for scalar subqueries
- Add AnyExpression for expr op ANY (subquery)
- Add AllExpression for expr op ALL (subquery)
- Update InExpression to support both value lists and subqueries

This significantly improves SQL-99 compliance and real-world SQL parsing.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: 2 people

pkg/sql/ast/ast.go

@@ -309,21 +309,57 @@ func (e ExistsExpression) Children() []Node {
 	return []Node{e.Subquery}
 }
 
-// InExpression represents expr IN (values)
+// InExpression represents expr IN (values) or expr IN (subquery)
 type InExpression struct {
-	Expr Expression
-	List []Expression
-	Not  bool
+	Expr     Expression
+	List     []Expression // For value list: IN (1, 2, 3)
+	Subquery Statement    // For subquery: IN (SELECT ...)
+	Not      bool
 }
 
 func (i *InExpression) expressionNode()     {}
 func (i InExpression) TokenLiteral() string { return "IN" }
 func (i InExpression) Children() []Node {
 	children := []Node{i.Expr}
-	children = append(children, nodifyExpressions(i.List)...)
+	if i.Subquery != nil {
+		children = append(children, i.Subquery)
+	} else {
+		children = append(children, nodifyExpressions(i.List)...)
+	}
 	return children
 }
 
+// SubqueryExpression represents a scalar subquery (SELECT ...)
+type SubqueryExpression struct {
+	Subquery Statement
+}
+
+func (s *SubqueryExpression) expressionNode()     {}
+func (s SubqueryExpression) TokenLiteral() string { return "SUBQUERY" }
+func (s SubqueryExpression) Children() []Node     { return []Node{s.Subquery} }
+
+// AnyExpression represents expr op ANY (subquery)
+type AnyExpression struct {
+	Expr     Expression
+	Operator string
+	Subquery Statement
+}
+
+func (a *AnyExpression) expressionNode()     {}
+func (a AnyExpression) TokenLiteral() string { return "ANY" }
+func (a AnyExpression) Children() []Node     { return []Node{a.Expr, a.Subquery} }
+
+// AllExpression represents expr op ALL (subquery)
+type AllExpression struct {
+	Expr     Expression
+	Operator string
+	Subquery Statement
+}
+
+func (al *AllExpression) expressionNode()     {}
+func (al AllExpression) TokenLiteral() string { return "ALL" }
+func (al AllExpression) Children() []Node     { return []Node{al.Expr, al.Subquery} }
+
 // BetweenExpression represents expr BETWEEN lower AND upper
 type BetweenExpression struct {
 	Expr  Expression