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

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

数据库系统

开发平台：

Unix_Linux

gist.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * gist.c
  4.  *   interface routines for the postgres GiST index access method.
  5.  *
  6.  *
  7.  *
  8.  * IDENTIFICATION
  9.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.38.2.1 1999/08/02 05:24:28 scrappy Exp $
  10.  *
  11.  *-------------------------------------------------------------------------
  12.  */
  14. #include "postgres.h"
  16. #include "access/genam.h"
  17. #include "access/gist.h"
  18. #include "access/gistscan.h"
  19. #include "access/heapam.h"
  20. #include "catalog/index.h"
  21. #include "catalog/pg_index.h"
  22. #include "executor/executor.h"
  23. #include "utils/syscache.h"
  26. /* non-export function prototypes */
  27. static InsertIndexResult gistdoinsert(Relation r, IndexTuple itup,
  28.  GISTSTATE *GISTstate);
  29. static InsertIndexResult gistentryinsert(Relation r, GISTSTACK *stk,
  30. IndexTuple tup,
  31. GISTSTATE *giststate);
  32. static void gistentryinserttwo(Relation r, GISTSTACK *stk, IndexTuple ltup,
  33.    IndexTuple rtup, GISTSTATE *giststate);
  34. static void gistAdjustKeys(Relation r, GISTSTACK *stk, BlockNumber blk,
  35.    char *datum, int att_size, GISTSTATE *giststate);
  36. static void gistintinsert(Relation r, GISTSTACK *stk, IndexTuple ltup,
  37.   IndexTuple rtup, GISTSTATE *giststate);
  38. static InsertIndexResult gistSplit(Relation r, Buffer buffer,
  39.   GISTSTACK *stack, IndexTuple itup,
  40.   GISTSTATE *giststate);
  41. static void gistnewroot(GISTSTATE *giststate, Relation r, IndexTuple lt,
  42. IndexTuple rt);
  43. static void GISTInitBuffer(Buffer b, uint32 f);
  44. static BlockNumber gistChooseSubtree(Relation r, IndexTuple itup, int level,
  45.   GISTSTATE *giststate,
  46.   GISTSTACK **retstack, Buffer *leafbuf);
  47. static OffsetNumber gistchoose(Relation r, Page p, IndexTuple it,
  48.    GISTSTATE *giststate);
  49. static int gistnospace(Page p, IndexTuple it);
  50. void gistdelete(Relation r, ItemPointer tid);
  51. static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t);
  52. static void gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
  53.    Relation r, Page pg, OffsetNumber o, int b, bool l);
  54. #ifdef GISTDEBUG
  55. static char *int_range_out(INTRANGE *r);
  56. #endif
  58. /*
  59. ** routine to build an index.  Basically calls insert over and over
  60. */
  61. void
  62. gistbuild(Relation heap,
  63.   Relation index,
  64.   int natts,
  65.   AttrNumber *attnum,
  66.   IndexStrategy istrat,
  67.   uint16 pint,
  68.   Datum *params,
  69.   FuncIndexInfo *finfo,
  70.   PredInfo *predInfo)
  71. {
  72. HeapScanDesc scan;
  73. AttrNumber i;
  74. HeapTuple htup;
  75. IndexTuple itup;
  76. TupleDesc hd,
  77. id;
  78. InsertIndexResult res;
  79. Datum    *d;
  80. bool    *nulls;
  81. int nb,
  82. nh,
  83. ni;
  85. #ifndef OMIT_PARTIAL_INDEX
  86. ExprContext *econtext;
  87. TupleTable tupleTable;
  88. TupleTableSlot *slot;
  90. #endif
  91. Oid hrelid,
  92. irelid;
  93. Node    *pred,
  94.    *oldPred;
  95. GISTSTATE giststate;
  96. GISTENTRY tmpcentry;
  97. Buffer buffer = InvalidBuffer;
  98. bool    *compvec;
  100. /* no locking is needed */
  102. setheapoverride(true); /* so we can see the new pg_index tuple */
  103. initGISTstate(&giststate, index);
  104. setheapoverride(false);
  106. pred = predInfo->pred;
  107. oldPred = predInfo->oldPred;
  109. /*
  110.  * We expect to be called exactly once for any index relation. If
  111.  * that's not the case, big trouble's what we have.
  112.  */
  114. if (oldPred == NULL && (nb = RelationGetNumberOfBlocks(index)) != 0)
  115. elog(ERROR, "%s already contains data", index->rd_rel->relname.data);
  117. /* initialize the root page (if this is a new index) */
  118. if (oldPred == NULL)
  119. {
  120. buffer = ReadBuffer(index, P_NEW);
  121. GISTInitBuffer(buffer, F_LEAF);
  122. WriteBuffer(buffer);
  123. }
  125. /* init the tuple descriptors and get set for a heap scan */
  126. hd = RelationGetDescr(heap);
  127. id = RelationGetDescr(index);
  128. d = (Datum *) palloc(natts * sizeof(*d));
  129. nulls = (bool *) palloc(natts * sizeof(*nulls));
  131. /*
  132.  * If this is a predicate (partial) index, we will need to evaluate
  133.  * the predicate using ExecQual, which requires the current tuple to
  134.  * be in a slot of a TupleTable.  In addition, ExecQual must have an
  135.  * ExprContext referring to that slot. Here, we initialize dummy
  136.  * TupleTable and ExprContext objects for this purpose. --Nels, Feb
  137.  * '92
  138.  */
  139. #ifndef OMIT_PARTIAL_INDEX
  140. if (pred != NULL || oldPred != NULL)
  141. {
  142. tupleTable = ExecCreateTupleTable(1);
  143. slot = ExecAllocTableSlot(tupleTable);
  144. econtext = makeNode(ExprContext);
  145. FillDummyExprContext(econtext, slot, hd, buffer);
  146. }
  147. else
  148. /* shut the compiler up */
  149. {
  150. tupleTable = NULL;
  151. slot = NULL;
  152. econtext = NULL;
  153. }
  154. #endif  /* OMIT_PARTIAL_INDEX */
  155. /* int the tuples as we insert them */
  156. nh = ni = 0;
  158. scan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
  160. while (HeapTupleIsValid(htup = heap_getnext(scan, 0)))
  161. {
  162. nh++;
  164. /*
  165.  * If oldPred != NULL, this is an EXTEND INDEX command, so skip
  166.  * this tuple if it was already in the existing partial index
  167.  */
  168. if (oldPred != NULL)
  169. {
  170. #ifndef OMIT_PARTIAL_INDEX
  171. /* SetSlotContents(slot, htup); */
  172. slot->val = htup;
  173. if (ExecQual((List *) oldPred, econtext) == true)
  174. {
  175. ni++;
  176. continue;
  177. }
  178. #endif  /* OMIT_PARTIAL_INDEX */
  179. }
  181. /*
  182.  * Skip this tuple if it doesn't satisfy the partial-index
  183.  * predicate
  184.  */
  185. if (pred != NULL)
  186. {
  187. #ifndef OMIT_PARTIAL_INDEX
  188. /* SetSlotContents(slot, htup); */
  189. slot->val = htup;
  190. if (ExecQual((List *) pred, econtext) == false)
  191. continue;
  192. #endif  /* OMIT_PARTIAL_INDEX */
  193. }
  195. ni++;
  197. /*
  198.  * For the current heap tuple, extract all the attributes we use
  199.  * in this index, and note which are null.
  200.  */
  202. for (i = 1; i <= natts; i++)
  203. {
  204. int attoff;
  205. bool attnull;
  207. /*
  208.  * Offsets are from the start of the tuple, and are
  209.  * zero-based; indices are one-based.  The next call returns i
  210.  * - 1.  That's data hiding for you.
  211.  */
  213. attoff = AttrNumberGetAttrOffset(i);
  215. /*
  216.  * d[attoff] = HeapTupleGetAttributeValue(htup, buffer,
  217.  */
  218. d[attoff] = GetIndexValue(htup,
  219.   hd,
  220.   attoff,
  221.   attnum,
  222.   finfo,
  223.   &attnull);
  224. nulls[attoff] = (attnull ? 'n' : ' ');
  225. }
  227. /* immediately compress keys to normalize */
  228. compvec = (bool *) palloc(sizeof(bool) * natts);
  229. for (i = 0; i < natts; i++)
  230. {
  231. gistcentryinit(&giststate, &tmpcentry, (char *) d[i],
  232.    (Relation) NULL, (Page) NULL, (OffsetNumber) 0,
  233.    -1 /* size is currently bogus */ , TRUE);
  234. if (d[i] != (Datum) tmpcentry.pred && !(giststate.keytypbyval))
  235. compvec[i] = TRUE;
  236. else
  237. compvec[i] = FALSE;
  238. d[i] = (Datum) tmpcentry.pred;
  239. }
  241. /* form an index tuple and point it at the heap tuple */
  242. itup = index_formtuple(id, &d[0], nulls);
  243. itup->t_tid = htup->t_self;
  245. /*
  246.  * Since we already have the index relation locked, we call
  247.  * gistdoinsert directly.  Normal access method calls dispatch
  248.  * through gistinsert, which locks the relation for write. This
  249.  * is the right thing to do if you're inserting single tups, but
  250.  * not when you're initializing the whole index at once.
  251.  */
  253. res = gistdoinsert(index, itup, &giststate);
  254. for (i = 0; i < natts; i++)
  255. if (compvec[i] == TRUE)
  256. pfree((char *) d[i]);
  257. pfree(itup);
  258. pfree(res);
  259. pfree(compvec);
  260. }
  262. /* okay, all heap tuples are indexed */
  263. heap_endscan(scan);
  265. if (pred != NULL || oldPred != NULL)
  266. {
  267. #ifndef OMIT_PARTIAL_INDEX
  268. ExecDestroyTupleTable(tupleTable, true);
  269. pfree(econtext);
  270. #endif  /* OMIT_PARTIAL_INDEX */
  271. }
  273. /*
  274.  * Since we just inted the tuples in the heap, we update its stats in
  275.  * pg_relation to guarantee that the planner takes advantage of the
  276.  * index we just created.  UpdateStats() does a
  277.  * CommandinterIncrement(), which flushes changed entries from the
  278.  * system relcache.  The act of constructing an index changes these
  279.  * heap and index tuples in the system catalogs, so they need to be
  280.  * flushed.  We close them to guarantee that they will be.
  281.  */
  283. hrelid = RelationGetRelid(heap);
  284. irelid = RelationGetRelid(index);
  285. heap_close(heap);
  286. index_close(index);
  288. UpdateStats(hrelid, nh, true);
  289. UpdateStats(irelid, ni, false);
  291. if (oldPred != NULL)
  292. {
  293. if (ni == nh)
  294. pred = NULL;
  295. UpdateIndexPredicate(irelid, oldPred, pred);
  296. }
  298. /* be tidy */
  299. pfree(nulls);
  300. pfree(d);
  301. }
  303. /*
  304.  * gistinsert -- wrapper for GiST tuple insertion.
  305.  *
  306.  *   This is the public interface routine for tuple insertion in GiSTs.
  307.  *   It doesn't do any work; just locks the relation and passes the buck.
  308.  */
  309. InsertIndexResult
  310. gistinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel)
  311. {
  312. InsertIndexResult res;
  313. IndexTuple itup;
  314. GISTSTATE giststate;
  315. GISTENTRY tmpentry;
  316. int i;
  317. bool    *compvec;
  319. initGISTstate(&giststate, r);
  321. /* immediately compress keys to normalize */
  322. compvec = (bool *) palloc(sizeof(bool) * r->rd_att->natts);
  323. for (i = 0; i < r->rd_att->natts; i++)
  324. {
  325. gistcentryinit(&giststate, &tmpentry, (char *) datum[i],
  326.    (Relation) NULL, (Page) NULL, (OffsetNumber) 0,
  327.    -1 /* size is currently bogus */ , TRUE);
  328. if (datum[i] != (Datum) tmpentry.pred && !(giststate.keytypbyval))
  329. compvec[i] = TRUE;
  330. else
  331. compvec[i] = FALSE;
  332. datum[i] = (Datum) tmpentry.pred;
  333. }
  334. itup = index_formtuple(RelationGetDescr(r), datum, nulls);
  335. itup->t_tid = *ht_ctid;
  337. /*
  338.  * Notes in ExecUtils:ExecOpenIndices()
  339.  *
  340.  * RelationSetLockForWrite(r);
  341.  */
  343. res = gistdoinsert(r, itup, &giststate);
  344. for (i = 0; i < r->rd_att->natts; i++)
  345. if (compvec[i] == TRUE)
  346. pfree((char *) datum[i]);
  347. pfree(itup);
  348. pfree(compvec);
  350. return res;
  351. }
  353. /*
  354. ** Take a compressed entry, and install it on a page.  Since we now know
  355. ** where the entry will live, we decompress it and recompress it using
  356. ** that knowledge (some compression routines may want to fish around
  357. ** on the page, for example, or do something special for leaf nodes.)
  358. */
  359. static OffsetNumber
  360. gistPageAddItem(GISTSTATE *giststate,
  361. Relation r,
  362. Page page,
  363. Item item,
  364. Size size,
  365. OffsetNumber offsetNumber,
  366. ItemIdFlags flags,
  367. GISTENTRY *dentry,
  368. IndexTuple *newtup)
  369. {
  370. GISTENTRY tmpcentry;
  371. IndexTuple itup = (IndexTuple) item;
  373. /*
  374.  * recompress the item given that we now know the exact page and
  375.  * offset for insertion
  376.  */
  377. gistdentryinit(giststate, dentry,
  378.    (((char *) itup) + sizeof(IndexTupleData)),
  379.   (Relation) 0, (Page) 0, (OffsetNumber) InvalidOffsetNumber,
  380.    IndexTupleSize(itup) - sizeof(IndexTupleData), FALSE);
  381. gistcentryinit(giststate, &tmpcentry, dentry->pred, r, page,
  382.    offsetNumber, dentry->bytes, FALSE);
  383. *newtup = gist_tuple_replacekey(r, *dentry, itup);
  384. /* be tidy */
  385. if (tmpcentry.pred != dentry->pred
  386. && tmpcentry.pred != (((char *) itup) + sizeof(IndexTupleData)))
  387. pfree(tmpcentry.pred);
  389. return (PageAddItem(page, (Item) *newtup, IndexTupleSize(*newtup),
  390. offsetNumber, flags));
  391. }
  394. static InsertIndexResult
  395. gistdoinsert(Relation r,
  396.  IndexTuple itup, /* itup contains compressed entry */
  397.  GISTSTATE *giststate)
  398. {
  399. GISTENTRY tmpdentry;
  400. InsertIndexResult res;
  401. OffsetNumber l;
  402. GISTSTACK  *stack;
  403. Buffer buffer;
  404. BlockNumber blk;
  405. Page page;
  406. OffsetNumber off;
  407. IndexTuple newtup;
  409. /* 3rd arg is ignored for now */
  410. blk = gistChooseSubtree(r, itup, 0, giststate, &stack, &buffer);
  411. page = (Page) BufferGetPage(buffer);
  413. if (gistnospace(page, itup))
  414. {
  415. /* need to do a split */
  416. res = gistSplit(r, buffer, stack, itup, giststate);
  417. gistfreestack(stack);
  418. WriteBuffer(buffer); /* don't forget to release buffer! */
  419. return res;
  420. }
  422. if (PageIsEmpty(page))
  423. off = FirstOffsetNumber;
  424. else
  425. off = OffsetNumberNext(PageGetMaxOffsetNumber(page));
  427. /* add the item and write the buffer */
  428. l = gistPageAddItem(giststate, r, page, (Item) itup, IndexTupleSize(itup),
  429. off, LP_USED, &tmpdentry, &newtup);
  430. WriteBuffer(buffer);
  432. /* now expand the page boundary in the parent to include the new child */
  433. gistAdjustKeys(r, stack, blk, tmpdentry.pred, tmpdentry.bytes, giststate);
  434. gistfreestack(stack);
  436. /* be tidy */
  437. if (itup != newtup)
  438. pfree(newtup);
  439. if (tmpdentry.pred != (((char *) itup) + sizeof(IndexTupleData)))
  440. pfree(tmpdentry.pred);
  442. /* build and return an InsertIndexResult for this insertion */
  443. res = (InsertIndexResult) palloc(sizeof(InsertIndexResultData));
  444. ItemPointerSet(&(res->pointerData), blk, l);
  446. return res;
  447. }
  450. static BlockNumber
  451. gistChooseSubtree(Relation r, IndexTuple itup, /* itup has compressed
  452.  * entry */
  453.   int level,
  454.   GISTSTATE *giststate,
  455.   GISTSTACK **retstack /* out */ ,
  456.   Buffer *leafbuf /* out */ )
  457. {
  458. Buffer buffer;
  459. BlockNumber blk;
  460. GISTSTACK  *stack;
  461. Page page;
  462. GISTPageOpaque opaque;
  463. IndexTuple which;
  465. blk = GISTP_ROOT;
  466. buffer = InvalidBuffer;
  467. stack = (GISTSTACK *) NULL;
  469. do
  470. {
  471. /* let go of current buffer before getting next */
  472. if (buffer != InvalidBuffer)
  473. ReleaseBuffer(buffer);
  475. /* get next buffer */
  476. buffer = ReadBuffer(r, blk);
  477. page = (Page) BufferGetPage(buffer);
  479. opaque = (GISTPageOpaque) PageGetSpecialPointer(page);
  480. if (!(opaque->flags & F_LEAF))
  481. {
  482. GISTSTACK  *n;
  483. ItemId iid;
  485. n = (GISTSTACK *) palloc(sizeof(GISTSTACK));
  486. n->gs_parent = stack;
  487. n->gs_blk = blk;
  488. n->gs_child = gistchoose(r, page, itup, giststate);
  489. stack = n;
  491. iid = PageGetItemId(page, n->gs_child);
  492. which = (IndexTuple) PageGetItem(page, iid);
  493. blk = ItemPointerGetBlockNumber(&(which->t_tid));
  494. }
  495. } while (!(opaque->flags & F_LEAF));
  497. *retstack = stack;
  498. *leafbuf = buffer;
  500. return blk;
  501. }
  504. static void
  505. gistAdjustKeys(Relation r,
  506.    GISTSTACK *stk,
  507.    BlockNumber blk,
  508.    char *datum, /* datum is uncompressed */
  509.    int att_size,
  510.    GISTSTATE *giststate)
  511. {
  512. char    *oldud;
  513. Page p;
  514. Buffer b;
  515. bool result;
  516. bytea    *evec;
  517. GISTENTRY centry,
  518.    *ev0p,
  519.    *ev1p;
  520. int size,
  521. datumsize;
  522. IndexTuple tid;
  524. if (stk == (GISTSTACK *) NULL)
  525. return;
  527. b = ReadBuffer(r, stk->gs_blk);
  528. p = BufferGetPage(b);
  530. oldud = (char *) PageGetItem(p, PageGetItemId(p, stk->gs_child));
  531. tid = (IndexTuple) oldud;
  532. size = IndexTupleSize((IndexTuple) oldud) - sizeof(IndexTupleData);
  533. oldud += sizeof(IndexTupleData);
  535. evec = (bytea *) palloc(2 * sizeof(GISTENTRY) + VARHDRSZ);
  536. VARSIZE(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
  538. /* insert decompressed oldud into entry vector */
  539. gistdentryinit(giststate, &((GISTENTRY *) VARDATA(evec))[0],
  540.    oldud, r, p, stk->gs_child,
  541.    size, FALSE);
  542. ev0p = &((GISTENTRY *) VARDATA(evec))[0];
  544. /* insert datum entry into entry vector */
  545. gistentryinit(((GISTENTRY *) VARDATA(evec))[1], datum,
  546. (Relation) NULL, (Page) NULL, (OffsetNumber) 0, att_size, FALSE);
  547. ev1p = &((GISTENTRY *) VARDATA(evec))[1];
  549. /* form union of decompressed entries */
  550. datum = (*fmgr_faddr(&giststate->unionFn)) (evec, &datumsize);
  552. /* did union leave decompressed version of oldud unchanged? */
  553. (*fmgr_faddr(&giststate->equalFn)) (ev0p->pred, datum, &result);
  554. if (!result)
  555. {
  556. TupleDesc td = RelationGetDescr(r);
  558. /* compress datum for storage on page */
  559. gistcentryinit(giststate, &centry, datum, ev0p->rel, ev0p->page,
  560.    ev0p->offset, datumsize, FALSE);
  561. if (td->attrs[0]->attlen >= 0)
  562. {
  563. memmove(oldud, centry.pred, att_size);
  564. gistAdjustKeys(r, stk->gs_parent, stk->gs_blk, datum, att_size,
  565.    giststate);
  566. }
  567. else if (VARSIZE(centry.pred) == VARSIZE(oldud))
  568. {
  569. memmove(oldud, centry.pred, VARSIZE(centry.pred));
  570. gistAdjustKeys(r, stk->gs_parent, stk->gs_blk, datum, att_size,
  571.    giststate);
  572. }
  573. else
  574. {
  576. /*
  577.  * * new datum is not the same size as the old. * We have to
  578.  * delete the old entry and insert the new * one.  Note that
  579.  * this may cause a split here!
  580.  */
  581. IndexTuple newtup;
  582. ItemPointerData oldtid;
  583. char    *isnull;
  584. TupleDesc tupDesc;
  585. InsertIndexResult res;
  587. /* delete old tuple */
  588. ItemPointerSet(&oldtid, stk->gs_blk, stk->gs_child);
  589. gistdelete(r, (ItemPointer) &oldtid);
  591. /* generate and insert new tuple */
  592. tupDesc = r->rd_att;
  593. isnull = (char *) palloc(r->rd_rel->relnatts);
  594. MemSet(isnull, ' ', r->rd_rel->relnatts);
  595. newtup = (IndexTuple) index_formtuple(tupDesc,
  596.  (Datum *) &centry.pred, isnull);
  597. pfree(isnull);
  598. /* set pointer in new tuple to point to current child */
  599. ItemPointerSet(&oldtid, blk, 1);
  600. newtup->t_tid = oldtid;
  602. /* inserting the new entry also adjust keys above */
  603. res = gistentryinsert(r, stk, newtup, giststate);
  605. /* in stack, set info to point to new tuple */
  606. stk->gs_blk = ItemPointerGetBlockNumber(&(res->pointerData));
  607. stk->gs_child = ItemPointerGetOffsetNumber(&(res->pointerData));
  609. pfree(res);
  610. }
  611. WriteBuffer(b);
  613. if (centry.pred != datum)
  614. pfree(datum);
  615. }
  616. else
  617. ReleaseBuffer(b);
  618. pfree(evec);
  619. }
  621. /*
  622.  * gistSplit -- split a page in the tree.
  623.  *
  624.  */
  625. static InsertIndexResult
  626. gistSplit(Relation r,
  627.   Buffer buffer,
  628.   GISTSTACK *stack,
  629.   IndexTuple itup, /* contains compressed entry */
  630.   GISTSTATE *giststate)
  631. {
  632. Page p;
  633. Buffer leftbuf,
  634. rightbuf;
  635. Page left,
  636. right;
  637. ItemId itemid;
  638. IndexTuple item;
  639. IndexTuple ltup,
  640. rtup,
  641. newtup;
  642. OffsetNumber maxoff;
  643. OffsetNumber i;
  644. OffsetNumber leftoff,
  645. rightoff;
  646. BlockNumber lbknum,
  647. rbknum;
  648. BlockNumber bufblock;
  649. GISTPageOpaque opaque;
  650. int blank;
  651. InsertIndexResult res;
  652. char    *isnull;
  653. GIST_SPLITVEC v;
  654. TupleDesc tupDesc;
  655. bytea    *entryvec;
  656. bool    *decompvec;
  657. IndexTuple item_1;
  658. GISTENTRY tmpdentry,
  659. tmpentry;
  661. isnull = (char *) palloc(r->rd_rel->relnatts);
  662. for (blank = 0; blank < r->rd_rel->relnatts; blank++)
  663. isnull[blank] = ' ';
  664. p = (Page) BufferGetPage(buffer);
  665. opaque = (GISTPageOpaque) PageGetSpecialPointer(p);
  668. /*
  669.  * The root of the tree is the first block in the relation.  If we're
  670.  * about to split the root, we need to do some hocus-pocus to enforce
  671.  * this guarantee.
  672.  */
  674. if (BufferGetBlockNumber(buffer) == GISTP_ROOT)
  675. {
  676. leftbuf = ReadBuffer(r, P_NEW);
  677. GISTInitBuffer(leftbuf, opaque->flags);
  678. lbknum = BufferGetBlockNumber(leftbuf);
  679. left = (Page) BufferGetPage(leftbuf);
  680. }
  681. else
  682. {
  683. leftbuf = buffer;
  684. IncrBufferRefCount(buffer);
  685. lbknum = BufferGetBlockNumber(buffer);
  686. left = (Page) PageGetTempPage(p, sizeof(GISTPageOpaqueData));
  687. }
  689. rightbuf = ReadBuffer(r, P_NEW);
  690. GISTInitBuffer(rightbuf, opaque->flags);
  691. rbknum = BufferGetBlockNumber(rightbuf);
  692. right = (Page) BufferGetPage(rightbuf);
  694. /* generate the item array */
  695. maxoff = PageGetMaxOffsetNumber(p);
  696. entryvec = (bytea *) palloc(VARHDRSZ + (maxoff + 2) * sizeof(GISTENTRY));
  697. decompvec = (bool *) palloc(VARHDRSZ + (maxoff + 2) * sizeof(bool));
  698. for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
  699. {
  700. item_1 = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
  701. gistdentryinit(giststate, &((GISTENTRY *) VARDATA(entryvec))[i],
  702.    (((char *) item_1) + sizeof(IndexTupleData)),
  703.    r, p, i,
  704.  IndexTupleSize(item_1) - sizeof(IndexTupleData), FALSE);
  705. if ((char *) (((GISTENTRY *) VARDATA(entryvec))[i].pred)
  706. == (((char *) item_1) + sizeof(IndexTupleData)))
  707. decompvec[i] = FALSE;
  708. else
  709. decompvec[i] = TRUE;
  710. }
  712. /* add the new datum as the last entry */
  713. gistdentryinit(giststate, &(((GISTENTRY *) VARDATA(entryvec))[maxoff + 1]),
  714.    (((char *) itup) + sizeof(IndexTupleData)),
  715.    (Relation) NULL, (Page) NULL,
  716.    (OffsetNumber) 0, tmpentry.bytes, FALSE);
  717. if ((char *) (((GISTENTRY *) VARDATA(entryvec))[maxoff + 1]).pred !=
  718. (((char *) itup) + sizeof(IndexTupleData)))
  719. decompvec[maxoff + 1] = TRUE;
  720. else
  721. decompvec[maxoff + 1] = FALSE;
  723. VARSIZE(entryvec) = (maxoff + 2) * sizeof(GISTENTRY) + VARHDRSZ;
  725. /* now let the user-defined picksplit function set up the split vector */
  726. (*fmgr_faddr(&giststate->picksplitFn)) (entryvec, &v);
  728. /* compress ldatum and rdatum */
  729. gistcentryinit(giststate, &tmpentry, v.spl_ldatum, (Relation) NULL,
  730.    (Page) NULL, (OffsetNumber) 0,
  731.    ((GISTENTRY *) VARDATA(entryvec))[i].bytes, FALSE);
  732. if (v.spl_ldatum != tmpentry.pred)
  733. pfree(v.spl_ldatum);
  734. v.spl_ldatum = tmpentry.pred;
  736. gistcentryinit(giststate, &tmpentry, v.spl_rdatum, (Relation) NULL,
  737.    (Page) NULL, (OffsetNumber) 0,
  738.    ((GISTENTRY *) VARDATA(entryvec))[i].bytes, FALSE);
  739. if (v.spl_rdatum != tmpentry.pred)
  740. pfree(v.spl_rdatum);
  741. v.spl_rdatum = tmpentry.pred;
  743. /* clean up the entry vector: its preds need to be deleted, too */
  744. for (i = FirstOffsetNumber; i <= maxoff + 1; i = OffsetNumberNext(i))
  745. if (decompvec[i])
  746. pfree(((GISTENTRY *) VARDATA(entryvec))[i].pred);
  747. pfree(entryvec);
  748. pfree(decompvec);
  750. leftoff = rightoff = FirstOffsetNumber;
  751. maxoff = PageGetMaxOffsetNumber(p);
  752. for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
  753. {
  754. itemid = PageGetItemId(p, i);
  755. item = (IndexTuple) PageGetItem(p, itemid);
  757. if (i == *(v.spl_left))
  758. {
  759. gistPageAddItem(giststate, r, left, (Item) item,
  760. IndexTupleSize(item),
  761. leftoff, LP_USED, &tmpdentry, &newtup);
  762. leftoff = OffsetNumberNext(leftoff);
  763. v.spl_left++; /* advance in left split vector */
  764. /* be tidy */
  765. if (tmpdentry.pred != (((char *) item) + sizeof(IndexTupleData)))
  766. pfree(tmpdentry.pred);
  767. if ((IndexTuple) item != newtup)
  768. pfree(newtup);
  769. }
  770. else
  771. {
  772. gistPageAddItem(giststate, r, right, (Item) item,
  773. IndexTupleSize(item),
  774. rightoff, LP_USED, &tmpdentry, &newtup);
  775. rightoff = OffsetNumberNext(rightoff);
  776. v.spl_right++; /* advance in right split vector */
  777. /* be tidy */
  778. if (tmpdentry.pred != (((char *) item) + sizeof(IndexTupleData)))
  779. pfree(tmpdentry.pred);
  780. if (item != newtup)
  781. pfree(newtup);
  782. }
  783. }
  785. /* build an InsertIndexResult for this insertion */
  786. res = (InsertIndexResult) palloc(sizeof(InsertIndexResultData));
  788. /* now insert the new index tuple */
  789. if (*(v.spl_left) != FirstOffsetNumber)
  790. {
  791. gistPageAddItem(giststate, r, left, (Item) itup,
  792. IndexTupleSize(itup),
  793. leftoff, LP_USED, &tmpdentry, &newtup);
  794. leftoff = OffsetNumberNext(leftoff);
  795. ItemPointerSet(&(res->pointerData), lbknum, leftoff);
  796. /* be tidy */
  797. if (tmpdentry.pred != (((char *) itup) + sizeof(IndexTupleData)))
  798. pfree(tmpdentry.pred);
  799. if (itup != newtup)
  800. pfree(newtup);
  801. }
  802. else
  803. {
  804. gistPageAddItem(giststate, r, right, (Item) itup,
  805. IndexTupleSize(itup),
  806. rightoff, LP_USED, &tmpdentry, &newtup);
  807. rightoff = OffsetNumberNext(rightoff);
  808. ItemPointerSet(&(res->pointerData), rbknum, rightoff);
  809. /* be tidy */
  810. if (tmpdentry.pred != (((char *) itup) + sizeof(IndexTupleData)))
  811. pfree(tmpdentry.pred);
  812. if (itup != newtup)
  813. pfree(newtup);
  814. }
  816. if ((bufblock = BufferGetBlockNumber(buffer)) != GISTP_ROOT)
  817. PageRestoreTempPage(left, p);
  818. WriteBuffer(leftbuf);
  819. WriteBuffer(rightbuf);
  821. /*
  822.  * Okay, the page is split.  We have three things left to do:
  823.  *
  824.  * 1)  Adjust any active scans on this index to cope with changes we
  825.  * introduced in its structure by splitting this page.
  826.  *
  827.  * 2)  "Tighten" the bounding box of the pointer to the left page in the
  828.  * parent node in the tree, if any.  Since we moved a bunch of stuff
  829.  * off the left page, we expect it to get smaller. This happens in
  830.  * the internal insertion routine.
  831.  *
  832.  * 3)  Insert a pointer to the right page in the parent.  This may cause
  833.  * the parent to split.  If it does, we need to repeat steps one and
  834.  * two for each split node in the tree.
  835.  */
  837. /* adjust active scans */
  838. gistadjscans(r, GISTOP_SPLIT, bufblock, FirstOffsetNumber);
  840. tupDesc = r->rd_att;
  842. ltup = (IndexTuple) index_formtuple(tupDesc,
  843.   (Datum *) &(v.spl_ldatum), isnull);
  844. rtup = (IndexTuple) index_formtuple(tupDesc,
  845.   (Datum *) &(v.spl_rdatum), isnull);
  846. pfree(isnull);
  848. /* set pointers to new child pages in the internal index tuples */
  849. ItemPointerSet(&(ltup->t_tid), lbknum, 1);
  850. ItemPointerSet(&(rtup->t_tid), rbknum, 1);
  852. gistintinsert(r, stack, ltup, rtup, giststate);
  854. pfree(ltup);
  855. pfree(rtup);
  857. return res;
  858. }
  860. /*
  861. ** After a split, we need to overwrite the old entry's key in the parent,
  862. ** and install install an entry for the new key into the parent.
  863. */
  864. static void
  865. gistintinsert(Relation r,
  866.   GISTSTACK *stk,
  867.   IndexTuple ltup, /* new version of entry for old page */
  868.   IndexTuple rtup, /* entry for new page */
  869.   GISTSTATE *giststate)
  870. {
  871. ItemPointerData ltid;
  873. if (stk == (GISTSTACK *) NULL)
  874. {
  875. gistnewroot(giststate, r, ltup, rtup);
  876. return;
  877. }
  879. /* remove old left pointer, insert the 2 new entries */
  880. ItemPointerSet(&ltid, stk->gs_blk, stk->gs_child);
  881. gistdelete(r, (ItemPointer) &ltid);
  882. gistentryinserttwo(r, stk, ltup, rtup, giststate);
  883. }
  886. /*
  887. ** Insert two entries onto one page, handling a split for either one!
  888. */
  889. static void
  890. gistentryinserttwo(Relation r, GISTSTACK *stk, IndexTuple ltup,
  891.    IndexTuple rtup, GISTSTATE *giststate)
  892. {
  893. Buffer b;
  894. Page p;
  895. InsertIndexResult res;
  896. GISTENTRY tmpentry;
  897. IndexTuple newtup;
  899. b = ReadBuffer(r, stk->gs_blk);
  900. p = BufferGetPage(b);
  902. if (gistnospace(p, ltup))
  903. {
  904. res = gistSplit(r, b, stk->gs_parent, ltup, giststate);
  905. WriteBuffer(b); /* don't forget to release buffer!  -
  906.  * 01/31/94 */
  907. pfree(res);
  908. gistdoinsert(r, rtup, giststate);
  909. }
  910. else
  911. {
  912. gistPageAddItem(giststate, r, p, (Item) ltup,
  913. IndexTupleSize(ltup), InvalidOffsetNumber,
  914. LP_USED, &tmpentry, &newtup);
  915. WriteBuffer(b);
  916. gistAdjustKeys(r, stk->gs_parent, stk->gs_blk, tmpentry.pred,
  917.    tmpentry.bytes, giststate);
  918. /* be tidy */
  919. if (tmpentry.pred != (((char *) ltup) + sizeof(IndexTupleData)))
  920. pfree(tmpentry.pred);
  921. if (ltup != newtup)
  922. pfree(newtup);
  923. gistentryinsert(r, stk, rtup, giststate);
  924. }
  925. }
  928. /*
  929. ** Insert an entry onto a page
  930. */
  931. static InsertIndexResult
  932. gistentryinsert(Relation r, GISTSTACK *stk, IndexTuple tup,
  933. GISTSTATE *giststate)
  934. {
  935. Buffer b;
  936. Page p;
  937. InsertIndexResult res;
  938. OffsetNumber off;
  939. GISTENTRY tmpentry;
  940. IndexTuple newtup;
  942. b = ReadBuffer(r, stk->gs_blk);
  943. p = BufferGetPage(b);
  945. if (gistnospace(p, tup))
  946. {
  947. res = gistSplit(r, b, stk->gs_parent, tup, giststate);
  948. WriteBuffer(b); /* don't forget to release buffer!  -
  949.  * 01/31/94 */
  950. return res;
  951. }
  952. else
  953. {
  954. res = (InsertIndexResult) palloc(sizeof(InsertIndexResultData));
  955. off = gistPageAddItem(giststate, r, p, (Item) tup, IndexTupleSize(tup),
  956.    InvalidOffsetNumber, LP_USED, &tmpentry, &newtup);
  957. WriteBuffer(b);
  958. ItemPointerSet(&(res->pointerData), stk->gs_blk, off);
  959. gistAdjustKeys(r, stk->gs_parent, stk->gs_blk, tmpentry.pred,
  960.    tmpentry.bytes, giststate);
  961. /* be tidy */
  962. if (tmpentry.pred != (((char *) tup) + sizeof(IndexTupleData)))
  963. pfree(tmpentry.pred);
  964. if (tup != newtup)
  965. pfree(newtup);
  966. return res;
  967. }
  968. }
  971. static void
  972. gistnewroot(GISTSTATE *giststate, Relation r, IndexTuple lt, IndexTuple rt)
  973. {
  974. Buffer b;
  975. Page p;
  976. GISTENTRY tmpentry;
  977. IndexTuple newtup;
  979. b = ReadBuffer(r, GISTP_ROOT);
  980. GISTInitBuffer(b, 0);
  981. p = BufferGetPage(b);
  982. gistPageAddItem(giststate, r, p, (Item) lt, IndexTupleSize(lt),
  983. FirstOffsetNumber,
  984. LP_USED, &tmpentry, &newtup);
  985. /* be tidy */
  986. if (tmpentry.pred != (((char *) lt) + sizeof(IndexTupleData)))
  987. pfree(tmpentry.pred);
  988. if (lt != newtup)
  989. pfree(newtup);
  990. gistPageAddItem(giststate, r, p, (Item) rt, IndexTupleSize(rt),
  991. OffsetNumberNext(FirstOffsetNumber), LP_USED,
  992. &tmpentry, &newtup);
  993. /* be tidy */
  994. if (tmpentry.pred != (((char *) rt) + sizeof(IndexTupleData)))
  995. pfree(tmpentry.pred);
  996. if (rt != newtup)
  997. pfree(newtup);
  998. WriteBuffer(b);
  999. }
  1001. static void
  1002. GISTInitBuffer(Buffer b, uint32 f)
  1003. {
  1004. GISTPageOpaque opaque;
  1005. Page page;
  1006. Size pageSize;
  1008. pageSize = BufferGetPageSize(b);
  1010. page = BufferGetPage(b);
  1011. MemSet(page, 0, (int) pageSize);
  1012. PageInit(page, pageSize, sizeof(GISTPageOpaqueData));
  1014. opaque = (GISTPageOpaque) PageGetSpecialPointer(page);
  1015. opaque->flags = f;
  1016. }
  1019. /*
  1020. ** find entry with lowest penalty
  1021. */
  1022. static OffsetNumber
  1023. gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */
  1024.    GISTSTATE *giststate)
  1025. {
  1026. OffsetNumber maxoff;
  1027. OffsetNumber i;
  1028. char    *id;
  1029. char    *datum;
  1030. float usize;
  1031. OffsetNumber which;
  1032. float which_grow;
  1033. GISTENTRY entry,
  1034. identry;
  1035. int size,
  1036. idsize;
  1038. idsize = IndexTupleSize(it) - sizeof(IndexTupleData);
  1039. id = ((char *) it) + sizeof(IndexTupleData);
  1040. maxoff = PageGetMaxOffsetNumber(p);
  1041. which_grow = -1.0;
  1042. which = -1;
  1044. gistdentryinit(giststate, &identry, id, (Relation) NULL, (Page) NULL,
  1045.    (OffsetNumber) 0, idsize, FALSE);
  1047. for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
  1048. {
  1049. datum = (char *) PageGetItem(p, PageGetItemId(p, i));
  1050. size = IndexTupleSize(datum) - sizeof(IndexTupleData);
  1051. datum += sizeof(IndexTupleData);
  1052. gistdentryinit(giststate, &entry, datum, r, p, i, size, FALSE);
  1053. (*fmgr_faddr(&giststate->penaltyFn)) (&entry, &identry, &usize);
  1054. if (which_grow < 0 || usize < which_grow)
  1055. {
  1056. which = i;
  1057. which_grow = usize;
  1058. if (which_grow == 0)
  1059. break;
  1060. }
  1061. if (entry.pred != datum)
  1062. pfree(entry.pred);
  1063. }
  1064. if (identry.pred != id)
  1065. pfree(identry.pred);
  1067. return which;
  1068. }
  1070. static int
  1071. gistnospace(Page p, IndexTuple it)
  1072. {
  1073. return PageGetFreeSpace(p) < IndexTupleSize(it);
  1074. }
  1076. void
  1077. gistfreestack(GISTSTACK *s)
  1078. {
  1079. GISTSTACK  *p;
  1081. while (s != (GISTSTACK *) NULL)
  1082. {
  1083. p = s->gs_parent;
  1084. pfree(s);
  1085. s = p;
  1086. }
  1087. }
  1090. /*
  1091. ** remove an entry from a page
  1092. */
  1093. void
  1094. gistdelete(Relation r, ItemPointer tid)
  1095. {
  1096. BlockNumber blkno;
  1097. OffsetNumber offnum;
  1098. Buffer buf;
  1099. Page page;
  1101. /*
  1102.  * Notes in ExecUtils:ExecOpenIndices() Also note that only vacuum
  1103.  * deletes index tuples now...
  1104.  *
  1105.  * RelationSetLockForWrite(r);
  1106.  */
  1108. blkno = ItemPointerGetBlockNumber(tid);
  1109. offnum = ItemPointerGetOffsetNumber(tid);
  1111. /* adjust any scans that will be affected by this deletion */
  1112. gistadjscans(r, GISTOP_DEL, blkno, offnum);
  1114. /* delete the index tuple */
  1115. buf = ReadBuffer(r, blkno);
  1116. page = BufferGetPage(buf);
  1118. PageIndexTupleDelete(page, offnum);
  1120. WriteBuffer(buf);
  1122. }
  1124. void
  1125. initGISTstate(GISTSTATE *giststate, Relation index)
  1126. {
  1127. RegProcedure consistent_proc,
  1128. union_proc,
  1129. compress_proc,
  1130. decompress_proc;
  1131. RegProcedure penalty_proc,
  1132. picksplit_proc,
  1133. equal_proc;
  1134. HeapTuple htup;
  1135. Form_pg_index itupform;
  1137. consistent_proc = index_getprocid(index, 1, GIST_CONSISTENT_PROC);
  1138. union_proc = index_getprocid(index, 1, GIST_UNION_PROC);
  1139. compress_proc = index_getprocid(index, 1, GIST_COMPRESS_PROC);
  1140. decompress_proc = index_getprocid(index, 1, GIST_DECOMPRESS_PROC);
  1141. penalty_proc = index_getprocid(index, 1, GIST_PENALTY_PROC);
  1142. picksplit_proc = index_getprocid(index, 1, GIST_PICKSPLIT_PROC);
  1143. equal_proc = index_getprocid(index, 1, GIST_EQUAL_PROC);
  1144. fmgr_info(consistent_proc, &giststate->consistentFn);
  1145. fmgr_info(union_proc, &giststate->unionFn);
  1146. fmgr_info(compress_proc, &giststate->compressFn);
  1147. fmgr_info(decompress_proc, &giststate->decompressFn);
  1148. fmgr_info(penalty_proc, &giststate->penaltyFn);
  1149. fmgr_info(picksplit_proc, &giststate->picksplitFn);
  1150. fmgr_info(equal_proc, &giststate->equalFn);
  1152. /* see if key type is different from type of attribute being indexed */
  1153. htup = SearchSysCacheTuple(INDEXRELID,
  1154.    ObjectIdGetDatum(RelationGetRelid(index)),
  1155.    0, 0, 0);
  1156. itupform = (Form_pg_index) GETSTRUCT(htup);
  1157. if (!HeapTupleIsValid(htup))
  1158. elog(ERROR, "initGISTstate: index %u not found",
  1159.  RelationGetRelid(index));
  1160. giststate->haskeytype = itupform->indhaskeytype;
  1161. if (giststate->haskeytype)
  1162. {
  1163. /* key type is different -- is it byval? */
  1164. htup = SearchSysCacheTuple(ATTNUM,
  1165.    ObjectIdGetDatum(itupform->indexrelid),
  1166.    UInt16GetDatum(FirstOffsetNumber),
  1167.    0, 0);
  1168. if (!HeapTupleIsValid(htup))
  1169. {
  1170. elog(ERROR, "initGISTstate: no attribute tuple %u %d",
  1171.  itupform->indexrelid, FirstOffsetNumber);
  1172. return;
  1173. }
  1174. giststate->keytypbyval = (((Form_pg_attribute) htup)->attbyval);
  1175. }
  1176. else
  1177. giststate->keytypbyval = FALSE;
  1178. return;
  1179. }
  1182. /*
  1183. ** Given an IndexTuple to be inserted on a page, this routine replaces
  1184. ** the key with another key, which may involve generating a new IndexTuple
  1185. ** if the sizes don't match
  1186. */
  1187. static IndexTuple
  1188. gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t)
  1189. {
  1190. char    *datum = (((char *) t) + sizeof(IndexTupleData));
  1192. /* if new entry fits in index tuple, copy it in */
  1193. if (entry.bytes < IndexTupleSize(t) - sizeof(IndexTupleData))
  1194. {
  1195. memcpy(datum, entry.pred, entry.bytes);
  1196. /* clear out old size */
  1197. t->t_info &= 0xe000;
  1198. /* or in new size */
  1199. t->t_info |= MAXALIGN(entry.bytes + sizeof(IndexTupleData));
  1201. return t;
  1202. }
  1203. else
  1204. {
  1205. /* generate a new index tuple for the compressed entry */
  1206. TupleDesc tupDesc = r->rd_att;
  1207. IndexTuple newtup;
  1208. char    *isnull;
  1209. int blank;
  1211. isnull = (char *) palloc(r->rd_rel->relnatts);
  1212. for (blank = 0; blank < r->rd_rel->relnatts; blank++)
  1213. isnull[blank] = ' ';
  1214. newtup = (IndexTuple) index_formtuple(tupDesc,
  1215.   (Datum *) &(entry.pred),
  1216.   isnull);
  1217. newtup->t_tid = t->t_tid;
  1218. pfree(isnull);
  1219. return newtup;
  1220. }
  1221. }
  1224. /*
  1225. ** initialize a GiST entry with a decompressed version of pred
  1226. */
  1227. void
  1228. gistdentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr, Relation r,
  1229.    Page pg, OffsetNumber o, int b, bool l)
  1230. {
  1231. GISTENTRY  *dep;
  1233. gistentryinit(*e, pr, r, pg, o, b, l);
  1234. if (giststate->haskeytype)
  1235. {
  1236. dep = (GISTENTRY *) ((*fmgr_faddr(&giststate->decompressFn)) (e));
  1237. gistentryinit(*e, dep->pred, dep->rel, dep->page, dep->offset, dep->bytes,
  1238.   dep->leafkey);
  1239. if (dep != e)
  1240. pfree(dep);
  1241. }
  1242. }
  1245. /*
  1246. ** initialize a GiST entry with a compressed version of pred
  1247. */
  1248. static void
  1249. gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr, Relation r,
  1250.    Page pg, OffsetNumber o, int b, bool l)
  1251. {
  1252. GISTENTRY  *cep;
  1254. gistentryinit(*e, pr, r, pg, o, b, l);
  1255. if (giststate->haskeytype)
  1256. {
  1257. cep = (GISTENTRY *) ((*fmgr_faddr(&giststate->compressFn)) (e));
  1258. gistentryinit(*e, cep->pred, cep->rel, cep->page, cep->offset, cep->bytes,
  1259.   cep->leafkey);
  1260. if (cep != e)
  1261. pfree(cep);
  1262. }
  1263. }
  1267. #ifdef GISTDEBUG
  1269. /*
  1270. ** sloppy debugging support routine, requires recompilation with appropriate
  1271. ** "out" method for the index keys.  Could be fixed to find that info
  1272. ** in the catalogs...
  1273. */
  1274. void
  1275. _gistdump(Relation r)
  1276. {
  1277. Buffer buf;
  1278. Page page;
  1279. OffsetNumber offnum,
  1280. maxoff;
  1281. BlockNumber blkno;
  1282. BlockNumber nblocks;
  1283. GISTPageOpaque po;
  1284. IndexTuple itup;
  1285. BlockNumber itblkno;
  1286. OffsetNumber itoffno;
  1287. char    *datum;
  1288. char    *itkey;
  1290. nblocks = RelationGetNumberOfBlocks(r);
  1291. for (blkno = 0; blkno < nblocks; blkno++)
  1292. {
  1293. buf = ReadBuffer(r, blkno);
  1294. page = BufferGetPage(buf);
  1295. po = (GISTPageOpaque) PageGetSpecialPointer(page);
  1296. maxoff = PageGetMaxOffsetNumber(page);
  1297. printf("Page %d maxoff %d <%s>n", blkno, maxoff,
  1298.    (po->flags & F_LEAF ? "LEAF" : "INTERNAL"));
  1300. if (PageIsEmpty(page))
  1301. {
  1302. ReleaseBuffer(buf);
  1303. continue;
  1304. }
  1306. for (offnum = FirstOffsetNumber;
  1307.  offnum <= maxoff;
  1308.  offnum = OffsetNumberNext(offnum))
  1309. {
  1310. itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
  1311. itblkno = ItemPointerGetBlockNumber(&(itup->t_tid));
  1312. itoffno = ItemPointerGetOffsetNumber(&(itup->t_tid));
  1313. datum = ((char *) itup);
  1314. datum += sizeof(IndexTupleData);
  1315. /* get out function for type of key, and out it! */
  1316. itkey = (char *) int_range_out((INTRANGE *) datum);
  1317. /* itkey = " unable to print"; */
  1318. printf("t[%d] size %d heap <%d,%d> key:%sn",
  1319.    offnum, IndexTupleSize(itup), itblkno, itoffno, itkey);
  1320. pfree(itkey);
  1321. }
  1323. ReleaseBuffer(buf);
  1324. }
  1325. }
  1327. static char *
  1328. int_range_out(INTRANGE *r)
  1329. {
  1330. char    *result;
  1332. if (r == NULL)
  1333. return NULL;
  1334. result = (char *) palloc(80);
  1335. snprintf(result, 80, "[%d,%d): %d", r->lower, r->upper, r->flag);
  1337. return result;
  1338. }
  1340. #endif  /* defined GISTDEBUG */