* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.172 2003/12/25 03:52:50 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.188 2004/07/21 20:22:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include <unistd.h>
-#include <time.h>
#include <signal.h>
#include <setjmp.h>
#ifdef HAVE_GETOPT_H
#include "executor/executor.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
+#include "postmaster/bgwriter.h"
+#include "postmaster/pg_autovacuum.h"
#include "storage/freespace.h"
#include "storage/ipc.h"
#include "storage/pg_shmem.h"
#include "utils/fmgroids.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
+#include "utils/ps_status.h"
#include "utils/relcache.h"
#define ALLOC(t, c) ((t *) calloc((unsigned)(c), sizeof(t)))
-#ifdef EXEC_BACKEND
-typedef struct Port Port;
-extern void SSDataBaseInit(int);
-extern void read_backend_variables(pid_t, Port*);
-#endif
-
extern int Int_yyparse(void);
+static void usage(void);
+static void bootstrap_signals(void);
static hashnode *AddStr(char *str, int strlength, int mderef);
static Form_pg_attribute AllocateAttribute(void);
-static bool BootstrapAlreadySeen(Oid id);
static int CompHash(char *str, int len);
static hashnode *FindStr(char *str, int length, hashnode *mderef);
static Oid gettype(char *type);
Oid oid;
Oid elem;
int16 len;
+ bool byval;
+ char align;
+ char storage;
Oid inproc;
Oid outproc;
};
-static struct typinfo Procid[] = {
- {"bool", BOOLOID, 0, 1, F_BOOLIN, F_BOOLOUT},
- {"bytea", BYTEAOID, 0, -1, F_BYTEAIN, F_BYTEAOUT},
- {"char", CHAROID, 0, 1, F_CHARIN, F_CHAROUT},
- {"name", NAMEOID, 0, NAMEDATALEN, F_NAMEIN, F_NAMEOUT},
- {"int2", INT2OID, 0, 2, F_INT2IN, F_INT2OUT},
- {"int2vector", INT2VECTOROID, 0, INDEX_MAX_KEYS * 2, F_INT2VECTORIN, F_INT2VECTOROUT},
- {"int4", INT4OID, 0, 4, F_INT4IN, F_INT4OUT},
- {"regproc", REGPROCOID, 0, 4, F_REGPROCIN, F_REGPROCOUT},
- {"regclass", REGCLASSOID, 0, 4, F_REGCLASSIN, F_REGCLASSOUT},
- {"regtype", REGTYPEOID, 0, 4, F_REGTYPEIN, F_REGTYPEOUT},
- {"text", TEXTOID, 0, -1, F_TEXTIN, F_TEXTOUT},
- {"oid", OIDOID, 0, 4, F_OIDIN, F_OIDOUT},
- {"tid", TIDOID, 0, 6, F_TIDIN, F_TIDOUT},
- {"xid", XIDOID, 0, 4, F_XIDIN, F_XIDOUT},
- {"cid", CIDOID, 0, 4, F_CIDIN, F_CIDOUT},
- {"oidvector", OIDVECTOROID, 0, INDEX_MAX_KEYS * 4, F_OIDVECTORIN, F_OIDVECTOROUT},
- {"smgr", 210, 0, 2, F_SMGRIN, F_SMGROUT},
- {"_int4", 1007, INT4OID, -1, F_ARRAY_IN, F_ARRAY_OUT},
- {"_aclitem", 1034, 1033, -1, F_ARRAY_IN, F_ARRAY_OUT}
+static const struct typinfo TypInfo[] = {
+ {"bool", BOOLOID, 0, 1, true, 'c', 'p',
+ F_BOOLIN, F_BOOLOUT},
+ {"bytea", BYTEAOID, 0, -1, false, 'i', 'x',
+ F_BYTEAIN, F_BYTEAOUT},
+ {"char", CHAROID, 0, 1, true, 'c', 'p',
+ F_CHARIN, F_CHAROUT},
+ {"name", NAMEOID, CHAROID, NAMEDATALEN, false, 'i', 'p',
+ F_NAMEIN, F_NAMEOUT},
+ {"int2", INT2OID, 0, 2, true, 's', 'p',
+ F_INT2IN, F_INT2OUT},
+ {"int4", INT4OID, 0, 4, true, 'i', 'p',
+ F_INT4IN, F_INT4OUT},
+ {"regproc", REGPROCOID, 0, 4, true, 'i', 'p',
+ F_REGPROCIN, F_REGPROCOUT},
+ {"regclass", REGCLASSOID, 0, 4, true, 'i', 'p',
+ F_REGCLASSIN, F_REGCLASSOUT},
+ {"regtype", REGTYPEOID, 0, 4, true, 'i', 'p',
+ F_REGTYPEIN, F_REGTYPEOUT},
+ {"text", TEXTOID, 0, -1, false, 'i', 'x',
+ F_TEXTIN, F_TEXTOUT},
+ {"oid", OIDOID, 0, 4, true, 'i', 'p',
+ F_OIDIN, F_OIDOUT},
+ {"tid", TIDOID, 0, 6, false, 's', 'p',
+ F_TIDIN, F_TIDOUT},
+ {"xid", XIDOID, 0, 4, true, 'i', 'p',
+ F_XIDIN, F_XIDOUT},
+ {"cid", CIDOID, 0, 4, true, 'i', 'p',
+ F_CIDIN, F_CIDOUT},
+ {"int2vector", INT2VECTOROID, INT2OID, INDEX_MAX_KEYS * 2, false, 's', 'p',
+ F_INT2VECTORIN, F_INT2VECTOROUT},
+ {"oidvector", OIDVECTOROID, OIDOID, INDEX_MAX_KEYS * 4, false, 'i', 'p',
+ F_OIDVECTORIN, F_OIDVECTOROUT},
+ {"_int4", INT4ARRAYOID, INT4OID, -1, false, 'i', 'x',
+ F_ARRAY_IN, F_ARRAY_OUT},
+ {"_text", 1009, TEXTOID, -1, false, 'i', 'x',
+ F_ARRAY_IN, F_ARRAY_OUT},
+ {"_aclitem", 1034, ACLITEMOID, -1, false, 'i', 'x',
+ F_ARRAY_IN, F_ARRAY_OUT}
};
-static int n_types = sizeof(Procid) / sizeof(struct typinfo);
+static const int n_types = sizeof(TypInfo) / sizeof(struct typinfo);
struct typmap
{ /* a hack */
FormData_pg_type am_typ;
};
-static struct typmap **Typ = (struct typmap **) NULL;
-static struct typmap *Ap = (struct typmap *) NULL;
+static struct typmap **Typ = NULL;
+static struct typmap *Ap = NULL;
static int Warnings = 0;
static char Blanks[MAXATTR];
struct _IndexList *il_next;
} IndexList;
-static IndexList *ILHead = (IndexList *) NULL;
-
-
-/* ----------------------------------------------------------------
- * misc functions
- * ----------------------------------------------------------------
- */
+static IndexList *ILHead = NULL;
-/* ----------------
- * error handling / abort routines
- * ----------------
- */
-void
-err_out(void)
-{
- Warnings++;
- cleanup();
-}
-/* usage:
- * usage help for the bootstrap backend
- */
-static void
-usage(void)
-{
- fprintf(stderr,
- gettext("Usage:\n"
- " postgres -boot [OPTION]... DBNAME\n"
- " -c NAME=VALUE set run-time parameter\n"
- " -d 1-5 debug level\n"
- " -D datadir data directory\n"
- " -F turn off fsync\n"
- " -o file send debug output to file\n"
- " -x num internal use\n"));
-
- proc_exit(1);
-}
-
-
-
-int
-BootstrapMain(int argc, char *argv[])
-/* ----------------------------------------------------------------
- * The main loop for handling the backend in bootstrap mode
- * the bootstrap mode is used to initialize the template database
- * the bootstrap backend doesn't speak SQL, but instead expects
+/*
+ * The main entry point for running the backend in bootstrap mode
+ *
+ * The bootstrap mode is used to initialize the template database.
+ * The bootstrap backend doesn't speak SQL, but instead expects
* commands in a special bootstrap language.
*
- * The arguments passed in to BootstrapMain are the run-time arguments
- * without the argument '-boot', the caller is required to have
- * removed -boot from the run-time args
- * ----------------------------------------------------------------
+ * For historical reasons, BootstrapMain is also used as the control
+ * routine for non-backend subprocesses launched by the postmaster,
+ * such as startup and shutdown.
*/
+int
+BootstrapMain(int argc, char *argv[])
{
int i;
char *dbname;
int flag;
int xlogop = BS_XLOG_NOP;
- char *potential_DataDir = NULL;
+ char *userPGDATA = NULL;
/*
* initialize globals
*/
-
MyProcPid = getpid();
/*
*
* If we are running under the postmaster, this is done already.
*/
- if (!IsUnderPostmaster || ExecBackend)
+ if (!IsUnderPostmaster)
MemoryContextInit();
/*
if (!IsUnderPostmaster)
{
InitializeGUCOptions();
- potential_DataDir = getenv("PGDATA"); /* Null if no PGDATA
- * variable */
+ userPGDATA = getenv("PGDATA"); /* Null if no PGDATA variable */
+ }
+
+ /* Ignore the initial -boot argument, if present */
+ if (argc > 1 && strcmp(argv[1], "-boot") == 0)
+ {
+ argv++;
+ argc--;
}
while ((flag = getopt(argc, argv, "B:c:d:D:Fo:p:x:-:")) != -1)
switch (flag)
{
case 'D':
- potential_DataDir = optarg;
+ userPGDATA = optarg;
break;
case 'd':
{
xlogop = atoi(optarg);
break;
case 'p':
-#ifdef EXEC_BACKEND
- IsUnderPostmaster = true;
-#endif
dbname = strdup(optarg);
- break;
+ break;
case 'B':
SetConfigOption("shared_buffers", optarg, PGC_POSTMASTER, PGC_S_ARGV);
break;
if (!dbname || argc != optind)
usage();
- if (!IsUnderPostmaster || ExecBackend)
+ if (!IsUnderPostmaster)
{
- if (!potential_DataDir)
+ if (!userPGDATA)
{
- fprintf(stderr,
- gettext("%s does not know where to find the database system data.\n"
- "You must specify the directory that contains the database system\n"
- "either by specifying the -D invocation option or by setting the\n"
- "PGDATA environment variable.\n"),
- argv[0]);
+ write_stderr("%s does not know where to find the database system data.\n"
+ "You must specify the directory that contains the database system\n"
+ "either by specifying the -D invocation option or by setting the\n"
+ "PGDATA environment variable.\n",
+ argv[0]);
proc_exit(1);
}
- SetDataDir(potential_DataDir);
+ SetDataDir(userPGDATA);
}
/* Validate we have been given a reasonable-looking DataDir */
Assert(DataDir);
ValidatePgVersion(DataDir);
- /* Acquire configuration parameters */
+ /*
+ * Identify myself via ps
+ */
if (IsUnderPostmaster)
{
-#ifdef EXEC_BACKEND
- read_nondefault_variables();
- read_backend_variables(getpid(),NULL);
+ const char *statmsg;
- SSDataBaseInit(xlogop);
-#endif
+ switch (xlogop)
+ {
+ case BS_XLOG_STARTUP:
+ statmsg = "startup process";
+ break;
+ case BS_XLOG_BGWRITER:
+ statmsg = "writer process";
+ break;
+ case BS_XLOG_AUTOVAC:
+ statmsg = "auto vacuum process";
+ break;
+ default:
+ statmsg = "??? process";
+ break;
+ }
+ init_ps_display(statmsg, "", "");
+ set_ps_display("");
}
- else
- ProcessConfigFile(PGC_POSTMASTER);
- if (IsUnderPostmaster)
+ /* Acquire configuration parameters, unless inherited from postmaster */
+ if (!IsUnderPostmaster)
{
- /*
- * Properly accept or ignore signals the postmaster might send us
- */
- pqsignal(SIGHUP, SIG_IGN);
- pqsignal(SIGINT, SIG_IGN); /* ignore query-cancel */
- pqsignal(SIGTERM, die);
- pqsignal(SIGQUIT, quickdie);
- pqsignal(SIGALRM, SIG_IGN);
- pqsignal(SIGPIPE, SIG_IGN);
- pqsignal(SIGUSR1, SIG_IGN);
- pqsignal(SIGUSR2, SIG_IGN);
-
- /*
- * Reset some signals that are accepted by postmaster but not here
- */
- pqsignal(SIGCHLD, SIG_DFL);
- pqsignal(SIGTTIN, SIG_DFL);
- pqsignal(SIGTTOU, SIG_DFL);
- pqsignal(SIGCONT, SIG_DFL);
- pqsignal(SIGWINCH, SIG_DFL);
+ ProcessConfigFile(PGC_POSTMASTER);
- /*
- * Unblock signals (they were blocked when the postmaster forked
- * us)
- */
- PG_SETMASK(&UnBlockSig);
+ /* If timezone is not set, determine what the OS uses */
+ pg_timezone_initialize();
}
- else
- {
- /* Set up appropriately for interactive use */
- pqsignal(SIGHUP, die);
- pqsignal(SIGINT, die);
- pqsignal(SIGTERM, die);
- pqsignal(SIGQUIT, die);
- /*
- * Create lockfile for data directory.
- */
+ /* If standalone, create lockfile for data directory */
+ if (!IsUnderPostmaster)
CreateDataDirLockFile(DataDir, false);
- }
SetProcessingMode(BootstrapProcessing);
IgnoreSystemIndexes(true);
-#ifdef EXEC_BACKEND
- if (IsUnderPostmaster)
- AttachSharedMemoryAndSemaphores();
-#endif
XLOGPathInit();
BaseInit();
switch (xlogop)
{
case BS_XLOG_BGWRITER:
- InitDummyProcess(DUMMY_PROC_BGWRITER);
+ InitDummyProcess(DUMMY_PROC_BGWRITER);
break;
-
+ case BS_XLOG_AUTOVAC:
+ InitDummyProcess(DUMMY_PROC_AUTOVAC);
+ break;
+
default:
- InitDummyProcess(DUMMY_PROC_DEFAULT);
+ InitDummyProcess(DUMMY_PROC_DEFAULT);
break;
}
}
switch (xlogop)
{
case BS_XLOG_NOP:
+ bootstrap_signals();
break;
case BS_XLOG_BOOTSTRAP:
+ bootstrap_signals();
BootStrapXLOG();
StartupXLOG();
break;
- case BS_XLOG_CHECKPOINT:
- CreateDummyCaches();
- CreateCheckPoint(false, false);
- SetSavedRedoRecPtr(); /* pass redo ptr back to
- * postmaster */
- proc_exit(0); /* done */
-
- case BS_XLOG_BGWRITER:
- CreateDummyCaches();
- BufferBackgroundWriter();
- proc_exit(0); /* done */
-
case BS_XLOG_STARTUP:
+ bootstrap_signals();
StartupXLOG();
LoadFreeSpaceMap();
- proc_exit(0); /* done */
-
- case BS_XLOG_SHUTDOWN:
- ShutdownXLOG(0, 0);
- DumpFreeSpaceMap(0, 0);
- proc_exit(0); /* done */
+ proc_exit(0); /* startup done */
+ case BS_XLOG_BGWRITER:
+ /* don't set signals, bgwriter has its own agenda */
+ InitXLOGAccess();
+ BackgroundWriterMain();
+ proc_exit(1); /* should never return */
+
+ case BS_XLOG_AUTOVAC:
+ /* don't set signals, autovac has its own agenda */
+ InitXLOGAccess();
+ AutoVacMain();
+ proc_exit(1); /* should never return */
+
default:
elog(PANIC, "unrecognized XLOG op: %d", xlogop);
- proc_exit(0);
+ proc_exit(1);
}
SetProcessingMode(BootstrapProcessing);
/* Initialize stuff for bootstrap-file processing */
for (i = 0; i < MAXATTR; i++)
{
- attrtypes[i] = (Form_pg_attribute) NULL;
+ attrtypes[i] = NULL;
Blanks[i] = ' ';
}
for (i = 0; i < STRTABLESIZE; ++i)
/* not reached, here to make compiler happy */
return 0;
+}
+
+
+/* ----------------------------------------------------------------
+ * misc functions
+ * ----------------------------------------------------------------
+ */
+
+/* usage:
+ * usage help for the bootstrap backend
+ */
+static void
+usage(void)
+{
+ write_stderr("Usage:\n"
+ " postgres -boot [OPTION]... DBNAME\n"
+ " -c NAME=VALUE set run-time parameter\n"
+ " -d 1-5 debug level\n"
+ " -D datadir data directory\n"
+ " -F turn off fsync\n"
+ " -o file send debug output to file\n"
+ " -x num internal use\n");
+ proc_exit(1);
}
+/*
+ * Set up signal handling for a bootstrap process
+ */
+static void
+bootstrap_signals(void)
+{
+ if (IsUnderPostmaster)
+ {
+ /*
+ * Properly accept or ignore signals the postmaster might send us
+ */
+ pqsignal(SIGHUP, SIG_IGN);
+ pqsignal(SIGINT, SIG_IGN); /* ignore query-cancel */
+ pqsignal(SIGTERM, die);
+ pqsignal(SIGQUIT, quickdie);
+ pqsignal(SIGALRM, SIG_IGN);
+ pqsignal(SIGPIPE, SIG_IGN);
+ pqsignal(SIGUSR1, SIG_IGN);
+ pqsignal(SIGUSR2, SIG_IGN);
+
+ /*
+ * Reset some signals that are accepted by postmaster but not here
+ */
+ pqsignal(SIGCHLD, SIG_DFL);
+ pqsignal(SIGTTIN, SIG_DFL);
+ pqsignal(SIGTTOU, SIG_DFL);
+ pqsignal(SIGCONT, SIG_DFL);
+ pqsignal(SIGWINCH, SIG_DFL);
+
+ /*
+ * Unblock signals (they were blocked when the postmaster forked
+ * us)
+ */
+ PG_SETMASK(&UnBlockSig);
+ }
+ else
+ {
+ /* Set up appropriately for interactive use */
+ pqsignal(SIGHUP, die);
+ pqsignal(SIGINT, die);
+ pqsignal(SIGTERM, die);
+ pqsignal(SIGQUIT, die);
+ }
+}
+
+/* ----------------
+ * error handling / abort routines
+ * ----------------
+ */
+void
+err_out(void)
+{
+ Warnings++;
+ cleanup();
+}
+
+
/* ----------------------------------------------------------------
* MANUAL BACKEND INTERACTIVE INTERFACE COMMANDS
* ----------------------------------------------------------------
if (strlen(relname) >= NAMEDATALEN - 1)
relname[NAMEDATALEN - 1] = '\0';
- if (Typ == (struct typmap **) NULL)
+ if (Typ == NULL)
{
rel = heap_openr(TypeRelationName, NoLock);
- scan = heap_beginscan(rel, SnapshotNow, 0, (ScanKey) NULL);
+ scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
i = 0;
while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
++i;
app = Typ = ALLOC(struct typmap *, i + 1);
while (i-- > 0)
*app++ = ALLOC(struct typmap, 1);
- *app = (struct typmap *) NULL;
- scan = heap_beginscan(rel, SnapshotNow, 0, (ScanKey) NULL);
+ *app = NULL;
+ scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
app = Typ;
while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
{
elog(DEBUG4, "close relation %s", relname ? relname : "(null)");
heap_close(boot_reldesc, NoLock);
- boot_reldesc = (Relation) NULL;
+ boot_reldesc = NULL;
}
}
closerel(relname);
}
- if (attrtypes[attnum] == (Form_pg_attribute) NULL)
+ if (attrtypes[attnum] == NULL)
attrtypes[attnum] = AllocateAttribute();
MemSet(attrtypes[attnum], 0, ATTRIBUTE_TUPLE_SIZE);
typeoid = gettype(type);
- if (Typ != (struct typmap **) NULL)
+ if (Typ != NULL)
{
attrtypes[attnum]->atttypid = Ap->am_oid;
attlen = attrtypes[attnum]->attlen = Ap->am_typ.typlen;
attrtypes[attnum]->attbyval = Ap->am_typ.typbyval;
attrtypes[attnum]->attstorage = Ap->am_typ.typstorage;
attrtypes[attnum]->attalign = Ap->am_typ.typalign;
+ /* if an array type, assume 1-dimensional attribute */
+ if (Ap->am_typ.typelem != InvalidOid && Ap->am_typ.typlen < 0)
+ attrtypes[attnum]->attndims = 1;
+ else
+ attrtypes[attnum]->attndims = 0;
}
else
{
- attrtypes[attnum]->atttypid = Procid[typeoid].oid;
- attlen = attrtypes[attnum]->attlen = Procid[typeoid].len;
-
- /*
- * Cheat like mad to fill in these items from the length only.
- * This only has to work for types that appear in Procid[].
- */
- switch (attlen)
- {
- case 1:
- attrtypes[attnum]->attbyval = true;
- attrtypes[attnum]->attstorage = 'p';
- attrtypes[attnum]->attalign = 'c';
- break;
- case 2:
- attrtypes[attnum]->attbyval = true;
- attrtypes[attnum]->attstorage = 'p';
- attrtypes[attnum]->attalign = 's';
- break;
- case 4:
- attrtypes[attnum]->attbyval = true;
- attrtypes[attnum]->attstorage = 'p';
- attrtypes[attnum]->attalign = 'i';
- break;
- case -1:
- attrtypes[attnum]->attbyval = false;
- attrtypes[attnum]->attstorage = 'x';
- attrtypes[attnum]->attalign = 'i';
- break;
- default:
- /* TID and fixed-length arrays, such as oidvector */
- attrtypes[attnum]->attbyval = false;
- attrtypes[attnum]->attstorage = 'p';
- attrtypes[attnum]->attalign = 'i';
- break;
- }
+ attrtypes[attnum]->atttypid = TypInfo[typeoid].oid;
+ attlen = attrtypes[attnum]->attlen = TypInfo[typeoid].len;
+ attrtypes[attnum]->attbyval = TypInfo[typeoid].byval;
+ attrtypes[attnum]->attstorage = TypInfo[typeoid].storage;
+ attrtypes[attnum]->attalign = TypInfo[typeoid].align;
+ /* if an array type, assume 1-dimensional attribute */
+ if (TypInfo[typeoid].elem != InvalidOid && attlen < 0)
+ attrtypes[attnum]->attndims = 1;
+ else
+ attrtypes[attnum]->attndims = 0;
}
+
+ attrtypes[attnum]->attstattarget = -1;
attrtypes[attnum]->attcacheoff = -1;
attrtypes[attnum]->atttypmod = -1;
attrtypes[attnum]->attislocal = true;
void
InsertOneValue(char *value, int i)
{
- int typeindex;
+ Oid typoid;
+ Oid typioparam;
+ Oid typinput;
+ Oid typoutput;
char *prt;
- struct typmap **app;
AssertArg(i >= 0 || i < MAXATTR);
elog(DEBUG4, "inserting column %d value \"%s\"", i, value);
- if (Typ != (struct typmap **) NULL)
+ if (Typ != NULL)
{
+ struct typmap **app;
struct typmap *ap;
- elog(DEBUG4, "Typ != NULL");
+ elog(DEBUG5, "Typ != NULL");
+ typoid = boot_reldesc->rd_att->attrs[i]->atttypid;
app = Typ;
- while (*app && (*app)->am_oid != boot_reldesc->rd_att->attrs[i]->atttypid)
+ while (*app && (*app)->am_oid != typoid)
++app;
ap = *app;
if (ap == NULL)
- {
- elog(FATAL, "could not find atttypid %u in Typ list",
- boot_reldesc->rd_att->attrs[i]->atttypid);
- }
- values[i] = OidFunctionCall3(ap->am_typ.typinput,
- CStringGetDatum(value),
- ObjectIdGetDatum(ap->am_typ.typelem),
- Int32GetDatum(-1));
- prt = DatumGetCString(OidFunctionCall3(ap->am_typ.typoutput,
- values[i],
- ObjectIdGetDatum(ap->am_typ.typelem),
- Int32GetDatum(-1)));
- elog(DEBUG4, " -> %s", prt);
- pfree(prt);
+ elog(ERROR, "could not find atttypid %u in Typ list", typoid);
+
+ /* XXX this should match getTypeIOParam() */
+ if (ap->am_typ.typtype == 'c')
+ typioparam = typoid;
+ else
+ typioparam = ap->am_typ.typelem;
+
+ typinput = ap->am_typ.typinput;
+ typoutput = ap->am_typ.typoutput;
}
else
{
+ int typeindex;
+
+ /* XXX why is typoid determined differently in this path? */
+ typoid = attrtypes[i]->atttypid;
for (typeindex = 0; typeindex < n_types; typeindex++)
{
- if (Procid[typeindex].oid == attrtypes[i]->atttypid)
+ if (TypInfo[typeindex].oid == typoid)
break;
}
if (typeindex >= n_types)
- elog(ERROR, "type oid %u not found", attrtypes[i]->atttypid);
- elog(DEBUG4, "Typ == NULL, typeindex = %u", typeindex);
- values[i] = OidFunctionCall3(Procid[typeindex].inproc,
- CStringGetDatum(value),
- ObjectIdGetDatum(Procid[typeindex].elem),
- Int32GetDatum(-1));
- prt = DatumGetCString(OidFunctionCall3(Procid[typeindex].outproc,
- values[i],
- ObjectIdGetDatum(Procid[typeindex].elem),
- Int32GetDatum(-1)));
- elog(DEBUG4, " -> %s", prt);
- pfree(prt);
+ elog(ERROR, "type oid %u not found", typoid);
+ elog(DEBUG5, "Typ == NULL, typeindex = %u", typeindex);
+
+ /* XXX there are no composite types in TypInfo */
+ typioparam = TypInfo[typeindex].elem;
+
+ typinput = TypInfo[typeindex].inproc;
+ typoutput = TypInfo[typeindex].outproc;
}
- elog(DEBUG4, "inserted");
+
+ values[i] = OidFunctionCall3(typinput,
+ CStringGetDatum(value),
+ ObjectIdGetDatum(typioparam),
+ Int32GetDatum(-1));
+ prt = DatumGetCString(OidFunctionCall3(typoutput,
+ values[i],
+ ObjectIdGetDatum(typioparam),
+ Int32GetDatum(-1)));
+ elog(DEBUG4, "inserted -> %s", prt);
+ pfree(prt);
}
/* ----------------
Blanks[i] = 'n';
}
-#define MORE_THAN_THE_NUMBER_OF_CATALOGS 256
-
-static bool
-BootstrapAlreadySeen(Oid id)
-{
- static Oid seenArray[MORE_THAN_THE_NUMBER_OF_CATALOGS];
- static int nseen = 0;
- bool seenthis;
- int i;
-
- seenthis = false;
-
- for (i = 0; i < nseen; i++)
- {
- if (seenArray[i] == id)
- {
- seenthis = true;
- break;
- }
- }
- if (!seenthis)
- {
- seenArray[nseen] = id;
- nseen++;
- }
- return seenthis;
-}
-
/* ----------------
* cleanup
* ----------------
/* ----------------
* gettype
*
- * NB: this is really ugly; it will return an integer index into Procid[],
+ * NB: this is really ugly; it will return an integer index into TypInfo[],
* and not an OID at all, until the first reference to a type not known in
- * Procid[]. At that point it will read and cache pg_type in the Typ array,
+ * TypInfo[]. At that point it will read and cache pg_type in the Typ array,
* and subsequently return a real OID (and set the global pointer Ap to
* point at the found row in Typ). So caller must check whether Typ is
* still NULL to determine what the return value is!
HeapTuple tup;
struct typmap **app;
- if (Typ != (struct typmap **) NULL)
+ if (Typ != NULL)
{
- for (app = Typ; *app != (struct typmap *) NULL; app++)
+ for (app = Typ; *app != NULL; app++)
{
if (strncmp(NameStr((*app)->am_typ.typname), type, NAMEDATALEN) == 0)
{
{
for (i = 0; i < n_types; i++)
{
- if (strncmp(type, Procid[i].name, NAMEDATALEN) == 0)
+ if (strncmp(type, TypInfo[i].name, NAMEDATALEN) == 0)
return i;
}
elog(DEBUG4, "external type: %s", type);
rel = heap_openr(TypeRelationName, NoLock);
- scan = heap_beginscan(rel, SnapshotNow, 0, (ScanKey) NULL);
+ scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
i = 0;
while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
++i;
app = Typ = ALLOC(struct typmap *, i + 1);
while (i-- > 0)
*app++ = ALLOC(struct typmap, 1);
- *app = (struct typmap *) NULL;
- scan = heap_beginscan(rel, SnapshotNow, 0, (ScanKey) NULL);
+ *app = NULL;
+ scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
app = Typ;
while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
*/
if (nogc == NULL)
- nogc = AllocSetContextCreate((MemoryContext) NULL,
+ nogc = AllocSetContextCreate(NULL,
"BootstrapNoGC",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
}
void
-build_indices()
+build_indices(void)
{
- for (; ILHead != (IndexList *) NULL; ILHead = ILHead->il_next)
+ for (; ILHead != NULL; ILHead = ILHead->il_next)
{
Relation heap;
Relation ind;
* index, but in bootstrap mode it will not.
*/
- /*
- * All of the rest of this routine is needed only because in
- * bootstrap processing we don't increment xact id's. The normal
- * DefineIndex code replaces a pg_class tuple with updated info
- * including the relhasindex flag (which we need to have updated).
- * Unfortunately, there are always two indices defined on each
- * catalog causing us to update the same pg_class tuple twice for
- * each catalog getting an index during bootstrap resulting in the
- * ghost tuple problem (see heap_update). To get around this we
- * change the relhasindex field ourselves in this routine keeping
- * track of what catalogs we already changed so that we don't
- * modify those tuples twice. The normal mechanism for updating
- * pg_class is disabled during bootstrap.
- *
- * -mer
- */
- if (!BootstrapAlreadySeen(RelationGetRelid(heap)))
- UpdateStats(RelationGetRelid(heap), 0);
-
/* XXX Probably we ought to close the heap and index here? */
}
}
projects / postgresql / blobdiff