开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
bootstrap.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：26k
源码类别：

数据库系统

开发平台：

Unix_Linux

bootstrap.c：源码内容
  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.  * Copyright (c) 1994, Regents of the University of California
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.60.2.1 1999/08/02 05:56:52 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <unistd.h>
  15. #include <time.h>
  16. #include <signal.h>
  17. #include <setjmp.h>
  19. #define BOOTSTRAP_INCLUDE /* mask out stuff in tcop/tcopprot.h */
  21. #include "postgres.h"
  22. #ifdef HAVE_GETOPT_H
  23. #include <getopt.h>
  24. #endif
  26. #include "access/genam.h"
  27. #include "access/heapam.h"
  28. #include "bootstrap/bootstrap.h"
  29. #include "catalog/catname.h"
  30. #include "catalog/index.h"
  31. #include "catalog/pg_type.h"
  32. #include "libpq/pqsignal.h"
  33. #include "miscadmin.h"
  34. #include "tcop/tcopprot.h"
  35. #include "utils/builtins.h"
  36. #include "utils/lsyscache.h"
  37. #include "utils/portal.h"
  39. #define ALLOC(t, c) (t *)calloc((unsigned)(c), sizeof(t))
  40. #define FIRST_TYPE_OID 16 /* OID of the first type */
  42. extern int Int_yyparse(void);
  43. static hashnode *AddStr(char *str, int strlength, int mderef);
  44. static Form_pg_attribute AllocateAttribute(void);
  45. static bool BootstrapAlreadySeen(Oid id);
  46. static int CompHash(char *str, int len);
  47. static hashnode *FindStr(char *str, int length, hashnode *mderef);
  48. static Oid gettype(char *type);
  49. static void cleanup(void);
  51. /* ----------------
  52.  * global variables
  53.  * ----------------
  54.  */
  55. /*
  56.  * In the lexical analyzer, we need to get the reference number quickly from
  57.  * the string, and the string from the reference number.  Thus we have
  58.  * as our data structure a hash table, where the hashing key taken from
  59.  * the particular string.  The hash table is chained.  One of the fields
  60.  * of the hash table node is an index into the array of character pointers.
  61.  * The unique index number that every string is assigned is simply the
  62.  * position of its string pointer in the array of string pointers.
  63.  */
  65. #define STRTABLESIZE 10000
  66. #define HASHTABLESIZE 503
  68. /* Hash function numbers */
  69. #define NUM 23
  70. #define NUMSQR 529
  71. #define NUMCUBE 12167
  73. char    *strtable[STRTABLESIZE];
  74. hashnode   *hashtable[HASHTABLESIZE];
  76. static int strtable_end = -1; /* Tells us last occupied string space */
  78. /*-
  79.  * Basic information associated with each type.  This is used before
  80.  * pg_type is created.
  81.  *
  82.  * XXX several of these input/output functions do catalog scans
  83.  * (e.g., F_REGPROCIN scans pg_proc). this obviously creates some
  84.  * order dependencies in the catalog creation process.
  85.  */
  86. struct typinfo
  87. {
  88. char name[NAMEDATALEN];
  89. Oid oid;
  90. Oid elem;
  91. int16 len;
  92. Oid inproc;
  93. Oid outproc;
  94. };
  96. static struct typinfo Procid[] = {
  97. {"bool", 16, 0, 1, F_BOOLIN, F_BOOLOUT},
  98. {"bytea", 17, 0, -1, F_BYTEAIN, F_BYTEAOUT},
  99. {"char", 18, 0, 1, F_CHARIN, F_CHAROUT},
  100. {"name", 19, 0, NAMEDATALEN, F_NAMEIN, F_NAMEOUT},
  101. {"dummy", 20, 0, 16, 0, 0},
  102. /*   { "dt",   20,  0,  4, F_DTIN, F_DTOUT}, */
  103. {"int2", 21, 0, 2, F_INT2IN, F_INT2OUT},
  104. {"int28", 22, 0, 16, F_INT28IN, F_INT28OUT},
  105. {"int4", 23, 0, 4, F_INT4IN, F_INT4OUT},
  106. {"regproc", 24, 0, 4, F_REGPROCIN, F_REGPROCOUT},
  107. {"text", 25, 0, -1, F_TEXTIN, F_TEXTOUT},
  108. {"oid", 26, 0, 4, F_INT4IN, F_INT4OUT},
  109. {"tid", 27, 0, 6, F_TIDIN, F_TIDOUT},
  110. {"xid", 28, 0, 5, F_XIDIN, F_XIDOUT},
  111. {"iid", 29, 0, 1, F_CIDIN, F_CIDOUT},
  112. {"oid8", 30, 0, 32, F_OID8IN, F_OID8OUT},
  113. {"smgr", 210, 0, 2, F_SMGRIN, F_SMGROUT},
  114. {"_int4", 1007, 23, -1, F_ARRAY_IN, F_ARRAY_OUT},
  115. {"_aclitem", 1034, 1033, -1, F_ARRAY_IN, F_ARRAY_OUT}
  116. };
  118. static int n_types = sizeof(Procid) / sizeof(struct typinfo);
  120. struct typmap
  121. { /* a hack */
  122. Oid am_oid;
  123. FormData_pg_type am_typ;
  124. };
  126. static struct typmap **Typ = (struct typmap **) NULL;
  127. static struct typmap *Ap = (struct typmap *) NULL;
  129. static int Warnings = 0;
  130. static char Blanks[MAXATTR];
  132. static char *relname; /* current relation name */
  134. Form_pg_attribute attrtypes[MAXATTR]; /* points to attribute info */
  135. static char *values[MAXATTR]; /* cooresponding attribute values */
  136. int numattr; /* number of attributes for cur. rel */
  137. extern bool disableFsync; /* do not fsync the database */
  139. int DebugMode;
  140. static GlobalMemory nogc = (GlobalMemory) NULL; /* special no-gc mem
  141.  * context */
  143. extern int optind;
  144. extern char *optarg;
  146. /*
  147.  * At bootstrap time, we first declare all the indices to be built, and
  148.  * then build them.  The IndexList structure stores enough information
  149.  * to allow us to build the indices after they've been declared.
  150.  */
  152. typedef struct _IndexList
  153. {
  154. char    *il_heap;
  155. char    *il_ind;
  156. int il_natts;
  157. AttrNumber *il_attnos;
  158. uint16 il_nparams;
  159. Datum    *il_params;
  160. FuncIndexInfo *il_finfo;
  161. PredInfo   *il_predInfo;
  162. struct _IndexList *il_next;
  163. } IndexList;
  165. static IndexList *ILHead = (IndexList *) NULL;
  167. typedef void (*sig_func) ();
  172. /* ----------------------------------------------------------------
  173.  * misc functions
  174.  * ----------------------------------------------------------------
  175.  */
  177. /* ----------------
  178.  * error handling / abort routines
  179.  * ----------------
  180.  */
  181. void
  182. err_out(void)
  183. {
  184. Warnings++;
  185. cleanup();
  186. }
  188. /* usage:
  189.    usage help for the bootstrap backen
  190. */
  191. static void
  192. usage(void)
  193. {
  194. fprintf(stderr, "Usage: postgres -boot [-d] [-C] [-F] [-O] [-Q] ");
  195. fprintf(stderr, "[-P portno] [dbName]n");
  196. fprintf(stderr, "     d: debug moden");
  197. fprintf(stderr, "     C: disable version checkingn");
  198. fprintf(stderr, "     F: turn off fsyncn");
  199. fprintf(stderr, "     O: set BootstrapProcessing moden");
  200. fprintf(stderr, "     P portno: specify port numbern");
  202. proc_exit(1);
  203. }
  207. int
  208. BootstrapMain(int argc, char *argv[])
  209. /* ----------------------------------------------------------------
  210.  *  The main loop for handling the backend in bootstrap mode
  211.  *  the bootstrap mode is used to initialize the template database
  212.  *  the bootstrap backend doesn't speak SQL, but instead expects
  213.  *  commands in a special bootstrap language.
  214.  *
  215.  *  The arguments passed in to BootstrapMain are the run-time arguments
  216.  *  without the argument '-boot', the caller is required to have
  217.  *  removed -boot from the run-time args
  218.  * ----------------------------------------------------------------
  219.  */
  220. {
  221. int i;
  222. int portFd = -1;
  223. char    *dbName;
  224. int flag;
  225. int override = 1; /* use BootstrapProcessing or
  226.  * InitProcessing mode */
  228. extern int optind;
  229. extern char *optarg;
  231. /* ----------------
  232.  * initialize signal handlers
  233.  * ----------------
  234.  */
  235. pqsignal(SIGINT, (sig_func) die);
  236. pqsignal(SIGHUP, (sig_func) die);
  237. pqsignal(SIGTERM, (sig_func) die);
  239. /* --------------------
  240.  * initialize globals
  241.  * -------------------
  242.  */
  244. MyProcPid = getpid();
  246. /* ----------------
  247.  * process command arguments
  248.  * ----------------
  249.  */
  251. /* Set defaults, to be overriden by explicit options below */
  252. Quiet = false;
  253. Noversion = false;
  254. dbName = NULL;
  255. DataDir = getenv("PGDATA"); /* Null if no PGDATA variable */
  257. while ((flag = getopt(argc, argv, "D:dCOQP:F")) != EOF)
  258. {
  259. switch (flag)
  260. {
  261. case 'D':
  262. DataDir = optarg;
  263. break;
  264. case 'd':
  265. DebugMode = true; /* print out debugging info while
  266.  * parsing */
  267. break;
  268. case 'C':
  269. Noversion = true;
  270. break;
  271. case 'F':
  272. disableFsync = true;
  273. break;
  274. case 'O':
  275. override = true;
  276. break;
  277. case 'Q':
  278. Quiet = true;
  279. break;
  280. case 'P': /* specify port */
  281. portFd = atoi(optarg);
  282. break;
  283. default:
  284. usage();
  285. break;
  286. }
  287. } /* while */
  289. if (argc - optind > 1)
  290. usage();
  291. else if (argc - optind == 1)
  292. dbName = argv[optind];
  294. if (!DataDir)
  295. {
  296. fprintf(stderr, "%s does not know where to find the database system "
  297. "data.  You must specify the directory that contains the "
  298. "database system either by specifying the -D invocation "
  299.  "option or by setting the PGDATA environment variable.nn",
  300. argv[0]);
  301. proc_exit(1);
  302. }
  304. if (dbName == NULL)
  305. {
  306. dbName = getenv("USER");
  307. if (dbName == NULL)
  308. {
  309. fputs("bootstrap backend: failed, no db name specifiedn", stderr);
  310. fputs("          and no USER enviroment variablen", stderr);
  311. proc_exit(1);
  312. }
  313. }
  315. /* ----------------
  316.  * initialize input fd
  317.  * ----------------
  318.  */
  319. if (IsUnderPostmaster && portFd < 0)
  320. {
  321. fputs("backend: failed, no -P option with -postmaster opt.n", stderr);
  322. proc_exit(1);
  323. }
  325. /* ----------------
  326.  * backend initialization
  327.  * ----------------
  328.  */
  329. SetProcessingMode((override) ? BootstrapProcessing : InitProcessing);
  330. InitPostgres(dbName);
  331. LockDisable(true);
  333. for (i = 0; i < MAXATTR; i++)
  334. {
  335. attrtypes[i] = (Form_pg_attribute) NULL;
  336. Blanks[i] = ' ';
  337. }
  338. for (i = 0; i < STRTABLESIZE; ++i)
  339. strtable[i] = NULL;
  340. for (i = 0; i < HASHTABLESIZE; ++i)
  341. hashtable[i] = NULL;
  343. /* ----------------
  344.  * abort processing resumes here
  345.  * ----------------
  346.  */
  347. pqsignal(SIGHUP, handle_warn);
  349. if (sigsetjmp(Warn_restart, 1) != 0)
  350. {
  351. Warnings++;
  352. AbortCurrentTransaction();
  353. }
  355. /* ----------------
  356.  * process input.
  357.  * ----------------
  358.  */
  360. /*
  361.  * the sed script boot.sed renamed yyparse to Int_yyparse for the
  362.  * bootstrap parser to avoid conflicts with the normal SQL parser
  363.  */
  364. Int_yyparse();
  366. /* clean up processing */
  367. StartTransactionCommand();
  368. cleanup();
  370. /* not reached, here to make compiler happy */
  371. return 0;
  373. }
  375. /* ----------------------------------------------------------------
  376.  * MANUAL BACKEND INTERACTIVE INTERFACE COMMANDS
  377.  * ----------------------------------------------------------------
  378.  */
  380. /* ----------------
  381.  * boot_openrel
  382.  * ----------------
  383.  */
  384. void
  385. boot_openrel(char *relname)
  386. {
  387. int i;
  388. struct typmap **app;
  389. Relation rel;
  390. HeapScanDesc scan;
  391. HeapTuple tup;
  393. if (strlen(relname) >= NAMEDATALEN - 1)
  394. relname[NAMEDATALEN - 1] = '';
  396. if (Typ == (struct typmap **) NULL)
  397. {
  398. StartPortalAllocMode(DefaultAllocMode, 0);
  399. rel = heap_openr(TypeRelationName);
  400. scan = heap_beginscan(rel, 0, SnapshotNow, 0, (ScanKey) NULL);
  401. i = 0;
  402. while (HeapTupleIsValid(tup = heap_getnext(scan, 0)))
  403. ++i;
  404. heap_endscan(scan);
  405. app = Typ = ALLOC(struct typmap *, i + 1);
  406. while (i-- > 0)
  407. *app++ = ALLOC(struct typmap, 1);
  408. *app = (struct typmap *) NULL;
  409. scan = heap_beginscan(rel, 0, SnapshotNow, 0, (ScanKey) NULL);
  410. app = Typ;
  411. while (HeapTupleIsValid(tup = heap_getnext(scan, 0)))
  412. {
  413. (*app)->am_oid = tup->t_data->t_oid;
  414. memmove((char *) &(*app++)->am_typ,
  415. (char *) GETSTRUCT(tup),
  416. sizeof((*app)->am_typ));
  417. }
  418. heap_endscan(scan);
  419. heap_close(rel);
  420. EndPortalAllocMode();
  421. }
  423. if (reldesc != NULL)
  424. closerel(NULL);
  426. if (!Quiet)
  427. printf("Amopen: relation %s. attrsize %dn", relname ? relname : "(null)",
  428.    (int) ATTRIBUTE_TUPLE_SIZE);
  430. reldesc = heap_openr(relname);
  431. Assert(reldesc);
  432. numattr = reldesc->rd_rel->relnatts;
  433. for (i = 0; i < numattr; i++)
  434. {
  435. if (attrtypes[i] == NULL)
  436. attrtypes[i] = AllocateAttribute();
  437. memmove((char *) attrtypes[i],
  438. (char *) reldesc->rd_att->attrs[i],
  439. ATTRIBUTE_TUPLE_SIZE);
  441. /* Some old pg_attribute tuples might not have attisset. */
  443. /*
  444.  * If the attname is attisset, don't look for it - it may not be
  445.  * defined yet.
  446.  */
  447. if (namestrcmp(&attrtypes[i]->attname, "attisset") == 0)
  448. attrtypes[i]->attisset = get_attisset(RelationGetRelid(reldesc),
  449.  attrtypes[i]->attname.data);
  450. else
  451. attrtypes[i]->attisset = false;
  453. if (DebugMode)
  454. {
  455. Form_pg_attribute at = attrtypes[i];
  457. printf("create attribute %d name %s len %d num %d type %dn",
  458.    i, at->attname.data, at->attlen, at->attnum,
  459.    at->atttypid
  460. );
  461. fflush(stdout);
  462. }
  463. }
  464. }
  466. /* ----------------
  467.  * closerel
  468.  * ----------------
  469.  */
  470. void
  471. closerel(char *name)
  472. {
  473. if (name)
  474. {
  475. if (reldesc)
  476. {
  477. if (namestrcmp(RelationGetRelationName(reldesc), name) != 0)
  478. elog(ERROR, "closerel: close of '%s' when '%s' was expected",
  479.  name, relname ? relname : "(null)");
  480. }
  481. else
  482. elog(ERROR, "closerel: close of '%s' before any relation was opened",
  483.  name);
  485. }
  487. if (reldesc == NULL)
  488. elog(ERROR, "Warning: no opened relation to close.n");
  489. else
  490. {
  491. if (!Quiet)
  492. printf("Amclose: relation %s.n", relname ? relname : "(null)");
  493. heap_close(reldesc);
  494. reldesc = (Relation) NULL;
  495. }
  496. }
  500. /* ----------------
  501.  * DEFINEATTR()
  502.  *
  503.  * define a <field,type> pair
  504.  * if there are n fields in a relation to be created, this routine
  505.  * will be called n times
  506.  * ----------------
  507.  */
  508. void
  509. DefineAttr(char *name, char *type, int attnum)
  510. {
  511. int attlen;
  512. Oid typeoid;
  514. if (reldesc != NULL)
  515. {
  516. fputs("Warning: no open relations allowed with 't' command.n", stderr);
  517. closerel(relname);
  518. }
  520. typeoid = gettype(type);
  521. if (attrtypes[attnum] == (Form_pg_attribute) NULL)
  522. attrtypes[attnum] = AllocateAttribute();
  523. if (Typ != (struct typmap **) NULL)
  524. {
  525. attrtypes[attnum]->atttypid = Ap->am_oid;
  526. namestrcpy(&attrtypes[attnum]->attname, name);
  527. if (!Quiet)
  528. printf("<%s %s> ", attrtypes[attnum]->attname.data, type);
  529. attrtypes[attnum]->attnum = 1 + attnum; /* fillatt */
  530. attlen = attrtypes[attnum]->attlen = Ap->am_typ.typlen;
  531. attrtypes[attnum]->attbyval = Ap->am_typ.typbyval;
  532. attrtypes[attnum]->attalign = Ap->am_typ.typalign;
  533. }
  534. else
  535. {
  536. attrtypes[attnum]->atttypid = Procid[typeoid].oid;
  537. namestrcpy(&attrtypes[attnum]->attname, name);
  538. if (!Quiet)
  539. printf("<%s %s> ", attrtypes[attnum]->attname.data, type);
  540. attrtypes[attnum]->attnum = 1 + attnum; /* fillatt */
  541. attlen = attrtypes[attnum]->attlen = Procid[typeoid].len;
  543. /*
  544.  * Cheat like mad to fill in these items from the length only.
  545.  * This only has to work for types used in the system catalogs...
  546.  */
  547. switch (attlen)
  548. {
  549. case 1:
  550. attrtypes[attnum]->attbyval = true;
  551. attrtypes[attnum]->attalign = 'c';
  552. break;
  553. case 2:
  554. attrtypes[attnum]->attbyval = true;
  555. attrtypes[attnum]->attalign = 's';
  556. break;
  557. case 4:
  558. attrtypes[attnum]->attbyval = true;
  559. attrtypes[attnum]->attalign = 'i';
  560. break;
  561. default:
  562. attrtypes[attnum]->attbyval = false;
  563. attrtypes[attnum]->attalign = 'i';
  564. break;
  565. }
  566. }
  567. attrtypes[attnum]->attcacheoff = -1;
  568. attrtypes[attnum]->atttypmod = -1;
  569. }
  572. /* ----------------
  573.  * InsertOneTuple
  574.  * assumes that 'oid' will not be zero.
  575.  * ----------------
  576.  */
  577. void
  578. InsertOneTuple(Oid objectid)
  579. {
  580. HeapTuple tuple;
  581. TupleDesc tupDesc;
  583. int i;
  585. if (DebugMode)
  586. {
  587. printf("InsertOneTuple oid %u, %d attrsn", objectid, numattr);
  588. fflush(stdout);
  589. }
  591. tupDesc = CreateTupleDesc(numattr, attrtypes);
  592. tuple = heap_formtuple(tupDesc, (Datum *) values, Blanks);
  593. pfree(tupDesc); /* just free's tupDesc, not the attrtypes */
  595. if (objectid != (Oid) 0)
  596. tuple->t_data->t_oid = objectid;
  597. heap_insert(reldesc, tuple);
  598. pfree(tuple);
  599. if (DebugMode)
  600. {
  601. printf("End InsertOneTuple, objectid=%un", objectid);
  602. fflush(stdout);
  603. }
  605. /*
  606.  * Reset blanks for next tuple
  607.  */
  608. for (i = 0; i < numattr; i++)
  609. Blanks[i] = ' ';
  610. }
  612. /* ----------------
  613.  * InsertOneValue
  614.  * ----------------
  615.  */
  616. void
  617. InsertOneValue(Oid objectid, char *value, int i)
  618. {
  619. int typeindex;
  620. char    *prt;
  621. struct typmap **app;
  623. if (DebugMode)
  624. printf("Inserting value: '%s'n", value);
  625. if (i < 0 || i >= MAXATTR)
  626. {
  627. printf("i out of range: %dn", i);
  628. Assert(0);
  629. }
  631. if (Typ != (struct typmap **) NULL)
  632. {
  633. struct typmap *ap;
  635. if (DebugMode)
  636. puts("Typ != NULL");
  637. app = Typ;
  638. while (*app && (*app)->am_oid != reldesc->rd_att->attrs[i]->atttypid)
  639. ++app;
  640. ap = *app;
  641. if (ap == NULL)
  642. {
  643. printf("Unable to find atttypid in Typ list! %un",
  644.    reldesc->rd_att->attrs[i]->atttypid
  645. );
  646. Assert(0);
  647. }
  648. values[i] = fmgr(ap->am_typ.typinput,
  649.  value,
  650.  ap->am_typ.typelem,
  651.  -1); /* shouldn't have char() or varchar()
  652.  * types during boostrapping but just to
  653.  * be safe */
  654. prt = fmgr(ap->am_typ.typoutput, values[i],
  655.    ap->am_typ.typelem);
  656. if (!Quiet)
  657. printf("%s ", prt);
  658. pfree(prt);
  659. }
  660. else
  661. {
  662. typeindex = attrtypes[i]->atttypid - FIRST_TYPE_OID;
  663. if (DebugMode)
  664. printf("Typ == NULL, typeindex = %u idx = %dn", typeindex, i);
  665. values[i] = fmgr(Procid[typeindex].inproc, value,
  666.  Procid[typeindex].elem, -1);
  667. prt = fmgr(Procid[typeindex].outproc, values[i],
  668.    Procid[typeindex].elem);
  669. if (!Quiet)
  670. printf("%s ", prt);
  671. pfree(prt);
  672. }
  673. if (DebugMode)
  674. {
  675. puts("End InsertValue");
  676. fflush(stdout);
  677. }
  678. }
  680. /* ----------------
  681.  * InsertOneNull
  682.  * ----------------
  683.  */
  684. void
  685. InsertOneNull(int i)
  686. {
  687. if (DebugMode)
  688. printf("Inserting nulln");
  689. if (i < 0 || i >= MAXATTR)
  690. elog(FATAL, "i out of range (too many attrs): %dn", i);
  691. values[i] = (char *) NULL;
  692. Blanks[i] = 'n';
  693. }
  695. #define MORE_THAN_THE_NUMBER_OF_CATALOGS 256
  697. static bool
  698. BootstrapAlreadySeen(Oid id)
  699. {
  700. static Oid seenArray[MORE_THAN_THE_NUMBER_OF_CATALOGS];
  701. static int nseen = 0;
  702. bool seenthis;
  703. int i;
  705. seenthis = false;
  707. for (i = 0; i < nseen; i++)
  708. {
  709. if (seenArray[i] == id)
  710. {
  711. seenthis = true;
  712. break;
  713. }
  714. }
  715. if (!seenthis)
  716. {
  717. seenArray[nseen] = id;
  718. nseen++;
  719. }
  720. return seenthis;
  721. }
  723. /* ----------------
  724.  * cleanup
  725.  * ----------------
  726.  */
  727. static void
  728. cleanup()
  729. {
  730. static int beenhere = 0;
  732. if (!beenhere)
  733. beenhere = 1;
  734. else
  735. {
  736. elog(FATAL, "Memory manager fault: cleanup called twice.n", stderr);
  737. proc_exit(1);
  738. }
  739. if (reldesc != (Relation) NULL)
  740. heap_close(reldesc);
  741. CommitTransactionCommand();
  742. proc_exit(Warnings);
  743. }
  745. /* ----------------
  746.  * gettype
  747.  * ----------------
  748.  */
  749. static Oid
  750. gettype(char *type)
  751. {
  752. int i;
  753. Relation rel;
  754. HeapScanDesc scan;
  755. HeapTuple tup;
  756. struct typmap **app;
  758. if (Typ != (struct typmap **) NULL)
  759. {
  760. for (app = Typ; *app != (struct typmap *) NULL; app++)
  761. {
  762. if (strncmp((*app)->am_typ.typname.data, type, NAMEDATALEN) == 0)
  763. {
  764. Ap = *app;
  765. return (*app)->am_oid;
  766. }
  767. }
  768. }
  769. else
  770. {
  771. for (i = 0; i <= n_types; i++)
  772. {
  773. if (strncmp(type, Procid[i].name, NAMEDATALEN) == 0)
  774. return i;
  775. }
  776. if (DebugMode)
  777. printf("bootstrap.c: External Type: %sn", type);
  778. rel = heap_openr(TypeRelationName);
  779. scan = heap_beginscan(rel, 0, SnapshotNow, 0, (ScanKey) NULL);
  780. i = 0;
  781. while (HeapTupleIsValid(tup = heap_getnext(scan, 0)))
  782. ++i;
  783. heap_endscan(scan);
  784. app = Typ = ALLOC(struct typmap *, i + 1);
  785. while (i-- > 0)
  786. *app++ = ALLOC(struct typmap, 1);
  787. *app = (struct typmap *) NULL;
  788. scan = heap_beginscan(rel, 0, SnapshotNow, 0, (ScanKey) NULL);
  789. app = Typ;
  790. while (HeapTupleIsValid(tup = heap_getnext(scan, 0)))
  791. {
  792. (*app)->am_oid = tup->t_data->t_oid;
  793. memmove((char *) &(*app++)->am_typ,
  794. (char *) GETSTRUCT(tup),
  795. sizeof((*app)->am_typ));
  796. }
  797. heap_endscan(scan);
  798. heap_close(rel);
  799. return gettype(type);
  800. }
  801. elog(ERROR, "Error: unknown type '%s'.n", type);
  802. err_out();
  803. /* not reached, here to make compiler happy */
  804. return 0;
  805. }
  807. /* ----------------
  808.  * AllocateAttribute
  809.  * ----------------
  810.  */
  811. static Form_pg_attribute /* XXX */
  812. AllocateAttribute()
  813. {
  814. Form_pg_attribute attribute = (Form_pg_attribute) malloc(ATTRIBUTE_TUPLE_SIZE);
  816. if (!PointerIsValid(attribute))
  817. elog(FATAL, "AllocateAttribute: malloc failed");
  818. MemSet(attribute, 0, ATTRIBUTE_TUPLE_SIZE);
  820. return attribute;
  821. }
  823. /* ----------------
  824.  * MapArrayTypeName
  825.  * XXX arrays of "basetype" are always "_basetype".
  826.  *    this is an evil hack inherited from rel. 3.1.
  827.  * XXX array dimension is thrown away because we
  828.  *    don't support fixed-dimension arrays.  again,
  829.  *    sickness from 3.1.
  830.  *
  831.  * the string passed in must have a '[' character in it
  832.  *
  833.  * the string returned is a pointer to static storage and should NOT
  834.  * be freed by the CALLER.
  835.  * ----------------
  836.  */
  837. char *
  838. MapArrayTypeName(char *s)
  839. {
  840. int i,
  841. j;
  842. static char newStr[NAMEDATALEN]; /* array type names < NAMEDATALEN
  843.  * long */
  845. if (s == NULL || s[0] == '')
  846. return s;
  848. j = 1;
  849. newStr[0] = '_';
  850. for (i = 0; i < NAMEDATALEN - 1 && s[i] != '['; i++, j++)
  851. newStr[j] = s[i];
  853. newStr[j] = '';
  855. return newStr;
  856. }
  858. /* ----------------
  859.  * EnterString
  860.  * returns the string table position of the identifier
  861.  * passed to it.  We add it to the table if we can't find it.
  862.  * ----------------
  863.  */
  864. int
  865. EnterString(char *str)
  866. {
  867. hashnode   *node;
  868. int len;
  870. len = strlen(str);
  872. node = FindStr(str, len, 0);
  873. if (node)
  874. return node->strnum;
  875. else
  876. {
  877. node = AddStr(str, len, 0);
  878. return node->strnum;
  879. }
  880. }
  882. /* ----------------
  883.  * LexIDStr
  884.  * when given an idnum into the 'string-table' return the string
  885.  * associated with the idnum
  886.  * ----------------
  887.  */
  888. char *
  889. LexIDStr(int ident_num)
  890. {
  891. return strtable[ident_num];
  892. }
  895. /* ----------------
  896.  * CompHash
  897.  *
  898.  * Compute a hash function for a given string.  We look at the first,
  899.  * the last, and the middle character of a string to try to get spread
  900.  * the strings out.  The function is rather arbitrary, except that we
  901.  * are mod'ing by a prime number.
  902.  * ----------------
  903.  */
  904. static int
  905. CompHash(char *str, int len)
  906. {
  907. int result;
  909. result = (NUM * str[0] + NUMSQR * str[len - 1] + NUMCUBE * str[(len - 1) / 2]);
  911. return result % HASHTABLESIZE;
  913. }
  915. /* ----------------
  916.  * FindStr
  917.  *
  918.  * This routine looks for the specified string in the hash
  919.  * table. It returns a pointer to the hash node found,
  920.  * or NULL if the string is not in the table.
  921.  * ----------------
  922.  */
  923. static hashnode *
  924. FindStr(char *str, int length, hashnode *mderef)
  925. {
  926. hashnode   *node;
  928. node = hashtable[CompHash(str, length)];
  929. while (node != NULL)
  930. {
  932. /*
  933.  * We must differentiate between string constants that might have
  934.  * the same value as a identifier and the identifier itself.
  935.  */
  936. if (!strcmp(str, strtable[node->strnum]))
  937. {
  938. return node; /* no need to check */
  939. }
  940. else
  941. node = node->next;
  942. }
  943. /* Couldn't find it in the list */
  944. return NULL;
  945. }
  947. /* ----------------
  948.  * AddStr
  949.  *
  950.  * This function adds the specified string, along with its associated
  951.  * data, to the hash table and the string table.  We return the node
  952.  * so that the calling routine can find out the unique id that AddStr
  953.  * has assigned to this string.
  954.  * ----------------
  955.  */
  956. static hashnode *
  957. AddStr(char *str, int strlength, int mderef)
  958. {
  959. hashnode   *temp,
  960.    *trail,
  961.    *newnode;
  962. int hashresult;
  963. int len;
  965. if (++strtable_end == STRTABLESIZE)
  966. {
  967. /* Error, string table overflow, so we Punt */
  968. elog(FATAL,
  969.  "There are too many string constants and identifiers for the compiler to handle.");
  972. }
  974. /*
  975.  * Some of the utilites (eg, define type, create relation) assume that
  976.  * the string they're passed is a NAMEDATALEN.  We get array bound
  977.  * read violations from purify if we don't allocate at least
  978.  * NAMEDATALEN bytes for strings of this sort. Because we're lazy, we
  979.  * allocate at least NAMEDATALEN bytes all the time.
  980.  */
  982. if ((len = strlength + 1) < NAMEDATALEN)
  983. len = NAMEDATALEN;
  985. strtable[strtable_end] = malloc((unsigned) len);
  986. strcpy(strtable[strtable_end], str);
  988. /* Now put a node in the hash table */
  990. newnode = (hashnode *) malloc(sizeof(hashnode) * 1);
  991. newnode->strnum = strtable_end;
  992. newnode->next = NULL;
  994. /* Find out where it goes */
  996. hashresult = CompHash(str, strlength);
  997. if (hashtable[hashresult] == NULL)
  998. hashtable[hashresult] = newnode;
  999. else
  1000. { /* There is something in the list */
  1001. trail = hashtable[hashresult];
  1002. temp = trail->next;
  1003. while (temp != NULL)
  1004. {
  1005. trail = temp;
  1006. temp = temp->next;
  1007. }
  1008. trail->next = newnode;
  1009. }
  1010. return newnode;
  1011. }
  1015. /*
  1016.  * index_register() -- record an index that has been set up for building
  1017.  * later.
  1018.  *
  1019.  * At bootstrap time, we define a bunch of indices on system catalogs.
  1020.  * We postpone actually building the indices until just before we're
  1021.  * finished with initialization, however. This is because more classes
  1022.  * and indices may be defined, and we want to be sure that all of them
  1023.  * are present in the index.
  1024.  */
  1025. void
  1026. index_register(char *heap,
  1027.    char *ind,
  1028.    int natts,
  1029.    AttrNumber *attnos,
  1030.    uint16 nparams,
  1031.    Datum *params,
  1032.    FuncIndexInfo *finfo,
  1033.    PredInfo *predInfo)
  1034. {
  1035. Datum    *v;
  1036. IndexList  *newind;
  1037. int len;
  1038. MemoryContext oldcxt;
  1040. /*
  1041.  * XXX mao 10/31/92 -- don't gc index reldescs, associated info at
  1042.  * bootstrap time. we'll declare the indices now, but want to create
  1043.  * them later.
  1044.  */
  1046. if (nogc == (GlobalMemory) NULL)
  1047. nogc = CreateGlobalMemory("BootstrapNoGC");
  1049. oldcxt = MemoryContextSwitchTo((MemoryContext) nogc);
  1051. newind = (IndexList *) palloc(sizeof(IndexList));
  1052. newind->il_heap = pstrdup(heap);
  1053. newind->il_ind = pstrdup(ind);
  1054. newind->il_natts = natts;
  1056. if (PointerIsValid(finfo))
  1057. len = FIgetnArgs(finfo) * sizeof(AttrNumber);
  1058. else
  1059. len = natts * sizeof(AttrNumber);
  1061. newind->il_attnos = (AttrNumber *) palloc(len);
  1062. memmove(newind->il_attnos, attnos, len);
  1064. if ((newind->il_nparams = nparams) > 0)
  1065. {
  1066. v = newind->il_params = (Datum *) palloc(2 * nparams * sizeof(Datum));
  1067. nparams *= 2;
  1068. while (nparams-- > 0)
  1069. {
  1070. *v = (Datum) palloc(strlen((char *) (*params)) + 1);
  1071. strcpy((char *) *v++, (char *) *params++);
  1072. }
  1073. }
  1074. else
  1075. newind->il_params = (Datum *) NULL;
  1077. if (finfo != (FuncIndexInfo *) NULL)
  1078. {
  1079. newind->il_finfo = (FuncIndexInfo *) palloc(sizeof(FuncIndexInfo));
  1080. memmove(newind->il_finfo, finfo, sizeof(FuncIndexInfo));
  1081. }
  1082. else
  1083. newind->il_finfo = (FuncIndexInfo *) NULL;
  1085. if (predInfo != NULL)
  1086. {
  1087. newind->il_predInfo = (PredInfo *) palloc(sizeof(PredInfo));
  1088. newind->il_predInfo->pred = predInfo->pred;
  1089. newind->il_predInfo->oldPred = predInfo->oldPred;
  1090. }
  1091. else
  1092. newind->il_predInfo = NULL;
  1094. newind->il_next = ILHead;
  1096. ILHead = newind;
  1098. MemoryContextSwitchTo(oldcxt);
  1099. }
  1101. void
  1102. build_indices()
  1103. {
  1104. Relation heap;
  1105. Relation ind;
  1107. for (; ILHead != (IndexList *) NULL; ILHead = ILHead->il_next)
  1108. {
  1109. heap = heap_openr(ILHead->il_heap);
  1110. ind = index_openr(ILHead->il_ind);
  1111. index_build(heap, ind, ILHead->il_natts, ILHead->il_attnos,
  1112.  ILHead->il_nparams, ILHead->il_params, ILHead->il_finfo,
  1113. ILHead->il_predInfo);
  1115. /*
  1116.  * All of the rest of this routine is needed only because in
  1117.  * bootstrap processing we don't increment xact id's.  The normal
  1118.  * DefineIndex code replaces a pg_class tuple with updated info
  1119.  * including the relhasindex flag (which we need to have updated).
  1120.  * Unfortunately, there are always two indices defined on each
  1121.  * catalog causing us to update the same pg_class tuple twice for
  1122.  * each catalog getting an index during bootstrap resulting in the
  1123.  * ghost tuple problem (see heap_replace). To get around this we
  1124.  * change the relhasindex field ourselves in this routine keeping
  1125.  * track of what catalogs we already changed so that we don't
  1126.  * modify those tuples twice.  The normal mechanism for updating
  1127.  * pg_class is disabled during bootstrap.
  1128.  *
  1129.  * -mer
  1130.  */
  1131. heap = heap_openr(ILHead->il_heap);
  1133. if (!BootstrapAlreadySeen(RelationGetRelid(heap)))
  1134. UpdateStats(RelationGetRelid(heap), 0, true);
  1135. }
  1136. }