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

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

数据库系统

开发平台：

Unix_Linux

heap.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * heap.c
  4.  *   code to create and destroy POSTGRES heap relations
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/catalog/heap.c,v 1.89 1999/07/08 02:46:37 momjian Exp $
  11.  *
  12.  *
  13.  * INTERFACE ROUTINES
  14.  * heap_create() - Create an uncataloged heap relation
  15.  * heap_create_with_catalog() - Create a cataloged relation
  16.  * heap_destroy_with_catalog() - Removes named relation from catalogs
  17.  *
  18.  * NOTES
  19.  *   this code taken from access/heap/create.c, which contains
  20.  *   the old heap_create_with_catalog, amcreate, and amdestroy.
  21.  *   those routines will soon call these routines using the function
  22.  *   manager,
  23.  *   just like the poorly named "NewXXX" routines do. The
  24.  *   "New" routines are all going to die soon, once and for all!
  25.  * -cim 1/13/91
  26.  *
  27.  *-------------------------------------------------------------------------
  28.  */
  29. #include "postgres.h"
  30. #include "miscadmin.h"
  32. #include "access/heapam.h"
  33. #include "catalog/catalog.h"
  34. #include "catalog/catname.h"
  35. #include "catalog/heap.h"
  36. #include "catalog/index.h"
  37. #include "catalog/indexing.h"
  38. #include "catalog/pg_attrdef.h"
  39. #include "catalog/pg_index.h"
  40. #include "catalog/pg_inherits.h"
  41. #include "catalog/pg_ipl.h"
  42. #include "catalog/pg_relcheck.h"
  43. #include "catalog/pg_type.h"
  44. #include "commands/trigger.h"
  45. #include "fmgr.h"
  46. #include "nodes/plannodes.h"
  47. #include "optimizer/tlist.h"
  48. #include "parser/parse_expr.h"
  49. #include "parser/parse_node.h"
  50. #include "parser/parse_target.h"
  51. #include "parser/parse_type.h"
  52. #include "parser/parse_coerce.h"
  53. #include "rewrite/rewriteRemove.h"
  54. #include "storage/bufmgr.h"
  55. #include "storage/lmgr.h"
  56. #include "storage/smgr.h"
  57. #include "tcop/tcopprot.h"
  58. #include "utils/catcache.h"
  59. #include "utils/builtins.h"
  60. #include "utils/mcxt.h"
  61. #include "utils/relcache.h"
  62. #include "utils/syscache.h"
  63. #include "utils/tqual.h"
  64. #include "utils/temprel.h"
  66. #ifndef HAVE_MEMMOVE
  67. #include <regex/utils.h>
  68. #else
  69. #include <string.h>
  70. #endif
  72. static void AddNewRelationTuple(Relation pg_class_desc,
  73.   Relation new_rel_desc, Oid new_rel_oid, unsigned natts,
  74. char relkind, char *temp_relname);
  75. static void AddToNoNameRelList(Relation r);
  76. static void DeleteAttributeTuples(Relation rel);
  77. static void DeleteRelationTuple(Relation rel);
  78. static void DeleteTypeTuple(Relation rel);
  79. static void RelationRemoveIndexes(Relation relation);
  80. static void RelationRemoveInheritance(Relation relation);
  81. static void RemoveFromNoNameRelList(Relation r);
  82. static void AddNewRelationType(char *typeName, Oid new_rel_oid);
  83. static void StoreConstraints(Relation rel);
  84. static void RemoveConstraints(Relation rel);
  87. /* ----------------------------------------------------------------
  88.  * XXX UGLY HARD CODED BADNESS FOLLOWS XXX
  89.  *
  90.  * these should all be moved to someplace in the lib/catalog
  91.  * module, if not obliterated first.
  92.  * ----------------------------------------------------------------
  93.  */
  96. /*
  97.  * Note:
  98.  * Should the executor special case these attributes in the future?
  99.  * Advantage: consume 1/2 the space in the ATTRIBUTE relation.
  100.  * Disadvantage:  having rules to compute values in these tuples may
  101.  * be more difficult if not impossible.
  102.  */
  104. static FormData_pg_attribute a1 = {
  105. 0xffffffff, {"ctid"}, TIDOID, 0, sizeof(ItemPointerData),
  106. SelfItemPointerAttributeNumber, 0, -1, -1, '', '', 'i', '', ''
  107. };
  109. static FormData_pg_attribute a2 = {
  110. 0xffffffff, {"oid"}, OIDOID, 0, sizeof(Oid),
  111. ObjectIdAttributeNumber, 0, -1, -1, '01', '', 'i', '', ''
  112. };
  114. static FormData_pg_attribute a3 = {
  115. 0xffffffff, {"xmin"}, XIDOID, 0, sizeof(TransactionId),
  116. MinTransactionIdAttributeNumber, 0, -1, -1, '01', '', 'i', '', ''
  117. };
  119. static FormData_pg_attribute a4 = {
  120. 0xffffffff, {"cmin"}, CIDOID, 0, sizeof(CommandId),
  121. MinCommandIdAttributeNumber, 0, -1, -1, '01', '', 'i', '', ''
  122. };
  124. static FormData_pg_attribute a5 = {
  125. 0xffffffff, {"xmax"}, XIDOID, 0, sizeof(TransactionId),
  126. MaxTransactionIdAttributeNumber, 0, -1, -1, '01', '', 'i', '', ''
  127. };
  129. static FormData_pg_attribute a6 = {
  130. 0xffffffff, {"cmax"}, CIDOID, 0, sizeof(CommandId),
  131. MaxCommandIdAttributeNumber, 0, -1, -1, '01', '', 'i', '', ''
  132. };
  134. static Form_pg_attribute HeapAtt[] = {&a1, &a2, &a3, &a4, &a5, &a6};
  136. /* ----------------------------------------------------------------
  137.  * XXX END OF UGLY HARD CODED BADNESS XXX
  138.  * ----------------------------------------------------------------
  139.  */
  141. /* the tempRelList holds
  142.    the list of temporary uncatalogued relations that are created.
  143.    these relations should be destroyed at the end of transactions
  144. */
  145. typedef struct tempRelList
  146. {
  147. Relation   *rels; /* array of relation descriptors */
  148. int num; /* number of temporary relations */
  149. int size; /* size of space allocated for the rels
  150.  * array */
  151. } TempRelList;
  153. #define NONAME_REL_LIST_SIZE 32
  155. static TempRelList *tempRels = NULL;
  158. /* ----------------------------------------------------------------
  159.  * heap_create - Create an uncataloged heap relation
  160.  *
  161.  * Fields relpages, reltuples, reltuples, relkeys, relhistory,
  162.  * relisindexed, and relkind of rel->rd_rel are initialized
  163.  * to all zeros, as are rd_last and rd_hook.  Rd_refcnt is set to 1.
  164.  *
  165.  * Remove the system relation specific code to elsewhere eventually.
  166.  *
  167.  * Eventually, must place information about this temporary relation
  168.  * into the transaction context block.
  169.  *
  170.  *
  171.  * if heap_create is called with "" as the name, then heap_create will create
  172.  * a temporary name "pg_noname.$PID.$SEQUENCE" for the relation
  173.  * ----------------------------------------------------------------
  174.  */
  175. Relation
  176. heap_create(char *relname,
  177. TupleDesc tupDesc,
  178. bool isnoname,
  179. bool istemp)
  180. {
  181. unsigned i;
  182. Oid relid;
  183. Relation rel;
  184. int len;
  185. bool nailme = false;
  186. int natts = tupDesc->natts;
  187. static unsigned int uniqueId = 0;
  189. extern GlobalMemory CacheCxt;
  190. MemoryContext oldcxt;
  193. /* ----------------
  194.  * sanity checks
  195.  * ----------------
  196.  */
  197. AssertArg(natts > 0);
  199. if (relname && !allowSystemTableMods && IsSystemRelationName(relname) && IsNormalProcessingMode())
  200. {
  201. elog(ERROR, "Illegal class name '%s'"
  202.  "ntThe 'pg_' name prefix is reserved for system catalogs",
  203.  relname);
  204. }
  206. /* ----------------
  207.  * switch to the cache context so that we don't lose
  208.  * allocations at the end of this transaction, I guess.
  209.  * -cim 6/14/90
  210.  * ----------------
  211.  */
  212. if (!CacheCxt)
  213. CacheCxt = CreateGlobalMemory("Cache");
  215. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  217. /* ----------------
  218.  * real ugly stuff to assign the proper relid in the relation
  219.  * descriptor follows.
  220.  * ----------------
  221.  */
  222. if (relname && !strcmp(RelationRelationName, relname))
  223. {
  224. relid = RelOid_pg_class;
  225. nailme = true;
  226. }
  227. else if (relname && !strcmp(AttributeRelationName, relname))
  228. {
  229. relid = RelOid_pg_attribute;
  230. nailme = true;
  231. }
  232. else if (relname && !strcmp(ProcedureRelationName, relname))
  233. {
  234. relid = RelOid_pg_proc;
  235. nailme = true;
  236. }
  237. else if (relname && !strcmp(TypeRelationName, relname))
  238. {
  239. relid = RelOid_pg_type;
  240. nailme = true;
  241. }
  242. else
  243. relid = newoid();
  245. if (isnoname)
  246. {
  247. Assert(!relname);
  248. relname = palloc(NAMEDATALEN);
  249. snprintf(relname, NAMEDATALEN, "pg_noname.%d.%u",
  250.  (int) MyProcPid, uniqueId++);
  251. }
  253. if (istemp)
  254. {
  255. /* replace relname of caller */
  256. snprintf(relname, NAMEDATALEN, "pg_temp.%d.%u",
  257.  MyProcPid, uniqueId++);
  258. }
  260. /* ----------------
  261.  * allocate a new relation descriptor.
  262.  *
  263.  * XXX the length computation may be incorrect, handle elsewhere
  264.  * ----------------
  265.  */
  266. len = sizeof(RelationData);
  268. rel = (Relation) palloc(len);
  269. MemSet((char *) rel, 0, len);
  271. /*
  272.  * create a new tuple descriptor from the one passed in
  273.  */
  274. rel->rd_att = CreateTupleDescCopyConstr(tupDesc);
  276. /* ----------------
  277.  * nail the reldesc if this is a bootstrap create reln and
  278.  * we may need it in the cache later on in the bootstrap
  279.  * process so we don't ever want it kicked out.  e.g. pg_attribute!!!
  280.  * ----------------
  281.  */
  282. if (nailme)
  283. rel->rd_isnailed = true;
  285. RelationSetReferenceCount(rel, 1);
  287. rel->rd_rel = (Form_pg_class) palloc(sizeof *rel->rd_rel);
  289. /* ----------------
  290.  * initialize the fields of our new relation descriptor
  291.  * ----------------
  292.  */
  293. MemSet((char *) rel->rd_rel, 0, sizeof *rel->rd_rel);
  294. namestrcpy(&(rel->rd_rel->relname), relname);
  295. rel->rd_rel->relkind = RELKIND_UNCATALOGED;
  296. rel->rd_rel->relnatts = natts;
  297. if (tupDesc->constr)
  298. rel->rd_rel->relchecks = tupDesc->constr->num_check;
  300. for (i = 0; i < natts; i++)
  301. rel->rd_att->attrs[i]->attrelid = relid;
  303. RelationGetRelid(rel) = relid;
  305. if (nailme)
  306. {
  307. /* for system relations, set the reltype field here */
  308. rel->rd_rel->reltype = relid;
  309. }
  311. /* ----------------
  312.  * remember if this is a noname relation
  313.  * ----------------
  314.  */
  315. rel->rd_isnoname = isnoname;
  317. /* ----------------
  318.  * have the storage manager create the relation.
  319.  * ----------------
  320.  */
  322. rel->rd_nonameunlinked = TRUE; /* change once table is created */
  323. rel->rd_fd = (File) smgrcreate(DEFAULT_SMGR, rel);
  324. rel->rd_nonameunlinked = FALSE;
  326. RelationRegisterRelation(rel);
  328. MemoryContextSwitchTo(oldcxt);
  330. /*
  331.  * add all noname relations to the tempRels list so they can be
  332.  * properly disposed of at the end of transaction
  333.  */
  334. if (isnoname)
  335. AddToNoNameRelList(rel);
  337. return rel;
  338. }
  341. /* ----------------------------------------------------------------
  342.  * heap_create_with_catalog - Create a cataloged relation
  343.  *
  344.  * this is done in 6 steps:
  345.  *
  346.  * 1) CheckAttributeNames() is used to make certain the tuple
  347.  *    descriptor contains a valid set of attribute names
  348.  *
  349.  * 2) pg_class is opened and RelationFindRelid()
  350.  *    preforms a scan to ensure that no relation with the
  351.  *    same name already exists.
  352.  *
  353.  * 3) heap_create_with_catalog() is called to create the new relation
  354.  *    on disk.
  355.  *
  356.  * 4) TypeDefine() is called to define a new type corresponding
  357.  *    to the new relation.
  358.  *
  359.  * 5) AddNewAttributeTuples() is called to register the
  360.  *    new relation's schema in pg_attribute.
  361.  *
  362.  * 6) AddNewRelationTuple() is called to register the
  363.  *    relation itself in the catalogs.
  364.  *
  365.  * 7) StoreConstraints is called () - vadim 08/22/97
  366.  *
  367.  * 8) the relations are closed and the new relation's oid
  368.  *    is returned.
  369.  *
  370.  * old comments:
  371.  * A new relation is inserted into the RELATION relation
  372.  * with the specified attribute(s) (newly inserted into
  373.  * the ATTRIBUTE relation).  How does concurrency control
  374.  * work?  Is it automatic now?  Expects the caller to have
  375.  * attname, atttypid, atttyparg, attproc, and attlen domains filled.
  376.  * Create fills the attnum domains sequentually from zero,
  377.  * fills the attdisbursion domains with zeros, and fills the
  378.  * attrelid fields with the relid.
  379.  *
  380.  * scan relation catalog for name conflict
  381.  * scan type catalog for typids (if not arg)
  382.  * create and insert attribute(s) into attribute catalog
  383.  * create new relation
  384.  * insert new relation into attribute catalog
  385.  *
  386.  * Should coordinate with heap_create_with_catalog(). Either
  387.  * it should not be called or there should be a way to prevent
  388.  * the relation from being removed at the end of the
  389.  * transaction if it is successful ('u'/'r' may be enough).
  390.  * Also, if the transaction does not commit, then the
  391.  * relation should be removed.
  392.  *
  393.  * XXX amcreate ignores "off" when inserting (for now).
  394.  * XXX amcreate (like the other utilities) needs to understand indexes.
  395.  *
  396.  * ----------------------------------------------------------------
  397.  */
  399. /* --------------------------------
  400.  * CheckAttributeNames
  401.  *
  402.  * this is used to make certain the tuple descriptor contains a
  403.  * valid set of attribute names.  a problem simply generates
  404.  * elog(ERROR) which aborts the current transaction.
  405.  * --------------------------------
  406.  */
  407. static void
  408. CheckAttributeNames(TupleDesc tupdesc)
  409. {
  410. unsigned i;
  411. unsigned j;
  412. int natts = tupdesc->natts;
  414. /* ----------------
  415.  * first check for collision with system attribute names
  416.  * ----------------
  417.  *
  418.  *  also, warn user if attribute to be created has
  419.  *  an unknown typid  (usually as a result of a 'retrieve into'
  420.  *   - jolly
  421.  */
  422. for (i = 0; i < natts; i += 1)
  423. {
  424. for (j = 0; j < sizeof HeapAtt / sizeof HeapAtt[0]; j += 1)
  425. {
  426. if (nameeq(&(HeapAtt[j]->attname),
  427.    &(tupdesc->attrs[i]->attname)))
  428. {
  429. elog(ERROR, "Attribute '%s' has a name conflict"
  430.  "ntName matches an existing system attribute",
  431.  HeapAtt[j]->attname.data);
  432. }
  433. }
  434. if (tupdesc->attrs[i]->atttypid == UNKNOWNOID)
  435. {
  436. elog(NOTICE, "Attribute '%s' has an unknown type"
  437.  "ntRelation created; continue",
  438.  tupdesc->attrs[i]->attname.data);
  439. }
  440. }
  442. /* ----------------
  443.  * next check for repeated attribute names
  444.  * ----------------
  445.  */
  446. for (i = 1; i < natts; i += 1)
  447. {
  448. for (j = 0; j < i; j += 1)
  449. {
  450. if (nameeq(&(tupdesc->attrs[j]->attname),
  451.    &(tupdesc->attrs[i]->attname)))
  452. {
  453. elog(ERROR, "Attribute '%s' is repeated",
  454.  tupdesc->attrs[j]->attname.data);
  455. }
  456. }
  457. }
  458. }
  460. /* --------------------------------
  461.  * RelnameFindRelid
  462.  *
  463.  * this preforms a scan of pg_class to ensure that
  464.  * no relation with the same name already exists.
  465.  * --------------------------------
  466.  */
  467. Oid
  468. RelnameFindRelid(char *relname)
  469. {
  470. HeapTuple tuple;
  471. Oid relid;
  473. /*
  474.  * If this is not bootstrap (initdb) time, use the catalog index on
  475.  * pg_class.
  476.  */
  477. if (!IsBootstrapProcessingMode())
  478. {
  479. tuple = SearchSysCacheTuple(RELNAME,
  480. PointerGetDatum(relname),
  481. 0, 0, 0);
  482. if (HeapTupleIsValid(tuple))
  483. relid = tuple->t_data->t_oid;
  484. else
  485. relid = InvalidOid;
  486. }
  487. else
  488. {
  489. Relation pg_class_desc;
  490. ScanKeyData key;
  491. HeapScanDesc pg_class_scan;
  493. pg_class_desc = heap_openr(RelationRelationName);
  495. /* ----------------
  496.  * At bootstrap time, we have to do this the hard way.  Form the
  497.  * scan key.
  498.  * ----------------
  499.  */
  500. ScanKeyEntryInitialize(&key,
  501.    0,
  502.    (AttrNumber) Anum_pg_class_relname,
  503.    (RegProcedure) F_NAMEEQ,
  504.    (Datum) relname);
  506. /* ----------------
  507.  * begin the scan
  508.  * ----------------
  509.  */
  510. pg_class_scan = heap_beginscan(pg_class_desc,
  511.    0,
  512.    SnapshotNow,
  513.    1,
  514.    &key);
  516. /* ----------------
  517.  * get a tuple.  if the tuple is NULL then it means we
  518.  * didn't find an existing relation.
  519.  * ----------------
  520.  */
  521. tuple = heap_getnext(pg_class_scan, 0);
  523. if (HeapTupleIsValid(tuple))
  524. relid = tuple->t_data->t_oid;
  525. else
  526. relid = InvalidOid;
  528. heap_endscan(pg_class_scan);
  530. heap_close(pg_class_desc);
  531. }
  532. return relid;
  533. }
  535. /* --------------------------------
  536.  * AddNewAttributeTuples
  537.  *
  538.  * this registers the new relation's schema by adding
  539.  * tuples to pg_attribute.
  540.  * --------------------------------
  541.  */
  542. static void
  543. AddNewAttributeTuples(Oid new_rel_oid,
  544.   TupleDesc tupdesc)
  545. {
  546. Form_pg_attribute *dpp;
  547. unsigned i;
  548. HeapTuple tup;
  549. Relation rel;
  550. bool hasindex;
  551. Relation idescs[Num_pg_attr_indices];
  552. int natts = tupdesc->natts;
  554. /* ----------------
  555.  * open pg_attribute
  556.  * ----------------
  557.  */
  558. rel = heap_openr(AttributeRelationName);
  560. /* -----------------
  561.  * Check if we have any indices defined on pg_attribute.
  562.  * -----------------
  563.  */
  564. Assert(rel);
  565. Assert(rel->rd_rel);
  566. hasindex = RelationGetForm(rel)->relhasindex;
  567. if (hasindex)
  568. CatalogOpenIndices(Num_pg_attr_indices, Name_pg_attr_indices, idescs);
  570. /* ----------------
  571.  * initialize tuple descriptor.  Note we use setheapoverride()
  572.  * so that we can see the effects of our TypeDefine() done
  573.  * previously.
  574.  * ----------------
  575.  */
  576. setheapoverride(true);
  577. fillatt(tupdesc);
  578. setheapoverride(false);
  580. /* ----------------
  581.  * first we add the user attributes..
  582.  * ----------------
  583.  */
  584. dpp = tupdesc->attrs;
  585. for (i = 0; i < natts; i++)
  586. {
  587. (*dpp)->attrelid = new_rel_oid;
  588. (*dpp)->attdisbursion = 0;
  590. tup = heap_addheader(Natts_pg_attribute,
  591.  ATTRIBUTE_TUPLE_SIZE,
  592.  (char *) *dpp);
  594. heap_insert(rel, tup);
  596. if (hasindex)
  597. CatalogIndexInsert(idescs, Num_pg_attr_indices, rel, tup);
  599. pfree(tup);
  600. dpp++;
  601. }
  603. /* ----------------
  604.  * next we add the system attributes..
  605.  * ----------------
  606.  */
  607. dpp = HeapAtt;
  608. for (i = 0; i < -1 - FirstLowInvalidHeapAttributeNumber; i++)
  609. {
  610. (*dpp)->attrelid = new_rel_oid;
  611. /* (*dpp)->attdisbursion = 0;    unneeded */
  613. tup = heap_addheader(Natts_pg_attribute,
  614.  ATTRIBUTE_TUPLE_SIZE,
  615.  (char *) *dpp);
  617. heap_insert(rel, tup);
  619. if (hasindex)
  620. CatalogIndexInsert(idescs, Num_pg_attr_indices, rel, tup);
  622. pfree(tup);
  623. dpp++;
  624. }
  626. heap_close(rel);
  628. /*
  629.  * close pg_attribute indices
  630.  */
  631. if (hasindex)
  632. CatalogCloseIndices(Num_pg_attr_indices, idescs);
  633. }
  635. /* --------------------------------
  636.  * AddNewRelationTuple
  637.  *
  638.  * this registers the new relation in the catalogs by
  639.  * adding a tuple to pg_class.
  640.  * --------------------------------
  641.  */
  642. static void
  643. AddNewRelationTuple(Relation pg_class_desc,
  644. Relation new_rel_desc,
  645. Oid new_rel_oid,
  646. unsigned natts,
  647. char relkind,
  648. char *temp_relname)
  649. {
  650. Form_pg_class new_rel_reltup;
  651. HeapTuple tup;
  652. Relation idescs[Num_pg_class_indices];
  653. bool isBootstrap;
  655. /* ----------------
  656.  * first we munge some of the information in our
  657.  * uncataloged relation's relation descriptor.
  658.  * ----------------
  659.  */
  660. new_rel_reltup = new_rel_desc->rd_rel;
  662. /* CHECK should get new_rel_oid first via an insert then use XXX */
  664. /* ----------------
  665.  * Here we insert bogus estimates of the size of the new relation.
  666.  * In reality, of course, the new relation has 0 tuples and pages,
  667.  * and if we were tracking these statistics accurately then we'd
  668.  * set the fields that way.  But at present the stats will be updated
  669.  * only by VACUUM or CREATE INDEX, and the user might insert a lot of
  670.  * tuples before he gets around to doing either of those.  So, instead
  671.  * of saying the relation is empty, we insert guesstimates.  The point
  672.  * is to keep the optimizer from making really stupid choices on
  673.  * never-yet-vacuumed tables; so the estimates need only be large
  674.  * enough to discourage the optimizer from using nested-loop plans.
  675.  * With this hack, nested-loop plans will be preferred only after
  676.  * the table has been proven to be small by VACUUM or CREATE INDEX.
  677.  * Maintaining the stats on-the-fly would solve the problem more cleanly,
  678.  * but the overhead of that would likely cost more than it'd save.
  679.  * (NOTE: CREATE INDEX inserts the same bogus estimates if it finds the
  680.  * relation has 0 rows and pages. See index.c.)
  681.  * ----------------
  682.  */
  683. new_rel_reltup->relpages = 10; /* bogus estimates */
  684. new_rel_reltup->reltuples = 1000;
  686. new_rel_reltup->relowner = GetUserId();
  687. new_rel_reltup->relkind = relkind;
  688. new_rel_reltup->relnatts = natts;
  690. /* ----------------
  691.  * now form a tuple to add to pg_class
  692.  * XXX Natts_pg_class_fixed is a hack - see pg_class.h
  693.  * ----------------
  694.  */
  695. tup = heap_addheader(Natts_pg_class_fixed,
  696.  CLASS_TUPLE_SIZE,
  697.  (char *) new_rel_reltup);
  698. tup->t_data->t_oid = new_rel_oid;
  700. /* ----------------
  701.  * finally insert the new tuple and free it.
  702.  *
  703.  * Note: I have no idea why we do a
  704.  * SetProcessingMode(BootstrapProcessing);
  705.  *   here -cim 6/14/90
  706.  * ----------------
  707.  */
  708. isBootstrap = IsBootstrapProcessingMode() ? true : false;
  710. SetProcessingMode(BootstrapProcessing);
  712. heap_insert(pg_class_desc, tup);
  714. if (temp_relname)
  715. create_temp_relation(temp_relname, tup);
  717. if (!isBootstrap)
  718. {
  720. /*
  721.  * First, open the catalog indices and insert index tuples for the
  722.  * new relation.
  723.  */
  725. CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, idescs);
  726. CatalogIndexInsert(idescs, Num_pg_class_indices, pg_class_desc, tup);
  727. CatalogCloseIndices(Num_pg_class_indices, idescs);
  728. /* now restore processing mode */
  729. SetProcessingMode(NormalProcessing);
  730. }
  732. pfree(tup);
  733. }
  736. /* --------------------------------
  737.  * AddNewRelationType -
  738.  *
  739.  * define a complex type corresponding to the new relation
  740.  * --------------------------------
  741.  */
  742. static void
  743. AddNewRelationType(char *typeName, Oid new_rel_oid)
  744. {
  745. Oid new_type_oid;
  747. /*
  748.  * The sizes are set to oid size because it makes implementing sets
  749.  * MUCH easier, and no one (we hope) uses these fields to figure out
  750.  * how much space to allocate for the type. An oid is the type used
  751.  * for a set definition.  When a user requests a set, what they
  752.  * actually get is the oid of a tuple in the pg_proc catalog, so the
  753.  * size of the "set" is the size of an oid. Similarly, byval being
  754.  * true makes sets much easier, and it isn't used by anything else.
  755.  * Note the assumption that OIDs are the same size as int4s.
  756.  */
  757. new_type_oid = TypeCreate(typeName, /* type name */
  758.   new_rel_oid, /* relation oid */
  759.   typeLen(typeidType(OIDOID)), /* internal size */
  760.   typeLen(typeidType(OIDOID)), /* external size */
  761.   'c', /* type-type (catalog) */
  762.   ',', /* default array delimiter */
  763.   "int4in", /* input procedure */
  764.   "int4out", /* output procedure */
  765.   "int4in", /* receive procedure */
  766.   "int4out", /* send procedure */
  767.   NULL, /* array element type - irrelevent */
  768.   "-", /* default type value */
  769.   (bool) 1, /* passed by value */
  770.   'i'); /* default alignment */
  771. }
  773. /* --------------------------------
  774.  * heap_create_with_catalog
  775.  *
  776.  * creates a new cataloged relation.  see comments above.
  777.  * --------------------------------
  778.  */
  779. Oid
  780. heap_create_with_catalog(char *relname,
  781.  TupleDesc tupdesc,
  782.  char relkind,
  783.  bool istemp)
  784. {
  785. Relation pg_class_desc;
  786. Relation new_rel_desc;
  787. Oid new_rel_oid;
  788. int natts = tupdesc->natts;
  789. char    *temp_relname = NULL;
  791. /* ----------------
  792.  * sanity checks
  793.  * ----------------
  794.  */
  795. Assert(IsNormalProcessingMode() || IsBootstrapProcessingMode());
  796. if (natts == 0 || natts > MaxHeapAttributeNumber)
  797. elog(ERROR, "Number of attributes is out of range"
  798.  "ntFrom 1 to %d attributes may be specified",
  799.  MaxHeapAttributeNumber);
  801. CheckAttributeNames(tupdesc);
  803. /* temp tables can mask non-temp tables */
  804. if ((!istemp && RelnameFindRelid(relname)) ||
  805. (istemp && get_temp_rel_by_name(relname) != NULL))
  806. elog(ERROR, "Relation '%s' already exists", relname);
  808. /* invalidate cache so non-temp table is masked by temp */
  809. if (istemp)
  810. {
  811. Oid relid = RelnameFindRelid(relname);
  813. if (relid != InvalidOid)
  814. RelationForgetRelation(relid);
  815. }
  817. /* save user relation name because heap_create changes it */
  818. if (istemp)
  819. {
  820. temp_relname = pstrdup(relname); /* save original value */
  821. relname = palloc(NAMEDATALEN);
  822. strcpy(relname, temp_relname); /* heap_create will change this */
  823. }
  825. /* ----------------
  826.  * ok, relation does not already exist so now we
  827.  * create an uncataloged relation and pull its relation oid
  828.  * from the newly formed relation descriptor.
  829.  *
  830.  * Note: The call to heap_create() does all the "real" work
  831.  * of creating the disk file for the relation.
  832.  * This changes relname for noname and temp tables.
  833.  * ----------------
  834.  */
  835. new_rel_desc = heap_create(relname, tupdesc, false, istemp);
  837. new_rel_oid = new_rel_desc->rd_att->attrs[0]->attrelid;
  839. /* ----------------
  840.  * since defining a relation also defines a complex type,
  841.  * we add a new system type corresponding to the new relation.
  842.  * ----------------
  843.  */
  844. AddNewRelationType(relname, new_rel_oid);
  846. /* ----------------
  847.  * now add tuples to pg_attribute for the attributes in
  848.  * our new relation.
  849.  * ----------------
  850.  */
  851. AddNewAttributeTuples(new_rel_oid, tupdesc);
  853. /* ----------------
  854.  * now update the information in pg_class.
  855.  * ----------------
  856.  */
  857. pg_class_desc = heap_openr(RelationRelationName);
  859. AddNewRelationTuple(pg_class_desc,
  860. new_rel_desc,
  861. new_rel_oid,
  862. natts,
  863. relkind,
  864. temp_relname);
  866. StoreConstraints(new_rel_desc);
  868. if (istemp)
  869. {
  870. pfree(relname);
  871. pfree(temp_relname);
  872. }
  874. /* ----------------
  875.  * ok, the relation has been cataloged, so close our relations
  876.  * and return the oid of the newly created relation.
  877.  *
  878.  * SOMEDAY: fill the STATISTIC relation properly.
  879.  * ----------------
  880.  */
  881. heap_close(new_rel_desc);
  882. heap_close(pg_class_desc);
  884. return new_rel_oid;
  885. }
  888. /* ----------------------------------------------------------------
  889.  * heap_destroy_with_catalog - removes all record of named relation from catalogs
  890.  *
  891.  * 1) open relation, check for existence, etc.
  892.  * 2) remove inheritance information
  893.  * 3) remove indexes
  894.  * 4) remove pg_class tuple
  895.  * 5) remove pg_attribute tuples
  896.  * 6) remove pg_type tuples
  897.  * 7) RemoveConstraints ()
  898.  * 8) unlink relation
  899.  *
  900.  * old comments
  901.  * Except for vital relations, removes relation from
  902.  * relation catalog, and related attributes from
  903.  * attribute catalog (needed?).  (Anything else?)
  904.  *
  905.  * get proper relation from relation catalog (if not arg)
  906.  * check if relation is vital (strcmp()/reltype?)
  907.  * scan attribute catalog deleting attributes of reldesc
  908.  * (necessary?)
  909.  * delete relation from relation catalog
  910.  * (How are the tuples of the relation discarded?)
  911.  *
  912.  * XXX Must fix to work with indexes.
  913.  * There may be a better order for doing things.
  914.  * Problems with destroying a deleted database--cannot create
  915.  * a struct reldesc without having an open file descriptor.
  916.  * ----------------------------------------------------------------
  917.  */
  919. /* --------------------------------
  920.  * RelationRemoveInheritance
  921.  *
  922.  * Note: for now, we cause an exception if relation is a
  923.  * superclass.  Someday, we may want to allow this and merge
  924.  * the type info into subclass procedures.... this seems like
  925.  * lots of work.
  926.  * --------------------------------
  927.  */
  928. static void
  929. RelationRemoveInheritance(Relation relation)
  930. {
  931. Relation catalogRelation;
  932. HeapTuple tuple;
  933. HeapScanDesc scan;
  934. ScanKeyData entry;
  935. bool found = false;
  937. /* ----------------
  938.  * open pg_inherits
  939.  * ----------------
  940.  */
  941. catalogRelation = heap_openr(InheritsRelationName);
  943. /* ----------------
  944.  * form a scan key for the subclasses of this class
  945.  * and begin scanning
  946.  * ----------------
  947.  */
  948. ScanKeyEntryInitialize(&entry, 0x0, Anum_pg_inherits_inhparent,
  949.    F_OIDEQ,
  950.    ObjectIdGetDatum(RelationGetRelid(relation)));
  952. scan = heap_beginscan(catalogRelation,
  953.   false,
  954.   SnapshotNow,
  955.   1,
  956.   &entry);
  958. /* ----------------
  959.  * if any subclasses exist, then we disallow the deletion.
  960.  * ----------------
  961.  */
  962. tuple = heap_getnext(scan, 0);
  963. if (HeapTupleIsValid(tuple))
  964. {
  965. heap_endscan(scan);
  966. heap_close(catalogRelation);
  968. elog(ERROR, "Relation '%u' inherits '%s'",
  969.  ((Form_pg_inherits) GETSTRUCT(tuple))->inhrel,
  970.  RelationGetRelationName(relation));
  971. }
  973. /* ----------------
  974.  * If we get here, it means the relation has no subclasses
  975.  * so we can trash it.  First we remove dead INHERITS tuples.
  976.  * ----------------
  977.  */
  978. entry.sk_attno = Anum_pg_inherits_inhrel;
  980. scan = heap_beginscan(catalogRelation,
  981.   false,
  982.   SnapshotNow,
  983.   1,
  984.   &entry);
  986. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  987. {
  988. heap_delete(catalogRelation, &tuple->t_self, NULL);
  989. found = true;
  990. }
  992. heap_endscan(scan);
  993. heap_close(catalogRelation);
  995. /* ----------------
  996.  * now remove dead IPL tuples
  997.  * ----------------
  998.  */
  999. catalogRelation = heap_openr(InheritancePrecidenceListRelationName);
  1001. entry.sk_attno = Anum_pg_ipl_iplrel;
  1003. scan = heap_beginscan(catalogRelation,
  1004.   false,
  1005.   SnapshotNow,
  1006.   1,
  1007.   &entry);
  1009. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  1010. heap_delete(catalogRelation, &tuple->t_self, NULL);
  1012. heap_endscan(scan);
  1013. heap_close(catalogRelation);
  1014. }
  1016. /* --------------------------------
  1017.  * RelationRemoveIndexes
  1018.  *
  1019.  * --------------------------------
  1020.  */
  1021. static void
  1022. RelationRemoveIndexes(Relation relation)
  1023. {
  1024. Relation indexRelation;
  1025. HeapTuple tuple;
  1026. HeapScanDesc scan;
  1027. ScanKeyData entry;
  1029. indexRelation = heap_openr(IndexRelationName);
  1031. ScanKeyEntryInitialize(&entry, 0x0, Anum_pg_index_indrelid,
  1032.    F_OIDEQ,
  1033.    ObjectIdGetDatum(RelationGetRelid(relation)));
  1035. scan = heap_beginscan(indexRelation,
  1036.   false,
  1037.   SnapshotNow,
  1038.   1,
  1039.   &entry);
  1041. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  1042. index_destroy(((Form_pg_index) GETSTRUCT(tuple))->indexrelid);
  1044. heap_endscan(scan);
  1045. heap_close(indexRelation);
  1046. }
  1048. /* --------------------------------
  1049.  * DeleteRelationTuple
  1050.  *
  1051.  * --------------------------------
  1052.  */
  1053. static void
  1054. DeleteRelationTuple(Relation rel)
  1055. {
  1056. Relation pg_class_desc;
  1057. HeapTuple tup;
  1059. /* ----------------
  1060.  * open pg_class
  1061.  * ----------------
  1062.  */
  1063. pg_class_desc = heap_openr(RelationRelationName);
  1065. tup = SearchSysCacheTupleCopy(RELOID,
  1066.    ObjectIdGetDatum(rel->rd_att->attrs[0]->attrelid),
  1067.   0, 0, 0);
  1068. if (!HeapTupleIsValid(tup))
  1069. {
  1070. heap_close(pg_class_desc);
  1071. elog(ERROR, "Relation '%s' does not exist",
  1072.  &rel->rd_rel->relname);
  1073. }
  1075. /* ----------------
  1076.  * delete the relation tuple from pg_class, and finish up.
  1077.  * ----------------
  1078.  */
  1079. heap_delete(pg_class_desc, &tup->t_self, NULL);
  1080. pfree(tup);
  1082. heap_close(pg_class_desc);
  1083. }
  1085. /* --------------------------------
  1086.  * DeleteAttributeTuples
  1087.  *
  1088.  * --------------------------------
  1089.  */
  1090. static void
  1091. DeleteAttributeTuples(Relation rel)
  1092. {
  1093. Relation pg_attribute_desc;
  1094. HeapTuple tup;
  1095. int2 attnum;
  1097. /* ----------------
  1098.  * open pg_attribute
  1099.  * ----------------
  1100.  */
  1101. pg_attribute_desc = heap_openr(AttributeRelationName);
  1103. /* -----------------
  1104.  * Get a write lock _before_ getting the read lock in the scan
  1105.  * ----------------
  1106.  */
  1107. LockRelation(pg_attribute_desc, AccessExclusiveLock);
  1109. for (attnum = FirstLowInvalidHeapAttributeNumber + 1;
  1110.  attnum <= rel->rd_att->natts;
  1111.  attnum++)
  1112. {
  1113. if (HeapTupleIsValid(tup = SearchSysCacheTupleCopy(ATTNUM,
  1114.  ObjectIdGetDatum(RelationGetRelid(rel)),
  1115.    Int16GetDatum(attnum),
  1116.    0, 0)))
  1117. {
  1118. heap_delete(pg_attribute_desc, &tup->t_self, NULL);
  1119. pfree(tup);
  1120. }
  1121. }
  1123. /* ----------------
  1124.  * Release the write lock
  1125.  * ----------------
  1126.  */
  1127. UnlockRelation(pg_attribute_desc, AccessExclusiveLock);
  1128. heap_close(pg_attribute_desc);
  1129. }
  1131. /* --------------------------------
  1132.  * DeleteTypeTuple
  1133.  *
  1134.  * If the user attempts to destroy a relation and there
  1135.  * exists attributes in other relations of type
  1136.  * "relation we are deleting", then we have to do something
  1137.  * special.  presently we disallow the destroy.
  1138.  * --------------------------------
  1139.  */
  1140. static void
  1141. DeleteTypeTuple(Relation rel)
  1142. {
  1143. Relation pg_type_desc;
  1144. HeapScanDesc pg_type_scan;
  1145. Relation pg_attribute_desc;
  1146. HeapScanDesc pg_attribute_scan;
  1147. ScanKeyData key;
  1148. ScanKeyData attkey;
  1149. HeapTuple tup;
  1150. HeapTuple atttup;
  1151. Oid typoid;
  1153. /* ----------------
  1154.  * open pg_type
  1155.  * ----------------
  1156.  */
  1157. pg_type_desc = heap_openr(TypeRelationName);
  1159. /* ----------------
  1160.  * create a scan key to locate the type tuple corresponding
  1161.  * to this relation.
  1162.  * ----------------
  1163.  */
  1164. ScanKeyEntryInitialize(&key, 0,
  1165.    Anum_pg_type_typrelid,
  1166.    F_OIDEQ,
  1167.    ObjectIdGetDatum(RelationGetRelid(rel)));
  1169. pg_type_scan = heap_beginscan(pg_type_desc,
  1170.   0,
  1171.   SnapshotNow,
  1172.   1,
  1173.   &key);
  1175. /* ----------------
  1176.  * use heap_getnext() to fetch the pg_type tuple. If this
  1177.  * tuple is not valid then something's wrong.
  1178.  * ----------------
  1179.  */
  1180. tup = heap_getnext(pg_type_scan, 0);
  1182. if (!HeapTupleIsValid(tup))
  1183. {
  1184. heap_endscan(pg_type_scan);
  1185. heap_close(pg_type_desc);
  1186. elog(ERROR, "DeleteTypeTuple: %s type nonexistent",
  1187.  &rel->rd_rel->relname);
  1188. }
  1190. /* ----------------
  1191.  * now scan pg_attribute. if any other relations have
  1192.  * attributes of the type of the relation we are deleteing
  1193.  * then we have to disallow the deletion. should talk to
  1194.  * stonebraker about this.  -cim 6/19/90
  1195.  * ----------------
  1196.  */
  1197. typoid = tup->t_data->t_oid;
  1199. pg_attribute_desc = heap_openr(AttributeRelationName);
  1201. ScanKeyEntryInitialize(&attkey,
  1202.    0,
  1203.    Anum_pg_attribute_atttypid,
  1204.    F_OIDEQ,
  1205.    typoid);
  1207. pg_attribute_scan = heap_beginscan(pg_attribute_desc,
  1208.    0,
  1209.    SnapshotNow,
  1210.    1,
  1211.    &attkey);
  1213. /* ----------------
  1214.  * try and get a pg_attribute tuple.  if we succeed it means
  1215.  * we can't delete the relation because something depends on
  1216.  * the schema.
  1217.  * ----------------
  1218.  */
  1219. atttup = heap_getnext(pg_attribute_scan, 0);
  1221. if (HeapTupleIsValid(atttup))
  1222. {
  1223. Oid relid = ((Form_pg_attribute) GETSTRUCT(atttup))->attrelid;
  1225. heap_endscan(pg_type_scan);
  1226. heap_close(pg_type_desc);
  1227. heap_endscan(pg_attribute_scan);
  1228. heap_close(pg_attribute_desc);
  1230. elog(ERROR, "DeleteTypeTuple: att of type %s exists in relation %u",
  1231.  &rel->rd_rel->relname, relid);
  1232. }
  1233. heap_endscan(pg_attribute_scan);
  1234. heap_close(pg_attribute_desc);
  1236. /* ----------------
  1237.  * Ok, it's safe so we delete the relation tuple
  1238.  * from pg_type and finish up.  But first end the scan so that
  1239.  * we release the read lock on pg_type.  -mer 13 Aug 1991
  1240.  * ----------------
  1241.  */
  1242. heap_delete(pg_type_desc, &tup->t_self, NULL);
  1244. heap_endscan(pg_type_scan);
  1245. heap_close(pg_type_desc);
  1246. }
  1248. /* --------------------------------
  1249.  * heap_destroy_with_catalog
  1250.  *
  1251.  * --------------------------------
  1252.  */
  1253. void
  1254. heap_destroy_with_catalog(char *relname)
  1255. {
  1256. Relation rel;
  1257. Oid rid;
  1258. bool istemp = (get_temp_rel_by_name(relname) != NULL);
  1260. /* ----------------
  1261.  * first open the relation.  if the relation does exist,
  1262.  * heap_openr() returns NULL.
  1263.  * ----------------
  1264.  */
  1265. rel = heap_openr(relname);
  1266. if (rel == NULL)
  1267. elog(ERROR, "Relation '%s' does not exist", relname);
  1269. LockRelation(rel, AccessExclusiveLock);
  1270. rid = rel->rd_id;
  1272. /* ----------------
  1273.  * prevent deletion of system relations
  1274.  * ----------------
  1275.  */
  1276. /* allow temp of pg_class? Guess so. */
  1277. if (!istemp &&
  1278. !allowSystemTableMods && IsSystemRelationName(RelationGetRelationName(rel)->data))
  1279. elog(ERROR, "System relation '%s' cannot be destroyed",
  1280.  &rel->rd_rel->relname);
  1282. /* ----------------
  1283.  * remove inheritance information
  1284.  * ----------------
  1285.  */
  1286. RelationRemoveInheritance(rel);
  1288. /* ----------------
  1289.  * remove indexes if necessary
  1290.  * ----------------
  1291.  */
  1292. if (rel->rd_rel->relhasindex)
  1293. RelationRemoveIndexes(rel);
  1295. /* ----------------
  1296.  * remove rules if necessary
  1297.  * ----------------
  1298.  */
  1299. if (rel->rd_rules != NULL)
  1300. RelationRemoveRules(rid);
  1302. /* triggers */
  1303. if (rel->rd_rel->reltriggers > 0)
  1304. RelationRemoveTriggers(rel);
  1306. /* ----------------
  1307.  * delete attribute tuples
  1308.  * ----------------
  1309.  */
  1310. DeleteAttributeTuples(rel);
  1312. if (istemp)
  1313. remove_temp_relation(rid);
  1315. /* ----------------
  1316.  * delete type tuple. here we want to see the effects
  1317.  * of the deletions we just did, so we use setheapoverride().
  1318.  * ----------------
  1319.  */
  1320. setheapoverride(true);
  1321. DeleteTypeTuple(rel);
  1322. setheapoverride(false);
  1324. /* ----------------
  1325.  * delete relation tuple
  1326.  * ----------------
  1327.  */
  1328. /* must delete fake tuple in cache */
  1329. DeleteRelationTuple(rel);
  1331. /*
  1332.  * release dirty buffers of this relation
  1333.  */
  1334. ReleaseRelationBuffers(rel);
  1336. /* ----------------
  1337.  * flush the relation from the relcache
  1338.  * ----------------
  1339.  * Does nothing!!! Flushing moved below. - vadim 06/04/97
  1340. RelationIdInvalidateRelationCacheByRelationId(rel->rd_id);
  1341.  */
  1343. RemoveConstraints(rel);
  1345. /* ----------------
  1346.  * unlink the relation and finish up.
  1347.  * ----------------
  1348.  */
  1349. if (!(rel->rd_isnoname) || !(rel->rd_nonameunlinked))
  1350. smgrunlink(DEFAULT_SMGR, rel);
  1352. rel->rd_nonameunlinked = TRUE;
  1354. UnlockRelation(rel, AccessExclusiveLock);
  1356. heap_close(rel);
  1358. RelationForgetRelation(rid);
  1359. }
  1361. /*
  1362.  * heap_destroy
  1363.  *   destroy and close temporary relations
  1364.  *
  1365.  */
  1367. void
  1368. heap_destroy(Relation rel)
  1369. {
  1370. ReleaseRelationBuffers(rel);
  1371. if (!(rel->rd_isnoname) || !(rel->rd_nonameunlinked))
  1372. smgrunlink(DEFAULT_SMGR, rel);
  1373. rel->rd_nonameunlinked = TRUE;
  1374. heap_close(rel);
  1375. RemoveFromNoNameRelList(rel);
  1376. }
  1379. /**************************************************************
  1380.   functions to deal with the list of temporary relations
  1381. **************************************************************/
  1383. /* --------------
  1384.    InitTempRellist():
  1386.    initialize temporary relations list
  1387.    the tempRelList is a list of temporary relations that
  1388.    are created in the course of the transactions
  1389.    they need to be destroyed properly at the end of the transactions
  1391.    MODIFIES the global variable tempRels
  1393.  >> NOTE <<
  1395.    malloc is used instead of palloc because we KNOW when we are
  1396.    going to free these things. Keeps us away from the memory context
  1397.    hairyness
  1399. */
  1400. void
  1401. InitNoNameRelList(void)
  1402. {
  1403. if (tempRels)
  1404. {
  1405. free(tempRels->rels);
  1406. free(tempRels);
  1407. }
  1409. tempRels = (TempRelList *) malloc(sizeof(TempRelList));
  1410. tempRels->size = NONAME_REL_LIST_SIZE;
  1411. tempRels->rels = (Relation *) malloc(sizeof(Relation) * tempRels->size);
  1412. MemSet(tempRels->rels, 0, sizeof(Relation) * tempRels->size);
  1413. tempRels->num = 0;
  1414. }
  1416. /*
  1417.    removes a relation from the TempRelList
  1419.    MODIFIES the global variable tempRels
  1420.   we don't really remove it, just mark it as NULL
  1421.   and DestroyNoNameRels will look for NULLs
  1422. */
  1423. static void
  1424. RemoveFromNoNameRelList(Relation r)
  1425. {
  1426. int i;
  1428. if (!tempRels)
  1429. return;
  1431. for (i = 0; i < tempRels->num; i++)
  1432. {
  1433. if (tempRels->rels[i] == r)
  1434. {
  1435. tempRels->rels[i] = NULL;
  1436. break;
  1437. }
  1438. }
  1439. }
  1441. /*
  1442.    add a temporary relation to the TempRelList
  1444.    MODIFIES the global variable tempRels
  1445. */
  1446. static void
  1447. AddToNoNameRelList(Relation r)
  1448. {
  1449. if (!tempRels)
  1450. return;
  1452. if (tempRels->num == tempRels->size)
  1453. {
  1454. tempRels->size += NONAME_REL_LIST_SIZE;
  1455. tempRels->rels = realloc(tempRels->rels,
  1456.  sizeof(Relation) * tempRels->size);
  1457. }
  1458. tempRels->rels[tempRels->num] = r;
  1459. tempRels->num++;
  1460. }
  1462. /*
  1463.    go through the tempRels list and destroy each of the relations
  1464. */
  1465. void
  1466. DestroyNoNameRels(void)
  1467. {
  1468. int i;
  1469. Relation rel;
  1471. if (!tempRels)
  1472. return;
  1474. for (i = 0; i < tempRels->num; i++)
  1475. {
  1476. rel = tempRels->rels[i];
  1477. /* rel may be NULL if it has been removed from the list already */
  1478. if (rel)
  1479. heap_destroy(rel);
  1480. }
  1481. free(tempRels->rels);
  1482. free(tempRels);
  1483. tempRels = NULL;
  1484. }
  1487. static void
  1488. StoreAttrDefault(Relation rel, AttrDefault *attrdef)
  1489. {
  1490. char str[MAX_PARSE_BUFFER];
  1491. char cast[2 * NAMEDATALEN] = {0};
  1492. Form_pg_attribute atp = rel->rd_att->attrs[attrdef->adnum - 1];
  1493. List    *queryTree_list;
  1494. List    *planTree_list;
  1495. Query    *query;
  1496. TargetEntry *te;
  1497. Resdom    *resdom;
  1498. Node    *expr;
  1499. Oid type;
  1500. char    *adbin;
  1501. MemoryContext oldcxt;
  1502. Relation adrel;
  1503. Relation idescs[Num_pg_attrdef_indices];
  1504. HeapTuple tuple;
  1505. Datum values[4];
  1506. char nulls[4] = {' ', ' ', ' ', ' '};
  1507. extern GlobalMemory CacheCxt;
  1509. start:
  1511. /*
  1512.  * Surround table name with double quotes to allow mixed-case and
  1513.  * whitespaces in names. - BGA 1998-11-14
  1514.  */
  1515. snprintf(str, MAX_PARSE_BUFFER,
  1516.  "select %s%s from "%.*s"", attrdef->adsrc, cast,
  1517.  NAMEDATALEN, rel->rd_rel->relname.data);
  1518. setheapoverride(true);
  1519. planTree_list = pg_parse_and_plan(str, NULL, 0,
  1520.   &queryTree_list, None, FALSE);
  1521. setheapoverride(false);
  1522. query = (Query *) lfirst(queryTree_list);
  1524. if (length(query->rtable) > 1 ||
  1525. flatten_tlist(query->targetList) != NIL)
  1526. elog(ERROR, "Cannot use attribute(s) in DEFAULT clause");
  1527. te = (TargetEntry *) lfirst(query->targetList);
  1528. resdom = te->resdom;
  1529. expr = te->expr;
  1530. type = exprType(expr);
  1532. if (type != atp->atttypid)
  1533. {
  1534. if (IS_BINARY_COMPATIBLE(type, atp->atttypid))
  1535. ; /* use without change */
  1536. else if (can_coerce_type(1, &(type), &(atp->atttypid)))
  1537. expr = coerce_type(NULL, (Node *) expr, type, atp->atttypid,
  1538.    atp->atttypmod);
  1539. else if (IsA(expr, Const))
  1540. {
  1541. if (*cast != 0)
  1542. elog(ERROR, "DEFAULT clause const type '%s' mismatched with column type '%s'",
  1543.  typeidTypeName(type), typeidTypeName(atp->atttypid));
  1544. snprintf(cast, 2 * NAMEDATALEN, ":: %s", typeidTypeName(atp->atttypid));
  1545. goto start;
  1546. }
  1547. else
  1548. elog(ERROR, "DEFAULT clause type '%s' mismatched with column type '%s'",
  1549.  typeidTypeName(type), typeidTypeName(atp->atttypid));
  1550. }
  1552. adbin = nodeToString(expr);
  1553. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  1554. attrdef->adbin = pstrdup(adbin);
  1555. (void) MemoryContextSwitchTo(oldcxt);
  1556. pfree(adbin);
  1558. values[Anum_pg_attrdef_adrelid - 1] = rel->rd_id;
  1559. values[Anum_pg_attrdef_adnum - 1] = attrdef->adnum;
  1560. values[Anum_pg_attrdef_adbin - 1] = PointerGetDatum(textin(attrdef->adbin));
  1561. values[Anum_pg_attrdef_adsrc - 1] = PointerGetDatum(textin(attrdef->adsrc));
  1562. adrel = heap_openr(AttrDefaultRelationName);
  1563. tuple = heap_formtuple(adrel->rd_att, values, nulls);
  1564. CatalogOpenIndices(Num_pg_attrdef_indices, Name_pg_attrdef_indices, idescs);
  1565. heap_insert(adrel, tuple);
  1566. CatalogIndexInsert(idescs, Num_pg_attrdef_indices, adrel, tuple);
  1567. CatalogCloseIndices(Num_pg_attrdef_indices, idescs);
  1568. heap_close(adrel);
  1570. pfree(DatumGetPointer(values[Anum_pg_attrdef_adbin - 1]));
  1571. pfree(DatumGetPointer(values[Anum_pg_attrdef_adsrc - 1]));
  1572. pfree(tuple);
  1574. }
  1576. static void
  1577. StoreRelCheck(Relation rel, ConstrCheck *check)
  1578. {
  1579. char str[MAX_PARSE_BUFFER];
  1580. List    *queryTree_list;
  1581. List    *planTree_list;
  1582. Query    *query;
  1583. Plan    *plan;
  1584. List    *qual;
  1585. char    *ccbin;
  1586. MemoryContext oldcxt;
  1587. Relation rcrel;
  1588. Relation idescs[Num_pg_relcheck_indices];
  1589. HeapTuple tuple;
  1590. Datum values[4];
  1591. char nulls[4] = {' ', ' ', ' ', ' '};
  1592. extern GlobalMemory CacheCxt;
  1594. /*
  1595.  * Check for table's existance. Surround table name with double-quotes
  1596.  * to allow mixed-case and whitespace names. - thomas 1998-11-12
  1597.  */
  1598. snprintf(str, MAX_PARSE_BUFFER,
  1599.  "select 1 from "%.*s" where %s",
  1600.  NAMEDATALEN, rel->rd_rel->relname.data, check->ccsrc);
  1601. setheapoverride(true);
  1602. planTree_list = pg_parse_and_plan(str, NULL, 0,
  1603.   &queryTree_list, None, FALSE);
  1604. setheapoverride(false);
  1605. query = (Query *) lfirst(queryTree_list);
  1607. if (length(query->rtable) > 1)
  1608. elog(ERROR, "Only relation '%.*s' can be referenced",
  1609.  NAMEDATALEN, rel->rd_rel->relname.data);
  1611. plan = (Plan *) lfirst(planTree_list);
  1612. qual = plan->qual;
  1614. ccbin = nodeToString(qual);
  1615. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  1616. check->ccbin = (char *) palloc(strlen(ccbin) + 1);
  1617. strcpy(check->ccbin, ccbin);
  1618. (void) MemoryContextSwitchTo(oldcxt);
  1619. pfree(ccbin);
  1621. values[Anum_pg_relcheck_rcrelid - 1] = rel->rd_id;
  1622. values[Anum_pg_relcheck_rcname - 1] = PointerGetDatum(namein(check->ccname));
  1623. values[Anum_pg_relcheck_rcbin - 1] = PointerGetDatum(textin(check->ccbin));
  1624. values[Anum_pg_relcheck_rcsrc - 1] = PointerGetDatum(textin(check->ccsrc));
  1625. rcrel = heap_openr(RelCheckRelationName);
  1626. tuple = heap_formtuple(rcrel->rd_att, values, nulls);
  1627. CatalogOpenIndices(Num_pg_relcheck_indices, Name_pg_relcheck_indices, idescs);
  1628. heap_insert(rcrel, tuple);
  1629. CatalogIndexInsert(idescs, Num_pg_relcheck_indices, rcrel, tuple);
  1630. CatalogCloseIndices(Num_pg_relcheck_indices, idescs);
  1631. heap_close(rcrel);
  1633. pfree(DatumGetPointer(values[Anum_pg_relcheck_rcname - 1]));
  1634. pfree(DatumGetPointer(values[Anum_pg_relcheck_rcbin - 1]));
  1635. pfree(DatumGetPointer(values[Anum_pg_relcheck_rcsrc - 1]));
  1636. pfree(tuple);
  1638. return;
  1639. }
  1641. static void
  1642. StoreConstraints(Relation rel)
  1643. {
  1644. TupleConstr *constr = rel->rd_att->constr;
  1645. int i;
  1647. if (!constr)
  1648. return;
  1650. if (constr->num_defval > 0)
  1651. {
  1652. for (i = 0; i < constr->num_defval; i++)
  1653. StoreAttrDefault(rel, &(constr->defval[i]));
  1654. }
  1656. if (constr->num_check > 0)
  1657. {
  1658. for (i = 0; i < constr->num_check; i++)
  1659. StoreRelCheck(rel, &(constr->check[i]));
  1660. }
  1662. return;
  1663. }
  1665. static void
  1666. RemoveAttrDefault(Relation rel)
  1667. {
  1668. Relation adrel;
  1669. HeapScanDesc adscan;
  1670. ScanKeyData key;
  1671. HeapTuple tup;
  1673. adrel = heap_openr(AttrDefaultRelationName);
  1675. ScanKeyEntryInitialize(&key, 0, Anum_pg_attrdef_adrelid,
  1676.    F_OIDEQ, rel->rd_id);
  1678. LockRelation(adrel, AccessExclusiveLock);
  1680. adscan = heap_beginscan(adrel, 0, SnapshotNow, 1, &key);
  1682. while (HeapTupleIsValid(tup = heap_getnext(adscan, 0)))
  1683. heap_delete(adrel, &tup->t_self, NULL);
  1685. heap_endscan(adscan);
  1687. UnlockRelation(adrel, AccessExclusiveLock);
  1688. heap_close(adrel);
  1690. }
  1692. static void
  1693. RemoveRelCheck(Relation rel)
  1694. {
  1695. Relation rcrel;
  1696. HeapScanDesc rcscan;
  1697. ScanKeyData key;
  1698. HeapTuple tup;
  1700. rcrel = heap_openr(RelCheckRelationName);
  1702. ScanKeyEntryInitialize(&key, 0, Anum_pg_relcheck_rcrelid,
  1703.    F_OIDEQ, rel->rd_id);
  1705. LockRelation(rcrel, AccessExclusiveLock);
  1707. rcscan = heap_beginscan(rcrel, 0, SnapshotNow, 1, &key);
  1709. while (HeapTupleIsValid(tup = heap_getnext(rcscan, 0)))
  1710. heap_delete(rcrel, &tup->t_self, NULL);
  1712. heap_endscan(rcscan);
  1714. UnlockRelation(rcrel, AccessExclusiveLock);
  1715. heap_close(rcrel);
  1717. }
  1719. static void
  1720. RemoveConstraints(Relation rel)
  1721. {
  1722. TupleConstr *constr = rel->rd_att->constr;
  1724. if (!constr)
  1725. return;
  1727. if (constr->num_defval > 0)
  1728. RemoveAttrDefault(rel);
  1730. if (constr->num_check > 0)
  1731. RemoveRelCheck(rel);
  1733. return;
  1734. }