PostgreSQL Source Code  git master
bootstrap.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * bootstrap.c
4  * routines to support running postgres in 'bootstrap' mode
5  * bootstrap mode is used to create the initial template database
6  *
7  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
8  * Portions Copyright (c) 1994, Regents of the University of California
9  *
10  * IDENTIFICATION
11  * src/backend/bootstrap/bootstrap.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include <unistd.h>
18 #include <signal.h>
19 
20 #include "access/genam.h"
21 #include "access/heapam.h"
22 #include "access/htup_details.h"
23 #include "access/tableam.h"
25 #include "access/xact.h"
26 #include "bootstrap/bootstrap.h"
27 #include "catalog/index.h"
28 #include "catalog/pg_collation.h"
29 #include "catalog/pg_type.h"
30 #include "common/link-canary.h"
31 #include "miscadmin.h"
32 #include "nodes/makefuncs.h"
33 #include "pg_getopt.h"
34 #include "storage/bufpage.h"
35 #include "storage/ipc.h"
36 #include "storage/proc.h"
37 #include "utils/builtins.h"
38 #include "utils/fmgroids.h"
39 #include "utils/guc.h"
40 #include "utils/memutils.h"
41 #include "utils/rel.h"
42 #include "utils/relmapper.h"
43 
45 
46 
47 static void CheckerModeMain(void);
48 static void bootstrap_signals(void);
50 static void populate_typ_list(void);
51 static Oid gettype(char *type);
52 static void cleanup(void);
53 
54 /* ----------------
55  * global variables
56  * ----------------
57  */
58 
59 Relation boot_reldesc; /* current relation descriptor */
60 
61 Form_pg_attribute attrtypes[MAXATTR]; /* points to attribute info */
62 int numattr; /* number of attributes for cur. rel */
63 
64 
65 /*
66  * Basic information associated with each type. This is used before
67  * pg_type is filled, so it has to cover the datatypes used as column types
68  * in the core "bootstrapped" catalogs.
69  *
70  * XXX several of these input/output functions do catalog scans
71  * (e.g., F_REGPROCIN scans pg_proc). this obviously creates some
72  * order dependencies in the catalog creation process.
73  */
74 struct typinfo
75 {
80  bool byval;
81  char align;
82  char storage;
86 };
87 
88 static const struct typinfo TypInfo[] = {
89  {"bool", BOOLOID, 0, 1, true, TYPALIGN_CHAR, TYPSTORAGE_PLAIN, InvalidOid,
90  F_BOOLIN, F_BOOLOUT},
91  {"bytea", BYTEAOID, 0, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, InvalidOid,
92  F_BYTEAIN, F_BYTEAOUT},
93  {"char", CHAROID, 0, 1, true, TYPALIGN_CHAR, TYPSTORAGE_PLAIN, InvalidOid,
94  F_CHARIN, F_CHAROUT},
95  {"int2", INT2OID, 0, 2, true, TYPALIGN_SHORT, TYPSTORAGE_PLAIN, InvalidOid,
96  F_INT2IN, F_INT2OUT},
97  {"int4", INT4OID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
98  F_INT4IN, F_INT4OUT},
99  {"float4", FLOAT4OID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
100  F_FLOAT4IN, F_FLOAT4OUT},
101  {"name", NAMEOID, CHAROID, NAMEDATALEN, false, TYPALIGN_CHAR, TYPSTORAGE_PLAIN, C_COLLATION_OID,
102  F_NAMEIN, F_NAMEOUT},
103  {"regclass", REGCLASSOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
104  F_REGCLASSIN, F_REGCLASSOUT},
105  {"regproc", REGPROCOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
106  F_REGPROCIN, F_REGPROCOUT},
107  {"regtype", REGTYPEOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
108  F_REGTYPEIN, F_REGTYPEOUT},
109  {"regrole", REGROLEOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
110  F_REGROLEIN, F_REGROLEOUT},
111  {"regnamespace", REGNAMESPACEOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
112  F_REGNAMESPACEIN, F_REGNAMESPACEOUT},
113  {"text", TEXTOID, 0, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, DEFAULT_COLLATION_OID,
114  F_TEXTIN, F_TEXTOUT},
115  {"oid", OIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
116  F_OIDIN, F_OIDOUT},
117  {"tid", TIDOID, 0, 6, false, TYPALIGN_SHORT, TYPSTORAGE_PLAIN, InvalidOid,
118  F_TIDIN, F_TIDOUT},
119  {"xid", XIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
120  F_XIDIN, F_XIDOUT},
121  {"cid", CIDOID, 0, 4, true, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
122  F_CIDIN, F_CIDOUT},
123  {"pg_node_tree", PG_NODE_TREEOID, 0, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, DEFAULT_COLLATION_OID,
124  F_PG_NODE_TREE_IN, F_PG_NODE_TREE_OUT},
125  {"int2vector", INT2VECTOROID, INT2OID, -1, false, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
126  F_INT2VECTORIN, F_INT2VECTOROUT},
127  {"oidvector", OIDVECTOROID, OIDOID, -1, false, TYPALIGN_INT, TYPSTORAGE_PLAIN, InvalidOid,
128  F_OIDVECTORIN, F_OIDVECTOROUT},
129  {"_int4", INT4ARRAYOID, INT4OID, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, InvalidOid,
130  F_ARRAY_IN, F_ARRAY_OUT},
131  {"_text", 1009, TEXTOID, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, DEFAULT_COLLATION_OID,
132  F_ARRAY_IN, F_ARRAY_OUT},
133  {"_oid", 1028, OIDOID, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, InvalidOid,
134  F_ARRAY_IN, F_ARRAY_OUT},
135  {"_char", 1002, CHAROID, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, InvalidOid,
136  F_ARRAY_IN, F_ARRAY_OUT},
137  {"_aclitem", 1034, ACLITEMOID, -1, false, TYPALIGN_INT, TYPSTORAGE_EXTENDED, InvalidOid,
138  F_ARRAY_IN, F_ARRAY_OUT}
139 };
140 
141 static const int n_types = sizeof(TypInfo) / sizeof(struct typinfo);
142 
143 struct typmap
144 { /* a hack */
147 };
148 
149 static List *Typ = NIL; /* List of struct typmap* */
150 static struct typmap *Ap = NULL;
151 
152 static Datum values[MAXATTR]; /* current row's attribute values */
153 static bool Nulls[MAXATTR];
154 
155 static MemoryContext nogc = NULL; /* special no-gc mem context */
156 
157 /*
158  * At bootstrap time, we first declare all the indices to be built, and
159  * then build them. The IndexList structure stores enough information
160  * to allow us to build the indices after they've been declared.
161  */
162 
163 typedef struct _IndexList
164 {
170 
171 static IndexList *ILHead = NULL;
172 
173 
174 /*
175  * In shared memory checker mode, all we really want to do is create shared
176  * memory and semaphores (just to prove we can do it with the current GUC
177  * settings). Since, in fact, that was already done by
178  * CreateSharedMemoryAndSemaphores(), we have nothing more to do here.
179  */
180 static void
182 {
183  proc_exit(0);
184 }
185 
186 /*
187  * The main entry point for running the backend in bootstrap mode
188  *
189  * The bootstrap mode is used to initialize the template database.
190  * The bootstrap backend doesn't speak SQL, but instead expects
191  * commands in a special bootstrap language.
192  *
193  * When check_only is true, startup is done only far enough to verify that
194  * the current configuration, particularly the passed in options pertaining
195  * to shared memory sizing, options work (or at least do not cause an error
196  * up to shared memory creation).
197  */
198 void
199 BootstrapModeMain(int argc, char *argv[], bool check_only)
200 {
201  int i;
202  char *progname = argv[0];
203  int flag;
204  char *userDoption = NULL;
205 
207 
208  InitStandaloneProcess(argv[0]);
209 
210  /* Set defaults, to be overridden by explicit options below */
212 
213  /* an initial --boot or --check should be present */
214  Assert(argc > 1
215  && (strcmp(argv[1], "--boot") == 0
216  || strcmp(argv[1], "--check") == 0));
217  argv++;
218  argc--;
219 
220  while ((flag = getopt(argc, argv, "B:c:d:D:Fkr:X:-:")) != -1)
221  {
222  switch (flag)
223  {
224  case 'B':
225  SetConfigOption("shared_buffers", optarg, PGC_POSTMASTER, PGC_S_ARGV);
226  break;
227  case 'c':
228  case '-':
229  {
230  char *name,
231  *value;
232 
234  if (!value)
235  {
236  if (flag == '-')
237  ereport(ERROR,
238  (errcode(ERRCODE_SYNTAX_ERROR),
239  errmsg("--%s requires a value",
240  optarg)));
241  else
242  ereport(ERROR,
243  (errcode(ERRCODE_SYNTAX_ERROR),
244  errmsg("-c %s requires a value",
245  optarg)));
246  }
247 
249  pfree(name);
250  pfree(value);
251  break;
252  }
253  case 'D':
255  break;
256  case 'd':
257  {
258  /* Turn on debugging for the bootstrap process. */
259  char *debugstr;
260 
261  debugstr = psprintf("debug%s", optarg);
262  SetConfigOption("log_min_messages", debugstr,
264  SetConfigOption("client_min_messages", debugstr,
266  pfree(debugstr);
267  }
268  break;
269  case 'F':
270  SetConfigOption("fsync", "false", PGC_POSTMASTER, PGC_S_ARGV);
271  break;
272  case 'k':
274  break;
275  case 'r':
277  break;
278  case 'X':
280  break;
281  default:
282  write_stderr("Try \"%s --help\" for more information.\n",
283  progname);
284  proc_exit(1);
285  break;
286  }
287  }
288 
289  if (argc != optind)
290  {
291  write_stderr("%s: invalid command-line arguments\n", progname);
292  proc_exit(1);
293  }
294 
295  /* Acquire configuration parameters */
297  proc_exit(1);
298 
299  /*
300  * Validate we have been given a reasonable-looking DataDir and change
301  * into it
302  */
303  checkDataDir();
304  ChangeToDataDir();
305 
306  CreateDataDirLockFile(false);
307 
309  IgnoreSystemIndexes = true;
310 
312 
314 
315  /*
316  * XXX: It might make sense to move this into its own function at some
317  * point. Right now it seems like it'd cause more code duplication than
318  * it's worth.
319  */
320  if (check_only)
321  {
323  CheckerModeMain();
324  abort();
325  }
326 
327  /*
328  * Do backend-like initialization for bootstrap mode
329  */
330  InitProcess();
331 
332  BaseInit();
333 
335  BootStrapXLOG();
336 
337  /*
338  * To ensure that src/common/link-canary.c is linked into the backend, we
339  * must call it from somewhere. Here is as good as anywhere.
340  */
342  elog(ERROR, "backend is incorrectly linked to frontend functions");
343 
344  InitPostgres(NULL, InvalidOid, NULL, InvalidOid, 0, NULL);
345 
346  /* Initialize stuff for bootstrap-file processing */
347  for (i = 0; i < MAXATTR; i++)
348  {
349  attrtypes[i] = NULL;
350  Nulls[i] = false;
351  }
352 
353  /*
354  * Process bootstrap input.
355  */
357  boot_yyparse();
359 
360  /*
361  * We should now know about all mapped relations, so it's okay to write
362  * out the initial relation mapping files.
363  */
365 
366  /* Clean up and exit */
367  cleanup();
368  proc_exit(0);
369 }
370 
371 
372 /* ----------------------------------------------------------------
373  * misc functions
374  * ----------------------------------------------------------------
375  */
376 
377 /*
378  * Set up signal handling for a bootstrap process
379  */
380 static void
382 {
384 
385  /*
386  * We don't actually need any non-default signal handling in bootstrap
387  * mode; "curl up and die" is a sufficient response for all these cases.
388  * Let's set that handling explicitly, as documentation if nothing else.
389  */
391  pqsignal(SIGINT, SIG_DFL);
392  pqsignal(SIGTERM, SIG_DFL);
394 }
395 
396 /* ----------------------------------------------------------------
397  * MANUAL BACKEND INTERACTIVE INTERFACE COMMANDS
398  * ----------------------------------------------------------------
399  */
400 
401 /* ----------------
402  * boot_openrel
403  *
404  * Execute BKI OPEN command.
405  * ----------------
406  */
407 void
409 {
410  int i;
411 
412  if (strlen(relname) >= NAMEDATALEN)
413  relname[NAMEDATALEN - 1] = '\0';
414 
415  /*
416  * pg_type must be filled before any OPEN command is executed, hence we
417  * can now populate Typ if we haven't yet.
418  */
419  if (Typ == NIL)
421 
422  if (boot_reldesc != NULL)
423  closerel(NULL);
424 
425  elog(DEBUG4, "open relation %s, attrsize %d",
427 
430  for (i = 0; i < numattr; i++)
431  {
432  if (attrtypes[i] == NULL)
434  memmove((char *) attrtypes[i],
435  (char *) TupleDescAttr(boot_reldesc->rd_att, i),
437 
438  {
440 
441  elog(DEBUG4, "create attribute %d name %s len %d num %d type %u",
442  i, NameStr(at->attname), at->attlen, at->attnum,
443  at->atttypid);
444  }
445  }
446 }
447 
448 /* ----------------
449  * closerel
450  * ----------------
451  */
452 void
454 {
455  if (relname)
456  {
457  if (boot_reldesc)
458  {
459  if (strcmp(RelationGetRelationName(boot_reldesc), relname) != 0)
460  elog(ERROR, "close of %s when %s was expected",
462  }
463  else
464  elog(ERROR, "close of %s before any relation was opened",
465  relname);
466  }
467 
468  if (boot_reldesc == NULL)
469  elog(ERROR, "no open relation to close");
470  else
471  {
472  elog(DEBUG4, "close relation %s",
475  boot_reldesc = NULL;
476  }
477 }
478 
479 
480 
481 /* ----------------
482  * DEFINEATTR()
483  *
484  * define a <field,type> pair
485  * if there are n fields in a relation to be created, this routine
486  * will be called n times
487  * ----------------
488  */
489 void
490 DefineAttr(char *name, char *type, int attnum, int nullness)
491 {
492  Oid typeoid;
493 
494  if (boot_reldesc != NULL)
495  {
496  elog(WARNING, "no open relations allowed with CREATE command");
497  closerel(NULL);
498  }
499 
500  if (attrtypes[attnum] == NULL)
503 
505  elog(DEBUG4, "column %s %s", NameStr(attrtypes[attnum]->attname), type);
506  attrtypes[attnum]->attnum = attnum + 1;
507 
508  typeoid = gettype(type);
509 
510  if (Typ != NIL)
511  {
512  attrtypes[attnum]->atttypid = Ap->am_oid;
513  attrtypes[attnum]->attlen = Ap->am_typ.typlen;
514  attrtypes[attnum]->attbyval = Ap->am_typ.typbyval;
515  attrtypes[attnum]->attalign = Ap->am_typ.typalign;
516  attrtypes[attnum]->attstorage = Ap->am_typ.typstorage;
517  attrtypes[attnum]->attcompression = InvalidCompressionMethod;
518  attrtypes[attnum]->attcollation = Ap->am_typ.typcollation;
519  /* if an array type, assume 1-dimensional attribute */
520  if (Ap->am_typ.typelem != InvalidOid && Ap->am_typ.typlen < 0)
521  attrtypes[attnum]->attndims = 1;
522  else
523  attrtypes[attnum]->attndims = 0;
524  }
525  else
526  {
527  attrtypes[attnum]->atttypid = TypInfo[typeoid].oid;
528  attrtypes[attnum]->attlen = TypInfo[typeoid].len;
529  attrtypes[attnum]->attbyval = TypInfo[typeoid].byval;
530  attrtypes[attnum]->attalign = TypInfo[typeoid].align;
531  attrtypes[attnum]->attstorage = TypInfo[typeoid].storage;
532  attrtypes[attnum]->attcompression = InvalidCompressionMethod;
533  attrtypes[attnum]->attcollation = TypInfo[typeoid].collation;
534  /* if an array type, assume 1-dimensional attribute */
535  if (TypInfo[typeoid].elem != InvalidOid &&
536  attrtypes[attnum]->attlen < 0)
537  attrtypes[attnum]->attndims = 1;
538  else
539  attrtypes[attnum]->attndims = 0;
540  }
541 
542  /*
543  * If a system catalog column is collation-aware, force it to use C
544  * collation, so that its behavior is independent of the database's
545  * collation. This is essential to allow template0 to be cloned with a
546  * different database collation.
547  */
548  if (OidIsValid(attrtypes[attnum]->attcollation))
549  attrtypes[attnum]->attcollation = C_COLLATION_OID;
550 
551  attrtypes[attnum]->attcacheoff = -1;
552  attrtypes[attnum]->atttypmod = -1;
553  attrtypes[attnum]->attislocal = true;
554 
555  if (nullness == BOOTCOL_NULL_FORCE_NOT_NULL)
556  {
557  attrtypes[attnum]->attnotnull = true;
558  }
559  else if (nullness == BOOTCOL_NULL_FORCE_NULL)
560  {
561  attrtypes[attnum]->attnotnull = false;
562  }
563  else
564  {
565  Assert(nullness == BOOTCOL_NULL_AUTO);
566 
567  /*
568  * Mark as "not null" if type is fixed-width and prior columns are
569  * likewise fixed-width and not-null. This corresponds to case where
570  * column can be accessed directly via C struct declaration.
571  */
572  if (attrtypes[attnum]->attlen > 0)
573  {
574  int i;
575 
576  /* check earlier attributes */
577  for (i = 0; i < attnum; i++)
578  {
579  if (attrtypes[i]->attlen <= 0 ||
581  break;
582  }
583  if (i == attnum)
584  attrtypes[attnum]->attnotnull = true;
585  }
586  }
587 }
588 
589 
590 /* ----------------
591  * InsertOneTuple
592  *
593  * If objectid is not zero, it is a specific OID to assign to the tuple.
594  * Otherwise, an OID will be assigned (if necessary) by heap_insert.
595  * ----------------
596  */
597 void
599 {
600  HeapTuple tuple;
601  TupleDesc tupDesc;
602  int i;
603 
604  elog(DEBUG4, "inserting row with %d columns", numattr);
605 
606  tupDesc = CreateTupleDesc(numattr, attrtypes);
607  tuple = heap_form_tuple(tupDesc, values, Nulls);
608  pfree(tupDesc); /* just free's tupDesc, not the attrtypes */
609 
611  heap_freetuple(tuple);
612  elog(DEBUG4, "row inserted");
613 
614  /*
615  * Reset null markers for next tuple
616  */
617  for (i = 0; i < numattr; i++)
618  Nulls[i] = false;
619 }
620 
621 /* ----------------
622  * InsertOneValue
623  * ----------------
624  */
625 void
626 InsertOneValue(char *value, int i)
627 {
628  Oid typoid;
629  int16 typlen;
630  bool typbyval;
631  char typalign;
632  char typdelim;
633  Oid typioparam;
634  Oid typinput;
635  Oid typoutput;
636 
637  Assert(i >= 0 && i < MAXATTR);
638 
639  elog(DEBUG4, "inserting column %d value \"%s\"", i, value);
640 
641  typoid = TupleDescAttr(boot_reldesc->rd_att, i)->atttypid;
642 
643  boot_get_type_io_data(typoid,
644  &typlen, &typbyval, &typalign,
645  &typdelim, &typioparam,
646  &typinput, &typoutput);
647 
648  values[i] = OidInputFunctionCall(typinput, value, typioparam, -1);
649 
650  /*
651  * We use ereport not elog here so that parameters aren't evaluated unless
652  * the message is going to be printed, which generally it isn't
653  */
654  ereport(DEBUG4,
655  (errmsg_internal("inserted -> %s",
656  OidOutputFunctionCall(typoutput, values[i]))));
657 }
658 
659 /* ----------------
660  * InsertOneNull
661  * ----------------
662  */
663 void
665 {
666  elog(DEBUG4, "inserting column %d NULL", i);
667  Assert(i >= 0 && i < MAXATTR);
668  if (TupleDescAttr(boot_reldesc->rd_att, i)->attnotnull)
669  elog(ERROR,
670  "NULL value specified for not-null column \"%s\" of relation \"%s\"",
673  values[i] = PointerGetDatum(NULL);
674  Nulls[i] = true;
675 }
676 
677 /* ----------------
678  * cleanup
679  * ----------------
680  */
681 static void
682 cleanup(void)
683 {
684  if (boot_reldesc != NULL)
685  closerel(NULL);
686 }
687 
688 /* ----------------
689  * populate_typ_list
690  *
691  * Load the Typ list by reading pg_type.
692  * ----------------
693  */
694 static void
696 {
697  Relation rel;
698  TableScanDesc scan;
699  HeapTuple tup;
700  MemoryContext old;
701 
702  Assert(Typ == NIL);
703 
704  rel = table_open(TypeRelationId, NoLock);
705  scan = table_beginscan_catalog(rel, 0, NULL);
707  while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
708  {
709  Form_pg_type typForm = (Form_pg_type) GETSTRUCT(tup);
710  struct typmap *newtyp;
711 
712  newtyp = (struct typmap *) palloc(sizeof(struct typmap));
713  Typ = lappend(Typ, newtyp);
714 
715  newtyp->am_oid = typForm->oid;
716  memcpy(&newtyp->am_typ, typForm, sizeof(newtyp->am_typ));
717  }
719  table_endscan(scan);
720  table_close(rel, NoLock);
721 }
722 
723 /* ----------------
724  * gettype
725  *
726  * NB: this is really ugly; it will return an integer index into TypInfo[],
727  * and not an OID at all, until the first reference to a type not known in
728  * TypInfo[]. At that point it will read and cache pg_type in Typ,
729  * and subsequently return a real OID (and set the global pointer Ap to
730  * point at the found row in Typ). So caller must check whether Typ is
731  * still NIL to determine what the return value is!
732  * ----------------
733  */
734 static Oid
735 gettype(char *type)
736 {
737  if (Typ != NIL)
738  {
739  ListCell *lc;
740 
741  foreach(lc, Typ)
742  {
743  struct typmap *app = lfirst(lc);
744 
745  if (strncmp(NameStr(app->am_typ.typname), type, NAMEDATALEN) == 0)
746  {
747  Ap = app;
748  return app->am_oid;
749  }
750  }
751 
752  /*
753  * The type wasn't known; reload the pg_type contents and check again
754  * to handle composite types, added since last populating the list.
755  */
756 
758  Typ = NIL;
760 
761  /*
762  * Calling gettype would result in infinite recursion for types
763  * missing in pg_type, so just repeat the lookup.
764  */
765  foreach(lc, Typ)
766  {
767  struct typmap *app = lfirst(lc);
768 
769  if (strncmp(NameStr(app->am_typ.typname), type, NAMEDATALEN) == 0)
770  {
771  Ap = app;
772  return app->am_oid;
773  }
774  }
775  }
776  else
777  {
778  int i;
779 
780  for (i = 0; i < n_types; i++)
781  {
782  if (strncmp(type, TypInfo[i].name, NAMEDATALEN) == 0)
783  return i;
784  }
785  /* Not in TypInfo, so we'd better be able to read pg_type now */
786  elog(DEBUG4, "external type: %s", type);
788  return gettype(type);
789  }
790  elog(ERROR, "unrecognized type \"%s\"", type);
791  /* not reached, here to make compiler happy */
792  return 0;
793 }
794 
795 /* ----------------
796  * boot_get_type_io_data
797  *
798  * Obtain type I/O information at bootstrap time. This intentionally has
799  * almost the same API as lsyscache.c's get_type_io_data, except that
800  * we only support obtaining the typinput and typoutput routines, not
801  * the binary I/O routines. It is exported so that array_in and array_out
802  * can be made to work during early bootstrap.
803  * ----------------
804  */
805 void
807  int16 *typlen,
808  bool *typbyval,
809  char *typalign,
810  char *typdelim,
811  Oid *typioparam,
812  Oid *typinput,
813  Oid *typoutput)
814 {
815  if (Typ != NIL)
816  {
817  /* We have the boot-time contents of pg_type, so use it */
818  struct typmap *ap = NULL;
819  ListCell *lc;
820 
821  foreach(lc, Typ)
822  {
823  ap = lfirst(lc);
824  if (ap->am_oid == typid)
825  break;
826  }
827 
828  if (!ap || ap->am_oid != typid)
829  elog(ERROR, "type OID %u not found in Typ list", typid);
830 
831  *typlen = ap->am_typ.typlen;
832  *typbyval = ap->am_typ.typbyval;
833  *typalign = ap->am_typ.typalign;
834  *typdelim = ap->am_typ.typdelim;
835 
836  /* XXX this logic must match getTypeIOParam() */
837  if (OidIsValid(ap->am_typ.typelem))
838  *typioparam = ap->am_typ.typelem;
839  else
840  *typioparam = typid;
841 
842  *typinput = ap->am_typ.typinput;
843  *typoutput = ap->am_typ.typoutput;
844  }
845  else
846  {
847  /* We don't have pg_type yet, so use the hard-wired TypInfo array */
848  int typeindex;
849 
850  for (typeindex = 0; typeindex < n_types; typeindex++)
851  {
852  if (TypInfo[typeindex].oid == typid)
853  break;
854  }
855  if (typeindex >= n_types)
856  elog(ERROR, "type OID %u not found in TypInfo", typid);
857 
858  *typlen = TypInfo[typeindex].len;
859  *typbyval = TypInfo[typeindex].byval;
860  *typalign = TypInfo[typeindex].align;
861  /* We assume typdelim is ',' for all boot-time types */
862  *typdelim = ',';
863 
864  /* XXX this logic must match getTypeIOParam() */
865  if (OidIsValid(TypInfo[typeindex].elem))
866  *typioparam = TypInfo[typeindex].elem;
867  else
868  *typioparam = typid;
869 
870  *typinput = TypInfo[typeindex].inproc;
871  *typoutput = TypInfo[typeindex].outproc;
872  }
873 }
874 
875 /* ----------------
876  * AllocateAttribute
877  *
878  * Note: bootstrap never sets any per-column ACLs, so we only need
879  * ATTRIBUTE_FIXED_PART_SIZE space per attribute.
880  * ----------------
881  */
882 static Form_pg_attribute
884 {
885  return (Form_pg_attribute)
887 }
888 
889 /*
890  * index_register() -- record an index that has been set up for building
891  * later.
892  *
893  * At bootstrap time, we define a bunch of indexes on system catalogs.
894  * We postpone actually building the indexes until just before we're
895  * finished with initialization, however. This is because the indexes
896  * themselves have catalog entries, and those have to be included in the
897  * indexes on those catalogs. Doing it in two phases is the simplest
898  * way of making sure the indexes have the right contents at the end.
899  */
900 void
902  Oid ind,
903  const IndexInfo *indexInfo)
904 {
905  IndexList *newind;
906  MemoryContext oldcxt;
907 
908  /*
909  * XXX mao 10/31/92 -- don't gc index reldescs, associated info at
910  * bootstrap time. we'll declare the indexes now, but want to create them
911  * later.
912  */
913 
914  if (nogc == NULL)
916  "BootstrapNoGC",
918 
919  oldcxt = MemoryContextSwitchTo(nogc);
920 
921  newind = (IndexList *) palloc(sizeof(IndexList));
922  newind->il_heap = heap;
923  newind->il_ind = ind;
924  newind->il_info = (IndexInfo *) palloc(sizeof(IndexInfo));
925 
926  memcpy(newind->il_info, indexInfo, sizeof(IndexInfo));
927  /* expressions will likely be null, but may as well copy it */
928  newind->il_info->ii_Expressions =
929  copyObject(indexInfo->ii_Expressions);
930  newind->il_info->ii_ExpressionsState = NIL;
931  /* predicate will likely be null, but may as well copy it */
932  newind->il_info->ii_Predicate =
933  copyObject(indexInfo->ii_Predicate);
934  newind->il_info->ii_PredicateState = NULL;
935  /* no exclusion constraints at bootstrap time, so no need to copy */
936  Assert(indexInfo->ii_ExclusionOps == NULL);
937  Assert(indexInfo->ii_ExclusionProcs == NULL);
938  Assert(indexInfo->ii_ExclusionStrats == NULL);
939 
940  newind->il_next = ILHead;
941  ILHead = newind;
942 
943  MemoryContextSwitchTo(oldcxt);
944 }
945 
946 
947 /*
948  * build_indices -- fill in all the indexes registered earlier
949  */
950 void
952 {
953  for (; ILHead != NULL; ILHead = ILHead->il_next)
954  {
955  Relation heap;
956  Relation ind;
957 
958  /* need not bother with locks during bootstrap */
959  heap = table_open(ILHead->il_heap, NoLock);
961 
962  index_build(heap, ind, ILHead->il_info, false, false);
963 
965  table_close(heap, NoLock);
966  }
967 }
#define write_stderr(str)
Definition: parallel.c:184
static Oid gettype(char *type)
Definition: bootstrap.c:735
static Datum values[MAXATTR]
Definition: bootstrap.c:152
void closerel(char *relname)
Definition: bootstrap.c:453
static void populate_typ_list(void)
Definition: bootstrap.c:695
static void CheckerModeMain(void)
Definition: bootstrap.c:181
void build_indices(void)
Definition: bootstrap.c:951
void InsertOneValue(char *value, int i)
Definition: bootstrap.c:626
static void cleanup(void)
Definition: bootstrap.c:682
static const int n_types
Definition: bootstrap.c:141
void InsertOneNull(int i)
Definition: bootstrap.c:664
static const struct typinfo TypInfo[]
Definition: bootstrap.c:88
Relation boot_reldesc
Definition: bootstrap.c:59
static struct typmap * Ap
Definition: bootstrap.c:150
static List * Typ
Definition: bootstrap.c:149
void InsertOneTuple(void)
Definition: bootstrap.c:598
struct _IndexList IndexList
static void bootstrap_signals(void)
Definition: bootstrap.c:381
Form_pg_attribute attrtypes[MAXATTR]
Definition: bootstrap.c:61
void boot_get_type_io_data(Oid typid, int16 *typlen, bool *typbyval, char *typalign, char *typdelim, Oid *typioparam, Oid *typinput, Oid *typoutput)
Definition: bootstrap.c:806
int numattr
Definition: bootstrap.c:62
static Form_pg_attribute AllocateAttribute(void)
Definition: bootstrap.c:883
static MemoryContext nogc
Definition: bootstrap.c:155
void BootstrapModeMain(int argc, char *argv[], bool check_only)
Definition: bootstrap.c:199
void DefineAttr(char *name, char *type, int attnum, int nullness)
Definition: bootstrap.c:490
uint32 bootstrap_data_checksum_version
Definition: bootstrap.c:44
static bool Nulls[MAXATTR]
Definition: bootstrap.c:153
void index_register(Oid heap, Oid ind, const IndexInfo *indexInfo)
Definition: bootstrap.c:901
void boot_openrel(char *relname)
Definition: bootstrap.c:408
static IndexList * ILHead
Definition: bootstrap.c:171
#define BOOTCOL_NULL_FORCE_NULL
Definition: bootstrap.h:28
#define MAXATTR
Definition: bootstrap.h:25
int boot_yyparse(void)
#define BOOTCOL_NULL_FORCE_NOT_NULL
Definition: bootstrap.h:29
#define BOOTCOL_NULL_AUTO
Definition: bootstrap.h:27
#define PG_DATA_CHECKSUM_VERSION
Definition: bufpage.h:203
#define NameStr(name)
Definition: c.h:746
unsigned int uint32
Definition: c.h:506
signed short int16
Definition: c.h:493
#define Assert(condition)
Definition: c.h:858
#define MemSet(start, val, len)
Definition: c.h:1020
#define OidIsValid(objectId)
Definition: c.h:775
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define WARNING
Definition: elog.h:36
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
#define DEBUG4
Definition: elog.h:27
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1754
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1763
bool IsUnderPostmaster
Definition: globals.c:117
char OutputFileName[MAXPGPATH]
Definition: globals.c:76
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4285
bool SelectConfigFiles(const char *userDoption, const char *progname)
Definition: guc.c:1786
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6321
void InitializeGUCOptions(void)
Definition: guc.c:1532
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
@ PGC_S_ARGV
Definition: guc.h:113
@ PGC_INTERNAL
Definition: guc.h:69
@ PGC_POSTMASTER
Definition: guc.h:70
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1251
void simple_heap_insert(Relation relation, HeapTuple tup)
Definition: heapam.c:2624
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1116
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
void index_build(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool isreindex, bool parallel)
Definition: index.c:2941
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
static struct @155 value
void proc_exit(int code)
Definition: ipc.c:104
void CreateSharedMemoryAndSemaphores(void)
Definition: ipci.c:199
int i
Definition: isn.c:73
List * lappend(List *list, void *datum)
Definition: list.c:339
void list_free_deep(List *list)
Definition: list.c:1560
#define NoLock
Definition: lockdefs.h:34
const char * progname
Definition: main.c:44
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:424
char * pstrdup(const char *in)
Definition: mcxt.c:1695
void pfree(void *pointer)
Definition: mcxt.c:1520
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1214
void * palloc(Size size)
Definition: mcxt.c:1316
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
@ NormalProcessing
Definition: miscadmin.h:449
@ BootstrapProcessing
Definition: miscadmin.h:447
#define SetProcessingMode(mode)
Definition: miscadmin.h:460
void ChangeToDataDir(void)
Definition: miscinit.c:454
void InitStandaloneProcess(const char *argv0)
Definition: miscinit.c:181
bool IgnoreSystemIndexes
Definition: miscinit.c:80
void checkDataDir(void)
Definition: miscinit.c:341
void CreateDataDirLockFile(bool amPostmaster)
Definition: miscinit.c:1455
void namestrcpy(Name name, const char *str)
Definition: name.c:233
#define copyObject(obj)
Definition: nodes.h:224
NameData attname
Definition: pg_attribute.h:41
#define ATTRIBUTE_FIXED_PART_SIZE
Definition: pg_attribute.h:201
int16 attnum
Definition: pg_attribute.h:74
int16 attlen
Definition: pg_attribute.h:59
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
bool attnotnull
Definition: pg_attribute.h:130
NameData relname
Definition: pg_class.h:38
#define NAMEDATALEN
#define MAXPGPATH
PGDLLIMPORT int optind
Definition: getopt.c:50
int getopt(int nargc, char *const *nargv, const char *ostr)
Definition: getopt.c:71
PGDLLIMPORT char * optarg
Definition: getopt.c:52
#define lfirst(lc)
Definition: pg_list.h:172
#define NIL
Definition: pg_list.h:68
char typalign
Definition: pg_type.h:176
FormData_pg_type
Definition: pg_type.h:254
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
pqsigfunc pqsignal(int signo, pqsigfunc func)
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
static const char * userDoption
Definition: postgres.c:161
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
void InitializeMaxBackends(void)
Definition: postinit.c:575
void BaseInit(void)
Definition: postinit.c:645
void InitPostgres(const char *in_dbname, Oid dboid, const char *username, Oid useroid, bits32 flags, char *out_dbname)
Definition: postinit.c:736
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
MemoryContextSwitchTo(old_ctx)
#define RelationGetNumberOfAttributes(relation)
Definition: rel.h:511
#define RelationGetRelationName(relation)
Definition: rel.h:539
void RelationMapFinishBootstrap(void)
Definition: relmapper.c:625
@ ForwardScanDirection
Definition: sdir.h:28
void InitProcess(void)
Definition: proc.c:296
uint16 * ii_ExclusionStrats
Definition: execnodes.h:193
ExprState * ii_PredicateState
Definition: execnodes.h:190
Oid * ii_ExclusionOps
Definition: execnodes.h:191
List * ii_ExpressionsState
Definition: execnodes.h:188
List * ii_Expressions
Definition: execnodes.h:187
Oid * ii_ExclusionProcs
Definition: execnodes.h:192
List * ii_Predicate
Definition: execnodes.h:189
Definition: pg_list.h:54
TupleDesc rd_att
Definition: rel.h:112
Oid il_heap
Definition: bootstrap.c:165
struct _IndexList * il_next
Definition: bootstrap.c:168
Oid il_ind
Definition: bootstrap.c:166
IndexInfo * il_info
Definition: bootstrap.c:167
char align
Definition: bootstrap.c:81
Oid outproc
Definition: bootstrap.c:85
int16 len
Definition: bootstrap.c:79
Oid oid
Definition: bootstrap.c:77
bool byval
Definition: bootstrap.c:80
char name[NAMEDATALEN]
Definition: bootstrap.c:76
Oid collation
Definition: bootstrap.c:83
Oid elem
Definition: bootstrap.c:78
char storage
Definition: bootstrap.c:82
Oid inproc
Definition: bootstrap.c:84
Oid am_oid
Definition: bootstrap.c:145
FormData_pg_type am_typ
Definition: bootstrap.c:146
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
Relation table_openrv(const RangeVar *relation, LOCKMODE lockmode)
Definition: table.c:83
TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, struct ScanKeyData *key)
Definition: tableam.c:112
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:1019
char * flag(int b)
Definition: test-ctype.c:33
#define InvalidCompressionMethod
TupleDesc CreateTupleDesc(int natts, Form_pg_attribute *attrs)
Definition: tupdesc.c:112
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
const char * type
const char * name
#define SIGHUP
Definition: win32_port.h:168
#define SIG_DFL
Definition: win32_port.h:163
#define SIGQUIT
Definition: win32_port.h:169
void StartTransactionCommand(void)
Definition: xact.c:2995
void CommitTransactionCommand(void)
Definition: xact.c:3093
void BootStrapXLOG(void)
Definition: xlog.c:5000