@@ -50,7 +50,7 @@ Full benchmark + corpus report: `bash scripts/run_benchmarks.sh report.md`.
 
 ### Namespace
 
-Everything parser-side is in `namespace sql_parser`. All templates are parameterized on `Dialect D`.
+Everything parser-side is in `namespace sql_parser`. Templates with dialect-specific behavior use `Dialect D`; dialect-independent generic helpers are exempt.
 
 ### Adding a new deep parser
 
@@ -242,7 +242,7 @@ Subclass `TransactionManager`. Provide `begin()/commit()/rollback()` semantics;
 
 ## Tests
 
-Google Test. 1,160 tests across 50 test files. Validated against 86K+ external queries from 9 corpora (99.92% fully parsed).
+Google Test. Run `make test` for the current test totals. Validated against 86K+ external queries from 9 corpora (99.92% fully parsed).
 
 Run a single test: `./run_tests --gtest_filter="*WindowFunc*"`.
 
 
@@ -63,6 +63,10 @@ TEST_SRCS = $(TEST_DIR)/test_main.cpp \
             $(TEST_DIR)/test_pg_foreign_ddl.cpp \
             $(TEST_DIR)/test_pg_table_constraints.cpp \
             $(TEST_DIR)/test_pg_maintenance.cpp \
+            $(TEST_DIR)/test_review_expressions.cpp \
+            $(TEST_DIR)/test_review_ast.cpp \
+            $(TEST_DIR)/test_review_transactions.cpp \
+            $(TEST_DIR)/test_review_runtime.cpp \
             $(TEST_DIR)/test_pg_admin_commands.cpp \
             $(TEST_DIR)/test_pg_session_commands.cpp \
             $(TEST_DIR)/test_pg_dml_extensions.cpp \
 
@@ -61,7 +61,7 @@ coverage and remaining syntax gaps.
 ### Build
 
 ```bash
-make all                # Build library + run all 1,160 tests
+make all                # Build library + run the full test suite
 make lib                # Just the static library
 make bench              # Benchmarks (-O2); use scripts/run_benchmarks.sh for -O3 report
 make build-sqlengine    # Interactive SQL CLI
@@ -264,7 +264,7 @@ auto report = recovery.recover();
           │           ▼
           │   ┌──────────────┐
           │   │ Full AST in  │
-          │   │ arena (32 B  │
+          │   │ arena (48 B  │
           │   │ nodes)       │
           │   └──────┬───────┘
           │          │
@@ -403,11 +403,11 @@ owning copies, subtree replacement and context-aware parameterization.
 | `engine_stress_test` | `make engine-stress` | Direct-API engine stress test |
 | `bench_distributed` | `make bench-distributed` | Distributed query benchmark + pipeline breakdown |
 | `run_bench` | `make bench` | Google-Benchmark micro-benchmarks |
-| `run_tests` | `make test` | 1,160 Google-Test unit tests |
+| `run_tests` | `make test` | Google-Test unit tests |
 
 ## Testing
 
-- **1,160 unit tests** (Google Test, 50 test files)
+- **Unit tests** (Google Test; run `make test` for current totals)
 - **86,467 external corpus queries** validated via `scripts/run_benchmarks.sh`
 - **CI** — runs unit tests + a corpus-subset on every push/PR
 - **Integration tests** (MySQL/PgSQL) auto-skip when no live backend is reachable
@@ -448,7 +448,7 @@ src/sql_engine/               function_registry.cpp, in_memory_catalog.cpp,
                               pgsql_remote_executor.cpp, multi_remote_executor.cpp
 
 tools/    sqlengine.cpp  mysql_server.cpp  engine_stress_test.cpp  bench_distributed.cpp
-tests/    1,160 Google-Test tests across 50 files
+tests/    Google-Test unit and regression tests
 bench/    bench_parser.cpp  bench_engine.cpp  bench_comparison.cpp
 scripts/  run_benchmarks.sh  run_comparison.sh
 docs/benchmarks/  latest.md  comparison.md  distributed_comparison.md  REPRODUCING.md
 
@@ -51,6 +51,19 @@ tree. Validation happens before mutation; errors leave input links unchanged.
 Nodes are never freed individually, and callers retain responsibility for the
 lifetimes of every participating arena.
 
+Identifier and alias values omit their surrounding delimiters; original spelling
+is retained separately in `source()`. Token text can still contain doubled
+identifier quotes; it is not a fully decoded SQL identifier. When editing a
+parsed value for re-emission,
+also clear its retained spelling with `node.set_source({})` (or replace it with
+matching source text). `set_value()` alone deliberately leaves `source()` intact.
+The emitter uses identifier flags to quote a changed delimited identifier when
+no retained spelling remains.
+
+Removing a required child can produce an incomplete SQL tree. Emission tolerates
+missing children, but callers must validate edited SQL before using it; tree
+link validation does not establish SQL grammar validity.
+
 Failed operations can consume arena space; they do not reset or roll back an
 arena that might contain other live nodes. Temporary STL allocation failures use
 the usual C++ exception behavior.
 
@@ -215,6 +215,24 @@ for name resolution, types, privileges and semantic checks. Corpus acceptance
 alone does not establish grammar parity or round-trip equivalence for every
 accepted statement.
 
+## Local execution and review corrections
+
+PostgreSQL `LIMIT ALL` and `LIMIT NULL` preserve an unlimited local row count;
+`OFFSET NULL` is zero. The local planner rejects limit/offset expressions it
+cannot evaluate, including dynamic, negative and overflowing counts, rather
+than treating their text as a number. PostgreSQL binary `||` uses the existing
+concatenation evaluator while retaining PostgreSQL operator precedence.
+MySQL ROWS/RANGE frames are parsed and emitted, but remain unsupported by the
+local planner. Nested ordinary function calls no longer allocate discarded
+expression trees during speculative type-prefix parsing.
+
+Session transaction dispatch requires a successful, complete parse before any
+transaction-manager call. PostgreSQL SAVEPOINT, RELEASE and ROLLBACK TO use the
+named operand, including identifier case folding and quoted-name decoding.
+Prepared transactions, chaining and other options the local manager cannot
+execute are rejected. Basic MySQL controls retain optional WORK and named
+SAVEPOINT forms. Parsing transaction syntax alone does not execute it.
+
 ## Multiple statements
 
 ```cpp
