Documentation

Parsing delegates to parseExtended over the Extends instance below — a bare table_ref parse is greedy, absorbing any trailing CROSS JOIN/JOIN/NATURAL JOIN continuation into itself, so a joined_table is never reachable as a bare, zero-extension TableRef; it always needs at least one. Failing that, the only remaining joined_table production is the non-left-recursive parseBase.

Collapses the non-canonical Right-wrapping-a-bare-select_with_parens shape of SubqueryAExpr's final field to the Left shape the parser actually produces for it.

a_expr subquery_Op sub_type select_with_parens (i.e. Left) and a_expr subquery_Op sub_type '(' a_expr ')' (i.e. Right) overlap whenever the parenthesized a_expr is itself nothing but a bare, indirection-less select_with_parens: both parse x = ANY ((select 1)). suffix tries the select_with_parens alternative before the parenthesized a_expr one (see the d Left <$ ... | Right $ ... line above), so that's always what the parser returns — never Right — making the latter non-canonical for this shape. Both arbitrary and shrink can otherwise construct it, which renders fine but parses back to a different, canonical value and so breaks the roundtrip property.

Collapses the non-canonical InParensCExpr-wrapping-a-SelectWithParensCExpr shape to the SelectWithParensCExpr/WithParensSelectWithParens shape the parser actually produces for it.

'(' a_expr ')' opt_indirection (i.e. InParensCExpr) and select_with_parens (i.e. SelectWithParensCExpr) overlap whenever the inner a_expr is itself nothing but a bare, indirection-less select_with_parens: both parse ((select 1)). customizedParser tries the select_with_parens alternative before parenthesizedExprCExpr, so that's always what the parser returns — never InParensCExpr — making the latter non-canonical for this shape. Both arbitrary and shrink can otherwise construct it (shrinking the outer indirection to Nothing is exactly how it arises), which renders fine but parses back to a different, canonical value and so breaks the roundtrip property.

Collapses the non-canonical SelectInExpr-of-WithParensSelectWithParens shape to the ExprListInExpr shape the parser actually produces for it: in_expr's two productions, select_with_parens and '(' expr_list ')', overlap whenever the parenthesised select itself contains another parenthesised select, since a single-element expr_list can itself be that inner parenthesised select wrapped as a c_expr. Both render to the same text; the parser's expr_list alternative is tried first and so wins. Both arbitrary and shrink can otherwise construct the non-canonical shape, which renders fine but parses back to a different, canonical value and so breaks the roundtrip property.

Collapses the non-canonical NoParensSelectWithParens shape described above to the WithParensSelectWithParens shape the parser actually produces for it. Both arbitrary and shrink can otherwise construct the non-canonical shape (shrinking the inner SelectNoParens toward Nothings is exactly how it arises), which renders fine but parses back to a different, canonical value and so breaks the roundtrip property.

Collapses an arbitrary-shaped BinSimpleSelect chain to the shape foldChain actually produces for it (left-associated within each precedence level, INTERSECT binding tighter than UNION/EXCEPT — see foldChain above): flattenChain reduces the chain to its flat sequence of operators and operands regardless of how it's currently nested, and re-folding that sequence with the same foldChain the parser itself uses is by construction the shape parse . toText produces. Both arbitrary and shrink can otherwise construct a non-canonical shape, which renders fine but parses back to a different, canonical value and so breaks the roundtrip property.

JoinedTable embeds trivially into a bare, alias-less TableRef (joined_table is one of table_ref's alternatives), and a TableRef of that exact shape is recognizable back as one. See Extends for how this is used to fold a chain of joins onto a leading TableRef.

A SimpleSelect embeds trivially into a SelectClause (it's one of its two alternatives), and a SelectClause of that exact shape is recognizable back as one. Needed so PostgresqlSyntax.Ast.SimpleSelect's Extends instance can fold a chain of UNION/INTERSECT/EXCEPT items onto a leading SelectClause.

The one joined_table production that doesn't begin with a left-recursive table_ref:

  | '(' joined_table ')'

It still recurses — just not on the left, since the opening parenthesis has to be consumed first. PostgresqlSyntax.Ast.TableRef reaches it through this class method, which is why JoinedTable needs no helper export.

Every select_clause production except the left-recursive ones (those are the UNION/INTERSECT/EXCEPT continuations, hosted by PostgresqlSyntax.Ast.SimpleSelect's Extends instance).

The simple_select productions that don't left-recurse through select_clause — i.e. everything but select_clause BINOP select_clause. PostgresqlSyntax.Ast.SelectClause reaches these through this class method, which is why SimpleSelect needs no helper export.

Every table_ref production except the left-recursive ones (those are the joined_table continuations, hosted by PostgresqlSyntax.Ast.JoinedTable's Extends instance).

The two joined_table-shaped alternatives here are not left-recursive: both begin with a parenthesis, so neither can loop back into this parser without consuming input. They reach '(' joined_table ')' through JoinedTable's own parseBase rather than through a JoinedTable helper export.

The left-recursion-eliminated form of select_clause: a bare SelectClause (either a parenthesized select, or one of SimpleSelect's non-chain cases) is the non-recursive base (β), and each UNION/INTERSECT/EXCEPT continuation is a SelectBinOp plus its ALL/DISTINCT qualifier and right operand, applied via BinSimpleSelect.

Keeps the collect-then-fold shape — parsing every SelectChainLink up front via parseExtensionChain, then folding via foldChain — rather than folding as it goes, because this hub's items aren't all one precedence level: gram.y declares %left UNION EXCEPT before (i.e. binding looser than) %left INTERSECT (gram.y:813-814), both left-associative, so a uniform left-to-right fold-as-you-parse would root a INTERSECT b UNION c at INTERSECT and nest a EXCEPT b EXCEPT c to the right — both wrong. foldChain needs the whole flat sequence in hand to sort that out; see its own docs above.

The left-recursion-eliminated form of table_ref/joined_table: a TableRef is the non-recursive base (β, its own parseBase). All three join kinds sit at the same precedence (%left JOIN CROSS LEFT FULL RIGHT INNER_P NATURAL in gram.y), and there's nothing to hold between parsing a join and applying it, so no item type is warranted here — unlike PostgresqlSyntax.Ast.SimpleSelect, this hub isn't collect-then-fold.