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

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

数据库系统

开发平台：

Unix_Linux

heapam.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * heapam.c
  4.  *   heap access method code
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.46.2.1 1999/08/02 05:56:36 scrappy Exp $
  11.  *
  12.  *
  13.  * INTERFACE ROUTINES
  14.  * heapgettup - fetch next heap tuple from a scan
  15.  * heap_open - open a heap relation by relationId
  16.  * heap_openr - open a heap relation by name
  17.  * heap_close - close a heap relation
  18.  * heap_beginscan - begin relation scan
  19.  * heap_rescan - restart a relation scan
  20.  * heap_endscan - end relation scan
  21.  * heap_getnext - retrieve next tuple in scan
  22.  * heap_fetch - retrive tuple with tid
  23.  * heap_insert - insert tuple into a relation
  24.  * heap_delete - delete a tuple from a relation
  25.  * heap_replace - replace a tuple in a relation with another tuple
  26.  * heap_markpos - mark scan position
  27.  * heap_restrpos - restore position to marked location
  28.  *
  29.  * NOTES
  30.  *   This file contains the heap_ routines which implement
  31.  *   the POSTGRES heap access method used for all POSTGRES
  32.  *   relations.
  33.  *
  34.  * OLD COMMENTS
  35.  * struct relscan hints:  (struct should be made AM independent?)
  36.  *
  37.  * rs_ctid is the tid of the last tuple returned by getnext.
  38.  * rs_ptid and rs_ntid are the tids of the previous and next tuples
  39.  * returned by getnext, respectively. NULL indicates an end of
  40.  * scan (either direction); NON indicates an unknow value.
  41.  *
  42.  * possible combinations:
  43.  * rs_p rs_c rs_n interpretation
  44.  * NULL NULL NULL empty scan
  45.  * NULL NULL NON at begining of scan
  46.  * NULL NULL t1 at begining of scan (with cached tid)
  47.  * NON NULL NULL at end of scan
  48.  * t1 NULL NULL at end of scan (with cached tid)
  49.  * NULL t1 NULL just returned only tuple
  50.  * NULL t1 NON just returned first tuple
  51.  * NULL t1 t2 returned first tuple (with cached tid)
  52.  * NON t1 NULL just returned last tuple
  53.  * t2 t1 NULL returned last tuple (with cached tid)
  54.  * t1 t2 NON in the middle of a forward scan
  55.  * NON t2 t1 in the middle of a reverse scan
  56.  * ti tj tk in the middle of a scan (w cached tid)
  57.  *
  58.  * Here NULL is ...tup == NULL && ...buf == InvalidBuffer,
  59.  * and NON is ...tup == NULL && ...buf == UnknownBuffer.
  60.  *
  61.  * Currently, the NONTID values are not cached with their actual
  62.  * values by getnext. Values may be cached by markpos since it stores
  63.  * all three tids.
  64.  *
  65.  * NOTE:  the calls to elog() must stop.  Should decide on an interface
  66.  * between the general and specific AM calls.
  67.  *
  68.  * XXX probably do not need a free tuple routine for heaps.
  69.  * Huh?  Free tuple is not necessary for tuples returned by scans, but
  70.  * is necessary for tuples which are returned by
  71.  * RelationGetTupleByItemPointer. -hirohama
  72.  *
  73.  *-------------------------------------------------------------------------
  74.  */
  76. #include "postgres.h"
  78. #include "access/heapam.h"
  79. #include "access/hio.h"
  80. #include "access/valid.h"
  81. #include "catalog/catalog.h"
  82. #include "miscadmin.h"
  83. #include "storage/smgr.h"
  84. #include "utils/builtins.h"
  85. #include "utils/inval.h"
  86. #include "utils/relcache.h"
  89. /* ----------------------------------------------------------------
  90.  *  heap support routines
  91.  * ----------------------------------------------------------------
  92.  */
  94. /* ----------------
  95.  * initscan - scan code common to heap_beginscan and heap_rescan
  96.  * ----------------
  97.  */
  98. static void
  99. initscan(HeapScanDesc scan,
  100.  Relation relation,
  101.  int atend,
  102.  unsigned nkeys,
  103.  ScanKey key)
  104. {
  105. if (!RelationGetNumberOfBlocks(relation))
  106. {
  107. /* ----------------
  108.  * relation is empty
  109.  * ----------------
  110.  */
  111. scan->rs_ntup.t_data = scan->rs_ctup.t_data =
  112. scan->rs_ptup.t_data = NULL;
  113. scan->rs_nbuf = scan->rs_cbuf = scan->rs_pbuf = InvalidBuffer;
  114. }
  115. else if (atend)
  116. {
  117. /* ----------------
  118.  * reverse scan
  119.  * ----------------
  120.  */
  121. scan->rs_ntup.t_data = scan->rs_ctup.t_data = NULL;
  122. scan->rs_nbuf = scan->rs_cbuf = InvalidBuffer;
  123. scan->rs_ptup.t_data = NULL;
  124. scan->rs_pbuf = UnknownBuffer;
  125. }
  126. else
  127. {
  128. /* ----------------
  129.  * forward scan
  130.  * ----------------
  131.  */
  132. scan->rs_ctup.t_data = scan->rs_ptup.t_data = NULL;
  133. scan->rs_cbuf = scan->rs_pbuf = InvalidBuffer;
  134. scan->rs_ntup.t_data = NULL;
  135. scan->rs_nbuf = UnknownBuffer;
  136. } /* invalid too */
  138. /* we don't have a marked position... */
  139. ItemPointerSetInvalid(&(scan->rs_mptid));
  140. ItemPointerSetInvalid(&(scan->rs_mctid));
  141. ItemPointerSetInvalid(&(scan->rs_mntid));
  142. ItemPointerSetInvalid(&(scan->rs_mcd));
  144. /* ----------------
  145.  * copy the scan key, if appropriate
  146.  * ----------------
  147.  */
  148. if (key != NULL)
  149. memmove(scan->rs_key, key, nkeys * sizeof(ScanKeyData));
  150. }
  152. /* ----------------
  153.  * unpinscan - code common to heap_rescan and heap_endscan
  154.  * ----------------
  155.  */
  156. static void
  157. unpinscan(HeapScanDesc scan)
  158. {
  159. if (BufferIsValid(scan->rs_pbuf))
  160. ReleaseBuffer(scan->rs_pbuf);
  162. /* ------------------------------------
  163.  * Scan will pin buffer one for each non-NULL tuple pointer
  164.  * (ptup, ctup, ntup), so they have to be unpinned multiple
  165.  * times.
  166.  * ------------------------------------
  167.  */
  168. if (BufferIsValid(scan->rs_cbuf))
  169. ReleaseBuffer(scan->rs_cbuf);
  171. if (BufferIsValid(scan->rs_nbuf))
  172. ReleaseBuffer(scan->rs_nbuf);
  173. }
  175. /* ------------------------------------------
  176.  * nextpage
  177.  *
  178.  * figure out the next page to scan after the current page
  179.  * taking into account of possible adjustment of degrees of
  180.  * parallelism
  181.  * ------------------------------------------
  182.  */
  183. static int
  184. nextpage(int page, int dir)
  185. {
  186. return (dir < 0) ? page - 1 : page + 1;
  187. }
  189. /* ----------------
  190.  * heapgettup - fetch next heap tuple
  191.  *
  192.  * routine used by heap_getnext() which does most of the
  193.  * real work in scanning tuples.
  194.  *
  195.  * The scan routines handle their own buffer lock/unlocking, so
  196.  * there is no reason to request the buffer number unless
  197.  * to want to perform some other operation with the result,
  198.  * like pass it to another function.
  199.  * ----------------
  200.  */
  201. static void
  202. heapgettup(Relation relation,
  203.    HeapTuple tuple,
  204.    int dir,
  205.    Buffer *buffer,
  206.    Snapshot snapshot,
  207.    int nkeys,
  208.    ScanKey key)
  209. {
  210. ItemId lpp;
  211. Page dp;
  212. int page;
  213. int pages;
  214. int lines;
  215. OffsetNumber lineoff;
  216. int linesleft;
  217. ItemPointer tid = (tuple->t_data == NULL) ?
  218. (ItemPointer) NULL : &(tuple->t_self);
  220. /* ----------------
  221.  * increment access statistics
  222.  * ----------------
  223.  */
  224. IncrHeapAccessStat(local_heapgettup);
  225. IncrHeapAccessStat(global_heapgettup);
  227. /* ----------------
  228.  * debugging stuff
  229.  *
  230.  * check validity of arguments, here and for other functions too
  231.  * Note: no locking manipulations needed--this is a local function
  232.  * ----------------
  233.  */
  234. #ifdef HEAPDEBUGALL
  235. if (ItemPointerIsValid(tid))
  236. {
  237. elog(DEBUG, "heapgettup(%s, tid=0x%x[%d,%d], dir=%d, ...)",
  238.  RelationGetRelationName(relation), tid, tid->ip_blkid,
  239.  tid->ip_posid, dir);
  240. }
  241. else
  242. {
  243. elog(DEBUG, "heapgettup(%s, tid=0x%x, dir=%d, ...)",
  244.  RelationGetRelationName(relation), tid, dir);
  245. }
  246. elog(DEBUG, "heapgettup(..., b=0x%x, nkeys=%d, key=0x%x", buffer, nkeys, key);
  248. elog(DEBUG, "heapgettup: relation(%c)=`%s', %p",
  249.  relation->rd_rel->relkind, &relation->rd_rel->relname,
  250.  snapshot);
  251. #endif  /* !defined(HEAPDEBUGALL) */
  253. if (!ItemPointerIsValid(tid))
  254. Assert(!PointerIsValid(tid));
  256. /* ----------------
  257.  * return null immediately if relation is empty
  258.  * ----------------
  259.  */
  260. if (!(pages = relation->rd_nblocks))
  261. {
  262. tuple->t_data = NULL;
  263. return;
  264. }
  266. /* ----------------
  267.  * calculate next starting lineoff, given scan direction
  268.  * ----------------
  269.  */
  270. if (!dir)
  271. {
  272. /* ----------------
  273.  * ``no movement'' scan direction
  274.  * ----------------
  275.  */
  276. /* assume it is a valid TID XXX */
  277. if (ItemPointerIsValid(tid) == false)
  278. {
  279. *buffer = InvalidBuffer;
  280. tuple->t_data = NULL;
  281. return;
  282. }
  283. *buffer = RelationGetBufferWithBuffer(relation,
  284.   ItemPointerGetBlockNumber(tid),
  285.   *buffer);
  287. if (!BufferIsValid(*buffer))
  288. elog(ERROR, "heapgettup: failed ReadBuffer");
  290. LockBuffer(*buffer, BUFFER_LOCK_SHARE);
  292. dp = (Page) BufferGetPage(*buffer);
  293. lineoff = ItemPointerGetOffsetNumber(tid);
  294. lpp = PageGetItemId(dp, lineoff);
  296. tuple->t_data = (HeapTupleHeader) PageGetItem((Page) dp, lpp);
  297. tuple->t_len = ItemIdGetLength(lpp);
  298. LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
  299. return;
  301. }
  302. else if (dir < 0)
  303. {
  304. /* ----------------
  305.  * reverse scan direction
  306.  * ----------------
  307.  */
  308. if (ItemPointerIsValid(tid) == false)
  309. tid = NULL;
  310. if (tid == NULL)
  311. {
  312. page = pages - 1; /* final page */
  313. }
  314. else
  315. {
  316. page = ItemPointerGetBlockNumber(tid); /* current page */
  317. }
  318. if (page < 0)
  319. {
  320. *buffer = InvalidBuffer;
  321. tuple->t_data = NULL;
  322. return;
  323. }
  325. *buffer = RelationGetBufferWithBuffer(relation, page, *buffer);
  326. if (!BufferIsValid(*buffer))
  327. elog(ERROR, "heapgettup: failed ReadBuffer");
  329. LockBuffer(*buffer, BUFFER_LOCK_SHARE);
  331. dp = (Page) BufferGetPage(*buffer);
  332. lines = PageGetMaxOffsetNumber(dp);
  333. if (tid == NULL)
  334. {
  335. lineoff = lines; /* final offnum */
  336. }
  337. else
  338. {
  339. lineoff = /* previous offnum */
  340. OffsetNumberPrev(ItemPointerGetOffsetNumber(tid));
  341. }
  342. /* page and lineoff now reference the physically previous tid */
  344. }
  345. else
  346. {
  347. /* ----------------
  348.  * forward scan direction
  349.  * ----------------
  350.  */
  351. if (ItemPointerIsValid(tid) == false)
  352. {
  353. page = 0; /* first page */
  354. lineoff = FirstOffsetNumber; /* first offnum */
  355. }
  356. else
  357. {
  358. page = ItemPointerGetBlockNumber(tid); /* current page */
  359. lineoff = /* next offnum */
  360. OffsetNumberNext(ItemPointerGetOffsetNumber(tid));
  361. }
  363. if (page >= pages)
  364. {
  365. *buffer = InvalidBuffer;
  366. tuple->t_data = NULL;
  367. return;
  368. }
  369. /* page and lineoff now reference the physically next tid */
  371. *buffer = RelationGetBufferWithBuffer(relation, page, *buffer);
  372. if (!BufferIsValid(*buffer))
  373. elog(ERROR, "heapgettup: failed ReadBuffer");
  375. LockBuffer(*buffer, BUFFER_LOCK_SHARE);
  377. dp = (Page) BufferGetPage(*buffer);
  378. lines = PageGetMaxOffsetNumber(dp);
  379. }
  381. /* 'dir' is now non-zero */
  383. /* ----------------
  384.  * calculate line pointer and number of remaining items
  385.  * to check on this page.
  386.  * ----------------
  387.  */
  388. lpp = PageGetItemId(dp, lineoff);
  389. if (dir < 0)
  390. linesleft = lineoff - 1;
  391. else
  392. linesleft = lines - lineoff;
  394. /* ----------------
  395.  * advance the scan until we find a qualifying tuple or
  396.  * run out of stuff to scan
  397.  * ----------------
  398.  */
  399. for (;;)
  400. {
  401. while (linesleft >= 0)
  402. {
  403. if (ItemIdIsUsed(lpp))
  404. {
  405. tuple->t_data = (HeapTupleHeader) PageGetItem((Page) dp, lpp);
  406. tuple->t_len = ItemIdGetLength(lpp);
  407. ItemPointerSet(&(tuple->t_self), page, lineoff);
  408. /* ----------------
  409.  * if current tuple qualifies, return it.
  410.  * ----------------
  411.  */
  412. HeapTupleSatisfies(tuple, relation, *buffer, (PageHeader) dp,
  413.    snapshot, nkeys, key);
  414. if (tuple->t_data != NULL)
  415. {
  416. LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
  417. return;
  418. }
  419. }
  421. /* ----------------
  422.  * otherwise move to the next item on the page
  423.  * ----------------
  424.  */
  425. --linesleft;
  426. if (dir < 0)
  427. {
  428. --lpp; /* move back in this page's ItemId array */
  429. --lineoff;
  430. }
  431. else
  432. {
  433. ++lpp; /* move forward in this page's ItemId
  434.  * array */
  435. ++lineoff;
  436. }
  437. }
  439. /* ----------------
  440.  * if we get here, it means we've exhausted the items on
  441.  * this page and it's time to move to the next..
  442.  * ----------------
  443.  */
  444. LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
  445. page = nextpage(page, dir);
  447. /* ----------------
  448.  * return NULL if we've exhausted all the pages..
  449.  * ----------------
  450.  */
  451. if (page < 0 || page >= pages)
  452. {
  453. if (BufferIsValid(*buffer))
  454. ReleaseBuffer(*buffer);
  455. *buffer = InvalidBuffer;
  456. tuple->t_data = NULL;
  457. return;
  458. }
  460. *buffer = ReleaseAndReadBuffer(*buffer, relation, page);
  462. if (!BufferIsValid(*buffer))
  463. elog(ERROR, "heapgettup: failed ReadBuffer");
  464. LockBuffer(*buffer, BUFFER_LOCK_SHARE);
  465. dp = (Page) BufferGetPage(*buffer);
  466. lines = PageGetMaxOffsetNumber((Page) dp);
  467. linesleft = lines - 1;
  468. if (dir < 0)
  469. {
  470. lineoff = lines;
  471. lpp = PageGetItemId(dp, lines);
  472. }
  473. else
  474. {
  475. lineoff = FirstOffsetNumber;
  476. lpp = PageGetItemId(dp, FirstOffsetNumber);
  477. }
  478. }
  479. }
  482. /* ----------------------------------------------------------------
  483.  *  heap access method interface
  484.  * ----------------------------------------------------------------
  485.  */
  486. /* ----------------
  487.  * heap_open - open a heap relation by relationId
  488.  *
  489.  * presently the relcache routines do all the work we need
  490.  * to open/close heap relations.
  491.  * ----------------
  492.  */
  493. Relation
  494. heap_open(Oid relationId)
  495. {
  496. Relation r;
  498. /* ----------------
  499.  * increment access statistics
  500.  * ----------------
  501.  */
  502. IncrHeapAccessStat(local_open);
  503. IncrHeapAccessStat(global_open);
  505. r = (Relation) RelationIdGetRelation(relationId);
  507. if (RelationIsValid(r) && r->rd_rel->relkind == RELKIND_INDEX)
  508. elog(ERROR, "%s is an index relation", r->rd_rel->relname.data);
  510. return r;
  511. }
  513. /* ----------------
  514.  * heap_openr - open a heap relation by name
  515.  *
  516.  * presently the relcache routines do all the work we need
  517.  * to open/close heap relations.
  518.  * ----------------
  519.  */
  520. Relation
  521. heap_openr(char *relationName)
  522. {
  523. Relation r;
  525. /* ----------------
  526.  * increment access statistics
  527.  * ----------------
  528.  */
  529. IncrHeapAccessStat(local_openr);
  530. IncrHeapAccessStat(global_openr);
  532. r = RelationNameGetRelation(relationName);
  534. if (RelationIsValid(r) && r->rd_rel->relkind == RELKIND_INDEX)
  535. elog(ERROR, "%s is an index relation", r->rd_rel->relname.data);
  537. return r;
  538. }
  540. /* ----------------
  541.  * heap_close - close a heap relation
  542.  *
  543.  * presently the relcache routines do all the work we need
  544.  * to open/close heap relations.
  545.  * ----------------
  546.  */
  547. void
  548. heap_close(Relation relation)
  549. {
  550. /* ----------------
  551.  * increment access statistics
  552.  * ----------------
  553.  */
  554. IncrHeapAccessStat(local_close);
  555. IncrHeapAccessStat(global_close);
  557. RelationClose(relation);
  558. }
  561. /* ----------------
  562.  * heap_beginscan - begin relation scan
  563.  * ----------------
  564.  */
  565. HeapScanDesc
  566. heap_beginscan(Relation relation,
  567.    int atend,
  568.    Snapshot snapshot,
  569.    unsigned nkeys,
  570.    ScanKey key)
  571. {
  572. HeapScanDesc scan;
  574. /* ----------------
  575.  * increment access statistics
  576.  * ----------------
  577.  */
  578. IncrHeapAccessStat(local_beginscan);
  579. IncrHeapAccessStat(global_beginscan);
  581. /* ----------------
  582.  * sanity checks
  583.  * ----------------
  584.  */
  585. if (RelationIsValid(relation) == false)
  586. elog(ERROR, "heap_beginscan: !RelationIsValid(relation)");
  588. LockRelation(relation, AccessShareLock);
  590. /* XXX someday assert SelfTimeQual if relkind == RELKIND_UNCATALOGED */
  591. if (relation->rd_rel->relkind == RELKIND_UNCATALOGED)
  592. snapshot = SnapshotSelf;
  594. /* ----------------
  595.  * increment relation ref count while scanning relation
  596.  * ----------------
  597.  */
  598. RelationIncrementReferenceCount(relation);
  600. /* ----------------
  601.  * allocate and initialize scan descriptor
  602.  * ----------------
  603.  */
  604. scan = (HeapScanDesc) palloc(sizeof(HeapScanDescData));
  606. relation->rd_nblocks = smgrnblocks(DEFAULT_SMGR, relation);
  607. scan->rs_rd = relation;
  609. if (nkeys)
  611. /*
  612.  * we do this here instead of in initscan() because heap_rescan
  613.  * also calls initscan() and we don't want to allocate memory
  614.  * again
  615.  */
  616. scan->rs_key = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
  617. else
  618. scan->rs_key = NULL;
  620. initscan(scan, relation, atend, nkeys, key);
  622. scan->rs_atend = atend;
  623. scan->rs_snapshot = snapshot;
  624. scan->rs_nkeys = (short) nkeys;
  626. return scan;
  627. }
  629. /* ----------------
  630.  * heap_rescan - restart a relation scan
  631.  * ----------------
  632.  */
  633. void
  634. heap_rescan(HeapScanDesc scan,
  635. bool scanFromEnd,
  636. ScanKey key)
  637. {
  638. /* ----------------
  639.  * increment access statistics
  640.  * ----------------
  641.  */
  642. IncrHeapAccessStat(local_rescan);
  643. IncrHeapAccessStat(global_rescan);
  645. /* Note: set relation level read lock is still set */
  647. /* ----------------
  648.  * unpin scan buffers
  649.  * ----------------
  650.  */
  651. unpinscan(scan);
  653. /* ----------------
  654.  * reinitialize scan descriptor
  655.  * ----------------
  656.  */
  657. initscan(scan, scan->rs_rd, scanFromEnd, scan->rs_nkeys, key);
  658. scan->rs_atend = (bool) scanFromEnd;
  659. }
  661. /* ----------------
  662.  * heap_endscan - end relation scan
  663.  *
  664.  * See how to integrate with index scans.
  665.  * Check handling if reldesc caching.
  666.  * ----------------
  667.  */
  668. void
  669. heap_endscan(HeapScanDesc scan)
  670. {
  671. /* ----------------
  672.  * increment access statistics
  673.  * ----------------
  674.  */
  675. IncrHeapAccessStat(local_endscan);
  676. IncrHeapAccessStat(global_endscan);
  678. /* Note: no locking manipulations needed */
  680. /* ----------------
  681.  * unpin scan buffers
  682.  * ----------------
  683.  */
  684. unpinscan(scan);
  686. /* ----------------
  687.  * decrement relation reference count and free scan descriptor storage
  688.  * ----------------
  689.  */
  690. RelationDecrementReferenceCount(scan->rs_rd);
  692. UnlockRelation(scan->rs_rd, AccessShareLock);
  694. pfree(scan); /* XXX */
  695. }
  697. /* ----------------
  698.  * heap_getnext - retrieve next tuple in scan
  699.  *
  700.  * Fix to work with index relations.
  701.  * We don't return the buffer anymore, but you can get it from the
  702.  * returned HeapTuple.
  703.  * ----------------
  704.  */
  706. #ifdef HEAPDEBUGALL
  707. #define HEAPDEBUG_1 
  708. elog(DEBUG, "heap_getnext([%s,nkeys=%d],backw=%d) called", 
  709.  scan->rs_rd->rd_rel->relname.data, scan->rs_nkeys, backw)
  711. #define HEAPDEBUG_2 
  712.  elog(DEBUG, "heap_getnext called with backw (no tracing yet)")
  714. #define HEAPDEBUG_3 
  715.  elog(DEBUG, "heap_getnext returns NULL at end")
  717. #define HEAPDEBUG_4 
  718.  elog(DEBUG, "heap_getnext valid buffer UNPIN'd")
  720. #define HEAPDEBUG_5 
  721.  elog(DEBUG, "heap_getnext next tuple was cached")
  723. #define HEAPDEBUG_6 
  724.  elog(DEBUG, "heap_getnext returning EOS")
  726. #define HEAPDEBUG_7 
  727.  elog(DEBUG, "heap_getnext returning tuple");
  728. #else
  729. #define HEAPDEBUG_1
  730. #define HEAPDEBUG_2
  731. #define HEAPDEBUG_3
  732. #define HEAPDEBUG_4
  733. #define HEAPDEBUG_5
  734. #define HEAPDEBUG_6
  735. #define HEAPDEBUG_7
  736. #endif  /* !defined(HEAPDEBUGALL) */
  739. HeapTuple
  740. heap_getnext(HeapScanDesc scandesc, int backw)
  741. {
  742. HeapScanDesc scan = scandesc;
  744. /* ----------------
  745.  * increment access statistics
  746.  * ----------------
  747.  */
  748. IncrHeapAccessStat(local_getnext);
  749. IncrHeapAccessStat(global_getnext);
  751. /* Note: no locking manipulations needed */
  753. /* ----------------
  754.  * argument checks
  755.  * ----------------
  756.  */
  757. if (scan == NULL)
  758. elog(ERROR, "heap_getnext: NULL relscan");
  760. /* ----------------
  761.  * initialize return buffer to InvalidBuffer
  762.  * ----------------
  763.  */
  765. HEAPDEBUG_1; /* heap_getnext( info ) */
  767. if (backw)
  768. {
  769. /* ----------------
  770.  * handle reverse scan
  771.  * ----------------
  772.  */
  773. HEAPDEBUG_2; /* heap_getnext called with backw */
  775. if (scan->rs_ptup.t_data == scan->rs_ctup.t_data &&
  776. BufferIsInvalid(scan->rs_pbuf))
  777. {
  778. if (BufferIsValid(scan->rs_nbuf))
  779. ReleaseBuffer(scan->rs_nbuf);
  780. return NULL;
  781. }
  783. /*
  784.  * Copy the "current" tuple/buffer to "next". Pin/unpin the
  785.  * buffers accordingly
  786.  */
  787. if (scan->rs_nbuf != scan->rs_cbuf)
  788. {
  789. if (BufferIsValid(scan->rs_nbuf))
  790. ReleaseBuffer(scan->rs_nbuf);
  791. if (BufferIsValid(scan->rs_cbuf))
  792. IncrBufferRefCount(scan->rs_cbuf);
  793. }
  794. scan->rs_ntup = scan->rs_ctup;
  795. scan->rs_nbuf = scan->rs_cbuf;
  797. if (scan->rs_ptup.t_data != NULL)
  798. {
  799. if (scan->rs_cbuf != scan->rs_pbuf)
  800. {
  801. if (BufferIsValid(scan->rs_cbuf))
  802. ReleaseBuffer(scan->rs_cbuf);
  803. if (BufferIsValid(scan->rs_pbuf))
  804. IncrBufferRefCount(scan->rs_pbuf);
  805. }
  806. scan->rs_ctup = scan->rs_ptup;
  807. scan->rs_cbuf = scan->rs_pbuf;
  808. }
  809. else
  810. { /* NONTUP */
  812. /*
  813.  * Don't release scan->rs_cbuf at this point, because
  814.  * heapgettup doesn't increase PrivateRefCount if it is
  815.  * already set. On a backward scan, both rs_ctup and rs_ntup
  816.  * usually point to the same buffer page, so
  817.  * PrivateRefCount[rs_cbuf] should be 2 (or more, if for
  818.  * instance ctup is stored in a TupleTableSlot).  - 01/09/94
  819.  */
  821. heapgettup(scan->rs_rd,
  822.    &(scan->rs_ctup),
  823.    -1,
  824.    &(scan->rs_cbuf),
  825.    scan->rs_snapshot,
  826.    scan->rs_nkeys,
  827.    scan->rs_key);
  828. }
  830. if (scan->rs_ctup.t_data == NULL && !BufferIsValid(scan->rs_cbuf))
  831. {
  832. if (BufferIsValid(scan->rs_pbuf))
  833. ReleaseBuffer(scan->rs_pbuf);
  834. scan->rs_ptup.t_data = NULL;
  835. scan->rs_pbuf = InvalidBuffer;
  836. if (BufferIsValid(scan->rs_nbuf))
  837. ReleaseBuffer(scan->rs_nbuf);
  838. scan->rs_ntup.t_data = NULL;
  839. scan->rs_nbuf = InvalidBuffer;
  840. return NULL;
  841. }
  843. if (BufferIsValid(scan->rs_pbuf))
  844. ReleaseBuffer(scan->rs_pbuf);
  845. scan->rs_ptup.t_data = NULL;
  846. scan->rs_pbuf = UnknownBuffer;
  848. }
  849. else
  850. {
  851. /* ----------------
  852.  * handle forward scan
  853.  * ----------------
  854.  */
  855. if (scan->rs_ctup.t_data == scan->rs_ntup.t_data &&
  856. BufferIsInvalid(scan->rs_nbuf))
  857. {
  858. if (BufferIsValid(scan->rs_pbuf))
  859. ReleaseBuffer(scan->rs_pbuf);
  860. HEAPDEBUG_3; /* heap_getnext returns NULL at end */
  861. return NULL;
  862. }
  864. /*
  865.  * Copy the "current" tuple/buffer to "previous". Pin/unpin the
  866.  * buffers accordingly
  867.  */
  868. if (scan->rs_pbuf != scan->rs_cbuf)
  869. {
  870. if (BufferIsValid(scan->rs_pbuf))
  871. ReleaseBuffer(scan->rs_pbuf);
  872. if (BufferIsValid(scan->rs_cbuf))
  873. IncrBufferRefCount(scan->rs_cbuf);
  874. }
  875. scan->rs_ptup = scan->rs_ctup;
  876. scan->rs_pbuf = scan->rs_cbuf;
  878. if (scan->rs_ntup.t_data != NULL)
  879. {
  880. if (scan->rs_cbuf != scan->rs_nbuf)
  881. {
  882. if (BufferIsValid(scan->rs_cbuf))
  883. ReleaseBuffer(scan->rs_cbuf);
  884. if (BufferIsValid(scan->rs_nbuf))
  885. IncrBufferRefCount(scan->rs_nbuf);
  886. }
  887. scan->rs_ctup = scan->rs_ntup;
  888. scan->rs_cbuf = scan->rs_nbuf;
  889. HEAPDEBUG_5; /* heap_getnext next tuple was cached */
  890. }
  891. else
  892. { /* NONTUP */
  894. /*
  895.  * Don't release scan->rs_cbuf at this point, because
  896.  * heapgettup doesn't increase PrivateRefCount if it is
  897.  * already set. On a forward scan, both rs_ctup and rs_ptup
  898.  * usually point to the same buffer page, so
  899.  * PrivateRefCount[rs_cbuf] should be 2 (or more, if for
  900.  * instance ctup is stored in a TupleTableSlot).  - 01/09/93
  901.  */
  903. heapgettup(scan->rs_rd,
  904.    &(scan->rs_ctup),
  905.    1,
  906.    &scan->rs_cbuf,
  907.    scan->rs_snapshot,
  908.    scan->rs_nkeys,
  909.    scan->rs_key);
  910. }
  912. if (scan->rs_ctup.t_data == NULL && !BufferIsValid(scan->rs_cbuf))
  913. {
  914. if (BufferIsValid(scan->rs_nbuf))
  915. ReleaseBuffer(scan->rs_nbuf);
  916. scan->rs_ntup.t_data = NULL;
  917. scan->rs_nbuf = InvalidBuffer;
  918. if (BufferIsValid(scan->rs_pbuf))
  919. ReleaseBuffer(scan->rs_pbuf);
  920. scan->rs_ptup.t_data = NULL;
  921. scan->rs_pbuf = InvalidBuffer;
  922. HEAPDEBUG_6; /* heap_getnext returning EOS */
  923. return NULL;
  924. }
  926. if (BufferIsValid(scan->rs_nbuf))
  927. ReleaseBuffer(scan->rs_nbuf);
  928. scan->rs_ntup.t_data = NULL;
  929. scan->rs_nbuf = UnknownBuffer;
  930. }
  932. /* ----------------
  933.  * if we get here it means we have a new current scan tuple, so
  934.  * point to the proper return buffer and return the tuple.
  935.  * ----------------
  936.  */
  938. HEAPDEBUG_7; /* heap_getnext returning tuple */
  940. return ((scan->rs_ctup.t_data == NULL) ? NULL : &(scan->rs_ctup));
  941. }
  943. /* ----------------
  944.  * heap_fetch - retrive tuple with tid
  945.  *
  946.  * Currently ignores LP_IVALID during processing!
  947.  *
  948.  * Because this is not part of a scan, there is no way to
  949.  * automatically lock/unlock the shared buffers.
  950.  * For this reason, we require that the user retrieve the buffer
  951.  * value, and they are required to BufferRelease() it when they
  952.  * are done.  If they want to make a copy of it before releasing it,
  953.  * they can call heap_copytyple().
  954.  * ----------------
  955.  */
  956. void
  957. heap_fetch(Relation relation,
  958.    Snapshot snapshot,
  959.    HeapTuple tuple,
  960.    Buffer *userbuf)
  961. {
  962. ItemId lp;
  963. Buffer buffer;
  964. PageHeader dp;
  965. ItemPointer tid = &(tuple->t_self);
  966. OffsetNumber offnum;
  968. AssertMacro(PointerIsValid(userbuf)); /* see comments above */
  970. /* ----------------
  971.  * increment access statistics
  972.  * ----------------
  973.  */
  974. IncrHeapAccessStat(local_fetch);
  975. IncrHeapAccessStat(global_fetch);
  977. /* ----------------
  978.  * get the buffer from the relation descriptor
  979.  * Note that this does a buffer pin.
  980.  * ----------------
  981.  */
  983. buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
  985. if (!BufferIsValid(buffer))
  986. elog(ERROR, "heap_fetch: %s relation: ReadBuffer(%lx) failed",
  987.  &relation->rd_rel->relname, (long) tid);
  989. LockBuffer(buffer, BUFFER_LOCK_SHARE);
  991. /* ----------------
  992.  * get the item line pointer corresponding to the requested tid
  993.  * ----------------
  994.  */
  995. dp = (PageHeader) BufferGetPage(buffer);
  996. offnum = ItemPointerGetOffsetNumber(tid);
  997. lp = PageGetItemId(dp, offnum);
  999. /* ----------------
  1000.  * more sanity checks
  1001.  * ----------------
  1002.  */
  1004. Assert(ItemIdIsUsed(lp));
  1006. tuple->t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
  1007. tuple->t_len = ItemIdGetLength(lp);
  1009. /* ----------------
  1010.  * check time qualification of tid
  1011.  * ----------------
  1012.  */
  1014. HeapTupleSatisfies(tuple, relation, buffer, dp,
  1015.    snapshot, 0, (ScanKey) NULL);
  1017. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1019. if (tuple->t_data == NULL)
  1020. {
  1021. ReleaseBuffer(buffer);
  1022. return;
  1023. }
  1025. /* ----------------
  1026.  * all checks passed, now either return a copy of the tuple
  1027.  * or pin the buffer page and return a pointer, depending on
  1028.  * whether caller gave us a valid buf.
  1029.  * ----------------
  1030.  */
  1032. *userbuf = buffer; /* user is required to ReleaseBuffer()
  1033.  * this */
  1035. return;
  1036. }
  1038. /* ----------------
  1039.  * heap_insert - insert tuple
  1040.  *
  1041.  * The assignment of t_min (and thus the others) should be
  1042.  * removed eventually.
  1043.  *
  1044.  * Currently places the tuple onto the last page. If there is no room,
  1045.  * it is placed on new pages. (Heap relations)
  1046.  * Note that concurrent inserts during a scan will probably have
  1047.  * unexpected results, though this will be fixed eventually.
  1048.  *
  1049.  * Fix to work with indexes.
  1050.  * ----------------
  1051.  */
  1052. Oid
  1053. heap_insert(Relation relation, HeapTuple tup)
  1054. {
  1055. /* ----------------
  1056.  * increment access statistics
  1057.  * ----------------
  1058.  */
  1059. IncrHeapAccessStat(local_insert);
  1060. IncrHeapAccessStat(global_insert);
  1062. /* ----------------
  1063.  * If the object id of this tuple has already been assigned, trust
  1064.  * the caller.  There are a couple of ways this can happen.  At initial
  1065.  * db creation, the backend program sets oids for tuples. When we
  1066.  * define an index, we set the oid.  Finally, in the future, we may
  1067.  * allow users to set their own object ids in order to support a
  1068.  * persistent object store (objects need to contain pointers to one
  1069.  * another).
  1070.  * ----------------
  1071.  */
  1072. if (!OidIsValid(tup->t_data->t_oid))
  1073. {
  1074. tup->t_data->t_oid = newoid();
  1075. LastOidProcessed = tup->t_data->t_oid;
  1076. }
  1077. else
  1078. CheckMaxObjectId(tup->t_data->t_oid);
  1080. TransactionIdStore(GetCurrentTransactionId(), &(tup->t_data->t_xmin));
  1081. tup->t_data->t_cmin = GetCurrentCommandId();
  1082. StoreInvalidTransactionId(&(tup->t_data->t_xmax));
  1083. tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
  1084. tup->t_data->t_infomask |= HEAP_XMAX_INVALID;
  1086. RelationPutHeapTupleAtEnd(relation, tup);
  1088. if (IsSystemRelationName(RelationGetRelationName(relation)->data))
  1089. RelationInvalidateHeapTuple(relation, tup);
  1091. return tup->t_data->t_oid;
  1092. }
  1094. /*
  1095.  * heap_delete - delete a tuple
  1096.  */
  1097. int
  1098. heap_delete(Relation relation, ItemPointer tid, ItemPointer ctid)
  1099. {
  1100. ItemId lp;
  1101. HeapTupleData tp;
  1102. PageHeader dp;
  1103. Buffer buffer;
  1104. int result;
  1106. /* increment access statistics */
  1107. IncrHeapAccessStat(local_delete);
  1108. IncrHeapAccessStat(global_delete);
  1110. Assert(ItemPointerIsValid(tid));
  1112. buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
  1114. if (!BufferIsValid(buffer))
  1115. elog(ERROR, "heap_delete: failed ReadBuffer");
  1117. LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
  1119. dp = (PageHeader) BufferGetPage(buffer);
  1120. lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
  1121. tp.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
  1122. tp.t_len = ItemIdGetLength(lp);
  1123. tp.t_self = *tid;
  1125. l1:
  1126. result = HeapTupleSatisfiesUpdate(&tp);
  1128. if (result == HeapTupleInvisible)
  1129. {
  1130. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1131. ReleaseBuffer(buffer);
  1132. elog(ERROR, "heap_delete: (am)invalid tid");
  1133. }
  1134. else if (result == HeapTupleBeingUpdated)
  1135. {
  1136. TransactionId xwait = tp.t_data->t_xmax;
  1138. /* sleep until concurrent transaction ends */
  1139. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1140. XactLockTableWait(xwait);
  1142. LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
  1143. if (TransactionIdDidAbort(xwait))
  1144. goto l1;
  1145. /* 
  1146.  * xwait is committed but if xwait had just marked
  1147.  * the tuple for update then some other xaction could 
  1148.  * update this tuple before we got to this point.
  1149.  */
  1150. if (tp.t_data->t_xmax != xwait)
  1151. goto l1;
  1152. if (!(tp.t_data->t_infomask & HEAP_XMAX_COMMITTED))
  1153. {
  1154. tp.t_data->t_infomask |= HEAP_XMAX_COMMITTED;
  1155. SetBufferCommitInfoNeedsSave(buffer);
  1156. }
  1157. /* if tuple was marked for update but not updated... */
  1158. if (tp.t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
  1159. result = HeapTupleMayBeUpdated;
  1160. else
  1161. result = HeapTupleUpdated;
  1162. }
  1163. if (result != HeapTupleMayBeUpdated)
  1164. {
  1165. Assert(result == HeapTupleSelfUpdated || result == HeapTupleUpdated);
  1166. if (ctid != NULL)
  1167. *ctid = tp.t_data->t_ctid;
  1168. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1169. ReleaseBuffer(buffer);
  1170. return result;
  1171. }
  1173. /* store transaction information of xact deleting the tuple */
  1174. TransactionIdStore(GetCurrentTransactionId(), &(tp.t_data->t_xmax));
  1175. tp.t_data->t_cmax = GetCurrentCommandId();
  1176. tp.t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED |
  1177.  HEAP_XMAX_INVALID | HEAP_MARKED_FOR_UPDATE);
  1179. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1181. /* invalidate caches */
  1182. RelationInvalidateHeapTuple(relation, &tp);
  1184. WriteBuffer(buffer);
  1186. return HeapTupleMayBeUpdated;
  1187. }
  1189. /*
  1190.  * heap_replace - replace a tuple
  1191.  */
  1192. int
  1193. heap_replace(Relation relation, ItemPointer otid, HeapTuple newtup,
  1194.  ItemPointer ctid)
  1195. {
  1196. ItemId lp;
  1197. HeapTupleData oldtup;
  1198. PageHeader dp;
  1199. Buffer buffer;
  1200. int result;
  1202. /* increment access statistics */
  1203. IncrHeapAccessStat(local_replace);
  1204. IncrHeapAccessStat(global_replace);
  1206. Assert(ItemPointerIsValid(otid));
  1208. buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(otid));
  1209. if (!BufferIsValid(buffer))
  1210. elog(ERROR, "amreplace: failed ReadBuffer");
  1211. LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
  1213. dp = (PageHeader) BufferGetPage(buffer);
  1214. lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(otid));
  1216. oldtup.t_data = (HeapTupleHeader) PageGetItem(dp, lp);
  1217. oldtup.t_len = ItemIdGetLength(lp);
  1218. oldtup.t_self = *otid;
  1220. l2:
  1221. result = HeapTupleSatisfiesUpdate(&oldtup);
  1223. if (result == HeapTupleInvisible)
  1224. {
  1225. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1226. ReleaseBuffer(buffer);
  1227. elog(ERROR, "heap_replace: (am)invalid tid");
  1228. }
  1229. else if (result == HeapTupleBeingUpdated)
  1230. {
  1231. TransactionId xwait = oldtup.t_data->t_xmax;
  1233. /* sleep untill concurrent transaction ends */
  1234. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1235. XactLockTableWait(xwait);
  1237. LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
  1238. if (TransactionIdDidAbort(xwait))
  1239. goto l2;
  1240. /* 
  1241.  * xwait is committed but if xwait had just marked
  1242.  * the tuple for update then some other xaction could 
  1243.  * update this tuple before we got to this point.
  1244.  */
  1245. if (oldtup.t_data->t_xmax != xwait)
  1246. goto l2;
  1247. if (!(oldtup.t_data->t_infomask & HEAP_XMAX_COMMITTED))
  1248. {
  1249. oldtup.t_data->t_infomask |= HEAP_XMAX_COMMITTED;
  1250. SetBufferCommitInfoNeedsSave(buffer);
  1251. }
  1252. /* if tuple was marked for update but not updated... */
  1253. if (oldtup.t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
  1254. result = HeapTupleMayBeUpdated;
  1255. else
  1256. result = HeapTupleUpdated;
  1257. }
  1258. if (result != HeapTupleMayBeUpdated)
  1259. {
  1260. Assert(result == HeapTupleSelfUpdated || result == HeapTupleUpdated);
  1261. if (ctid != NULL)
  1262. *ctid = oldtup.t_data->t_ctid;
  1263. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1264. ReleaseBuffer(buffer);
  1265. return result;
  1266. }
  1268. /* XXX order problems if not atomic assignment ??? */
  1269. newtup->t_data->t_oid = oldtup.t_data->t_oid;
  1270. TransactionIdStore(GetCurrentTransactionId(), &(newtup->t_data->t_xmin));
  1271. newtup->t_data->t_cmin = GetCurrentCommandId();
  1272. StoreInvalidTransactionId(&(newtup->t_data->t_xmax));
  1273. newtup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
  1274. newtup->t_data->t_infomask |= (HEAP_XMAX_INVALID | HEAP_UPDATED);
  1276. /* logically delete old item */
  1277. TransactionIdStore(GetCurrentTransactionId(), &(oldtup.t_data->t_xmax));
  1278. oldtup.t_data->t_cmax = GetCurrentCommandId();
  1279. oldtup.t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED |
  1280.  HEAP_XMAX_INVALID | HEAP_MARKED_FOR_UPDATE);
  1282. /* insert new item */
  1283. if ((unsigned) MAXALIGN(newtup->t_len) <= PageGetFreeSpace((Page) dp))
  1284. RelationPutHeapTuple(relation, buffer, newtup);
  1285. else
  1286. {
  1288. /*
  1289.  * New item won't fit on same page as old item, have to look for a
  1290.  * new place to put it. Note that we have to unlock current buffer
  1291.  * context - not good but RelationPutHeapTupleAtEnd uses extend
  1292.  * lock.
  1293.  */
  1294. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1295. RelationPutHeapTupleAtEnd(relation, newtup);
  1296. LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
  1297. }
  1299. /*
  1300.  * New item in place, now record address of new tuple in t_ctid of old
  1301.  * one.
  1302.  */
  1303. oldtup.t_data->t_ctid = newtup->t_self;
  1305. LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
  1307. /* invalidate caches */
  1308. RelationInvalidateHeapTuple(relation, &oldtup);
  1310. WriteBuffer(buffer);
  1312. return HeapTupleMayBeUpdated;
  1313. }
  1315. /*
  1316.  * heap_mark4update - mark a tuple for update
  1317.  */
  1318. int
  1319. heap_mark4update(Relation relation, HeapTuple tuple, Buffer *buffer)
  1320. {
  1321. ItemPointer tid = &(tuple->t_self);
  1322. ItemId lp;
  1323. PageHeader dp;
  1324. int result;
  1326. /* increment access statistics */
  1327. IncrHeapAccessStat(local_mark4update);
  1328. IncrHeapAccessStat(global_mark4update);
  1330. *buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
  1332. if (!BufferIsValid(*buffer))
  1333. elog(ERROR, "heap_mark4update: failed ReadBuffer");
  1335. LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
  1337. dp = (PageHeader) BufferGetPage(*buffer);
  1338. lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
  1339. tuple->t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
  1340. tuple->t_len = ItemIdGetLength(lp);
  1342. l3:
  1343. result = HeapTupleSatisfiesUpdate(tuple);
  1345. if (result == HeapTupleInvisible)
  1346. {
  1347. LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
  1348. ReleaseBuffer(*buffer);
  1349. elog(ERROR, "heap_mark4update: (am)invalid tid");
  1350. }
  1351. else if (result == HeapTupleBeingUpdated)
  1352. {
  1353. TransactionId xwait = tuple->t_data->t_xmax;
  1355. /* sleep untill concurrent transaction ends */
  1356. LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
  1357. XactLockTableWait(xwait);
  1359. LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
  1360. if (TransactionIdDidAbort(xwait))
  1361. goto l3;
  1362. /* 
  1363.  * xwait is committed but if xwait had just marked
  1364.  * the tuple for update then some other xaction could 
  1365.  * update this tuple before we got to this point.
  1366.  */
  1367. if (tuple->t_data->t_xmax != xwait)
  1368. goto l3;
  1369. if (!(tuple->t_data->t_infomask & HEAP_XMAX_COMMITTED))
  1370. {
  1371. tuple->t_data->t_infomask |= HEAP_XMAX_COMMITTED;
  1372. SetBufferCommitInfoNeedsSave(*buffer);
  1373. }
  1374. /* if tuple was marked for update but not updated... */
  1375. if (tuple->t_data->t_infomask & HEAP_MARKED_FOR_UPDATE)
  1376. result = HeapTupleMayBeUpdated;
  1377. else
  1378. result = HeapTupleUpdated;
  1379. }
  1380. if (result != HeapTupleMayBeUpdated)
  1381. {
  1382. Assert(result == HeapTupleSelfUpdated || result == HeapTupleUpdated);
  1383. tuple->t_self = tuple->t_data->t_ctid;
  1384. LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
  1385. return result;
  1386. }
  1388. /* store transaction information of xact marking the tuple */
  1389. TransactionIdStore(GetCurrentTransactionId(), &(tuple->t_data->t_xmax));
  1390. tuple->t_data->t_cmax = GetCurrentCommandId();
  1391. tuple->t_data->t_infomask &= ~(HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID);
  1392. tuple->t_data->t_infomask |= HEAP_MARKED_FOR_UPDATE;
  1394. LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
  1396. WriteNoReleaseBuffer(*buffer);
  1398. return HeapTupleMayBeUpdated;
  1399. }
  1401. /* ----------------
  1402.  * heap_markpos - mark scan position
  1403.  *
  1404.  * Note:
  1405.  * Should only one mark be maintained per scan at one time.
  1406.  * Check if this can be done generally--say calls to get the
  1407.  * next/previous tuple and NEVER pass struct scandesc to the
  1408.  * user AM's.  Now, the mark is sent to the executor for safekeeping.
  1409.  * Probably can store this info into a GENERAL scan structure.
  1410.  *
  1411.  * May be best to change this call to store the marked position
  1412.  * (up to 2?) in the scan structure itself.
  1413.  * Fix to use the proper caching structure.
  1414.  * ----------------
  1415.  */
  1416. void
  1417. heap_markpos(HeapScanDesc scan)
  1418. {
  1420. /* ----------------
  1421.  * increment access statistics
  1422.  * ----------------
  1423.  */
  1424. IncrHeapAccessStat(local_markpos);
  1425. IncrHeapAccessStat(global_markpos);
  1427. /* Note: no locking manipulations needed */
  1429. if (scan->rs_ptup.t_data == NULL &&
  1430. BufferIsUnknown(scan->rs_pbuf))
  1431. { /* == NONTUP */
  1432. scan->rs_ptup = scan->rs_ctup;
  1433. heapgettup(scan->rs_rd,
  1434.    &(scan->rs_ptup),
  1435.    -1,
  1436.    &scan->rs_pbuf,
  1437.    scan->rs_snapshot,
  1438.    scan->rs_nkeys,
  1439.    scan->rs_key);
  1441. }
  1442. else if (scan->rs_ntup.t_data == NULL &&
  1443.  BufferIsUnknown(scan->rs_nbuf))
  1444. { /* == NONTUP */
  1445. scan->rs_ntup = scan->rs_ctup;
  1446. heapgettup(scan->rs_rd,
  1447.    &(scan->rs_ntup),
  1448.    1,
  1449.    &scan->rs_nbuf,
  1450.    scan->rs_snapshot,
  1451.    scan->rs_nkeys,
  1452.    scan->rs_key);
  1453. }
  1455. /* ----------------
  1456.  * Should not unpin the buffer pages.  They may still be in use.
  1457.  * ----------------
  1458.  */
  1459. if (scan->rs_ptup.t_data != NULL)
  1460. scan->rs_mptid = scan->rs_ptup.t_self;
  1461. else
  1462. ItemPointerSetInvalid(&scan->rs_mptid);
  1463. if (scan->rs_ctup.t_data != NULL)
  1464. scan->rs_mctid = scan->rs_ctup.t_self;
  1465. else
  1466. ItemPointerSetInvalid(&scan->rs_mctid);
  1467. if (scan->rs_ntup.t_data != NULL)
  1468. scan->rs_mntid = scan->rs_ntup.t_self;
  1469. else
  1470. ItemPointerSetInvalid(&scan->rs_mntid);
  1471. }
  1473. /* ----------------
  1474.  * heap_restrpos - restore position to marked location
  1475.  *
  1476.  * Note:  there are bad side effects here.  If we were past the end
  1477.  * of a relation when heapmarkpos is called, then if the relation is
  1478.  * extended via insert, then the next call to heaprestrpos will set
  1479.  * cause the added tuples to be visible when the scan continues.
  1480.  * Problems also arise if the TID's are rearranged!!!
  1481.  *
  1482.  * Now pins buffer once for each valid tuple pointer (rs_ptup,
  1483.  * rs_ctup, rs_ntup) referencing it.
  1484.  *  - 01/13/94
  1485.  *
  1486.  * XXX might be better to do direct access instead of
  1487.  * using the generality of heapgettup().
  1488.  *
  1489.  * XXX It is very possible that when a scan is restored, that a tuple
  1490.  * XXX which previously qualified may fail for time range purposes, unless
  1491.  * XXX some form of locking exists (ie., portals currently can act funny.
  1492.  * ----------------
  1493.  */
  1494. void
  1495. heap_restrpos(HeapScanDesc scan)
  1496. {
  1497. /* ----------------
  1498.  * increment access statistics
  1499.  * ----------------
  1500.  */
  1501. IncrHeapAccessStat(local_restrpos);
  1502. IncrHeapAccessStat(global_restrpos);
  1504. /* XXX no amrestrpos checking that ammarkpos called */
  1506. /* Note: no locking manipulations needed */
  1508. unpinscan(scan);
  1510. /* force heapgettup to pin buffer for each loaded tuple */
  1511. scan->rs_pbuf = InvalidBuffer;
  1512. scan->rs_cbuf = InvalidBuffer;
  1513. scan->rs_nbuf = InvalidBuffer;
  1515. if (!ItemPointerIsValid(&scan->rs_mptid))
  1516. scan->rs_ptup.t_data = NULL;
  1517. else
  1518. {
  1519. scan->rs_ptup.t_self = scan->rs_mptid;
  1520. scan->rs_ptup.t_data = (HeapTupleHeader) 0x1; /* for heapgettup */
  1521. heapgettup(scan->rs_rd,
  1522.    &(scan->rs_ptup),
  1523.    0,
  1524.    &(scan->rs_pbuf),
  1525.    false,
  1526.    0,
  1527.    (ScanKey) NULL);
  1528. }
  1530. if (!ItemPointerIsValid(&scan->rs_mctid))
  1531. scan->rs_ctup.t_data = NULL;
  1532. else
  1533. {
  1534. scan->rs_ctup.t_self = scan->rs_mctid;
  1535. scan->rs_ctup.t_data = (HeapTupleHeader) 0x1; /* for heapgettup */
  1536. heapgettup(scan->rs_rd,
  1537.    &(scan->rs_ctup),
  1538.    0,
  1539.    &(scan->rs_cbuf),
  1540.    false,
  1541.    0,
  1542.    (ScanKey) NULL);
  1543. }
  1545. if (!ItemPointerIsValid(&scan->rs_mntid))
  1546. scan->rs_ntup.t_data = NULL;
  1547. else
  1548. {
  1549. scan->rs_ntup.t_self = scan->rs_mntid;
  1550. scan->rs_ntup.t_data = (HeapTupleHeader) 0x1; /* for heapgettup */
  1551. heapgettup(scan->rs_rd,
  1552.    &(scan->rs_ntup),
  1553.    0,
  1554.    &scan->rs_nbuf,
  1555.    false,
  1556.    0,
  1557.    (ScanKey) NULL);
  1558. }
  1559. }