From d508e63e77ea13ca036ad57d7930b3a7eb9bea5e Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 16:50:28 +0000 Subject: [PATCH] =?UTF-8?q?Milestone=205:=20DML=20=E2=80=94=20INSERT,=20UP?= =?UTF-8?q?DATE,=20DELETE,=20MERGE,=20COPY,=20PREPARE/EXECUTE,=20cursors?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Port the gram.y DML productions to internal/parse: InsertStmt (insert_rest, ON CONFLICT with index_params/reloptions, OVERRIDING, RETURNING), UpdateStmt and DeleteStmt (set_clause_list with multi-assignment, USING, WHERE CURRENT OF), MergeStmt (merge_when_list and all action forms), CopyStmt (legacy and generic option syntax, PROGRAM/STDIN checks with bison's empty-production error locations), PrepareStmt/ExecuteStmt/DeallocateStmt, and the cursor statements (DECLARE, FETCH/MOVE with the full fetch_args direction set, CLOSE). The five opt_with_clause statements share one WITH-prefixed entry point, and PreparableStmt (CTE bodies, COPY (query), PREPARE ... AS) accepts the full statement set. The unreserved-keyword ambiguities (FETCH direction vs cursor name, DEALLOCATE PREPARE, WHERE CURRENT OF, insert column list vs parenthesized select, bare SET alias) resolve by the same one-token lookahead the LALR tables use. CREATE TABLE AS EXECUTE stays with milestone 6's CREATE machinery. Corpus: 7,337 parse todos and 73 deparse error-path todos graduate; the difftest classifier reports no tree or error mismatches against implemented statements. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_016okPsjeaUU3xf6qGrrEhRK --- PLAN.md | 34 +- internal/parse/dml.go | 1071 +++++++++++++++++ internal/parse/gram_support.go | 16 + internal/parse/nodes.go | 76 ++ internal/parse/parser.go | 36 +- internal/parse/select.go | 23 +- .../postgres_regress/aggregates.metadata.json | 1 - .../postgres_regress/arrays.metadata.json | 1 - .../btree_index.metadata.json | 4 - .../constraints.metadata.json | 2 - .../postgres_regress/copy.metadata.json | 10 - .../postgres_regress/copyselect.metadata.json | 1 - .../create_index.metadata.json | 2 - .../create_view.metadata.json | 1 - .../postgres_regress/errors.metadata.json | 3 - .../postgres_regress/hash_index.metadata.json | 4 - .../postgres_regress/jsonb.metadata.json | 1 - .../largeobject.metadata.json | 1 - .../postgres_regress/merge.metadata.json | 9 - .../postgres_regress/misc.metadata.json | 4 - .../postgres_regress/test_setup.metadata.json | 7 - .../transactions.metadata.json | 21 - .../postgres_regress/tsearch.metadata.json | 1 - .../parse/deparse/insert_long.metadata.json | 4 +- .../parse/deparse/nested_cte.metadata.json | 4 +- .../parse/deparse/union.metadata.json | 4 +- .../09-inserts_01-basic.metadata.json | 4 +- .../09-inserts_02-with-columns.metadata.json | 4 +- .../09-inserts_03-many-columns.metadata.json | 4 +- .../09-inserts_04-with-schema.metadata.json | 4 +- .../09-inserts_05-multirow.metadata.json | 4 +- .../09-inserts_06-returning-all.metadata.json | 4 +- ...09-inserts_07-returning-some.metadata.json | 4 +- .../09-inserts_08-default.metadata.json | 4 +- .../09-inserts_09-cte.metadata.json | 4 +- ...es_01-single-column-no-where.metadata.json | 4 +- ...es_02-many-columns-and-where.metadata.json | 4 +- .../10-updates_03-with.metadata.json | 4 +- .../10-updates_04-returning-all.metadata.json | 4 +- ...10-updates_05-returning-some.metadata.json | 4 +- ...dates_06-multi-assign-simple.metadata.json | 4 +- ...updates_07-multi-assign-long.metadata.json | 4 +- ...-updates_08-multi-assign-mix.metadata.json | 4 +- .../10-updates_09-cte.metadata.json | 4 +- .../10-updates_10-complex-where.metadata.json | 4 +- .../11-deletes_01-simple.metadata.json | 4 +- .../11-deletes_02-where.metadata.json | 4 +- .../11-deletes_03-using.metadata.json | 4 +- .../11-deletes_04-returning-all.metadata.json | 4 +- ...11-deletes_05-returning-some.metadata.json | 4 +- .../11-deletes_06-cte.metadata.json | 4 +- .../11-deletes_07-complex-where.metadata.json | 4 +- ...8-conflicts_01-basic-nothing.metadata.json | 4 +- ...flicts_02-constraint-nothing.metadata.json | 4 +- ...conflicts_03-columns-nothing.metadata.json | 4 +- ...18-conflicts_04-expr-complex.metadata.json | 4 +- ...8-conflicts_05-simple-update.metadata.json | 4 +- ...flicts_06-update-multicolumn.metadata.json | 4 +- ...-conflicts_07-update-complex.metadata.json | 4 +- .../testdata/parse/libpg_query.metadata.json | 2 - .../postgres_regress/aggregates.metadata.json | 12 - .../alter_table.metadata.json | 202 ---- .../postgres_regress/arrays.metadata.json | 93 -- .../parse/postgres_regress/bit.metadata.json | 25 +- .../postgres_regress/bitmapops.metadata.json | 1 - .../postgres_regress/boolean.metadata.json | 13 - .../parse/postgres_regress/box.metadata.json | 15 - .../parse/postgres_regress/brin.metadata.json | 16 - .../postgres_regress/brin_bloom.metadata.json | 7 - .../postgres_regress/brin_multi.metadata.json | 27 - .../btree_index.metadata.json | 12 - .../parse/postgres_regress/case.metadata.json | 13 - .../parse/postgres_regress/char.metadata.json | 11 +- .../postgres_regress/circle.metadata.json | 15 +- .../postgres_regress/cluster.metadata.json | 70 -- .../collate.icu.utf8.metadata.json | 64 - .../collate.linux.utf8.metadata.json | 7 - .../postgres_regress/collate.metadata.json | 11 - .../collate.utf8.metadata.json | 1 - .../collate.windows.win1252.metadata.json | 6 - .../postgres_regress/combocid.metadata.json | 32 - .../compression.metadata.json | 15 - .../constraints.metadata.json | 142 --- .../postgres_regress/conversion.metadata.json | 10 +- .../parse/postgres_regress/copy.metadata.json | 39 - .../postgres_regress/copydml.metadata.json | 27 - .../postgres_regress/copyselect.metadata.json | 16 - .../postgres_regress/create_am.metadata.json | 1 - .../create_function_sql.metadata.json | 2 - .../create_index.metadata.json | 52 - .../create_index_spgist.metadata.json | 5 - .../create_misc.metadata.json | 51 - .../create_table.metadata.json | 12 - .../create_table_like.metadata.json | 21 - .../create_type.metadata.json | 3 - .../create_view.metadata.json | 6 - .../postgres_regress/database.metadata.json | 1 - .../parse/postgres_regress/date.metadata.json | 17 - .../postgres_regress/delete.metadata.json | 6 - .../postgres_regress/domain.metadata.json | 74 -- .../parse/postgres_regress/enum.metadata.json | 6 - .../postgres_regress/errors.metadata.json | 4 - .../event_trigger.metadata.json | 4 - .../postgres_regress/explain.metadata.json | 1 - .../expressions.metadata.json | 1 - .../fast_default.metadata.json | 58 - .../postgres_regress/float4.metadata.json | 26 - .../postgres_regress/float8.metadata.json | 18 - .../foreign_data.metadata.json | 1 - .../foreign_key.metadata.json | 437 ------- .../functional_deps.metadata.json | 5 +- .../postgres_regress/generated.metadata.json | 41 +- .../parse/postgres_regress/gin.metadata.json | 11 - .../parse/postgres_regress/gist.metadata.json | 6 - .../groupingsets.metadata.json | 6 - .../parse/postgres_regress/guc.metadata.json | 2 - .../postgres_regress/hash_index.metadata.json | 31 - .../postgres_regress/horology.metadata.json | 2 - .../postgres_regress/identity.metadata.json | 90 -- .../incremental_sort.metadata.json | 11 - .../index_including.metadata.json | 25 - .../index_including_gist.metadata.json | 11 - .../postgres_regress/indexing.metadata.json | 16 - .../indirect_toast.metadata.json | 13 - .../parse/postgres_regress/inet.metadata.json | 24 +- .../postgres_regress/inherit.metadata.json | 135 --- .../postgres_regress/insert.metadata.json | 165 --- .../insert_conflict.metadata.json | 111 -- .../parse/postgres_regress/int2.metadata.json | 11 +- .../parse/postgres_regress/int4.metadata.json | 11 +- .../parse/postgres_regress/int8.metadata.json | 10 +- .../postgres_regress/interval.metadata.json | 21 - .../parse/postgres_regress/join.metadata.json | 122 -- .../postgres_regress/join_hash.metadata.json | 15 - .../parse/postgres_regress/json.metadata.json | 9 +- .../postgres_regress/jsonb.metadata.json | 81 +- .../largeobject.metadata.json | 7 - .../postgres_regress/limit.metadata.json | 37 - .../parse/postgres_regress/line.metadata.json | 24 +- .../parse/postgres_regress/lseg.metadata.json | 14 +- .../postgres_regress/macaddr.metadata.json | 14 - .../postgres_regress/macaddr8.metadata.json | 21 - .../postgres_regress/matview.metadata.json | 10 - .../postgres_regress/memoize.metadata.json | 7 - .../postgres_regress/merge.metadata.json | 177 --- .../parse/postgres_regress/misc.metadata.json | 15 - .../misc_functions.metadata.json | 1 - .../postgres_regress/money.metadata.json | 15 +- .../multirangetypes.metadata.json | 24 - .../parse/postgres_regress/mvcc.metadata.json | 1 - .../parse/postgres_regress/name.metadata.json | 7 - .../postgres_regress/namespace.metadata.json | 4 - .../postgres_regress/numeric.metadata.json | 567 --------- .../numeric_big.metadata.json | 476 +------- .../parse/postgres_regress/oid.metadata.json | 18 - .../partition_aggregate.metadata.json | 6 - .../partition_join.metadata.json | 60 - .../partition_prune.metadata.json | 72 -- .../parse/postgres_regress/path.metadata.json | 16 +- .../postgres_regress/pg_lsn.metadata.json | 7 - .../postgres_regress/plancache.metadata.json | 38 - .../postgres_regress/plpgsql.metadata.json | 205 ---- .../postgres_regress/point.metadata.json | 7 - .../postgres_regress/polygon.metadata.json | 15 - .../polymorphism.metadata.json | 8 - .../postgres_regress/portals.metadata.json | 220 ---- .../postgres_regress/portals_p2.metadata.json | 39 - .../postgres_regress/predicate.metadata.json | 4 - .../postgres_regress/prepare.metadata.json | 24 +- .../prepared_xacts.metadata.json | 15 - .../postgres_regress/privileges.metadata.json | 28 +- .../parse/postgres_regress/psql.metadata.json | 135 --- .../psql_crosstab.metadata.json | 3 +- .../publication.metadata.json | 84 -- .../postgres_regress/rangefuncs.metadata.json | 24 - .../postgres_regress/rangetypes.metadata.json | 40 - .../postgres_regress/reloptions.metadata.json | 3 - .../postgres_regress/returning.metadata.json | 33 +- .../rowsecurity.metadata.json | 129 -- .../postgres_regress/rowtypes.metadata.json | 21 - .../postgres_regress/rules.metadata.json | 253 ---- .../postgres_regress/select.metadata.json | 2 - .../select_distinct.metadata.json | 6 +- .../select_having.metadata.json | 10 - .../select_implicit.metadata.json | 10 - .../select_into.metadata.json | 8 - .../select_parallel.metadata.json | 10 - .../select_views.metadata.json | 9 - .../postgres_regress/sequence.metadata.json | 15 - .../postgres_regress/spgist.metadata.json | 13 +- .../postgres_regress/sqljson.metadata.json | 1 - .../sqljson_jsontable.metadata.json | 2 - .../sqljson_queryfuncs.metadata.json | 6 - .../postgres_regress/stats.metadata.json | 40 - .../postgres_regress/stats_ext.metadata.json | 40 - .../postgres_regress/subselect.metadata.json | 59 - .../postgres_regress/sysviews.metadata.json | 2 - .../tablesample.metadata.json | 16 - .../postgres_regress/tablespace.metadata.json | 9 - .../parse/postgres_regress/temp.metadata.json | 17 - .../postgres_regress/test_setup.metadata.json | 17 - .../parse/postgres_regress/tid.metadata.json | 3 - .../tidrangescan.metadata.json | 8 - .../postgres_regress/tidscan.metadata.json | 10 - .../parse/postgres_regress/time.metadata.json | 13 +- .../postgres_regress/timestamp.metadata.json | 80 +- .../timestamptz.metadata.json | 86 -- .../postgres_regress/timetz.metadata.json | 15 - .../transactions.metadata.json | 108 -- .../postgres_regress/triggers.metadata.json | 280 ----- .../postgres_regress/truncate.metadata.json | 38 - .../postgres_regress/tsearch.metadata.json | 11 - .../parse/postgres_regress/tsrf.metadata.json | 4 - .../postgres_regress/tuplesort.metadata.json | 36 - .../parse/postgres_regress/txid.metadata.json | 4 - .../typed_table.metadata.json | 1 - .../postgres_regress/union.metadata.json | 4 - .../updatable_views.metadata.json | 461 +------ .../postgres_regress/update.metadata.json | 94 -- .../parse/postgres_regress/uuid.metadata.json | 16 - .../postgres_regress/vacuum.metadata.json | 51 - .../vacuum_parallel.metadata.json | 3 - .../postgres_regress/varchar.metadata.json | 11 +- .../postgres_regress/window.metadata.json | 6 - .../parse/postgres_regress/with.metadata.json | 67 -- .../write_parallel.metadata.json | 1 - .../parse/postgres_regress/xid.metadata.json | 5 - .../parse/postgres_regress/xml.metadata.json | 24 +- .../postgres_regress/xmlmap.metadata.json | 4 - 229 files changed, 1309 insertions(+), 7524 deletions(-) create mode 100644 internal/parse/dml.go diff --git a/PLAN.md b/PLAN.md index deed895..c75b0de 100644 --- a/PLAN.md +++ b/PLAN.md @@ -389,8 +389,9 @@ gate; the corpus harness exists before the first line of the lexer. locking clauses. The largest single chunk of work. `ParseToJSON` ships here too (the generated-equivalent JSON emitter plus `Parse`/ `ParseToProtobuf`). See "As-built notes (milestone 4)". -5. **DML.** `INSERT` (`ON CONFLICT`, `OVERRIDING`), `UPDATE`, `DELETE`, - `MERGE`, `RETURNING`, `COPY`, `PREPARE`/`EXECUTE`, cursors. +5. **DML.** ✅ *Landed 2026-08-16.* `INSERT` (`ON CONFLICT`, `OVERRIDING`), + `UPDATE`, `DELETE`, `MERGE`, `RETURNING`, `COPY`, `PREPARE`/`EXECUTE`, + cursors. See "As-built notes (milestone 5)". 6. **DDL, part 1.** `CREATE`/`ALTER TABLE` (the second-biggest grammar region: constraints, partitioning, identity, storage options), `CREATE INDEX`, views, sequences, schemas. @@ -525,6 +526,35 @@ Measured at the pin, where the plan's estimates differ: classifier used to drive the milestone; the mutation fuzzer replaces it in milestone 12. +### As-built notes (milestone 5) + +- The five statements that carry `opt_with_clause` (SELECT, INSERT, UPDATE, + DELETE, MERGE) share one entry point: the WITH clause is parsed once and + the following head token picks the statement, reproducing how the LALR + tables keep all five alternatives alive through the with_clause. + `PreparableStmt` (CTE bodies, `COPY (query)`, `PREPARE ... AS`) now + accepts the full set. +- The grammar's unreserved-keyword ambiguities are each resolved by the same + single token of lookahead bison uses: FETCH/MOVE direction keywords vs. a + cursor named `next`/`prior`/`forward`/…, `DEALLOCATE PREPARE x` vs. a plan + named `prepare`, `WHERE CURRENT OF` vs. a column named `current` (OF + decides), `insert_rest`'s `'(' column list` vs. a parenthesized SelectStmt + (skip-the-parens select-head gate, as in table_ref), and + `relation_expr_opt_alias` refusing bare `SET` as an alias (the production + outranks SET's `%nonassoc` precedence). +- COPY's two action ereports ("STDIN/STDOUT not allowed with PROGRAM", + "WHERE clause not allowed with COPY TO") reproduce bison's + empty-production location rule: `@8` falls back through empty + copy_delimiter/opt_using to the file-name token's location. +- `CREATE TABLE ... AS EXECUTE` is deferred to milestone 6 with the rest of + the CREATE TABLE machinery (`OptTemp`, `create_as_target`, + `opt_with_data`); plain `EXECUTE name [(params)]` ships now. +- Corpus effect: 7,337 parse todos and 73 deparse todos (error-path cases, + where the golden is the parse error itself) graduated. Every remaining + parse todo starts with — or embeds — a statement type from milestones 6-7, + and the `-summary` classifier shows no tree or error mismatches against + any implemented statement. + ## Regeneration (the PostgreSQL-upgrade story) Everything derived is derived by committed tooling from the pin: diff --git a/internal/parse/dml.go b/internal/parse/dml.go new file mode 100644 index 0000000..b23a5cc --- /dev/null +++ b/internal/parse/dml.go @@ -0,0 +1,1071 @@ +package parse + +import ( + "math" + + "github.com/sqlc-dev/oliphant/ast" +) + +// Milestone 5: the DML statement family — INSERT (ON CONFLICT, OVERRIDING), +// UPDATE, DELETE, MERGE, RETURNING, COPY, PREPARE/EXECUTE/DEALLOCATE, and +// cursors (DECLARE/FETCH/MOVE/CLOSE). + +// parseWithPrefixedStmt handles the statements that begin with +// opt_with_clause: the WITH clause is parsed once, then the head token of +// what follows picks the statement, exactly as the LALR tables keep all five +// alternatives alive through the with_clause. +// gram.y: InsertStmt/UpdateStmt/DeleteStmt/MergeStmt: opt_with_clause ...; +// select_no_parens: with_clause select_clause ... +func (p *parser) parseWithPrefixedStmt() *ast.Node { + with := p.parseWithClause() + switch p.kind() { + case ast.Token_INSERT: + return p.parseInsertStmt(with) + case ast.Token_UPDATE: + return p.parseUpdateStmt(with) + case ast.Token_DELETE_P: + return p.parseDeleteStmt(with) + case ast.Token_MERGE: + return p.parseMergeStmt(with) + } + return p.parseSelectNoParensRest(with) +} + +// parseInsertStmt is gram.y's InsertStmt: +// opt_with_clause INSERT INTO insert_target insert_rest +// opt_on_conflict returning_clause +func (p *parser) parseInsertStmt(with *ast.WithClause) *ast.Node { + p.expect(ast.Token_INSERT) + p.expect(ast.Token_INTO) + rel := p.parseInsertTarget() + n := p.parseInsertRest() + n.Relation = rel + n.OnConflictClause = p.parseOptOnConflict() + n.ReturningList = p.parseReturningClause() + n.WithClause = with + return nInsertStmt(n) +} + +// parseInsertTarget is gram.y's insert_target: qualified_name, with the +// alias requiring AS (VALUES would conflict with an optional alias). +func (p *parser) parseInsertTarget() *ast.RangeVar { + rel := p.parseQualifiedName() + if p.have(ast.Token_AS) { + rel.Alias = makeAlias(p.colId(), nil) + } + return rel +} + +// parseInsertRest is gram.y's insert_rest. +func (p *parser) parseInsertRest() *ast.InsertStmt { + n := &ast.InsertStmt{Override: ast.OverridingKind_OVERRIDING_NOT_SET} + switch { + case p.kind() == ast.Token_DEFAULT: + // DEFAULT VALUES + p.next() + p.expect(ast.Token_VALUES) + return n + case p.kind() == ast.Token_OVERRIDING: + p.next() + n.Override = p.parseOverrideKind() + p.expect(ast.Token_VALUE_P) + n.SelectStmt = p.parseSelectStmt() + return n + case p.kind() == ast.Token('(') && !p.looksLikeSelectAhead() && + p.kindN(1) != ast.Token('('): + // '(' insert_column_list ')' [OVERRIDING override_kind VALUE_P] SelectStmt + // A '(' that opens a select (or another '(', which only a select can + // absorb) belongs to SelectStmt instead — the LALR tables keep both + // paths alive through the '('. + p.next() + n.Cols = p.parseInsertColumnList() + p.expect(ast.Token(')')) + if p.kind() == ast.Token_OVERRIDING { + p.next() + n.Override = p.parseOverrideKind() + p.expect(ast.Token_VALUE_P) + } + n.SelectStmt = p.parseSelectStmt() + return n + } + n.SelectStmt = p.parseSelectStmt() + return n +} + +// parseOverrideKind is gram.y's override_kind (OVERRIDING consumed). +func (p *parser) parseOverrideKind() ast.OverridingKind { + switch { + case p.have(ast.Token_USER): + return ast.OverridingKind_OVERRIDING_USER_VALUE + case p.have(ast.Token_SYSTEM_P): + return ast.OverridingKind_OVERRIDING_SYSTEM_VALUE + } + p.syntaxErrorAt() + return ast.OverridingKind_OVERRIDING_NOT_SET +} + +// parseInsertColumnList is gram.y's insert_column_list. +func (p *parser) parseInsertColumnList() []*ast.Node { + list := []*ast.Node{p.parseInsertColumnItem()} + for p.have(ast.Token(',')) { + list = append(list, p.parseInsertColumnItem()) + } + return list +} + +// parseInsertColumnItem is gram.y's insert_column_item: ColId opt_indirection. +func (p *parser) parseInsertColumnItem() *ast.Node { + tok := p.peek() + name := p.colId() + rt := &ast.ResTarget{Name: name, Location: tok.Start} + if ind := p.parseOptIndirection(); ind != nil { + rt.Indirection = p.check_indirection(ind) + } + return nResTarget(rt) +} + +// parseOptOnConflict is gram.y's opt_on_conflict. +func (p *parser) parseOptOnConflict() *ast.OnConflictClause { + if p.kind() != ast.Token_ON { + return nil + } + tok := p.next() + p.expect(ast.Token_CONFLICT) + oc := &ast.OnConflictClause{Location: tok.Start} + oc.Infer = p.parseOptConfExpr() + p.expect(ast.Token_DO) + switch { + case p.have(ast.Token_UPDATE): + p.expect(ast.Token_SET) + oc.Action = ast.OnConflictAction_ONCONFLICT_UPDATE + oc.TargetList = p.parseSetClauseList() + if p.have(ast.Token_WHERE) { + oc.WhereClause = p.parseAExpr(0) + } + case p.have(ast.Token_NOTHING): + oc.Action = ast.OnConflictAction_ONCONFLICT_NOTHING + default: + p.syntaxErrorAt() + } + return oc +} + +// parseOptConfExpr is gram.y's opt_conf_expr. +func (p *parser) parseOptConfExpr() *ast.InferClause { + switch p.kind() { + case ast.Token('('): + tok := p.next() + ic := &ast.InferClause{Location: tok.Start} + ic.IndexElems = p.parseIndexParams() + p.expect(ast.Token(')')) + if p.have(ast.Token_WHERE) { + ic.WhereClause = p.parseAExpr(0) + } + return ic + case ast.Token_ON: + tok := p.next() + p.expect(ast.Token_CONSTRAINT) + return &ast.InferClause{Conname: p.name(), Location: tok.Start} + } + return nil +} + +// parseIndexParams is gram.y's index_params. +func (p *parser) parseIndexParams() []*ast.Node { + list := []*ast.Node{p.parseIndexElem()} + for p.have(ast.Token(',')) { + list = append(list, p.parseIndexElem()) + } + return list +} + +// parseIndexElem is gram.y's index_elem: a bare column, a parenthesized +// expression, or (for backwards compatibility) an unparenthesized function +// call. +func (p *parser) parseIndexElem() *ast.Node { + switch { + case p.kind() == ast.Token('('): + p.next() + expr := p.parseAExpr(0) + p.expect(ast.Token(')')) + el := p.parseIndexElemOptions() + el.Expr = expr + return nIndexElem(el) + case p.startsFunctionCallAhead(): + expr := p.parseFuncExprWindowless() + el := p.parseIndexElemOptions() + el.Expr = expr + return nIndexElem(el) + } + name := p.colId() + el := p.parseIndexElemOptions() + el.Name = name + return nIndexElem(el) +} + +// parseIndexElemOptions is gram.y's index_elem_options: opt_collate, then +// either opt_qualified_name or any_name reloptions, then opt_asc_desc and +// opt_nulls_order. +func (p *parser) parseIndexElemOptions() *ast.IndexElem { + el := &ast.IndexElem{ + Ordering: ast.SortByDir_SORTBY_DEFAULT, + NullsOrdering: ast.SortByNulls_SORTBY_NULLS_DEFAULT, + } + if p.have(ast.Token_COLLATE) { + el.Collation = p.anyName() + } + if isColIdToken(p.peek()) { + el.Opclass = p.anyName() + if p.kind() == ast.Token('(') { + el.Opclassopts = p.parseReloptions() + } + } + switch p.kind() { + case ast.Token_ASC: + p.next() + el.Ordering = ast.SortByDir_SORTBY_ASC + case ast.Token_DESC: + p.next() + el.Ordering = ast.SortByDir_SORTBY_DESC + } + if p.kind() == ast.Token_NULLS_LA { + p.next() + if p.have(ast.Token_FIRST_P) { + el.NullsOrdering = ast.SortByNulls_SORTBY_NULLS_FIRST + } else { + p.expect(ast.Token_LAST_P) + el.NullsOrdering = ast.SortByNulls_SORTBY_NULLS_LAST + } + } + return el +} + +// parseReloptions is gram.y's reloptions: '(' reloption_list ')'. +func (p *parser) parseReloptions() []*ast.Node { + p.expect(ast.Token('(')) + list := []*ast.Node{p.parseReloptionElem()} + for p.have(ast.Token(',')) { + list = append(list, p.parseReloptionElem()) + } + p.expect(ast.Token(')')) + return list +} + +// parseReloptionElem is gram.y's reloption_elem. +func (p *parser) parseReloptionElem() *ast.Node { + tok := p.peek() + name := p.colLabel() + if p.have(ast.Token('.')) { + name2 := p.colLabel() + var arg *ast.Node + if p.have(ast.Token('=')) { + arg = p.parseDefArg() + } + return makeDefElemExtended(name, name2, arg, ast.DefElemAction_DEFELEM_UNSPEC, tok.Start) + } + var arg *ast.Node + if p.have(ast.Token('=')) { + arg = p.parseDefArg() + } + return makeDefElem(name, arg, tok.Start) +} + +// parseDefArg is gram.y's def_arg: func_type | reserved_keyword | +// qual_all_Op | NumericOnly | Sconst | NONE. +func (p *parser) parseDefArg() *ast.Node { + tok := p.peek() + switch tok.Kind { + case ast.Token_SCONST: + p.next() + return nStr(tok.Str) + case ast.Token_NONE: + p.next() + return nStr("none") + case ast.Token_ICONST, ast.Token_FCONST: + return p.parseNumericOnly() + case ast.Token('+'), ast.Token('-'): + // '+'/'-' start NumericOnly when a number follows, all_Op otherwise. + if p.kindN(1) == ast.Token_ICONST || p.kindN(1) == ast.Token_FCONST { + return p.parseNumericOnly() + } + return nList(p.parseQualAllOp()) + case ast.Token_Op, ast.Token('*'), ast.Token('/'), ast.Token('%'), + ast.Token('^'), ast.Token('<'), ast.Token('>'), ast.Token('='), + ast.Token_LESS_EQUALS, ast.Token_GREATER_EQUALS, ast.Token_NOT_EQUALS, + ast.Token_OPERATOR: + return nList(p.parseQualAllOp()) + } + if tok.KeywordKind == ast.KeywordKind_RESERVED_KEYWORD { + p.next() + return nStr(tok.Str) + } + return nTypeName(p.parseTypename()) +} + +// parseNumericOnly is gram.y's NumericOnly. +func (p *parser) parseNumericOnly() *ast.Node { + tok := p.peek() + switch tok.Kind { + case ast.Token_FCONST: + p.next() + return nFloat(tok.Str) + case ast.Token('+'): + p.next() + if p.kind() == ast.Token_FCONST { + return nFloat(p.next().Str) + } + return nInteger(p.iconst()) + case ast.Token('-'): + p.next() + if p.kind() == ast.Token_FCONST { + f := &ast.Float{Fval: p.next().Str} + doNegateFloat(f) + return &ast.Node{Node: &ast.Node_Float{Float: f}} + } + return nInteger(-p.iconst()) + } + return nInteger(p.iconst()) +} + +// parseSignedIconst is gram.y's SignedIconst. +func (p *parser) parseSignedIconst() int32 { + switch { + case p.have(ast.Token('+')): + return p.iconst() + case p.have(ast.Token('-')): + return -p.iconst() + } + return p.iconst() +} + +// parseReturningClause is gram.y's returning_clause. +func (p *parser) parseReturningClause() []*ast.Node { + if !p.have(ast.Token_RETURNING) { + return nil + } + return p.parseTargetList() +} + +// parseDeleteStmt is gram.y's DeleteStmt. +func (p *parser) parseDeleteStmt(with *ast.WithClause) *ast.Node { + p.expect(ast.Token_DELETE_P) + p.expect(ast.Token_FROM) + n := &ast.DeleteStmt{WithClause: with} + n.Relation = p.parseRelationExprOptAlias() + // using_clause + if p.have(ast.Token_USING) { + n.UsingClause = p.parseFromList() + } + n.WhereClause = p.parseWhereOrCurrentClause() + n.ReturningList = p.parseReturningClause() + return nDeleteStmt(n) +} + +// parseUpdateStmt is gram.y's UpdateStmt. +func (p *parser) parseUpdateStmt(with *ast.WithClause) *ast.Node { + p.expect(ast.Token_UPDATE) + n := &ast.UpdateStmt{WithClause: with} + n.Relation = p.parseRelationExprOptAlias() + p.expect(ast.Token_SET) + n.TargetList = p.parseSetClauseList() + if p.have(ast.Token_FROM) { + n.FromClause = p.parseFromList() + } + n.WhereClause = p.parseWhereOrCurrentClause() + n.ReturningList = p.parseReturningClause() + return nUpdateStmt(n) +} + +// parseRelationExprOptAlias is gram.y's relation_expr_opt_alias. The bare +// (no AS) alias form excludes SET: the production outranks the SET token's +// precedence so that "UPDATE foo set ..." reads SET as the keyword. +func (p *parser) parseRelationExprOptAlias() *ast.RangeVar { + rel := p.parseRelationExprVar() + switch { + case p.have(ast.Token_AS): + rel.Alias = makeAlias(p.colId(), nil) + case isColIdToken(p.peek()) && p.kind() != ast.Token_SET: + rel.Alias = makeAlias(p.next().Str, nil) + } + return rel +} + +// parseWhereOrCurrentClause is gram.y's where_or_current_clause. CURRENT_P +// resolves to the cursor form only when OF follows (one-token lookahead, +// as bison shifts OF where a ColumnRef reduction would be dead). +func (p *parser) parseWhereOrCurrentClause() *ast.Node { + if !p.have(ast.Token_WHERE) { + return nil + } + if p.kind() == ast.Token_CURRENT_P && p.kindN(1) == ast.Token_OF { + p.next() + p.next() + return nCurrentOfExpr(&ast.CurrentOfExpr{CursorName: p.name()}) + } + return p.parseAExpr(0) +} + +// parseSetClauseList is gram.y's set_clause_list (list_concat semantics: +// each multi-assignment set_clause contributes all its targets). +func (p *parser) parseSetClauseList() []*ast.Node { + list := p.parseSetClause() + for p.have(ast.Token(',')) { + list = append(list, p.parseSetClause()...) + } + return list +} + +// parseSetClause is gram.y's set_clause. +func (p *parser) parseSetClause() []*ast.Node { + if p.have(ast.Token('(')) { + // '(' set_target_list ')' '=' a_expr + targets := []*ast.Node{p.parseSetTarget()} + for p.have(ast.Token(',')) { + targets = append(targets, p.parseSetTarget()) + } + p.expect(ast.Token(')')) + p.expect(ast.Token('=')) + source := p.parseAExpr(0) + ncolumns := int32(len(targets)) + for i, t := range targets { + t.GetResTarget().Val = nMultiAssignRef(&ast.MultiAssignRef{ + Source: source, + Colno: int32(i) + 1, + Ncolumns: ncolumns, + }) + } + return targets + } + t := p.parseSetTarget() + p.expect(ast.Token('=')) + t.GetResTarget().Val = p.parseAExpr(0) + return []*ast.Node{t} +} + +// parseSetTarget is gram.y's set_target: ColId opt_indirection. +func (p *parser) parseSetTarget() *ast.Node { + tok := p.peek() + name := p.colId() + rt := &ast.ResTarget{Name: name, Location: tok.Start} + if ind := p.parseOptIndirection(); ind != nil { + rt.Indirection = p.check_indirection(ind) + } + return nResTarget(rt) +} + +// parseMergeStmt is gram.y's MergeStmt. +func (p *parser) parseMergeStmt(with *ast.WithClause) *ast.Node { + p.expect(ast.Token_MERGE) + p.expect(ast.Token_INTO) + m := &ast.MergeStmt{WithClause: with} + m.Relation = p.parseRelationExprOptAlias() + p.expect(ast.Token_USING) + m.SourceRelation = p.parseTableRef() + p.expect(ast.Token_ON) + m.JoinCondition = p.parseAExpr(0) + // merge_when_list + m.MergeWhenClauses = []*ast.Node{p.parseMergeWhenClause()} + for p.kind() == ast.Token_WHEN { + m.MergeWhenClauses = append(m.MergeWhenClauses, p.parseMergeWhenClause()) + } + m.ReturningList = p.parseReturningClause() + return nMergeStmt(m) +} + +// parseMergeWhenClause is gram.y's merge_when_clause, covering +// merge_when_tgt_matched / merge_when_tgt_not_matched / +// opt_merge_when_condition and the four action forms. +func (p *parser) parseMergeWhenClause() *ast.Node { + p.expect(ast.Token_WHEN) + matchKind := ast.MergeMatchKind_MERGE_WHEN_MATCHED + matched := true + if !p.have(ast.Token_MATCHED) { + p.expect(ast.Token_NOT) + p.expect(ast.Token_MATCHED) + matchKind = ast.MergeMatchKind_MERGE_WHEN_NOT_MATCHED_BY_TARGET + matched = false + if p.have(ast.Token_BY) { + switch { + case p.have(ast.Token_SOURCE): + matchKind = ast.MergeMatchKind_MERGE_WHEN_NOT_MATCHED_BY_SOURCE + matched = true + case p.have(ast.Token_TARGET): + default: + p.syntaxErrorAt() + } + } + } + var cond *ast.Node + if p.have(ast.Token_AND) { + cond = p.parseAExpr(0) + } + p.expect(ast.Token_THEN) + var m *ast.MergeWhenClause + switch { + case matched && p.kind() == ast.Token_UPDATE: + // gram.y: merge_update + p.next() + p.expect(ast.Token_SET) + m = &ast.MergeWhenClause{ + CommandType: ast.CmdType_CMD_UPDATE, + Override: ast.OverridingKind_OVERRIDING_NOT_SET, + TargetList: p.parseSetClauseList(), + } + case matched && p.kind() == ast.Token_DELETE_P: + // gram.y: merge_delete + p.next() + m = &ast.MergeWhenClause{ + CommandType: ast.CmdType_CMD_DELETE, + Override: ast.OverridingKind_OVERRIDING_NOT_SET, + } + case !matched && p.kind() == ast.Token_INSERT: + p.next() + m = p.parseMergeInsertRest() + case p.kind() == ast.Token_DO: + p.next() + p.expect(ast.Token_NOTHING) + m = &ast.MergeWhenClause{ + CommandType: ast.CmdType_CMD_NOTHING, + Override: ast.OverridingKind_OVERRIDING_NOT_SET, + } + default: + p.syntaxErrorAt() + } + m.MatchKind = matchKind + m.Condition = cond + return nMergeWhenClause(m) +} + +// parseMergeInsertRest is gram.y's merge_insert (INSERT consumed). +func (p *parser) parseMergeInsertRest() *ast.MergeWhenClause { + m := &ast.MergeWhenClause{ + CommandType: ast.CmdType_CMD_INSERT, + Override: ast.OverridingKind_OVERRIDING_NOT_SET, + } + switch { + case p.kind() == ast.Token_DEFAULT: + // INSERT DEFAULT VALUES + p.next() + p.expect(ast.Token_VALUES) + return m + case p.kind() == ast.Token_OVERRIDING: + p.next() + m.Override = p.parseOverrideKind() + p.expect(ast.Token_VALUE_P) + case p.have(ast.Token('(')): + m.TargetList = p.parseInsertColumnList() + p.expect(ast.Token(')')) + if p.kind() == ast.Token_OVERRIDING { + p.next() + m.Override = p.parseOverrideKind() + p.expect(ast.Token_VALUE_P) + } + } + m.Values = p.parseMergeValuesClause() + return m +} + +// parseMergeValuesClause is gram.y's merge_values_clause. +func (p *parser) parseMergeValuesClause() []*ast.Node { + p.expect(ast.Token_VALUES) + p.expect(ast.Token('(')) + list := p.parseExprList() + p.expect(ast.Token(')')) + return list +} + +// parseCopyStmt is gram.y's CopyStmt (both the relation and query forms). +func (p *parser) parseCopyStmt() *ast.Node { + p.expect(ast.Token_COPY) + n := &ast.CopyStmt{} + + if p.kind() == ast.Token('(') { + // COPY '(' PreparableStmt ')' TO opt_program copy_file_name + // opt_with copy_options + p.next() + n.Query = p.parsePreparableStmt() + p.expect(ast.Token(')')) + toTok := p.expect(ast.Token_TO) + n.IsProgram = p.have(ast.Token_PROGRAM) + filename, isNull := p.parseCopyFileName() + n.Filename = filename + if n.IsProgram && isNull { + p.ereport("base_yyparse", "STDIN/STDOUT not allowed with PROGRAM", toTok.Start) + } + p.have(ast.Token_WITH) // opt_with + n.Options = p.parseCopyOptions() + return nCopyStmt(n) + } + + // COPY opt_binary qualified_name opt_column_list copy_from opt_program + // copy_file_name copy_delimiter opt_with copy_options where_clause + var binary *ast.Node + if p.kind() == ast.Token_BINARY { + tok := p.next() + binary = makeDefElem("format", nStr("binary"), tok.Start) + } + n.Relation = p.parseQualifiedName() + if p.have(ast.Token('(')) { + n.Attlist = p.columnList() + p.expect(ast.Token(')')) + } + switch { + case p.have(ast.Token_FROM): + n.IsFrom = true + case p.have(ast.Token_TO): + default: + p.syntaxErrorAt() + } + n.IsProgram = p.have(ast.Token_PROGRAM) + fileTok := p.peek() + filename, isNull := p.parseCopyFileName() + n.Filename = filename + // copy_delimiter: [USING] DELIMITERS Sconst. Bison's empty-production + // location rule makes @8 (and the chain through empty copy_delimiter / + // opt_using) fall back to the previous symbol's location. + loc8 := fileTok.Start + var delim *ast.Node + if p.kind() == ast.Token_USING || p.kind() == ast.Token_DELIMITERS { + if tok := p.peek(); tok.Kind == ast.Token_USING { + p.next() + loc8 = tok.Start + } + dtok := p.expect(ast.Token_DELIMITERS) + delim = makeDefElem("delimiter", nStr(p.sconst()), dtok.Start) + } + if tok := p.peek(); tok.Kind == ast.Token_WITH { + p.next() + loc8 = tok.Start + } + opts := p.parseCopyOptions() + whereLoc := int32(-1) + if wtok := p.peek(); wtok.Kind == ast.Token_WHERE { + p.next() + n.WhereClause = p.parseAExpr(0) + whereLoc = wtok.Start + } + // The action's checks, in order. + if n.IsProgram && isNull { + p.ereport("base_yyparse", "STDIN/STDOUT not allowed with PROGRAM", loc8) + } + if !n.IsFrom && n.WhereClause != nil { + p.ereport("base_yyparse", "WHERE clause not allowed with COPY TO", whereLoc) + } + if binary != nil { + n.Options = append(n.Options, binary) + } + if delim != nil { + n.Options = append(n.Options, delim) + } + n.Options = append(n.Options, opts...) + return nCopyStmt(n) +} + +// parseCopyFileName is gram.y's copy_file_name; the bool reports the NULL +// (STDIN/STDOUT) cases. +func (p *parser) parseCopyFileName() (string, bool) { + switch p.kind() { + case ast.Token_STDIN, ast.Token_STDOUT: + p.next() + return "", true + } + return p.sconst(), false +} + +// parseCopyOptions is gram.y's copy_options: either the parenthesized +// generic list or the legacy space-separated option keywords. +func (p *parser) parseCopyOptions() []*ast.Node { + if p.kind() == ast.Token('(') { + p.next() + list := []*ast.Node{p.parseCopyGenericOptElem()} + for p.have(ast.Token(',')) { + list = append(list, p.parseCopyGenericOptElem()) + } + p.expect(ast.Token(')')) + return list + } + var list []*ast.Node + for { + item := p.parseCopyOptItem() + if item == nil { + return list + } + list = append(list, item) + } +} + +// parseCopyOptItem is gram.y's copy_opt_item; returns nil when the current +// token does not start one. +func (p *parser) parseCopyOptItem() *ast.Node { + tok := p.peek() + switch tok.Kind { + case ast.Token_BINARY: + p.next() + return makeDefElem("format", nStr("binary"), tok.Start) + case ast.Token_FREEZE: + p.next() + return makeDefElem("freeze", nBoolean(true), tok.Start) + case ast.Token_DELIMITER: + p.next() + p.have(ast.Token_AS) + return makeDefElem("delimiter", nStr(p.sconst()), tok.Start) + case ast.Token_NULL_P: + p.next() + p.have(ast.Token_AS) + return makeDefElem("null", nStr(p.sconst()), tok.Start) + case ast.Token_CSV: + p.next() + return makeDefElem("format", nStr("csv"), tok.Start) + case ast.Token_HEADER_P: + p.next() + return makeDefElem("header", nBoolean(true), tok.Start) + case ast.Token_QUOTE: + p.next() + p.have(ast.Token_AS) + return makeDefElem("quote", nStr(p.sconst()), tok.Start) + case ast.Token_ESCAPE: + p.next() + p.have(ast.Token_AS) + return makeDefElem("escape", nStr(p.sconst()), tok.Start) + case ast.Token_FORCE: + p.next() + switch { + case p.have(ast.Token_QUOTE): + if p.have(ast.Token('*')) { + return makeDefElem("force_quote", nAStar(), tok.Start) + } + return makeDefElem("force_quote", nList(p.columnList()), tok.Start) + case p.have(ast.Token_NOT): + p.expect(ast.Token_NULL_P) + if p.have(ast.Token('*')) { + return makeDefElem("force_not_null", nAStar(), tok.Start) + } + return makeDefElem("force_not_null", nList(p.columnList()), tok.Start) + case p.have(ast.Token_NULL_P): + if p.have(ast.Token('*')) { + return makeDefElem("force_null", nAStar(), tok.Start) + } + return makeDefElem("force_null", nList(p.columnList()), tok.Start) + } + p.syntaxErrorAt() + case ast.Token_ENCODING: + p.next() + return makeDefElem("encoding", nStr(p.sconst()), tok.Start) + } + return nil +} + +// parseCopyGenericOptElem is gram.y's copy_generic_opt_elem. +func (p *parser) parseCopyGenericOptElem() *ast.Node { + tok := p.peek() + name := p.colLabel() + return makeDefElem(name, p.parseCopyGenericOptArg(), tok.Start) +} + +// parseCopyGenericOptArg is gram.y's copy_generic_opt_arg. +func (p *parser) parseCopyGenericOptArg() *ast.Node { + tok := p.peek() + switch tok.Kind { + case ast.Token_TRUE_P: + p.next() + return nStr("true") + case ast.Token_FALSE_P: + p.next() + return nStr("false") + case ast.Token_ON: + p.next() + return nStr("on") + case ast.Token_SCONST: + p.next() + return nStr(tok.Str) + case ast.Token_ICONST, ast.Token_FCONST, ast.Token('+'), ast.Token('-'): + return p.parseNumericOnly() + case ast.Token('*'): + p.next() + return nAStar() + case ast.Token_DEFAULT: + p.next() + return nStr("default") + case ast.Token('('): + p.next() + list := []*ast.Node{nStr(p.parseOptBooleanOrString())} + for p.have(ast.Token(',')) { + list = append(list, nStr(p.parseOptBooleanOrString())) + } + p.expect(ast.Token(')')) + return nList(list) + } + if isNonReservedWordToken(tok) { + p.next() + return nStr(tok.Str) + } + return nil +} + +// parseOptBooleanOrString is gram.y's opt_boolean_or_string. +func (p *parser) parseOptBooleanOrString() string { + switch p.kind() { + case ast.Token_TRUE_P: + p.next() + return "true" + case ast.Token_FALSE_P: + p.next() + return "false" + case ast.Token_ON: + p.next() + return "on" + case ast.Token_SCONST: + return p.sconst() + } + return p.nonReservedWord() +} + +// parsePrepareStmt is gram.y's PrepareStmt. +func (p *parser) parsePrepareStmt() *ast.Node { + p.expect(ast.Token_PREPARE) + n := &ast.PrepareStmt{Name: p.name()} + // prep_type_clause + if p.have(ast.Token('(')) { + n.Argtypes = p.parseTypeList() + p.expect(ast.Token(')')) + } + p.expect(ast.Token_AS) + n.Query = p.parsePreparableStmt() + return nPrepareStmt(n) +} + +// parseTypeList is gram.y's type_list. +func (p *parser) parseTypeList() []*ast.Node { + list := []*ast.Node{nTypeName(p.parseTypename())} + for p.have(ast.Token(',')) { + list = append(list, nTypeName(p.parseTypename())) + } + return list +} + +// parseExecuteStmt is gram.y's ExecuteStmt (the CREATE TABLE AS EXECUTE +// forms land with the DDL milestone's CREATE machinery). +func (p *parser) parseExecuteStmt() *ast.Node { + p.expect(ast.Token_EXECUTE) + n := &ast.ExecuteStmt{Name: p.name()} + // execute_param_clause + if p.have(ast.Token('(')) { + n.Params = p.parseExprList() + p.expect(ast.Token(')')) + } + return nExecuteStmt(n) +} + +// parseDeallocateStmt is gram.y's DeallocateStmt. A lone PREPARE with no +// name after it is itself the plan name ("DEALLOCATE prepare"), as the LALR +// lookahead resolves. +func (p *parser) parseDeallocateStmt() *ast.Node { + p.expect(ast.Token_DEALLOCATE) + if p.kind() == ast.Token_PREPARE && + (isColIdToken(p.peekN(1)) || p.kindN(1) == ast.Token_ALL) { + p.next() + } + if p.have(ast.Token_ALL) { + return nDeallocateStmt(&ast.DeallocateStmt{Isall: true, Location: -1}) + } + tok := p.peek() + return nDeallocateStmt(&ast.DeallocateStmt{Name: p.name(), Location: tok.Start}) +} + +// Cursor option flags (parsenodes.h). +const ( + cursorOptBinary = 0x0001 + cursorOptScroll = 0x0002 + cursorOptNoScroll = 0x0004 + cursorOptInsensitive = 0x0008 + cursorOptAsensitive = 0x0010 + cursorOptHold = 0x0020 + cursorOptFastPlan = 0x0100 +) + +// parseDeclareCursorStmt is gram.y's DeclareCursorStmt. +func (p *parser) parseDeclareCursorStmt() *ast.Node { + p.expect(ast.Token_DECLARE) + n := &ast.DeclareCursorStmt{Portalname: p.name()} + // cursor_options — we always set FAST_PLAN, like the reference. + options := int32(cursorOptFastPlan) +loop: + for { + switch p.kind() { + case ast.Token_NO: + p.next() + p.expect(ast.Token_SCROLL) + options |= cursorOptNoScroll + case ast.Token_SCROLL: + p.next() + options |= cursorOptScroll + case ast.Token_BINARY: + p.next() + options |= cursorOptBinary + case ast.Token_ASENSITIVE: + p.next() + options |= cursorOptAsensitive + case ast.Token_INSENSITIVE: + p.next() + options |= cursorOptInsensitive + default: + break loop + } + } + p.expect(ast.Token_CURSOR) + // opt_hold + switch { + case p.have(ast.Token_WITH): + p.expect(ast.Token_HOLD) + options |= cursorOptHold + case p.have(ast.Token_WITHOUT): + p.expect(ast.Token_HOLD) + } + n.Options = options + p.expect(ast.Token_FOR) + n.Query = p.parseSelectStmt() + return nDeclareCursorStmt(n) +} + +// parseClosePortalStmt is gram.y's ClosePortalStmt. +func (p *parser) parseClosePortalStmt() *ast.Node { + p.expect(ast.Token_CLOSE) + n := &ast.ClosePortalStmt{} + if !p.have(ast.Token_ALL) { + n.Portalname = p.name() + } + return nClosePortalStmt(n) +} + +// fetchAll is FETCH_ALL (LONG_MAX on the 64-bit reference build). +const fetchAll = math.MaxInt64 + +// parseFetchStmt is gram.y's FetchStmt: FETCH fetch_args | MOVE fetch_args. +func (p *parser) parseFetchStmt(ismove bool) *ast.Node { + p.next() // FETCH or MOVE + n := p.parseFetchArgs() + n.Ismove = ismove + return nFetchStmt(n) +} + +// fetchArgsFollows reports whether the token after a direction keyword +// continues fetch_args (opt_from_in cursor_name), which is what commits the +// keyword to its direction reading rather than being the cursor_name. +func (p *parser) fetchArgsFollows(n int) bool { + tok := p.peekN(n) + if tok.Kind == ast.Token_FROM || tok.Kind == ast.Token_IN_P { + return true + } + return isColIdToken(tok) +} + +// parseOptFromIn is gram.y's opt_from_in. +func (p *parser) parseOptFromIn() { + if p.kind() == ast.Token_FROM || p.kind() == ast.Token_IN_P { + p.next() + } +} + +// parseFetchArgs is gram.y's fetch_args. The direction keywords are all +// unreserved, so each doubles as a possible cursor_name; one token of +// lookahead decides, as in the LALR tables. +func (p *parser) parseFetchArgs() *ast.FetchStmt { + tok := p.peek() + switch tok.Kind { + case ast.Token_FROM, ast.Token_IN_P: + // from_in cursor_name + p.next() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: 1, Portalname: p.name()} + case ast.Token_NEXT: + if p.fetchArgsFollows(1) { + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: 1, Portalname: p.name()} + } + case ast.Token_PRIOR: + if p.fetchArgsFollows(1) { + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_BACKWARD, HowMany: 1, Portalname: p.name()} + } + case ast.Token_FIRST_P: + if p.fetchArgsFollows(1) { + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_ABSOLUTE, HowMany: 1, Portalname: p.name()} + } + case ast.Token_LAST_P: + if p.fetchArgsFollows(1) { + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_ABSOLUTE, HowMany: -1, Portalname: p.name()} + } + case ast.Token_ABSOLUTE_P: + if p.signedIconstAhead(1) { + p.next() + v := p.parseSignedIconst() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_ABSOLUTE, HowMany: int64(v), Portalname: p.name()} + } + case ast.Token_RELATIVE_P: + if p.signedIconstAhead(1) { + p.next() + v := p.parseSignedIconst() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_RELATIVE, HowMany: int64(v), Portalname: p.name()} + } + case ast.Token_ICONST, ast.Token('+'), ast.Token('-'): + v := p.parseSignedIconst() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: int64(v), Portalname: p.name()} + case ast.Token_ALL: + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: fetchAll, Portalname: p.name()} + case ast.Token_FORWARD: + switch { + case p.kindN(1) == ast.Token_ALL: + p.next() + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: fetchAll, Portalname: p.name()} + case p.signedIconstAhead(1): + p.next() + v := p.parseSignedIconst() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: int64(v), Portalname: p.name()} + case p.fetchArgsFollows(1): + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: 1, Portalname: p.name()} + } + case ast.Token_BACKWARD: + switch { + case p.kindN(1) == ast.Token_ALL: + p.next() + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_BACKWARD, HowMany: fetchAll, Portalname: p.name()} + case p.signedIconstAhead(1): + p.next() + v := p.parseSignedIconst() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_BACKWARD, HowMany: int64(v), Portalname: p.name()} + case p.fetchArgsFollows(1): + p.next() + p.parseOptFromIn() + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_BACKWARD, HowMany: 1, Portalname: p.name()} + } + } + // cursor_name + return &ast.FetchStmt{Direction: ast.FetchDirection_FETCH_FORWARD, HowMany: 1, Portalname: p.name()} +} + +// signedIconstAhead reports whether a SignedIconst starts n tokens ahead. +func (p *parser) signedIconstAhead(n int) bool { + switch p.kindN(n) { + case ast.Token_ICONST, ast.Token('+'), ast.Token('-'): + return true + } + return false +} diff --git a/internal/parse/gram_support.go b/internal/parse/gram_support.go index 46b1180..1678a41 100644 --- a/internal/parse/gram_support.go +++ b/internal/parse/gram_support.go @@ -130,6 +130,22 @@ func (p *parser) parserYyerror(msg string) { p.fail(p.filter.SyntaxErrorMsg(p.peek(), msg)) } +// makefuncs.c: makeAlias +func makeAlias(aliasname string, colnames []*ast.Node) *ast.Alias { + return &ast.Alias{Aliasname: aliasname, Colnames: colnames} +} + +// makefuncs.c: makeDefElemExtended +func makeDefElemExtended(nameSpace, name string, arg *ast.Node, defaction ast.DefElemAction, location int32) *ast.Node { + return nDefElem(&ast.DefElem{ + Defnamespace: nameSpace, + Defname: name, + Arg: arg, + Defaction: defaction, + Location: location, + }) +} + // gram.y: makeTypeCast func makeTypeCast(arg *ast.Node, typename *ast.TypeName, location int32) *ast.Node { return nTypeCast(&ast.TypeCast{Arg: arg, TypeName: typename, Location: location}) diff --git a/internal/parse/nodes.go b/internal/parse/nodes.go index 1a1bac5..fb8cdb6 100644 --- a/internal/parse/nodes.go +++ b/internal/parse/nodes.go @@ -235,3 +235,79 @@ func isAIndices(n *ast.Node) bool { _, ok := n.Node.(*ast.Node_AIndices) return ok } + +func nFloat(s string) *ast.Node { + return &ast.Node{Node: &ast.Node_Float{Float: &ast.Float{Fval: s}}} +} + +func nBoolean(b bool) *ast.Node { + return &ast.Node{Node: &ast.Node_Boolean{Boolean: &ast.Boolean{Boolval: b}}} +} + +func nTypeName(t *ast.TypeName) *ast.Node { + return &ast.Node{Node: &ast.Node_TypeName{TypeName: t}} +} + +func nDefElem(d *ast.DefElem) *ast.Node { + return &ast.Node{Node: &ast.Node_DefElem{DefElem: d}} +} + +func nIndexElem(e *ast.IndexElem) *ast.Node { + return &ast.Node{Node: &ast.Node_IndexElem{IndexElem: e}} +} + +func nMultiAssignRef(m *ast.MultiAssignRef) *ast.Node { + return &ast.Node{Node: &ast.Node_MultiAssignRef{MultiAssignRef: m}} +} + +func nCurrentOfExpr(c *ast.CurrentOfExpr) *ast.Node { + return &ast.Node{Node: &ast.Node_CurrentOfExpr{CurrentOfExpr: c}} +} + +func nMergeWhenClause(m *ast.MergeWhenClause) *ast.Node { + return &ast.Node{Node: &ast.Node_MergeWhenClause{MergeWhenClause: m}} +} + +func nInsertStmt(s *ast.InsertStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_InsertStmt{InsertStmt: s}} +} + +func nUpdateStmt(s *ast.UpdateStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_UpdateStmt{UpdateStmt: s}} +} + +func nDeleteStmt(s *ast.DeleteStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_DeleteStmt{DeleteStmt: s}} +} + +func nMergeStmt(s *ast.MergeStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_MergeStmt{MergeStmt: s}} +} + +func nCopyStmt(s *ast.CopyStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_CopyStmt{CopyStmt: s}} +} + +func nPrepareStmt(s *ast.PrepareStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_PrepareStmt{PrepareStmt: s}} +} + +func nExecuteStmt(s *ast.ExecuteStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_ExecuteStmt{ExecuteStmt: s}} +} + +func nDeallocateStmt(s *ast.DeallocateStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_DeallocateStmt{DeallocateStmt: s}} +} + +func nDeclareCursorStmt(s *ast.DeclareCursorStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_DeclareCursorStmt{DeclareCursorStmt: s}} +} + +func nFetchStmt(s *ast.FetchStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_FetchStmt{FetchStmt: s}} +} + +func nClosePortalStmt(s *ast.ClosePortalStmt) *ast.Node { + return &ast.Node{Node: &ast.Node_ClosePortalStmt{ClosePortalStmt: s}} +} diff --git a/internal/parse/parser.go b/internal/parse/parser.go index 29a6bfb..d4f21f3 100644 --- a/internal/parse/parser.go +++ b/internal/parse/parser.go @@ -172,22 +172,48 @@ func (p *parser) parseToplevel() *ast.ParseResult { } // parseToplevelStmt is toplevel_stmt/stmt: dispatch on the leading token. -// Milestone 4 implements the SELECT family; everything else reports the -// syntax error bison would only reach much later, and stays on the todo -// list until its milestone lands. +// Milestones 4-5 implement the SELECT family and DML; everything else +// reports the syntax error bison would only reach much later, and stays on +// the todo list until its milestone lands. func (p *parser) parseToplevelStmt() *ast.Node { tok := p.peek() switch tok.Kind { case ast.Token(';'), 0: // Empty statement: stmt: /*EMPTY*/ return nil - case ast.Token_SELECT, ast.Token_TABLE, ast.Token_VALUES, - ast.Token_WITH, ast.Token_WITH_LA: + case ast.Token_SELECT, ast.Token_TABLE, ast.Token_VALUES: // gram.y: SelectStmt: select_no_parens %prec UMINUS return p.parseSelectStmt() case ast.Token('('): // gram.y: SelectStmt: select_with_parens %prec UMINUS return p.parseSelectStmt() + case ast.Token_WITH, ast.Token_WITH_LA: + // opt_with_clause statements: SELECT/INSERT/UPDATE/DELETE/MERGE + return p.parseWithPrefixedStmt() + case ast.Token_INSERT: + return p.parseInsertStmt(nil) + case ast.Token_UPDATE: + return p.parseUpdateStmt(nil) + case ast.Token_DELETE_P: + return p.parseDeleteStmt(nil) + case ast.Token_MERGE: + return p.parseMergeStmt(nil) + case ast.Token_COPY: + return p.parseCopyStmt() + case ast.Token_PREPARE: + return p.parsePrepareStmt() + case ast.Token_EXECUTE: + return p.parseExecuteStmt() + case ast.Token_DEALLOCATE: + return p.parseDeallocateStmt() + case ast.Token_DECLARE: + return p.parseDeclareCursorStmt() + case ast.Token_FETCH: + return p.parseFetchStmt(false) + case ast.Token_MOVE: + return p.parseFetchStmt(true) + case ast.Token_CLOSE: + return p.parseClosePortalStmt() } p.syntaxError(tok) return nil diff --git a/internal/parse/select.go b/internal/parse/select.go index f137d64..3243623 100644 --- a/internal/parse/select.go +++ b/internal/parse/select.go @@ -40,7 +40,13 @@ func (p *parser) parseSelectNoParens() *ast.Node { if p.kind() == ast.Token_WITH || p.kind() == ast.Token_WITH_LA { with = p.parseWithClause() } + return p.parseSelectNoParensRest(with) +} +// parseSelectNoParensRest continues select_no_parens after opt_with_clause; +// split out so the WITH-prefixed statement dispatch can hand over a +// with_clause it already consumed. +func (p *parser) parseSelectNoParensRest(with *ast.WithClause) *ast.Node { sel := p.parseSelectClause(0) var sort []*ast.Node @@ -294,13 +300,22 @@ func (p *parser) parseCommonTableExpr() *ast.Node { return nCommonTableExpr(cte) } -// parsePreparableStmt is gram.y's PreparableStmt, restricted to the -// statement types implemented so far. +// parsePreparableStmt is gram.y's PreparableStmt: +// SelectStmt | InsertStmt | UpdateStmt | DeleteStmt | MergeStmt. func (p *parser) parsePreparableStmt() *ast.Node { switch p.kind() { - case ast.Token_SELECT, ast.Token_TABLE, ast.Token_VALUES, - ast.Token_WITH, ast.Token_WITH_LA, ast.Token('('): + case ast.Token_SELECT, ast.Token_TABLE, ast.Token_VALUES, ast.Token('('): return p.parseSelectStmt() + case ast.Token_WITH, ast.Token_WITH_LA: + return p.parseWithPrefixedStmt() + case ast.Token_INSERT: + return p.parseInsertStmt(nil) + case ast.Token_UPDATE: + return p.parseUpdateStmt(nil) + case ast.Token_DELETE_P: + return p.parseDeleteStmt(nil) + case ast.Token_MERGE: + return p.parseMergeStmt(nil) } p.syntaxErrorAt() return nil diff --git a/parser/testdata/deparse/postgres_regress/aggregates.metadata.json b/parser/testdata/deparse/postgres_regress/aggregates.metadata.json index e38fdfe..27b01ab 100644 --- a/parser/testdata/deparse/postgres_regress/aggregates.metadata.json +++ b/parser/testdata/deparse/postgres_regress/aggregates.metadata.json @@ -2,7 +2,6 @@ "todo": [ "001", "002", - "003", "004", "005", "006", diff --git a/parser/testdata/deparse/postgres_regress/arrays.metadata.json b/parser/testdata/deparse/postgres_regress/arrays.metadata.json index a8dc578..1c1bac5 100644 --- a/parser/testdata/deparse/postgres_regress/arrays.metadata.json +++ b/parser/testdata/deparse/postgres_regress/arrays.metadata.json @@ -2,7 +2,6 @@ "todo": [ "001", "002", - "003", "004", "005", "006", diff --git a/parser/testdata/deparse/postgres_regress/btree_index.metadata.json b/parser/testdata/deparse/postgres_regress/btree_index.metadata.json index 11ed4d1..54c571b 100644 --- a/parser/testdata/deparse/postgres_regress/btree_index.metadata.json +++ b/parser/testdata/deparse/postgres_regress/btree_index.metadata.json @@ -4,10 +4,6 @@ "002", "003", "004", - "005", - "006", - "007", - "008", "009", "010", "011", diff --git a/parser/testdata/deparse/postgres_regress/constraints.metadata.json b/parser/testdata/deparse/postgres_regress/constraints.metadata.json index 60d70f4..60b2f8d 100644 --- a/parser/testdata/deparse/postgres_regress/constraints.metadata.json +++ b/parser/testdata/deparse/postgres_regress/constraints.metadata.json @@ -102,9 +102,7 @@ "100", "101", "102", - "103", "104", - "105", "106", "107", "108", diff --git a/parser/testdata/deparse/postgres_regress/copy.metadata.json b/parser/testdata/deparse/postgres_regress/copy.metadata.json index 8e8d1f7..e4063a0 100644 --- a/parser/testdata/deparse/postgres_regress/copy.metadata.json +++ b/parser/testdata/deparse/postgres_regress/copy.metadata.json @@ -5,13 +5,9 @@ "003", "004", "005", - "006", "007", - "008", "009", "010", - "011", - "012", "013", "014", "015", @@ -27,18 +23,14 @@ "025", "026", "027", - "028", "029", - "030", "031", "032", - "033", "034", "035", "036", "037", "038", - "039", "040", "041", "042", @@ -52,7 +44,6 @@ "050", "051", "052", - "053", "054", "055", "056", @@ -84,7 +75,6 @@ "082", "083", "084", - "085", "086", "087" ] diff --git a/parser/testdata/deparse/postgres_regress/copyselect.metadata.json b/parser/testdata/deparse/postgres_regress/copyselect.metadata.json index 57687ba..19189c7 100644 --- a/parser/testdata/deparse/postgres_regress/copyselect.metadata.json +++ b/parser/testdata/deparse/postgres_regress/copyselect.metadata.json @@ -18,7 +18,6 @@ "016", "017", "018", - "019", "021" ] } diff --git a/parser/testdata/deparse/postgres_regress/create_index.metadata.json b/parser/testdata/deparse/postgres_regress/create_index.metadata.json index 528c575..185d38e 100644 --- a/parser/testdata/deparse/postgres_regress/create_index.metadata.json +++ b/parser/testdata/deparse/postgres_regress/create_index.metadata.json @@ -24,7 +24,6 @@ "022", "023", "024", - "025", "026", "027", "028", @@ -115,7 +114,6 @@ "113", "114", "115", - "116", "117", "118", "119", diff --git a/parser/testdata/deparse/postgres_regress/create_view.metadata.json b/parser/testdata/deparse/postgres_regress/create_view.metadata.json index 5d2a46c..0aae9dc 100644 --- a/parser/testdata/deparse/postgres_regress/create_view.metadata.json +++ b/parser/testdata/deparse/postgres_regress/create_view.metadata.json @@ -2,7 +2,6 @@ "todo": [ "001", "002", - "003", "004", "005", "006", diff --git a/parser/testdata/deparse/postgres_regress/errors.metadata.json b/parser/testdata/deparse/postgres_regress/errors.metadata.json index 13b81c8..2fd3b8b 100644 --- a/parser/testdata/deparse/postgres_regress/errors.metadata.json +++ b/parser/testdata/deparse/postgres_regress/errors.metadata.json @@ -9,7 +9,6 @@ "008", "009", "010", - "011", "012", "013", "014", @@ -74,8 +73,6 @@ "073", "074", "075", - "076", - "077", "078", "079", "080", diff --git a/parser/testdata/deparse/postgres_regress/hash_index.metadata.json b/parser/testdata/deparse/postgres_regress/hash_index.metadata.json index ba349a5..9006187 100644 --- a/parser/testdata/deparse/postgres_regress/hash_index.metadata.json +++ b/parser/testdata/deparse/postgres_regress/hash_index.metadata.json @@ -4,10 +4,6 @@ "002", "003", "004", - "005", - "006", - "007", - "008", "009", "010", "011", diff --git a/parser/testdata/deparse/postgres_regress/jsonb.metadata.json b/parser/testdata/deparse/postgres_regress/jsonb.metadata.json index 4c380dc..72c7637 100644 --- a/parser/testdata/deparse/postgres_regress/jsonb.metadata.json +++ b/parser/testdata/deparse/postgres_regress/jsonb.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "001", - "002", "003", "004", "005", diff --git a/parser/testdata/deparse/postgres_regress/largeobject.metadata.json b/parser/testdata/deparse/postgres_regress/largeobject.metadata.json index 9cb7b18..268ea7b 100644 --- a/parser/testdata/deparse/postgres_regress/largeobject.metadata.json +++ b/parser/testdata/deparse/postgres_regress/largeobject.metadata.json @@ -61,7 +61,6 @@ "060", "061", "062", - "063", "064", "065", "066", diff --git a/parser/testdata/deparse/postgres_regress/merge.metadata.json b/parser/testdata/deparse/postgres_regress/merge.metadata.json index 168c3f9..23cae0c 100644 --- a/parser/testdata/deparse/postgres_regress/merge.metadata.json +++ b/parser/testdata/deparse/postgres_regress/merge.metadata.json @@ -20,15 +20,6 @@ "018", "019", "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", "030", "031", "032", diff --git a/parser/testdata/deparse/postgres_regress/misc.metadata.json b/parser/testdata/deparse/postgres_regress/misc.metadata.json index 6a71114..a5cd28a 100644 --- a/parser/testdata/deparse/postgres_regress/misc.metadata.json +++ b/parser/testdata/deparse/postgres_regress/misc.metadata.json @@ -8,14 +8,10 @@ "006", "007", "008", - "009", "010", - "011", "012", "013", - "014", "015", - "016", "017", "018", "019", diff --git a/parser/testdata/deparse/postgres_regress/test_setup.metadata.json b/parser/testdata/deparse/postgres_regress/test_setup.metadata.json index abfc1a2..f11579c 100644 --- a/parser/testdata/deparse/postgres_regress/test_setup.metadata.json +++ b/parser/testdata/deparse/postgres_regress/test_setup.metadata.json @@ -28,29 +28,22 @@ "026", "027", "028", - "029", "030", "031", "032", "033", - "034", "035", "036", "037", "038", - "039", "040", "041", - "042", "043", "044", - "045", "046", "047", - "048", "049", "050", - "051", "052", "053", "054", diff --git a/parser/testdata/deparse/postgres_regress/transactions.metadata.json b/parser/testdata/deparse/postgres_regress/transactions.metadata.json index 12a1280..df001e2 100644 --- a/parser/testdata/deparse/postgres_regress/transactions.metadata.json +++ b/parser/testdata/deparse/postgres_regress/transactions.metadata.json @@ -378,18 +378,14 @@ "376", "377", "380", - "381", "382", - "383", "385", "386", "387", "388", - "389", "390", "391", "392", - "393", "394", "395", "397", @@ -398,11 +394,8 @@ "401", "402", "403", - "404", "405", - "406", "407", - "408", "409", "410", "411", @@ -428,43 +421,29 @@ "437", "438", "439", - "440", "441", - "442", "443", - "444", "445", - "446", "447", - "448", "449", - "450", "451", - "452", "453", - "454", "455", "456", - "457", "458", "459", "460", "461", - "462", "463", "464", "465", "466", "467", - "468", "469", - "470", "471", "472", "473", - "474", "475", - "476", "477", "478", "479", diff --git a/parser/testdata/deparse/postgres_regress/tsearch.metadata.json b/parser/testdata/deparse/postgres_regress/tsearch.metadata.json index 61a7831..47ed65e 100644 --- a/parser/testdata/deparse/postgres_regress/tsearch.metadata.json +++ b/parser/testdata/deparse/postgres_regress/tsearch.metadata.json @@ -7,7 +7,6 @@ "005", "006", "007", - "008", "009", "010", "011", diff --git a/parser/testdata/parse/deparse/insert_long.metadata.json b/parser/testdata/parse/deparse/insert_long.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse/insert_long.metadata.json +++ b/parser/testdata/parse/deparse/insert_long.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse/nested_cte.metadata.json b/parser/testdata/parse/deparse/nested_cte.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse/nested_cte.metadata.json +++ b/parser/testdata/parse/deparse/nested_cte.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse/union.metadata.json b/parser/testdata/parse/deparse/union.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse/union.metadata.json +++ b/parser/testdata/parse/deparse/union.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_01-basic.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_01-basic.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_01-basic.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_01-basic.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_02-with-columns.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_02-with-columns.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_02-with-columns.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_02-with-columns.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_03-many-columns.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_03-many-columns.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_03-many-columns.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_03-many-columns.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_04-with-schema.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_04-with-schema.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_04-with-schema.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_04-with-schema.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_05-multirow.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_05-multirow.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_05-multirow.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_05-multirow.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_06-returning-all.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_06-returning-all.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_06-returning-all.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_06-returning-all.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_07-returning-some.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_07-returning-some.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_07-returning-some.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_07-returning-some.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_08-default.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_08-default.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_08-default.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_08-default.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/09-inserts_09-cte.metadata.json b/parser/testdata/parse/deparse_depesz/09-inserts_09-cte.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/09-inserts_09-cte.metadata.json +++ b/parser/testdata/parse/deparse_depesz/09-inserts_09-cte.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_01-single-column-no-where.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_01-single-column-no-where.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_01-single-column-no-where.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_01-single-column-no-where.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_02-many-columns-and-where.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_02-many-columns-and-where.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_02-many-columns-and-where.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_02-many-columns-and-where.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_03-with.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_03-with.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_03-with.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_03-with.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_04-returning-all.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_04-returning-all.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_04-returning-all.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_04-returning-all.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_05-returning-some.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_05-returning-some.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_05-returning-some.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_05-returning-some.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_06-multi-assign-simple.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_06-multi-assign-simple.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_06-multi-assign-simple.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_06-multi-assign-simple.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_07-multi-assign-long.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_07-multi-assign-long.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_07-multi-assign-long.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_07-multi-assign-long.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_08-multi-assign-mix.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_08-multi-assign-mix.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_08-multi-assign-mix.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_08-multi-assign-mix.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_09-cte.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_09-cte.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_09-cte.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_09-cte.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/10-updates_10-complex-where.metadata.json b/parser/testdata/parse/deparse_depesz/10-updates_10-complex-where.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/10-updates_10-complex-where.metadata.json +++ b/parser/testdata/parse/deparse_depesz/10-updates_10-complex-where.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/11-deletes_01-simple.metadata.json b/parser/testdata/parse/deparse_depesz/11-deletes_01-simple.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/11-deletes_01-simple.metadata.json +++ b/parser/testdata/parse/deparse_depesz/11-deletes_01-simple.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/11-deletes_02-where.metadata.json b/parser/testdata/parse/deparse_depesz/11-deletes_02-where.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/11-deletes_02-where.metadata.json +++ b/parser/testdata/parse/deparse_depesz/11-deletes_02-where.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/11-deletes_03-using.metadata.json b/parser/testdata/parse/deparse_depesz/11-deletes_03-using.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/11-deletes_03-using.metadata.json +++ b/parser/testdata/parse/deparse_depesz/11-deletes_03-using.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/11-deletes_04-returning-all.metadata.json b/parser/testdata/parse/deparse_depesz/11-deletes_04-returning-all.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/11-deletes_04-returning-all.metadata.json +++ b/parser/testdata/parse/deparse_depesz/11-deletes_04-returning-all.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/11-deletes_05-returning-some.metadata.json b/parser/testdata/parse/deparse_depesz/11-deletes_05-returning-some.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/11-deletes_05-returning-some.metadata.json +++ b/parser/testdata/parse/deparse_depesz/11-deletes_05-returning-some.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/11-deletes_06-cte.metadata.json b/parser/testdata/parse/deparse_depesz/11-deletes_06-cte.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/11-deletes_06-cte.metadata.json +++ b/parser/testdata/parse/deparse_depesz/11-deletes_06-cte.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/11-deletes_07-complex-where.metadata.json b/parser/testdata/parse/deparse_depesz/11-deletes_07-complex-where.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/11-deletes_07-complex-where.metadata.json +++ b/parser/testdata/parse/deparse_depesz/11-deletes_07-complex-where.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/18-conflicts_01-basic-nothing.metadata.json b/parser/testdata/parse/deparse_depesz/18-conflicts_01-basic-nothing.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/18-conflicts_01-basic-nothing.metadata.json +++ b/parser/testdata/parse/deparse_depesz/18-conflicts_01-basic-nothing.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/18-conflicts_02-constraint-nothing.metadata.json b/parser/testdata/parse/deparse_depesz/18-conflicts_02-constraint-nothing.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/18-conflicts_02-constraint-nothing.metadata.json +++ b/parser/testdata/parse/deparse_depesz/18-conflicts_02-constraint-nothing.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/18-conflicts_03-columns-nothing.metadata.json b/parser/testdata/parse/deparse_depesz/18-conflicts_03-columns-nothing.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/18-conflicts_03-columns-nothing.metadata.json +++ b/parser/testdata/parse/deparse_depesz/18-conflicts_03-columns-nothing.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/18-conflicts_04-expr-complex.metadata.json b/parser/testdata/parse/deparse_depesz/18-conflicts_04-expr-complex.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/18-conflicts_04-expr-complex.metadata.json +++ b/parser/testdata/parse/deparse_depesz/18-conflicts_04-expr-complex.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/18-conflicts_05-simple-update.metadata.json b/parser/testdata/parse/deparse_depesz/18-conflicts_05-simple-update.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/18-conflicts_05-simple-update.metadata.json +++ b/parser/testdata/parse/deparse_depesz/18-conflicts_05-simple-update.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/18-conflicts_06-update-multicolumn.metadata.json b/parser/testdata/parse/deparse_depesz/18-conflicts_06-update-multicolumn.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/18-conflicts_06-update-multicolumn.metadata.json +++ b/parser/testdata/parse/deparse_depesz/18-conflicts_06-update-multicolumn.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/deparse_depesz/18-conflicts_07-update-complex.metadata.json b/parser/testdata/parse/deparse_depesz/18-conflicts_07-update-complex.metadata.json index f23fe5c..737fd31 100644 --- a/parser/testdata/parse/deparse_depesz/18-conflicts_07-update-complex.metadata.json +++ b/parser/testdata/parse/deparse_depesz/18-conflicts_07-update-complex.metadata.json @@ -1,5 +1,3 @@ { - "todo": [ - "001" - ] + "todo": [] } diff --git a/parser/testdata/parse/libpg_query.metadata.json b/parser/testdata/parse/libpg_query.metadata.json index 0fe25fb..beb223c 100644 --- a/parser/testdata/parse/libpg_query.metadata.json +++ b/parser/testdata/parse/libpg_query.metadata.json @@ -10,8 +10,6 @@ "019", "025", "026", - "032", - "033", "034", "035" ] diff --git a/parser/testdata/parse/postgres_regress/aggregates.metadata.json b/parser/testdata/parse/postgres_regress/aggregates.metadata.json index 6b9e2e1..04c0775 100644 --- a/parser/testdata/parse/postgres_regress/aggregates.metadata.json +++ b/parser/testdata/parse/postgres_regress/aggregates.metadata.json @@ -2,17 +2,13 @@ "todo": [ "001", "002", - "003", "004", "081", - "082", "095", "109", "111", "113", - "115", "119", - "121", "125", "127", "129", @@ -38,10 +34,6 @@ "161", "162", "163", - "164", - "165", - "166", - "167", "168", "170", "172", @@ -92,11 +84,8 @@ "259", "262", "275", - "277", - "279", "283", "284", - "285", "286", "287", "288", @@ -168,7 +157,6 @@ "428", "429", "430", - "431", "432", "433", "434", diff --git a/parser/testdata/parse/postgres_regress/alter_table.metadata.json b/parser/testdata/parse/postgres_regress/alter_table.metadata.json index 2349700..ab39fd4 100644 --- a/parser/testdata/parse/postgres_regress/alter_table.metadata.json +++ b/parser/testdata/parse/postgres_regress/alter_table.metadata.json @@ -31,7 +31,6 @@ "029", "030", "031", - "032", "034", "035", "036", @@ -56,7 +55,6 @@ "055", "056", "057", - "058", "060", "061", "062", @@ -135,8 +133,6 @@ "105", "1050", "1051", - "1052", - "1053", "1054", "1055", "1056", @@ -156,8 +152,6 @@ "1069", "107", "1070", - "1071", - "1072", "1076", "1077", "1078", @@ -237,7 +231,6 @@ "1145", "1146", "1147", - "1148", "1149", "115", "1150", @@ -304,10 +297,7 @@ "1216", "1217", "1218", - "1219", "122", - "1220", - "1221", "1222", "1223", "1224", @@ -351,13 +341,11 @@ "1263", "1264", "1265", - "1266", "1267", "1268", "1269", "127", "1270", - "1271", "1272", "1273", "1274", @@ -411,8 +399,6 @@ "1319", "132", "1320", - "1321", - "1322", "1323", "1324", "1325", @@ -453,15 +439,11 @@ "1359", "136", "1360", - "1361", "1362", - "1363", "1364", "1365", - "1366", "1367", "1368", - "1369", "137", "1370", "1371", @@ -474,25 +456,20 @@ "1378", "1379", "138", - "1380", "1381", - "1382", "1383", "1384", "1385", "1386", "1387", "1388", - "1389", "139", "1390", "1391", "1392", "1393", "1394", - "1395", "1396", - "1397", "1398", "1399", "1400", @@ -510,16 +487,13 @@ "1411", "1412", "1413", - "1414", "1416", "1417", "1418", "1419", "142", - "1420", "1421", "1422", - "1423", "1424", "1425", "1426", @@ -544,16 +518,12 @@ "1443", "1444", "1445", - "1446", "1447", - "1448", "1449", "145", "1450", "1451", - "1452", "1453", - "1454", "1455", "1456", "1457", @@ -598,7 +568,6 @@ "1495", "1496", "1497", - "1498", "1499", "150", "1500", @@ -645,7 +614,6 @@ "1539", "154", "1541", - "1542", "1543", "1544", "1545", @@ -656,7 +624,6 @@ "155", "1550", "1551", - "1552", "1553", "1554", "1555", @@ -667,9 +634,7 @@ "156", "1560", "1561", - "1562", "1563", - "1564", "1565", "1566", "1567", @@ -689,7 +654,6 @@ "158", "1580", "1581", - "1582", "1583", "1584", "1585", @@ -703,13 +667,11 @@ "1592", "1593", "1594", - "1595", "1596", "1597", "1599", "160", "1600", - "1601", "1602", "1603", "1604", @@ -746,12 +708,9 @@ "1636", "1637", "1638", - "1639", "164", "1640", - "1641", "1642", - "1643", "1644", "1645", "1646", @@ -778,50 +737,33 @@ "178", "179", "180", - "181", - "182", - "183", - "184", - "185", - "186", - "187", "188", "189", "190", - "191", "192", "193", - "194", "195", "196", - "197", "198", "199", "200", "201", "202", - "203", "204", "205", "207", "208", - "209", "210", "211", - "212", "213", "214", - "215", "216", "217", "218", "219", "220", - "221", - "222", "223", "224", - "225", "226", "228", "229", @@ -845,26 +787,20 @@ "247", "248", "249", - "250", "251", "252", "253", "254", "255", "256", - "257", - "258", "259", "260", "261", "262", "263", "264", - "265", "266", "267", - "268", - "269", "270", "271", "272", @@ -892,34 +828,23 @@ "294", "297", "298", - "299", - "300", "301", "302", - "303", "304", - "305", "306", "307", "308", "309", "310", "311", - "312", - "313", "314", "315", "316", - "317", "318", "319", "320", "321", "322", - "323", - "324", - "325", - "326", "327", "328", "329", @@ -928,7 +853,6 @@ "332", "333", "334", - "335", "337", "338", "339", @@ -937,7 +861,6 @@ "342", "343", "344", - "345", "346", "347", "348", @@ -948,72 +871,45 @@ "354", "355", "356", - "357", - "358", - "359", "360", "361", "362", "363", "364", - "365", - "366", - "367", "368", "369", "370", - "371", - "372", "373", - "374", "375", "376", "377", "378", "379", "380", - "381", - "382", - "383", - "384", - "385", "386", "387", "388", - "389", - "390", "391", "392", "393", - "394", - "395", - "396", - "397", "398", "399", "400", "401", "402", - "403", - "404", "405", - "406", "407", "408", - "409", "410", - "411", "412", "413", "414", "415", "416", - "417", "418", "419", "420", "421", - "422", "423", "424", "425", @@ -1021,31 +917,18 @@ "427", "428", "429", - "430", "431", "432", "433", "434", - "435", "436", "437", "438", "439", "440", "441", - "442", - "443", - "444", - "445", - "446", - "447", - "448", - "449", "450", "451", - "452", - "453", - "454", "455", "456", "457", @@ -1056,9 +939,7 @@ "462", "463", "464", - "465", "466", - "467", "468", "469", "470", @@ -1068,22 +949,17 @@ "474", "475", "476", - "477", "478", "479", "480", "481", "482", "483", - "484", "485", "486", - "487", - "488", "489", "490", "491", - "492", "493", "494", "495", @@ -1092,70 +968,34 @@ "498", "499", "500", - "501", - "502", "503", - "504", - "505", "506", "507", - "508", "509", - "510", "511", - "512", - "513", "514", - "515", "516", "517", "518", - "519", "520", - "521", "522", - "523", "524", "525", - "526", "528", "529", "530", "531", "532", - "533", "534", - "535", "536", - "537", "539", "540", "541", "542", "543", "544", - "545", "546", "547", - "563", - "564", - "565", - "566", - "567", - "568", - "569", - "570", - "571", - "572", - "573", - "574", - "575", - "576", - "577", - "578", - "579", - "580", - "581", "582", "583", "584", @@ -1197,7 +1037,6 @@ "621", "622", "623", - "624", "625", "627", "630", @@ -1206,17 +1045,12 @@ "633", "635", "636", - "637", "638", "639", - "640", - "641", "642", "643", - "644", "645", "646", - "647", "650", "653", "654", @@ -1228,14 +1062,7 @@ "660", "661", "662", - "663", "664", - "665", - "666", - "667", - "668", - "670", - "672", "674", "675", "676", @@ -1302,27 +1129,16 @@ "743", "744", "745", - "746", - "747", - "748", - "750", "752", "753", "754", - "755", "757", - "759", - "761", "764", "765", "766", - "767", - "768", "770", "771", "772", - "774", - "775", "777", "779", "780", @@ -1344,9 +1160,6 @@ "797", "798", "799", - "800", - "801", - "802", "804", "806", "807", @@ -1359,7 +1172,6 @@ "814", "815", "816", - "817", "818", "819", "820", @@ -1367,9 +1179,7 @@ "822", "823", "824", - "825", "826", - "827", "828", "829", "830", @@ -1384,8 +1194,6 @@ "839", "840", "841", - "842", - "843", "844", "847", "850", @@ -1416,7 +1224,6 @@ "882", "883", "884", - "885", "886", "887", "888", @@ -1425,9 +1232,6 @@ "891", "892", "893", - "894", - "895", - "896", "897", "898", "899", @@ -1438,7 +1242,6 @@ "904", "905", "906", - "907", "908", "909", "910", @@ -1454,12 +1257,9 @@ "922", "923", "924", - "925", "928", "929", "930", - "931", - "932", "939", "940", "941", @@ -1467,9 +1267,7 @@ "943", "944", "945", - "946", "947", - "948", "949", "950", "952", diff --git a/parser/testdata/parse/postgres_regress/arrays.metadata.json b/parser/testdata/parse/postgres_regress/arrays.metadata.json index 2988a90..3364224 100644 --- a/parser/testdata/parse/postgres_regress/arrays.metadata.json +++ b/parser/testdata/parse/postgres_regress/arrays.metadata.json @@ -2,112 +2,24 @@ "todo": [ "001", "002", - "003", "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "020", - "021", - "022", - "026", - "028", - "030", - "044", - "045", - "046", "048", - "049", - "050", - "055", - "057", - "059", - "061", - "062", - "063", "064", - "065", - "070", - "071", - "072", - "073", - "074", "075", - "076", - "078", - "080", - "082", - "084", - "086", - "088", - "090", - "092", - "094", - "096", - "098", - "100", - "102", - "103", - "105", "107", - "108", "109", - "110", - "111", - "112", - "113", - "114", - "115", - "116", - "117", - "118", "119", - "120", - "121", - "122", - "123", - "124", - "125", - "126", - "127", - "128", "155", "223", - "224", - "225", - "226", - "227", - "228", - "229", "230", "231", "234", - "235", - "236", - "237", "238", "239", - "240", - "241", - "242", - "243", - "244", "245", "300", - "301", - "302", - "304", - "306", - "308", - "310", "312", "313", - "314", "315", "318", "319", @@ -117,14 +29,9 @@ "325", "326", "444", - "445", - "447", "449", - "450", "451", "452", - "453", - "455", "457", "458", "460", diff --git a/parser/testdata/parse/postgres_regress/bit.metadata.json b/parser/testdata/parse/postgres_regress/bit.metadata.json index 25798e7..815e758 100644 --- a/parser/testdata/parse/postgres_regress/bit.metadata.json +++ b/parser/testdata/parse/postgres_regress/bit.metadata.json @@ -1,40 +1,17 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", "008", - "009", - "010", - "011", - "012", - "013", "030", "031", - "032", "036", "037", "038", - "039", "043", "085", - "086", - "087", - "088", - "089", - "090", "096", - "097", - "098", - "099", - "100", - "101", "105", "106", - "120", - "121" + "120" ] } diff --git a/parser/testdata/parse/postgres_regress/bitmapops.metadata.json b/parser/testdata/parse/postgres_regress/bitmapops.metadata.json index 4fd3b1b..c3d0ee8 100644 --- a/parser/testdata/parse/postgres_regress/bitmapops.metadata.json +++ b/parser/testdata/parse/postgres_regress/bitmapops.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "001", - "002", "003", "004", "005", diff --git a/parser/testdata/parse/postgres_regress/boolean.metadata.json b/parser/testdata/parse/postgres_regress/boolean.metadata.json index d405a45..134ef67 100644 --- a/parser/testdata/parse/postgres_regress/boolean.metadata.json +++ b/parser/testdata/parse/postgres_regress/boolean.metadata.json @@ -1,22 +1,9 @@ { "todo": [ "044", - "045", - "046", - "047", - "052", "054", - "055", - "056", - "057", - "058", - "059", "073", - "074", - "075", - "076", "078", - "079", "095", "096", "097", diff --git a/parser/testdata/parse/postgres_regress/box.metadata.json b/parser/testdata/parse/postgres_regress/box.metadata.json index ce03273..ace92a1 100644 --- a/parser/testdata/parse/postgres_regress/box.metadata.json +++ b/parser/testdata/parse/postgres_regress/box.metadata.json @@ -1,20 +1,8 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", "030", - "031", "032", - "033", "034", "036", "038", @@ -31,9 +19,6 @@ "059", "060", "061", - "062", - "063", - "064", "065", "066", "067", diff --git a/parser/testdata/parse/postgres_regress/brin.metadata.json b/parser/testdata/parse/postgres_regress/brin.metadata.json index 2a0301f..c7816ad 100644 --- a/parser/testdata/parse/postgres_regress/brin.metadata.json +++ b/parser/testdata/parse/postgres_regress/brin.metadata.json @@ -1,54 +1,38 @@ { "todo": [ "001", - "002", - "003", "004", "005", - "006", "007", "008", "009", - "010", "012", - "013", - "014", "022", "023", "024", "031", "032", - "033", - "034", - "035", "038", "039", - "040", "041", "042", "043", "044", "045", "046", - "047", "048", - "049", "050", "051", "052", - "053", "054", "055", "057", "058", "059", "060", - "061", "062", "063", - "064", "065", - "066", "067", "068" ] diff --git a/parser/testdata/parse/postgres_regress/brin_bloom.metadata.json b/parser/testdata/parse/postgres_regress/brin_bloom.metadata.json index d5d6f62..7440f0b 100644 --- a/parser/testdata/parse/postgres_regress/brin_bloom.metadata.json +++ b/parser/testdata/parse/postgres_regress/brin_bloom.metadata.json @@ -1,26 +1,19 @@ { "todo": [ "001", - "002", - "003", "004", "005", "006", "007", "008", - "009", "010", "011", "012", - "013", "015", - "016", - "017", "025", "026", "027", "034", - "035", "036", "037", "038", diff --git a/parser/testdata/parse/postgres_regress/brin_multi.metadata.json b/parser/testdata/parse/postgres_regress/brin_multi.metadata.json index 8c72158..8ceb2ad 100644 --- a/parser/testdata/parse/postgres_regress/brin_multi.metadata.json +++ b/parser/testdata/parse/postgres_regress/brin_multi.metadata.json @@ -1,76 +1,55 @@ { "todo": [ "001", - "002", - "003", "004", "005", "006", "007", "008", "009", - "010", "011", "012", "013", - "014", "016", - "017", - "018", - "019", "020", "021", - "022", - "023", "024", "032", - "033", "034", "035", "036", "037", "038", "045", - "046", "047", "048", "049", "050", "051", "052", - "053", "054", "055", "056", "077", - "078", "099", "100", "101", - "102", "103", "104", "111", - "112", "119", "120", "121", "122", - "123", - "124", "125", "126", "127", - "128", - "129", "130", "131", "132", "133", "134", "135", - "136", - "137", "138", "139", "140", @@ -78,8 +57,6 @@ "142", "143", "144", - "145", - "146", "147", "148", "149", @@ -88,8 +65,6 @@ "152", "153", "154", - "155", - "156", "157", "158", "159", @@ -97,8 +72,6 @@ "161", "162", "163", - "164", - "165", "166", "167", "168", diff --git a/parser/testdata/parse/postgres_regress/btree_index.metadata.json b/parser/testdata/parse/postgres_regress/btree_index.metadata.json index 40274e6..3eabe40 100644 --- a/parser/testdata/parse/postgres_regress/btree_index.metadata.json +++ b/parser/testdata/parse/postgres_regress/btree_index.metadata.json @@ -4,10 +4,6 @@ "002", "003", "004", - "005", - "006", - "007", - "008", "009", "010", "011", @@ -40,29 +36,21 @@ "059", "060", "061", - "062", "063", "065", "067", "069", - "071", "072", "073", "074", "075", "076", - "077", - "078", "079", "080", "081", - "082", "083", - "084", "085", - "086", "087", - "088", "089", "090", "091", diff --git a/parser/testdata/parse/postgres_regress/case.metadata.json b/parser/testdata/parse/postgres_regress/case.metadata.json index fc293e5..a1a6197 100644 --- a/parser/testdata/parse/postgres_regress/case.metadata.json +++ b/parser/testdata/parse/postgres_regress/case.metadata.json @@ -2,22 +2,9 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", "033", "034", "035", - "036", - "038", - "040", "042", "043", "045", diff --git a/parser/testdata/parse/postgres_regress/char.metadata.json b/parser/testdata/parse/postgres_regress/char.metadata.json index 1a2b1bc..80ec909 100644 --- a/parser/testdata/parse/postgres_regress/char.metadata.json +++ b/parser/testdata/parse/postgres_regress/char.metadata.json @@ -1,15 +1,6 @@ { "todo": [ "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "018", - "019" + "018" ] } diff --git a/parser/testdata/parse/postgres_regress/circle.metadata.json b/parser/testdata/parse/postgres_regress/circle.metadata.json index 2aa574e..d7dfa22 100644 --- a/parser/testdata/parse/postgres_regress/circle.metadata.json +++ b/parser/testdata/parse/postgres_regress/circle.metadata.json @@ -1,19 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015" + "002" ] } diff --git a/parser/testdata/parse/postgres_regress/cluster.metadata.json b/parser/testdata/parse/postgres_regress/cluster.metadata.json index e66d508..52b2ab1 100644 --- a/parser/testdata/parse/postgres_regress/cluster.metadata.json +++ b/parser/testdata/parse/postgres_regress/cluster.metadata.json @@ -6,48 +6,8 @@ "004", "005", "006", - "007", - "008", - "009", - "010", - "011", - "012", "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", "046", - "051", - "053", "057", "059", "061", @@ -58,48 +18,19 @@ "066", "067", "068", - "069", - "070", - "071", - "072", - "073", - "074", "075", "076", "077", - "079", - "080", - "081", - "082", - "083", - "084", - "085", - "086", - "087", "088", "089", "090", "091", - "093", - "094", - "095", "096", "098", - "099", - "100", - "101", - "102", - "103", "104", - "105", - "106", - "107", - "108", - "109", "111", "113", "115", - "116", "117", "119", "120", @@ -149,7 +80,6 @@ "167", "168", "169", - "170", "171", "172", "173", diff --git a/parser/testdata/parse/postgres_regress/collate.icu.utf8.metadata.json b/parser/testdata/parse/postgres_regress/collate.icu.utf8.metadata.json index 15d6b15..7083dc4 100644 --- a/parser/testdata/parse/postgres_regress/collate.icu.utf8.metadata.json +++ b/parser/testdata/parse/postgres_regress/collate.icu.utf8.metadata.json @@ -10,19 +10,12 @@ "009", "010", "011", - "012", - "013", - "014", "023", "024", "025", - "026", "028", - "029", "040", - "041", "062", - "063", "070", "071", "072", @@ -109,17 +102,12 @@ "226", "228", "229", - "230", "233", "234", "235", "236", "237", - "238", - "239", "243", - "244", - "245", "249", "250", "253", @@ -127,119 +115,67 @@ "257", "258", "259", - "260", - "261", - "262", "269", "277", "281", - "282", "283", "286", "287", "288", "289", - "290", - "291", - "292", "309", - "310", "311", "314", "315", "316", "317", - "318", - "319", - "320", "337", - "338", "339", "342", - "343", "344", "345", "350", "357", - "358", - "359", - "360", - "361", "362", - "363", "365", "366", "367", "368", - "369", "374", - "375", "376", - "377", - "378", - "379", - "382", - "384", "387", - "388", "389", - "390", - "391", - "392", - "395", - "397", "400", "401", - "402", - "403", "405", "406", - "407", - "408", "410", "411", "412", - "413", - "414", "416", "417", "418", - "419", - "420", "422", "423", "424", - "425", - "426", "428", "429", "430", - "431", - "432", "434", "435", - "436", - "437", "439", "440", - "441", - "442", "444", "445", "446", - "447", - "448", "450", "451", "452", - "453", - "454", "456", "457", "458", "459", "460", - "461", "462", "463", "464", diff --git a/parser/testdata/parse/postgres_regress/collate.linux.utf8.metadata.json b/parser/testdata/parse/postgres_regress/collate.linux.utf8.metadata.json index 81057e1..b3049c0 100644 --- a/parser/testdata/parse/postgres_regress/collate.linux.utf8.metadata.json +++ b/parser/testdata/parse/postgres_regress/collate.linux.utf8.metadata.json @@ -10,19 +10,12 @@ "009", "010", "011", - "012", - "013", - "014", "023", "024", "025", - "026", "028", - "029", "040", - "041", "062", - "063", "070", "078", "079", diff --git a/parser/testdata/parse/postgres_regress/collate.metadata.json b/parser/testdata/parse/postgres_regress/collate.metadata.json index b19dbe0..ad818c3 100644 --- a/parser/testdata/parse/postgres_regress/collate.metadata.json +++ b/parser/testdata/parse/postgres_regress/collate.metadata.json @@ -6,16 +6,11 @@ "004", "005", "006", - "007", - "008", "013", "014", "015", - "016", "018", - "019", "028", - "029", "033", "034", "035", @@ -33,14 +28,9 @@ "098", "099", "100", - "101", "102", - "103", - "104", "105", - "106", "107", - "108", "109", "110", "111", @@ -59,7 +49,6 @@ "125", "126", "127", - "128", "133", "134", "135", diff --git a/parser/testdata/parse/postgres_regress/collate.utf8.metadata.json b/parser/testdata/parse/postgres_regress/collate.utf8.metadata.json index 51f45d8..6381c8e 100644 --- a/parser/testdata/parse/postgres_regress/collate.utf8.metadata.json +++ b/parser/testdata/parse/postgres_regress/collate.utf8.metadata.json @@ -6,7 +6,6 @@ "005", "006", "007", - "008", "010" ] } diff --git a/parser/testdata/parse/postgres_regress/collate.windows.win1252.metadata.json b/parser/testdata/parse/postgres_regress/collate.windows.win1252.metadata.json index 55e8735..104d2d0 100644 --- a/parser/testdata/parse/postgres_regress/collate.windows.win1252.metadata.json +++ b/parser/testdata/parse/postgres_regress/collate.windows.win1252.metadata.json @@ -10,17 +10,11 @@ "009", "010", "011", - "012", - "013", - "014", "023", "024", "025", - "026", "028", - "029", "053", - "054", "057", "058", "072", diff --git a/parser/testdata/parse/postgres_regress/combocid.metadata.json b/parser/testdata/parse/postgres_regress/combocid.metadata.json index ac484dd..8a01a83 100644 --- a/parser/testdata/parse/postgres_regress/combocid.metadata.json +++ b/parser/testdata/parse/postgres_regress/combocid.metadata.json @@ -2,50 +2,18 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", "016", - "017", "019", "021", "023", - "024", - "025", - "026", - "027", "028", "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", "043", - "046", "048", "050", "052", - "053", "054", - "056", "057", - "058", "059", "061", "062" diff --git a/parser/testdata/parse/postgres_regress/compression.metadata.json b/parser/testdata/parse/postgres_regress/compression.metadata.json index ecf4cb4..1022e45 100644 --- a/parser/testdata/parse/postgres_regress/compression.metadata.json +++ b/parser/testdata/parse/postgres_regress/compression.metadata.json @@ -3,22 +3,14 @@ "001", "002", "003", - "004", "005", - "006", "013", - "014", - "015", "017", "018", "019", "020", - "021", - "023", "025", "026", - "027", - "029", "033", "034", "035", @@ -26,14 +18,11 @@ "037", "038", "039", - "040", "042", "045", "046", "047", "048", - "049", - "050", "053", "054", "055", @@ -43,18 +32,14 @@ "059", "060", "061", - "062", "064", "065", "066", "067", - "068", - "069", "073", "075", "076", "077", - "078", "084", "085", "086", diff --git a/parser/testdata/parse/postgres_regress/constraints.metadata.json b/parser/testdata/parse/postgres_regress/constraints.metadata.json index 731b9ae..6e9982a 100644 --- a/parser/testdata/parse/postgres_regress/constraints.metadata.json +++ b/parser/testdata/parse/postgres_regress/constraints.metadata.json @@ -1,186 +1,68 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", "008", "009", - "010", - "011", - "012", - "013", "015", "016", "017", "018", "019", - "020", - "021", - "022", - "023", - "024", - "025", "027", "028", - "029", - "030", - "031", - "032", - "033", - "034", "036", "037", - "038", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "049", - "050", - "051", - "052", - "055", - "057", "059", - "060", - "061", "063", "064", "065", - "066", - "067", - "068", - "069", "071", "072", "073", - "074", - "075", "076", "077", "078", - "079", - "080", - "081", - "082", "083", - "084", "085", "086", - "087", - "088", - "089", - "090", - "092", - "093", - "094", "096", - "097", - "098", - "099", - "100", "102", - "103", - "105", "107", - "108", - "109", - "110", - "111", - "112", - "113", "115", "116", - "117", - "118", - "119", - "120", - "121", - "122", "124", "125", - "126", - "127", - "128", - "129", - "130", - "131", - "132", - "133", - "134", - "135", "137", "138", - "139", - "140", - "141", - "142", - "143", - "144", - "145", - "146", "148", "149", - "150", - "151", - "152", - "153", - "154", - "155", "157", "158", - "159", - "160", - "161", - "162", - "163", "164", - "165", "166", - "167", "169", "170", - "171", - "172", "173", "175", "176", "177", - "178", - "179", - "180", - "181", - "182", - "183", "184", "186", - "187", "188", "189", "190", - "191", "192", "193", "194", - "195", "196", "197", "198", "199", "200", "202", - "203", "204", - "205", "206", "207", - "208", "209", "210", "211", @@ -216,46 +98,22 @@ "243", "244", "245", - "246", - "247", "248", "250", - "251", - "252", - "253", "255", "257", "258", - "259", - "260", - "261", - "262", - "263", - "264", - "265", - "266", "267", "268", "269", "270", - "271", - "272", - "273", - "274", "275", - "276", "277", "278", - "279", - "280", "281", "282", - "283", - "284", - "285", "286", "288", - "289", "290", "291", "292", diff --git a/parser/testdata/parse/postgres_regress/conversion.metadata.json b/parser/testdata/parse/postgres_regress/conversion.metadata.json index 44428ef..cd9267f 100644 --- a/parser/testdata/parse/postgres_regress/conversion.metadata.json +++ b/parser/testdata/parse/postgres_regress/conversion.metadata.json @@ -17,20 +17,12 @@ "016", "017", "018", - "019", "025", - "026", "034", - "035", "038", - "039", "043", - "044", "047", - "048", "053", - "054", - "058", - "059" + "058" ] } diff --git a/parser/testdata/parse/postgres_regress/copy.metadata.json b/parser/testdata/parse/postgres_regress/copy.metadata.json index d2a5017..5fc0bf7 100644 --- a/parser/testdata/parse/postgres_regress/copy.metadata.json +++ b/parser/testdata/parse/postgres_regress/copy.metadata.json @@ -1,82 +1,43 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", "007", - "008", "010", - "011", - "012", "014", - "015", - "016", "017", - "018", - "019", "020", "021", "022", "023", "024", - "025", - "026", - "027", - "028", "029", - "030", "031", "032", - "033", "034", "036", "037", "038", - "039", "041", "042", "043", - "044", "047", "048", "049", "050", - "051", "052", - "053", "054", "055", "056", "057", "058", "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", "070", - "071", - "072", - "073", - "074", "076", "077", - "078", - "079", - "080", "081", "082", "083", "084", - "085", "087" ] } diff --git a/parser/testdata/parse/postgres_regress/copydml.metadata.json b/parser/testdata/parse/postgres_regress/copydml.metadata.json index f53b7f4..656afe6 100644 --- a/parser/testdata/parse/postgres_regress/copydml.metadata.json +++ b/parser/testdata/parse/postgres_regress/copydml.metadata.json @@ -1,62 +1,35 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", "013", - "014", "015", "016", - "017", "018", "019", - "020", "021", "022", - "023", "024", "025", - "026", "027", "028", - "029", "030", "031", - "032", "033", "034", - "035", "036", "037", - "038", "039", "040", - "041", "042", "043", - "044", "045", "046", - "047", "048", "049", - "050", "051", "052", "053", "054", - "055", - "056", - "057", "058", "059" ] diff --git a/parser/testdata/parse/postgres_regress/copyselect.metadata.json b/parser/testdata/parse/postgres_regress/copyselect.metadata.json index 57687ba..0e9fa4a 100644 --- a/parser/testdata/parse/postgres_regress/copyselect.metadata.json +++ b/parser/testdata/parse/postgres_regress/copyselect.metadata.json @@ -1,24 +1,8 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", "007", - "008", - "009", - "010", - "011", - "012", "013", - "014", - "015", - "016", - "017", - "018", - "019", "021" ] } diff --git a/parser/testdata/parse/postgres_regress/create_am.metadata.json b/parser/testdata/parse/postgres_regress/create_am.metadata.json index 000db02..2b42ba9 100644 --- a/parser/testdata/parse/postgres_regress/create_am.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_am.metadata.json @@ -27,7 +27,6 @@ "028", "029", "031", - "032", "034", "037", "038", diff --git a/parser/testdata/parse/postgres_regress/create_function_sql.metadata.json b/parser/testdata/parse/postgres_regress/create_function_sql.metadata.json index e8a330d..e421d63 100644 --- a/parser/testdata/parse/postgres_regress/create_function_sql.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_function_sql.metadata.json @@ -58,7 +58,6 @@ "075", "089", "090", - "091", "092", "093", "095", @@ -85,7 +84,6 @@ "121", "122", "123", - "124", "125", "127", "128", diff --git a/parser/testdata/parse/postgres_regress/create_index.metadata.json b/parser/testdata/parse/postgres_regress/create_index.metadata.json index 9042fed..bfc7fa2 100644 --- a/parser/testdata/parse/postgres_regress/create_index.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_index.metadata.json @@ -24,17 +24,12 @@ "022", "023", "024", - "025", - "026", "027", "028", "029", "030", - "031", "032", "033", - "034", - "035", "036", "037", "038", @@ -73,7 +68,6 @@ "113", "114", "115", - "116", "117", "122", "123", @@ -88,7 +82,6 @@ "163", "164", "165", - "166", "167", "169", "170", @@ -103,53 +96,27 @@ "180", "181", "182", - "183", - "184", - "185", - "186", - "187", - "188", - "189", "190", - "191", "192", "193", - "194", "195", "198", "199", "200", - "201", - "202", - "203", - "204", - "205", "206", "207", "208", - "209", - "210", - "211", - "212", - "213", "214", "215", "216", - "217", - "218", - "219", - "220", "221", "222", "223", "224", "225", "226", - "227", - "228", "229", "230", - "231", "232", "233", "234", @@ -166,21 +133,17 @@ "245", "246", "247", - "248", "249", "250", "251", - "252", "253", "254", "255", "256", "257", - "258", "259", "260", "261", - "262", "263", "264", "265", @@ -197,7 +160,6 @@ "276", "277", "278", - "279", "280", "281", "282", @@ -222,7 +184,6 @@ "301", "302", "303", - "304", "305", "306", "307", @@ -282,13 +243,9 @@ "408", "409", "410", - "411", - "412", "413", - "414", "415", "416", - "417", "418", "420", "421", @@ -374,16 +331,13 @@ "522", "523", "524", - "525", "526", "527", "528", - "529", "530", "531", "532", "533", - "534", "535", "536", "537", @@ -393,7 +347,6 @@ "548", "554", "555", - "556", "557", "558", "559", @@ -406,7 +359,6 @@ "566", "567", "568", - "569", "570", "571", "572", @@ -417,16 +369,12 @@ "579", "580", "581", - "582", "583", - "584", "585", "586", "587", "588", "589", - "590", - "591", "592", "593", "595", diff --git a/parser/testdata/parse/postgres_regress/create_index_spgist.metadata.json b/parser/testdata/parse/postgres_regress/create_index_spgist.metadata.json index 0463040..fd2f15d 100644 --- a/parser/testdata/parse/postgres_regress/create_index_spgist.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_index_spgist.metadata.json @@ -1,15 +1,10 @@ { "todo": [ "001", - "002", - "003", "004", "005", "006", "007", - "008", - "009", - "010", "011", "012", "013", diff --git a/parser/testdata/parse/postgres_regress/create_misc.metadata.json b/parser/testdata/parse/postgres_regress/create_misc.metadata.json index 04cb06b..6d5c740 100644 --- a/parser/testdata/parse/postgres_regress/create_misc.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_misc.metadata.json @@ -6,56 +6,6 @@ "004", "005", "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", - "055", - "056", "057", "058", "059", @@ -71,7 +21,6 @@ "078", "080", "082", - "083", "084", "086" ] diff --git a/parser/testdata/parse/postgres_regress/create_table.metadata.json b/parser/testdata/parse/postgres_regress/create_table.metadata.json index d12570c..b4bb322 100644 --- a/parser/testdata/parse/postgres_regress/create_table.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_table.metadata.json @@ -8,7 +8,6 @@ "007", "008", "010", - "011", "012", "013", "014", @@ -20,12 +19,10 @@ "020", "021", "022", - "023", "024", "025", "027", "028", - "029", "032", "033", "034", @@ -87,7 +84,6 @@ "092", "093", "094", - "095", "096", "097", "098", @@ -180,7 +176,6 @@ "187", "188", "189", - "190", "191", "192", "193", @@ -196,7 +191,6 @@ "203", "204", "205", - "206", "207", "208", "209", @@ -229,7 +223,6 @@ "240", "241", "242", - "243", "244", "245", "246", @@ -256,8 +249,6 @@ "267", "268", "269", - "270", - "271", "272", "273", "274", @@ -284,13 +275,11 @@ "296", "297", "298", - "299", "300", "301", "302", "303", "304", - "305", "307", "308", "309", @@ -298,7 +287,6 @@ "311", "312", "313", - "314", "315", "316", "317", diff --git a/parser/testdata/parse/postgres_regress/create_table_like.metadata.json b/parser/testdata/parse/postgres_regress/create_table_like.metadata.json index 3598d51..e5aa037 100644 --- a/parser/testdata/parse/postgres_regress/create_table_like.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_table_like.metadata.json @@ -5,43 +5,27 @@ "003", "004", "005", - "006", "011", "012", - "013", "015", "016", "017", - "018", "019", "020", - "021", - "022", - "023", "025", "026", - "027", "029", - "030", "032", - "033", "035", "036", - "037", "039", - "040", "042", - "043", "045", "046", "047", "048", "049", "050", - "051", - "053", - "055", - "057", "059", "060", "061", @@ -53,16 +37,11 @@ "067", "068", "069", - "070", - "071", "072", "073", "074", "075", "076", - "077", - "078", - "079", "080", "081", "082", diff --git a/parser/testdata/parse/postgres_regress/create_type.metadata.json b/parser/testdata/parse/postgres_regress/create_type.metadata.json index ce432c1..9175d93 100644 --- a/parser/testdata/parse/postgres_regress/create_type.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_type.metadata.json @@ -20,7 +20,6 @@ "018", "019", "020", - "021", "023", "024", "025", @@ -47,11 +46,9 @@ "047", "048", "049", - "051", "062", "063", "065", - "066", "068", "069", "070", diff --git a/parser/testdata/parse/postgres_regress/create_view.metadata.json b/parser/testdata/parse/postgres_regress/create_view.metadata.json index fc77ce9..4ef138c 100644 --- a/parser/testdata/parse/postgres_regress/create_view.metadata.json +++ b/parser/testdata/parse/postgres_regress/create_view.metadata.json @@ -2,7 +2,6 @@ "todo": [ "001", "002", - "003", "004", "006", "007", @@ -15,7 +14,6 @@ "014", "015", "016", - "017", "018", "019", "021", @@ -165,19 +163,16 @@ "221", "223", "225", - "226", "227", "228", "229", "232", "233", - "234", "235", "237", "240", "241", "242", - "243", "244", "248", "249", @@ -206,7 +201,6 @@ "299", "300", "301", - "303", "305", "306", "307" diff --git a/parser/testdata/parse/postgres_regress/database.metadata.json b/parser/testdata/parse/postgres_regress/database.metadata.json index e71b2c2..5741e52 100644 --- a/parser/testdata/parse/postgres_regress/database.metadata.json +++ b/parser/testdata/parse/postgres_regress/database.metadata.json @@ -6,7 +6,6 @@ "004", "005", "006", - "007", "008", "009", "010", diff --git a/parser/testdata/parse/postgres_regress/date.metadata.json b/parser/testdata/parse/postgres_regress/date.metadata.json index 1b50005..22d9859 100644 --- a/parser/testdata/parse/postgres_regress/date.metadata.json +++ b/parser/testdata/parse/postgres_regress/date.metadata.json @@ -1,23 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", "022", "023", "068", diff --git a/parser/testdata/parse/postgres_regress/delete.metadata.json b/parser/testdata/parse/postgres_regress/delete.metadata.json index 3cf0226..b7e3a9e 100644 --- a/parser/testdata/parse/postgres_regress/delete.metadata.json +++ b/parser/testdata/parse/postgres_regress/delete.metadata.json @@ -1,12 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "008", "010" ] } diff --git a/parser/testdata/parse/postgres_regress/domain.metadata.json b/parser/testdata/parse/postgres_regress/domain.metadata.json index cefcd81..bdf8a2a 100644 --- a/parser/testdata/parse/postgres_regress/domain.metadata.json +++ b/parser/testdata/parse/postgres_regress/domain.metadata.json @@ -11,10 +11,6 @@ "009", "010", "013", - "014", - "015", - "016", - "017", "023", "024", "025", @@ -27,16 +23,6 @@ "040", "041", "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "053", - "054", - "056", "063", "064", "065", @@ -48,82 +34,49 @@ "071", "072", "073", - "074", "075", - "076", "077", - "078", "079", - "080", - "081", - "082", "084", "085", "086", - "087", "088", - "089", "090", - "091", "092", - "093", "094", - "095", - "096", "097", - "098", "100", - "101", "102", "103", - "104", "106", - "107", "109", - "110", "112", "113", "114", - "115", - "116", "117", "118", "119", - "120", - "121", - "122", "123", - "124", - "125", "126", "127", "128", "129", - "130", "131", - "132", "133", - "134", "135", "137", - "139", "140", - "141", "142", "143", "144", "145", - "146", "147", "148", "149", - "150", "151", "152", "153", "154", - "155", - "156", "158", "160", "162", @@ -138,63 +91,43 @@ "173", "174", "181", - "182", - "183", - "184", - "185", - "186", - "187", "188", "189", "190", "191", - "192", - "193", "194", "195", "196", "197", - "198", - "199", - "200", - "201", "202", "204", "206", "212", "213", "214", - "215", "216", "217", "218", - "219", "220", "221", "222", "223", - "224", "225", "226", "227", "228", "229", - "230", "231", "232", "233", "234", "235", - "236", "237", "238", "239", "240", "241", "242", - "243", - "244", - "245", "246", "247", "248", @@ -208,10 +141,6 @@ "262", "263", "266", - "267", - "268", - "269", - "270", "272", "275", "276", @@ -226,9 +155,6 @@ "291", "292", "295", - "296", - "297", - "298", "299", "300", "301", diff --git a/parser/testdata/parse/postgres_regress/enum.metadata.json b/parser/testdata/parse/postgres_regress/enum.metadata.json index dd0ff69..4e66b7b 100644 --- a/parser/testdata/parse/postgres_regress/enum.metadata.json +++ b/parser/testdata/parse/postgres_regress/enum.metadata.json @@ -44,8 +44,6 @@ "055", "056", "058", - "059", - "060", "073", "074", "075", @@ -62,10 +60,6 @@ "115", "116", "117", - "118", - "119", - "120", - "121", "122", "123", "124", diff --git a/parser/testdata/parse/postgres_regress/errors.metadata.json b/parser/testdata/parse/postgres_regress/errors.metadata.json index e5e1304..f71830c 100644 --- a/parser/testdata/parse/postgres_regress/errors.metadata.json +++ b/parser/testdata/parse/postgres_regress/errors.metadata.json @@ -1,7 +1,5 @@ { "todo": [ - "011", - "012", "013", "014", "015", @@ -54,8 +52,6 @@ "073", "074", "075", - "076", - "077", "078", "079", "080", diff --git a/parser/testdata/parse/postgres_regress/event_trigger.metadata.json b/parser/testdata/parse/postgres_regress/event_trigger.metadata.json index 76a5b30..4bca649 100644 --- a/parser/testdata/parse/postgres_regress/event_trigger.metadata.json +++ b/parser/testdata/parse/postgres_regress/event_trigger.metadata.json @@ -74,7 +74,6 @@ "074", "075", "076", - "077", "078", "079", "080", @@ -82,9 +81,7 @@ "082", "083", "084", - "085", "086", - "087", "088", "090", "092", @@ -126,7 +123,6 @@ "129", "130", "131", - "132", "133", "134", "135", diff --git a/parser/testdata/parse/postgres_regress/explain.metadata.json b/parser/testdata/parse/postgres_regress/explain.metadata.json index fd945f7..83150dd 100644 --- a/parser/testdata/parse/postgres_regress/explain.metadata.json +++ b/parser/testdata/parse/postgres_regress/explain.metadata.json @@ -9,7 +9,6 @@ "016", "017", "020", - "027", "029", "030", "031", diff --git a/parser/testdata/parse/postgres_regress/expressions.metadata.json b/parser/testdata/parse/postgres_regress/expressions.metadata.json index 0d7d4b7..ded3915 100644 --- a/parser/testdata/parse/postgres_regress/expressions.metadata.json +++ b/parser/testdata/parse/postgres_regress/expressions.metadata.json @@ -31,7 +31,6 @@ "061", "062", "063", - "064", "071" ] } diff --git a/parser/testdata/parse/postgres_regress/fast_default.metadata.json b/parser/testdata/parse/postgres_regress/fast_default.metadata.json index fd73f1f..306dbf3 100644 --- a/parser/testdata/parse/postgres_regress/fast_default.metadata.json +++ b/parser/testdata/parse/postgres_regress/fast_default.metadata.json @@ -3,7 +3,6 @@ "001", "002", "003", - "004", "005", "006", "007", @@ -14,58 +13,35 @@ "012", "013", "014", - "016", "017", - "018", "019", - "020", "021", - "022", "023", - "024", "025", - "026", "027", - "028", "029", - "030", "031", - "032", "033", - "034", "035", - "036", "037", - "038", "039", - "040", "041", - "042", "045", "046", "047", - "049", "050", - "051", "052", - "053", "054", - "055", "056", - "057", "058", - "059", "060", - "061", "062", - "063", "066", "067", "068", "069", "070", "071", - "072", "073", "075", "076", @@ -77,7 +53,6 @@ "085", "086", "087", - "088", "090", "092", "094", @@ -85,111 +60,79 @@ "097", "098", "099", - "101", "102", - "103", "104", - "105", "107", "109", "113", "115", - "116", "117", - "118", "121", "122", - "124", "125", - "126", "127", - "128", "129", - "130", "132", "135", "136", "138", "139", "140", - "141", "142", "143", "144", - "146", "148", "149", - "150", "151", "152", "153", - "155", "157", "158", - "159", "160", "161", "162", - "164", "166", "167", - "168", "169", "170", "171", - "173", "175", "176", - "177", "178", "179", "180", - "182", "184", "185", - "186", "187", "188", "189", - "191", "193", "194", - "195", "196", "197", "198", - "200", "202", "203", - "204", "205", "206", "207", - "209", "211", "212", "213", - "214", "215", "216", - "217", "218", - "219", "220", "221", "223", "225", - "226", "227", "228", - "229", "230", "232", "233", - "234", "235", "236", - "237", "238", "240", "242", @@ -216,7 +159,6 @@ "264", "265", "266", - "267", "268" ] } diff --git a/parser/testdata/parse/postgres_regress/float4.metadata.json b/parser/testdata/parse/postgres_regress/float4.metadata.json index 7c488b7..2e39566 100644 --- a/parser/testdata/parse/postgres_regress/float4.metadata.json +++ b/parser/testdata/parse/postgres_regress/float4.metadata.json @@ -1,32 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "059", "090", "091", "092", diff --git a/parser/testdata/parse/postgres_regress/float8.metadata.json b/parser/testdata/parse/postgres_regress/float8.metadata.json index 04c38b2..c2c1ff6 100644 --- a/parser/testdata/parse/postgres_regress/float8.metadata.json +++ b/parser/testdata/parse/postgres_regress/float8.metadata.json @@ -1,27 +1,9 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", "057", - "100", "132", "134", - "135", - "136", - "137", - "138", "139", "159", "160", diff --git a/parser/testdata/parse/postgres_regress/foreign_data.metadata.json b/parser/testdata/parse/postgres_regress/foreign_data.metadata.json index b57efe1..feded6b 100644 --- a/parser/testdata/parse/postgres_regress/foreign_data.metadata.json +++ b/parser/testdata/parse/postgres_regress/foreign_data.metadata.json @@ -431,7 +431,6 @@ "462", "463", "464", - "465", "466", "467", "468", diff --git a/parser/testdata/parse/postgres_regress/foreign_key.metadata.json b/parser/testdata/parse/postgres_regress/foreign_key.metadata.json index 9ee373a..2acf27c 100644 --- a/parser/testdata/parse/postgres_regress/foreign_key.metadata.json +++ b/parser/testdata/parse/postgres_regress/foreign_key.metadata.json @@ -2,18 +2,6 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "014", - "016", "018", "019", "020", @@ -21,86 +9,26 @@ "022", "023", "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "041", - "043", - "045", - "047", - "048", "049", "050", "053", "054", "055", "056", - "057", - "058", - "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", - "069", - "070", - "071", - "072", - "074", - "076", - "078", "080", "081", "082", "083", "084", - "085", - "086", - "087", - "088", - "089", - "090", - "091", - "092", - "093", - "094", - "097", - "098", - "100", "1000", - "1001", - "1002", - "1003", "1005", "1006", - "1007", "1008", "1009", - "101", "1010", "1011", "1012", "1013", - "1014", - "1015", - "1016", "1018", "1019", "1020", @@ -108,82 +36,43 @@ "1022", "1023", "1024", - "1025", "1026", - "1027", "1028", "1029", "103", "1030", "1031", - "1032", - "1033", - "1034", "1037", "1038", - "1039", "104", - "1040", - "1041", - "1042", "1043", - "1044", - "1045", - "1046", "1047", "1048", - "1049", "105", - "1050", - "1051", "1052", "1053", - "1054", - "1055", - "1056", - "1057", "1058", "1059", "106", - "1060", - "1061", - "1062", - "1063", "1064", "1065", - "1066", "1067", - "1068", "1069", - "107", - "1070", - "1071", "1072", - "1073", "1074", "1075", "1076", "1077", "1078", "1079", - "108", "1080", "1081", - "1082", - "1083", - "1084", - "1085", - "1086", "109", "1090", - "1091", "1092", - "1093", - "1094", "1099", "110", "1100", - "1101", "1103", "1104", "1105", @@ -193,28 +82,20 @@ "1109", "111", "1110", - "1111", - "1112", "1113", "1114", "1115", "1116", "1117", "1118", - "1119", "112", "1120", "1121", - "1122", - "1123", "1124", "1125", - "1126", - "1127", "1128", "1129", "113", - "1130", "1131", "1132", "1133", @@ -224,102 +105,30 @@ "1137", "1138", "1139", - "114", "1140", "1141", "1142", "1143", "1144", "1145", - "1146", - "1147", - "1148", - "1149", - "115", - "1152", "1153", "1154", - "116", - "117", - "118", - "119", - "120", - "121", - "122", - "123", - "125", - "126", - "127", - "128", "131", "132", "133", "134", - "135", - "136", - "137", - "138", - "139", "142", "143", "144", "145", - "146", - "147", - "148", - "149", - "150", - "151", - "152", - "153", - "154", - "155", - "157", - "158", - "161", - "164", "167", "168", "169", "170", - "171", - "172", - "173", - "174", - "175", - "176", - "177", - "178", - "179", - "180", - "181", - "183", - "184", - "187", - "190", "193", "194", "195", "196", - "197", - "198", - "199", - "200", - "201", - "202", - "203", - "204", - "205", - "206", - "207", - "208", - "209", - "211", - "212", - "213", - "214", - "217", - "220", "223", "224", "225", @@ -327,9 +136,6 @@ "227", "228", "229", - "231", - "232", - "233", "235", "236", "237", @@ -343,24 +149,14 @@ "245", "246", "247", - "248", "249", "250", "251", - "252", - "253", - "254", - "255", "256", "257", "258", "259", - "260", "261", - "262", - "263", - "264", - "265", "266", "267", "268", @@ -384,41 +180,13 @@ "286", "287", "288", - "289", - "290", - "291", - "292", - "293", - "294", - "295", - "296", - "297", "298", - "299", "300", - "301", - "302", - "303", - "304", - "305", - "306", - "307", - "308", - "309", "310", "311", "312", "313", "314", - "315", - "316", - "317", - "318", - "319", - "320", - "321", - "322", - "323", "324", "325", "326", @@ -439,37 +207,28 @@ "341", "342", "343", - "344", "345", "346", - "347", - "348", "349", "350", "351", "352", "353", - "354", - "355", "356", "357", "358", - "359", "360", "361", "362", "363", "364", "365", - "366", "367", - "368", "369", "370", "371", "372", "373", - "374", "375", "376", "377", @@ -489,99 +248,50 @@ "391", "392", "393", - "394", "395", - "396", - "397", "398", "399", - "400", "401", - "402", "403", "404", "405", - "406", "407", - "408", "409", "410", - "411", "412", - "413", "414", "415", - "416", "417", "418", - "419", "420", "421", - "422", "423", "424", "425", "426", "427", "428", - "429", - "430", - "431", "432", - "433", - "434", - "435", - "437", - "439", "441", - "442", - "444", "446", "447", - "448", "449", - "450", - "452", "454", "455", "456", - "457", - "458", - "460", - "462", "463", - "464", - "466", "467", "468", - "469", - "470", - "471", - "472", - "473", - "474", - "475", "476", "477", "478", - "479", - "480", - "481", - "482", - "483", - "484", "485", "486", "487", "488", "489", - "490", "491", "492", - "493", - "494", - "495", - "496", "497", "498", "499", @@ -589,33 +299,23 @@ "502", "503", "504", - "505", "506", - "507", "508", - "509", "510", "511", "512", - "513", "514", - "515", "516", "517", "518", - "519", "520", "521", "522", - "523", "524", "525", "526", "527", "528", - "529", - "530", - "533", "536", "537", "538", @@ -635,34 +335,12 @@ "552", "553", "554", - "555", - "556", - "557", - "558", - "559", - "560", - "561", - "562", - "563", - "564", - "565", - "566", - "567", - "568", - "569", - "570", - "571", - "572", - "573", "574", "575", "576", "577", "578", - "579", - "580", "581", - "582", "583", "584", "585", @@ -671,49 +349,24 @@ "588", "589", "590", - "591", - "592", - "593", - "594", - "595", - "596", - "597", "598", "599", - "600", "601", "602", "603", - "604", "605", - "607", - "609", - "611", "613", "614", - "615", - "616", - "617", - "618", - "619", "621", "622", "623", - "624", "626", "627", "628", "629", - "630", - "631", - "632", - "633", - "634", "636", "637", "638", - "639", - "642", "644", "645", "646", @@ -744,9 +397,7 @@ "671", "672", "673", - "674", "675", - "676", "677", "678", "679", @@ -762,10 +413,8 @@ "689", "690", "691", - "692", "693", "694", - "695", "696", "697", "698", @@ -781,16 +430,8 @@ "708", "709", "710", - "711", - "712", - "713", - "714", "716", - "717", - "718", "719", - "720", - "721", "722", "723", "724", @@ -810,14 +451,8 @@ "739", "740", "741", - "742", - "743", - "744", - "745", "746", "747", - "748", - "749", "750", "751", "752", @@ -828,13 +463,9 @@ "757", "758", "759", - "760", - "761", "762", "763", "764", - "765", - "766", "767", "768", "769", @@ -860,39 +491,6 @@ "789", "790", "791", - "792", - "793", - "794", - "795", - "796", - "797", - "798", - "799", - "800", - "801", - "802", - "803", - "804", - "805", - "806", - "807", - "808", - "809", - "810", - "811", - "812", - "813", - "814", - "815", - "816", - "817", - "818", - "819", - "820", - "821", - "822", - "823", - "824", "825", "826", "827", @@ -906,9 +504,7 @@ "835", "836", "837", - "838", "839", - "840", "841", "842", "843", @@ -919,7 +515,6 @@ "848", "849", "850", - "851", "852", "853", "854", @@ -946,7 +541,6 @@ "875", "876", "878", - "879", "880", "881", "882", @@ -955,20 +549,14 @@ "885", "886", "887", - "888", "889", "890", - "891", "892", "893", "894", - "895", - "896", "897", "898", "899", - "900", - "901", "902", "903", "904", @@ -976,11 +564,7 @@ "906", "907", "908", - "909", - "910", "911", - "912", - "913", "914", "915", "916", @@ -990,13 +574,9 @@ "920", "921", "922", - "923", - "924", "925", "926", "927", - "928", - "929", "930", "931", "932", @@ -1005,11 +585,7 @@ "935", "936", "937", - "938", - "939", "940", - "941", - "942", "943", "944", "945", @@ -1020,11 +596,7 @@ "950", "951", "952", - "953", - "954", "955", - "956", - "957", "958", "959", "960", @@ -1040,25 +612,16 @@ "970", "971", "972", - "973", - "974", - "975", - "977", "979", "980", - "981", "982", "983", "984", "985", "986", "987", - "988", - "989", - "990", "992", "993", - "994", "995", "996", "997", diff --git a/parser/testdata/parse/postgres_regress/functional_deps.metadata.json b/parser/testdata/parse/postgres_regress/functional_deps.metadata.json index 4e897cd..641220a 100644 --- a/parser/testdata/parse/postgres_regress/functional_deps.metadata.json +++ b/parser/testdata/parse/postgres_regress/functional_deps.metadata.json @@ -21,9 +21,6 @@ "034", "035", "036", - "037", - "038", - "039", - "040" + "039" ] } diff --git a/parser/testdata/parse/postgres_regress/generated.metadata.json b/parser/testdata/parse/postgres_regress/generated.metadata.json index 5b4c7ae..973316e 100644 --- a/parser/testdata/parse/postgres_regress/generated.metadata.json +++ b/parser/testdata/parse/postgres_regress/generated.metadata.json @@ -18,41 +18,14 @@ "019", "020", "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "030", - "031", - "032", - "036", - "038", "039", - "040", "042", - "044", - "046", "048", - "049", - "050", "052", "053", - "055", - "056", - "057", - "058", - "059", - "060", "061", - "062", - "063", - "065", "066", "068", - "070", "073", "074", "075", @@ -78,21 +51,9 @@ "095", "096", "097", - "098", - "100", "102", "103", - "104", - "106", "108", - "109", - "111", - "113", - "114", - "115", - "116", - "117", - "118", - "119" + "113" ] } diff --git a/parser/testdata/parse/postgres_regress/gin.metadata.json b/parser/testdata/parse/postgres_regress/gin.metadata.json index de868eb..73da878 100644 --- a/parser/testdata/parse/postgres_regress/gin.metadata.json +++ b/parser/testdata/parse/postgres_regress/gin.metadata.json @@ -2,16 +2,9 @@ "todo": [ "001", "002", - "003", - "004", - "006", "007", - "009", "010", "011", - "012", - "013", - "014", "015", "016", "018", @@ -19,7 +12,6 @@ "021", "022", "023", - "024", "025", "026", "029", @@ -28,21 +20,18 @@ "033", "035", "036", - "037", "039", "040", "041", "042", "044", "046", - "048", "049", "053", "054", "055", "056", "057", - "058", "059" ] } diff --git a/parser/testdata/parse/postgres_regress/gist.metadata.json b/parser/testdata/parse/postgres_regress/gist.metadata.json index 295d0e8..c8772f4 100644 --- a/parser/testdata/parse/postgres_regress/gist.metadata.json +++ b/parser/testdata/parse/postgres_regress/gist.metadata.json @@ -9,15 +9,10 @@ "007", "008", "009", - "010", - "011", - "012", - "013", "014", "015", "016", "017", - "018", "019", "020", "021", @@ -48,7 +43,6 @@ "058", "059", "060", - "061", "062" ] } diff --git a/parser/testdata/parse/postgres_regress/groupingsets.metadata.json b/parser/testdata/parse/postgres_regress/groupingsets.metadata.json index dc65c1e..e4385ee 100644 --- a/parser/testdata/parse/postgres_regress/groupingsets.metadata.json +++ b/parser/testdata/parse/postgres_regress/groupingsets.metadata.json @@ -2,12 +2,9 @@ "todo": [ "001", "002", - "003", "004", - "005", "006", "007", - "008", "009", "010", "011", @@ -51,14 +48,11 @@ "137", "138", "139", - "140", - "141", "142", "143", "145", "146", "147", - "148", "149", "150", "151", diff --git a/parser/testdata/parse/postgres_regress/guc.metadata.json b/parser/testdata/parse/postgres_regress/guc.metadata.json index 4bd108b..3370404 100644 --- a/parser/testdata/parse/postgres_regress/guc.metadata.json +++ b/parser/testdata/parse/postgres_regress/guc.metadata.json @@ -116,8 +116,6 @@ "140", "141", "143", - "145", - "146", "147", "148", "149", diff --git a/parser/testdata/parse/postgres_regress/hash_index.metadata.json b/parser/testdata/parse/postgres_regress/hash_index.metadata.json index dae43f7..76c5d2c2 100644 --- a/parser/testdata/parse/postgres_regress/hash_index.metadata.json +++ b/parser/testdata/parse/postgres_regress/hash_index.metadata.json @@ -4,10 +4,6 @@ "002", "003", "004", - "005", - "006", - "007", - "008", "009", "010", "011", @@ -19,64 +15,37 @@ "017", "018", "019", - "028", - "030", - "032", - "034", - "036", - "038", - "040", - "042", "044", - "045", "046", - "047", "048", "049", "050", - "051", - "052", - "053", - "054", - "055", "056", - "057", - "058", "059", "060", "061", "062", "063", "064", - "065", "066", - "067", "068", "069", "070", "071", - "072", "073", - "074", "075", - "076", "077", "078", "079", - "080", "081", - "082", "083", - "084", "085", "086", "087", "088", - "089", "090", "091", "092", - "093", "094", "095", "096", diff --git a/parser/testdata/parse/postgres_regress/horology.metadata.json b/parser/testdata/parse/postgres_regress/horology.metadata.json index afbebc5..badbb72 100644 --- a/parser/testdata/parse/postgres_regress/horology.metadata.json +++ b/parser/testdata/parse/postgres_regress/horology.metadata.json @@ -10,7 +10,6 @@ "147", "152", "193", - "194", "201", "209", "215", @@ -25,7 +24,6 @@ "230", "232", "233", - "234", "237", "238", "240", diff --git a/parser/testdata/parse/postgres_regress/identity.metadata.json b/parser/testdata/parse/postgres_regress/identity.metadata.json index 748d9f6..0ab7666 100644 --- a/parser/testdata/parse/postgres_regress/identity.metadata.json +++ b/parser/testdata/parse/postgres_regress/identity.metadata.json @@ -16,69 +16,20 @@ "018", "019", "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", "051", - "052", - "053", - "055", - "056", - "057", - "059", - "060", - "061", - "063", - "064", - "066", - "067", "069", - "070", - "071", "073", "074", "075", - "076", "077", - "078", "081", "082", "083", "084", - "085", - "086", - "087", - "088", - "091", - "092", - "094", - "095", "097", "098", "099", - "100", "101", "103", "104", @@ -94,18 +45,13 @@ "115", "116", "117", - "118", "119", - "120", - "121", "124", "125", "126", - "127", "129", "130", "131", - "132", "134", "135", "136", @@ -117,7 +63,6 @@ "143", "144", "145", - "146", "148", "149", "150", @@ -128,7 +73,6 @@ "155", "156", "157", - "158", "159", "161", "162", @@ -136,60 +80,33 @@ "164", "165", "166", - "167", - "168", "169", - "170", "171", "172", "173", - "174", - "175", "176", - "177", "180", "183", "184", "185", - "186", - "187", "188", - "189", - "190", - "191", - "192", "194", "195", "196", "197", - "198", - "199", - "200", - "201", "203", - "204", - "205", - "206", "209", "210", "211", - "212", - "213", "214", "215", "216", "217", "218", "219", - "220", - "221", "223", "224", "225", - "226", - "227", - "228", - "229", "231", "232", "233", @@ -206,7 +123,6 @@ "244", "245", "246", - "247", "248", "249", "250", @@ -215,12 +131,6 @@ "253", "254", "255", - "256", - "257", - "258", - "259", - "260", - "261", "264", "265", "266", diff --git a/parser/testdata/parse/postgres_regress/incremental_sort.metadata.json b/parser/testdata/parse/postgres_regress/incremental_sort.metadata.json index 1d813fc..b6e4b5d 100644 --- a/parser/testdata/parse/postgres_regress/incremental_sort.metadata.json +++ b/parser/testdata/parse/postgres_regress/incremental_sort.metadata.json @@ -9,19 +9,14 @@ "007", "008", "009", - "010", "011", "012", "014", "016", "018", "020", - "022", - "023", "024", "025", - "030", - "031", "032", "033", "035", @@ -32,23 +27,18 @@ "041", "042", "044", - "048", - "049", "050", "051", "053", "055", "057", "059", - "061", - "062", "063", "064", "066", "068", "070", "072", - "074", "075", "076", "077", @@ -56,7 +46,6 @@ "079", "080", "081", - "082", "083", "084", "085", diff --git a/parser/testdata/parse/postgres_regress/index_including.metadata.json b/parser/testdata/parse/postgres_regress/index_including.metadata.json index fa7d701..ed15e77 100644 --- a/parser/testdata/parse/postgres_regress/index_including.metadata.json +++ b/parser/testdata/parse/postgres_regress/index_including.metadata.json @@ -1,51 +1,35 @@ { "todo": [ "001", - "002", "003", "004", "006", - "007", "008", "009", "010", "012", - "013", "014", "015", "016", - "017", "018", "020", - "021", "022", "023", "025", - "026", "027", "028", - "031", "032", "033", - "036", - "037", - "038", "039", "041", "042", "044", "045", "046", - "049", "050", "051", - "054", - "055", - "056", "057", "058", - "061", - "062", "063", "064", "065", @@ -67,7 +51,6 @@ "088", "089", "090", - "091", "092", "094", "095", @@ -85,22 +68,14 @@ "111", "112", "113", - "114", "115", - "116", - "117", - "118", - "119", - "120", "121", "122", - "123", "124", "125", "126", "127", "128", - "129", "130", "131", "132", diff --git a/parser/testdata/parse/postgres_regress/index_including_gist.metadata.json b/parser/testdata/parse/postgres_regress/index_including_gist.metadata.json index b4a37ad..4c3660c 100644 --- a/parser/testdata/parse/postgres_regress/index_including_gist.metadata.json +++ b/parser/testdata/parse/postgres_regress/index_including_gist.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "001", - "002", "003", "006", "007", @@ -9,37 +8,27 @@ "009", "010", "011", - "012", "015", "016", "017", "018", "019", - "020", "021", "023", "024", - "025", "026", "028", "030", "032", "033", - "034", "035", - "036", - "037", - "038", "039", "040", - "041", "042", "043", "044", "045", "046", - "047", - "048", "049", "050" ] diff --git a/parser/testdata/parse/postgres_regress/indexing.metadata.json b/parser/testdata/parse/postgres_regress/indexing.metadata.json index 8765d36..a081d9a 100644 --- a/parser/testdata/parse/postgres_regress/indexing.metadata.json +++ b/parser/testdata/parse/postgres_regress/indexing.metadata.json @@ -21,7 +21,6 @@ "024", "025", "026", - "027", "028", "029", "030", @@ -385,17 +384,9 @@ "425", "426", "427", - "428", "429", "430", "431", - "432", - "433", - "434", - "435", - "436", - "437", - "438", "440", "441", "442", @@ -447,19 +438,13 @@ "488", "489", "490", - "491", - "492", "493", "494", "495", - "496", - "497", "498", "499", "500", "501", - "502", - "503", "504", "505", "506", @@ -495,7 +480,6 @@ "537", "538", "539", - "540", "541", "542", "544", diff --git a/parser/testdata/parse/postgres_regress/indirect_toast.metadata.json b/parser/testdata/parse/postgres_regress/indirect_toast.metadata.json index 2041982..0eab3e4 100644 --- a/parser/testdata/parse/postgres_regress/indirect_toast.metadata.json +++ b/parser/testdata/parse/postgres_regress/indirect_toast.metadata.json @@ -3,22 +3,9 @@ "001", "002", "003", - "004", - "005", - "006", - "007", - "009", - "010", - "011", - "012", "014", "016", "017", - "018", - "019", - "020", - "021", - "022", "024", "026", "027", diff --git a/parser/testdata/parse/postgres_regress/inet.metadata.json b/parser/testdata/parse/postgres_regress/inet.metadata.json index 662889a..70342f0 100644 --- a/parser/testdata/parse/postgres_regress/inet.metadata.json +++ b/parser/testdata/parse/postgres_regress/inet.metadata.json @@ -2,27 +2,6 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", "036", "037", "038", @@ -40,7 +19,6 @@ "066", "078", "080", - "081", - "102" + "081" ] } diff --git a/parser/testdata/parse/postgres_regress/inherit.metadata.json b/parser/testdata/parse/postgres_regress/inherit.metadata.json index 808bc5a..3a1d18a 100644 --- a/parser/testdata/parse/postgres_regress/inherit.metadata.json +++ b/parser/testdata/parse/postgres_regress/inherit.metadata.json @@ -4,90 +4,31 @@ "002", "003", "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "037", - "038", - "039", - "040", - "041", - "050", - "059", - "060", - "069", "078", - "079", "080", "081", - "082", "083", "084", "085", "086", - "087", "088", "089", "090", "091", - "092", "093", - "094", "095", - "096", "098", "099", "100", "101", "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", - "110", - "111", - "112", - "113", - "114", - "115", - "117", "119", - "120", "121", - "122", "123", "124", "125", "126", - "127", - "128", "130", - "131", - "132", "134", "135", "136", @@ -96,8 +37,6 @@ "139", "140", "141", - "142", - "143", "145", "146", "147", @@ -107,7 +46,6 @@ "151", "152", "153", - "154", "155", "157", "158", @@ -123,7 +61,6 @@ "169", "170", "171", - "172", "175", "176", "177", @@ -133,7 +70,6 @@ "181", "182", "183", - "184", "186", "187", "188", @@ -141,13 +77,9 @@ "190", "191", "192", - "194", - "195", "196", "197", "199", - "201", - "202", "203", "204", "206", @@ -170,13 +102,9 @@ "229", "230", "231", - "232", "233", "234", - "235", - "236", "237", - "238", "239", "240", "241", @@ -227,12 +155,8 @@ "287", "288", "289", - "290", "291", - "292", "293", - "294", - "295", "298", "299", "300", @@ -273,16 +197,11 @@ "336", "337", "338", - "339", "340", "341", - "342", - "343", "345", "346", - "347", "348", - "349", "350", "351", "352", @@ -300,12 +219,6 @@ "366", "367", "368", - "369", - "370", - "371", - "372", - "373", - "374", "375", "376", "378", @@ -328,8 +241,6 @@ "399", "400", "401", - "402", - "403", "404", "405", "406", @@ -350,26 +261,17 @@ "422", "423", "424", - "425", - "426", "427", - "428", "430", "431", "432", "433", "434", "435", - "436", "437", - "438", - "440", "442", "443", "444", - "445", - "446", - "447", "450", "451", "452", @@ -392,10 +294,6 @@ "469", "470", "471", - "472", - "473", - "474", - "475", "478", "479", "480", @@ -450,7 +348,6 @@ "529", "530", "531", - "532", "533", "535", "536", @@ -530,7 +427,6 @@ "610", "611", "612", - "613", "614", "615", "616", @@ -557,43 +453,12 @@ "637", "638", "639", - "640", - "641", - "642", - "643", - "644", - "645", - "646", - "647", - "648", - "649", - "650", - "651", "652", - "653", - "654", - "655", "656", - "657", - "658", - "659", "660", - "661", - "662", - "663", "664", - "665", - "666", - "667", "668", - "669", - "670", - "671", "672", - "673", - "674", - "675", - "676", "677" ] } diff --git a/parser/testdata/parse/postgres_regress/insert.metadata.json b/parser/testdata/parse/postgres_regress/insert.metadata.json index 5fd95ff..ff299cd 100644 --- a/parser/testdata/parse/postgres_regress/insert.metadata.json +++ b/parser/testdata/parse/postgres_regress/insert.metadata.json @@ -1,41 +1,12 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "008", - "009", - "010", - "011", - "013", - "015", "017", "018", "019", - "020", - "021", - "023", - "024", "025", "026", "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", "043", "044", "045", @@ -46,26 +17,6 @@ "050", "051", "052", - "053", - "054", - "055", - "056", - "057", - "058", - "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", - "069", - "070", - "071", - "072", "075", "076", "077", @@ -78,45 +29,24 @@ "084", "085", "086", - "087", - "088", "089", - "090", - "091", "092", "093", "094", "095", "096", - "097", "098", "099", "100", "101", - "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", "110", "111", "112", "113", - "114", - "115", - "116", - "117", - "118", "119", "120", "121", "122", - "123", - "124", - "125", "126", "127", "128", @@ -124,37 +54,7 @@ "130", "131", "132", - "133", - "134", - "135", - "136", - "137", - "138", - "139", - "140", - "141", - "142", - "143", - "145", - "146", - "147", - "148", - "149", - "150", - "151", "152", - "153", - "154", - "155", - "156", - "157", - "158", - "160", - "161", - "162", - "163", - "164", - "165", "167", "168", "169", @@ -164,26 +64,15 @@ "173", "174", "175", - "176", - "177", - "178", - "179", "181", "182", "183", "184", "185", - "186", - "187", - "188", - "189", "191", "192", "193", "194", - "195", - "196", - "197", "199", "200", "201", @@ -194,19 +83,14 @@ "206", "208", "209", - "210", - "212", "213", "214", "215", "216", - "217", "218", "219", - "220", "221", "222", - "223", "224", "225", "226", @@ -217,30 +101,20 @@ "231", "232", "233", - "234", "235", "236", "237", "238", "239", "240", - "241", "242", "243", - "244", "245", "246", "247", "248", "249", - "250", - "251", - "252", - "253", - "254", - "255", "256", - "257", "259", "260", "261", @@ -250,20 +124,10 @@ "265", "266", "267", - "268", - "269", - "270", - "271", - "272", "274", "275", "276", "277", - "278", - "279", - "280", - "281", - "282", "284", "285", "286", @@ -272,12 +136,9 @@ "289", "290", "291", - "292", "293", "294", "295", - "296", - "297", "298", "299", "300", @@ -293,38 +154,17 @@ "310", "311", "312", - "313", - "314", - "315", - "316", - "317", - "318", - "319", - "320", - "321", - "322", - "323", - "324", - "325", - "326", - "327", - "328", - "329", - "330", "332", "333", "334", "335", "336", - "337", - "338", "339", "340", "341", "342", "343", "344", - "345", "346", "347", "348", @@ -341,8 +181,6 @@ "359", "360", "361", - "362", - "363", "365", "366", "367", @@ -354,16 +192,13 @@ "373", "374", "375", - "376", "378", "379", "380", - "381", "382", "383", "384", "385", - "386", "387" ] } diff --git a/parser/testdata/parse/postgres_regress/insert_conflict.metadata.json b/parser/testdata/parse/postgres_regress/insert_conflict.metadata.json index fd36aab..d8fef6e 100644 --- a/parser/testdata/parse/postgres_regress/insert_conflict.metadata.json +++ b/parser/testdata/parse/postgres_regress/insert_conflict.metadata.json @@ -32,190 +32,85 @@ "030", "031", "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", "048", "049", - "050", - "051", - "052", - "053", - "054", - "055", "056", "057", "058", - "059", - "060", - "061", - "062", - "063", - "064", "065", "066", "067", - "068", - "069", - "070", - "071", "072", "073", "074", - "075", - "076", "077", - "078", - "079", - "080", "081", "082", "083", "084", - "085", - "086", - "087", "088", "089", "090", - "091", - "092", - "093", - "094", - "095", - "096", "097", "098", - "099", - "100", - "101", - "102", "103", "104", "105", "106", "107", "108", - "109", - "110", "111", "112", "113", "114", - "115", - "116", - "117", "118", "119", "120", - "121", - "123", "125", "126", "127", "128", "129", "130", - "131", - "132", - "133", - "134", - "135", - "137", - "138", - "139", - "141", - "143", - "146", "148", "149", "150", - "151", - "152", - "153", - "154", - "155", "156", "157", - "158", - "159", - "160", "161", - "162", - "163", "164", "165", - "166", - "167", - "168", - "169", - "170", "172", "173", "174", - "175", "176", "177", - "178", "179", "180", - "181", "182", "183", - "184", "185", "186", - "187", "188", "189", - "190", "191", "193", "194", "195", - "196", - "197", - "198", - "199", - "200", - "201", - "202", "204", "205", "206", - "207", - "208", "210", "211", "212", - "213", - "214", "216", "217", "218", - "219", - "220", "222", - "223", - "224", "226", "227", "228", "229", - "230", - "231", "232", "233", "234", @@ -223,8 +118,6 @@ "236", "237", "238", - "239", - "240", "241", "242", "243", @@ -232,13 +125,9 @@ "245", "246", "247", - "248", - "249", "251", "252", "253", - "254", - "255", "256", "257" ] diff --git a/parser/testdata/parse/postgres_regress/int2.metadata.json b/parser/testdata/parse/postgres_regress/int2.metadata.json index 5e6664a..737fd31 100644 --- a/parser/testdata/parse/postgres_regress/int2.metadata.json +++ b/parser/testdata/parse/postgres_regress/int2.metadata.json @@ -1,12 +1,3 @@ { - "todo": [ - "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008" - ] + "todo": [] } diff --git a/parser/testdata/parse/postgres_regress/int4.metadata.json b/parser/testdata/parse/postgres_regress/int4.metadata.json index 5e6664a..737fd31 100644 --- a/parser/testdata/parse/postgres_regress/int4.metadata.json +++ b/parser/testdata/parse/postgres_regress/int4.metadata.json @@ -1,12 +1,3 @@ { - "todo": [ - "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008" - ] + "todo": [] } diff --git a/parser/testdata/parse/postgres_regress/int8.metadata.json b/parser/testdata/parse/postgres_regress/int8.metadata.json index b4c5d89..737fd31 100644 --- a/parser/testdata/parse/postgres_regress/int8.metadata.json +++ b/parser/testdata/parse/postgres_regress/int8.metadata.json @@ -1,11 +1,3 @@ { - "todo": [ - "001", - "002", - "003", - "004", - "005", - "006", - "007" - ] + "todo": [] } diff --git a/parser/testdata/parse/postgres_regress/interval.metadata.json b/parser/testdata/parse/postgres_regress/interval.metadata.json index 972fdee..de66215 100644 --- a/parser/testdata/parse/postgres_regress/interval.metadata.json +++ b/parser/testdata/parse/postgres_regress/interval.metadata.json @@ -3,33 +3,13 @@ "001", "002", "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", "049", - "050", - "051", - "052", - "053", - "054", "057", "058", "059", "061", "063", "064", - "065", "070", "071", "072", @@ -47,7 +27,6 @@ "343", "345", "376", - "377", "379" ] } diff --git a/parser/testdata/parse/postgres_regress/join.metadata.json b/parser/testdata/parse/postgres_regress/join.metadata.json index 3590d26..738ae66 100644 --- a/parser/testdata/parse/postgres_regress/join.metadata.json +++ b/parser/testdata/parse/postgres_regress/join.metadata.json @@ -2,51 +2,14 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", "023", - "024", "025", "067", "068", "069", "070", - "071", - "072", - "073", - "074", - "075", - "076", - "077", "090", - "091", - "092", - "093", - "094", - "095", "096", - "097", - "098", - "099", - "100", "114", "115", "116", @@ -86,32 +49,14 @@ "158", "159", "160", - "161", - "162", - "163", - "164", - "165", - "166", - "167", - "168", - "169", - "170", - "172", - "174", "176", - "177", "185", - "186", - "187", "188", - "189", - "190", "191", "192", "195", "196", "197", - "198", "199", "200", "201", @@ -127,10 +72,8 @@ "213", "214", "215", - "216", "217", "218", - "219", "220", "221", "222", @@ -144,28 +87,12 @@ "231", "232", "233", - "234", - "235", - "236", - "237", - "238", "240", "241", - "242", - "243", - "244", - "245", - "246", - "247", "249", "250", "251", - "252", - "253", "255", - "258", - "259", - "260", "261", "262", "263", @@ -186,27 +113,11 @@ "283", "284", "285", - "286", - "287", - "288", - "289", - "290", - "291", - "292", "294", "297", "299", "300", "301", - "302", - "303", - "304", - "305", - "306", - "307", - "308", - "309", - "310", "311", "313", "315", @@ -294,10 +205,6 @@ "434", "435", "436", - "437", - "438", - "439", - "440", "441", "442", "443", @@ -327,8 +234,6 @@ "467", "468", "469", - "470", - "471", "473", "475", "477", @@ -336,12 +241,9 @@ "480", "481", "482", - "483", - "484", "487", "488", "489", - "490", "492", "493", "494", @@ -353,19 +255,16 @@ "501", "502", "503", - "504", "505", "507", "508", "509", - "510", "511", "512", "514", "515", "517", "518", - "519", "520", "530", "532", @@ -395,26 +294,16 @@ "587", "589", "599", - "600", - "601", - "602", - "603", - "604", - "605", - "606", "607", "608", "609", "610", - "611", "612", - "613", "614", "616", "617", "618", "619", - "620", "621", "622", "623", @@ -424,8 +313,6 @@ "627", "628", "629", - "630", - "631", "632", "633", "634", @@ -434,9 +321,6 @@ "637", "638", "639", - "640", - "641", - "642", "643", "644", "645", @@ -456,9 +340,6 @@ "659", "660", "661", - "662", - "663", - "664", "665", "666", "667", @@ -474,7 +355,6 @@ "677", "678", "679", - "680", "681", "682", "684", @@ -492,7 +372,6 @@ "698", "699", "700", - "701", "702", "703", "704", @@ -501,7 +380,6 @@ "708", "709", "710", - "711", "712", "713", "714", diff --git a/parser/testdata/parse/postgres_regress/join_hash.metadata.json b/parser/testdata/parse/postgres_regress/join_hash.metadata.json index e326b2b..047832d 100644 --- a/parser/testdata/parse/postgres_regress/join_hash.metadata.json +++ b/parser/testdata/parse/postgres_regress/join_hash.metadata.json @@ -13,13 +13,10 @@ "011", "012", "013", - "014", "015", "016", "017", "018", - "019", - "020", "021", "022", "023", @@ -204,9 +201,6 @@ "244", "245", "246", - "247", - "248", - "249", "251", "252", "254", @@ -216,15 +210,6 @@ "258", "259", "260", - "261", - "262", - "263", - "264", - "265", - "266", - "267", - "268", - "269", "270", "272", "274", diff --git a/parser/testdata/parse/postgres_regress/json.metadata.json b/parser/testdata/parse/postgres_regress/json.metadata.json index 5c6e68f..941a883 100644 --- a/parser/testdata/parse/postgres_regress/json.metadata.json +++ b/parser/testdata/parse/postgres_regress/json.metadata.json @@ -8,9 +8,7 @@ "072", "074", "076", - "086", "092", - "093", "212", "213", "214", @@ -21,7 +19,6 @@ "219", "312", "332", - "333", "335", "336", "337", @@ -29,10 +26,6 @@ "339", "340", "341", - "374", - "375", - "376", - "377", - "380" + "374" ] } diff --git a/parser/testdata/parse/postgres_regress/jsonb.metadata.json b/parser/testdata/parse/postgres_regress/jsonb.metadata.json index d59256f..56f4702 100644 --- a/parser/testdata/parse/postgres_regress/jsonb.metadata.json +++ b/parser/testdata/parse/postgres_regress/jsonb.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "001", - "002", "036", "039", "058", @@ -10,15 +9,8 @@ "063", "065", "067", - "077", "079", - "080", - "1001", "266", - "267", - "268", - "269", - "272", "353", "354", "355", @@ -37,7 +29,6 @@ "468", "469", "519", - "520", "522", "523", "524", @@ -68,9 +59,6 @@ "657", "658", "683", - "684", - "685", - "686", "687", "688", "689", @@ -79,74 +67,7 @@ "698", "699", "905", - "906", - "907", - "909", - "911", - "913", - "915", - "920", - "921", - "923", - "924", - "926", - "927", - "929", - "930", - "931", - "933", - "935", - "937", - "938", - "939", - "941", - "942", - "943", - "945", - "946", - "947", - "949", - "950", - "951", - "953", - "954", - "955", - "957", - "958", - "959", - "960", - "962", - "963", - "964", - "965", - "967", - "968", - "969", - "970", - "972", - "973", - "974", - "975", - "977", - "978", - "979", - "981", - "982", - "983", - "985", - "986", - "987", - "988", - "989", - "990", - "991", - "992", - "993", - "994", - "995", "996", - "997", - "998", - "999" + "997" ] } diff --git a/parser/testdata/parse/postgres_regress/largeobject.metadata.json b/parser/testdata/parse/postgres_regress/largeobject.metadata.json index c09cd46..41dc028 100644 --- a/parser/testdata/parse/postgres_regress/largeobject.metadata.json +++ b/parser/testdata/parse/postgres_regress/largeobject.metadata.json @@ -8,26 +8,19 @@ "007", "008", "009", - "010", "011", - "012", "015", "017", - "018", "027", "028", "030", "031", "032", - "033", "044", "045", - "046", "060", "062", - "063", "064", - "065", "075", "079", "091", diff --git a/parser/testdata/parse/postgres_regress/limit.metadata.json b/parser/testdata/parse/postgres_regress/limit.metadata.json index e8c8068..eda3faf 100644 --- a/parser/testdata/parse/postgres_regress/limit.metadata.json +++ b/parser/testdata/parse/postgres_regress/limit.metadata.json @@ -1,43 +1,6 @@ { "todo": [ "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", "050", "052", "053", diff --git a/parser/testdata/parse/postgres_regress/line.metadata.json b/parser/testdata/parse/postgres_regress/line.metadata.json index 880b1d2..f23fe5c 100644 --- a/parser/testdata/parse/postgres_regress/line.metadata.json +++ b/parser/testdata/parse/postgres_regress/line.metadata.json @@ -1,27 +1,5 @@ { "todo": [ - "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023" + "001" ] } diff --git a/parser/testdata/parse/postgres_regress/lseg.metadata.json b/parser/testdata/parse/postgres_regress/lseg.metadata.json index 70c818b..f23fe5c 100644 --- a/parser/testdata/parse/postgres_regress/lseg.metadata.json +++ b/parser/testdata/parse/postgres_regress/lseg.metadata.json @@ -1,17 +1,5 @@ { "todo": [ - "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013" + "001" ] } diff --git a/parser/testdata/parse/postgres_regress/macaddr.metadata.json b/parser/testdata/parse/postgres_regress/macaddr.metadata.json index 7cf15e3..eddbb92 100644 --- a/parser/testdata/parse/postgres_regress/macaddr.metadata.json +++ b/parser/testdata/parse/postgres_regress/macaddr.metadata.json @@ -1,20 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", "017", "018", "031" diff --git a/parser/testdata/parse/postgres_regress/macaddr8.metadata.json b/parser/testdata/parse/postgres_regress/macaddr8.metadata.json index 0bcd944..985171f 100644 --- a/parser/testdata/parse/postgres_regress/macaddr8.metadata.json +++ b/parser/testdata/parse/postgres_regress/macaddr8.metadata.json @@ -1,27 +1,6 @@ { "todo": [ "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", "045", "046", "067" diff --git a/parser/testdata/parse/postgres_regress/matview.metadata.json b/parser/testdata/parse/postgres_regress/matview.metadata.json index dae74a1..7dd6984 100644 --- a/parser/testdata/parse/postgres_regress/matview.metadata.json +++ b/parser/testdata/parse/postgres_regress/matview.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "001", - "002", "003", "005", "006", @@ -22,7 +21,6 @@ "026", "027", "028", - "029", "032", "033", "036", @@ -50,7 +48,6 @@ "067", "068", "069", - "070", "071", "072", "073", @@ -59,8 +56,6 @@ "076", "077", "078", - "079", - "080", "081", "082", "083", @@ -68,10 +63,8 @@ "085", "086", "087", - "088", "089", "090", - "091", "092", "094", "095", @@ -82,10 +75,8 @@ "100", "101", "102", - "103", "104", "105", - "106", "107", "108", "109", @@ -99,7 +90,6 @@ "123", "124", "125", - "126", "129", "130", "131", diff --git a/parser/testdata/parse/postgres_regress/memoize.metadata.json b/parser/testdata/parse/postgres_regress/memoize.metadata.json index 4c3e878..760696c 100644 --- a/parser/testdata/parse/postgres_regress/memoize.metadata.json +++ b/parser/testdata/parse/postgres_regress/memoize.metadata.json @@ -5,8 +5,6 @@ "003", "010", "011", - "012", - "013", "014", "015", "017", @@ -14,23 +12,18 @@ "019", "021", "022", - "023", "024", "025", "028", "029", "030", "031", - "032", - "033", "034", "037", "038", "039", "040", "041", - "042", - "043", "044", "045", "046", diff --git a/parser/testdata/parse/postgres_regress/merge.metadata.json b/parser/testdata/parse/postgres_regress/merge.metadata.json index c5340df..84257a7 100644 --- a/parser/testdata/parse/postgres_regress/merge.metadata.json +++ b/parser/testdata/parse/postgres_regress/merge.metadata.json @@ -7,9 +7,6 @@ "005", "006", "007", - "008", - "009", - "010", "012", "013", "014", @@ -19,148 +16,70 @@ "018", "019", "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", "033", - "034", "035", "036", - "037", "038", - "039", "040", "041", - "042", "043", "044", - "045", - "046", - "047", - "048", - "049", - "050", "051", - "052", "053", - "054", - "057", - "058", - "059", "060", - "061", "063", "064", - "065", "067", - "068", "069", "070", "071", "072", "073", - "074", "075", - "076", - "077", "080", - "081", "083", "084", - "085", "087", "088", - "089", "091", "092", - "093", "095", - "096", "099", - "100", "101", "102", - "103", "104", - "105", - "106", - "109", "110", - "111", "113", - "114", - "115", "118", "119", "120", - "121", "123", "124", - "125", "127", "128", - "129", "131", "132", - "133", "135", - "136", - "137", "138", - "139", "141", - "142", "143", - "144", "146", - "147", "148", - "149", "151", "152", - "153", "155", "156", - "157", "158", "159", "160", - "161", "162", - "163", "165", - "166", - "168", "170", - "171", "173", "174", - "175", "177", - "178", - "180", - "181", - "183", - "185", - "187", - "189", - "191", - "193", "195", - "196", "198", - "199", - "200", - "201", "203", "204", "205", @@ -176,12 +95,8 @@ "215", "216", "217", - "218", - "219", "221", "222", - "223", - "224", "226", "227", "229", @@ -192,69 +107,44 @@ "235", "236", "237", - "238", "240", "241", - "242", "244", "245", - "246", "248", "249", - "250", "252", "253", - "254", "256", "257", - "258", "260", "261", "262", "265", "266", - "267", - "268", "270", "271", - "272", - "273", "275", "276", "277", - "278", - "279", "280", - "281", "283", "284", "285", - "286", "288", "289", - "290", "291", "292", - "293", - "294", "296", "297", - "298", - "299", "300", "303", "304", - "305", - "306", "307", - "309", "310", - "311", "312", - "313", "315", "316", - "317", "318", "319", "320", @@ -267,8 +157,6 @@ "330", "331", "332", - "333", - "334", "335", "344", "345", @@ -278,13 +166,10 @@ "349", "350", "351", - "352", "354", "355", - "356", "358", "359", - "360", "362", "363", "364", @@ -293,23 +178,17 @@ "367", "368", "369", - "370", - "371", "372", - "373", "375", "376", - "377", "379", "380", "381", "384", "385", - "386", "388", "389", "390", - "391", "393", "394", "395", @@ -322,12 +201,10 @@ "402", "403", "404", - "405", "406", "407", "409", "410", - "411", "413", "414", "415", @@ -346,7 +223,6 @@ "431", "432", "433", - "434", "435", "436", "437", @@ -358,48 +234,26 @@ "443", "444", "445", - "446", - "447", - "448", "449", - "450", "452", "453", "454", "455", "456", "457", - "458", "459", - "460", "462", "463", - "464", "465", "466", "467", "468", "469", - "470", - "471", - "472", - "473", - "474", - "475", - "476", - "477", - "478", - "479", - "480", - "482", "484", "485", "486", - "487", "488", "489", - "490", - "491", "493", "494", "495", @@ -407,64 +261,33 @@ "497", "498", "499", - "500", "501", "502", - "503", - "504", - "505", - "506", - "507", - "508", "510", - "511", - "512", - "513", - "514", - "515", - "516", - "517", - "518", "519", - "520", "522", - "523", "525", - "526", "528", - "529", "531", "532", "533", "534", - "535", "537", "538", "539", "540", - "541", - "542", - "544", "545", "546", "547", - "548", "549", - "550", - "551", "553", "554", - "555", "556", "557", - "558", - "559", "561", "562", "563", - "564", "565", - "566", "567", "568", "569", diff --git a/parser/testdata/parse/postgres_regress/misc.metadata.json b/parser/testdata/parse/postgres_regress/misc.metadata.json index 222cfd0..d360ac8 100644 --- a/parser/testdata/parse/postgres_regress/misc.metadata.json +++ b/parser/testdata/parse/postgres_regress/misc.metadata.json @@ -2,26 +2,11 @@ "todo": [ "001", "002", - "003", - "004", - "006", - "007", "008", - "009", "010", - "011", - "014", "015", - "016", "018", "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", "027", "028", "029", diff --git a/parser/testdata/parse/postgres_regress/misc_functions.metadata.json b/parser/testdata/parse/postgres_regress/misc_functions.metadata.json index befbdec..ce38c34 100644 --- a/parser/testdata/parse/postgres_regress/misc_functions.metadata.json +++ b/parser/testdata/parse/postgres_regress/misc_functions.metadata.json @@ -22,7 +22,6 @@ "113", "115", "116", - "117", "119" ] } diff --git a/parser/testdata/parse/postgres_regress/money.metadata.json b/parser/testdata/parse/postgres_regress/money.metadata.json index 6987d00..f23fe5c 100644 --- a/parser/testdata/parse/postgres_regress/money.metadata.json +++ b/parser/testdata/parse/postgres_regress/money.metadata.json @@ -1,18 +1,5 @@ { "todo": [ - "001", - "002", - "039", - "040", - "042", - "043", - "045", - "046", - "048", - "049", - "051", - "052", - "054", - "055" + "001" ] } diff --git a/parser/testdata/parse/postgres_regress/multirangetypes.metadata.json b/parser/testdata/parse/postgres_regress/multirangetypes.metadata.json index e17434e..2010ea2 100644 --- a/parser/testdata/parse/postgres_regress/multirangetypes.metadata.json +++ b/parser/testdata/parse/postgres_regress/multirangetypes.metadata.json @@ -2,24 +2,8 @@ "todo": [ "068", "069", - "070", - "071", - "072", - "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", "104", "366", - "367", - "368", - "369", - "370", - "371", "372", "373", "374", @@ -30,14 +14,8 @@ "416", "455", "456", - "457", "480", "481", - "482", - "483", - "484", - "485", - "486", "490", "491", "492", @@ -52,7 +30,6 @@ "504", "505", "507", - "508", "510", "511", "512", @@ -98,7 +75,6 @@ "571", "572", "574", - "575", "577", "582", "583", diff --git a/parser/testdata/parse/postgres_regress/mvcc.metadata.json b/parser/testdata/parse/postgres_regress/mvcc.metadata.json index 5d6e121..e17e032 100644 --- a/parser/testdata/parse/postgres_regress/mvcc.metadata.json +++ b/parser/testdata/parse/postgres_regress/mvcc.metadata.json @@ -6,7 +6,6 @@ "004", "005", "006", - "007", "009", "011" ] diff --git a/parser/testdata/parse/postgres_regress/name.metadata.json b/parser/testdata/parse/postgres_regress/name.metadata.json index 1dd35ff..a7ac0dd 100644 --- a/parser/testdata/parse/postgres_regress/name.metadata.json +++ b/parser/testdata/parse/postgres_regress/name.metadata.json @@ -1,13 +1,6 @@ { "todo": [ "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", "022", "023" ] diff --git a/parser/testdata/parse/postgres_regress/namespace.metadata.json b/parser/testdata/parse/postgres_regress/namespace.metadata.json index 87f2b47..f0b87e1 100644 --- a/parser/testdata/parse/postgres_regress/namespace.metadata.json +++ b/parser/testdata/parse/postgres_regress/namespace.metadata.json @@ -14,9 +14,6 @@ "013", "014", "015", - "017", - "018", - "019", "022", "024", "025", @@ -26,7 +23,6 @@ "030", "031", "032", - "033", "034", "035", "036", diff --git a/parser/testdata/parse/postgres_regress/numeric.metadata.json b/parser/testdata/parse/postgres_regress/numeric.metadata.json index beae823..2a1b104 100644 --- a/parser/testdata/parse/postgres_regress/numeric.metadata.json +++ b/parser/testdata/parse/postgres_regress/numeric.metadata.json @@ -11,470 +11,20 @@ "009", "010", "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", - "055", - "056", - "057", - "058", - "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", - "069", - "070", - "071", - "072", - "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", - "082", - "083", - "084", - "085", - "086", - "087", - "088", - "089", - "090", - "091", - "092", - "093", - "094", - "095", - "096", - "097", - "098", - "099", - "100", "1000", "1001", "1003", "1004", - "101", - "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", - "110", - "111", - "112", - "113", - "114", - "115", - "116", - "117", - "118", - "119", - "120", - "121", - "122", - "123", - "124", - "125", - "126", - "127", - "128", - "129", - "130", - "131", - "132", - "133", - "134", - "135", - "136", - "137", - "138", - "139", - "140", - "141", - "142", - "143", - "144", - "145", - "146", - "147", - "148", - "149", - "150", - "151", - "152", - "153", - "154", - "155", - "156", - "157", - "158", - "159", - "160", - "161", - "162", - "163", - "164", - "165", - "166", - "167", - "168", - "169", - "170", - "171", - "172", - "173", - "174", - "175", - "176", - "177", - "178", - "179", - "180", - "181", - "182", - "183", - "184", - "185", - "186", - "187", - "188", - "189", - "190", - "191", - "192", - "193", - "194", - "195", - "196", - "197", - "198", - "199", - "200", - "201", - "202", - "203", - "204", - "205", - "206", - "207", - "208", - "209", - "210", - "211", - "212", - "213", - "214", - "215", - "216", - "217", - "218", - "219", - "220", - "221", - "222", - "223", - "224", - "225", - "226", - "227", - "228", - "229", - "230", - "231", - "232", - "233", - "234", - "235", - "236", - "237", - "238", - "239", - "240", - "241", - "242", - "243", - "244", - "245", - "246", - "247", - "248", - "249", - "250", - "251", - "252", - "253", - "254", - "255", - "256", - "257", - "258", - "259", - "260", - "261", - "262", - "263", - "264", - "265", - "266", - "267", - "268", - "269", - "270", - "271", - "272", - "273", - "274", - "275", - "276", - "277", - "278", - "279", - "280", - "281", - "282", - "283", - "284", - "285", - "286", - "287", - "288", - "289", - "290", - "291", - "292", - "293", - "294", - "295", - "296", - "297", - "298", - "299", - "300", - "301", - "302", - "303", - "304", - "305", - "306", - "307", - "308", - "309", - "310", - "311", - "312", - "313", - "314", - "315", - "316", - "317", - "318", - "319", - "320", - "321", - "322", - "323", - "324", - "325", - "326", - "327", - "328", - "329", - "330", - "331", - "332", - "333", - "334", - "335", - "336", - "337", - "338", - "339", - "340", - "341", - "342", - "343", - "344", - "345", - "346", - "347", - "348", - "349", - "350", - "351", - "352", - "353", - "354", - "355", - "356", - "357", - "358", - "359", - "360", - "361", - "362", - "363", - "364", - "365", - "366", - "367", - "368", - "369", - "370", - "371", - "372", - "373", - "374", - "375", - "376", - "377", - "378", - "379", - "380", - "381", - "382", - "383", - "384", - "385", - "386", - "387", - "388", - "389", - "390", - "391", - "392", - "393", - "394", - "395", - "396", - "397", - "398", - "399", - "400", - "401", - "402", - "403", - "404", - "405", - "406", - "407", - "408", - "409", - "410", - "411", "412", "413", - "414", - "415", - "416", - "417", - "418", - "419", - "420", - "421", - "422", - "423", "424", "425", - "426", - "427", - "428", - "429", - "430", - "431", - "432", - "433", - "434", - "435", "436", "437", - "438", - "439", - "440", - "441", - "442", - "443", - "444", - "445", - "446", - "447", "448", "449", - "450", - "451", - "452", - "453", - "454", - "455", - "456", - "457", - "458", - "459", "460", "461", - "462", - "463", - "464", - "465", - "466", - "467", - "468", - "469", - "470", - "471", "472", "473", "474", @@ -492,139 +42,22 @@ "486", "487", "488", - "489", - "490", - "492", - "493", - "495", - "496", - "498", - "499", - "501", - "502", - "504", - "505", - "507", - "508", - "510", - "511", - "513", - "514", - "516", - "517", - "519", - "520", - "522", - "523", "582", - "583", - "584", - "585", - "586", - "587", - "588", - "589", - "590", - "591", - "592", - "593", "595", "630", - "631", - "632", - "633", - "634", - "635", - "636", - "637", "639", "668", - "669", - "670", "678", "729", "752", "753", - "754", - "755", - "756", - "757", - "758", - "759", - "760", - "761", - "762", - "763", - "764", - "765", - "766", - "767", - "768", - "769", - "770", - "771", - "772", - "773", - "774", - "775", - "776", - "777", - "778", - "779", - "780", - "781", - "782", - "783", - "784", - "785", - "786", - "787", - "788", - "789", - "790", - "791", - "792", - "793", - "794", - "795", - "796", - "797", - "798", - "799", - "800", - "801", - "802", - "803", - "804", "814", - "815", - "816", - "817", - "818", - "819", - "820", - "821", - "822", - "823", - "825", - "826", - "827", - "828", - "829", - "830", "982", - "983", - "984", - "985", - "986", - "987", "989", "990", "991", "992", "994", - "995", - "996", "998", "999" ] diff --git a/parser/testdata/parse/postgres_regress/numeric_big.metadata.json b/parser/testdata/parse/postgres_regress/numeric_big.metadata.json index b9b3672..14f9ec0 100644 --- a/parser/testdata/parse/postgres_regress/numeric_big.metadata.json +++ b/parser/testdata/parse/postgres_regress/numeric_big.metadata.json @@ -21,466 +21,16 @@ "019", "020", "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", - "055", - "056", - "057", - "058", - "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", - "069", - "070", - "071", - "072", - "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", - "082", - "083", - "084", - "085", - "086", - "087", - "088", - "089", - "090", - "091", - "092", - "093", - "094", - "095", - "096", - "097", - "098", - "099", - "100", - "101", - "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", - "110", - "111", - "112", - "113", - "114", - "115", - "116", - "117", - "118", - "119", - "120", - "121", - "122", - "123", - "124", - "125", - "126", - "127", - "128", - "129", - "130", - "131", - "132", - "133", - "134", - "135", - "136", - "137", - "138", - "139", - "140", - "141", - "142", - "143", - "144", - "145", - "146", - "147", - "148", - "149", - "150", - "151", - "152", - "153", - "154", - "155", - "156", - "157", - "158", - "159", - "160", - "161", - "162", - "163", - "164", - "165", - "166", - "167", - "168", - "169", - "170", - "171", - "172", - "173", - "174", - "175", - "176", - "177", - "178", - "179", - "180", - "181", - "182", - "183", - "184", - "185", - "186", - "187", - "188", - "189", - "190", - "191", - "192", - "193", - "194", - "195", - "196", - "197", - "198", - "199", - "200", - "201", - "202", - "203", - "204", - "205", - "206", - "207", - "208", - "209", - "210", - "211", - "212", - "213", - "214", - "215", - "216", - "217", - "218", - "219", - "220", - "221", - "222", - "223", - "224", - "225", - "226", - "227", - "228", - "229", - "230", - "231", - "232", - "233", - "234", - "235", - "236", - "237", - "238", - "239", - "240", - "241", - "242", - "243", - "244", - "245", - "246", - "247", - "248", - "249", - "250", - "251", - "252", - "253", - "254", - "255", - "256", - "257", - "258", - "259", - "260", - "261", - "262", - "263", - "264", - "265", - "266", - "267", - "268", - "269", - "270", - "271", - "272", - "273", - "274", - "275", - "276", - "277", - "278", - "279", - "280", - "281", - "282", - "283", - "284", - "285", - "286", - "287", - "288", - "289", - "290", - "291", - "292", - "293", - "294", - "295", - "296", - "297", - "298", - "299", - "300", - "301", - "302", - "303", - "304", - "305", - "306", - "307", - "308", - "309", - "310", - "311", - "312", - "313", - "314", - "315", - "316", - "317", - "318", - "319", - "320", - "321", - "322", - "323", - "324", - "325", - "326", - "327", - "328", - "329", - "330", - "331", - "332", - "333", - "334", - "335", - "336", - "337", - "338", - "339", - "340", - "341", - "342", - "343", - "344", - "345", - "346", - "347", - "348", - "349", - "350", - "351", - "352", - "353", - "354", - "355", - "356", - "357", - "358", - "359", - "360", - "361", - "362", - "363", - "364", - "365", - "366", - "367", - "368", - "369", - "370", - "371", - "372", - "373", - "374", - "375", - "376", - "377", - "378", - "379", - "380", - "381", - "382", - "383", - "384", - "385", - "386", - "387", - "388", - "389", - "390", - "391", - "392", - "393", - "394", - "395", - "396", - "397", - "398", - "399", - "400", - "401", - "402", - "403", - "404", - "405", - "406", - "407", - "408", - "409", - "410", - "411", - "412", - "413", - "414", - "415", - "416", - "417", - "418", - "419", - "420", - "421", "422", "423", - "424", - "425", - "426", - "427", - "428", - "429", - "430", - "431", - "432", - "433", "434", "435", - "436", - "437", - "438", - "439", - "440", - "441", - "442", - "443", - "444", - "445", "446", "447", - "448", - "449", - "450", - "451", - "452", - "453", - "454", - "455", - "456", - "457", "458", "459", - "460", - "461", - "462", - "463", - "464", - "465", - "466", - "467", - "468", - "469", "470", "471", - "472", - "473", - "474", - "475", - "476", - "477", - "478", - "479", - "480", - "481", "482", "483", "484", @@ -497,30 +47,6 @@ "495", "496", "497", - "498", - "499", - "500", - "502", - "503", - "505", - "506", - "508", - "509", - "511", - "512", - "514", - "515", - "517", - "518", - "520", - "521", - "523", - "524", - "526", - "527", - "529", - "530", - "532", - "533" + "498" ] } diff --git a/parser/testdata/parse/postgres_regress/oid.metadata.json b/parser/testdata/parse/postgres_regress/oid.metadata.json index 9057780..6120e61 100644 --- a/parser/testdata/parse/postgres_regress/oid.metadata.json +++ b/parser/testdata/parse/postgres_regress/oid.metadata.json @@ -1,24 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", "037" ] } diff --git a/parser/testdata/parse/postgres_regress/partition_aggregate.metadata.json b/parser/testdata/parse/postgres_regress/partition_aggregate.metadata.json index 2fd978c..17198fe 100644 --- a/parser/testdata/parse/postgres_regress/partition_aggregate.metadata.json +++ b/parser/testdata/parse/postgres_regress/partition_aggregate.metadata.json @@ -8,7 +8,6 @@ "006", "007", "008", - "009", "010", "011", "013", @@ -34,8 +33,6 @@ "040", "041", "042", - "043", - "044", "045", "046", "047", @@ -54,7 +51,6 @@ "069", "070", "071", - "072", "073", "074", "076", @@ -69,7 +65,6 @@ "087", "088", "089", - "090", "091", "092", "093", @@ -89,7 +84,6 @@ "114", "115", "116", - "117", "118", "119", "121", diff --git a/parser/testdata/parse/postgres_regress/partition_join.metadata.json b/parser/testdata/parse/postgres_regress/partition_join.metadata.json index 19820db..c1d1356 100644 --- a/parser/testdata/parse/postgres_regress/partition_join.metadata.json +++ b/parser/testdata/parse/postgres_regress/partition_join.metadata.json @@ -5,7 +5,6 @@ "003", "004", "005", - "006", "007", "008", "009", @@ -14,7 +13,6 @@ "012", "013", "014", - "015", "016", "017", "018", @@ -44,7 +42,6 @@ "057", "058", "059", - "060", "061", "062", "063", @@ -53,7 +50,6 @@ "066", "067", "068", - "069", "070", "071", "073", @@ -76,32 +72,27 @@ "102", "103", "104", - "105", "106", "107", "108", "109", "110", - "111", "112", "113", "115", "116", "117", "118", - "119", "120", "121", "122", "123", "124", - "125", "126", "127", "128", "129", "130", - "131", "132", "133", "135", @@ -112,19 +103,16 @@ "140", "141", "142", - "143", "144", "145", "146", "147", "148", - "149", "150", "151", "152", "153", "154", - "155", "156", "157", "159", @@ -149,7 +137,6 @@ "178", "179", "180", - "181", "182", "183", "184", @@ -159,7 +146,6 @@ "188", "189", "190", - "191", "192", "193", "195", @@ -173,24 +159,20 @@ "208", "209", "210", - "211", "212", "213", "214", "215", - "216", "217", "218", "219", "220", "221", - "222", "223", "224", "225", "226", "227", - "228", "229", "230", "231", @@ -209,8 +191,6 @@ "244", "245", "246", - "247", - "248", "249", "250", "251", @@ -222,16 +202,12 @@ "259", "260", "261", - "262", "263", "264", "265", "266", "267", "268", - "269", - "270", - "271", "272", "273", "275", @@ -239,7 +215,6 @@ "279", "281", "283", - "284", "285", "286", "288", @@ -253,7 +228,6 @@ "300", "301", "302", - "303", "304", "305", "306", @@ -285,7 +259,6 @@ "333", "334", "335", - "336", "337", "338", "340", @@ -296,13 +269,11 @@ "345", "346", "347", - "348", "349", "350", "351", "352", "353", - "354", "355", "356", "358", @@ -317,13 +288,11 @@ "368", "369", "370", - "371", "372", "373", "374", "375", "376", - "377", "378", "379", "381", @@ -331,7 +300,6 @@ "385", "387", "389", - "390", "391", "392", "394", @@ -344,7 +312,6 @@ "404", "405", "406", - "407", "408", "409", "410", @@ -356,13 +323,9 @@ "416", "417", "418", - "419", - "420", "421", "422", "423", - "424", - "425", "426", "427", "429", @@ -372,7 +335,6 @@ "437", "438", "439", - "440", "441", "442", "443", @@ -381,7 +343,6 @@ "447", "448", "449", - "450", "451", "452", "454", @@ -398,7 +359,6 @@ "468", "470", "471", - "472", "473", "474", "475", @@ -411,18 +371,14 @@ "482", "483", "484", - "485", "486", "487", "489", "490", - "491", - "492", "493", "494", "496", "497", - "498", "499", "500", "502", @@ -433,16 +389,12 @@ "507", "508", "509", - "510", - "511", "512", "513", "514", "515", "516", "517", - "518", - "519", "520", "521", "523", @@ -457,17 +409,14 @@ "535", "536", "537", - "538", "539", "540", "541", "542", - "543", "544", "545", "546", "547", - "548", "549", "550", "552", @@ -482,8 +431,6 @@ "561", "562", "563", - "564", - "565", "566", "567", "568", @@ -494,12 +441,6 @@ "573", "574", "575", - "576", - "577", - "578", - "579", - "580", - "581", "582", "583", "585", @@ -507,7 +448,6 @@ "589", "590", "591", - "592", "593", "594", "595", diff --git a/parser/testdata/parse/postgres_regress/partition_prune.metadata.json b/parser/testdata/parse/postgres_regress/partition_prune.metadata.json index fa2aec9..401e2f4 100644 --- a/parser/testdata/parse/postgres_regress/partition_prune.metadata.json +++ b/parser/testdata/parse/postgres_regress/partition_prune.metadata.json @@ -131,7 +131,6 @@ "129", "130", "131", - "132", "133", "134", "135", @@ -140,9 +139,7 @@ "138", "139", "140", - "149", "150", - "151", "152", "153", "154", @@ -154,7 +151,6 @@ "164", "165", "166", - "167", "168", "169", "170", @@ -163,9 +159,7 @@ "173", "174", "175", - "184", "185", - "186", "190", "191", "192", @@ -200,7 +194,6 @@ "221", "222", "223", - "224", "225", "226", "227", @@ -248,12 +241,6 @@ "269", "270", "271", - "272", - "273", - "274", - "275", - "276", - "277", "279", "280", "281", @@ -288,34 +275,23 @@ "310", "311", "312", - "313", "314", "315", - "316", - "317", "318", "319", - "320", "321", - "322", "323", "324", "325", "326", - "327", "328", - "329", "330", "331", "332", "333", "334", "335", - "336", "337", - "338", - "339", - "340", "341", "342", "343", @@ -325,15 +301,11 @@ "347", "348", "349", - "350", "351", "352", "353", "354", - "356", "361", - "362", - "363", "364", "365", "366", @@ -347,8 +319,6 @@ "374", "375", "376", - "379", - "382", "384", "385", "386", @@ -360,28 +330,16 @@ "392", "393", "394", - "395", "396", "397", - "398", "399", - "400", "401", "402", - "403", - "404", - "405", - "406", - "407", - "408", - "409", "410", "412", - "413", "414", "416", "417", - "418", "419", "420", "421", @@ -395,19 +353,13 @@ "429", "430", "431", - "432", "433", "434", "435", "436", - "439", "440", "441", - "444", - "445", "446", - "448", - "449", "450", "452", "453", @@ -417,21 +369,16 @@ "457", "458", "459", - "460", "461", - "462", "463", "464", "465", "466", "467", "468", - "470", "471", "472", "473", - "474", - "475", "476", "477", "478", @@ -453,17 +400,11 @@ "494", "495", "496", - "497", "498", - "499", "500", - "501", - "502", "503", - "504", "505", "506", - "507", "508", "509", "510", @@ -476,20 +417,12 @@ "517", "518", "519", - "520", "521", "522", - "523", "524", - "525", "526", - "527", "528", - "529", - "530", - "531", "532", - "533", "534", "535", "536", @@ -507,7 +440,6 @@ "548", "549", "550", - "551", "553", "554", "555", @@ -577,11 +509,8 @@ "619", "620", "621", - "622", "623", - "625", "626", - "627", "628", "629", "630", @@ -636,7 +565,6 @@ "681", "682", "683", - "685", "688", "689", "690", diff --git a/parser/testdata/parse/postgres_regress/path.metadata.json b/parser/testdata/parse/postgres_regress/path.metadata.json index 2aa574e..f23fe5c 100644 --- a/parser/testdata/parse/postgres_regress/path.metadata.json +++ b/parser/testdata/parse/postgres_regress/path.metadata.json @@ -1,19 +1,5 @@ { "todo": [ - "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015" + "001" ] } diff --git a/parser/testdata/parse/postgres_regress/pg_lsn.metadata.json b/parser/testdata/parse/postgres_regress/pg_lsn.metadata.json index aaf942e..32a21c3 100644 --- a/parser/testdata/parse/postgres_regress/pg_lsn.metadata.json +++ b/parser/testdata/parse/postgres_regress/pg_lsn.metadata.json @@ -1,13 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", "012", "030" ] diff --git a/parser/testdata/parse/postgres_regress/plancache.metadata.json b/parser/testdata/parse/postgres_regress/plancache.metadata.json index 842dadd..e526209 100644 --- a/parser/testdata/parse/postgres_regress/plancache.metadata.json +++ b/parser/testdata/parse/postgres_regress/plancache.metadata.json @@ -1,27 +1,12 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", "006", - "007", - "008", "009", - "010", - "011", "012", - "013", - "014", "015", - "016", - "017", "018", - "019", - "020", "021", - "022", "023", "027", "028", @@ -29,55 +14,32 @@ "032", "034", "035", - "036", - "037", "038", - "039", - "040", "041", - "043", "044", - "045", "046", "047", "048", "049", - "050", - "051", "052", "053", - "054", "055", "058", "059", "060", "061", - "062", - "063", - "064", "065", - "066", "067", - "068", "069", - "070", "071", - "072", "073", - "074", "075", "076", - "077", "079", "080", "082", "083", "085", - "086", - "087", - "088", - "089", - "091", "093", "094", "095", diff --git a/parser/testdata/parse/postgres_regress/plpgsql.metadata.json b/parser/testdata/parse/postgres_regress/plpgsql.metadata.json index be86770..df3caff 100644 --- a/parser/testdata/parse/postgres_regress/plpgsql.metadata.json +++ b/parser/testdata/parse/postgres_regress/plpgsql.metadata.json @@ -93,179 +93,6 @@ "091", "092", "093", - "094", - "095", - "096", - "097", - "098", - "099", - "100", - "101", - "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", - "110", - "111", - "112", - "113", - "114", - "115", - "116", - "117", - "118", - "119", - "120", - "121", - "122", - "123", - "124", - "125", - "126", - "127", - "128", - "129", - "130", - "131", - "132", - "133", - "134", - "135", - "136", - "137", - "138", - "139", - "140", - "141", - "142", - "143", - "144", - "145", - "146", - "147", - "148", - "149", - "150", - "151", - "152", - "153", - "154", - "155", - "156", - "157", - "158", - "159", - "160", - "161", - "162", - "163", - "164", - "165", - "166", - "167", - "168", - "169", - "170", - "171", - "172", - "173", - "174", - "175", - "176", - "177", - "178", - "179", - "180", - "181", - "182", - "183", - "184", - "185", - "186", - "187", - "188", - "189", - "190", - "191", - "192", - "193", - "194", - "195", - "196", - "197", - "198", - "199", - "200", - "201", - "202", - "203", - "204", - "207", - "210", - "213", - "214", - "217", - "220", - "223", - "224", - "225", - "226", - "227", - "228", - "229", - "230", - "231", - "232", - "233", - "234", - "235", - "236", - "239", - "240", - "241", - "242", - "243", - "244", - "245", - "246", - "247", - "248", - "249", - "250", - "251", - "252", - "253", - "254", - "255", - "256", - "257", - "258", - "259", - "260", - "261", - "262", - "263", - "264", - "265", - "266", - "267", - "268", - "269", - "270", - "273", - "274", - "275", - "276", - "277", - "278", - "279", - "280", - "281", - "282", "283", "285", "286", @@ -314,21 +141,16 @@ "368", "369", "370", - "371", "374", "380", "381", "382", - "383", "384", "385", "387", "388", "389", - "391", - "393", "394", - "395", "396", "398", "400", @@ -370,7 +192,6 @@ "452", "453", "455", - "456", "457", "459", "461", @@ -425,7 +246,6 @@ "533", "534", "535", - "536", "537", "538", "539", @@ -459,7 +279,6 @@ "584", "586", "587", - "588", "589", "591", "593", @@ -641,11 +460,8 @@ "875", "876", "877", - "878", - "879", "880", "881", - "882", "883", "884", "885", @@ -656,48 +472,27 @@ "890", "891", "892", - "893", "894", - "895", "896", - "897", - "898", "899", - "900", "901", "902", "903", - "904", "905", - "906", - "907", - "908", - "909", - "910", - "911", - "913", "915", "916", "917", "918", - "919", - "920", "921", - "922", "923", - "924", "925", - "926", "927", "928", - "929", "930", "931", "932", "933", "934", - "935", - "936", "937", "939", "941" diff --git a/parser/testdata/parse/postgres_regress/point.metadata.json b/parser/testdata/parse/postgres_regress/point.metadata.json index a146079..601ff32 100644 --- a/parser/testdata/parse/postgres_regress/point.metadata.json +++ b/parser/testdata/parse/postgres_regress/point.metadata.json @@ -1,15 +1,8 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", "023", - "024", "025", - "026", "027", "028", "029", diff --git a/parser/testdata/parse/postgres_regress/polygon.metadata.json b/parser/testdata/parse/postgres_regress/polygon.metadata.json index ef55208..2a0e491 100644 --- a/parser/testdata/parse/postgres_regress/polygon.metadata.json +++ b/parser/testdata/parse/postgres_regress/polygon.metadata.json @@ -1,22 +1,7 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", "015", - "016", - "017", - "018", "019", "020", "021", diff --git a/parser/testdata/parse/postgres_regress/polymorphism.metadata.json b/parser/testdata/parse/postgres_regress/polymorphism.metadata.json index 13c415d..33e17fc 100644 --- a/parser/testdata/parse/postgres_regress/polymorphism.metadata.json +++ b/parser/testdata/parse/postgres_regress/polymorphism.metadata.json @@ -108,14 +108,6 @@ "137", "138", "139", - "140", - "141", - "142", - "143", - "144", - "145", - "146", - "147", "172", "173", "176", diff --git a/parser/testdata/parse/postgres_regress/portals.metadata.json b/parser/testdata/parse/postgres_regress/portals.metadata.json index 0450592..c9de67f 100644 --- a/parser/testdata/parse/postgres_regress/portals.metadata.json +++ b/parser/testdata/parse/postgres_regress/portals.metadata.json @@ -1,318 +1,98 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", - "055", - "056", - "057", - "058", - "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", - "069", - "070", - "071", - "072", - "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", - "082", "084", "086", - "087", - "088", - "089", "090", "091", - "092", - "093", - "094", - "095", "096", "098", - "099", - "100", - "101", "102", - "103", - "104", - "105", - "107", "108", - "109", - "110", - "111", "112", - "113", - "114", - "115", - "117", "118", - "119", "120", - "121", "122", "123", - "125", "126", "127", "128", "129", "130", - "131", - "132", - "133", - "134", "135", "136", - "137", - "138", - "139", "140", - "141", - "142", "143", "144", "145", - "147", "149", - "150", - "151", - "153", "155", - "156", - "157", - "159", "161", "162", - "163", "165", - "166", - "167", - "168", - "170", - "171", - "172", "173", "175", - "176", - "177", - "178", "180", "182", - "183", - "184", - "185", - "187", - "189", - "190", - "192", - "194", - "196", "197", "199", - "200", - "201", - "202", - "204", - "206", - "208", - "210", - "212", "213", "215", - "216", - "217", - "218", - "219", - "220", "221", - "223", "224", - "225", "227", - "228", - "229", - "230", - "231", - "232", - "233", - "234", - "235", "236", "238", - "239", - "240", - "241", "242", "243", - "244", - "245", - "246", "247", "248", - "249", - "250", - "251", "253", - "254", - "255", - "256", "257", - "258", - "259", "260", "261", - "262", - "263", "264", "265", - "266", - "267", "268", "269", - "270", - "271", "272", "273", - "274", - "275", "276", "277", - "278", "279", "280", "281", "282", - "283", - "284", - "285", "286", "287", "288", - "289", - "290", - "291", "293", "294", "295", "296", "297", - "298", - "299", - "300", - "301", - "302", - "303", - "304", - "305", - "306", "308", "309", "310", "311", - "312", - "313", - "314", - "315", "316", "317", "318", "319", - "320", - "321", - "322", - "323", "324", "325", "326", "327", - "328", - "329", - "330", "331", "332", "333", "334", - "335", - "336", - "337", "338", "339", "340", "341", - "342", - "343", - "344", - "345", "346", "347", - "348", "349" ] } diff --git a/parser/testdata/parse/postgres_regress/portals_p2.metadata.json b/parser/testdata/parse/postgres_regress/portals_p2.metadata.json index 66f0b1d..a9dd67f 100644 --- a/parser/testdata/parse/postgres_regress/portals_p2.metadata.json +++ b/parser/testdata/parse/postgres_regress/portals_p2.metadata.json @@ -1,45 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", "041" ] } diff --git a/parser/testdata/parse/postgres_regress/predicate.metadata.json b/parser/testdata/parse/postgres_regress/predicate.metadata.json index 3a967e4..7ea3a46 100644 --- a/parser/testdata/parse/postgres_regress/predicate.metadata.json +++ b/parser/testdata/parse/postgres_regress/predicate.metadata.json @@ -30,10 +30,6 @@ "028", "029", "030", - "031", - "032", - "033", - "034", "035", "036", "037", diff --git a/parser/testdata/parse/postgres_regress/prepare.metadata.json b/parser/testdata/parse/postgres_regress/prepare.metadata.json index 5e73844..27febf1 100644 --- a/parser/testdata/parse/postgres_regress/prepare.metadata.json +++ b/parser/testdata/parse/postgres_regress/prepare.metadata.json @@ -1,28 +1,6 @@ { "todo": [ - "002", - "003", - "005", - "006", - "007", - "008", - "009", - "011", - "013", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", - "023", "024", - "026", - "028", - "029", - "030", - "032" + "026" ] } diff --git a/parser/testdata/parse/postgres_regress/prepared_xacts.metadata.json b/parser/testdata/parse/postgres_regress/prepared_xacts.metadata.json index cb68778..2d12b82 100644 --- a/parser/testdata/parse/postgres_regress/prepared_xacts.metadata.json +++ b/parser/testdata/parse/postgres_regress/prepared_xacts.metadata.json @@ -1,27 +1,20 @@ { "todo": [ "001", - "002", "003", - "004", "006", "009", "012", - "013", "015", "017", "019", - "020", "022", "024", - "025", "026", "028", "030", - "031", "033", "035", - "037", "038", "040", "042", @@ -29,23 +22,15 @@ "046", "047", "048", - "049", "050", - "051", "052", "053", - "054", "055", "056", "057", "058", "059", - "060", - "061", - "062", - "063", "064", - "065", "068", "069", "070", diff --git a/parser/testdata/parse/postgres_regress/privileges.metadata.json b/parser/testdata/parse/postgres_regress/privileges.metadata.json index bc5e1f7..2fc3d78 100644 --- a/parser/testdata/parse/postgres_regress/privileges.metadata.json +++ b/parser/testdata/parse/postgres_regress/privileges.metadata.json @@ -133,9 +133,6 @@ "144", "145", "147", - "149", - "150", - "151", "152", "153", "154", @@ -150,17 +147,10 @@ "165", "166", "167", - "171", - "172", - "173", - "174", - "175", - "178", "179", "180", "181", "182", - "183", "184", "187", "188", @@ -200,23 +190,19 @@ "222", "223", "224", - "226", "227", "228", "229", "230", "231", - "232", "233", "234", "235", "236", - "237", "238", "239", "240", "241", - "242", "243", "244", "245", @@ -236,24 +222,12 @@ "272", "273", "274", - "275", "276", - "279", - "281", - "283", "315", "316", "317", "319", "320", - "321", - "323", - "324", - "325", - "327", - "328", - "329", - "330", - "331" + "321" ] } diff --git a/parser/testdata/parse/postgres_regress/psql.metadata.json b/parser/testdata/parse/postgres_regress/psql.metadata.json index e83fbdb..6cd28c5 100644 --- a/parser/testdata/parse/postgres_regress/psql.metadata.json +++ b/parser/testdata/parse/postgres_regress/psql.metadata.json @@ -1,96 +1,11 @@ { "todo": [ - "025", "026", "029", "032", "033", "034", "035", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", - "055", - "056", - "057", - "058", - "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", - "069", - "070", - "071", - "072", - "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", - "082", - "083", - "084", - "085", - "086", - "087", - "088", - "089", - "090", - "091", - "092", - "093", - "094", - "095", - "096", - "097", - "098", - "099", - "100", - "101", - "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", - "110", - "111", - "112", - "113", - "114", - "115", - "116", - "117", - "118", - "119", - "120", "121", "123", "124", @@ -107,56 +22,6 @@ "135", "136", "137", - "139", - "140", - "141", - "142", - "143", - "144", - "145", - "146", - "147", - "148", - "149", - "150", - "155", - "156", - "157", - "158", - "159", - "160", - "161", - "162", - "163", - "164", - "165", - "166", - "167", - "168", - "169", - "170", - "171", - "172", - "173", - "174", - "175", - "176", - "177", - "178", - "179", - "180", - "181", - "182", - "183", - "184", - "185", - "186", - "187", - "188", - "189", - "190", - "191", - "192", "193" ] } diff --git a/parser/testdata/parse/postgres_regress/psql_crosstab.metadata.json b/parser/testdata/parse/postgres_regress/psql_crosstab.metadata.json index 4ec0128..088c33a 100644 --- a/parser/testdata/parse/postgres_regress/psql_crosstab.metadata.json +++ b/parser/testdata/parse/postgres_regress/psql_crosstab.metadata.json @@ -2,7 +2,6 @@ "todo": [ "001", "002", - "005", - "006" + "005" ] } diff --git a/parser/testdata/parse/postgres_regress/publication.metadata.json b/parser/testdata/parse/postgres_regress/publication.metadata.json index 242cb20..263dab1 100644 --- a/parser/testdata/parse/postgres_regress/publication.metadata.json +++ b/parser/testdata/parse/postgres_regress/publication.metadata.json @@ -67,16 +67,10 @@ "067", "068", "069", - "070", "071", - "072", - "073", "074", - "075", "076", - "077", "078", - "079", "080", "081", "082", @@ -176,29 +170,19 @@ "176", "177", "178", - "179", "180", - "181", "182", - "183", "184", - "185", "186", - "187", "188", "189", "190", - "191", "192", - "193", "194", "195", "196", - "197", "198", - "199", "200", - "201", "202", "203", "204", @@ -206,29 +190,21 @@ "206", "207", "208", - "209", "210", - "211", "212", - "213", "214", - "215", "216", "217", "218", - "219", "220", "221", - "222", "223", "224", "225", "226", "227", - "228", "229", "230", - "231", "232", "233", "234", @@ -244,7 +220,6 @@ "244", "245", "246", - "247", "248", "249", "250", @@ -254,28 +229,22 @@ "254", "255", "256", - "257", "258", "259", "260", - "261", "262", "263", "264", "265", "266", "267", - "268", "269", - "270", "271", "272", "273", "274", - "275", "276", "277", - "278", "279", "280", "281", @@ -292,23 +261,18 @@ "292", "293", "294", - "295", "296", "297", - "298", "299", "300", "301", - "302", "303", "304", "305", "306", - "307", "308", "309", "310", - "311", "312", "313", "314", @@ -320,9 +284,7 @@ "320", "321", "322", - "323", "324", - "325", "326", "327", "328", @@ -351,29 +313,19 @@ "351", "352", "353", - "354", "355", - "356", "357", - "358", "359", - "360", "361", - "362", "363", "364", "365", - "366", "367", - "368", "369", "370", "371", - "372", "373", - "374", "375", - "376", "377", "378", "379", @@ -381,42 +333,30 @@ "381", "382", "383", - "384", "385", - "386", "387", - "388", "389", - "390", "391", "392", "393", - "394", "395", "396", - "397", "398", "399", "400", "401", "402", - "403", "404", "405", - "406", "407", "408", "409", "410", "411", "412", - "413", - "414", "415", "416", - "417", "418", - "419", "420", "421", "422", @@ -440,11 +380,8 @@ "440", "441", "442", - "443", "444", - "445", "446", - "447", "448", "449", "450", @@ -529,34 +466,21 @@ "529", "530", "531", - "532", - "533", "534", - "535", "536", - "537", "538", "539", "540", "541", - "542", - "543", "544", "545", "546", - "547", - "548", "549", "550", "551", - "552", - "553", "554", "555", "556", - "557", - "558", - "559", "560", "561", "562", @@ -615,10 +539,6 @@ "622", "623", "624", - "625", - "626", - "627", - "628", "629", "630", "631", @@ -627,10 +547,6 @@ "634", "635", "636", - "637", - "638", - "639", - "640", "641", "642", "643", diff --git a/parser/testdata/parse/postgres_regress/rangefuncs.metadata.json b/parser/testdata/parse/postgres_regress/rangefuncs.metadata.json index fbec2bd..ab455db 100644 --- a/parser/testdata/parse/postgres_regress/rangefuncs.metadata.json +++ b/parser/testdata/parse/postgres_regress/rangefuncs.metadata.json @@ -1,9 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", "005", "014", "017", @@ -16,25 +13,8 @@ "035", "038", "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", "054", "061", - "062", - "063", - "064", "065", "068", "070", @@ -170,8 +150,6 @@ "357", "362", "363", - "364", - "365", "366", "367", "370", @@ -179,12 +157,10 @@ "378", "380", "381", - "382", "383", "385", "386", "387", - "388", "389", "391", "392", diff --git a/parser/testdata/parse/postgres_regress/rangetypes.metadata.json b/parser/testdata/parse/postgres_regress/rangetypes.metadata.json index 104b351..dce7b76 100644 --- a/parser/testdata/parse/postgres_regress/rangetypes.metadata.json +++ b/parser/testdata/parse/postgres_regress/rangetypes.metadata.json @@ -2,20 +2,9 @@ "todo": [ "042", "043", - "044", - "045", - "046", - "047", - "048", - "049", "103", "104", "105", - "106", - "107", - "108", - "109", - "110", "114", "115", "116", @@ -31,21 +20,8 @@ "129", "130", "131", - "132", - "133", - "134", - "135", - "136", - "137", "163", "164", - "165", - "166", - "167", - "168", - "169", - "170", - "171", "172", "173", "174", @@ -57,13 +33,6 @@ "220", "241", "242", - "243", - "244", - "245", - "246", - "247", - "248", - "249", "250", "251", "252", @@ -78,23 +47,16 @@ "295", "296", "297", - "298", "299", "301", "302", "304", "305", "306", - "307", - "308", - "309", - "310", - "311", "313", "316", "317", "319", - "320", "322", "323", "324", @@ -116,7 +78,6 @@ "354", "355", "357", - "358", "360", "361", "366", @@ -149,7 +110,6 @@ "400", "401", "402", - "403", "404", "406", "407" diff --git a/parser/testdata/parse/postgres_regress/reloptions.metadata.json b/parser/testdata/parse/postgres_regress/reloptions.metadata.json index 69d9ea7..6b8d7c4 100644 --- a/parser/testdata/parse/postgres_regress/reloptions.metadata.json +++ b/parser/testdata/parse/postgres_regress/reloptions.metadata.json @@ -22,14 +22,11 @@ "023", "025", "027", - "028", "029", "031", "032", - "034", "035", "038", - "040", "041", "043", "044", diff --git a/parser/testdata/parse/postgres_regress/returning.metadata.json b/parser/testdata/parse/postgres_regress/returning.metadata.json index b21e11e..8a183ee 100644 --- a/parser/testdata/parse/postgres_regress/returning.metadata.json +++ b/parser/testdata/parse/postgres_regress/returning.metadata.json @@ -1,55 +1,24 @@ { "todo": [ "001", - "002", - "004", - "006", - "008", - "009", - "010", - "011", - "013", "015", - "016", "017", - "020", - "023", - "026", "029", "030", "031", - "032", - "033", "034", "035", - "036", - "037", "040", - "041", - "042", "045", - "046", - "047", "050", - "051", "053", - "054", "056", "057", "058", - "059", "061", "062", "063", - "064", - "065", - "066", "067", - "069", - "070", - "074", - "075", - "076", - "077" + "069" ] } diff --git a/parser/testdata/parse/postgres_regress/rowsecurity.metadata.json b/parser/testdata/parse/postgres_regress/rowsecurity.metadata.json index e8626c7..de7bd30 100644 --- a/parser/testdata/parse/postgres_regress/rowsecurity.metadata.json +++ b/parser/testdata/parse/postgres_regress/rowsecurity.metadata.json @@ -27,13 +27,10 @@ "025", "026", "027", - "028", "029", "030", - "031", "032", "033", - "034", "035", "036", "037", @@ -47,8 +44,6 @@ "052", "055", "056", - "057", - "058", "059", "060", "061", @@ -61,13 +56,8 @@ "072", "073", "074", - "076", "077", - "079", "080", - "081", - "083", - "084", "085", "086", "089", @@ -83,14 +73,11 @@ "107", "108", "109", - "110", "111", "112", - "113", "114", "115", "116", - "117", "118", "119", "120", @@ -118,7 +105,6 @@ "151", "152", "153", - "154", "155", "156", "157", @@ -129,15 +115,10 @@ "165", "166", "168", - "169", - "170", - "171", - "172", "175", "176", "177", "178", - "179", "182", "183", "185", @@ -160,7 +141,6 @@ "212", "213", "214", - "215", "216", "217", "218", @@ -197,9 +177,7 @@ "252", "254", "255", - "256", "257", - "258", "259", "260", "261", @@ -208,7 +186,6 @@ "264", "265", "266", - "268", "269", "270", "271", @@ -222,50 +199,31 @@ "282", "283", "284", - "286", - "287", "288", "289", "290", "292", - "293", "294", - "295", - "296", "297", "298", "299", - "300", "301", "302", "303", - "304", "305", - "306", - "307", - "308", - "309", "310", - "311", "312", - "313", "314", - "315", "316", - "317", "318", - "319", "320", "321", "323", "324", "325", "326", - "327", - "328", "329", "330", - "331", "332", "333", "334", @@ -274,13 +232,8 @@ "337", "338", "339", - "341", - "342", - "343", "344", - "345", "346", - "347", "348", "350", "351", @@ -289,30 +242,16 @@ "354", "355", "356", - "358", - "359", - "360", - "361", - "362", - "363", - "364", - "365", - "366", "367", "368", "369", "370", "371", "372", - "373", - "374", "375", "376", "377", "378", - "379", - "380", - "381", "382", "383", "384", @@ -321,49 +260,27 @@ "387", "388", "390", - "391", - "392", - "393", - "394", - "395", - "396", - "397", - "398", "400", "401", - "402", "403", "404", - "405", - "406", - "407", "408", "409", "410", "411", - "412", - "413", - "414", - "415", - "417", - "418", "419", "420", "422", "423", "424", "425", - "426", "427", "428", "429", "430", "432", - "433", "434", - "435", "436", - "437", "438", "439", "441", @@ -403,7 +320,6 @@ "483", "484", "485", - "486", "487", "488", "490", @@ -462,7 +378,6 @@ "557", "558", "559", - "560", "561", "562", "563", @@ -470,10 +385,7 @@ "565", "566", "567", - "569", "570", - "572", - "573", "574", "575", "576", @@ -493,14 +405,12 @@ "590", "591", "592", - "593", "594", "595", "596", "598", "600", "601", - "602", "604", "606", "607", @@ -512,7 +422,6 @@ "613", "614", "615", - "616", "617", "618", "619", @@ -524,19 +433,13 @@ "625", "626", "627", - "628", "629", "631", - "632", - "633", - "634", - "635", "636", "637", "639", "641", "642", - "643", "644", "646", "647", @@ -546,8 +449,6 @@ "654", "655", "656", - "657", - "658", "659", "662", "663", @@ -573,88 +474,58 @@ "689", "690", "691", - "692", "693", "694", - "695", "696", - "697", "698", "699", - "700", "701", - "702", "703", "704", - "705", "706", - "707", "708", "709", - "710", "711", - "712", "713", "714", "715", "716", "717", "718", - "719", "720", "721", - "722", "723", - "724", "725", "726", - "727", "728", - "729", "730", "731", - "732", "733", - "734", "735", "736", - "737", "738", - "739", "740", "741", "742", - "743", "744", "745", - "746", "747", - "748", "749", "750", - "751", "752", - "753", "754", "755", - "756", "757", - "758", "759", "760", - "761", "762", - "763", "764", "765", - "766", "768", "769", - "770", "771", "772", "773", - "774", "775" ] } diff --git a/parser/testdata/parse/postgres_regress/rowtypes.metadata.json b/parser/testdata/parse/postgres_regress/rowtypes.metadata.json index 490a0ee..b995227 100644 --- a/parser/testdata/parse/postgres_regress/rowtypes.metadata.json +++ b/parser/testdata/parse/postgres_regress/rowtypes.metadata.json @@ -4,28 +4,15 @@ "002", "003", "020", - "021", - "022", "026", - "027", "029", "030", - "032", - "034", - "035", - "036", "038", - "039", - "040", - "042", "061", "063", "065", "067", "069", - "070", - "071", - "072", "073", "074", "075", @@ -33,8 +20,6 @@ "079", "094", "095", - "096", - "097", "099", "113", "116", @@ -53,23 +38,18 @@ "164", "165", "166", - "167", - "168", "170", "171", "172", "173", "174", "175", - "188", "191", "194", "205", "209", "210", - "211", "213", - "214", "216", "218", "220", @@ -80,7 +60,6 @@ "227", "228", "229", - "230", "237" ] } diff --git a/parser/testdata/parse/postgres_regress/rules.metadata.json b/parser/testdata/parse/postgres_regress/rules.metadata.json index 56afadf..8645f17 100644 --- a/parser/testdata/parse/postgres_regress/rules.metadata.json +++ b/parser/testdata/parse/postgres_regress/rules.metadata.json @@ -49,130 +49,6 @@ "047", "048", "049", - "050", - "051", - "052", - "053", - "054", - "055", - "056", - "057", - "058", - "059", - "061", - "063", - "064", - "066", - "067", - "071", - "072", - "074", - "075", - "077", - "080", - "081", - "083", - "085", - "087", - "089", - "090", - "092", - "094", - "096", - "098", - "100", - "101", - "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", - "110", - "111", - "112", - "115", - "117", - "120", - "121", - "122", - "123", - "124", - "125", - "127", - "128", - "129", - "130", - "132", - "133", - "135", - "137", - "138", - "139", - "140", - "141", - "142", - "143", - "144", - "145", - "146", - "152", - "153", - "154", - "155", - "156", - "157", - "158", - "159", - "160", - "161", - "162", - "163", - "164", - "165", - "166", - "167", - "173", - "179", - "185", - "187", - "188", - "189", - "190", - "191", - "192", - "193", - "194", - "195", - "196", - "197", - "199", - "200", - "201", - "202", - "205", - "206", - "207", - "208", - "209", - "210", - "211", - "212", - "213", - "214", - "215", - "216", - "217", - "218", - "219", - "221", - "222", - "223", - "224", - "225", - "226", "229", "230", "231", @@ -183,107 +59,38 @@ "236", "237", "238", - "239", - "240", - "241", - "242", - "243", - "244", - "245", - "246", - "247", - "248", - "249", - "250", - "251", - "252", - "253", - "254", - "260", - "262", - "263", - "265", - "266", - "268", - "269", - "271", - "272", - "274", "275", "276", "277", - "278", - "279", - "280", - "281", - "282", - "283", - "284", - "285", - "286", "289", "290", "291", "292", "293", "294", - "295", - "296", - "297", - "298", - "299", - "300", - "301", - "302", - "303", - "304", - "305", - "306", - "307", - "308", - "309", "312", "313", - "314", "316", "317", "318", "319", "320", "321", - "322", - "323", - "324", - "326", "329", "330", - "331", - "332", - "333", - "336", "340", "341", "342", - "343", - "344", "346", "347", "348", - "349", - "350", "353", "354", "355", "356", - "357", - "358", "359", - "360", "361", "362", - "364", - "366", - "368", "371", "372", "373", @@ -291,32 +98,11 @@ "377", "378", "379", - "380", "381", - "382", "384", "385", "386", - "387", - "388", - "389", - "390", - "391", - "392", - "393", - "394", - "395", - "396", - "397", - "398", - "399", - "400", - "401", - "402", - "403", "404", - "405", - "406", "407", "408", "409", @@ -332,17 +118,8 @@ "419", "420", "421", - "422", - "423", - "424", - "425", - "426", - "427", "428", "429", - "431", - "432", - "433", "435", "436", "437", @@ -352,27 +129,17 @@ "441", "442", "443", - "444", - "445", "449", "450", - "451", "452", - "453", "454", - "455", "456", "457", "461", "462", - "463", "464", - "465", - "466", "469", - "470", "471", - "472", "475", "476", "477", @@ -385,14 +152,11 @@ "484", "485", "486", - "487", - "488", "490", "491", "492", "493", "494", - "495", "497", "498", "499", @@ -411,18 +175,11 @@ "512", "513", "514", - "516", - "517", "519", "520", "522", - "523", "524", - "526", - "528", - "530", "533", - "534", "535", "537", "538", @@ -438,12 +195,9 @@ "562", "563", "564", - "565", - "566", "567", "568", "569", - "570", "571", "572", "573", @@ -455,16 +209,11 @@ "579", "580", "581", - "582", "583", - "584", "585", "586", - "587", "588", - "589", "590", - "591", "594", "595", "596", @@ -474,7 +223,6 @@ "600", "601", "602", - "603", "604", "605", "606", @@ -482,7 +230,6 @@ "608", "609", "610", - "611", "612", "615", "616", diff --git a/parser/testdata/parse/postgres_regress/select.metadata.json b/parser/testdata/parse/postgres_regress/select.metadata.json index 9abc3eb..28aa1ac 100644 --- a/parser/testdata/parse/postgres_regress/select.metadata.json +++ b/parser/testdata/parse/postgres_regress/select.metadata.json @@ -8,9 +8,7 @@ "016", "017", "028", - "029", "031", - "032", "038", "039", "044", diff --git a/parser/testdata/parse/postgres_regress/select_distinct.metadata.json b/parser/testdata/parse/postgres_regress/select_distinct.metadata.json index f744f09..4a190f6 100644 --- a/parser/testdata/parse/postgres_regress/select_distinct.metadata.json +++ b/parser/testdata/parse/postgres_regress/select_distinct.metadata.json @@ -47,10 +47,6 @@ "057", "058", "059", - "060", - "061", - "062", - "063", - "064" + "060" ] } diff --git a/parser/testdata/parse/postgres_regress/select_having.metadata.json b/parser/testdata/parse/postgres_regress/select_having.metadata.json index afa22da..36b740f 100644 --- a/parser/testdata/parse/postgres_regress/select_having.metadata.json +++ b/parser/testdata/parse/postgres_regress/select_having.metadata.json @@ -1,16 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", "023" ] } diff --git a/parser/testdata/parse/postgres_regress/select_implicit.metadata.json b/parser/testdata/parse/postgres_regress/select_implicit.metadata.json index 52dc1f4..b9415e3 100644 --- a/parser/testdata/parse/postgres_regress/select_implicit.metadata.json +++ b/parser/testdata/parse/postgres_regress/select_implicit.metadata.json @@ -1,16 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", "028", "040", "042", diff --git a/parser/testdata/parse/postgres_regress/select_into.metadata.json b/parser/testdata/parse/postgres_regress/select_into.metadata.json index d2164bf..aef44e9 100644 --- a/parser/testdata/parse/postgres_regress/select_into.metadata.json +++ b/parser/testdata/parse/postgres_regress/select_into.metadata.json @@ -8,11 +8,9 @@ "008", "009", "010", - "011", "012", "013", "014", - "015", "016", "017", "018", @@ -21,11 +19,9 @@ "021", "022", "023", - "024", "025", "026", "027", - "028", "029", "030", "031", @@ -41,10 +37,7 @@ "047", "048", "049", - "050", - "051", "053", - "054", "055", "056", "057", @@ -54,7 +47,6 @@ "061", "062", "063", - "064", "065", "066", "067" diff --git a/parser/testdata/parse/postgres_regress/select_parallel.metadata.json b/parser/testdata/parse/postgres_regress/select_parallel.metadata.json index 014db35..a737edd 100644 --- a/parser/testdata/parse/postgres_regress/select_parallel.metadata.json +++ b/parser/testdata/parse/postgres_regress/select_parallel.metadata.json @@ -41,10 +41,7 @@ "046", "048", "049", - "050", "051", - "052", - "053", "054", "055", "057", @@ -88,7 +85,6 @@ "102", "103", "105", - "106", "107", "109", "110", @@ -173,11 +169,7 @@ "203", "204", "205", - "206", - "207", "208", - "209", - "210", "211", "212", "213", @@ -193,11 +185,9 @@ "227", "228", "229", - "230", "231", "232", "233", - "234", "235" ] } diff --git a/parser/testdata/parse/postgres_regress/select_views.metadata.json b/parser/testdata/parse/postgres_regress/select_views.metadata.json index 772a280..27a506f 100644 --- a/parser/testdata/parse/postgres_regress/select_views.metadata.json +++ b/parser/testdata/parse/postgres_regress/select_views.metadata.json @@ -5,9 +5,6 @@ "006", "007", "008", - "009", - "010", - "011", "012", "013", "014", @@ -29,16 +26,10 @@ "036", "038", "040", - "041", - "042", - "043", - "044", "045", "046", "047", "048", - "049", - "050", "051", "052" ] diff --git a/parser/testdata/parse/postgres_regress/sequence.metadata.json b/parser/testdata/parse/postgres_regress/sequence.metadata.json index 27232a8..c8125d5 100644 --- a/parser/testdata/parse/postgres_regress/sequence.metadata.json +++ b/parser/testdata/parse/postgres_regress/sequence.metadata.json @@ -37,21 +37,7 @@ "035", "036", "037", - "038", - "039", - "040", - "041", "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", "061", "062", "075", @@ -60,7 +46,6 @@ "079", "084", "085", - "086", "088", "089", "090", diff --git a/parser/testdata/parse/postgres_regress/spgist.metadata.json b/parser/testdata/parse/postgres_regress/spgist.metadata.json index 60ac70c..bd3d21f 100644 --- a/parser/testdata/parse/postgres_regress/spgist.metadata.json +++ b/parser/testdata/parse/postgres_regress/spgist.metadata.json @@ -2,21 +2,12 @@ "todo": [ "001", "002", - "003", - "004", "005", - "006", - "007", - "008", - "009", "010", "011", - "012", "013", "015", "016", - "017", - "018", "019", "020", "021", @@ -24,10 +15,8 @@ "023", "024", "025", - "026", "027", "029", - "030", - "031" + "030" ] } diff --git a/parser/testdata/parse/postgres_regress/sqljson.metadata.json b/parser/testdata/parse/postgres_regress/sqljson.metadata.json index 00c02bf..26aba7f 100644 --- a/parser/testdata/parse/postgres_regress/sqljson.metadata.json +++ b/parser/testdata/parse/postgres_regress/sqljson.metadata.json @@ -35,7 +35,6 @@ "183", "184", "194", - "195", "200", "201", "202", diff --git a/parser/testdata/parse/postgres_regress/sqljson_jsontable.metadata.json b/parser/testdata/parse/postgres_regress/sqljson_jsontable.metadata.json index 92f697d..86f93ab 100644 --- a/parser/testdata/parse/postgres_regress/sqljson_jsontable.metadata.json +++ b/parser/testdata/parse/postgres_regress/sqljson_jsontable.metadata.json @@ -26,11 +26,9 @@ "067", "073", "091", - "092", "095", "096", "097", - "098", "104", "105", "106", diff --git a/parser/testdata/parse/postgres_regress/sqljson_queryfuncs.metadata.json b/parser/testdata/parse/postgres_regress/sqljson_queryfuncs.metadata.json index cec7a0c..d905161 100644 --- a/parser/testdata/parse/postgres_regress/sqljson_queryfuncs.metadata.json +++ b/parser/testdata/parse/postgres_regress/sqljson_queryfuncs.metadata.json @@ -11,12 +11,6 @@ "181", "182", "200", - "203", - "204", - "205", - "206", - "207", - "208", "209", "210", "211", diff --git a/parser/testdata/parse/postgres_regress/stats.metadata.json b/parser/testdata/parse/postgres_regress/stats.metadata.json index f5298e7..cab46d0 100644 --- a/parser/testdata/parse/postgres_regress/stats.metadata.json +++ b/parser/testdata/parse/postgres_regress/stats.metadata.json @@ -14,44 +14,22 @@ "013", "014", "015", - "016", - "017", - "018", "019", - "020", - "021", - "022", - "023", - "024", "025", - "026", "027", - "028", "029", "030", - "031", - "032", "033", - "034", "035", - "036", "037", "038", "039", - "040", - "041", "042", - "043", - "044", "045", - "046", "047", "048", "049", - "050", - "051", "052", - "053", "054", "056", "058", @@ -81,24 +59,17 @@ "113", "114", "117", - "118", "120", - "121", "123", - "124", "128", "134", - "135", "137", "139", "145", - "146", "148", "150", "155", - "156", "157", - "158", "160", "161", "162", @@ -119,7 +90,6 @@ "184", "185", "186", - "187", "190", "193", "194", @@ -178,7 +148,6 @@ "343", "345", "350", - "351", "355", "356", "361", @@ -194,40 +163,31 @@ "380", "381", "382", - "384", "391", "395", "396", "398", - "399", "400", "401", "406", "408", "417", - "418", "419", "420", - "421", "424", "425", "426", - "427", "428", - "429", "430", "432", "433", "435", "436", - "437", "438", - "439", "440", "442", "443", "444", - "445", "447" ] } diff --git a/parser/testdata/parse/postgres_regress/stats_ext.metadata.json b/parser/testdata/parse/postgres_regress/stats_ext.metadata.json index 20c5ce1..726a504 100644 --- a/parser/testdata/parse/postgres_regress/stats_ext.metadata.json +++ b/parser/testdata/parse/postgres_regress/stats_ext.metadata.json @@ -51,7 +51,6 @@ "052", "054", "055", - "056", "057", "058", "059", @@ -65,23 +64,18 @@ "068", "069", "070", - "071", "072", "073", "074", "075", "076", "077", - "078", - "079", - "080", "081", "084", "085", "090", "091", "092", - "093", "094", "095", "099", @@ -92,7 +86,6 @@ "106", "107", "108", - "109", "110", "112", "113", @@ -120,12 +113,10 @@ "135", "136", "137", - "138", "139", "149", "150", "162", - "163", "164", "175", "189", @@ -135,7 +126,6 @@ "200", "205", "206", - "207", "208", "216", "217", @@ -159,19 +149,16 @@ "270", "271", "272", - "273", "274", "277", "278", "281", "282", - "283", "284", "287", "288", "291", "292", - "293", "294", "320", "321", @@ -181,26 +168,22 @@ "378", "379", "406", - "407", "408", "414", "415", "416", "422", "423", - "424", "425", "428", "429", "432", "433", - "434", "435", "438", "439", "442", "443", - "444", "445", "470", "471", @@ -209,7 +192,6 @@ "501", "503", "504", - "505", "506", "517", "518", @@ -222,76 +204,61 @@ "535", "547", "548", - "549", "550", "556", "557", "563", - "564", "565", "567", "568", - "569", "570", "574", "575", "580", - "581", "582", "585", "586", "589", "590", - "591", "592", "593", "594", - "595", "596", "601", "602", "607", - "608", - "609", - "610", "611", "620", "621", "630", "631", - "632", "633", "641", "642", "643", "651", "652", - "653", "654", "657", "658", "661", "662", "663", - "664", "665", "669", "670", "674", "675", - "676", "677", "679", "680", "682", "683", "684", - "685", "686", "688", "689", "690", - "691", "692", "693", "694", @@ -306,7 +273,6 @@ "703", "704", "705", - "706", "707", "708", "709", @@ -330,32 +296,26 @@ "729", "730", "731", - "734", "735", "736", "737", "738", - "741", "742", "743", "744", "745", "746", - "749", "750", "751", "752", "753", - "756", "757", "758", "759", "760", "761", - "764", "765", "766", - "767", "768", "769", "770", diff --git a/parser/testdata/parse/postgres_regress/subselect.metadata.json b/parser/testdata/parse/postgres_regress/subselect.metadata.json index fa5a5df..a9d0cea 100644 --- a/parser/testdata/parse/postgres_regress/subselect.metadata.json +++ b/parser/testdata/parse/postgres_regress/subselect.metadata.json @@ -1,14 +1,6 @@ { "todo": [ "014", - "015", - "016", - "017", - "018", - "019", - "020", - "021", - "022", "032", "034", "040", @@ -23,74 +15,30 @@ "054", "059", "060", - "061", - "062", - "063", - "064", "071", - "072", - "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", - "082", "083", "085", "086", "087", "088", "089", - "090", - "091", "093", - "094", "099", - "100", "101", - "102", "105", - "106", - "107", "108", - "109", - "110", - "111", - "112", "113", - "114", - "115", "117", "119", - "120", "121", "126", "130", - "131", "132", "134", - "135", - "136", - "138", "139", - "140", - "141", - "142", - "143", "144", - "145", "147", - "148", - "149", - "150", - "151", "152", - "153", - "154", "156", "158", "162", @@ -107,7 +55,6 @@ "178", "179", "180", - "181", "182", "183", "186", @@ -119,7 +66,6 @@ "194", "196", "197", - "198", "200", "203", "205", @@ -133,18 +79,13 @@ "221", "223", "224", - "225", "226", "229", "230", "231", - "232", - "233", - "234", "235", "236", "237", - "238", "239", "241", "242", diff --git a/parser/testdata/parse/postgres_regress/sysviews.metadata.json b/parser/testdata/parse/postgres_regress/sysviews.metadata.json index 06e70ed..84504bc 100644 --- a/parser/testdata/parse/postgres_regress/sysviews.metadata.json +++ b/parser/testdata/parse/postgres_regress/sysviews.metadata.json @@ -1,8 +1,6 @@ { "todo": [ "004", - "005", - "006", "008", "024", "026" diff --git a/parser/testdata/parse/postgres_regress/tablesample.metadata.json b/parser/testdata/parse/postgres_regress/tablesample.metadata.json index 2727d5e..9805f86 100644 --- a/parser/testdata/parse/postgres_regress/tablesample.metadata.json +++ b/parser/testdata/parse/postgres_regress/tablesample.metadata.json @@ -1,30 +1,14 @@ { "todo": [ "001", - "002", "011", "012", "013", - "014", - "015", - "016", - "017", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", "029", "030", "031", "032", "038", - "049", "052", "053", "054", diff --git a/parser/testdata/parse/postgres_regress/tablespace.metadata.json b/parser/testdata/parse/postgres_regress/tablespace.metadata.json index 252c4c8..0fc6a12 100644 --- a/parser/testdata/parse/postgres_regress/tablespace.metadata.json +++ b/parser/testdata/parse/postgres_regress/tablespace.metadata.json @@ -21,7 +21,6 @@ "021", "022", "023", - "024", "025", "026", "027", @@ -54,10 +53,7 @@ "065", "066", "067", - "069", - "070", "071", - "073", "074", "076", "078", @@ -94,7 +90,6 @@ "111", "112", "113", - "114", "115", "116", "117", @@ -108,7 +103,6 @@ "127", "128", "129", - "130", "131", "132", "133", @@ -121,7 +115,6 @@ "142", "143", "144", - "145", "146", "147", "148", @@ -142,8 +135,6 @@ "164", "165", "166", - "167", - "168", "170", "171", "172", diff --git a/parser/testdata/parse/postgres_regress/temp.metadata.json b/parser/testdata/parse/postgres_regress/temp.metadata.json index e7f7107..f0a7ea2 100644 --- a/parser/testdata/parse/postgres_regress/temp.metadata.json +++ b/parser/testdata/parse/postgres_regress/temp.metadata.json @@ -9,17 +9,13 @@ "009", "010", "011", - "012", "013", - "014", "016", "018", "019", "021", "022", "023", - "024", - "025", "027", "029", "030", @@ -28,8 +24,6 @@ "035", "036", "037", - "038", - "039", "041", "043", "044", @@ -42,17 +36,13 @@ "055", "056", "057", - "058", - "059", "060", "063", "064", "065", "066", "067", - "068", "069", - "070", "071", "072", "075", @@ -64,32 +54,26 @@ "089", "090", "091", - "092", "093", "095", "096", "097", "098", "099", - "100", "101", "103", "104", "105", "106", - "107", "108", "111", "112", "113", "114", - "115", "116", "118", "119", "120", - "121", - "122", "123", "126", "127", @@ -115,7 +99,6 @@ "147", "149", "150", - "151", "152", "153", "154", diff --git a/parser/testdata/parse/postgres_regress/test_setup.metadata.json b/parser/testdata/parse/postgres_regress/test_setup.metadata.json index abfc1a2..10ce81c 100644 --- a/parser/testdata/parse/postgres_regress/test_setup.metadata.json +++ b/parser/testdata/parse/postgres_regress/test_setup.metadata.json @@ -5,58 +5,41 @@ "003", "004", "005", - "006", "007", "008", - "009", "010", "011", - "012", "013", "014", - "015", "016", "017", - "018", "019", "020", - "021", "022", - "023", "024", "025", - "026", "027", "028", - "029", "030", "031", "032", "033", - "034", "035", "036", "037", "038", - "039", "040", "041", - "042", "043", "044", - "045", "046", "047", - "048", "049", "050", - "051", "052", "053", - "054", "055", "056", - "057", "058", "059", "060", diff --git a/parser/testdata/parse/postgres_regress/tid.metadata.json b/parser/testdata/parse/postgres_regress/tid.metadata.json index a58fbb0..9b7b7f5 100644 --- a/parser/testdata/parse/postgres_regress/tid.metadata.json +++ b/parser/testdata/parse/postgres_regress/tid.metadata.json @@ -1,10 +1,8 @@ { "todo": [ "008", - "009", "012", "013", - "015", "016", "018", "019", @@ -17,7 +15,6 @@ "029", "031", "032", - "034", "036", "037", "038", diff --git a/parser/testdata/parse/postgres_regress/tidrangescan.metadata.json b/parser/testdata/parse/postgres_regress/tidrangescan.metadata.json index e741d6a..e467198 100644 --- a/parser/testdata/parse/postgres_regress/tidrangescan.metadata.json +++ b/parser/testdata/parse/postgres_regress/tidrangescan.metadata.json @@ -4,8 +4,6 @@ "002", "003", "005", - "007", - "008", "009", "010", "012", @@ -19,12 +17,6 @@ "033", "035", "036", - "037", - "038", - "039", - "040", - "041", - "042", "043", "044", "045" diff --git a/parser/testdata/parse/postgres_regress/tidscan.metadata.json b/parser/testdata/parse/postgres_regress/tidscan.metadata.json index ac36ec6..96b2f81 100644 --- a/parser/testdata/parse/postgres_regress/tidscan.metadata.json +++ b/parser/testdata/parse/postgres_regress/tidscan.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "001", - "002", "004", "006", "008", @@ -13,19 +12,10 @@ "019", "021", "022", - "023", - "024", - "025", - "026", "027", "028", - "029", - "030", - "031", "032", - "033", "034", - "036", "037", "038", "039", diff --git a/parser/testdata/parse/postgres_regress/time.metadata.json b/parser/testdata/parse/postgres_regress/time.metadata.json index bf73c3a..f23fe5c 100644 --- a/parser/testdata/parse/postgres_regress/time.metadata.json +++ b/parser/testdata/parse/postgres_regress/time.metadata.json @@ -1,16 +1,5 @@ { "todo": [ - "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012" + "001" ] } diff --git a/parser/testdata/parse/postgres_regress/timestamp.metadata.json b/parser/testdata/parse/postgres_regress/timestamp.metadata.json index b93047b..72b72dd 100644 --- a/parser/testdata/parse/postgres_regress/timestamp.metadata.json +++ b/parser/testdata/parse/postgres_regress/timestamp.metadata.json @@ -2,89 +2,11 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", "011", - "012", - "013", "015", - "016", - "018", "022", "023", - "024", - "025", - "026", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", "055", - "056", - "057", - "058", - "059", - "060", - "061", - "067", - "068", - "069", - "070", - "071", - "072", - "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", - "082", - "083", - "084", - "085", - "086", - "087", - "088", - "089", - "090", - "091", - "092", - "093", - "094", - "095", - "096", - "097", - "098", - "099", - "100" + "058" ] } diff --git a/parser/testdata/parse/postgres_regress/timestamptz.metadata.json b/parser/testdata/parse/postgres_regress/timestamptz.metadata.json index f7e3721..40d874f 100644 --- a/parser/testdata/parse/postgres_regress/timestamptz.metadata.json +++ b/parser/testdata/parse/postgres_regress/timestamptz.metadata.json @@ -2,91 +2,12 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", "013", - "014", - "015", "017", - "018", - "020", "024", "025", - "026", - "027", - "028", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "050", - "051", - "052", - "053", - "054", - "055", - "056", "057", - "058", - "059", "060", - "061", - "062", - "064", - "066", - "077", - "078", - "079", - "080", - "081", - "082", - "083", - "084", - "085", - "086", - "087", - "088", - "089", - "090", - "091", - "092", - "093", - "094", - "095", - "096", - "097", - "098", - "099", - "100", - "101", - "102", - "103", - "104", - "105", - "106", - "107", - "108", - "109", - "110", "171", "173", "175", @@ -108,12 +29,6 @@ "206", "208", "209", - "210", - "211", - "212", - "213", - "214", - "215", "217", "218", "237", @@ -130,7 +45,6 @@ "365", "366", "367", - "368", "369" ] } diff --git a/parser/testdata/parse/postgres_regress/timetz.metadata.json b/parser/testdata/parse/postgres_regress/timetz.metadata.json index 97f0ba8..b35a27a 100644 --- a/parser/testdata/parse/postgres_regress/timetz.metadata.json +++ b/parser/testdata/parse/postgres_regress/timetz.metadata.json @@ -1,21 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "015", - "016", "051", "052", "053", diff --git a/parser/testdata/parse/postgres_regress/transactions.metadata.json b/parser/testdata/parse/postgres_regress/transactions.metadata.json index 1c91cc5..8df280b 100644 --- a/parser/testdata/parse/postgres_regress/transactions.metadata.json +++ b/parser/testdata/parse/postgres_regress/transactions.metadata.json @@ -2,12 +2,9 @@ "todo": [ "001", "002", - "003", - "004", "005", "007", "008", - "009", "011", "014", "016", @@ -55,11 +52,6 @@ "066", "067", "068", - "069", - "071", - "072", - "073", - "074", "076", "077", "078", @@ -80,21 +72,16 @@ "093", "094", "099", - "100", "101", - "102", "103", "104", "105", - "106", "107", "108", "109", - "110", "111", "112", "113", - "114", "115", "118", "119", @@ -103,66 +90,41 @@ "123", "124", "125", - "126", "127", - "128", "129", - "130", "131", "132", "133", "135", "136", - "137", "138", "139", - "140", "141", - "142", "143", "144", "146", - "147", "148", - "149", "151", "153", - "154", "155", - "156", "157", - "158", "159", "162", - "163", "164", - "165", "166", - "167", "168", "171", - "172", "173", - "174", "175", - "176", "177", - "178", "179", - "180", "181", - "182", "183", "185", - "186", "187", - "188", "189", - "190", "191", - "192", "193", - "194", "195", "197", "198", @@ -175,92 +137,54 @@ "206", "208", "210", - "211", "212", - "213", "214", - "215", "216", - "217", - "218", - "219", "220", - "221", "222", - "223", "224", "225", - "226", "227", "229", "230", - "231", "233", "234", "235", - "236", "238", "239", "240", - "241", "243", "244", "245", - "246", "248", "249", "250", "251", - "252", - "253", "254", "255", - "256", - "257", "258", "259", "260", "261", "262", "263", - "264", - "265", "266", "267", "268", "269", "270", - "271", - "272", - "273", - "274", "275", - "276", "277", "278", "279", - "280", - "281", - "282", - "283", - "284", "285", - "286", "287", - "288", "289", "290", "291", "292", - "293", - "294", - "295", "296", - "297", - "298", "299", - "300", - "301", "302", "303", "304", @@ -270,31 +194,24 @@ "308", "309", "310", - "311", - "312", "313", "314", "315", "316", - "317", - "318", "319", "320", "321", "322", - "323", "324", "325", "326", "327", "328", "329", - "330", "331", "332", "333", "334", - "335", "336", "337", "338", @@ -320,12 +237,10 @@ "358", "359", "360", - "361", "362", "363", "364", "365", - "366", "367", "368", "369", @@ -336,27 +251,18 @@ "375", "376", "377", - "381", - "383", "387", "388", - "389", "390", "391", "392", - "393", "394", "395", "397", - "398", "399", "401", - "402", "403", - "404", "405", - "406", - "408", "409", "412", "414", @@ -378,43 +284,29 @@ "437", "438", "439", - "440", "441", - "442", "443", - "444", "445", - "446", "447", - "448", "449", - "450", "451", - "452", "453", - "454", "455", "456", - "457", "458", "459", "460", "461", - "462", "463", "464", "465", "466", "467", - "468", "469", - "470", "471", "472", "473", - "474", "475", - "476", "477", "478", "479", diff --git a/parser/testdata/parse/postgres_regress/triggers.metadata.json b/parser/testdata/parse/postgres_regress/triggers.metadata.json index 40f5a5a..6ce3339 100644 --- a/parser/testdata/parse/postgres_regress/triggers.metadata.json +++ b/parser/testdata/parse/postgres_regress/triggers.metadata.json @@ -11,12 +11,6 @@ "009", "010", "011", - "012", - "013", - "014", - "015", - "016", - "017", "018", "019", "020", @@ -26,76 +20,34 @@ "024", "025", "026", - "027", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", "043", "044", "045", "046", "047", - "048", - "050", - "052", "054", "055", - "056", - "058", - "060", "062", - "063", - "065", - "067", "069", - "070", - "072", - "074", "076", "077", "078", - "079", "081", - "083", "085", - "087", "089", "090", "091", "092", "093", - "094", - "095", - "096", - "098", "1000", "1001", "1002", - "1003", - "1004", - "1005", - "1006", "1007", "1008", "1009", - "101", - "1010", "1011", "1012", - "1013", "1014", - "1015", "1016", "1017", "1018", @@ -105,12 +57,9 @@ "1022", "1023", "1024", - "1025", "1026", "1027", - "1028", "1029", - "103", "1030", "1031", "1032", @@ -136,37 +85,22 @@ "1054", "1055", "1056", - "106", - "107", - "109", - "112", - "114", "117", "118", "119", "120", - "121", "122", "123", "124", "125", - "126", "127", - "128", - "129", - "130", "131", - "132", "134", "135", "136", "137", "138", "139", - "141", - "142", - "143", - "144", "149", "152", "153", @@ -175,9 +109,7 @@ "156", "157", "158", - "159", "160", - "161", "162", "163", "164", @@ -185,17 +117,11 @@ "166", "167", "168", - "170", - "171", "172", "173", "174", "175", "176", - "177", - "178", - "179", - "180", "181", "182", "183", @@ -218,64 +144,36 @@ "200", "201", "202", - "203", "204", - "205", "206", - "207", "208", - "209", "210", - "211", "212", - "213", "214", - "215", - "216", - "217", "219", - "220", - "222", "224", "225", "226", "227", "228", - "229", - "230", - "231", "232", "233", "234", "235", "236", "237", - "238", - "239", - "240", - "241", - "242", "243", - "244", - "245", - "246", "247", "248", "249", "250", "251", - "252", "253", "254", - "255", "256", "258", "259", - "260", "261", - "262", - "263", - "264", "266", "267", "268", @@ -302,21 +200,11 @@ "289", "290", "291", - "292", - "293", - "294", - "295", "296", - "297", - "298", - "299", - "300", - "301", "302", "303", "304", "305", - "306", "307", "308", "309", @@ -325,36 +213,12 @@ "312", "313", "314", - "315", - "316", - "317", - "318", - "319", - "320", - "321", - "322", - "323", - "324", - "325", - "326", - "327", - "328", "329", "331", "332", - "333", - "334", - "335", "336", "337", "338", - "339", - "340", - "341", - "342", - "343", - "344", - "345", "347", "348", "349", @@ -366,8 +230,6 @@ "355", "356", "357", - "359", - "361", "363", "364", "365", @@ -382,14 +244,7 @@ "374", "375", "376", - "377", - "378", - "381", - "382", - "385", - "386", "389", - "390", "393", "394", "395", @@ -400,13 +255,6 @@ "400", "401", "402", - "403", - "404", - "405", - "406", - "407", - "408", - "410", "412", "413", "414", @@ -415,16 +263,12 @@ "417", "418", "419", - "420", - "421", "422", "423", "424", "425", "426", - "427", "428", - "429", "430", "431", "432", @@ -432,14 +276,6 @@ "434", "435", "436", - "437", - "438", - "439", - "440", - "441", - "442", - "443", - "444", "446", "447", "448", @@ -516,15 +352,8 @@ "523", "524", "525", - "526", - "527", - "528", - "529", - "530", "531", - "532", "533", - "534", "535", "536", "537", @@ -535,19 +364,15 @@ "542", "543", "544", - "545", "546", "547", "548", "549", - "550", "551", "552", "553", "554", "555", - "556", - "557", "558", "559", "560", @@ -556,7 +381,6 @@ "563", "564", "565", - "566", "567", "568", "569", @@ -570,44 +394,26 @@ "577", "578", "579", - "580", - "581", - "582", "583", "584", "585", "586", "587", - "588", "589", - "590", - "591", "592", - "593", - "594", "595", - "596", - "597", "599", "600", - "601", - "602", "604", "605", "606", - "607", "608", - "609", - "611", "613", "614", "615", "616", "617", "618", - "619", - "620", - "621", "623", "624", "625", @@ -618,14 +424,9 @@ "630", "631", "632", - "633", - "634", - "635", "636", "637", "638", - "639", - "640", "641", "642", "643", @@ -639,8 +440,6 @@ "651", "652", "653", - "654", - "655", "656", "657", "658", @@ -666,9 +465,6 @@ "679", "680", "681", - "682", - "683", - "684", "685", "686", "687", @@ -703,27 +499,16 @@ "725", "726", "727", - "728", "729", - "730", "731", - "732", "733", "734", - "735", "736", "737", - "738", "739", "740", "741", - "742", "744", - "745", - "746", - "747", - "748", - "749", "750", "751", "752", @@ -748,18 +533,6 @@ "771", "772", "773", - "775", - "776", - "777", - "778", - "779", - "780", - "781", - "782", - "783", - "784", - "785", - "786", "787", "788", "789", @@ -771,12 +544,8 @@ "795", "796", "797", - "798", - "799", "800", "801", - "802", - "803", "804", "805", "806", @@ -796,12 +565,8 @@ "820", "821", "822", - "823", - "824", "825", "826", - "827", - "828", "829", "830", "831", @@ -821,20 +586,7 @@ "845", "846", "847", - "848", - "849", - "850", - "851", - "852", - "853", - "854", - "855", - "856", - "857", - "858", - "859", "860", - "861", "862", "863", "864", @@ -846,7 +598,6 @@ "870", "871", "872", - "873", "874", "875", "876", @@ -861,16 +612,11 @@ "885", "886", "887", - "888", - "889", "892", "893", "894", "895", "896", - "897", - "898", - "899", "900", "901", "902", @@ -878,9 +624,6 @@ "904", "905", "906", - "907", - "908", - "909", "910", "911", "912", @@ -891,15 +634,10 @@ "917", "918", "919", - "920", - "921", - "922", - "924", "926", "927", "928", "929", - "930", "931", "932", "933", @@ -907,21 +645,13 @@ "935", "936", "937", - "938", - "939", "940", - "941", - "942", "943", "944", "945", "946", "947", "948", - "949", - "950", - "951", - "952", "953", "954", "955", @@ -931,9 +661,7 @@ "959", "960", "961", - "962", "963", - "964", "966", "967", "968", @@ -941,21 +669,13 @@ "970", "971", "972", - "973", "974", - "975", "976", - "977", "978", - "979", "980", - "981", "982", - "983", "984", - "985", "986", - "987", "988", "989", "990", diff --git a/parser/testdata/parse/postgres_regress/truncate.metadata.json b/parser/testdata/parse/postgres_regress/truncate.metadata.json index f5e413f..fa4974f 100644 --- a/parser/testdata/parse/postgres_regress/truncate.metadata.json +++ b/parser/testdata/parse/postgres_regress/truncate.metadata.json @@ -1,8 +1,6 @@ { "todo": [ "001", - "002", - "003", "005", "006", "007", @@ -25,32 +23,17 @@ "026", "027", "028", - "029", - "030", - "031", - "032", - "033", "034", "035", "036", "037", "038", - "041", - "042", - "043", - "044", - "045", "046", "049", "050", - "051", - "052", "053", - "054", "055", - "056", "057", - "058", "059", "061", "063", @@ -67,12 +50,10 @@ "088", "089", "090", - "091", "092", "095", "098", "099", - "100", "101", "104", "107", @@ -81,34 +62,18 @@ "110", "111", "112", - "113", - "114", "116", - "117", - "118", "120", - "121", - "122", "124", - "125", - "126", "128", - "129", - "130", "132", - "133", - "134", "136", "137", - "138", "140", - "141", - "142", "144", "146", "147", "148", - "149", "150", "151", "152", @@ -133,15 +98,12 @@ "177", "178", "179", - "180", "181", - "182", "183", "185", "186", "187", "188", - "189", "190", "193" ] diff --git a/parser/testdata/parse/postgres_regress/tsearch.metadata.json b/parser/testdata/parse/postgres_regress/tsearch.metadata.json index 96e90e3..7ee8f41 100644 --- a/parser/testdata/parse/postgres_regress/tsearch.metadata.json +++ b/parser/testdata/parse/postgres_regress/tsearch.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "007", - "008", "009", "034", "035", @@ -32,11 +31,8 @@ "180", "182", "184", - "185", "282", - "284", "285", - "286", "292", "293", "299", @@ -46,18 +42,11 @@ "340", "344", "348", - "350", - "352", - "354", "356", "357", "358", "359", - "360", - "361", "367", - "368", - "369", "370", "371", "373" diff --git a/parser/testdata/parse/postgres_regress/tsrf.metadata.json b/parser/testdata/parse/postgres_regress/tsrf.metadata.json index e3d4463..5981a79 100644 --- a/parser/testdata/parse/postgres_regress/tsrf.metadata.json +++ b/parser/testdata/parse/postgres_regress/tsrf.metadata.json @@ -2,7 +2,6 @@ "todo": [ "007", "009", - "010", "011", "013", "019", @@ -11,9 +10,6 @@ "044", "045", "047", - "048", - "050", - "051", "065", "067", "069", diff --git a/parser/testdata/parse/postgres_regress/tuplesort.metadata.json b/parser/testdata/parse/postgres_regress/tuplesort.metadata.json index e4cf5e2..f16dedc 100644 --- a/parser/testdata/parse/postgres_regress/tuplesort.metadata.json +++ b/parser/testdata/parse/postgres_regress/tuplesort.metadata.json @@ -3,11 +3,6 @@ "001", "002", "003", - "004", - "005", - "006", - "007", - "008", "015", "016", "017", @@ -35,47 +30,16 @@ "052", "053", "054", - "055", - "056", - "057", - "058", - "059", - "060", - "061", - "062", - "063", - "064", - "065", - "066", - "067", - "068", - "069", "070", "071", "072", "073", "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", - "082", - "083", - "084", - "085", - "086", - "087", - "088", - "089", "090", "092", "093", "095", "096", - "097", "098", "099", "100", diff --git a/parser/testdata/parse/postgres_regress/txid.metadata.json b/parser/testdata/parse/postgres_regress/txid.metadata.json index b5cf648..5445416 100644 --- a/parser/testdata/parse/postgres_regress/txid.metadata.json +++ b/parser/testdata/parse/postgres_regress/txid.metadata.json @@ -1,10 +1,6 @@ { "todo": [ "008", - "009", - "010", - "011", - "012", "024", "028", "029", diff --git a/parser/testdata/parse/postgres_regress/typed_table.metadata.json b/parser/testdata/parse/postgres_regress/typed_table.metadata.json index 16d3d04..6043573 100644 --- a/parser/testdata/parse/postgres_regress/typed_table.metadata.json +++ b/parser/testdata/parse/postgres_regress/typed_table.metadata.json @@ -21,7 +21,6 @@ "021", "022", "023", - "024", "025", "027", "028" diff --git a/parser/testdata/parse/postgres_regress/union.metadata.json b/parser/testdata/parse/postgres_regress/union.metadata.json index 9b74ccf..50696b4 100644 --- a/parser/testdata/parse/postgres_regress/union.metadata.json +++ b/parser/testdata/parse/postgres_regress/union.metadata.json @@ -50,8 +50,6 @@ "138", "139", "140", - "141", - "142", "143", "144", "145", @@ -61,8 +59,6 @@ "149", "150", "151", - "152", - "153", "154", "155", "156", diff --git a/parser/testdata/parse/postgres_regress/updatable_views.metadata.json b/parser/testdata/parse/postgres_regress/updatable_views.metadata.json index 91b84bc..4a87b2f 100644 --- a/parser/testdata/parse/postgres_regress/updatable_views.metadata.json +++ b/parser/testdata/parse/postgres_regress/updatable_views.metadata.json @@ -2,7 +2,6 @@ "todo": [ "001", "002", - "003", "004", "005", "006", @@ -24,71 +23,15 @@ "022", "023", "024", - "028", - "029", - "030", - "031", - "032", - "033", - "034", - "035", - "036", - "037", - "038", - "039", - "040", - "041", - "042", - "043", - "044", - "045", - "046", - "047", - "048", - "049", - "051", - "052", - "053", - "055", - "057", - "058", - "059", - "061", - "063", - "065", "068", - "069", - "070", - "071", - "072", - "074", - "075", - "076", - "077", - "078", - "080", - "081", - "082", - "083", - "084", - "085", "086", "087", "088", - "089", - "090", - "091", - "092", "093", "094", "095", "096", - "097", "098", - "1000", - "1001", - "1002", - "1003", "1004", "1006", "1007", @@ -96,16 +39,11 @@ "1009", "1010", "1011", - "1012", "1013", - "1014", "1015", "1017", "1018", - "1019", - "102", "1020", - "1021", "1022", "1024", "1025", @@ -113,74 +51,30 @@ "1027", "1028", "1029", - "103", "1030", "1031", "1032", "1033", "1034", "1035", - "1036", - "1037", - "1038", - "1039", - "104", - "1040", - "1041", - "1042", - "1043", - "1044", "1046", "1047", "1048", - "1049", - "105", - "1050", - "1051", - "1052", - "1053", - "1054", - "1055", - "1056", - "1057", "1059", "1060", "1061", "1062", - "1063", - "1064", - "1065", - "1066", - "1067", - "1068", - "1069", - "107", - "1070", - "1071", "1073", "1074", "1075", - "1076", - "1077", - "1078", - "1079", - "1080", - "1081", - "1082", - "1083", - "1084", "1086", "1087", "1088", - "1089", - "109", - "1090", "1092", "1093", "1094", "1095", "1096", - "1097", "1099", "1100", "111", @@ -191,68 +85,41 @@ "116", "117", "118", - "120", "122", "123", "124", - "125", "126", "127", - "131", - "132", - "134", - "135", - "137", - "139", "141", "142", "143", "144", - "145", "146", "147", "151", "155", "159", - "163", - "164", - "166", - "168", "169", "170", "171", "172", - "173", "174", "175", "179", "180", "184", "188", - "192", - "193", - "195", - "197", - "199", "201", "202", "203", "204", - "205", - "206", "207", - "208", - "209", "210", - "211", - "212", "214", "215", "216", - "217", "218", "219", - "220", "222", "223", "224", @@ -260,9 +127,7 @@ "226", "227", "228", - "229", "230", - "231", "232", "233", "234", @@ -270,412 +135,166 @@ "236", "237", "238", - "242", - "243", - "244", - "245", - "246", - "247", - "248", - "249", - "250", - "251", - "252", - "253", - "254", - "255", - "256", - "257", - "258", - "259", "260", "261", "262", "263", "264", - "265", - "266", - "267", - "268", - "269", - "270", - "271", - "272", "274", "275", "276", "277", "278", "279", - "280", - "281", - "282", - "283", - "284", - "285", - "286", - "287", "289", "290", "291", - "292", "293", "294", - "297", - "298", "299", "300", - "303", - "304", "305", "306", "307", - "310", - "311", "312", - "315", - "316", "317", "318", "319", - "322", - "323", "324", "325", "326", - "329", - "330", "331", - "334", - "335", "336", "337", "338", - "341", - "342", "343", "344", "345", - "348", - "349", "350", - "353", - "354", "355", "356", "357", "358", - "359", "360", "361", - "362", "363", "364", "365", - "368", - "369", - "370", - "371", - "372", - "373", - "374", - "375", "376", "377", "378", "379", - "382", - "383", - "384", - "385", - "386", - "387", - "388", - "389", "390", "391", "392", - "393", - "394", - "395", - "396", - "397", "398", "399", "400", "401", - "402", - "403", - "404", "405", "406", "407", - "408", - "409", - "410", "412", "413", "414", - "415", "416", "417", "418", - "420", - "421", "422", "423", "424", - "426", - "427", "428", "429", "430", "431", - "433", - "434", - "435", - "436", "437", - "439", - "440", "441", - "443", - "444", "445", "446", "447", "448", - "450", - "451", "452", - "454", - "455", "456", "457", "458", "459", - "461", - "462", - "463", - "464", - "465", - "466", "467", - "469", - "470", - "471", - "472", - "473", - "474", "475", "476", "477", "478", - "480", - "481", - "482", - "483", - "484", - "485", "486", "487", "488", - "490", - "491", "492", - "494", - "495", - "496", - "497", - "498", - "499", "500", - "502", - "503", - "504", - "505", - "506", - "507", "508", "509", "510", - "512", - "513", - "514", - "515", - "516", - "517", "518", - "520", - "521", - "522", - "523", - "524", - "525", "526", "527", "528", "529", "530", "531", - "532", - "533", - "534", "535", "536", - "537", - "538", - "539", "541", "542", - "543", - "544", "545", "546", "547", - "548", "550", "551", "552", "553", "554", - "555", "556", - "558", "560", - "561", "563", "564", - "565", "566", - "567", "569", "570", - "571", "572", - "573", - "574", - "575", - "576", - "577", - "578", - "579", "580", - "581", - "582", - "583", - "584", - "585", - "586", - "587", "588", - "589", - "590", - "591", - "592", "598", "599", "600", - "601", - "602", - "603", - "604", - "605", - "606", - "608", - "609", "611", "612", "613", - "614", - "615", "616", "617", - "621", - "622", - "623", - "624", - "625", - "626", - "627", - "628", - "629", - "630", - "633", - "634", - "635", - "636", "639", "640", - "641", - "642", "643", - "644", "647", "648", "649", - "650", "651", - "653", - "654", - "655", - "656", - "657", - "658", - "659", - "661", - "662", - "663", - "664", "666", "667", "668", "669", - "671", - "672", - "673", - "675", - "676", "677", - "679", - "680", "682", "683", - "684", - "685", "686", - "688", "690", "691", "692", "693", "694", - "696", - "697", - "698", - "699", - "700", - "701", "702", "703", "704", - "705", - "706", - "707", - "708", - "709", - "710", - "711", - "712", "713", "714", "715", - "716", "717", - "718", - "719", - "720", - "721", "722", "723", "724", @@ -683,9 +302,6 @@ "726", "727", "728", - "729", - "730", - "731", "732", "733", "734", @@ -693,90 +309,54 @@ "736", "737", "738", - "739", - "740", - "741", - "742", - "743", - "744", - "745", - "746", "748", - "749", - "750", "752", "753", "754", - "755", - "756", - "757", - "758", - "759", - "760", "762", "763", "764", "765", "766", "767", - "768", "769", "770", - "771", "772", "773", "774", - "776", - "777", "778", - "783", - "784", - "785", "786", "787", "788", "789", "790", - "795", - "796", - "797", "798", "799", "800", "801", "802", "803", - "804", "805", "806", "807", "809", - "810", "811", - "812", "814", "815", "816", - "817", "818", "819", "820", - "821", "822", "823", "824", - "825", "826", "827", "828", - "829", "830", "831", "834", - "835", "838", - "839", - "841", "843", "844", "845", @@ -784,7 +364,6 @@ "847", "848", "849", - "850", "853", "854", "855", @@ -793,8 +372,6 @@ "858", "859", "860", - "861", - "862", "865", "866", "867", @@ -806,25 +383,14 @@ "873", "874", "875", - "876", - "877", "880", "881", "882", "883", "884", - "885", "886", - "887", "888", "889", - "890", - "891", - "892", - "893", - "894", - "895", - "896", "898", "899", "900", @@ -840,8 +406,6 @@ "910", "911", "912", - "913", - "914", "915", "916", "917", @@ -854,63 +418,40 @@ "924", "925", "926", - "932", "934", - "935", - "936", - "937", - "938", "940", "941", "942", "943", "944", - "945", "946", "947", "948", "949", "950", - "951", "952", - "953", "954", "955", "956", - "957", "958", - "959", - "961", - "963", "965", - "966", "968", "969", "970", "971", - "972", "973", - "974", - "976", - "977", - "978", "980", - "981", "983", - "984", - "986", "987", "988", "989", "990", "991", "992", - "993", "994", "995", "996", "997", - "998", - "999" + "998" ] } diff --git a/parser/testdata/parse/postgres_regress/update.metadata.json b/parser/testdata/parse/postgres_regress/update.metadata.json index ceeb05a..fef1acb 100644 --- a/parser/testdata/parse/postgres_regress/update.metadata.json +++ b/parser/testdata/parse/postgres_regress/update.metadata.json @@ -2,43 +2,13 @@ "todo": [ "001", "002", - "003", - "004", - "006", - "008", - "010", - "012", - "013", - "015", - "016", - "018", - "020", - "022", - "023", - "025", - "027", - "028", - "030", - "031", - "032", - "033", "035", - "036", - "038", - "039", - "040", - "041", - "042", - "043", "044", "045", "046", "047", "048", "049", - "050", - "051", - "052", "053", "054", "055", @@ -48,7 +18,6 @@ "059", "060", "061", - "062", "063", "064", "065", @@ -60,38 +29,19 @@ "071", "072", "073", - "074", - "075", - "076", - "077", - "078", - "079", - "080", - "081", "082", - "083", "084", - "085", - "086", - "087", - "088", "089", - "090", "091", "092", - "093", "094", "095", - "096", "097", "098", "099", "100", "101", "102", - "103", - "104", - "105", "106", "107", "108", @@ -103,30 +53,23 @@ "114", "115", "116", - "117", "118", "119", "120", "121", - "122", "123", "124", - "125", "126", "127", "128", "129", "130", "131", - "132", - "133", "134", "135", "136", - "137", "138", "139", - "140", "141", "142", "143", @@ -147,7 +90,6 @@ "158", "159", "160", - "161", "162", "163", "164", @@ -161,22 +103,10 @@ "172", "173", "174", - "175", - "176", - "177", - "178", - "179", - "180", - "181", - "182", "183", "184", "185", "186", - "187", - "188", - "189", - "190", "191", "192", "193", @@ -184,13 +114,6 @@ "195", "196", "197", - "198", - "199", - "200", - "201", - "202", - "203", - "204", "205", "206", "207", @@ -200,25 +123,14 @@ "211", "212", "213", - "214", - "215", - "216", - "217", - "218", - "220", "222", "223", - "225", "227", "228", "229", - "230", "232", - "233", "235", "236", - "237", - "238", "240", "241", "242", @@ -228,12 +140,6 @@ "246", "247", "248", - "249", - "250", - "251", - "252", - "253", - "254", "255", "256", "257" diff --git a/parser/testdata/parse/postgres_regress/uuid.metadata.json b/parser/testdata/parse/postgres_regress/uuid.metadata.json index b171ee4..38e45f6 100644 --- a/parser/testdata/parse/postgres_regress/uuid.metadata.json +++ b/parser/testdata/parse/postgres_regress/uuid.metadata.json @@ -2,26 +2,10 @@ "todo": [ "001", "002", - "003", - "004", - "005", - "006", - "007", - "008", - "011", - "012", - "013", "023", "024", "025", - "026", - "028", - "029", - "030", - "031", "034", - "035", - "036", "044" ] } diff --git a/parser/testdata/parse/postgres_regress/vacuum.metadata.json b/parser/testdata/parse/postgres_regress/vacuum.metadata.json index 6077fb0..84b7984 100644 --- a/parser/testdata/parse/postgres_regress/vacuum.metadata.json +++ b/parser/testdata/parse/postgres_regress/vacuum.metadata.json @@ -1,37 +1,8 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "010", - "011", - "012", - "013", - "014", - "016", "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", - "027", - "028", - "029", - "030", - "031", - "033", "034", - "035", "037", "038", "039", @@ -40,20 +11,13 @@ "042", "043", "044", - "045", "046", - "047", - "048", "049", - "050", - "051", "052", "053", "054", "055", "056", - "057", - "058", "059", "061", "062", @@ -61,7 +25,6 @@ "065", "066", "067", - "068", "069", "070", "072", @@ -73,7 +36,6 @@ "079", "080", "081", - "082", "083", "084", "085", @@ -81,14 +43,11 @@ "087", "088", "089", - "090", "091", "092", "093", "094", - "095", "096", - "097", "098", "099", "100", @@ -96,7 +55,6 @@ "102", "103", "104", - "105", "106", "107", "108", @@ -109,18 +67,14 @@ "115", "116", "117", - "118", "119", "120", "121", - "122", "123", "124", "125", "126", "127", - "128", - "129", "130", "131", "132", @@ -129,15 +83,12 @@ "135", "136", "137", - "138", "139", "141", "143", "144", "145", "146", - "147", - "148", "149", "150", "151", @@ -146,7 +97,6 @@ "154", "155", "156", - "157", "158", "159", "160", @@ -185,7 +135,6 @@ "194", "195", "196", - "197", "198", "199", "200", diff --git a/parser/testdata/parse/postgres_regress/vacuum_parallel.metadata.json b/parser/testdata/parse/postgres_regress/vacuum_parallel.metadata.json index ea3d6ea..17cbadd 100644 --- a/parser/testdata/parse/postgres_regress/vacuum_parallel.metadata.json +++ b/parser/testdata/parse/postgres_regress/vacuum_parallel.metadata.json @@ -3,13 +3,10 @@ "001", "002", "003", - "004", "005", "006", "007", - "010", "011", - "012", "013", "014" ] diff --git a/parser/testdata/parse/postgres_regress/varchar.metadata.json b/parser/testdata/parse/postgres_regress/varchar.metadata.json index eb5b802..69a5a4c 100644 --- a/parser/testdata/parse/postgres_regress/varchar.metadata.json +++ b/parser/testdata/parse/postgres_regress/varchar.metadata.json @@ -1,15 +1,6 @@ { "todo": [ "001", - "002", - "003", - "004", - "005", - "006", - "007", - "008", - "009", - "017", - "018" + "017" ] } diff --git a/parser/testdata/parse/postgres_regress/window.metadata.json b/parser/testdata/parse/postgres_regress/window.metadata.json index d6adb2d..b3026b2 100644 --- a/parser/testdata/parse/postgres_regress/window.metadata.json +++ b/parser/testdata/parse/postgres_regress/window.metadata.json @@ -1,7 +1,6 @@ { "todo": [ "001", - "002", "045", "074", "077", @@ -23,15 +22,10 @@ "137", "138", "145", - "146", "166", - "167", "238", - "239", "241", "246", - "256", - "257", "265", "266", "268", diff --git a/parser/testdata/parse/postgres_regress/with.metadata.json b/parser/testdata/parse/postgres_regress/with.metadata.json index 9462d84..4a322fd 100644 --- a/parser/testdata/parse/postgres_regress/with.metadata.json +++ b/parser/testdata/parse/postgres_regress/with.metadata.json @@ -3,144 +3,77 @@ "006", "008", "018", - "019", - "020", - "021", - "022", - "023", - "024", - "025", - "026", "033", "037", "041", - "042", "046", - "047", "049", "050", "051", "052", - "053", "054", "057", "060", "062", "070", "073", - "074", "078", "081", "097", "098", "109", - "110", - "111", - "113", - "115", "117", - "129", "130", - "131", "149", "150", "155", - "165", - "167", - "169", - "171", "173", - "174", "176", "177", - "179", "181", "182", - "183", "186", - "187", "188", "189", "190", "191", - "192", "193", "195", "197", - "199", - "201", - "203", "205", "206", - "207", - "208", - "210", - "211", - "212", - "213", - "214", - "215", "216", "217", "218", - "219", - "220", "222", - "223", "225", - "226", "228", "229", "230", - "231", "232", - "233", - "236", "239", - "240", "241", "242", - "243", "245", "246", - "247", "249", "250", "251", - "252", "254", "255", "256", "257", "258", - "259", - "260", - "261", - "262", - "264", - "266", - "268", "270", - "271", - "272", - "273", - "274", "275", - "276", "277", - "278", "279", - "280", "281", - "282", "283", - "284", "285", "286", "287", - "289", "290", - "291", "293" ] } diff --git a/parser/testdata/parse/postgres_regress/write_parallel.metadata.json b/parser/testdata/parse/postgres_regress/write_parallel.metadata.json index 39897e0..48bdd37 100644 --- a/parser/testdata/parse/postgres_regress/write_parallel.metadata.json +++ b/parser/testdata/parse/postgres_regress/write_parallel.metadata.json @@ -16,7 +16,6 @@ "015", "016", "017", - "018", "019", "020", "021", diff --git a/parser/testdata/parse/postgres_regress/xid.metadata.json b/parser/testdata/parse/postgres_regress/xid.metadata.json index fd0d4f2..8cbb110 100644 --- a/parser/testdata/parse/postgres_regress/xid.metadata.json +++ b/parser/testdata/parse/postgres_regress/xid.metadata.json @@ -1,15 +1,10 @@ { "todo": [ "027", - "028", "030", "031", "032", "045", - "046", - "047", - "048", - "049", "061", "065", "066", diff --git a/parser/testdata/parse/postgres_regress/xml.metadata.json b/parser/testdata/parse/postgres_regress/xml.metadata.json index 639ee39..b150a01 100644 --- a/parser/testdata/parse/postgres_regress/xml.metadata.json +++ b/parser/testdata/parse/postgres_regress/xml.metadata.json @@ -1,18 +1,10 @@ { "todo": [ "001", - "002", - "003", - "004", "035", "037", - "120", "121", - "122", - "123", "125", - "126", - "127", "134", "135", "136", @@ -25,32 +17,18 @@ "143", "144", "163", - "170", - "171", - "172", - "173", "184", - "185", "191", "206", "214", - "215", "217", "219", "220", "224", - "228", - "229", "242", "244", "245", - "246", - "247", "250", - "254", - "255", - "256", - "257", - "258" + "254" ] } diff --git a/parser/testdata/parse/postgres_regress/xmlmap.metadata.json b/parser/testdata/parse/postgres_regress/xmlmap.metadata.json index 0210985..c07ab38 100644 --- a/parser/testdata/parse/postgres_regress/xmlmap.metadata.json +++ b/parser/testdata/parse/postgres_regress/xmlmap.metadata.json @@ -2,13 +2,9 @@ "todo": [ "001", "002", - "003", "004", "005", "006", - "007", - "025", - "028", "036", "037", "038"