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

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

数据库系统

开发平台：

Unix_Linux

index.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * index.c
  4.  *   code to create and destroy POSTGRES index 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/index.c,v 1.81.2.1 1999/08/02 05:56:54 scrappy Exp $
  11.  *
  12.  *
  13.  * INTERFACE ROUTINES
  14.  * index_create() - Create a cataloged index relation
  15.  * index_destroy() - Removes index relation from catalogs
  16.  *
  17.  *
  18.  *-------------------------------------------------------------------------
  19.  */
  20. #include "postgres.h"
  23. #include "access/genam.h"
  24. #include "access/heapam.h"
  25. #include "access/istrat.h"
  26. #include "bootstrap/bootstrap.h"
  27. #include "catalog/catname.h"
  28. #include "catalog/heap.h"
  29. #include "catalog/index.h"
  30. #include "catalog/indexing.h"
  31. #include "catalog/pg_index.h"
  32. #include "catalog/pg_proc.h"
  33. #include "catalog/pg_type.h"
  34. #include "executor/executor.h"
  35. #include "miscadmin.h"
  36. #include "optimizer/clauses.h"
  37. #include "optimizer/prep.h"
  38. #include "parser/parse_func.h"
  39. #include "storage/smgr.h"
  40. #include "utils/builtins.h"
  41. #include "utils/relcache.h"
  42. #include "utils/syscache.h"
  43. #include "utils/temprel.h"
  45. /*
  46.  * macros used in guessing how many tuples are on a page.
  47.  */
  48. #define AVG_ATTR_SIZE 8
  49. #define NTUPLES_PER_PAGE(natts) 
  50. ((BLCKSZ - MAXALIGN(sizeof (PageHeaderData))) / 
  51. ((natts) * AVG_ATTR_SIZE + MAXALIGN(sizeof(HeapTupleHeaderData))))
  53. /* non-export function prototypes */
  54. static Oid GetHeapRelationOid(char *heapRelationName, char *indexRelationName,
  55.    bool istemp);
  56. static TupleDesc BuildFuncTupleDesc(FuncIndexInfo *funcInfo);
  57. static TupleDesc ConstructTupleDescriptor(Oid heapoid, Relation heapRelation,
  58.  List *attributeList,
  59.  int numatts, AttrNumber *attNums);
  61. static void ConstructIndexReldesc(Relation indexRelation, Oid amoid);
  62. static Oid UpdateRelationRelation(Relation indexRelation, char *temp_relname);
  63. static void InitializeAttributeOids(Relation indexRelation,
  64. int numatts,
  65. Oid indexoid);
  66. static void
  67. AppendAttributeTuples(Relation indexRelation, int numatts);
  68. static void UpdateIndexRelation(Oid indexoid, Oid heapoid,
  69. FuncIndexInfo *funcInfo, int natts,
  70. AttrNumber *attNums, Oid *classOids, Node *predicate,
  71.    List *attributeList, bool islossy, bool unique, bool primary);
  72. static void DefaultBuild(Relation heapRelation, Relation indexRelation,
  73.  int numberOfAttributes, AttrNumber *attributeNumber,
  74.  IndexStrategy indexStrategy, uint16 parameterCount,
  75. Datum *parameter, FuncIndexInfoPtr funcInfo, PredInfo *predInfo);
  77. /* ----------------------------------------------------------------
  78.  *   sysatts is a structure containing attribute tuple forms
  79.  *   for system attributes (numbered -1, -2, ...).  This really
  80.  *   should be generated or eliminated or moved elsewhere. -cim 1/19/91
  81.  *
  82.  * typedef struct FormData_pg_attribute {
  83.  * Oid attrelid;
  84.  * NameData attname;
  85.  * Oid atttypid;
  86.  * uint32 attnvals;
  87.  * int16 attlen;
  88.  * AttrNumber attnum;
  89.  * uint32 attnelems;
  90.  * int32 attcacheoff;
  91.  * int32 atttypmod;
  92.  * bool attbyval;
  93.  * bool attisset;
  94.  * char attalign;
  95.  * bool attnotnull;
  96.  * bool atthasdef;
  97.  * } FormData_pg_attribute;
  98.  *
  99.  * ----------------------------------------------------------------
  100.  */
  101. static FormData_pg_attribute sysatts[] = {
  102. {0, {"ctid"}, TIDOID, 0, 6, -1, 0, -1, -1, '', '', 'i', '', ''},
  103. {0, {"oid"}, OIDOID, 0, 4, -2, 0, -1, -1, '01', '', 'i', '', ''},
  104. {0, {"xmin"}, XIDOID, 0, 4, -3, 0, -1, -1, '01', '', 'i', '', ''},
  105. {0, {"cmin"}, CIDOID, 0, 4, -4, 0, -1, -1, '01', '', 'i', '', ''},
  106. {0, {"xmax"}, XIDOID, 0, 4, -5, 0, -1, -1, '01', '', 'i', '', ''},
  107. {0, {"cmax"}, CIDOID, 0, 4, -6, 0, -1, -1, '01', '', 'i', '', ''},
  108. };
  110. /* ----------------------------------------------------------------
  111.  * GetHeapRelationOid
  112.  * ----------------------------------------------------------------
  113.  */
  114. static Oid
  115. GetHeapRelationOid(char *heapRelationName, char *indexRelationName, bool istemp)
  116. {
  117. Oid indoid;
  118. Oid heapoid;
  121. indoid = RelnameFindRelid(indexRelationName);
  123. if ((!istemp && OidIsValid(indoid)) ||
  124. (istemp && get_temp_rel_by_name(indexRelationName) != NULL))
  125. elog(ERROR, "Cannot create index: '%s' already exists",
  126.  indexRelationName);
  128. heapoid = RelnameFindRelid(heapRelationName);
  130. if (!OidIsValid(heapoid))
  131. elog(ERROR, "Cannot create index on '%s': relation does not exist",
  132.  heapRelationName);
  134. return heapoid;
  135. }
  137. static TupleDesc
  138. BuildFuncTupleDesc(FuncIndexInfo *funcInfo)
  139. {
  140. HeapTuple tuple;
  141. TupleDesc funcTupDesc;
  142. Oid retType;
  143. char    *funcname;
  144. int4 nargs;
  145. Oid    *argtypes;
  147. /*
  148.  * Allocate and zero a tuple descriptor.
  149.  */
  150. funcTupDesc = CreateTemplateTupleDesc(1);
  151. funcTupDesc->attrs[0] = (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
  152. MemSet(funcTupDesc->attrs[0], 0, ATTRIBUTE_TUPLE_SIZE);
  154. /*
  155.  * Lookup the function for the return type.
  156.  */
  157. funcname = FIgetname(funcInfo);
  158. nargs = FIgetnArgs(funcInfo);
  159. argtypes = FIgetArglist(funcInfo);
  160. tuple = SearchSysCacheTuple(PRONAME,
  161. PointerGetDatum(funcname),
  162. Int32GetDatum(nargs),
  163. PointerGetDatum(argtypes),
  164. 0);
  166. if (!HeapTupleIsValid(tuple))
  167. func_error("BuildFuncTupleDesc", funcname, nargs, argtypes, NULL);
  169. retType = ((Form_pg_proc) GETSTRUCT(tuple))->prorettype;
  171. /*
  172.  * Look up the return type in pg_type for the type length.
  173.  */
  174. tuple = SearchSysCacheTuple(TYPOID,
  175. ObjectIdGetDatum(retType),
  176. 0, 0, 0);
  177. if (!HeapTupleIsValid(tuple))
  178. elog(ERROR, "Function %s return type does not exist", FIgetname(funcInfo));
  180. /*
  181.  * Assign some of the attributes values. Leave the rest as 0.
  182.  */
  183. funcTupDesc->attrs[0]->attlen = ((Form_pg_type) GETSTRUCT(tuple))->typlen;
  184. funcTupDesc->attrs[0]->atttypid = retType;
  185. funcTupDesc->attrs[0]->attnum = 1;
  186. funcTupDesc->attrs[0]->attbyval = ((Form_pg_type) GETSTRUCT(tuple))->typbyval;
  187. funcTupDesc->attrs[0]->attcacheoff = -1;
  188. funcTupDesc->attrs[0]->atttypmod = -1;
  189. funcTupDesc->attrs[0]->attalign = ((Form_pg_type) GETSTRUCT(tuple))->typalign;
  191. /*
  192.  * make the attributes name the same as the functions
  193.  */
  194. namestrcpy(&funcTupDesc->attrs[0]->attname, funcname);
  196. return funcTupDesc;
  197. }
  199. /* ----------------------------------------------------------------
  200.  * ConstructTupleDescriptor
  201.  * ----------------------------------------------------------------
  202.  */
  203. static TupleDesc
  204. ConstructTupleDescriptor(Oid heapoid,
  205.  Relation heapRelation,
  206.  List *attributeList,
  207.  int numatts,
  208.  AttrNumber *attNums)
  209. {
  210. TupleDesc heapTupDesc;
  211. TupleDesc indexTupDesc;
  212. IndexElem  *IndexKey;
  213. TypeName   *IndexKeyType;
  214. AttrNumber atnum; /* attributeNumber[attributeOffset] */
  215. AttrNumber atind;
  216. int natts; /* Form_pg_class->relnatts */
  217. char    *from; /* used to simplify memcpy below */
  218. char    *to; /* used to simplify memcpy below */
  219. int i;
  221. /* ----------------
  222.  * allocate the new tuple descriptor
  223.  * ----------------
  224.  */
  225. natts = RelationGetForm(heapRelation)->relnatts;
  227. indexTupDesc = CreateTemplateTupleDesc(numatts);
  229. /* ----------------
  230.  *
  231.  * ----------------
  232.  */
  234. /* ----------------
  235.  *   for each attribute we are indexing, obtain its attribute
  236.  *   tuple form from either the static table of system attribute
  237.  *   tuple forms or the relation tuple descriptor
  238.  * ----------------
  239.  */
  240. for (i = 0; i < numatts; i += 1)
  241. {
  243. /* ----------------
  244.  *  get the attribute number and make sure it's valid
  245.  * ----------------
  246.  */
  247. atnum = attNums[i];
  248. if (atnum > natts)
  249. elog(ERROR, "Cannot create index: attribute %d does not exist",
  250.  atnum);
  251. if (attributeList)
  252. {
  253. IndexKey = (IndexElem *) lfirst(attributeList);
  254. IndexKeyType = IndexKey->typename;
  255. attributeList = lnext(attributeList);
  256. }
  257. else
  258. IndexKeyType = NULL;
  260. indexTupDesc->attrs[i] = (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
  262. /* ----------------
  263.  *  determine which tuple descriptor to copy
  264.  * ----------------
  265.  */
  266. if (!AttrNumberIsForUserDefinedAttr(atnum))
  267. {
  269. /* ----------------
  270.  *   here we are indexing on a system attribute (-1...-12)
  271.  *   so we convert atnum into a usable index 0...11 so we can
  272.  *   use it to dereference the array sysatts[] which stores
  273.  *   tuple descriptor information for system attributes.
  274.  * ----------------
  275.  */
  276. if (atnum <= FirstLowInvalidHeapAttributeNumber || atnum >= 0)
  277. elog(ERROR, "Cannot create index on system attribute: attribute number out of range (%d)", atnum);
  278. atind = (-atnum) - 1;
  280. from = (char *) (&sysatts[atind]);
  282. }
  283. else
  284. {
  285. /* ----------------
  286.  *   here we are indexing on a normal attribute (1...n)
  287.  * ----------------
  288.  */
  289. heapTupDesc = RelationGetDescr(heapRelation);
  290. atind = AttrNumberGetAttrOffset(atnum);
  292. from = (char *) (heapTupDesc->attrs[atind]);
  293. }
  295. /* ----------------
  296.  *  now that we've determined the "from", let's copy
  297.  *  the tuple desc data...
  298.  * ----------------
  299.  */
  301. to = (char *) (indexTupDesc->attrs[i]);
  302. memcpy(to, from, ATTRIBUTE_TUPLE_SIZE);
  304. ((Form_pg_attribute) to)->attnum = i + 1;
  306. ((Form_pg_attribute) to)->attnotnull = false;
  307. ((Form_pg_attribute) to)->atthasdef = false;
  308. ((Form_pg_attribute) to)->attcacheoff = -1;
  309. ((Form_pg_attribute) to)->atttypmod = -1;
  310. ((Form_pg_attribute) to)->attalign = 'i';
  312. /*
  313.  * if the keytype is defined, we need to change the tuple form's
  314.  * atttypid & attlen field to match that of the key's type
  315.  */
  316. if (IndexKeyType != NULL)
  317. {
  318. HeapTuple tup;
  320. tup = SearchSysCacheTuple(TYPNAME,
  321.   PointerGetDatum(IndexKeyType->name),
  322.   0, 0, 0);
  323. if (!HeapTupleIsValid(tup))
  324. elog(ERROR, "create index: type '%s' undefined",
  325.  IndexKeyType->name);
  326. ((Form_pg_attribute) to)->atttypid = tup->t_data->t_oid;
  327. ((Form_pg_attribute) to)->attbyval =
  328. ((Form_pg_type) GETSTRUCT(tup))->typbyval;
  329. ((Form_pg_attribute) to)->attlen =
  330. ((Form_pg_type) GETSTRUCT(tup))->typlen;
  331. ((Form_pg_attribute) to)->attalign =
  332. ((Form_pg_type) GETSTRUCT(tup))->typalign;
  333. ((Form_pg_attribute) to)->atttypmod = IndexKeyType->typmod;
  334. }
  337. /* ----------------
  338.  *   now we have to drop in the proper relation descriptor
  339.  *   into the copied tuple form's attrelid and we should be
  340.  *   all set.
  341.  * ----------------
  342.  */
  343. ((Form_pg_attribute) to)->attrelid = heapoid;
  344. }
  346. return indexTupDesc;
  347. }
  349. /* ----------------------------------------------------------------
  350.  * AccessMethodObjectIdGetForm
  351.  * Returns the formated access method tuple given its object identifier.
  352.  *
  353.  * XXX ADD INDEXING
  354.  *
  355.  * Note:
  356.  * Assumes object identifier is valid.
  357.  * ----------------------------------------------------------------
  358.  */
  359. Form_pg_am
  360. AccessMethodObjectIdGetForm(Oid accessMethodObjectId)
  361. {
  362. Relation pg_am_desc;
  363. HeapScanDesc pg_am_scan;
  364. HeapTuple pg_am_tuple;
  365. ScanKeyData key;
  366. Form_pg_am aform;
  368. /* ----------------
  369.  * form a scan key for the pg_am relation
  370.  * ----------------
  371.  */
  372. ScanKeyEntryInitialize(&key, 0, ObjectIdAttributeNumber,
  373.    F_OIDEQ,
  374.    ObjectIdGetDatum(accessMethodObjectId));
  376. /* ----------------
  377.  * fetch the desired access method tuple
  378.  * ----------------
  379.  */
  380. pg_am_desc = heap_openr(AccessMethodRelationName);
  381. pg_am_scan = heap_beginscan(pg_am_desc, 0, SnapshotNow, 1, &key);
  383. pg_am_tuple = heap_getnext(pg_am_scan, 0);
  385. /* ----------------
  386.  * return NULL if not found
  387.  * ----------------
  388.  */
  389. if (!HeapTupleIsValid(pg_am_tuple))
  390. {
  391. heap_endscan(pg_am_scan);
  392. heap_close(pg_am_desc);
  393. return NULL;
  394. }
  396. /* ----------------
  397.  * if found am tuple, then copy the form and return the copy
  398.  * ----------------
  399.  */
  400. aform = (Form_pg_am) palloc(sizeof *aform);
  401. memcpy(aform, GETSTRUCT(pg_am_tuple), sizeof *aform);
  403. heap_endscan(pg_am_scan);
  404. heap_close(pg_am_desc);
  406. return aform;
  407. }
  409. /* ----------------------------------------------------------------
  410.  * ConstructIndexReldesc
  411.  * ----------------------------------------------------------------
  412.  */
  413. static void
  414. ConstructIndexReldesc(Relation indexRelation, Oid amoid)
  415. {
  416. extern GlobalMemory CacheCxt;
  417. MemoryContext oldcxt;
  419. /* ----------------
  420.  *   here we make certain to allocate the access method
  421.  *   tuple within the cache context lest it vanish when the
  422.  *   context changes
  423.  * ----------------
  424.  */
  425. if (!CacheCxt)
  426. CacheCxt = CreateGlobalMemory("Cache");
  428. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  430. indexRelation->rd_am = AccessMethodObjectIdGetForm(amoid);
  432. MemoryContextSwitchTo(oldcxt);
  434. /* ----------------
  435.  *  XXX missing the initialization of some other fields
  436.  * ----------------
  437.  */
  439. indexRelation->rd_rel->relowner = GetUserId();
  441. indexRelation->rd_rel->relam = amoid;
  442. indexRelation->rd_rel->reltuples = 1; /* XXX */
  443. indexRelation->rd_rel->relkind = RELKIND_INDEX;
  444. }
  446. /* ----------------------------------------------------------------
  447.  * UpdateRelationRelation
  448.  * ----------------------------------------------------------------
  449.  */
  450. static Oid
  451. UpdateRelationRelation(Relation indexRelation, char *temp_relname)
  452. {
  453. Relation pg_class;
  454. HeapTuple tuple;
  455. Oid tupleOid;
  456. Relation idescs[Num_pg_class_indices];
  458. pg_class = heap_openr(RelationRelationName);
  460. /* XXX Natts_pg_class_fixed is a hack - see pg_class.h */
  461. tuple = heap_addheader(Natts_pg_class_fixed,
  462.    sizeof(*indexRelation->rd_rel),
  463.    (char *) indexRelation->rd_rel);
  465. /* ----------------
  466.  * the new tuple must have the same oid as the relcache entry for the
  467.  * index. sure would be embarassing to do this sort of thing in polite
  468.  * company.
  469.  * ----------------
  470.  */
  471. tuple->t_data->t_oid = RelationGetRelid(indexRelation);
  472. heap_insert(pg_class, tuple);
  474. if (temp_relname)
  475. create_temp_relation(temp_relname, tuple);
  477. /*
  478.  * During normal processing, we need to make sure that the system
  479.  * catalog indices are correct.  Bootstrap (initdb) time doesn't
  480.  * require this, because we make sure that the indices are correct
  481.  * just before exiting.
  482.  */
  484. if (!IsBootstrapProcessingMode())
  485. {
  486. CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, idescs);
  487. CatalogIndexInsert(idescs, Num_pg_class_indices, pg_class, tuple);
  488. CatalogCloseIndices(Num_pg_class_indices, idescs);
  489. }
  491. tupleOid = tuple->t_data->t_oid;
  492. pfree(tuple);
  493. heap_close(pg_class);
  495. return tupleOid;
  496. }
  498. /* ----------------------------------------------------------------
  499.  * InitializeAttributeOids
  500.  * ----------------------------------------------------------------
  501.  */
  502. static void
  503. InitializeAttributeOids(Relation indexRelation,
  504. int numatts,
  505. Oid indexoid)
  506. {
  507. TupleDesc tupleDescriptor;
  508. int i;
  510. tupleDescriptor = RelationGetDescr(indexRelation);
  512. for (i = 0; i < numatts; i += 1)
  513. tupleDescriptor->attrs[i]->attrelid = indexoid;
  514. }
  516. /* ----------------------------------------------------------------
  517.  * AppendAttributeTuples
  518.  *
  519.  * XXX For now, only change the ATTNUM attribute value
  520.  * ----------------------------------------------------------------
  521.  */
  522. static void
  523. AppendAttributeTuples(Relation indexRelation, int numatts)
  524. {
  525. Relation pg_attribute;
  526. HeapTuple init_tuple,
  527. cur_tuple = NULL,
  528. new_tuple;
  529. bool hasind;
  530. Relation idescs[Num_pg_attr_indices];
  532. Datum value[Natts_pg_attribute];
  533. char nullv[Natts_pg_attribute];
  534. char replace[Natts_pg_attribute];
  536. TupleDesc indexTupDesc;
  537. int i;
  539. /* ----------------
  540.  * open the attribute relation
  541.  * XXX ADD INDEXING
  542.  * ----------------
  543.  */
  544. pg_attribute = heap_openr(AttributeRelationName);
  546. /* ----------------
  547.  * initialize *null, *replace and *value
  548.  * ----------------
  549.  */
  550. MemSet(nullv, ' ', Natts_pg_attribute);
  551. MemSet(replace, ' ', Natts_pg_attribute);
  553. /* ----------------
  554.  * create the first attribute tuple.
  555.  * XXX For now, only change the ATTNUM attribute value
  556.  * ----------------
  557.  */
  558. replace[Anum_pg_attribute_attnum - 1] = 'r';
  559. replace[Anum_pg_attribute_attcacheoff - 1] = 'r';
  561. value[Anum_pg_attribute_attnum - 1] = Int16GetDatum(1);
  562. value[Anum_pg_attribute_attcacheoff - 1] = Int32GetDatum(-1);
  564. init_tuple = heap_addheader(Natts_pg_attribute,
  565. ATTRIBUTE_TUPLE_SIZE,
  566.  (char *) (indexRelation->rd_att->attrs[0]));
  568. hasind = false;
  569. if (!IsBootstrapProcessingMode() && pg_attribute->rd_rel->relhasindex)
  570. {
  571. hasind = true;
  572. CatalogOpenIndices(Num_pg_attr_indices, Name_pg_attr_indices, idescs);
  573. }
  575. /* ----------------
  576.  * insert the first attribute tuple.
  577.  * ----------------
  578.  */
  579. cur_tuple = heap_modifytuple(init_tuple,
  580.  pg_attribute,
  581.  value,
  582.  nullv,
  583.  replace);
  584. pfree(init_tuple);
  586. heap_insert(pg_attribute, cur_tuple);
  587. if (hasind)
  588. CatalogIndexInsert(idescs, Num_pg_attr_indices, pg_attribute, cur_tuple);
  590. /* ----------------
  591.  * now we use the information in the index cur_tuple
  592.  * descriptor to form the remaining attribute tuples.
  593.  * ----------------
  594.  */
  595. indexTupDesc = RelationGetDescr(indexRelation);
  597. for (i = 1; i < numatts; i += 1)
  598. {
  599. /* ----------------
  600.  * process the remaining attributes...
  601.  * ----------------
  602.  */
  603. memmove(GETSTRUCT(cur_tuple),
  604. (char *) indexTupDesc->attrs[i],
  605. ATTRIBUTE_TUPLE_SIZE);
  607. value[Anum_pg_attribute_attnum - 1] = Int16GetDatum(i + 1);
  609. new_tuple = heap_modifytuple(cur_tuple,
  610.  pg_attribute,
  611.  value,
  612.  nullv,
  613.  replace);
  614. pfree(cur_tuple);
  616. heap_insert(pg_attribute, new_tuple);
  617. if (hasind)
  618. CatalogIndexInsert(idescs, Num_pg_attr_indices, pg_attribute, new_tuple);
  620. /* ----------------
  621.  * ModifyHeapTuple returns a new copy of a cur_tuple
  622.  * so we free the original and use the copy..
  623.  * ----------------
  624.  */
  625. cur_tuple = new_tuple;
  626. }
  628. if (cur_tuple)
  629. pfree(cur_tuple);
  630. heap_close(pg_attribute);
  631. if (hasind)
  632. CatalogCloseIndices(Num_pg_attr_indices, idescs);
  634. }
  636. /* ----------------------------------------------------------------
  637.  * UpdateIndexRelation
  638.  * ----------------------------------------------------------------
  639.  */
  640. static void
  641. UpdateIndexRelation(Oid indexoid,
  642. Oid heapoid,
  643. FuncIndexInfo *funcInfo,
  644. int natts,
  645. AttrNumber *attNums,
  646. Oid *classOids,
  647. Node *predicate,
  648. List *attributeList,
  649. bool islossy,
  650. bool unique,
  651. bool primary)
  652. {
  653. Form_pg_index indexForm;
  654. IndexElem  *IndexKey;
  655. char    *predString;
  656. text    *predText;
  657. int predLen,
  658. itupLen;
  659. Relation pg_index;
  660. HeapTuple tuple;
  661. int i;
  663. /* ----------------
  664.  * allocate an Form_pg_index big enough to hold the
  665.  * index-predicate (if any) in string form
  666.  * ----------------
  667.  */
  668. if (predicate != NULL)
  669. {
  670. predString = nodeToString(predicate);
  671. predText = (text *) fmgr(F_TEXTIN, predString);
  672. pfree(predString);
  673. }
  674. else
  675. predText = (text *) fmgr(F_TEXTIN, "");
  677. predLen = VARSIZE(predText);
  678. itupLen = predLen + sizeof(FormData_pg_index);
  679. indexForm = (Form_pg_index) palloc(itupLen);
  680. memset(indexForm, 0, sizeof(FormData_pg_index));
  682. memmove((char *) &indexForm->indpred, (char *) predText, predLen);
  684. /* ----------------
  685.  * store the oid information into the index tuple form
  686.  * ----------------
  687.  */
  688. indexForm->indrelid = heapoid;
  689. indexForm->indexrelid = indexoid;
  690. indexForm->indproc = (PointerIsValid(funcInfo)) ?
  691. FIgetProcOid(funcInfo) : InvalidOid;
  692. indexForm->indislossy = islossy;
  693. indexForm->indisprimary = primary;
  694. indexForm->indisunique = unique;
  696. indexForm->indhaskeytype = 0;
  697. while (attributeList != NIL)
  698. {
  699. IndexKey = (IndexElem *) lfirst(attributeList);
  700. if (IndexKey->typename != NULL)
  701. {
  702. indexForm->indhaskeytype = 1;
  703. break;
  704. }
  705. attributeList = lnext(attributeList);
  706. }
  708. MemSet((char *) &indexForm->indkey[0], 0, sizeof indexForm->indkey);
  709. MemSet((char *) &indexForm->indclass[0], 0, sizeof indexForm->indclass);
  711. /* ----------------
  712.  * copy index key and op class information
  713.  * ----------------
  714.  */
  715. for (i = 0; i < natts; i += 1)
  716. {
  717. indexForm->indkey[i] = attNums[i];
  718. indexForm->indclass[i] = classOids[i];
  719. }
  721. /*
  722.  * If we have a functional index, add all attribute arguments
  723.  */
  724. if (PointerIsValid(funcInfo))
  725. {
  726. for (i = 1; i < FIgetnArgs(funcInfo); i++)
  727. indexForm->indkey[i] = attNums[i];
  728. }
  730. indexForm->indisclustered = ''; /* XXX constant */
  732. /* ----------------
  733.  * open the system catalog index relation
  734.  * ----------------
  735.  */
  736. pg_index = heap_openr(IndexRelationName);
  738. /* ----------------
  739.  * form a tuple to insert into pg_index
  740.  * ----------------
  741.  */
  742. tuple = heap_addheader(Natts_pg_index,
  743.    itupLen,
  744.    (char *) indexForm);
  746. /* ----------------
  747.  * insert the tuple into the pg_index
  748.  * XXX ADD INDEX TUPLES TOO
  749.  * ----------------
  750.  */
  751. heap_insert(pg_index, tuple);
  753. /* ----------------
  754.  * close the relation and free the tuple
  755.  * ----------------
  756.  */
  757. heap_close(pg_index);
  758. pfree(predText);
  759. pfree(indexForm);
  760. pfree(tuple);
  761. }
  763. /* ----------------------------------------------------------------
  764.  * UpdateIndexPredicate
  765.  * ----------------------------------------------------------------
  766.  */
  767. void
  768. UpdateIndexPredicate(Oid indexoid, Node *oldPred, Node *predicate)
  769. {
  770. Node    *newPred;
  771. char    *predString;
  772. text    *predText;
  773. Relation pg_index;
  774. HeapTuple tuple;
  775. HeapTuple newtup;
  776. int i;
  777. Datum values[Natts_pg_index];
  778. char nulls[Natts_pg_index];
  779. char replace[Natts_pg_index];
  781. /*
  782.  * Construct newPred as a CNF expression equivalent to the OR of the
  783.  * original partial-index predicate ("oldPred") and the extension
  784.  * predicate ("predicate").
  785.  *
  786.  * This should really try to process the result to change things like
  787.  * "a>2 OR a>1" to simply "a>1", but for now all it does is make sure
  788.  * that if the extension predicate is NULL (i.e., it is being extended
  789.  * to be a complete index), then newPred will be NULL - in effect,
  790.  * changing "a>2 OR TRUE" to "TRUE". --Nels, Jan '93
  791.  */
  792. newPred = NULL;
  793. if (predicate != NULL)
  794. {
  795. newPred = (Node *) make_orclause(lcons(make_andclause((List *) predicate),
  796.   lcons(make_andclause((List *) oldPred),
  797. NIL)));
  798. newPred = (Node *) cnfify((Expr *) newPred, true);
  799. }
  801. /* translate the index-predicate to string form */
  802. if (newPred != NULL)
  803. {
  804. predString = nodeToString(newPred);
  805. predText = (text *) fmgr(F_TEXTIN, predString);
  806. pfree(predString);
  807. }
  808. else
  809. predText = (text *) fmgr(F_TEXTIN, "");
  811. /* open the index system catalog relation */
  812. pg_index = heap_openr(IndexRelationName);
  814. tuple = SearchSysCacheTuple(INDEXRELID,
  815. ObjectIdGetDatum(indexoid),
  816. 0, 0, 0);
  817. Assert(HeapTupleIsValid(tuple));
  819. for (i = 0; i < Natts_pg_index; i++)
  820. {
  821. nulls[i] = heap_attisnull(tuple, i + 1) ? 'n' : ' ';
  822. replace[i] = ' ';
  823. values[i] = (Datum) NULL;
  824. }
  826. replace[Anum_pg_index_indpred - 1] = 'r';
  827. values[Anum_pg_index_indpred - 1] = (Datum) predText;
  829. newtup = heap_modifytuple(tuple, pg_index, values, nulls, replace);
  831. heap_replace(pg_index, &newtup->t_self, newtup, NULL);
  833. pfree(newtup);
  834. heap_close(pg_index);
  835. pfree(predText);
  836. }
  838. /* ----------------------------------------------------------------
  839.  * InitIndexStrategy
  840.  * ----------------------------------------------------------------
  841.  */
  842. void
  843. InitIndexStrategy(int numatts,
  844.   Relation indexRelation,
  845.   Oid accessMethodObjectId)
  846. {
  847. IndexStrategy strategy;
  848. RegProcedure *support;
  849. uint16 amstrategies;
  850. uint16 amsupport;
  851. Oid attrelid;
  852. Size strsize;
  853. extern GlobalMemory CacheCxt;
  855. /* ----------------
  856.  * get information from the index relation descriptor
  857.  * ----------------
  858.  */
  859. attrelid = indexRelation->rd_att->attrs[0]->attrelid;
  860. amstrategies = indexRelation->rd_am->amstrategies;
  861. amsupport = indexRelation->rd_am->amsupport;
  863. /* ----------------
  864.  * get the size of the strategy
  865.  * ----------------
  866.  */
  867. strsize = AttributeNumberGetIndexStrategySize(numatts, amstrategies);
  869. /* ----------------
  870.  * allocate the new index strategy structure
  871.  *
  872.  * the index strategy has to be allocated in the same
  873.  * context as the relation descriptor cache or else
  874.  * it will be lost at the end of the transaction.
  875.  * ----------------
  876.  */
  877. if (!CacheCxt)
  878. CacheCxt = CreateGlobalMemory("Cache");
  880. strategy = (IndexStrategy)
  881. MemoryContextAlloc((MemoryContext) CacheCxt, strsize);
  883. if (amsupport > 0)
  884. {
  885. strsize = numatts * (amsupport * sizeof(RegProcedure));
  886. support = (RegProcedure *) MemoryContextAlloc((MemoryContext) CacheCxt,
  887.   strsize);
  888. }
  889. else
  890. support = (RegProcedure *) NULL;
  892. /* ----------------
  893.  * fill in the index strategy structure with information
  894.  * from the catalogs. Note: we use heap override mode
  895.  * in order to be allowed to see the correct information in the
  896.  * catalogs, even though our transaction has not yet committed.
  897.  * ----------------
  898.  */
  899. setheapoverride(true);
  901. IndexSupportInitialize(strategy, support,
  902.    attrelid, accessMethodObjectId,
  903.    amstrategies, amsupport, numatts);
  905. setheapoverride(false);
  907. /* ----------------
  908.  * store the strategy information in the index reldesc
  909.  * ----------------
  910.  */
  911. RelationSetIndexSupport(indexRelation, strategy, support);
  912. }
  915. /* ----------------------------------------------------------------
  916.  * index_create
  917.  * ----------------------------------------------------------------
  918.  */
  919. void
  920. index_create(char *heapRelationName,
  921.  char *indexRelationName,
  922.  FuncIndexInfo *funcInfo,
  923.  List *attributeList,
  924.  Oid accessMethodObjectId,
  925.  int numatts,
  926.  AttrNumber *attNums,
  927.  Oid *classObjectId,
  928.  uint16 parameterCount,
  929.  Datum *parameter,
  930.  Node *predicate,
  931.  bool islossy,
  932.  bool unique,
  933.  bool primary)
  934. {
  935. Relation heapRelation;
  936. Relation indexRelation;
  937. TupleDesc indexTupDesc;
  938. Oid heapoid;
  939. Oid indexoid;
  940. PredInfo   *predInfo;
  941. bool istemp = (get_temp_rel_by_name(heapRelationName) != NULL);
  942. char    *temp_relname = NULL;
  944. /* ----------------
  945.  * check parameters
  946.  * ----------------
  947.  */
  948. if (numatts < 1)
  949. elog(ERROR, "must index at least one attribute");
  951. /* ----------------
  952.  *   get heap relation oid and open the heap relation
  953.  *   XXX ADD INDEXING
  954.  * ----------------
  955.  */
  956. heapoid = GetHeapRelationOid(heapRelationName, indexRelationName, istemp);
  958. heapRelation = heap_open(heapoid);
  960. /*
  961.  * Only SELECT ... FOR UPDATE are allowed
  962.  */
  963. LockRelation(heapRelation, ShareLock);
  965. /* ----------------
  966.  *   construct new tuple descriptor
  967.  * ----------------
  968.  */
  969. if (PointerIsValid(funcInfo))
  970. indexTupDesc = BuildFuncTupleDesc(funcInfo);
  971. else
  972. indexTupDesc = ConstructTupleDescriptor(heapoid,
  973. heapRelation,
  974. attributeList,
  975. numatts,
  976. attNums);
  978. /* invalidate cache so possible non-temp index is masked by temp */
  979. if (istemp)
  980. {
  981. Oid relid = RelnameFindRelid(indexRelationName);
  983. if (relid != InvalidOid)
  984. RelationForgetRelation(relid);
  985. }
  987. /* save user relation name because heap_create changes it */
  988. if (istemp)
  989. {
  990. temp_relname = pstrdup(indexRelationName); /* save original value */
  991. indexRelationName = palloc(NAMEDATALEN);
  992. strcpy(indexRelationName, temp_relname); /* heap_create will
  993.  * change this */
  994. }
  996. /* ----------------
  997.  * create the index relation
  998.  * ----------------
  999.  */
  1000. indexRelation = heap_create(indexRelationName,
  1001. indexTupDesc, false, istemp);
  1003. /* ----------------
  1004.  *   construct the index relation descriptor
  1005.  *
  1006.  *   XXX should have a proper way to create cataloged relations
  1007.  * ----------------
  1008.  */
  1009. ConstructIndexReldesc(indexRelation, accessMethodObjectId);
  1011. /* ----------------
  1012.  *   add index to catalogs
  1013.  *   (append RELATION tuple)
  1014.  * ----------------
  1015.  */
  1016. indexoid = UpdateRelationRelation(indexRelation, temp_relname);
  1018. /* ----------------
  1019.  * Now get the index procedure (only relevant for functional indices).
  1020.  * ----------------
  1021.  */
  1023. if (PointerIsValid(funcInfo))
  1024. {
  1025. HeapTuple proc_tup;
  1027. proc_tup = SearchSysCacheTuple(PRONAME,
  1028. PointerGetDatum(FIgetname(funcInfo)),
  1029.  Int32GetDatum(FIgetnArgs(funcInfo)),
  1030.  PointerGetDatum(FIgetArglist(funcInfo)),
  1031.    0);
  1033. if (!HeapTupleIsValid(proc_tup))
  1034. {
  1035. func_error("index_create", FIgetname(funcInfo),
  1036.  FIgetnArgs(funcInfo), FIgetArglist(funcInfo), NULL);
  1037. }
  1038. FIgetProcOid(funcInfo) = proc_tup->t_data->t_oid;
  1039. }
  1041. /* ----------------
  1042.  * now update the object id's of all the attribute
  1043.  * tuple forms in the index relation's tuple descriptor
  1044.  * ----------------
  1045.  */
  1046. InitializeAttributeOids(indexRelation, numatts, indexoid);
  1048. /* ----------------
  1049.  *   append ATTRIBUTE tuples
  1050.  * ----------------
  1051.  */
  1052. AppendAttributeTuples(indexRelation, numatts);
  1054. /* ----------------
  1055.  *   update pg_index
  1056.  *   (append INDEX tuple)
  1057.  *
  1058.  *   Note that this stows away a representation of "predicate".
  1059.  *   (Or, could define a rule to maintain the predicate) --Nels, Feb '92
  1060.  * ----------------
  1061.  */
  1062. UpdateIndexRelation(indexoid, heapoid, funcInfo,
  1063. numatts, attNums, classObjectId, predicate,
  1064. attributeList, islossy, unique, primary);
  1066. predInfo = (PredInfo *) palloc(sizeof(PredInfo));
  1067. predInfo->pred = predicate;
  1068. predInfo->oldPred = NULL;
  1070. /* ----------------
  1071.  *   initialize the index strategy
  1072.  * ----------------
  1073.  */
  1074. InitIndexStrategy(numatts, indexRelation, accessMethodObjectId);
  1076. /*
  1077.  * If this is bootstrap (initdb) time, then we don't actually fill in
  1078.  * the index yet.  We'll be creating more indices and classes later,
  1079.  * so we delay filling them in until just before we're done with
  1080.  * bootstrapping.  Otherwise, we call the routine that constructs the
  1081.  * index.  The heap and index relations are closed by index_build().
  1082.  */
  1083. if (IsBootstrapProcessingMode())
  1084. {
  1085. index_register(heapRelationName, indexRelationName, numatts, attNums,
  1086.    parameterCount, parameter, funcInfo, predInfo);
  1087. }
  1088. else
  1089. {
  1090. heapRelation = heap_openr(heapRelationName);
  1091. index_build(heapRelation, indexRelation, numatts, attNums,
  1092. parameterCount, parameter, funcInfo, predInfo);
  1093. }
  1094. }
  1096. /* ----------------------------------------------------------------
  1097.  *
  1098.  * index_destroy
  1099.  *
  1100.  * ----------------------------------------------------------------
  1101.  */
  1102. void
  1103. index_destroy(Oid indexId)
  1104. {
  1105. Relation userindexRelation;
  1106. Relation indexRelation;
  1107. Relation relationRelation;
  1108. Relation attributeRelation;
  1109. HeapTuple tuple;
  1110. int16 attnum;
  1112. Assert(OidIsValid(indexId));
  1114. /* Open now to obtain lock by referencing table?  bjm */
  1115. userindexRelation = index_open(indexId);
  1117. /* ----------------
  1118.  * fix RELATION relation
  1119.  * ----------------
  1120.  */
  1121. relationRelation = heap_openr(RelationRelationName);
  1123. tuple = SearchSysCacheTupleCopy(RELOID,
  1124. ObjectIdGetDatum(indexId),
  1125. 0, 0, 0);
  1127. Assert(HeapTupleIsValid(tuple));
  1129. heap_delete(relationRelation, &tuple->t_self, NULL);
  1130. pfree(tuple);
  1131. heap_close(relationRelation);
  1133. /* ----------------
  1134.  * fix ATTRIBUTE relation
  1135.  * ----------------
  1136.  */
  1137. attributeRelation = heap_openr(AttributeRelationName);
  1139. attnum = 1; /* indexes start at 1 */
  1141. while (HeapTupleIsValid(tuple = SearchSysCacheTupleCopy(ATTNUM,
  1142.    ObjectIdGetDatum(indexId),
  1143.    Int16GetDatum(attnum),
  1144. 0, 0)))
  1145. {
  1146. heap_delete(attributeRelation, &tuple->t_self, NULL);
  1147. pfree(tuple);
  1148. attnum++;
  1149. }
  1150. heap_close(attributeRelation);
  1152. /* does something only if it is a temp index */
  1153. remove_temp_relation(indexId);
  1155. /* ----------------
  1156.  * fix INDEX relation
  1157.  * ----------------
  1158.  */
  1159. tuple = SearchSysCacheTupleCopy(INDEXRELID,
  1160. ObjectIdGetDatum(indexId),
  1161. 0, 0, 0);
  1162. Assert(HeapTupleIsValid(tuple));
  1164. indexRelation = heap_openr(IndexRelationName);
  1166. heap_delete(indexRelation, &tuple->t_self, NULL);
  1167. pfree(tuple);
  1168. heap_close(indexRelation);
  1170. /*
  1171.  * flush cache and physically remove the file
  1172.  */
  1173. ReleaseRelationBuffers(userindexRelation);
  1175. if (smgrunlink(DEFAULT_SMGR, userindexRelation) != SM_SUCCESS)
  1176. elog(ERROR, "amdestroyr: unlink: %m");
  1178. index_close(userindexRelation);
  1179. RelationForgetRelation(RelationGetRelid(userindexRelation));
  1180. }
  1182. /* ----------------------------------------------------------------
  1183.  * index_build support
  1184.  * ----------------------------------------------------------------
  1185.  */
  1186. /* ----------------
  1187.  * FormIndexDatum
  1188.  * ----------------
  1189.  */
  1190. void
  1191. FormIndexDatum(int numberOfAttributes,
  1192.    AttrNumber *attributeNumber,
  1193.    HeapTuple heapTuple,
  1194.    TupleDesc heapDescriptor,
  1195.    Datum *datum,
  1196.    char *nullv,
  1197.    FuncIndexInfoPtr fInfo)
  1198. {
  1199. AttrNumber i;
  1200. int offset;
  1201. bool isNull;
  1203. /* ----------------
  1204.  * for each attribute we need from the heap tuple,
  1205.  * get the attribute and stick it into the datum and
  1206.  * null arrays.
  1207.  * ----------------
  1208.  */
  1210. for (i = 1; i <= numberOfAttributes; i++)
  1211. {
  1212. offset = AttrNumberGetAttrOffset(i);
  1214. datum[offset] = PointerGetDatum(GetIndexValue(heapTuple,
  1215.   heapDescriptor,
  1216.   offset,
  1217.   attributeNumber,
  1218.   fInfo,
  1219.   &isNull));
  1221. nullv[offset] = (isNull) ? 'n' : ' ';
  1222. }
  1223. }
  1226. /* ----------------
  1227.  * UpdateStats
  1228.  * ----------------
  1229.  */
  1230. void
  1231. UpdateStats(Oid relid, long reltuples, bool hasindex)
  1232. {
  1233. Relation whichRel;
  1234. Relation pg_class;
  1235. HeapTuple tuple;
  1236. HeapTuple newtup;
  1237. long relpages;
  1238. int i;
  1239. Form_pg_class rd_rel;
  1240. Relation idescs[Num_pg_class_indices];
  1241. Datum values[Natts_pg_class];
  1242. char nulls[Natts_pg_class];
  1243. char replace[Natts_pg_class];
  1244. HeapScanDesc pg_class_scan = NULL;
  1246. /* ----------------
  1247.  * This routine handles updates for both the heap and index relation
  1248.  * statistics. In order to guarantee that we're able to *see* the index
  1249.  * relation tuple, we bump the command counter id here.  The index
  1250.  * relation tuple was created in the current transaction.
  1251.  * ----------------
  1252.  */
  1253. CommandCounterIncrement();
  1255. /* ----------------
  1256.  * CommandCounterIncrement() flushes invalid cache entries, including
  1257.  * those for the heap and index relations for which we're updating
  1258.  * statistics. Now that the cache is flushed, it's safe to open the
  1259.  * relation again. We need the relation open in order to figure out
  1260.  * how many blocks it contains.
  1261.  * ----------------
  1262.  */
  1264. whichRel = RelationIdGetRelation(relid);
  1266. if (!RelationIsValid(whichRel))
  1267. elog(ERROR, "UpdateStats: cannot open relation id %u", relid);
  1269. /* ----------------
  1270.  * Find the RELATION relation tuple for the given relation.
  1271.  * ----------------
  1272.  */
  1273. pg_class = heap_openr(RelationRelationName);
  1274. if (!RelationIsValid(pg_class))
  1275. elog(ERROR, "UpdateStats: could not open RELATION relation");
  1277. if (!IsBootstrapProcessingMode())
  1278. {
  1279. tuple = SearchSysCacheTupleCopy(RELOID,
  1280. ObjectIdGetDatum(relid),
  1281. 0, 0, 0);
  1282. }
  1283. else
  1284. {
  1285. ScanKeyData key[1];
  1287. ScanKeyEntryInitialize(&key[0], 0,
  1288.    ObjectIdAttributeNumber,
  1289.    F_OIDEQ,
  1290.    ObjectIdGetDatum(relid));
  1292. pg_class_scan = heap_beginscan(pg_class, 0, SnapshotNow, 1, key);
  1293. tuple = heap_getnext(pg_class_scan, 0);
  1294. }
  1296. if (!HeapTupleIsValid(tuple))
  1297. {
  1298. if (IsBootstrapProcessingMode())
  1299. heap_endscan(pg_class_scan);
  1300. heap_close(pg_class);
  1301. elog(ERROR, "UpdateStats: cannot scan RELATION relation");
  1302. }
  1304. /* ----------------
  1305.  * Figure values to insert.
  1306.  *
  1307.  * If we found zero tuples in the scan, do NOT believe it; instead put
  1308.  * a bogus estimate into the statistics fields.  Otherwise, the common
  1309.  * pattern "CREATE TABLE; CREATE INDEX; insert data" leaves the table
  1310.  * with zero size statistics until a VACUUM is done.  The optimizer will
  1311.  * generate very bad plans if the stats claim the table is empty when
  1312.  * it is actually sizable.  See also CREATE TABLE in heap.c.
  1313.  * ----------------
  1314.  */
  1315. relpages = RelationGetNumberOfBlocks(whichRel);
  1317. if (reltuples == 0)
  1318. {
  1319. if (relpages == 0)
  1320. {
  1321. /* Bogus defaults for a virgin table, same as heap.c */
  1322. reltuples = 1000;
  1323. relpages = 10;
  1324. }
  1325. else if (whichRel->rd_rel->relkind == RELKIND_INDEX && relpages <= 2)
  1326. {
  1327. /* Empty index, leave bogus defaults in place */
  1328. reltuples = 1000;
  1329. }
  1330. else
  1331. reltuples = relpages * NTUPLES_PER_PAGE(whichRel->rd_rel->relnatts);
  1332. }
  1334. /*
  1335.  * We shouldn't have to do this, but we do...  Modify the reldesc in
  1336.  * place with the new values so that the cache contains the latest
  1337.  * copy.
  1338.  */
  1339. whichRel->rd_rel->relhasindex = hasindex;
  1340. whichRel->rd_rel->relpages = relpages;
  1341. whichRel->rd_rel->reltuples = reltuples;
  1343. /* ----------------
  1344.  * Update statistics in pg_class.
  1345.  * ----------------
  1346.  */
  1347. if (IsBootstrapProcessingMode())
  1348. {
  1350. /*
  1351.  * At bootstrap time, we don't need to worry about concurrency or
  1352.  * visibility of changes, so we cheat.
  1353.  */
  1354. rd_rel = (Form_pg_class) GETSTRUCT(tuple);
  1355. rd_rel->relpages = relpages;
  1356. rd_rel->reltuples = reltuples;
  1357. rd_rel->relhasindex = hasindex;
  1358. WriteBuffer(pg_class_scan->rs_cbuf);
  1359. }
  1360. else
  1361. {
  1362. /* During normal processing, must work harder. */
  1364. for (i = 0; i < Natts_pg_class; i++)
  1365. {
  1366. nulls[i] = heap_attisnull(tuple, i + 1) ? 'n' : ' ';
  1367. replace[i] = ' ';
  1368. values[i] = (Datum) NULL;
  1369. }
  1371. replace[Anum_pg_class_relpages - 1] = 'r';
  1372. values[Anum_pg_class_relpages - 1] = (Datum) relpages;
  1373. replace[Anum_pg_class_reltuples - 1] = 'r';
  1374. values[Anum_pg_class_reltuples - 1] = (Datum) reltuples;
  1375. replace[Anum_pg_class_relhasindex - 1] = 'r';
  1376. values[Anum_pg_class_relhasindex - 1] = CharGetDatum(hasindex);
  1378. newtup = heap_modifytuple(tuple, pg_class, values, nulls, replace);
  1379. heap_replace(pg_class, &tuple->t_self, newtup, NULL);
  1380. CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, idescs);
  1381. CatalogIndexInsert(idescs, Num_pg_class_indices, pg_class, newtup);
  1382. CatalogCloseIndices(Num_pg_class_indices, idescs);
  1383. pfree(newtup);
  1384. }
  1386. if (!IsBootstrapProcessingMode())
  1387. pfree(tuple);
  1388. else
  1389. heap_endscan(pg_class_scan);
  1391. heap_close(pg_class);
  1392. heap_close(whichRel);
  1393. }
  1396. /* -------------------------
  1397.  * FillDummyExprContext
  1398.  * Sets up dummy ExprContext and TupleTableSlot objects for use
  1399.  * with ExecQual.
  1400.  * -------------------------
  1401.  */
  1402. void
  1403. FillDummyExprContext(ExprContext *econtext,
  1404.  TupleTableSlot *slot,
  1405.  TupleDesc tupdesc,
  1406.  Buffer buffer)
  1407. {
  1408. econtext->ecxt_scantuple = slot;
  1409. econtext->ecxt_innertuple = NULL;
  1410. econtext->ecxt_outertuple = NULL;
  1411. econtext->ecxt_param_list_info = NULL;
  1412. econtext->ecxt_range_table = NULL;
  1414. slot->ttc_tupleDescriptor = tupdesc;
  1415. slot->ttc_buffer = buffer;
  1416. slot->ttc_shouldFree = false;
  1418. }
  1421. /* ----------------
  1422.  * DefaultBuild
  1423.  * ----------------
  1424.  */
  1425. static void
  1426. DefaultBuild(Relation heapRelation,
  1427.  Relation indexRelation,
  1428.  int numberOfAttributes,
  1429.  AttrNumber *attributeNumber,
  1430.  IndexStrategy indexStrategy, /* not used */
  1431.  uint16 parameterCount, /* not used */
  1432.  Datum *parameter, /* not used */
  1433.  FuncIndexInfoPtr funcInfo,
  1434.  PredInfo *predInfo)
  1435. {
  1436. HeapScanDesc scan;
  1437. HeapTuple heapTuple;
  1438. IndexTuple indexTuple;
  1439. TupleDesc heapDescriptor;
  1440. TupleDesc indexDescriptor;
  1441. Datum    *datum;
  1442. char    *nullv;
  1443. long reltuples,
  1444. indtuples;
  1445. #ifndef OMIT_PARTIAL_INDEX
  1446. ExprContext *econtext;
  1447. TupleTable tupleTable;
  1448. TupleTableSlot *slot;
  1449. #endif
  1450. Node    *predicate;
  1451. Node    *oldPred;
  1453. InsertIndexResult insertResult;
  1455. /* ----------------
  1456.  * more & better checking is needed
  1457.  * ----------------
  1458.  */
  1459. Assert(OidIsValid(indexRelation->rd_rel->relam)); /* XXX */
  1461. /* ----------------
  1462.  * get the tuple descriptors from the relations so we know
  1463.  * how to form the index tuples..
  1464.  * ----------------
  1465.  */
  1466. heapDescriptor = RelationGetDescr(heapRelation);
  1467. indexDescriptor = RelationGetDescr(indexRelation);
  1469. /* ----------------
  1470.  * datum and null are arrays in which we collect the index attributes
  1471.  * when forming a new index tuple.
  1472.  * ----------------
  1473.  */
  1474. datum = (Datum *) palloc(numberOfAttributes * sizeof *datum);
  1475. nullv = (char *) palloc(numberOfAttributes * sizeof *nullv);
  1477. /*
  1478.  * If this is a predicate (partial) index, we will need to evaluate
  1479.  * the predicate using ExecQual, which requires the current tuple to
  1480.  * be in a slot of a TupleTable.  In addition, ExecQual must have an
  1481.  * ExprContext referring to that slot. Here, we initialize dummy
  1482.  * TupleTable and ExprContext objects for this purpose. --Nels, Feb
  1483.  * '92
  1484.  */
  1486. predicate = predInfo->pred;
  1487. oldPred = predInfo->oldPred;
  1489. #ifndef OMIT_PARTIAL_INDEX
  1490. if (predicate != NULL || oldPred != NULL)
  1491. {
  1492. tupleTable = ExecCreateTupleTable(1);
  1493. slot = ExecAllocTableSlot(tupleTable);
  1494. econtext = makeNode(ExprContext);
  1495. /* last parameter was junk being sent bjm 1998/08/17 */
  1496. FillDummyExprContext(econtext, slot, heapDescriptor, InvalidBuffer);
  1497. }
  1498. else
  1499. {
  1500. econtext = NULL;
  1501. tupleTable = 0;
  1502. slot = NULL;
  1503. }
  1504. #endif  /* OMIT_PARTIAL_INDEX */
  1506. /* ----------------
  1507.  * Ok, begin our scan of the base relation.
  1508.  * ----------------
  1509.  */
  1510. scan = heap_beginscan(heapRelation, /* relation */
  1511.   0, /* start at end */
  1512.   SnapshotNow, /* seeself */
  1513.   0, /* number of keys */
  1514.   (ScanKey) NULL); /* scan key */
  1516. reltuples = indtuples = 0;
  1518. /* ----------------
  1519.  * for each tuple in the base relation, we create an index
  1520.  * tuple and add it to the index relation.  We keep a running
  1521.  * count of the number of tuples so that we can update pg_class
  1522.  * with correct statistics when we're done building the index.
  1523.  * ----------------
  1524.  */
  1525. while (HeapTupleIsValid(heapTuple = heap_getnext(scan, 0)))
  1526. {
  1527. reltuples++;
  1529. #ifndef OMIT_PARTIAL_INDEX
  1530. /*
  1531.  * If oldPred != NULL, this is an EXTEND INDEX command, so skip
  1532.  * this tuple if it was already in the existing partial index
  1533.  */
  1534. if (oldPred != NULL)
  1535. {
  1536. /* SetSlotContents(slot, heapTuple); */
  1537. slot->val = heapTuple;
  1538. if (ExecQual((List *) oldPred, econtext) == true)
  1539. {
  1540. indtuples++;
  1541. continue;
  1542. }
  1543. }
  1545. /*
  1546.  * Skip this tuple if it doesn't satisfy the partial-index
  1547.  * predicate
  1548.  */
  1549. if (predicate != NULL)
  1550. {
  1551. /* SetSlotContents(slot, heapTuple); */
  1552. slot->val = heapTuple;
  1553. if (ExecQual((List *) predicate, econtext) == false)
  1554. continue;
  1555. }
  1556. #endif  /* OMIT_PARTIAL_INDEX */
  1558. indtuples++;
  1560. /* ----------------
  1561.  * FormIndexDatum fills in its datum and null parameters
  1562.  * with attribute information taken from the given heap tuple.
  1563.  * ----------------
  1564.  */
  1565. FormIndexDatum(numberOfAttributes, /* num attributes */
  1566.    attributeNumber, /* array of att nums to extract */
  1567.    heapTuple, /* tuple from base relation */
  1568.    heapDescriptor, /* heap tuple's descriptor */
  1569.    datum, /* return: array of attributes */
  1570.    nullv, /* return: array of char's */
  1571.    funcInfo);
  1573. indexTuple = index_formtuple(indexDescriptor,
  1574.  datum,
  1575.  nullv);
  1577. indexTuple->t_tid = heapTuple->t_self;
  1579. insertResult = index_insert(indexRelation, datum, nullv,
  1580. &(heapTuple->t_self), heapRelation);
  1582. if (insertResult)
  1583. pfree(insertResult);
  1584. pfree(indexTuple);
  1585. }
  1587. heap_endscan(scan);
  1589. #ifndef OMIT_PARTIAL_INDEX
  1590. if (predicate != NULL || oldPred != NULL)
  1591. {
  1592. ExecDestroyTupleTable(tupleTable, false);
  1593. }
  1594. #endif  /* OMIT_PARTIAL_INDEX */
  1596. pfree(nullv);
  1597. pfree(datum);
  1599. /*
  1600.  * Okay, now update the reltuples and relpages statistics for both the
  1601.  * heap relation and the index.  These statistics are used by the
  1602.  * planner to choose a scan type.  They are maintained generally by
  1603.  * the vacuum daemon, but we update them here to make the index useful
  1604.  * as soon as possible.
  1605.  */
  1606. UpdateStats(RelationGetRelid(heapRelation), reltuples, true);
  1607. UpdateStats(RelationGetRelid(indexRelation), indtuples, false);
  1608. if (oldPred != NULL)
  1609. {
  1610. if (indtuples == reltuples)
  1611. predicate = NULL;
  1612. UpdateIndexPredicate(RelationGetRelid(indexRelation),
  1613.  oldPred, predicate);
  1614. }
  1615. }
  1617. /* ----------------
  1618.  * index_build
  1619.  * ----------------
  1620.  */
  1621. void
  1622. index_build(Relation heapRelation,
  1623. Relation indexRelation,
  1624. int numberOfAttributes,
  1625. AttrNumber *attributeNumber,
  1626. uint16 parameterCount,
  1627. Datum *parameter,
  1628. FuncIndexInfo *funcInfo,
  1629. PredInfo *predInfo)
  1630. {
  1631. RegProcedure procedure;
  1633. /* ----------------
  1634.  * sanity checks
  1635.  * ----------------
  1636.  */
  1637. Assert(RelationIsValid(indexRelation));
  1638. Assert(PointerIsValid(indexRelation->rd_am));
  1640. procedure = indexRelation->rd_am->ambuild;
  1642. /* ----------------
  1643.  * use the access method build procedure if supplied..
  1644.  * ----------------
  1645.  */
  1646. if (RegProcedureIsValid(procedure))
  1647. fmgr(procedure,
  1648.  heapRelation,
  1649.  indexRelation,
  1650.  numberOfAttributes,
  1651.  attributeNumber,
  1652.  RelationGetIndexStrategy(indexRelation),
  1653.  parameterCount,
  1654.  parameter,
  1655.  funcInfo,
  1656.  predInfo);
  1657. else
  1658. DefaultBuild(heapRelation,
  1659.  indexRelation,
  1660.  numberOfAttributes,
  1661.  attributeNumber,
  1662.  RelationGetIndexStrategy(indexRelation),
  1663.  parameterCount,
  1664.  parameter,
  1665.  funcInfo,
  1666.  predInfo);
  1667. }
  1669. /*
  1670.  * IndexIsUnique: given an index's relation OID, see if it
  1671.  * is unique using the system cache.
  1672.  */
  1673. bool
  1674. IndexIsUnique(Oid indexId)
  1675. {
  1676. HeapTuple tuple;
  1677. Form_pg_index index;
  1679. tuple = SearchSysCacheTuple(INDEXRELID,
  1680. ObjectIdGetDatum(indexId),
  1681. 0, 0, 0);
  1682. if (!HeapTupleIsValid(tuple))
  1683. {
  1684. elog(ERROR, "IndexIsUnique: can't find index id %u",
  1685.  indexId);
  1686. }
  1687. index = (Form_pg_index) GETSTRUCT(tuple);
  1688. Assert(index->indexrelid == indexId);
  1690. return index->indisunique;
  1691. }
  1693. /*
  1694.  * IndexIsUniqueNoCache: same as above function, but don't use the
  1695.  * system cache.  if we are called from btbuild, the transaction
  1696.  * that is adding the entry to pg_index has not been committed yet.
  1697.  * the system cache functions will do a heap scan, but only with
  1698.  * NowTimeQual, not SelfTimeQual, so it won't find tuples added
  1699.  * by the current transaction (which is good, because if the transaction
  1700.  * is aborted, you don't want the tuples sitting around in the cache).
  1701.  * so anyway, we have to do our own scan with SelfTimeQual.
  1702.  * this is only called when a new index is created, so it's OK
  1703.  * if it's slow.
  1704.  */
  1705. bool
  1706. IndexIsUniqueNoCache(Oid indexId)
  1707. {
  1708. Relation pg_index;
  1709. ScanKeyData skey[1];
  1710. HeapScanDesc scandesc;
  1711. HeapTuple tuple;
  1712. Form_pg_index index;
  1713. bool isunique;
  1715. pg_index = heap_openr(IndexRelationName);
  1717. ScanKeyEntryInitialize(&skey[0], (bits16) 0x0,
  1718.    Anum_pg_index_indexrelid,
  1719.    (RegProcedure) F_OIDEQ,
  1720.    ObjectIdGetDatum(indexId));
  1722. scandesc = heap_beginscan(pg_index, 0, SnapshotSelf, 1, skey);
  1724. /* NO CACHE */
  1725. tuple = heap_getnext(scandesc, 0);
  1726. if (!HeapTupleIsValid(tuple))
  1727. elog(ERROR, "IndexIsUniqueNoCache: can't find index id %u", indexId);
  1729. index = (Form_pg_index) GETSTRUCT(tuple);
  1730. Assert(index->indexrelid == indexId);
  1731. isunique = index->indisunique;
  1733. heap_endscan(scandesc);
  1734. heap_close(pg_index);
  1735. return isunique;
  1736. }