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