@@ -55,6 +55,9 @@ TEST_SRCS = $(TEST_DIR)/test_main.cpp \
             $(TEST_DIR)/test_pg_expressions.cpp \
             $(TEST_DIR)/test_pg_special_expressions.cpp \
             $(TEST_DIR)/test_pg_query_gaps.cpp \
+            $(TEST_DIR)/test_pg_query_continuation.cpp \
+            $(TEST_DIR)/test_pg_expression_continuation.cpp \
+            $(TEST_DIR)/test_pg_object_ddl.cpp \
             $(TEST_DIR)/test_pg_dml_extensions.cpp \
             $(TEST_DIR)/test_pg_ddl.cpp \
             $(TEST_DIR)/test_pg_json_xml.cpp \
 
@@ -139,11 +139,25 @@ RETURNING and behavior options, table columns, serialization and default
 expressions. Their new node kinds support traversal and SQL reconstruction;
 parameterization remains conservative about unsupported contexts.
 
-Coverage is still a subset of PostgreSQL. Remaining examples include CREATE
-TYPE/DOMAIN/SEQUENCE, embedded CREATE SCHEMA elements, CREATE DATABASE options,
-most non-table ALTER commands, unquoted SQL function bodies, exclusion
-constraints, less common DDL options, assignment slices,
-full ON CONFLICT index-inference options, and `IS JSON` predicates. PostgreSQL remains responsible
+Additional expression forms include `VARIADIC` arguments, array slices,
+`ILIKE`/`SIMILAR TO` and `ESCAPE`, SQL `POSITION`/`OVERLAY`, `IS JSON` predicates,
+and `ORDER BY ... USING` in queries, aggregates and windows. PostgreSQL bit and
+hexadecimal literals preserve their prefixes. Nested joins, join USING aliases,
+`TABLESAMPLE ... REPEATABLE`, `ROWS FROM`, row-lock strengths/targets/wait policies,
+and `SELECT INTO` have explicit AST nodes. EXPLAIN retains grouped options and
+propagates its inner statement's completion and error status. Unsupported local
+execution is guarded; parameterization conservatively rejects the new contexts.
+
+Object DDL includes CREATE/ALTER DOMAIN, shell/composite/enum/range/base TYPE
+forms, CREATE/ALTER SEQUENCE, routine properties and SET/RESET clauses,
+object renaming/ownership/schema changes, and additional DROP families.
+Defaults, constraints, names and options remain traversable AST components.
+
+Coverage is still a subset of PostgreSQL. Remaining examples include embedded
+CREATE SCHEMA elements, CREATE DATABASE options, other object-specific ALTER
+commands, aggregate/operator definitions, roles, comments, cursors, unquoted SQL
+function bodies, exclusion constraints, less common DDL options, assignment
+slices and full ON CONFLICT index-inference options. PostgreSQL remains responsible
 for name resolution, types, privileges and semantic checks. Corpus acceptance
 alone does not establish grammar parity or round-trip equivalence for every
 accepted statement.
 
