fix(parser): support qualified names and nested functions in SQL

The tree-sitter grammar's `positional_arg` rule was too restrictive,
only accepting simple identifiers, numbers, strings, and wildcards.
This caused parse failures for common SQL patterns:

1. Table alias prefixes: `SELECT p.name, SUM(s.quantity)`
2. Cross-table arithmetic: `SUM(quantity * price)`
3. Nested function calls: `ROUND(AVG(price), 2)`
4. Full table qualifiers: `products.product_name`

The fix extends `positional_arg` to also accept:
- `qualified_name` for table.column references
- `function_call` for nested functions
- Binary arithmetic/comparison expressions
- Parenthesized expressions

Adds 6 regression tests covering all reported limitations.

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

Author: cpsievert

src/parser/builder.rs

@@ -3134,4 +3134,104 @@ mod tests {
         assert!(ok);
         eprintln!("{:?}", palette);
     }
+
+    // ========================================
+    // Parser Limitation Tests (from ggsql-parser-limitations.md)
+    // Tests to verify and fix reported parsing issues
+    // ========================================
+
+    #[test]
+    fn test_table_alias_prefixes_in_select() {
+        // Issue 1: Table alias prefixes in SELECT clause
+        // Query like `SELECT p.product_name FROM products p` should parse
+        let query = r#"
+            SELECT p.product_name, SUM(s.quantity) as total
+            FROM sales s JOIN products p ON s.product_id = p.product_id
+            GROUP BY p.product_name
+            VISUALISE
+            DRAW bar MAPPING product_name AS x, total AS y
+        "#;
+
+        let result = parse_test_query(query);
+        assert!(result.is_ok(), "Parse failed: {:?}", result);
+    }
+
+    #[test]
+    fn test_cross_table_arithmetic() {
+        // Issue 2: Cross-table arithmetic expressions
+        // `quantity * price` across joined tables should work
+        let query = r#"
+            WITH t AS (
+                SELECT region, SUM(quantity * price) as revenue
+                FROM sales JOIN products ON sales.product_id = products.product_id
+                GROUP BY region
+            )
+            VISUALISE FROM t
+            DRAW bar MAPPING region AS x, revenue AS y
+        "#;
+
+        let result = parse_test_query(query);
+        assert!(result.is_ok(), "Parse failed: {:?}", result);
+    }
+
+    #[test]
+    fn test_nested_function_calls() {
+        // Issue 3: Nested function calls
+        // `ROUND(AVG(price), 2)` should parse
+        let query = r#"
+            SELECT category, ROUND(AVG(price), 2) as avg_price
+            FROM products
+            GROUP BY category
+            VISUALISE
+            DRAW bar MAPPING category AS x, avg_price AS y
+        "#;
+
+        let result = parse_test_query(query);
+        assert!(result.is_ok(), "Parse failed: {:?}", result);
+    }
+
+    #[test]
+    fn test_full_table_name_qualifiers() {
+        // Issue 4: Full table name qualifiers
+        // `products.product_name` (full table name, not alias) should work
+        let query = r#"
+            SELECT products.product_name, SUM(sales.quantity) as total
+            FROM sales
+            JOIN products ON sales.product_id = products.product_id
+            GROUP BY products.product_name
+            VISUALISE
+            DRAW bar MAPPING product_name AS x, total AS y
+        "#;
+
+        let result = parse_test_query(query);
+        assert!(result.is_ok(), "Parse failed: {:?}", result);
+    }
+
+    #[test]
+    fn test_simple_cross_table_multiplication() {
+        // Simplified version of cross-table arithmetic
+        let query = r#"
+            SELECT a.x * b.y as result
+            FROM a JOIN b ON a.id = b.id
+            VISUALISE
+            DRAW point MAPPING result AS x
+        "#;
+
+        let result = parse_test_query(query);
+        assert!(result.is_ok(), "Parse failed: {:?}", result);
+    }
+
+    #[test]
+    fn test_deeply_nested_functions() {
+        // Multiple levels of nesting
+        let query = r#"
+            SELECT COALESCE(NULLIF(TRIM(name), ''), 'Unknown') as clean_name
+            FROM data
+            VISUALISE
+            DRAW bar MAPPING clean_name AS x
+        "#;
+
+        let result = parse_test_query(query);
+        assert!(result.is_ok(), "Parse failed: {:?}", result);
+    }
 }

tree-sitter-ggsql/grammar.js

@@ -276,12 +276,25 @@ module.exports = grammar({
       field('value', $.positional_arg)
     ),
 
-    positional_arg: $ => choice(
-      $.identifier,
+    // Positional argument: supports complex expressions including:
+    // - Simple values: identifier, number, string, *
+    // - Qualified names: table.column
+    // - Nested function calls: ROUND(AVG(x), 2)
+    // - Arithmetic expressions: quantity * price
+    // - Type casts: value::type
+    positional_arg: $ => prec.left(choice(
+      // Simple values
+      $.qualified_name,  // Handles both simple identifiers and table.column
       $.number,
       $.string,
-      '*'
-    ),
+      '*',
+      // Nested function call
+      $.function_call,
+      // Arithmetic/comparison expression (binary operators)
+      seq($.positional_arg, choice('+', '-', '*', '/', '%', '||', '::', '<', '>', '<=', '>=', '=', '!=', '<>'), $.positional_arg),
+      // Parenthesized expression
+      seq('(', $.positional_arg, ')')
+    )),
 
     // Namespaced identifier: matches "namespace:name" pattern
     // Examples: ggsql:penguins, ggsql:airquality

tree-sitter-ggsql/test/corpus/basic.txt

@@ -1123,8 +1123,9 @@ DRAW line MAPPING x AS x, total AS y
             (function_args
               (function_arg
                 (positional_arg
-                  (identifier
-                    (bare_identifier)))))
+                  (qualified_name
+                    (identifier
+                      (bare_identifier))))))
             (window_specification
               (window_order_clause
                 (order_item