@@ -232,6 +250,10 @@ All returned ASTs remain alive until the next `parse`, `parse_all`, or `reset`
 on that parser. Input SQL must remain alive too. Use `clone_ast` to retain a tree
 independently. The result vector owns records, not the ASTs or source bytes.
 
+Both `parse` and `parse_all` reject input longer than `UINT32_MAX` bytes before
+reading the buffer, preserving the 32-bit source-location contract. An oversized
+batch returns one ERROR record with an empty source span and a diagnostic.
+
 The tokenizer identifies boundaries, so semicolons in strings, quoted
 identifiers and comments do not split statements. Empty statements/comments are
 skipped. Malformed statements remain in the result; scanning continues at the
 
@@ -26,6 +26,7 @@
 #include "sql_parser/arena.h"
 #include <cstring>
 #include <vector>
+#include <limits>
 
 namespace sql_engine {
 
@@ -122,6 +123,14 @@ class PlanBuilder {
             case NodeType::NODE_PG_DDL_SYNTAX:
                 return true;
             // PG_GAPS_QUERY_GUARD
+            case NodeType::NODE_LIMIT_CLAUSE: {
+                int64_t value;
+                const auto* count = node->first_child;
+                if (!read_limit_literal(count, -1, value)) return true;
+                const auto* offset = count->next_sibling;
+                if (offset && (!read_limit_literal(offset, 0, value) || offset->next_sibling)) return true;
+                break;
+            }
             case NodeType::NODE_TABLE_REF:
                 if (node->flags & (sql_parser::FLAG_TABLE_ONLY | sql_parser::FLAG_TABLE_INHERIT)) return true;
                 break;
@@ -481,41 +490,44 @@ class PlanBuilder {
         return current;
     }
 
-    // Build a Limit plan node from LIMIT clause AST
-    PlanNode* build_limit_node(const sql_parser::AstNode* limit_clause, PlanNode* child) {
-        PlanNode* limit = make_plan_node(arena_, PlanNodeType::LIMIT);
-        limit->limit.count = -1;
-        limit->limit.offset = 0;
-
-        const sql_parser::AstNode* first = limit_clause->first_child;
-        if (first) {
-            // Parse the literal count value
-            limit->limit.count = parse_int_literal(first);
-
-            const sql_parser::AstNode* second = first->next_sibling;
-            if (second) {
-                // LIMIT count OFFSET offset_val  or  LIMIT offset, count (MySQL)
-                // In the AST, second child is always the offset value
-                limit->limit.offset = parse_int_literal(second);
+    // Local LIMIT execution supports integer constants and PostgreSQL NULL
+    // (including normalized ALL). Other expressions need runtime evaluation.
+    static bool read_limit_literal(const sql_parser::AstNode* node,
+                                   int64_t null_value, int64_t& value) {
+        if (!node) return false;
+        if constexpr (D == sql_parser::Dialect::PostgreSQL) {
+            if (node->type == sql_parser::NodeType::NODE_LITERAL_NULL) {
+                value = null_value;
+                return true;
             }
         }
-        limit->left = child;
-        return limit;
+        if (node->type != sql_parser::NodeType::NODE_LITERAL_INT) return false;
+        const auto text = node->value();
+        if (text.empty()) return false;
+        value = 0;
+        for (uint32_t i = 0; i < text.len; ++i) {
+            const char c = text.ptr[i];
+            if (c < '0' || c > '9') return false;
+            const int digit = c - '0';
+            if (value > (std::numeric_limits<int64_t>::max() - digit) / 10) return false;
+            value = value * 10 + digit;
+        }
+        return true;
     }
 
-    // Parse an integer literal from an AST node
-    static int64_t parse_int_literal(const sql_parser::AstNode* node) {
-        if (!node) return 0;
-        sql_parser::StringRef val = node->value();
-        if (val.len == 0) return 0;
-        int64_t result = 0;
-        for (uint32_t i = 0; i < val.len; ++i) {
-            char c = val.ptr[i];
-            if (c >= '0' && c <= '9') {
-                result = result * 10 + (c - '0');
-            }
-        }
-        return result;
+    // Build a Limit plan node without converting unsupported expressions to zero.
+    PlanNode* build_limit_node(const sql_parser::AstNode* limit_clause, PlanNode* child) {
+        int64_t count, offset = 0;
+        const auto* first = limit_clause->first_child;
+        if (!read_limit_literal(first, -1, count)) return nullptr;
+        const auto* second = first->next_sibling;
+        if (second && (!read_limit_literal(second, 0, offset) || second->next_sibling)) return nullptr;
+        PlanNode* limit = make_plan_node(arena_, PlanNodeType::LIMIT);
+        if (!limit) return nullptr;
+        limit->limit.count = count;
+        limit->limit.offset = offset;
+        limit->left = child;
+        return limit;
     }
 
     // Build plan for CTE (WITH clause)
 
@@ -156,42 +156,114 @@ class Session {
         parser_.reset();
         auto pr = parser_.parse(sql, len);
 
-        // Check for transaction control statements first (parser may not
-        // produce an AST for these — they are classified by stmt_type).
+        auto transaction_error = [](const char* message) {
+            DmlResult dr;
+            dr.error_message = message;
+            return dr;
+        };
+        auto transaction_name = [](const sql_parser::AstNode* operand) {
+            std::string name;
+            const bool quoted = (operand->flags & sql_parser::FLAG_IDENT_DELIMITED) != 0;
+            auto value = operand->value();
+            name.reserve(value.len);
+            for (uint32_t i = 0; i < value.len; ++i) {
+                char c = value.ptr[i];
+                if (quoted && c == '"' && i + 1 < value.len && value.ptr[i + 1] == '"') ++i;
+                else if (!quoted && c >= 'A' && c <= 'Z') c = static_cast<char>(c - 'A' + 'a');
+                name.push_back(c);
+            }
+            return name;
+        };
+        if (pr.status != sql_parser::ParseResult::OK || !pr.full_input)
+            return transaction_error("parse error");
+
+        // PostgreSQL transaction controls retain their operands and options
+        // in the AST. MySQL's legacy transaction extractor has no AST.
+        if constexpr (D == sql_parser::Dialect::PostgreSQL) {
+            if ((pr.stmt_type == sql_parser::StmtType::BEGIN ||
+                 pr.stmt_type == sql_parser::StmtType::START_TRANSACTION ||
+                 pr.stmt_type == sql_parser::StmtType::COMMIT ||
+                 pr.stmt_type == sql_parser::StmtType::ROLLBACK ||
+                 pr.stmt_type == sql_parser::StmtType::SAVEPOINT ||
+                 pr.stmt_type == sql_parser::StmtType::RELEASE_SAVEPOINT) &&
+                (!pr.ast || pr.ast->type != sql_parser::NodeType::NODE_TRANSACTION_STMT))
+                return transaction_error("parse error");
+        }
+
         switch (pr.stmt_type) {
             case sql_parser::StmtType::BEGIN:
             case sql_parser::StmtType::START_TRANSACTION: {
+                if constexpr (D == sql_parser::Dialect::PostgreSQL) {
+                    if (pr.ast->first_child)
+                        return transaction_error("unsupported transaction options");
+                }
                 DmlResult dr;
                 dr.success = txn_mgr_.begin();
                 if (!dr.success) dr.error_message = "BEGIN failed";
                 return dr;
             }
             case sql_parser::StmtType::COMMIT: {
+                if constexpr (D == sql_parser::Dialect::PostgreSQL) {
+                    if (pr.ast->first_child)
+                        return transaction_error("unsupported transaction options");
+                }
                 DmlResult dr;
                 dr.success = txn_mgr_.commit();
                 if (!dr.success) dr.error_message = "COMMIT failed";
                 return dr;
             }
             case sql_parser::StmtType::ROLLBACK: {
+                if constexpr (D == sql_parser::Dialect::PostgreSQL) {
+                    const auto* option = pr.ast->first_child;
+                    if (option) {
+                        const auto* name = option->next_sibling;
+                        if (option->type != sql_parser::NodeType::NODE_TRANSACTION_OPTION ||
+                            option->value() != sql_parser::StringRef{"TO SAVEPOINT", 12} ||
+                            !name || name->type != sql_parser::NodeType::NODE_IDENTIFIER ||
+                            name->next_sibling)
+                            return transaction_error("unsupported transaction options");
+                        std::string savepoint = transaction_name(name);
+                        DmlResult dr;
+                        dr.success = txn_mgr_.rollback_to(savepoint.c_str());
+                        if (!dr.success) dr.error_message = "ROLLBACK TO SAVEPOINT failed";
+                        return dr;
+                    }
+                }
                 DmlResult dr;
                 dr.success = txn_mgr_.rollback();
                 if (!dr.success) dr.error_message = "ROLLBACK failed";
                 return dr;
             }
             case sql_parser::StmtType::SAVEPOINT: {
                 DmlResult dr;
-                // The savepoint name is in the AST value or table_name
                 std::string name;
-                if (pr.table_name.ptr && pr.table_name.len > 0)
+                if constexpr (D == sql_parser::Dialect::PostgreSQL) {
+                    const auto* operand = pr.ast->first_child;
+                    if (!operand || operand->type != sql_parser::NodeType::NODE_IDENTIFIER ||
+                        operand->next_sibling)
+                        return transaction_error("parse error");
+                    name = transaction_name(operand);
+                } else if (pr.table_name.ptr && pr.table_name.len > 0)
                     name.assign(pr.table_name.ptr, pr.table_name.len);
-                else if (pr.ast && pr.ast->value_ptr && pr.ast->value_len > 0)
-                    name.assign(pr.ast->value_ptr, pr.ast->value_len);
-                else
-                    name = "sp";
+                else name = "sp";
                 dr.success = txn_mgr_.savepoint(name.c_str());
                 if (!dr.success) dr.error_message = "SAVEPOINT failed";
                 return dr;
             }
+            case sql_parser::StmtType::RELEASE_SAVEPOINT: {
+                if constexpr (D == sql_parser::Dialect::PostgreSQL) {
+                    const auto* operand = pr.ast->first_child;
+                    if (!operand || operand->type != sql_parser::NodeType::NODE_IDENTIFIER ||
+                        operand->next_sibling)
+                        return transaction_error("parse error");
+                    std::string name = transaction_name(operand);
+                    DmlResult dr;
+                    dr.success = txn_mgr_.release_savepoint(name.c_str());
+                    if (!dr.success) dr.error_message = "RELEASE SAVEPOINT failed";
+                    return dr;
+                }
+                break;
+            }
             default:
                 break;
         }
 
@@ -350,8 +350,10 @@ class DeleteParser {
             if (next.type == TokenType::TK_AS) {
                 tok_.skip();
                 Token alias_name = tok_.next_token();
-                ret->add_child(make_node(arena_, NodeType::NODE_ALIAS,
-                    alias_name.source.empty() ? alias_name.text : alias_name.source));
+                AstNode* alias = make_node_from_token(arena_, NodeType::NODE_ALIAS, alias_name);
+                if (alias && alias_name.source.ptr != alias_name.text.ptr)
+                    alias->flags |= FLAG_IDENT_DELIMITED;
+                ret->add_child(alias);
             }
 
             if (tok_.peek().type == TokenType::TK_COMMA) {