Debian Codegraph @

src/backend/bootstrap/bootparse.y

raw
1 %{
2 /*-------------------------------------------------------------------------
3 *
4 * bootparse.y
5 * yacc grammar for the "bootstrap" mode (BKI file format)
6 *
7 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/bootstrap/bootparse.y
13 *
14 *-------------------------------------------------------------------------
15 */
16
17 #include "postgres.h"
18
19 #include <unistd.h>
20
21 #include "bootstrap/bootstrap.h"
22 #include "catalog/heap.h"
23 #include "catalog/namespace.h"
24 #include "catalog/pg_am.h"
25 #include "catalog/pg_authid.h"
26 #include "catalog/pg_class.h"
27 #include "catalog/pg_namespace.h"
28 #include "catalog/pg_tablespace.h"
29 #include "catalog/toasting.h"
30 #include "commands/defrem.h"
31 #include "miscadmin.h"
32 #include "nodes/makefuncs.h"
33 #include "utils/memutils.h"
34
35 #include "bootparse.h"
36
37
38 /*
39 * Bison doesn't allocate anything that needs to live across parser calls,
40 * so we can easily have it use palloc instead of malloc. This prevents
41 * memory leaks if we error out during parsing.
42 */
43 #define YYMALLOC palloc
44 #define YYFREE pfree
45
46 static MemoryContext per_line_ctx = NULL;
47
48 static void
49 do_start(void)
50 {
51 Assert(CurrentMemoryContext == CurTransactionContext);
52 /* First time through, create the per-line working context */
53 if (per_line_ctx == NULL)
54 per_line_ctx = AllocSetContextCreate(CurTransactionContext,
55 "bootstrap per-line processing",
56 ALLOCSET_DEFAULT_SIZES);
57 MemoryContextSwitchTo(per_line_ctx);
58 }
59
60
61 static void
62 do_end(void)
63 {
64 /* Reclaim memory allocated while processing this line */
65 MemoryContextSwitchTo(CurTransactionContext);
66 MemoryContextReset(per_line_ctx);
67 CHECK_FOR_INTERRUPTS(); /* allow SIGINT to kill bootstrap run */
68 if (isatty(0))
69 {
70 printf("bootstrap> ");
71 fflush(stdout);
72 }
73 }
74
75
76 static int num_columns_read = 0;
77
78 %}
79
80 %parse-param {yyscan_t yyscanner}
81 %lex-param {yyscan_t yyscanner}
82 %pure-parser
83 %expect 0
84 %name-prefix="boot_yy"
85
86 %union
87 {
88 List *list;
89 IndexElem *ielem;
90 char *str;
91 const char *kw;
92 int ival;
93 Oid oidval;
94 }
95
96 %type <list> boot_index_params
97 %type <ielem> boot_index_param
98 %type <str> boot_ident
99 %type <ival> optbootstrap optsharedrelation boot_column_nullness
100 %type <oidval> oidspec optrowtypeoid
101
102 %token <str> ID
103 %token COMMA EQUALS LPAREN RPAREN
104 /* NULLVAL is a reserved keyword */
105 %token NULLVAL
106 /* All the rest are unreserved, and should be handled in boot_ident! */
107 %token <kw> OPEN XCLOSE XCREATE INSERT_TUPLE
108 %token <kw> XDECLARE INDEX ON USING XBUILD INDICES UNIQUE XTOAST
109 %token <kw> OBJ_ID XBOOTSTRAP XSHARED_RELATION XROWTYPE_OID
110 %token <kw> XFORCE XNOT XNULL
111
112 %start TopLevel
113
114 %%
115
116 TopLevel:
117 Boot_Queries
118 |
119 ;
120
121 Boot_Queries:
122 Boot_Query
123 | Boot_Queries Boot_Query
124 ;
125
126 Boot_Query :
127 Boot_OpenStmt
128 | Boot_CloseStmt
129 | Boot_CreateStmt
130 | Boot_InsertStmt
131 | Boot_DeclareIndexStmt
132 | Boot_DeclareUniqueIndexStmt
133 | Boot_DeclareToastStmt
134 | Boot_BuildIndsStmt
135 ;
136
137 Boot_OpenStmt:
138 OPEN boot_ident
139 {
140 do_start();
141 boot_openrel($2);
142 do_end();
143
144 (void) yynerrs; /* suppress compiler warning */
145 }
146 ;
147
148 Boot_CloseStmt:
149 XCLOSE boot_ident
150 {
151 do_start();
152 closerel($2);
153 do_end();
154 }
155 ;
156
157 Boot_CreateStmt:
158 XCREATE boot_ident oidspec optbootstrap optsharedrelation optrowtypeoid LPAREN
159 {
160 do_start();
161 numattr = 0;
162 elog(DEBUG4, "creating%s%s relation %s %u",
163 $4 ? " bootstrap" : "",
164 $5 ? " shared" : "",
165 $2,
166 $3);
167 }
168 boot_column_list
169 {
170 do_end();
171 }
172 RPAREN
173 {
174 TupleDesc tupdesc;
175 bool shared_relation;
176 bool mapped_relation;
177
178 do_start();
179
180 tupdesc = CreateTupleDesc(numattr, attrtypes);
181
182 shared_relation = $5;
183
184 /*
185 * The catalogs that use the relation mapper are the
186 * bootstrap catalogs plus the shared catalogs. If this
187 * ever gets more complicated, we should invent a BKI
188 * keyword to mark the mapped catalogs, but for now a
189 * quick hack seems the most appropriate thing. Note in
190 * particular that all "nailed" heap rels (see formrdesc
191 * in relcache.c) must be mapped.
192 */
193 mapped_relation = ($4 || shared_relation);
194
195 if ($4)
196 {
197 TransactionId relfrozenxid;
198 MultiXactId relminmxid;
199
200 if (boot_reldesc)
201 {
202 elog(DEBUG4, "create bootstrap: warning, open relation exists, closing first");
203 closerel(NULL);
204 }
205
206 boot_reldesc = heap_create($2,
207 PG_CATALOG_NAMESPACE,
208 shared_relation ? GLOBALTABLESPACE_OID : 0,
209 $3,
210 InvalidOid,
211 HEAP_TABLE_AM_OID,
212 tupdesc,
213 RELKIND_RELATION,
214 RELPERSISTENCE_PERMANENT,
215 shared_relation,
216 mapped_relation,
217 true,
218 &relfrozenxid,
219 &relminmxid,
220 true);
221 elog(DEBUG4, "bootstrap relation created");
222 }
223 else
224 {
225 Oid id;
226
227 id = heap_create_with_catalog($2,
228 PG_CATALOG_NAMESPACE,
229 shared_relation ? GLOBALTABLESPACE_OID : 0,
230 $3,
231 $6,
232 InvalidOid,
233 BOOTSTRAP_SUPERUSERID,
234 HEAP_TABLE_AM_OID,
235 tupdesc,
236 NIL,
237 RELKIND_RELATION,
238 RELPERSISTENCE_PERMANENT,
239 shared_relation,
240 mapped_relation,
241 ONCOMMIT_NOOP,
242 (Datum) 0,
243 false,
244 true,
245 false,
246 InvalidOid,
247 NULL);
248 elog(DEBUG4, "relation created with OID %u", id);
249 }
250 do_end();
251 }
252 ;
253
254 Boot_InsertStmt:
255 INSERT_TUPLE
256 {
257 do_start();
258 elog(DEBUG4, "inserting row");
259 num_columns_read = 0;
260 }
261 LPAREN boot_column_val_list RPAREN
262 {
263 if (num_columns_read != numattr)
264 elog(ERROR, "incorrect number of columns in row (expected %d, got %d)",
265 numattr, num_columns_read);
266 if (boot_reldesc == NULL)
267 elog(FATAL, "relation not open");
268 InsertOneTuple();
269 do_end();
270 }
271 ;
272
273 Boot_DeclareIndexStmt:
274 XDECLARE INDEX boot_ident oidspec ON boot_ident USING boot_ident LPAREN boot_index_params RPAREN
275 {
276 IndexStmt *stmt = makeNode(IndexStmt);
277 Oid relationId;
278
279 elog(DEBUG4, "creating index \"%s\"", $3);
280
281 do_start();
282
283 stmt->idxname = $3;
284 stmt->relation = makeRangeVar(NULL, $6, -1);
285 stmt->accessMethod = $8;
286 stmt->tableSpace = NULL;
287 stmt->indexParams = $10;
288 stmt->indexIncludingParams = NIL;
289 stmt->options = NIL;
290 stmt->whereClause = NULL;
291 stmt->excludeOpNames = NIL;
292 stmt->idxcomment = NULL;
293 stmt->indexOid = InvalidOid;
294 stmt->oldNumber = InvalidRelFileNumber;
295 stmt->oldCreateSubid = InvalidSubTransactionId;
296 stmt->oldFirstRelfilelocatorSubid = InvalidSubTransactionId;
297 stmt->unique = false;
298 stmt->primary = false;
299 stmt->isconstraint = false;
300 stmt->deferrable = false;
301 stmt->initdeferred = false;
302 stmt->transformed = false;
303 stmt->concurrent = false;
304 stmt->if_not_exists = false;
305 stmt->reset_default_tblspc = false;
306
307 /* locks and races need not concern us in bootstrap mode */
308 relationId = RangeVarGetRelid(stmt->relation, NoLock,
309 false);
310
311 DefineIndex(relationId,
312 stmt,
313 $4,
314 InvalidOid,
315 InvalidOid,
316 -1,
317 false,
318 false,
319 false,
320 true, /* skip_build */
321 false);
322 do_end();
323 }
324 ;
325
326 Boot_DeclareUniqueIndexStmt:
327 XDECLARE UNIQUE INDEX boot_ident oidspec ON boot_ident USING boot_ident LPAREN boot_index_params RPAREN
328 {
329 IndexStmt *stmt = makeNode(IndexStmt);
330 Oid relationId;
331
332 elog(DEBUG4, "creating unique index \"%s\"", $4);
333
334 do_start();
335
336 stmt->idxname = $4;
337 stmt->relation = makeRangeVar(NULL, $7, -1);
338 stmt->accessMethod = $9;
339 stmt->tableSpace = NULL;
340 stmt->indexParams = $11;
341 stmt->indexIncludingParams = NIL;
342 stmt->options = NIL;
343 stmt->whereClause = NULL;
344 stmt->excludeOpNames = NIL;
345 stmt->idxcomment = NULL;
346 stmt->indexOid = InvalidOid;
347 stmt->oldNumber = InvalidRelFileNumber;
348 stmt->oldCreateSubid = InvalidSubTransactionId;
349 stmt->oldFirstRelfilelocatorSubid = InvalidSubTransactionId;
350 stmt->unique = true;
351 stmt->primary = false;
352 stmt->isconstraint = false;
353 stmt->deferrable = false;
354 stmt->initdeferred = false;
355 stmt->transformed = false;
356 stmt->concurrent = false;
357 stmt->if_not_exists = false;
358 stmt->reset_default_tblspc = false;
359
360 /* locks and races need not concern us in bootstrap mode */
361 relationId = RangeVarGetRelid(stmt->relation, NoLock,
362 false);
363
364 DefineIndex(relationId,
365 stmt,
366 $5,
367 InvalidOid,
368 InvalidOid,
369 -1,
370 false,
371 false,
372 false,
373 true, /* skip_build */
374 false);
375 do_end();
376 }
377 ;
378
379 Boot_DeclareToastStmt:
380 XDECLARE XTOAST oidspec oidspec ON boot_ident
381 {
382 elog(DEBUG4, "creating toast table for table \"%s\"", $6);
383
384 do_start();
385
386 BootstrapToastTable($6, $3, $4);
387 do_end();
388 }
389 ;
390
391 Boot_BuildIndsStmt:
392 XBUILD INDICES
393 {
394 do_start();
395 build_indices();
396 do_end();
397 }
398 ;
399
400
401 boot_index_params:
402 boot_index_params COMMA boot_index_param { $$ = lappend($1, $3); }
403 | boot_index_param { $$ = list_make1($1); }
404 ;
405
406 boot_index_param:
407 boot_ident boot_ident
408 {
409 IndexElem *n = makeNode(IndexElem);
410
411 n->name = $1;
412 n->expr = NULL;
413 n->indexcolname = NULL;
414 n->collation = NIL;
415 n->opclass = list_make1(makeString($2));
416 n->ordering = SORTBY_DEFAULT;
417 n->nulls_ordering = SORTBY_NULLS_DEFAULT;
418 $$ = n;
419 }
420 ;
421
422 optbootstrap:
423 XBOOTSTRAP { $$ = 1; }
424 | { $$ = 0; }
425 ;
426
427 optsharedrelation:
428 XSHARED_RELATION { $$ = 1; }
429 | { $$ = 0; }
430 ;
431
432 optrowtypeoid:
433 XROWTYPE_OID oidspec { $$ = $2; }
434 | { $$ = InvalidOid; }
435 ;
436
437 boot_column_list:
438 boot_column_def
439 | boot_column_list COMMA boot_column_def
440 ;
441
442 boot_column_def:
443 boot_ident EQUALS boot_ident boot_column_nullness
444 {
445 if (++numattr > MAXATTR)
446 elog(FATAL, "too many columns");
447 DefineAttr($1, $3, numattr-1, $4);
448 }
449 ;
450
451 boot_column_nullness:
452 XFORCE XNOT XNULL { $$ = BOOTCOL_NULL_FORCE_NOT_NULL; }
453 | XFORCE XNULL { $$ = BOOTCOL_NULL_FORCE_NULL; }
454 | { $$ = BOOTCOL_NULL_AUTO; }
455 ;
456
457 oidspec:
458 boot_ident { $$ = atooid($1); }
459 ;
460
461 boot_column_val_list:
462 boot_column_val
463 | boot_column_val_list boot_column_val
464 | boot_column_val_list COMMA boot_column_val
465 ;
466
467 boot_column_val:
468 boot_ident
469 { InsertOneValue($1, num_columns_read++); }
470 | NULLVAL
471 { InsertOneNull(num_columns_read++); }
472 ;
473
474 boot_ident:
475 ID { $$ = $1; }
476 | OPEN { $$ = pstrdup($1); }
477 | XCLOSE { $$ = pstrdup($1); }
478 | XCREATE { $$ = pstrdup($1); }
479 | INSERT_TUPLE { $$ = pstrdup($1); }
480 | XDECLARE { $$ = pstrdup($1); }
481 | INDEX { $$ = pstrdup($1); }
482 | ON { $$ = pstrdup($1); }
483 | USING { $$ = pstrdup($1); }
484 | XBUILD { $$ = pstrdup($1); }
485 | INDICES { $$ = pstrdup($1); }
486 | UNIQUE { $$ = pstrdup($1); }
487 | XTOAST { $$ = pstrdup($1); }
488 | OBJ_ID { $$ = pstrdup($1); }
489 | XBOOTSTRAP { $$ = pstrdup($1); }
490 | XSHARED_RELATION { $$ = pstrdup($1); }
491 | XROWTYPE_OID { $$ = pstrdup($1); }
492 | XFORCE { $$ = pstrdup($1); }
493 | XNOT { $$ = pstrdup($1); }
494 | XNULL { $$ = pstrdup($1); }
495 ;
496 %%