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

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

数据库系统

开发平台：

Unix_Linux

relcache.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * relcache.c
  4.  *   POSTGRES relation descriptor cache code
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.62.2.2 1999/09/02 04:07:18 tgl Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. /*
  15.  * INTERFACE ROUTINES
  16.  * RelationInitialize - initialize relcache
  17.  * RelationIdCacheGetRelation - get a reldesc from the cache (id)
  18.  * RelationNameCacheGetRelation - get a reldesc from the cache (name)
  19.  * RelationIdGetRelation - get a reldesc by relation id
  20.  * RelationNameGetRelation - get a reldesc by relation name
  21.  * RelationClose - close an open relation
  22.  * RelationFlushRelation - flush relation information
  23.  *
  24.  * NOTES
  25.  * This file is in the process of being cleaned up
  26.  * before I add system attribute indexing.  -cim 1/13/91
  27.  *
  28.  * The following code contains many undocumented hacks.  Please be
  29.  * careful....
  30.  *
  31.  */
  32. #include <sys/types.h>
  33. #include <errno.h>
  34. #include <sys/file.h>
  35. #include <fcntl.h>
  37. #include "postgres.h"
  39. #include "access/genam.h"
  40. #include "access/heapam.h"
  41. #include "access/istrat.h"
  42. #include "catalog/catalog.h"
  43. #include "catalog/catname.h"
  44. #include "catalog/index.h"
  45. #include "catalog/indexing.h"
  46. #include "catalog/pg_attrdef.h"
  47. #include "catalog/pg_log.h"
  48. #include "catalog/pg_proc.h"
  49. #include "catalog/pg_relcheck.h"
  50. #include "catalog/pg_rewrite.h"
  51. #include "catalog/pg_type.h"
  52. #include "catalog/pg_variable.h"
  53. #include "lib/hasht.h"
  54. #include "miscadmin.h"
  55. #include "storage/smgr.h"
  56. #include "utils/builtins.h"
  57. #include "utils/catcache.h"
  58. #include "utils/relcache.h"
  61. static void RelationFlushRelation(Relation *relationPtr,
  62.   bool onlyFlushReferenceCountZero);
  63. static Relation RelationNameCacheGetRelation(char *relationName);
  64. static void init_irels(void);
  65. static void write_irels(void);
  67. /* ----------------
  68.  * externs
  69.  * ----------------
  70.  */
  71. extern bool AMI_OVERRIDE; /* XXX style */
  72. extern GlobalMemory CacheCxt; /* from utils/cache/catcache.c */
  74. /* ----------------
  75.  * hardcoded tuple descriptors.  see lib/backend/catalog/pg_attribute.h
  76.  * ----------------
  77.  */
  78. FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class};
  79. FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute};
  80. FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc};
  81. FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type};
  82. FormData_pg_attribute Desc_pg_variable[Natts_pg_variable] = {Schema_pg_variable};
  83. FormData_pg_attribute Desc_pg_log[Natts_pg_log] = {Schema_pg_log};
  85. /* ----------------
  86.  * global variables
  87.  *
  88.  * Relations are cached two ways, by name and by id,
  89.  * thus there are two hash tables for referencing them.
  90.  * ----------------
  91.  */
  92. HTAB    *RelationNameCache;
  93. HTAB    *RelationIdCache;
  95. /* ----------------
  96.  * RelationBuildDescInfo exists so code can be shared
  97.  * between RelationIdGetRelation() and RelationNameGetRelation()
  98.  * ----------------
  99.  */
  100. typedef struct RelationBuildDescInfo
  101. {
  102. int infotype; /* lookup by id or by name */
  103. #define INFO_RELID 1
  104. #define INFO_RELNAME 2
  105. union
  106. {
  107. Oid info_id; /* relation object id */
  108. char    *info_name; /* relation name */
  109. } i;
  110. } RelationBuildDescInfo;
  112. typedef struct relidcacheent
  113. {
  114. Oid reloid;
  115. Relation reldesc;
  116. } RelIdCacheEnt;
  118. typedef struct relnamecacheent
  119. {
  120. NameData relname;
  121. Relation reldesc;
  122. } RelNameCacheEnt;
  124. /* -----------------
  125.  * macros to manipulate name cache and id cache
  126.  * -----------------
  127.  */
  128. #define RelationCacheInsert(RELATION)
  129. do { 
  130. RelIdCacheEnt *idhentry; RelNameCacheEnt *namehentry; 
  131. char *relname; Oid reloid; bool found; 
  132. relname = (RELATION->rd_rel->relname).data; 
  133. namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, 
  134.    relname, 
  135.    HASH_ENTER, 
  136.    &found); 
  137. if (namehentry == NULL) 
  138. elog(FATAL, "can't insert into relation descriptor cache"); 
  139. if (found && !IsBootstrapProcessingMode()) 
  140. /* used to give notice -- now just keep quiet */ ; 
  141. namehentry->reldesc = RELATION; 
  142. reloid = RELATION->rd_id; 
  143. idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, 
  144.    (char *)&reloid, 
  145.    HASH_ENTER, 
  146.    &found); 
  147. if (idhentry == NULL) 
  148. elog(FATAL, "can't insert into relation descriptor cache"); 
  149. if (found && !IsBootstrapProcessingMode()) 
  150. /* used to give notice -- now just keep quiet */ ; 
  151. idhentry->reldesc = RELATION; 
  152. } while(0)
  154. #define RelationNameCacheLookup(NAME, RELATION) 
  155. do { 
  156. RelNameCacheEnt *hentry; bool found; 
  157. hentry = (RelNameCacheEnt*)hash_search(RelationNameCache, 
  158.    (char *)NAME,HASH_FIND,&found); 
  159. if (hentry == NULL) 
  160. elog(FATAL, "error in CACHE"); 
  161. if (found) 
  162. RELATION = hentry->reldesc; 
  163. else 
  164. RELATION = NULL; 
  165. } while(0)
  167. #define RelationIdCacheLookup(ID, RELATION) 
  168. do { 
  169. RelIdCacheEnt *hentry; 
  170. bool found; 
  171. hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, 
  172.  (char *)&(ID),HASH_FIND, &found); 
  173. if (hentry == NULL) 
  174. elog(FATAL, "error in CACHE"); 
  175. if (found) 
  176. RELATION = hentry->reldesc; 
  177. else 
  178. RELATION = NULL; 
  179. } while(0)
  181. #define RelationCacheDelete(RELATION) 
  182. do { 
  183. RelNameCacheEnt *namehentry; RelIdCacheEnt *idhentry; 
  184. char *relname; Oid reloid; bool found; 
  185. relname = (RELATION->rd_rel->relname).data; 
  186. namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, 
  187.    relname, 
  188.    HASH_REMOVE, 
  189.    &found); 
  190. if (namehentry == NULL) 
  191. elog(FATAL, "can't delete from relation descriptor cache"); 
  192. if (!found) 
  193. elog(NOTICE, "trying to delete a reldesc that does not exist."); 
  194. reloid = RELATION->rd_id; 
  195. idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, 
  196.    (char *)&reloid, 
  197.    HASH_REMOVE, &found); 
  198. if (idhentry == NULL) 
  199. elog(FATAL, "can't delete from relation descriptor cache"); 
  200. if (!found) 
  201. elog(NOTICE, "trying to delete a reldesc that does not exist."); 
  202. } while(0)
  204. /* non-export function prototypes */
  205. static void formrdesc(char *relationName, u_int natts,
  206.   FormData_pg_attribute *att);
  208. #ifdef NOT_USED /* See comments at line 1304 */
  209. static void RelationFlushIndexes(Relation *r, Oid accessMethodId);
  211. #endif
  213. static HeapTuple ScanPgRelation(RelationBuildDescInfo buildinfo);
  214. static HeapTuple scan_pg_rel_seq(RelationBuildDescInfo buildinfo);
  215. static HeapTuple scan_pg_rel_ind(RelationBuildDescInfo buildinfo);
  216. static Relation AllocateRelationDesc(u_int natts, Form_pg_class relp);
  217. static void RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
  218.    Relation relation, u_int natts);
  219. static void build_tupdesc_seq(RelationBuildDescInfo buildinfo,
  220.   Relation relation, u_int natts);
  221. static void build_tupdesc_ind(RelationBuildDescInfo buildinfo,
  222.   Relation relation, u_int natts);
  223. static Relation RelationBuildDesc(RelationBuildDescInfo buildinfo);
  224. static void IndexedAccessMethodInitialize(Relation relation);
  225. static void AttrDefaultFetch(Relation relation);
  226. static void RelCheckFetch(Relation relation);
  228. extern void RelationBuildTriggers(Relation relation);
  229. extern void FreeTriggerDesc(Relation relation);
  231. /*
  232.  * newlyCreatedRelns -
  233.  *   relations created during this transaction. We need to keep track of
  234.  *   these.
  235.  */
  236. static List *newlyCreatedRelns = NULL;
  238. /* ----------------------------------------------------------------
  239.  * RelationIdGetRelation() and RelationNameGetRelation()
  240.  * support functions
  241.  * ----------------------------------------------------------------
  242.  */
  245. #if NOT_USED /* XXX This doesn't seem to be used
  246.  * anywhere */
  247. /* --------------------------------
  248.  * BuildDescInfoError returns a string appropriate to
  249.  * the buildinfo passed to it
  250.  * --------------------------------
  251.  */
  252. static char *
  253. BuildDescInfoError(RelationBuildDescInfo buildinfo)
  254. {
  255. static char errBuf[64];
  257. MemSet(errBuf, 0, (int) sizeof(errBuf));
  258. switch (buildinfo.infotype)
  259. {
  260. case INFO_RELID:
  261. sprintf(errBuf, "(relation id %u)", buildinfo.i.info_id);
  262. break;
  263. case INFO_RELNAME:
  264. sprintf(errBuf, "(relation name %s)", buildinfo.i.info_name);
  265. break;
  266. }
  268. return errBuf;
  269. }
  271. #endif
  273. /* --------------------------------
  274.  * ScanPgRelation
  275.  *
  276.  * this is used by RelationBuildDesc to find a pg_class
  277.  * tuple matching either a relation name or a relation id
  278.  * as specified in buildinfo.
  279.  * --------------------------------
  280.  */
  281. static HeapTuple
  282. ScanPgRelation(RelationBuildDescInfo buildinfo)
  283. {
  285. /*
  286.  * If this is bootstrap time (initdb), then we can't use the system
  287.  * catalog indices, because they may not exist yet.  Otherwise, we
  288.  * can, and do.
  289.  */
  291. if (IsBootstrapProcessingMode())
  292. return scan_pg_rel_seq(buildinfo);
  293. else
  294. return scan_pg_rel_ind(buildinfo);
  295. }
  297. static HeapTuple
  298. scan_pg_rel_seq(RelationBuildDescInfo buildinfo)
  299. {
  300. HeapTuple pg_class_tuple;
  301. HeapTuple return_tuple;
  302. Relation pg_class_desc;
  303. HeapScanDesc pg_class_scan;
  304. ScanKeyData key;
  306. /* ----------------
  307.  * form a scan key
  308.  * ----------------
  309.  */
  310. switch (buildinfo.infotype)
  311. {
  312. case INFO_RELID:
  313. ScanKeyEntryInitialize(&key, 0,
  314.    ObjectIdAttributeNumber,
  315.    F_OIDEQ,
  316.    ObjectIdGetDatum(buildinfo.i.info_id));
  317. break;
  319. case INFO_RELNAME:
  320. ScanKeyEntryInitialize(&key, 0,
  321.    Anum_pg_class_relname,
  322.    F_NAMEEQ,
  323.    NameGetDatum(buildinfo.i.info_name));
  324. break;
  326. default:
  327. elog(ERROR, "ScanPgRelation: bad buildinfo");
  328. return NULL;
  329. }
  331. /* ----------------
  332.  * open pg_class and fetch a tuple
  333.  * ----------------
  334.  */
  335. pg_class_desc = heap_openr(RelationRelationName);
  336. pg_class_scan = heap_beginscan(pg_class_desc, 0, SnapshotNow, 1, &key);
  337. pg_class_tuple = heap_getnext(pg_class_scan, 0);
  339. /* ----------------
  340.  * get set to return tuple
  341.  * ----------------
  342.  */
  343. if (!HeapTupleIsValid(pg_class_tuple))
  344. return_tuple = pg_class_tuple;
  345. else
  346. {
  347. /* ------------------
  348.  * a satanic bug used to live here: pg_class_tuple used to be
  349.  * returned here without having the corresponding buffer pinned.
  350.  * so when the buffer gets replaced, all hell breaks loose.
  351.  * this bug is discovered and killed by wei on 9/27/91.
  352.  * -------------------
  353.  */
  354. return_tuple = heap_copytuple(pg_class_tuple);
  355. }
  357. /* all done */
  358. heap_endscan(pg_class_scan);
  359. heap_close(pg_class_desc);
  361. return return_tuple;
  362. }
  364. static HeapTuple
  365. scan_pg_rel_ind(RelationBuildDescInfo buildinfo)
  366. {
  367. Relation pg_class_desc;
  368. HeapTuple return_tuple;
  370. pg_class_desc = heap_openr(RelationRelationName);
  371. if (!IsInitProcessingMode())
  372. LockRelation(pg_class_desc, AccessShareLock);
  374. switch (buildinfo.infotype)
  375. {
  376. case INFO_RELID:
  377. return_tuple = ClassOidIndexScan(pg_class_desc, buildinfo.i.info_id);
  378. break;
  380. case INFO_RELNAME:
  381. return_tuple = ClassNameIndexScan(pg_class_desc,
  382.   buildinfo.i.info_name);
  383. break;
  385. default:
  386. elog(ERROR, "ScanPgRelation: bad buildinfo");
  388. /*
  389.  * XXX I hope this is right.  It seems better than returning
  390.  * an uninitialized value
  391.  */
  392. return_tuple = NULL;
  393. }
  395. /* all done */
  396. if (!IsInitProcessingMode())
  397. UnlockRelation(pg_class_desc, AccessShareLock);
  398. heap_close(pg_class_desc);
  400. return return_tuple;
  401. }
  403. /* ----------------
  404.  * AllocateRelationDesc
  405.  *
  406.  * This is used to allocate memory for a new relation descriptor
  407.  * and initialize the rd_rel field.
  408.  * ----------------
  409.  */
  410. static Relation
  411. AllocateRelationDesc(u_int natts, Form_pg_class relp)
  412. {
  413. Relation relation;
  414. Size len;
  415. Form_pg_class relationForm;
  417. /* ----------------
  418.  * allocate space for the relation tuple form
  419.  * ----------------
  420.  */
  421. relationForm = (Form_pg_class)
  422. palloc((Size) (sizeof(FormData_pg_class)));
  424. memmove((char *) relationForm, (char *) relp, CLASS_TUPLE_SIZE);
  426. /* ----------------
  427.  * allocate space for new relation descriptor
  428.  */
  429. len = sizeof(RelationData) + 10; /* + 10 is voodoo XXX mao */
  431. relation = (Relation) palloc(len);
  433. /* ----------------
  434.  * clear new reldesc
  435.  * ----------------
  436.  */
  437. MemSet((char *) relation, 0, len);
  439. /* initialize attribute tuple form */
  440. relation->rd_att = CreateTemplateTupleDesc(natts);
  442. /* and initialize relation tuple form */
  443. relation->rd_rel = relationForm;
  445. return relation;
  446. }
  448. /* --------------------------------
  449.  * RelationBuildTupleDesc
  450.  *
  451.  * Form the relation's tuple descriptor from information in
  452.  * the pg_attribute, pg_attrdef & pg_relcheck system cataloges.
  453.  * --------------------------------
  454.  */
  455. static void
  456. RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
  457.    Relation relation,
  458.    u_int natts)
  459. {
  461. /*
  462.  * If this is bootstrap time (initdb), then we can't use the system
  463.  * catalog indices, because they may not exist yet.  Otherwise, we
  464.  * can, and do.
  465.  */
  467. if (IsBootstrapProcessingMode())
  468. build_tupdesc_seq(buildinfo, relation, natts);
  469. else
  470. build_tupdesc_ind(buildinfo, relation, natts);
  471. }
  473. static void
  474. build_tupdesc_seq(RelationBuildDescInfo buildinfo,
  475.   Relation relation,
  476.   u_int natts)
  477. {
  478. HeapTuple pg_attribute_tuple;
  479. Relation pg_attribute_desc;
  480. HeapScanDesc pg_attribute_scan;
  481. Form_pg_attribute attp;
  482. ScanKeyData key;
  483. int need;
  485. /* ----------------
  486.  * form a scan key
  487.  * ----------------
  488.  */
  489. ScanKeyEntryInitialize(&key, 0,
  490.    Anum_pg_attribute_attrelid,
  491.    F_OIDEQ,
  492.    ObjectIdGetDatum(RelationGetRelid(relation)));
  494. /* ----------------
  495.  * open pg_attribute and begin a scan
  496.  * ----------------
  497.  */
  498. pg_attribute_desc = heap_openr(AttributeRelationName);
  499. pg_attribute_scan = heap_beginscan(pg_attribute_desc, 0, SnapshotNow, 1, &key);
  501. /* ----------------
  502.  * add attribute data to relation->rd_att
  503.  * ----------------
  504.  */
  505. need = natts;
  507. pg_attribute_tuple = heap_getnext(pg_attribute_scan, 0);
  508. while (HeapTupleIsValid(pg_attribute_tuple) && need > 0)
  509. {
  510. attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple);
  512. if (attp->attnum > 0)
  513. {
  514. relation->rd_att->attrs[attp->attnum - 1] =
  515. (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
  517. memmove((char *) (relation->rd_att->attrs[attp->attnum - 1]),
  518. (char *) attp,
  519. ATTRIBUTE_TUPLE_SIZE);
  520. need--;
  521. }
  522. pg_attribute_tuple = heap_getnext(pg_attribute_scan, 0);
  523. }
  525. if (need > 0)
  526. elog(ERROR, "catalog is missing %d attribute%s for relid %u",
  527.  need, (need == 1 ? "" : "s"), RelationGetRelid(relation));
  529. /* ----------------
  530.  * end the scan and close the attribute relation
  531.  * ----------------
  532.  */
  533. heap_endscan(pg_attribute_scan);
  534. heap_close(pg_attribute_desc);
  535. }
  537. static void
  538. build_tupdesc_ind(RelationBuildDescInfo buildinfo,
  539.   Relation relation,
  540.   u_int natts)
  541. {
  542. Relation attrel;
  543. HeapTuple atttup;
  544. Form_pg_attribute attp;
  545. TupleConstr *constr = (TupleConstr *) palloc(sizeof(TupleConstr));
  546. AttrDefault *attrdef = NULL;
  547. int ndef = 0;
  548. int i;
  550. constr->has_not_null = false;
  552. attrel = heap_openr(AttributeRelationName);
  554. for (i = 1; i <= relation->rd_rel->relnatts; i++)
  555. {
  556. atttup = (HeapTuple) AttributeNumIndexScan(attrel,
  557.   RelationGetRelid(relation), i);
  559. if (!HeapTupleIsValid(atttup))
  560. elog(ERROR, "cannot find attribute %d of relation %s", i,
  561.  relation->rd_rel->relname.data);
  562. attp = (Form_pg_attribute) GETSTRUCT(atttup);
  564. relation->rd_att->attrs[i - 1] =
  565. (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
  567. memmove((char *) (relation->rd_att->attrs[i - 1]),
  568. (char *) attp,
  569. ATTRIBUTE_TUPLE_SIZE);
  571. /* Update if this attribute have a constraint */
  572. if (attp->attnotnull)
  573. constr->has_not_null = true;
  575. if (attp->atthasdef)
  576. {
  577. if (attrdef == NULL)
  578. attrdef = (AttrDefault *) palloc(relation->rd_rel->relnatts *
  579.  sizeof(AttrDefault));
  580. attrdef[ndef].adnum = i;
  581. attrdef[ndef].adbin = NULL;
  582. attrdef[ndef].adsrc = NULL;
  583. ndef++;
  584. }
  585. }
  587. heap_close(attrel);
  589. if (constr->has_not_null || ndef > 0 || relation->rd_rel->relchecks)
  590. {
  591. relation->rd_att->constr = constr;
  593. if (ndef > 0) /* DEFAULTs */
  594. {
  595. if (ndef < relation->rd_rel->relnatts)
  596. constr->defval = (AttrDefault *)
  597. repalloc(attrdef, ndef * sizeof(AttrDefault));
  598. else
  599. constr->defval = attrdef;
  600. constr->num_defval = ndef;
  601. AttrDefaultFetch(relation);
  602. }
  603. else
  604. constr->num_defval = 0;
  606. if (relation->rd_rel->relchecks > 0) /* CHECKs */
  607. {
  608. constr->num_check = relation->rd_rel->relchecks;
  609. constr->check = (ConstrCheck *) palloc(constr->num_check *
  610.    sizeof(ConstrCheck));
  611. MemSet(constr->check, 0, constr->num_check * sizeof(ConstrCheck));
  612. RelCheckFetch(relation);
  613. }
  614. else
  615. constr->num_check = 0;
  616. }
  617. else
  618. {
  619. pfree(constr);
  620. relation->rd_att->constr = NULL;
  621. }
  623. }
  625. /* --------------------------------
  626.  * RelationBuildRuleLock
  627.  *
  628.  * Form the relation's rewrite rules from information in
  629.  * the pg_rewrite system catalog.
  630.  * --------------------------------
  631.  */
  632. static void
  633. RelationBuildRuleLock(Relation relation)
  634. {
  635. HeapTuple pg_rewrite_tuple;
  636. Relation pg_rewrite_desc;
  637. TupleDesc pg_rewrite_tupdesc;
  638. HeapScanDesc pg_rewrite_scan;
  639. ScanKeyData key;
  640. RuleLock   *rulelock;
  641. int numlocks;
  642. RewriteRule **rules;
  643. int maxlocks;
  645. /* ----------------
  646.  * form an array to hold the rewrite rules (the array is extended if
  647.  * necessary)
  648.  * ----------------
  649.  */
  650. maxlocks = 4;
  651. rules = (RewriteRule **) palloc(sizeof(RewriteRule *) * maxlocks);
  652. numlocks = 0;
  654. /* ----------------
  655.  * form a scan key
  656.  * ----------------
  657.  */
  658. ScanKeyEntryInitialize(&key, 0,
  659.    Anum_pg_rewrite_ev_class,
  660.    F_OIDEQ,
  661.    ObjectIdGetDatum(RelationGetRelid(relation)));
  663. /* ----------------
  664.  * open pg_attribute and begin a scan
  665.  * ----------------
  666.  */
  667. pg_rewrite_desc = heap_openr(RewriteRelationName);
  668. pg_rewrite_scan = heap_beginscan(pg_rewrite_desc, 0, SnapshotNow, 1, &key);
  669. pg_rewrite_tupdesc = RelationGetDescr(pg_rewrite_desc);
  671. /* ----------------
  672.  * add attribute data to relation->rd_att
  673.  * ----------------
  674.  */
  675. while (HeapTupleIsValid(pg_rewrite_tuple = heap_getnext(pg_rewrite_scan, 0)))
  676. {
  677. bool isnull;
  678. Datum ruleaction;
  679. Datum rule_evqual_string;
  680. RewriteRule *rule;
  682. rule = (RewriteRule *) palloc(sizeof(RewriteRule));
  684. rule->ruleId = pg_rewrite_tuple->t_data->t_oid;
  686. rule->event = (int) heap_getattr(pg_rewrite_tuple,
  687.  Anum_pg_rewrite_ev_type, pg_rewrite_tupdesc,
  688.  &isnull) - 48;
  689. rule->attrno = (int) heap_getattr(pg_rewrite_tuple,
  690.  Anum_pg_rewrite_ev_attr, pg_rewrite_tupdesc,
  691.   &isnull);
  692. rule->isInstead = !!heap_getattr(pg_rewrite_tuple,
  693.   Anum_pg_rewrite_is_instead, pg_rewrite_tupdesc,
  694.  &isnull);
  696. ruleaction = heap_getattr(pg_rewrite_tuple,
  697.    Anum_pg_rewrite_ev_action, pg_rewrite_tupdesc,
  698.   &isnull);
  699. rule_evqual_string = heap_getattr(pg_rewrite_tuple,
  700.  Anum_pg_rewrite_ev_qual, pg_rewrite_tupdesc,
  701.   &isnull);
  703. ruleaction = PointerGetDatum(textout((struct varlena *) DatumGetPointer(ruleaction)));
  704. rule_evqual_string = PointerGetDatum(textout((struct varlena *) DatumGetPointer(rule_evqual_string)));
  706. rule->actions = (List *) stringToNode(DatumGetPointer(ruleaction));
  707. rule->qual = (Node *) stringToNode(DatumGetPointer(rule_evqual_string));
  709. rules[numlocks++] = rule;
  710. if (numlocks == maxlocks)
  711. {
  712. maxlocks *= 2;
  713. rules = (RewriteRule **) repalloc(rules, sizeof(RewriteRule *) * maxlocks);
  714. }
  715. }
  717. /* ----------------
  718.  * end the scan and close the attribute relation
  719.  * ----------------
  720.  */
  721. heap_endscan(pg_rewrite_scan);
  722. heap_close(pg_rewrite_desc);
  724. /* ----------------
  725.  * form a RuleLock and insert into relation
  726.  * ----------------
  727.  */
  728. rulelock = (RuleLock *) palloc(sizeof(RuleLock));
  729. rulelock->numLocks = numlocks;
  730. rulelock->rules = rules;
  732. relation->rd_rules = rulelock;
  733. return;
  734. }
  737. /* --------------------------------
  738.  * RelationBuildDesc
  739.  *
  740.  * To build a relation descriptor, we have to allocate space,
  741.  * open the underlying unix file and initialize the following
  742.  * fields:
  743.  *
  744.  * File    rd_fd;  open file descriptor
  745.  * int    rd_nblocks;  number of blocks in rel
  746.  *  it will be set in ambeginscan()
  747.  * uint16    rd_refcnt;  reference count
  748.  * Form_pg_am    rd_am;  AM tuple
  749.  * Form_pg_class    rd_rel;  RELATION tuple
  750.  * Oid    rd_id;  relations's object id
  751.  * Pointer    lockInfo;  ptr. to misc. info.
  752.  * TupleDesc    rd_att;  tuple desciptor
  753.  *
  754.  * Note: rd_ismem (rel is in-memory only) is currently unused
  755.  * by any part of the system. someday this will indicate that
  756.  * the relation lives only in the main-memory buffer pool
  757.  * -cim 2/4/91
  758.  * --------------------------------
  759.  */
  760. static Relation
  761. RelationBuildDesc(RelationBuildDescInfo buildinfo)
  762. {
  763. File fd;
  764. Relation relation;
  765. u_int natts;
  766. Oid relid;
  767. Oid relam;
  768. Form_pg_class relp;
  770. MemoryContext oldcxt;
  772. HeapTuple pg_class_tuple;
  774. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  776. /* ----------------
  777.  * find the tuple in pg_class corresponding to the given relation id
  778.  * ----------------
  779.  */
  780. pg_class_tuple = ScanPgRelation(buildinfo);
  782. /* ----------------
  783.  * if no such tuple exists, return NULL
  784.  * ----------------
  785.  */
  786. if (!HeapTupleIsValid(pg_class_tuple))
  787. {
  788. MemoryContextSwitchTo(oldcxt);
  790. return NULL;
  791. }
  793. /* ----------------
  794.  * get information from the pg_class_tuple
  795.  * ----------------
  796.  */
  797. relid = pg_class_tuple->t_data->t_oid;
  798. relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
  799. natts = relp->relnatts;
  801. /* ----------------
  802.  * allocate storage for the relation descriptor,
  803.  * initialize relation->rd_rel and get the access method id.
  804.  * ----------------
  805.  */
  806. relation = AllocateRelationDesc(natts, relp);
  807. relam = relation->rd_rel->relam;
  809. /* ----------------
  810.  * initialize the relation's relation id (relation->rd_id)
  811.  * ----------------
  812.  */
  813. RelationGetRelid(relation) = relid;
  815. /* ----------------
  816.  * initialize relation->rd_refcnt
  817.  * ----------------
  818.  */
  819. RelationSetReferenceCount(relation, 1);
  821. /* ----------------
  822.  *  normal relations are not nailed into the cache
  823.  * ----------------
  824.  */
  825. relation->rd_isnailed = false;
  827. /* ----------------
  828.  * initialize the access method information (relation->rd_am)
  829.  * ----------------
  830.  */
  831. if (OidIsValid(relam))
  832. relation->rd_am = (Form_pg_am) AccessMethodObjectIdGetForm(relam);
  834. /* ----------------
  835.  * initialize the tuple descriptor (relation->rd_att).
  836.  * remember, rd_att is an array of attribute pointers that lives
  837.  * off the end of the relation descriptor structure so space was
  838.  * already allocated for it by AllocateRelationDesc.
  839.  * ----------------
  840.  */
  841. RelationBuildTupleDesc(buildinfo, relation, natts);
  843. /* ----------------
  844.  * initialize rules that affect this relation
  845.  * ----------------
  846.  */
  847. if (relp->relhasrules)
  848. RelationBuildRuleLock(relation);
  849. else
  850. relation->rd_rules = NULL;
  852. /* Triggers */
  853. if (relp->reltriggers > 0)
  854. RelationBuildTriggers(relation);
  855. else
  856. relation->trigdesc = NULL;
  858. /* ----------------
  859.  * initialize index strategy and support information for this relation
  860.  * ----------------
  861.  */
  862. if (OidIsValid(relam))
  863. IndexedAccessMethodInitialize(relation);
  865. /* ----------------
  866.  * initialize the relation lock manager information
  867.  * ----------------
  868.  */
  869. RelationInitLockInfo(relation); /* see lmgr.c */
  871. /* ----------------
  872.  * open the relation and assign the file descriptor returned
  873.  * by the storage manager code to rd_fd.
  874.  * ----------------
  875.  */
  876. fd = smgropen(DEFAULT_SMGR, relation);
  878. Assert(fd >= -1);
  879. if (fd == -1)
  880. elog(NOTICE, "RelationIdBuildRelation: smgropen(%s): %m",
  881.  &relp->relname);
  883. relation->rd_fd = fd;
  885. /* ----------------
  886.  * insert newly created relation into proper relcaches,
  887.  * restore memory context and return the new reldesc.
  888.  * ----------------
  889.  */
  890. RelationCacheInsert(relation);
  892. /* -------------------
  893.  * free the memory allocated for pg_class_tuple
  894.  * and for lock data pointed to by pg_class_tuple
  895.  * -------------------
  896.  */
  897. pfree(pg_class_tuple);
  899. MemoryContextSwitchTo(oldcxt);
  901. return relation;
  902. }
  904. static void
  905. IndexedAccessMethodInitialize(Relation relation)
  906. {
  907. IndexStrategy strategy;
  908. RegProcedure *support;
  909. int natts;
  910. Size stratSize;
  911. Size supportSize;
  912. uint16 relamstrategies;
  913. uint16 relamsupport;
  915. natts = relation->rd_rel->relnatts;
  916. relamstrategies = relation->rd_am->amstrategies;
  917. stratSize = AttributeNumberGetIndexStrategySize(natts, relamstrategies);
  918. strategy = (IndexStrategy) palloc(stratSize);
  919. relamsupport = relation->rd_am->amsupport;
  921. if (relamsupport > 0)
  922. {
  923. supportSize = natts * (relamsupport * sizeof(RegProcedure));
  924. support = (RegProcedure *) palloc(supportSize);
  925. }
  926. else
  927. support = (RegProcedure *) NULL;
  929. IndexSupportInitialize(strategy, support,
  930.    relation->rd_att->attrs[0]->attrelid,
  931.    relation->rd_rel->relam,
  932.    relamstrategies, relamsupport, natts);
  934. RelationSetIndexSupport(relation, strategy, support);
  935. }
  937. /* --------------------------------
  938.  * formrdesc
  939.  *
  940.  * This is a special version of RelationBuildDesc()
  941.  * used by RelationInitialize() in initializing the
  942.  * relcache.  The system relation descriptors built
  943.  * here are all nailed in the descriptor caches, for
  944.  * bootstrapping.
  945.  * --------------------------------
  946.  */
  947. static void
  948. formrdesc(char *relationName,
  949.   u_int natts,
  950.   FormData_pg_attribute *att)
  951. {
  952. Relation relation;
  953. Size len;
  954. int i;
  956. /* ----------------
  957.  * allocate new relation desc
  958.  * ----------------
  959.  */
  960. len = sizeof(RelationData);
  961. relation = (Relation) palloc(len);
  962. MemSet((char *) relation, 0, len);
  964. /* ----------------
  965.  * don't open the unix file yet..
  966.  * ----------------
  967.  */
  968. relation->rd_fd = -1;
  970. /* ----------------
  971.  * initialize reference count
  972.  * ----------------
  973.  */
  974. RelationSetReferenceCount(relation, 1);
  976. /* ----------------
  977.  * initialize relation tuple form
  978.  * ----------------
  979.  */
  980. relation->rd_rel = (Form_pg_class)
  981. palloc((Size) (sizeof(*relation->rd_rel)));
  982. MemSet(relation->rd_rel, 0, sizeof(FormData_pg_class));
  983. namestrcpy(&relation->rd_rel->relname, relationName);
  985. /* ----------------
  986.    initialize attribute tuple form
  987. */
  988. relation->rd_att = CreateTemplateTupleDesc(natts);
  990. /*
  991.  * For debugging purposes, it's important to distinguish between
  992.  * shared and non-shared relations, even at bootstrap time.  There's
  993.  * code in the buffer manager that traces allocations that has to know
  994.  * about this.
  995.  */
  997. if (IsSystemRelationName(relationName))
  998. {
  999. relation->rd_rel->relowner = 6; /* XXX use sym const */
  1000. relation->rd_rel->relisshared = IsSharedSystemRelationName(relationName);
  1001. }
  1002. else
  1003. {
  1004. relation->rd_rel->relowner = 0;
  1005. relation->rd_rel->relisshared = false;
  1006. }
  1008. relation->rd_rel->relpages = 1; /* XXX */
  1009. relation->rd_rel->reltuples = 1; /* XXX */
  1010. relation->rd_rel->relkind = RELKIND_RELATION;
  1011. relation->rd_rel->relnatts = (uint16) natts;
  1012. relation->rd_isnailed = true;
  1014. /* ----------------
  1015.  * initialize tuple desc info
  1016.  * ----------------
  1017.  */
  1018. for (i = 0; i < natts; i++)
  1019. {
  1020. relation->rd_att->attrs[i] = (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
  1022. MemSet((char *) relation->rd_att->attrs[i], 0,
  1023.    ATTRIBUTE_TUPLE_SIZE);
  1024. memmove((char *) relation->rd_att->attrs[i],
  1025. (char *) &att[i],
  1026. ATTRIBUTE_TUPLE_SIZE);
  1027. }
  1029. /* ----------------
  1030.  * initialize relation id
  1031.  * ----------------
  1032.  */
  1033. RelationGetRelid(relation) = relation->rd_att->attrs[0]->attrelid;
  1035. /* ----------------
  1036.  * add new reldesc to relcache
  1037.  * ----------------
  1038.  */
  1039. RelationCacheInsert(relation);
  1041. RelationInitLockInfo(relation);
  1043. /*
  1044.  * Determining this requires a scan on pg_class, but to do the scan
  1045.  * the rdesc for pg_class must already exist.  Therefore we must do
  1046.  * the check (and possible set) after cache insertion.
  1047.  */
  1048. relation->rd_rel->relhasindex =
  1049. CatalogHasIndex(relationName, RelationGetRelid(relation));
  1050. }
  1053. /* ----------------------------------------------------------------
  1054.  *  Relation Descriptor Lookup Interface
  1055.  * ----------------------------------------------------------------
  1056.  */
  1058. /* --------------------------------
  1059.  * RelationIdCacheGetRelation
  1060.  *
  1061.  * only try to get the reldesc by looking up the cache
  1062.  * do not go to the disk. this is used by BlockPrepareFile()
  1063.  * and RelationIdGetRelation below.
  1064.  * --------------------------------
  1065.  */
  1066. Relation
  1067. RelationIdCacheGetRelation(Oid relationId)
  1068. {
  1069. Relation rd;
  1071. RelationIdCacheLookup(relationId, rd);
  1073. if (RelationIsValid(rd))
  1074. {
  1075. if (rd->rd_fd == -1)
  1076. {
  1077. rd->rd_fd = smgropen(DEFAULT_SMGR, rd);
  1078. Assert(rd->rd_fd != -1);
  1079. }
  1081. RelationIncrementReferenceCount(rd);
  1083. }
  1085. return rd;
  1086. }
  1088. /* --------------------------------
  1089.  * RelationNameCacheGetRelation
  1090.  * --------------------------------
  1091.  */
  1092. static Relation
  1093. RelationNameCacheGetRelation(char *relationName)
  1094. {
  1095. Relation rd;
  1096. NameData name;
  1098. /*
  1099.  * make sure that the name key used for hash lookup is properly
  1100.  * null-padded
  1101.  */
  1102. namestrcpy(&name, relationName);
  1103. RelationNameCacheLookup(name.data, rd);
  1105. if (RelationIsValid(rd))
  1106. {
  1107. if (rd->rd_fd == -1)
  1108. {
  1109. rd->rd_fd = smgropen(DEFAULT_SMGR, rd);
  1110. Assert(rd->rd_fd != -1);
  1111. }
  1113. RelationIncrementReferenceCount(rd);
  1115. }
  1117. return rd;
  1118. }
  1120. /* --------------------------------
  1121.  * RelationIdGetRelation
  1122.  *
  1123.  * return a relation descriptor based on its id.
  1124.  * return a cached value if possible
  1125.  * --------------------------------
  1126.  */
  1127. Relation
  1128. RelationIdGetRelation(Oid relationId)
  1129. {
  1130. Relation rd;
  1131. RelationBuildDescInfo buildinfo;
  1133. /* ----------------
  1134.  * increment access statistics
  1135.  * ----------------
  1136.  */
  1137. IncrHeapAccessStat(local_RelationIdGetRelation);
  1138. IncrHeapAccessStat(global_RelationIdGetRelation);
  1140. /* ----------------
  1141.  * first try and get a reldesc from the cache
  1142.  * ----------------
  1143.  */
  1144. rd = RelationIdCacheGetRelation(relationId);
  1145. if (RelationIsValid(rd))
  1146. return rd;
  1148. /* ----------------
  1149.  * no reldesc in the cache, so have RelationBuildDesc()
  1150.  * build one and add it.
  1151.  * ----------------
  1152.  */
  1153. buildinfo.infotype = INFO_RELID;
  1154. buildinfo.i.info_id = relationId;
  1156. rd = RelationBuildDesc(buildinfo);
  1157. return rd;
  1158. }
  1160. /* --------------------------------
  1161.  * RelationNameGetRelation
  1162.  *
  1163.  * return a relation descriptor based on its name.
  1164.  * return a cached value if possible
  1165.  * --------------------------------
  1166.  */
  1167. Relation
  1168. RelationNameGetRelation(char *relationName)
  1169. {
  1170. Relation rd;
  1171. RelationBuildDescInfo buildinfo;
  1173. /* ----------------
  1174.  * increment access statistics
  1175.  * ----------------
  1176.  */
  1177. IncrHeapAccessStat(local_RelationNameGetRelation);
  1178. IncrHeapAccessStat(global_RelationNameGetRelation);
  1180. /* ----------------
  1181.  * first try and get a reldesc from the cache
  1182.  * ----------------
  1183.  */
  1184. rd = RelationNameCacheGetRelation(relationName);
  1185. if (RelationIsValid(rd))
  1186. return rd;
  1188. /* ----------------
  1189.  * no reldesc in the cache, so have RelationBuildDesc()
  1190.  * build one and add it.
  1191.  * ----------------
  1192.  */
  1193. buildinfo.infotype = INFO_RELNAME;
  1194. buildinfo.i.info_name = relationName;
  1196. rd = RelationBuildDesc(buildinfo);
  1197. return rd;
  1198. }
  1200. /* ----------------
  1201.  * old "getreldesc" interface.
  1202.  * ----------------
  1203.  */
  1204. #ifdef NOT_USED
  1205. Relation
  1206. getreldesc(char *relationName)
  1207. {
  1208. /* ----------------
  1209.  * increment access statistics
  1210.  * ----------------
  1211.  */
  1212. IncrHeapAccessStat(local_getreldesc);
  1213. IncrHeapAccessStat(global_getreldesc);
  1215. return RelationNameGetRelation(relationName);
  1216. }
  1218. #endif
  1220. /* ----------------------------------------------------------------
  1221.  * cache invalidation support routines
  1222.  * ----------------------------------------------------------------
  1223.  */
  1225. /* --------------------------------
  1226.  * RelationClose - close an open relation
  1227.  * --------------------------------
  1228.  */
  1229. void
  1230. RelationClose(Relation relation)
  1231. {
  1232. /* Note: no locking manipulations needed */
  1233. RelationDecrementReferenceCount(relation);
  1234. }
  1236. /* --------------------------------
  1237.  * RelationFlushRelation
  1238.  *
  1239.  *  Actually blows away a relation... RelationFree doesn't do
  1240.  *  anything anymore.
  1241.  * --------------------------------
  1242.  */
  1243. static void
  1244. RelationFlushRelation(Relation *relationPtr,
  1245.   bool onlyFlushReferenceCountZero)
  1246. {
  1247. MemoryContext oldcxt;
  1248. Relation relation = *relationPtr;
  1250. if (relation->rd_isnailed)
  1251. {
  1252. /* this is a nailed special relation for bootstraping */
  1253. return;
  1254. }
  1256. if (!onlyFlushReferenceCountZero ||
  1257. RelationHasReferenceCountZero(relation))
  1258. {
  1259. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  1261. /* make sure smgr and lower levels close the relation's files,
  1262.  * if they weren't closed already
  1263.  */
  1264. smgrclose(DEFAULT_SMGR, relation);
  1266. RelationCacheDelete(relation);
  1268. FreeTupleDesc(relation->rd_att);
  1269. SystemCacheRelationFlushed(RelationGetRelid(relation));
  1271. FreeTriggerDesc(relation);
  1273. #ifdef NOT_USED
  1274. if (relation->rd_rules)
  1275. {
  1276. int j;
  1278. for (j = 0; j < relation->rd_rules->numLocks; j++)
  1279. pfree(relation->rd_rules->rules[j]);
  1280. pfree(relation->rd_rules->rules);
  1281. pfree(relation->rd_rules);
  1282. }
  1283. #endif
  1285. pfree(RelationGetLockInfo(relation));
  1286. pfree(RelationGetForm(relation));
  1287. pfree(relation);
  1289. MemoryContextSwitchTo(oldcxt);
  1290. }
  1291. }
  1293. /* --------------------------------
  1294.  * RelationForgetRelation -
  1295.  *    RelationFlushRelation + if the relation is myxactonly then
  1296.  *    get rid of the relation descriptor from the newly created
  1297.  *    relation list.
  1298.  * --------------------------------
  1299.  */
  1300. void
  1301. RelationForgetRelation(Oid rid)
  1302. {
  1303. Relation relation;
  1305. RelationIdCacheLookup(rid, relation);
  1307. if (PointerIsValid(relation))
  1308. {
  1309. if (relation->rd_myxactonly)
  1310. {
  1311. MemoryContext oldcxt;
  1312. List    *curr;
  1313. List    *prev = NIL;
  1315. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  1317. foreach(curr, newlyCreatedRelns)
  1318. {
  1319. Relation reln = lfirst(curr);
  1321. Assert(reln != NULL && reln->rd_myxactonly);
  1322. if (RelationGetRelid(reln) == rid)
  1323. break;
  1324. prev = curr;
  1325. }
  1326. if (curr == NIL)
  1327. elog(FATAL, "Local relation %s not found in list",
  1328.  (RelationGetRelationName(relation))->data);
  1329. if (prev == NIL)
  1330. newlyCreatedRelns = lnext(newlyCreatedRelns);
  1331. else
  1332. lnext(prev) = lnext(curr);
  1333. pfree(curr);
  1334. MemoryContextSwitchTo(oldcxt);
  1335. }
  1337. RelationFlushRelation(&relation, false);
  1338. }
  1339. }
  1341. /* --------------------------------
  1342.  * RelationIdInvalidateRelationCacheByRelationId
  1343.  * --------------------------------
  1344.  */
  1345. void
  1346. RelationIdInvalidateRelationCacheByRelationId(Oid relationId)
  1347. {
  1348. Relation relation;
  1350. RelationIdCacheLookup(relationId, relation);
  1352. /*
  1353.  * "local" relations are invalidated by RelationPurgeLocalRelation.
  1354.  * (This is to make LocalBufferSync's life easier: want the descriptor
  1355.  * to hang around for a while. In fact, won't we want this for
  1356.  * BufferSync also? But I'll leave it for now since I don't want to
  1357.  * break anything.) - ay 3/95
  1358.  */
  1359. if (PointerIsValid(relation) && !relation->rd_myxactonly)
  1360. {
  1362. /*
  1363.  * The boolean onlyFlushReferenceCountZero in RelationFlushReln()
  1364.  * should be set to true when we are incrementing the command
  1365.  * counter and to false when we are starting a new xaction.  This
  1366.  * can be determined by checking the current xaction status.
  1367.  */
  1368. RelationFlushRelation(&relation, CurrentXactInProgress());
  1369. }
  1370. }
  1372. #if NOT_USED /* See comments at line 1304 */
  1373. /* --------------------------------
  1374.  * RelationIdInvalidateRelationCacheByAccessMethodId
  1375.  *
  1376.  * RelationFlushIndexes is needed for use with HashTableWalk..
  1377.  * --------------------------------
  1378.  */
  1379. static void
  1380. RelationFlushIndexes(Relation *r,
  1381.  Oid accessMethodId)
  1382. {
  1383. Relation relation = *r;
  1385. if (!RelationIsValid(relation))
  1386. {
  1387. elog(NOTICE, "inval call to RFI");
  1388. return;
  1389. }
  1391. if (relation->rd_rel->relkind == RELKIND_INDEX && /* XXX style */
  1392. (!OidIsValid(accessMethodId) ||
  1393.  relation->rd_rel->relam == accessMethodId))
  1394. RelationFlushRelation(&relation, false);
  1395. }
  1397. #endif
  1400. void
  1401. RelationIdInvalidateRelationCacheByAccessMethodId(Oid accessMethodId)
  1402. {
  1403. #ifdef NOT_USED
  1405. /*
  1406.  * 25 aug 1992:  mao commented out the ht walk below.  it should be
  1407.  * doing the right thing, in theory, but flushing reldescs for index
  1408.  * relations apparently doesn't work.  we want to cut 4.0.1, and i
  1409.  * don't want to introduce new bugs.  this code never executed before,
  1410.  * so i'm turning it off for now.  after the release is cut, i'll fix
  1411.  * this up.
  1412.  */
  1414. HashTableWalk(RelationNameCache, (HashtFunc) RelationFlushIndexes,
  1415.   accessMethodId);
  1416. #else
  1417. return;
  1418. #endif
  1419. }
  1421. /*
  1422.  * RelationCacheInvalidate
  1423.  *
  1424.  *  Will blow away either all the cached relation descriptors or
  1425.  *  those that have a zero reference count.
  1426.  *
  1427.  */
  1428. void
  1429. RelationCacheInvalidate(bool onlyFlushReferenceCountZero)
  1430. {
  1431. HashTableWalk(RelationNameCache, (HashtFunc) RelationFlushRelation,
  1432.   onlyFlushReferenceCountZero);
  1434. /*
  1435.  * nailed-in reldescs will still be in the cache... 7 hardwired heaps
  1436.  * + 3 hardwired indices == 10 total.
  1437.  */
  1438. if (!onlyFlushReferenceCountZero)
  1439. {
  1440. Assert(RelationNameCache->hctl->nkeys == 10);
  1441. Assert(RelationIdCache->hctl->nkeys == 10);
  1442. }
  1443. }
  1446. /* --------------------------------
  1447.  * RelationRegisterRelation -
  1448.  *    register the Relation descriptor of a newly created relation
  1449.  *    with the relation descriptor Cache.
  1450.  * --------------------------------
  1451.  */
  1452. void
  1453. RelationRegisterRelation(Relation relation)
  1454. {
  1455. MemoryContext oldcxt;
  1457. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  1459. if (oldcxt != (MemoryContext) CacheCxt)
  1460. elog(NOIND, "RelationRegisterRelation: WARNING: Context != CacheCxt");
  1462. RelationCacheInsert(relation);
  1464. RelationInitLockInfo(relation);
  1466. /*
  1467.  * we've just created the relation. It is invisible to anyone else
  1468.  * before the transaction is committed. Setting rd_myxactonly allows
  1469.  * us to use the local buffer manager for select/insert/etc before the
  1470.  * end of transaction. (We also need to keep track of relations
  1471.  * created during a transaction and does the necessary clean up at the
  1472.  * end of the transaction.) - ay 3/95
  1473.  */
  1474. relation->rd_myxactonly = TRUE;
  1475. newlyCreatedRelns = lcons(relation, newlyCreatedRelns);
  1477. MemoryContextSwitchTo(oldcxt);
  1478. }
  1480. /*
  1481.  * RelationPurgeLocalRelation -
  1482.  *   find all the Relation descriptors marked rd_myxactonly and reset them.
  1483.  *   This should be called at the end of a transaction (commit/abort) when
  1484.  *   the "local" relations will become visible to others and the multi-user
  1485.  *   buffer pool should be used.
  1486.  */
  1487. void
  1488. RelationPurgeLocalRelation(bool xactCommitted)
  1489. {
  1490. MemoryContext oldcxt;
  1492. if (newlyCreatedRelns == NULL)
  1493. return;
  1495. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  1497. while (newlyCreatedRelns)
  1498. {
  1499. List    *l = newlyCreatedRelns;
  1500. Relation reln = lfirst(l);
  1502. Assert(reln != NULL && reln->rd_myxactonly);
  1504. if (!xactCommitted)
  1505. {
  1507. /*
  1508.  * remove the file if we abort. This is so that files for
  1509.  * tables created inside a transaction block get removed.
  1510.  */
  1511. if (reln->rd_isnoname)
  1512. {
  1513. if (!(reln->rd_nonameunlinked))
  1514. {
  1515. smgrunlink(DEFAULT_SMGR, reln);
  1516. reln->rd_nonameunlinked = TRUE;
  1517. }
  1518. }
  1519. else
  1520. smgrunlink(DEFAULT_SMGR, reln);
  1521. }
  1523. reln->rd_myxactonly = FALSE;
  1525. if (!IsBootstrapProcessingMode())
  1526. RelationFlushRelation(&reln, FALSE);
  1528. newlyCreatedRelns = lnext(newlyCreatedRelns);
  1529. pfree(l);
  1530. }
  1532. MemoryContextSwitchTo(oldcxt);
  1533. }
  1535. /* --------------------------------
  1536.  * RelationInitialize
  1537.  *
  1538.  * This initializes the relation descriptor cache.
  1539.  * --------------------------------
  1540.  */
  1542. #define INITRELCACHESIZE 400
  1544. void
  1545. RelationInitialize(void)
  1546. {
  1547. MemoryContext oldcxt;
  1548. HASHCTL ctl;
  1550. /* ----------------
  1551.  * switch to cache memory context
  1552.  * ----------------
  1553.  */
  1554. if (!CacheCxt)
  1555. CacheCxt = CreateGlobalMemory("Cache");
  1557. oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
  1559. /* ----------------
  1560.  * create global caches
  1561.  * ----------------
  1562.  */
  1563. MemSet(&ctl, 0, (int) sizeof(ctl));
  1564. ctl.keysize = sizeof(NameData);
  1565. ctl.datasize = sizeof(Relation);
  1566. RelationNameCache = hash_create(INITRELCACHESIZE, &ctl, HASH_ELEM);
  1568. ctl.keysize = sizeof(Oid);
  1569. ctl.hash = tag_hash;
  1570. RelationIdCache = hash_create(INITRELCACHESIZE, &ctl,
  1571.   HASH_ELEM | HASH_FUNCTION);
  1573. /* ----------------
  1574.  * initialize the cache with pre-made relation descriptors
  1575.  * for some of the more important system relations.  These
  1576.  * relations should always be in the cache.
  1577.  * ----------------
  1578.  */
  1579. formrdesc(RelationRelationName, Natts_pg_class, Desc_pg_class);
  1580. formrdesc(AttributeRelationName, Natts_pg_attribute, Desc_pg_attribute);
  1581. formrdesc(ProcedureRelationName, Natts_pg_proc, Desc_pg_proc);
  1582. formrdesc(TypeRelationName, Natts_pg_type, Desc_pg_type);
  1583. formrdesc(VariableRelationName, Natts_pg_variable, Desc_pg_variable);
  1584. formrdesc(LogRelationName, Natts_pg_log, Desc_pg_log);
  1586. /*
  1587.  * If this isn't initdb time, then we want to initialize some index
  1588.  * relation descriptors, as well.  The descriptors are for
  1589.  * pg_attnumind (to make building relation descriptors fast) and
  1590.  * possibly others, as they're added.
  1591.  */
  1593. if (!IsBootstrapProcessingMode())
  1594. init_irels();
  1596. MemoryContextSwitchTo(oldcxt);
  1597. }
  1599. static void
  1600. AttrDefaultFetch(Relation relation)
  1601. {
  1602. AttrDefault *attrdef = relation->rd_att->constr->defval;
  1603. int ndef = relation->rd_att->constr->num_defval;
  1604. Relation adrel;
  1605. Relation irel;
  1606. ScanKeyData skey;
  1607. HeapTupleData tuple;
  1608. Form_pg_attrdef adform;
  1609. IndexScanDesc sd;
  1610. RetrieveIndexResult indexRes;
  1611. struct varlena *val;
  1612. bool isnull;
  1613. int found;
  1614. int i;
  1616. ScanKeyEntryInitialize(&skey,
  1617.    (bits16) 0x0,
  1618.    (AttrNumber) 1,
  1619.    (RegProcedure) F_OIDEQ,
  1620.    ObjectIdGetDatum(RelationGetRelid(relation)));
  1622. adrel = heap_openr(AttrDefaultRelationName);
  1623. irel = index_openr(AttrDefaultIndex);
  1624. sd = index_beginscan(irel, false, 1, &skey);
  1625. tuple.t_data = NULL;
  1627. for (found = 0;;)
  1628. {
  1629. Buffer buffer;
  1631. indexRes = index_getnext(sd, ForwardScanDirection);
  1632. if (!indexRes)
  1633. break;
  1635. tuple.t_self = indexRes->heap_iptr;
  1636. heap_fetch(adrel, SnapshotNow, &tuple, &buffer);
  1637. pfree(indexRes);
  1638. if (tuple.t_data == NULL)
  1639. continue;
  1640. found++;
  1641. adform = (Form_pg_attrdef) GETSTRUCT(&tuple);
  1642. for (i = 0; i < ndef; i++)
  1643. {
  1644. if (adform->adnum != attrdef[i].adnum)
  1645. continue;
  1646. if (attrdef[i].adsrc != NULL)
  1647. elog(ERROR, "AttrDefaultFetch: second record found for attr %s in rel %s",
  1648. relation->rd_att->attrs[adform->adnum - 1]->attname.data,
  1649.  relation->rd_rel->relname.data);
  1651. val = (struct varlena *) fastgetattr(&tuple,
  1652.  Anum_pg_attrdef_adbin,
  1653.  adrel->rd_att, &isnull);
  1654. if (isnull)
  1655. elog(ERROR, "AttrDefaultFetch: adbin IS NULL for attr %s in rel %s",
  1656. relation->rd_att->attrs[adform->adnum - 1]->attname.data,
  1657.  relation->rd_rel->relname.data);
  1658. attrdef[i].adbin = textout(val);
  1659. val = (struct varlena *) fastgetattr(&tuple,
  1660.  Anum_pg_attrdef_adsrc,
  1661.  adrel->rd_att, &isnull);
  1662. if (isnull)
  1663. elog(ERROR, "AttrDefaultFetch: adsrc IS NULL for attr %s in rel %s",
  1664. relation->rd_att->attrs[adform->adnum - 1]->attname.data,
  1665.  relation->rd_rel->relname.data);
  1666. attrdef[i].adsrc = textout(val);
  1667. break;
  1668. }
  1669. ReleaseBuffer(buffer);
  1671. if (i >= ndef)
  1672. elog(ERROR, "AttrDefaultFetch: unexpected record found for attr %d in rel %s",
  1673.  adform->adnum,
  1674.  relation->rd_rel->relname.data);
  1675. }
  1677. if (found < ndef)
  1678. elog(ERROR, "AttrDefaultFetch: %d record not found for rel %s",
  1679.  ndef - found, relation->rd_rel->relname.data);
  1681. index_endscan(sd);
  1682. pfree(sd);
  1683. index_close(irel);
  1684. heap_close(adrel);
  1685. }
  1687. static void
  1688. RelCheckFetch(Relation relation)
  1689. {
  1690. ConstrCheck *check = relation->rd_att->constr->check;
  1691. int ncheck = relation->rd_att->constr->num_check;
  1692. Relation rcrel;
  1693. Relation irel;
  1694. ScanKeyData skey;
  1695. HeapTupleData tuple;
  1696. IndexScanDesc sd;
  1697. RetrieveIndexResult indexRes;
  1698. Name rcname;
  1699. struct varlena *val;
  1700. bool isnull;
  1701. int found;
  1703. ScanKeyEntryInitialize(&skey,
  1704.    (bits16) 0x0,
  1705.    (AttrNumber) 1,
  1706.    (RegProcedure) F_OIDEQ,
  1707.    ObjectIdGetDatum(RelationGetRelid(relation)));
  1709. rcrel = heap_openr(RelCheckRelationName);
  1710. irel = index_openr(RelCheckIndex);
  1711. sd = index_beginscan(irel, false, 1, &skey);
  1712. tuple.t_data = NULL;
  1714. for (found = 0;;)
  1715. {
  1716. Buffer buffer;
  1718. indexRes = index_getnext(sd, ForwardScanDirection);
  1719. if (!indexRes)
  1720. break;
  1722. tuple.t_self = indexRes->heap_iptr;
  1723. heap_fetch(rcrel, SnapshotNow, &tuple, &buffer);
  1724. pfree(indexRes);
  1725. if (tuple.t_data == NULL)
  1726. continue;
  1727. if (found == ncheck)
  1728. elog(ERROR, "RelCheckFetch: unexpected record found for rel %s",
  1729.  relation->rd_rel->relname.data);
  1731. rcname = (Name) fastgetattr(&tuple,
  1732. Anum_pg_relcheck_rcname,
  1733. rcrel->rd_att, &isnull);
  1734. if (isnull)
  1735. elog(ERROR, "RelCheckFetch: rcname IS NULL for rel %s",
  1736.  relation->rd_rel->relname.data);
  1737. check[found].ccname = nameout(rcname);
  1738. val = (struct varlena *) fastgetattr(&tuple,
  1739.  Anum_pg_relcheck_rcbin,
  1740.  rcrel->rd_att, &isnull);
  1741. if (isnull)
  1742. elog(ERROR, "RelCheckFetch: rcbin IS NULL for rel %s",
  1743.  relation->rd_rel->relname.data);
  1744. check[found].ccbin = textout(val);
  1745. val = (struct varlena *) fastgetattr(&tuple,
  1746.  Anum_pg_relcheck_rcsrc,
  1747.  rcrel->rd_att, &isnull);
  1748. if (isnull)
  1749. elog(ERROR, "RelCheckFetch: rcsrc IS NULL for rel %s",
  1750.  relation->rd_rel->relname.data);
  1751. check[found].ccsrc = textout(val);
  1752. found++;
  1753. ReleaseBuffer(buffer);
  1754. }
  1756. if (found < ncheck)
  1757. elog(ERROR, "RelCheckFetch: %d record not found for rel %s",
  1758.  ncheck - found,
  1759.  relation->rd_rel->relname.data);
  1761. index_endscan(sd);
  1762. pfree(sd);
  1763. index_close(irel);
  1764. heap_close(rcrel);
  1766. }
  1768. /*
  1769.  * init_irels(), write_irels() -- handle special-case initialization of
  1770.  *    index relation descriptors.
  1771.  *
  1772.  * In late 1992, we started regularly having databases with more than
  1773.  * a thousand classes in them.  With this number of classes, it became
  1774.  * critical to do indexed lookups on the system catalogs.
  1775.  *
  1776.  * Bootstrapping these lookups is very hard.  We want to be able to
  1777.  * use an index on pg_attribute, for example, but in order to do so,
  1778.  * we must have read pg_attribute for the attributes in the index,
  1779.  * which implies that we need to use the index.
  1780.  *
  1781.  * In order to get around the problem, we do the following:
  1782.  *
  1783.  *    +  When the database system is initialized (at initdb time), we
  1784.  *   don't use indices on pg_attribute.  We do sequential scans.
  1785.  *
  1786.  *    +  When the backend is started up in normal mode, we load an image
  1787.  *   of the appropriate relation descriptors, in internal format,
  1788.  *   from an initialization file in the data/base/... directory.
  1789.  *
  1790.  *    +  If the initialization file isn't there, then we create the
  1791.  *   relation descriptors using sequential scans and write 'em to
  1792.  *   the initialization file for use by subsequent backends.
  1793.  *
  1794.  * We could dispense with the initialization file and just build the
  1795.  * critical reldescs the hard way on every backend startup, but that
  1796.  * slows down backend startup noticeably if pg_class is large.
  1797.  *
  1798.  * As of v6.5, vacuum.c deletes the initialization file at completion
  1799.  * of a VACUUM, so that it will be rebuilt at the next backend startup.
  1800.  * This ensures that vacuum-collected stats for the system indexes
  1801.  * will eventually get used by the optimizer --- otherwise the relcache
  1802.  * entries for these indexes will show zero sizes forever, since the
  1803.  * relcache entries are pinned in memory and will never be reloaded
  1804.  * from pg_class.
  1805.  */
  1807. /* pg_attnumind, pg_classnameind, pg_classoidind */
  1808. #define Num_indices_bootstrap 3
  1810. static void
  1811. init_irels(void)
  1812. {
  1813. Size len;
  1814. int nread;
  1815. File fd;
  1816. Relation irel[Num_indices_bootstrap];
  1817. Relation ird;
  1818. Form_pg_am am;
  1819. Form_pg_class relform;
  1820. IndexStrategy strat;
  1821. RegProcedure *support;
  1822. int i;
  1823. int relno;
  1825. #ifndef __CYGWIN32__
  1826. if ((fd = FileNameOpenFile(RELCACHE_INIT_FILENAME, O_RDONLY, 0600)) < 0)
  1827. #else
  1828. if ((fd = FileNameOpenFile(RELCACHE_INIT_FILENAME, O_RDONLY | O_BINARY, 0600)) < 0)
  1829. #endif
  1830. {
  1831. write_irels();
  1832. return;
  1833. }
  1835. FileSeek(fd, 0L, SEEK_SET);
  1837. for (relno = 0; relno < Num_indices_bootstrap; relno++)
  1838. {
  1839. /* first read the relation descriptor length */
  1840. if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
  1841. {
  1842. write_irels();
  1843. return;
  1844. }
  1846. ird = irel[relno] = (Relation) palloc(len);
  1847. MemSet(ird, 0, len);
  1849. /* then, read the Relation structure */
  1850. if ((nread = FileRead(fd, (char *) ird, len)) != len)
  1851. {
  1852. write_irels();
  1853. return;
  1854. }
  1856. /* the file descriptor is not yet opened */
  1857. ird->rd_fd = -1;
  1859. /* lock info is not initialized */
  1860. ird->lockInfo = (char *) NULL;
  1862. /* next, read the access method tuple form */
  1863. if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
  1864. {
  1865. write_irels();
  1866. return;
  1867. }
  1869. am = (Form_pg_am) palloc(len);
  1870. if ((nread = FileRead(fd, (char *) am, len)) != len)
  1871. {
  1872. write_irels();
  1873. return;
  1874. }
  1876. ird->rd_am = am;
  1878. /* next read the relation tuple form */
  1879. if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
  1880. {
  1881. write_irels();
  1882. return;
  1883. }
  1885. relform = (Form_pg_class) palloc(len);
  1886. if ((nread = FileRead(fd, (char *) relform, len)) != len)
  1887. {
  1888. write_irels();
  1889. return;
  1890. }
  1892. ird->rd_rel = relform;
  1894. /* initialize attribute tuple forms */
  1895. ird->rd_att = CreateTemplateTupleDesc(relform->relnatts);
  1897. /* next read all the attribute tuple form data entries */
  1898. len = ATTRIBUTE_TUPLE_SIZE;
  1899. for (i = 0; i < relform->relnatts; i++)
  1900. {
  1901. if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
  1902. {
  1903. write_irels();
  1904. return;
  1905. }
  1907. ird->rd_att->attrs[i] = (Form_pg_attribute) palloc(len);
  1909. if ((nread = FileRead(fd, (char *) ird->rd_att->attrs[i], len)) != len)
  1910. {
  1911. write_irels();
  1912. return;
  1913. }
  1914. }
  1916. /* next, read the index strategy map */
  1917. if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
  1918. {
  1919. write_irels();
  1920. return;
  1921. }
  1923. strat = (IndexStrategy) palloc(len);
  1924. if ((nread = FileRead(fd, (char *) strat, len)) != len)
  1925. {
  1926. write_irels();
  1927. return;
  1928. }
  1930. /* oh, for god's sake... */
  1931. #define SMD(i) strat[0].strategyMapData[i].entry[0]
  1933. /* have to reinit the function pointers in the strategy maps */
  1934. for (i = 0; i < am->amstrategies * relform->relnatts; i++)
  1935. {
  1936. fmgr_info(SMD(i).sk_procedure,
  1937.   &(SMD(i).sk_func));
  1938. SMD(i).sk_nargs = SMD(i).sk_func.fn_nargs;
  1939. }
  1942. /*
  1943.  * use a real field called rd_istrat instead of the bogosity of
  1944.  * hanging invisible fields off the end of a structure - jolly
  1945.  */
  1946. ird->rd_istrat = strat;
  1948. /* finally, read the vector of support procedures */
  1949. if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
  1950. {
  1951. write_irels();
  1952. return;
  1953. }
  1955. support = (RegProcedure *) palloc(len);
  1956. if ((nread = FileRead(fd, (char *) support, len)) != len)
  1957. {
  1958. write_irels();
  1959. return;
  1960. }
  1962. /*
  1963.  * p += sizeof(IndexStrategy); ((RegProcedure **) p) = support;
  1964.  */
  1966. ird->rd_support = support;
  1968. RelationCacheInsert(ird);
  1969. RelationInitLockInfo(ird);
  1970. }
  1971. }
  1973. static void
  1974. write_irels(void)
  1975. {
  1976. Size len;
  1977. int nwritten;
  1978. File fd;
  1979. Relation irel[Num_indices_bootstrap];
  1980. Relation ird;
  1981. Form_pg_am am;
  1982. Form_pg_class relform;
  1983. IndexStrategy strat;
  1984. RegProcedure *support;
  1985. ProcessingMode oldmode;
  1986. int i;
  1987. int relno;
  1988. RelationBuildDescInfo bi;
  1990. #ifndef __CYGWIN32__
  1991. fd = FileNameOpenFile(RELCACHE_INIT_FILENAME, O_WRONLY | O_CREAT | O_TRUNC, 0600);
  1992. #else
  1993. fd = FileNameOpenFile(RELCACHE_INIT_FILENAME, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0600);
  1994. #endif
  1995. if (fd < 0)
  1996. elog(FATAL, "cannot create init file %s", RELCACHE_INIT_FILENAME);
  1998. FileSeek(fd, 0L, SEEK_SET);
  2000. /*
  2001.  * Build a relation descriptor for pg_attnumind without resort to the
  2002.  * descriptor cache.  In order to do this, we set ProcessingMode to
  2003.  * Bootstrap.  The effect of this is to disable indexed relation
  2004.  * searches -- a necessary step, since we're trying to instantiate the
  2005.  * index relation descriptors here.
  2006.  */
  2008. oldmode = GetProcessingMode();
  2009. SetProcessingMode(BootstrapProcessing);
  2011. bi.infotype = INFO_RELNAME;
  2012. bi.i.info_name = AttributeNumIndex;
  2013. irel[0] = RelationBuildDesc(bi);
  2014. irel[0]->rd_isnailed = true;
  2016. bi.i.info_name = ClassNameIndex;
  2017. irel[1] = RelationBuildDesc(bi);
  2018. irel[1]->rd_isnailed = true;
  2020. bi.i.info_name = ClassOidIndex;
  2021. irel[2] = RelationBuildDesc(bi);
  2022. irel[2]->rd_isnailed = true;
  2024. SetProcessingMode(oldmode);
  2026. /* nail the descriptor in the cache */
  2027. for (relno = 0; relno < Num_indices_bootstrap; relno++)
  2028. {
  2029. ird = irel[relno];
  2031. /* save the volatile fields in the relation descriptor */
  2032. am = ird->rd_am;
  2033. ird->rd_am = (Form_pg_am) NULL;
  2034. relform = ird->rd_rel;
  2035. ird->rd_rel = (Form_pg_class) NULL;
  2036. strat = ird->rd_istrat;
  2037. support = ird->rd_support;
  2039. /*
  2040.  * first write the relation descriptor , excluding strategy and
  2041.  * support
  2042.  */
  2043. len = sizeof(RelationData);
  2045. /* first, write the relation descriptor length */
  2046. if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
  2047. != sizeof(len))
  2048. elog(FATAL, "cannot write init file -- descriptor length");
  2050. /* next, write out the Relation structure */
  2051. if ((nwritten = FileWrite(fd, (char *) ird, len)) != len)
  2052. elog(FATAL, "cannot write init file -- reldesc");
  2054. /* next, write the access method tuple form */
  2055. len = sizeof(FormData_pg_am);
  2056. if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
  2057. != sizeof(len))
  2058. elog(FATAL, "cannot write init file -- am tuple form length");
  2060. if ((nwritten = FileWrite(fd, (char *) am, len)) != len)
  2061. elog(FATAL, "cannot write init file -- am tuple form");
  2063. /* next write the relation tuple form */
  2064. len = sizeof(FormData_pg_class);
  2065. if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
  2066. != sizeof(len))
  2067. elog(FATAL, "cannot write init file -- relation tuple form length");
  2069. if ((nwritten = FileWrite(fd, (char *) relform, len)) != len)
  2070. elog(FATAL, "cannot write init file -- relation tuple form");
  2072. /* next, do all the attribute tuple form data entries */
  2073. len = ATTRIBUTE_TUPLE_SIZE;
  2074. for (i = 0; i < relform->relnatts; i++)
  2075. {
  2076. if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
  2077. != sizeof(len))
  2078. elog(FATAL, "cannot write init file -- length of attdesc %d", i);
  2079. if ((nwritten = FileWrite(fd, (char *) ird->rd_att->attrs[i], len))
  2080. != len)
  2081. elog(FATAL, "cannot write init file -- attdesc %d", i);
  2082. }
  2084. /* next, write the index strategy map */
  2085. len = AttributeNumberGetIndexStrategySize(relform->relnatts,
  2086.   am->amstrategies);
  2087. if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
  2088. != sizeof(len))
  2089. elog(FATAL, "cannot write init file -- strategy map length");
  2091. if ((nwritten = FileWrite(fd, (char *) strat, len)) != len)
  2092. elog(FATAL, "cannot write init file -- strategy map");
  2094. /* finally, write the vector of support procedures */
  2095. len = relform->relnatts * (am->amsupport * sizeof(RegProcedure));
  2096. if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
  2097. != sizeof(len))
  2098. elog(FATAL, "cannot write init file -- support vector length");
  2100. if ((nwritten = FileWrite(fd, (char *) support, len)) != len)
  2101. elog(FATAL, "cannot write init file -- support vector");
  2103. /* restore volatile fields */
  2104. ird->rd_am = am;
  2105. ird->rd_rel = relform;
  2106. }
  2108. FileClose(fd);
  2109. }