@@ -0,0 +1,33 @@
+# PostgreSQL grammar continuation implementation plan
+
+> **For agentic workers:** Use superpowers:subagent-driven-development for independent expression and DDL work. Parent owns query integration and final verification.
+
+**Goal:** Extend the native parser against the remaining PostgreSQL corpus, prioritizing SELECT composition and common object DDL.
+**Architecture:** Preserve the current tokenizer/arena/AST architecture; add validated productions and explicit nodes where existing AST shapes cannot preserve semantics. Unsupported local engine behavior must be rejected before execution. Use the pinned PostgreSQL parser only as a development oracle.
+**Tech stack:** C++17, GoogleTest, Python compatibility harness, PostgreSQL 18.4/libpg_query pinned source.
+**Spec:** Continues the user-approved native grammar work documented in 2026-09-26-pg-grammar-gaps.md and the user's request to continue filling remaining gaps.
+
+## Global constraints
+
+- Continue branch feat/postgresql-coverage-and-ast-apis and update PR #67 with detailed commits.
+- Do not commit benchmarks, benchmark README/.gitignore edits, or generated binaries.
+- Preserve MySQL behavior, appended enum values, and the 48-byte AST layout.
+- No runtime PostgreSQL dependency or unvalidated opaque-tail acceptance.
+- Base 91880dc: 43,373 deep parses of 51,415 pinned corpus statements; preserve prior accepted coverage.
+
+## Review focus
+
+- Nested joins retain association and ON/USING ownership through emission.
+- Keywords used as names and quoted names remain distinguishable from grammar.
+- New syntax operands stay traversable; syntax constants do not become bind values.
+- Malformed separators/clauses and exhausted arenas cannot produce a truncated successful AST.
+- Planner guards reject new semantics rather than executing a simplified statement.
+
+## Tasks
+
+- [x] Expressions: tests/test_pg_expression_continuation.cpp; expression_parser.h and owned shared markers. Start with failing positive/negative fixtures for VARIADIC calls, array slices, ILIKE/SIMILAR TO/ESCAPE, POSITION/OVERLAY and IS JSON. Examples: SELECT a[:3], b[1:]; SELECT POSITION('a' IN s); SELECT OVERLAY(s PLACING 'x' FROM 2 FOR 1); SELECT f(VARIADIC ARRAY[1,2]); SELECT doc IS JSON OBJECT WITH UNIQUE KEYS. Compare emitted PostgreSQL AST, reject malformed bounds/operands and guard local execution.
+- [x] DDL: tests/test_pg_object_ddl.cpp; pg_ddl_parser.h. Start with ALTER FUNCTION f(int) PARALLEL SAFE, CREATE DOMAIN d AS int CHECK(VALUE>0), CREATE TYPE t AS ENUM('a','b'), CREATE TYPE t AS(a int,b text), CREATE SEQUENCE s START WITH 3, ALTER SEQUENCE s RESTART WITH 4. Add routine options/ownership/schema/renaming, common ALTER domain/type/sequence and validated remaining DROP families. Keep names/types/expressions structural. Verify positive/negative/oracle cases.
+- [x] Query composition: tests/test_pg_query_continuation.cpp; table_ref_parser.h, select_parser.h, compound_query_parser.h and pg_query_clauses.h. Tests first for parenthesized/nested joins, TABLESAMPLE/REPEATABLE, ROWS FROM, ORDER BY USING operators, row-lock strength/OF/wait policies and SELECT INTO. Preserve EXPLAIN options and inner completion while validating new query forms inside EXPLAIN. Preserve existing simple-join execution representation where possible; use appended guarded nodes for richer forms. Validate PostgreSQL AST equivalence and malformed syntax.
+- [ ] Integration: register tests, run independent cross-reviews, force full build and corpus runner, focused ASan/UBSan, oracle comparisons and Python harness. Replay all 51,415 statements and inspect losses/status transitions. Commit implementation first, refresh correctness snapshot against that commit, verify full compatibility workflow, commit snapshot and push/update PR #67. Report concrete remaining grammar variants without claiming complete PostgreSQL parity.
+
+Implementation workers must not commit, run full make or change shared files outside their owned markers. Parent consolidates commits and verifies the final tree.
@@ -69,6 +69,29 @@ class PlanBuilder {
                                                bool dml_values = false) {
         using sql_parser::NodeType;
         switch (node->type) {
+            // PG_CONT_EXPRESSION_GUARD
+            case NodeType::NODE_LITERAL_BIT:
+            case NodeType::NODE_LITERAL_HEX:
+                if constexpr (D == sql_parser::Dialect::PostgreSQL) return true;
+                break;
+            case NodeType::NODE_PG_VARIADIC_ARGUMENT:
+            case NodeType::NODE_PG_ARRAY_SLICE:
+            case NodeType::NODE_PG_PATTERN_PREDICATE:
+            case NodeType::NODE_PG_POSITION:
+            case NodeType::NODE_PG_OVERLAY:
+            case NodeType::NODE_PG_JSON_PREDICATE:
+                return true;
+            // PG_CONT_QUERY_GUARD
+            case NodeType::NODE_PG_EXPLAIN_OPTION:
+            case NodeType::NODE_PG_JOIN_TREE:
+            case NodeType::NODE_PG_TABLE_GROUP:
+            case NodeType::NODE_PG_JOIN_USING:
+            case NodeType::NODE_PG_TABLESAMPLE:
+            case NodeType::NODE_PG_ROWS_FROM:
+            case NodeType::NODE_PG_SORT_USING:
+            case NodeType::NODE_PG_SELECT_INTO:
+            case NodeType::NODE_PG_ROW_LOCK:
+                return true;
             // PG_GAPS_EXPRESSION_GUARD
             case NodeType::NODE_PG_EXTRACT:
             case NodeType::NODE_PG_SUBSTRING:
 
@@ -310,6 +310,24 @@ enum class NodeType : uint16_t {
     // PG_GAPS_JSON_XML_NODES
     NODE_PG_JSON_XML,
     NODE_PG_JSON_XML_SYNTAX,
+    // PG_CONT_EXPRESSION_NODES
+    NODE_PG_VARIADIC_ARGUMENT, // one value or named-argument child; final call argument
+    NODE_PG_ARRAY_SLICE,       // base, optional lower/upper; flags 1/2 mark bounds
+    NODE_PG_PATTERN_PREDICATE, // value=operator; subject, pattern, optional escape
+    NODE_PG_POSITION,          // needle, haystack
+    NODE_PG_OVERLAY,           // source, replacement, start, optional length; flag 1=plain call
+    NODE_PG_JSON_PREDICATE,    // validated IS [NOT] JSON suffix; one expression child
+    // PG_CONT_QUERY_NODES
+    NODE_PG_EXPLAIN_OPTION,
+    NODE_PG_JOIN_TREE,
+    NODE_PG_TABLE_GROUP,
+    NODE_PG_JOIN_USING,
+    NODE_PG_TABLESAMPLE,
+    NODE_PG_ROWS_FROM,
+    NODE_PG_SORT_USING,
+    NODE_PG_SELECT_INTO,
+    NODE_PG_ROW_LOCK,
+
 };
 
 } // namespace sql_parser
 
@@ -44,14 +44,14 @@ class CompoundQueryParser {
             result->add_child(order);
         }
         if constexpr (D == Dialect::PostgreSQL) {
-            if (!PgQueryClauses<D>(tok_, arena_, expr_parser_).pagination(result)) return nullptr;
+            if (!PgQueryClauses<D>(tok_, arena_, expr_parser_).tail(result)) return nullptr;
         } else if (tok_.peek().type == TokenType::TK_LIMIT) {
             tok_.skip();
             AstNode* limit = parse_limit(require_operands);
             if (!limit || !limit->first_child) return nullptr;
             result->add_child(limit);
         }
-        if (result->type == NodeType::NODE_SELECT_STMT &&
+        if (D == Dialect::MySQL && result->type == NodeType::NODE_SELECT_STMT &&
             tok_.peek().type == TokenType::TK_FOR) {
             tok_.skip();
             AstNode* lock = make_node(arena_, NodeType::NODE_LOCKING_CLAUSE);
@@ -222,15 +222,22 @@ class CompoundQueryParser {
             }
 
             if constexpr (D == Dialect::PostgreSQL) {
+                if (dir.type == TokenType::TK_USING) {
+                    auto* op = expressions.parse_sort_operator();
+                    if (!op) return nullptr;
+                    item->add_child(op);
+                }
                 if (ExpressionParser<D>::keyword(tok_.peek(), "NULLS")) {
                     tok_.skip();
                     Token placement = tok_.peek();
                     bool first = ExpressionParser<D>::keyword(placement, "FIRST");
                     if (!first && !ExpressionParser<D>::keyword(placement, "LAST")) return nullptr;
                     tok_.skip();
                     item->flags |= FLAG_ORDER_NULLS;
-                    item->add_child(make_node(arena_, NodeType::NODE_IDENTIFIER,
-                        first ? StringRef{"NULLS FIRST", 11} : StringRef{"NULLS LAST", 10}));
+                    auto* nulls = make_node(arena_, NodeType::NODE_IDENTIFIER,
+                        first ? StringRef{"NULLS FIRST", 11} : StringRef{"NULLS LAST", 10});
+                    if (!nulls) return nullptr;
+                    item->add_child(nulls);
                 }
             }
             order_by->add_child(item);
 
@@ -197,6 +197,56 @@ class Emitter {
                 if (mode_ == EmitMode::DIGEST) { sb_.append_char('?'); break; }
                 emit_string_literal(node); break;
 
+            // PG_CONT_EXPRESSION_DISPATCH
+            case NodeType::NODE_PG_VARIADIC_ARGUMENT:
+                sb_.append("VARIADIC "); emit_node(node->first_child); break;
+            case NodeType::NODE_PG_ARRAY_SLICE:
+            case NodeType::NODE_PG_PATTERN_PREDICATE:
+            case NodeType::NODE_PG_POSITION:
+            case NodeType::NODE_PG_OVERLAY:
+            case NodeType::NODE_PG_JSON_PREDICATE:
+                emit_pg_continuation_expression(node); break;
+            // PG_CONT_QUERY_DISPATCH
+            case NodeType::NODE_PG_EXPLAIN_OPTION:
+                emit_value(node);
+                if (node->first_child) { sb_.append_char(' '); emit_node(node->first_child); }
+                break;
+            case NodeType::NODE_PG_JOIN_TREE: emit_pg_join_tree(node); break;
+            case NodeType::NODE_PG_TABLE_GROUP:
+                sb_.append_char('('); emit_node(node->first_child); sb_.append_char(')'); break;
+            case NodeType::NODE_PG_JOIN_USING:
+                sb_.append("USING (");
+                for (const auto* col = node->first_child; col; col = col->next_sibling) {
+                    if (col != node->first_child) sb_.append(", ");
+                    emit_node(col);
+                }
+                sb_.append_char(')');
+                if (!node->value().empty()) { sb_.append(" AS "); emit_value(node); }
+                break;
+            case NodeType::NODE_PG_TABLESAMPLE: emit_pg_tablesample(node); break;
+            case NodeType::NODE_PG_ROWS_FROM:
+                sb_.append("ROWS FROM (");
+                for (const auto* item = node->first_child; item; item = item->next_sibling) {
+                    if (item != node->first_child) sb_.append(", ");
+                    emit_node(item);
+                }
+                sb_.append_char(')'); break;
+            case NodeType::NODE_PG_SORT_USING:
+                sb_.append("USING "); emit_value(node); break;
+            case NodeType::NODE_PG_SELECT_INTO:
+                sb_.append(" INTO "); emit_value(node); emit_node(node->first_child); break;
+            case NodeType::NODE_PG_ROW_LOCK:
+                sb_.append(" FOR "); emit_value(node);
+                if (node->first_child) {
+                    sb_.append(" OF ");
+                    for (const auto* rel = node->first_child; rel; rel = rel->next_sibling) {
+                        if (rel != node->first_child) sb_.append(", ");
+                        emit_node(rel);
+                    }
+                }
+                if (node->flags == 1) sb_.append(" NOWAIT");
+                if (node->flags == 2) sb_.append(" SKIP LOCKED");
+                break;
             // PG_GAPS_EXPRESSION_DISPATCH
             case NodeType::NODE_PG_EXTRACT:
             case NodeType::NODE_PG_SUBSTRING:
@@ -248,6 +298,63 @@ class Emitter {
         }
     }
 
+    // PG_CONT_EXPRESSION_EMITTER
+    void emit_pg_continuation_expression(const AstNode* node) {
+        const AstNode* first = node->first_child;
+        if (node->type == NodeType::NODE_PG_ARRAY_SLICE) {
+            emit_node(first); sb_.append_char('[');
+            const AstNode* bound = first ? first->next_sibling : nullptr;
+            if (node->flags & 1) { emit_node(bound); bound = bound ? bound->next_sibling : nullptr; }
+            sb_.append_char(':');
+            if (node->flags & 2) emit_node(bound);
+            sb_.append_char(']');
+        } else if (node->type == NodeType::NODE_PG_PATTERN_PREDICATE) {
+            emit_node(first); sb_.append_char(' '); emit_value(node); sb_.append_char(' ');
+            const AstNode* pattern = first ? first->next_sibling : nullptr;
+            emit_node(pattern);
+            if (pattern && pattern->next_sibling) {
+                sb_.append(" ESCAPE "); emit_node(pattern->next_sibling);
+            }
+        } else if (node->type == NodeType::NODE_PG_JSON_PREDICATE) {
+            emit_node(first); sb_.append_char(' '); emit_value(node);
+        } else if (node->type == NodeType::NODE_PG_POSITION) {
+            sb_.append("POSITION("); emit_node(first); sb_.append(" IN ");
+            emit_node(first ? first->next_sibling : nullptr); sb_.append_char(')');
+        } else {
+            sb_.append("OVERLAY(");
+            if (node->flags & 1) emit_list(node, ", ");
+            else {
+                const AstNode* replacement = first ? first->next_sibling : nullptr;
+                const AstNode* start = replacement ? replacement->next_sibling : nullptr;
+                emit_node(first); sb_.append(" PLACING "); emit_node(replacement);
+                sb_.append(" FROM "); emit_node(start);
+                if (start && start->next_sibling) { sb_.append(" FOR "); emit_node(start->next_sibling); }
+            }
+            sb_.append_char(')');
+        }
+    }
+    // PG_CONT_QUERY_EMITTER
+    void emit_pg_join_tree(const AstNode* node) {
+        const auto* left = node->first_child;
+        const auto* right = left->next_sibling;
+        const auto* qual = right->next_sibling;
+        sb_.append_char('('); emit_node(left); sb_.append_char(' ');
+        emit_value(node); sb_.append_char(' '); emit_node(right);
+        if (qual) {
+            sb_.append(qual->type == NodeType::NODE_PG_JOIN_USING ? " " : " ON ");
+            emit_node(qual);
+        }
+        sb_.append_char(')');
+    }
+    void emit_pg_tablesample(const AstNode* node) {
+        const auto* name = node->first_child;
+        const auto* args = name->next_sibling;
+        sb_.append(" TABLESAMPLE "); emit_node(name); emit_node(args);
+        if (args->next_sibling) {
+            sb_.append(" REPEATABLE ("); emit_node(args->next_sibling); sb_.append_char(')');
+        }
+    }
+
     // PG_GAPS_EXPRESSION_EMITTER
     void emit_pg_special_expression(const AstNode* node) {
         const AstNode* first = node->first_child;
@@ -1220,7 +1327,7 @@ class Emitter {
             }
         }
 
-        if (!has_inner_stmt && !has_options) {
+        if (D == Dialect::MySQL && !has_inner_stmt && !has_options) {
             sb_.append("DESCRIBE");
         } else {
             sb_.append("EXPLAIN");
@@ -1233,6 +1340,11 @@ class Emitter {
     }
 
     void emit_explain_options(const AstNode* node) {
+        if constexpr (D == Dialect::PostgreSQL) {
+            if (node->flags & 1) {
+                sb_.append_char('('); emit_list(node, ", "); sb_.append_char(')'); return;
+            }
+        }
         bool first = true;
         for (const AstNode* child = node->first_child; child; child = child->next_sibling) {
             if (!first) sb_.append_char(' ');
@@ -1687,7 +1799,10 @@ class Emitter {
     void emit_field_access(const AstNode* node) {
         const AstNode* expr = node->first_child;
         const AstNode* field = expr ? expr->next_sibling : nullptr;
-        if (expr && expr->type == NodeType::NODE_EXPRESSION) emit_node(expr);
+        if (expr && (expr->type == NodeType::NODE_EXPRESSION ||
+            (D == Dialect::PostgreSQL && (expr->type == NodeType::NODE_COLUMN_REF ||
+             expr->type == NodeType::NODE_QUALIFIED_NAME || expr->type == NodeType::NODE_ARRAY_SUBSCRIPT ||
+             expr->type == NodeType::NODE_PG_ARRAY_SLICE || expr->type == NodeType::NODE_FIELD_ACCESS)))) emit_node(expr);
         else {
             sb_.append_char('(');
             if (expr) emit_node(expr);