feat: Add UNNEST foundation - AST, lexer, and formatter support

Foundation work for UNNEST row expansion feature to handle FIX repeated groups
and other delimited string splitting with row multiplication.

Changes:
- Add Unnest variant to SqlExpression enum in AST
  - Stores column expression and delimiter
  - Documented as row expansion function
- Add UNNEST keyword token to lexer
  - Recognized in both keyword mappings
- Update formatters to handle Unnest expressions
  - AST formatter shows Unnest structure
  - SQL formatter outputs UNNEST(column, 'delimiter')
- Add UNNEST to text navigation token formatting

Architecture:
- UNNEST will be an expression that causes row multiplication
- Each row with UNNEST expression splits into N rows
- NULL padding for mismatched lengths across multiple UNNEST calls
- Use case: Expanding FIX allocations like "ACC_1|ACC_2|ACC_3"

Next steps: Parser implementation, evaluator, and query executor

All tests passing (397 passed)

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

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

Author: TimelordUK

src/sql/parser/ast.rs

@@ -178,12 +178,19 @@ pub enum SqlExpression {
     ScalarSubquery {
         query: Box<SelectStatement>,
     },
-    /// IN subquery that returns multiple values  
+    /// IN subquery that returns multiple values
     /// Used in expressions like: WHERE col IN (SELECT id FROM table WHERE ...)
     InSubquery {
         expr: Box<SqlExpression>,
         subquery: Box<SelectStatement>,
     },
+    /// UNNEST - Row expansion function that splits delimited strings
+    /// Used like: SELECT UNNEST(accounts, '|') AS account FROM fix_trades
+    /// Causes row multiplication - one input row becomes N output rows
+    Unnest {
+        column: Box<SqlExpression>,
+        delimiter: String,
+    },
     /// NOT IN subquery
     /// Used in expressions like: WHERE col NOT IN (SELECT id FROM table WHERE ...)
     NotInSubquery {

src/sql/parser/formatter.rs

@@ -318,6 +318,13 @@ pub fn format_expression_ast(expr: &SqlExpression) -> String {
                 format_expression_ast(expr)
             )
         }
+        SqlExpression::Unnest { column, delimiter } => {
+            format!(
+                "Unnest {{ column: {}, delimiter: \"{}\" }}",
+                format_expression_ast(column),
+                delimiter
+            )
+        }
     }
 }
 
@@ -817,6 +824,9 @@ pub fn format_expression(expr: &SqlExpression) -> String {
         SqlExpression::NotInSubquery { expr, subquery: _ } => {
             format!("{} NOT IN (SELECT ...)", format_expression(expr))
         }
+        SqlExpression::Unnest { column, delimiter } => {
+            format!("UNNEST({}, '{}')", format_expression(column), delimiter)
+        }
     }
 }
 

src/sql/parser/lexer.rs

@@ -54,6 +54,9 @@ pub enum Token {
     // Special CTE keyword
     Web, // WEB (for WEB CTEs)
 
+    // Row expansion functions
+    Unnest, // UNNEST (for expanding delimited strings into rows)
+
     // JOIN keywords
     Join,  // JOIN keyword
     Inner, // INNER JOIN
@@ -142,6 +145,7 @@ impl Token {
             "INTERSECT" => Some(Token::Intersect),
             "EXCEPT" => Some(Token::Except),
             "WEB" => Some(Token::Web),
+            "UNNEST" => Some(Token::Unnest),
             "JOIN" => Some(Token::Join),
             "INNER" => Some(Token::Inner),
             "LEFT" => Some(Token::Left),
@@ -575,6 +579,8 @@ impl Lexer {
                     "EXCEPT" => Token::Except,
                     // Special CTE keyword
                     "WEB" => Token::Web,
+                    // Row expansion functions
+                    "UNNEST" => Token::Unnest,
                     // JOIN keywords
                     "JOIN" => Token::Join,
                     "INNER" => Token::Inner,

src/text_navigation.rs

@@ -205,6 +205,8 @@ impl TextNavigator {
             Token::Except => "EXCEPT",
             // Special CTE keyword
             Token::Web => "WEB",
+            // Row expansion functions
+            Token::Unnest => "UNNEST",
             Token::Identifier(s) => s,
             Token::QuotedIdentifier(s) => s,
             Token::StringLiteral(s) => s,