perf: build IN-list AST children in linear time

The IN-list parser previously called AstNode::add_child for every value.
Each append walked all existing siblings, making construction quadratic
in the number of list elements even though tokenization itself is linear.

Keep a tail pointer local to parse_in and attach each parsed expression
in constant time. Preserve the left-hand expression, value order, nested
expression roots and the separate subquery path. Both PostgreSQL and
MySQL benefit without adding allocations or changing the 48-byte AST ABI.

Add regression tests inspecting every value in 3,000-element lists across
arena blocks, together with emission checks for NOT IN, NULL, functions,
arithmetic, tuples, nested lists and subqueries in both dialects. These
correctness tests passed in the full suite; timing thresholds are not
part of the tests. Benchmark code and reports are intentionally excluded
from this branch's commits.

Author: renecannao

include/sql_parser/expression_parser.h

@@ -542,9 +542,15 @@ class ExpressionParser {
                 AstNode* sq = parse_subquery_inner();
                 node->add_child(sq);
             } else {
+                // Expression roots are single, unattached nodes. Keep the tail
+                // locally so appending N IN-list values takes O(N), not O(N^2).
+                AstNode* tail = left;
                 while (true) {
                     AstNode* val = parse();
-                    if (val) node->add_child(val);
+                    if (val) {
+                        tail->next_sibling = val;
+                        tail = val;
+                    }
                     if (tok_.peek().type == TokenType::TK_COMMA) {
                         tok_.skip();
                     } else {

tests/test_expression.cpp

@@ -1,6 +1,7 @@
 #include <gtest/gtest.h>
 #include "sql_parser/parser.h"
 #include "sql_parser/expression_parser.h"
+#include "sql_parser/emitter.h"
 
 using namespace sql_parser;
 
@@ -292,6 +293,81 @@ TEST_F(ExpressionTest, InList) {
     EXPECT_EQ(count, 4);
 }
 
+template <Dialect D>
+static void check_large_in_list() {
+    // Cross arena blocks and inspect every value: appending must neither drop
+    // elements nor reorder/overwrite the left-hand expression or list tail.
+    constexpr int count = 3000;
+    std::string sql = "key_col IN (";
+    for (int i = 0; i < count; ++i) {
+        if (i) sql += ", ";
+        sql += std::to_string(i);
+    }
+    sql += ")";
+    Arena arena;
+    Tokenizer<D> tok;
+    tok.reset(sql.data(), sql.size());
+    ExpressionParser<D> parser(tok, arena);
+    AstNode* node = parser.parse();
+    ASSERT_NE(node, nullptr);
+    ASSERT_EQ(node->type, NodeType::NODE_IN_LIST);
+    ASSERT_NE(node->first_child, nullptr);
+    EXPECT_EQ(std::string(node->first_child->value_ptr, node->first_child->value_len), "key_col");
+    const AstNode* value = node->first_child->next_sibling;
+    for (int i = 0; i < count; ++i) {
+        ASSERT_NE(value, nullptr) << "Missing item " << i;
+        EXPECT_EQ(value->type, NodeType::NODE_LITERAL_INT);
+        EXPECT_EQ(std::string(value->value_ptr, value->value_len), std::to_string(i));
+        value = value->next_sibling;
+    }
+    EXPECT_EQ(value, nullptr);
+    EXPECT_EQ(tok.peek().type, TokenType::TK_EOF);
+    Emitter<D> emitter(arena);
+    emitter.emit(node);
+    StringRef result = emitter.result();
+    EXPECT_EQ(std::string(result.ptr, result.len), sql);
+}
+
+TEST(InListAppend, LargeMySQLListRetainsEveryValue) {
+    check_large_in_list<Dialect::MySQL>();
+}
+
+TEST(InListAppend, LargePostgreSQLListRetainsEveryValue) {
+    check_large_in_list<Dialect::PostgreSQL>();
+}
+
+template <Dialect D>
+static void check_nested_in_lists() {
+    const char* cases[] = {
+        "x IN (1)",
+        "x NOT IN (1, NULL, f(2, 3), 4 + 5)",
+        "(x, y) IN ((1, 2), (3, 4))",
+        "x IN (1, (y IN (2, 3)), 4)",
+        "x IN (SELECT y FROM t WHERE z IN (2, 3))",
+    };
+    Parser<D> parser;
+    for (const char* expression : cases) {
+        const std::string sql = std::string("SELECT * FROM t WHERE ") + expression;
+        SCOPED_TRACE(sql);
+        auto result = parser.parse(sql.data(), sql.size());
+        ASSERT_EQ(result.status, ParseResult::OK);
+        ASSERT_TRUE(result.full_input);
+        ASSERT_NE(result.ast, nullptr);
+        Emitter<D> emitter(parser.arena());
+        emitter.emit(result.ast);
+        StringRef emitted = emitter.result();
+        EXPECT_EQ(std::string(emitted.ptr, emitted.len), sql);
+    }
+}
+
+TEST(InListAppend, NestedMySQLListsAndSubqueryRoundTrip) {
+    check_nested_in_lists<Dialect::MySQL>();
+}
+
+TEST(InListAppend, NestedPostgreSQLListsAndSubqueryRoundTrip) {
+    check_nested_in_lists<Dialect::PostgreSQL>();
+}
+
 TEST_F(ExpressionTest, FunctionCall) {
     AstNode* node = parse_expr("COUNT(*)");
     ASSERT_NE(node, nullptr);