pgindent new GIST index code, per request from Tom.
This commit is contained in:
parent
08817bdb76
commit
b3364fc81b
File diff suppressed because it is too large
Load Diff
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistget.c,v 1.50 2005/06/27 12:45:22 teodor Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistget.c,v 1.51 2005/09/22 20:44:36 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -20,64 +20,71 @@
|
||||
#include "utils/memutils.h"
|
||||
|
||||
static OffsetNumber gistfindnext(IndexScanDesc scan, OffsetNumber n,
|
||||
ScanDirection dir);
|
||||
static int gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, bool ignore_killed_tuples);
|
||||
ScanDirection dir);
|
||||
static int gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, bool ignore_killed_tuples);
|
||||
static bool gistindex_keytest(IndexTuple tuple, IndexScanDesc scan,
|
||||
OffsetNumber offset);
|
||||
OffsetNumber offset);
|
||||
|
||||
static void
|
||||
killtuple(Relation r, GISTScanOpaque so, ItemPointer iptr) {
|
||||
Buffer buffer = so->curbuf;
|
||||
static void
|
||||
killtuple(Relation r, GISTScanOpaque so, ItemPointer iptr)
|
||||
{
|
||||
Buffer buffer = so->curbuf;
|
||||
|
||||
for(;;) {
|
||||
Page p;
|
||||
for (;;)
|
||||
{
|
||||
Page p;
|
||||
BlockNumber blkno;
|
||||
OffsetNumber offset, maxoff;
|
||||
OffsetNumber offset,
|
||||
maxoff;
|
||||
|
||||
LockBuffer( buffer, GIST_SHARE );
|
||||
p = (Page)BufferGetPage( buffer );
|
||||
|
||||
if ( buffer == so->curbuf && XLByteEQ( so->stack->lsn, PageGetLSN(p) ) ) {
|
||||
LockBuffer(buffer, GIST_SHARE);
|
||||
p = (Page) BufferGetPage(buffer);
|
||||
|
||||
if (buffer == so->curbuf && XLByteEQ(so->stack->lsn, PageGetLSN(p)))
|
||||
{
|
||||
/* page unchanged, so all is simple */
|
||||
offset = ItemPointerGetOffsetNumber(iptr);
|
||||
PageGetItemId(p, offset)->lp_flags |= LP_DELETE;
|
||||
SetBufferCommitInfoNeedsSave(buffer);
|
||||
LockBuffer( buffer, GIST_UNLOCK );
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
break;
|
||||
}
|
||||
|
||||
maxoff = PageGetMaxOffsetNumber( p );
|
||||
maxoff = PageGetMaxOffsetNumber(p);
|
||||
|
||||
for(offset = FirstOffsetNumber; offset<= maxoff; offset = OffsetNumberNext(offset)) {
|
||||
IndexTuple ituple = (IndexTuple) PageGetItem(p, PageGetItemId(p, offset));
|
||||
for (offset = FirstOffsetNumber; offset <= maxoff; offset = OffsetNumberNext(offset))
|
||||
{
|
||||
IndexTuple ituple = (IndexTuple) PageGetItem(p, PageGetItemId(p, offset));
|
||||
|
||||
if ( ItemPointerEquals( &(ituple->t_tid), iptr ) ) {
|
||||
if (ItemPointerEquals(&(ituple->t_tid), iptr))
|
||||
{
|
||||
/* found */
|
||||
PageGetItemId(p, offset)->lp_flags |= LP_DELETE;
|
||||
SetBufferCommitInfoNeedsSave(buffer);
|
||||
LockBuffer( buffer, GIST_UNLOCK );
|
||||
if ( buffer != so->curbuf )
|
||||
ReleaseBuffer( buffer );
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
if (buffer != so->curbuf)
|
||||
ReleaseBuffer(buffer);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* follow right link */
|
||||
|
||||
/*
|
||||
* ??? is it good? if tuple dropped by concurrent vacuum,
|
||||
* we will read all leaf pages...
|
||||
* ??? is it good? if tuple dropped by concurrent vacuum, we will read
|
||||
* all leaf pages...
|
||||
*/
|
||||
blkno = GistPageGetOpaque(p)->rightlink;
|
||||
LockBuffer( buffer, GIST_UNLOCK );
|
||||
if ( buffer != so->curbuf )
|
||||
ReleaseBuffer( buffer );
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
if (buffer != so->curbuf)
|
||||
ReleaseBuffer(buffer);
|
||||
|
||||
if ( blkno==InvalidBlockNumber )
|
||||
if (blkno == InvalidBlockNumber)
|
||||
/* can't found, dropped by somebody else */
|
||||
return;
|
||||
buffer = ReadBuffer( r, blkno );
|
||||
buffer = ReadBuffer(r, blkno);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* gistgettuple() -- Get the next tuple in the scan
|
||||
@ -85,27 +92,27 @@ killtuple(Relation r, GISTScanOpaque so, ItemPointer iptr) {
|
||||
Datum
|
||||
gistgettuple(PG_FUNCTION_ARGS)
|
||||
{
|
||||
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
|
||||
ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1);
|
||||
GISTScanOpaque so;
|
||||
ItemPointerData tid;
|
||||
bool res;
|
||||
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
|
||||
ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1);
|
||||
GISTScanOpaque so;
|
||||
ItemPointerData tid;
|
||||
bool res;
|
||||
|
||||
so = (GISTScanOpaque) scan->opaque;
|
||||
|
||||
/*
|
||||
* If we have produced an index tuple in the past and the executor
|
||||
* has informed us we need to mark it as "killed", do so now.
|
||||
* If we have produced an index tuple in the past and the executor has
|
||||
* informed us we need to mark it as "killed", do so now.
|
||||
*/
|
||||
if (scan->kill_prior_tuple && ItemPointerIsValid(&(scan->currentItemData)))
|
||||
if (scan->kill_prior_tuple && ItemPointerIsValid(&(scan->currentItemData)))
|
||||
killtuple(scan->indexRelation, so, &(scan->currentItemData));
|
||||
|
||||
/*
|
||||
* Get the next tuple that matches the search key. If asked to
|
||||
* skip killed tuples, continue looping until we find a non-killed
|
||||
* tuple that matches the search key.
|
||||
* Get the next tuple that matches the search key. If asked to skip killed
|
||||
* tuples, continue looping until we find a non-killed tuple that matches
|
||||
* the search key.
|
||||
*/
|
||||
res = ( gistnext(scan, dir, &tid, 1, scan->ignore_killed_tuples) ) ? true : false;
|
||||
res = (gistnext(scan, dir, &tid, 1, scan->ignore_killed_tuples)) ? true : false;
|
||||
|
||||
PG_RETURN_BOOL(res);
|
||||
}
|
||||
@ -114,12 +121,12 @@ Datum
|
||||
gistgetmulti(PG_FUNCTION_ARGS)
|
||||
{
|
||||
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
|
||||
ItemPointer tids = (ItemPointer) PG_GETARG_POINTER(1);
|
||||
ItemPointer tids = (ItemPointer) PG_GETARG_POINTER(1);
|
||||
int32 max_tids = PG_GETARG_INT32(2);
|
||||
int32 *returned_tids = (int32 *) PG_GETARG_POINTER(3);
|
||||
|
||||
*returned_tids = gistnext(scan, ForwardScanDirection, tids, max_tids, false);
|
||||
|
||||
|
||||
PG_RETURN_BOOL(*returned_tids == max_tids);
|
||||
}
|
||||
|
||||
@ -128,17 +135,17 @@ gistgetmulti(PG_FUNCTION_ARGS)
|
||||
* either to fetch the first such tuple or subsequent matching
|
||||
* tuples. Returns true iff a matching tuple was found.
|
||||
*/
|
||||
static int
|
||||
static int
|
||||
gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, bool ignore_killed_tuples)
|
||||
{
|
||||
Page p;
|
||||
OffsetNumber n;
|
||||
GISTScanOpaque so;
|
||||
GISTSearchStack *stk;
|
||||
GISTSearchStack *stk;
|
||||
IndexTuple it;
|
||||
GISTPageOpaque opaque;
|
||||
bool resetoffset=false;
|
||||
int ntids=0;
|
||||
GISTPageOpaque opaque;
|
||||
bool resetoffset = false;
|
||||
int ntids = 0;
|
||||
|
||||
so = (GISTScanOpaque) scan->opaque;
|
||||
|
||||
@ -149,59 +156,67 @@ gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, b
|
||||
Assert(so->stack == NULL);
|
||||
|
||||
so->curbuf = ReadBuffer(scan->indexRelation, GIST_ROOT_BLKNO);
|
||||
|
||||
stk = so->stack = (GISTSearchStack*) palloc0( sizeof(GISTSearchStack) );
|
||||
|
||||
stk = so->stack = (GISTSearchStack *) palloc0(sizeof(GISTSearchStack));
|
||||
|
||||
stk->next = NULL;
|
||||
stk->block = GIST_ROOT_BLKNO;
|
||||
} else if ( so->curbuf == InvalidBuffer ) {
|
||||
}
|
||||
else if (so->curbuf == InvalidBuffer)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
for(;;) {
|
||||
for (;;)
|
||||
{
|
||||
/* First of all, we need lock buffer */
|
||||
Assert( so->curbuf != InvalidBuffer );
|
||||
LockBuffer( so->curbuf, GIST_SHARE );
|
||||
Assert(so->curbuf != InvalidBuffer);
|
||||
LockBuffer(so->curbuf, GIST_SHARE);
|
||||
p = BufferGetPage(so->curbuf);
|
||||
opaque = GistPageGetOpaque( p );
|
||||
opaque = GistPageGetOpaque(p);
|
||||
resetoffset = false;
|
||||
|
||||
if ( XLogRecPtrIsInvalid( so->stack->lsn ) || !XLByteEQ( so->stack->lsn, PageGetLSN(p) ) ) {
|
||||
|
||||
if (XLogRecPtrIsInvalid(so->stack->lsn) || !XLByteEQ(so->stack->lsn, PageGetLSN(p)))
|
||||
{
|
||||
/* page changed from last visit or visit first time , reset offset */
|
||||
so->stack->lsn = PageGetLSN(p);
|
||||
resetoffset = true;
|
||||
|
||||
/* check page split, occured from last visit or visit to parent */
|
||||
if ( !XLogRecPtrIsInvalid( so->stack->parentlsn ) &&
|
||||
XLByteLT( so->stack->parentlsn, opaque->nsn ) &&
|
||||
opaque->rightlink != InvalidBlockNumber /* sanity check */ &&
|
||||
(so->stack->next==NULL || so->stack->next->block != opaque->rightlink) /* check if already added */) {
|
||||
if (!XLogRecPtrIsInvalid(so->stack->parentlsn) &&
|
||||
XLByteLT(so->stack->parentlsn, opaque->nsn) &&
|
||||
opaque->rightlink != InvalidBlockNumber /* sanity check */ &&
|
||||
(so->stack->next == NULL || so->stack->next->block != opaque->rightlink) /* check if already
|
||||
added */ )
|
||||
{
|
||||
/* detect page split, follow right link to add pages */
|
||||
|
||||
stk = (GISTSearchStack*) palloc( sizeof(GISTSearchStack) );
|
||||
|
||||
stk = (GISTSearchStack *) palloc(sizeof(GISTSearchStack));
|
||||
stk->next = so->stack->next;
|
||||
stk->block = opaque->rightlink;
|
||||
stk->parentlsn = so->stack->parentlsn;
|
||||
memset( &(stk->lsn), 0, sizeof(GistNSN) );
|
||||
memset(&(stk->lsn), 0, sizeof(GistNSN));
|
||||
so->stack->next = stk;
|
||||
}
|
||||
}
|
||||
|
||||
/* if page is empty, then just skip it */
|
||||
if ( PageIsEmpty(p) ) {
|
||||
LockBuffer( so->curbuf, GIST_UNLOCK );
|
||||
if (PageIsEmpty(p))
|
||||
{
|
||||
LockBuffer(so->curbuf, GIST_UNLOCK);
|
||||
stk = so->stack->next;
|
||||
pfree( so->stack );
|
||||
pfree(so->stack);
|
||||
so->stack = stk;
|
||||
|
||||
if (so->stack == NULL) {
|
||||
if (so->stack == NULL)
|
||||
{
|
||||
ReleaseBuffer(so->curbuf);
|
||||
so->curbuf = InvalidBuffer;
|
||||
return ntids;
|
||||
}
|
||||
|
||||
so->curbuf = ReleaseAndReadBuffer(so->curbuf, scan->indexRelation,
|
||||
stk->block);
|
||||
stk->block);
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -215,33 +230,33 @@ gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, b
|
||||
else
|
||||
{
|
||||
n = ItemPointerGetOffsetNumber(&(scan->currentItemData));
|
||||
|
||||
|
||||
if (ScanDirectionIsBackward(dir))
|
||||
n = OffsetNumberPrev(n);
|
||||
else
|
||||
n = OffsetNumberNext(n);
|
||||
}
|
||||
|
||||
/* wonderfull, we can look at page */
|
||||
/* wonderfull, we can look at page */
|
||||
|
||||
for(;;)
|
||||
for (;;)
|
||||
{
|
||||
n = gistfindnext(scan, n, dir);
|
||||
|
||||
if (!OffsetNumberIsValid(n))
|
||||
{
|
||||
/*
|
||||
* We ran out of matching index entries on the current
|
||||
* page, so pop the top stack entry and use it to continue
|
||||
* the search.
|
||||
* We ran out of matching index entries on the current page,
|
||||
* so pop the top stack entry and use it to continue the
|
||||
* search.
|
||||
*/
|
||||
LockBuffer( so->curbuf, GIST_UNLOCK );
|
||||
LockBuffer(so->curbuf, GIST_UNLOCK);
|
||||
stk = so->stack->next;
|
||||
pfree( so->stack );
|
||||
pfree(so->stack);
|
||||
so->stack = stk;
|
||||
|
||||
/* If we're out of stack entries, we're done */
|
||||
|
||||
|
||||
if (so->stack == NULL)
|
||||
{
|
||||
ReleaseBuffer(so->curbuf);
|
||||
@ -250,8 +265,8 @@ gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, b
|
||||
}
|
||||
|
||||
so->curbuf = ReleaseAndReadBuffer(so->curbuf, scan->indexRelation,
|
||||
stk->block);
|
||||
/* XXX go up */
|
||||
stk->block);
|
||||
/* XXX go up */
|
||||
break;
|
||||
}
|
||||
|
||||
@ -259,20 +274,22 @@ gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, b
|
||||
{
|
||||
/*
|
||||
* We've found a matching index entry in a leaf page, so
|
||||
* return success. Note that we keep "curbuf" pinned so
|
||||
* that we can efficiently resume the index scan later.
|
||||
* return success. Note that we keep "curbuf" pinned so that
|
||||
* we can efficiently resume the index scan later.
|
||||
*/
|
||||
|
||||
ItemPointerSet(&(scan->currentItemData),
|
||||
BufferGetBlockNumber(so->curbuf), n);
|
||||
BufferGetBlockNumber(so->curbuf), n);
|
||||
|
||||
if ( ! ( ignore_killed_tuples && ItemIdDeleted(PageGetItemId(p, n)) ) ) {
|
||||
if (!(ignore_killed_tuples && ItemIdDeleted(PageGetItemId(p, n))))
|
||||
{
|
||||
it = (IndexTuple) PageGetItem(p, PageGetItemId(p, n));
|
||||
tids[ntids] = scan->xs_ctup.t_self = it->t_tid;
|
||||
ntids++;
|
||||
|
||||
if ( ntids == maxtids ) {
|
||||
LockBuffer( so->curbuf, GIST_UNLOCK );
|
||||
if (ntids == maxtids)
|
||||
{
|
||||
LockBuffer(so->curbuf, GIST_UNLOCK);
|
||||
return ntids;
|
||||
}
|
||||
}
|
||||
@ -281,14 +298,14 @@ gistnext(IndexScanDesc scan, ScanDirection dir, ItemPointer tids, int maxtids, b
|
||||
{
|
||||
/*
|
||||
* We've found an entry in an internal node whose key is
|
||||
* consistent with the search key, so push it to stack
|
||||
* consistent with the search key, so push it to stack
|
||||
*/
|
||||
|
||||
stk = (GISTSearchStack *) palloc(sizeof(GISTSearchStack));
|
||||
|
||||
it = (IndexTuple) PageGetItem(p, PageGetItemId(p, n));
|
||||
stk->block = ItemPointerGetBlockNumber(&(it->t_tid));
|
||||
memset( &(stk->lsn), 0, sizeof(GistNSN) );
|
||||
memset(&(stk->lsn), 0, sizeof(GistNSN));
|
||||
stk->parentlsn = so->stack->lsn;
|
||||
|
||||
stk->next = so->stack->next;
|
||||
@ -320,12 +337,12 @@ gistindex_keytest(IndexTuple tuple,
|
||||
IndexScanDesc scan,
|
||||
OffsetNumber offset)
|
||||
{
|
||||
int keySize = scan->numberOfKeys;
|
||||
ScanKey key = scan->keyData;
|
||||
Relation r = scan->indexRelation;
|
||||
int keySize = scan->numberOfKeys;
|
||||
ScanKey key = scan->keyData;
|
||||
Relation r = scan->indexRelation;
|
||||
GISTScanOpaque so;
|
||||
Page p;
|
||||
GISTSTATE *giststate;
|
||||
Page p;
|
||||
GISTSTATE *giststate;
|
||||
|
||||
so = (GISTScanOpaque) scan->opaque;
|
||||
giststate = so->giststate;
|
||||
@ -334,9 +351,10 @@ gistindex_keytest(IndexTuple tuple,
|
||||
IncrIndexProcessed();
|
||||
|
||||
/*
|
||||
* Tuple doesn't restore after crash recovery because of inclomplete insert
|
||||
*/
|
||||
if ( !GistPageIsLeaf(p) && GistTupleIsInvalid(tuple) )
|
||||
* Tuple doesn't restore after crash recovery because of inclomplete
|
||||
* insert
|
||||
*/
|
||||
if (!GistPageIsLeaf(p) && GistTupleIsInvalid(tuple))
|
||||
return true;
|
||||
|
||||
while (keySize > 0)
|
||||
@ -366,13 +384,12 @@ gistindex_keytest(IndexTuple tuple,
|
||||
FALSE, isNull);
|
||||
|
||||
/*
|
||||
* Call the Consistent function to evaluate the test. The
|
||||
* arguments are the index datum (as a GISTENTRY*), the comparison
|
||||
* datum, and the comparison operator's strategy number and
|
||||
* subtype from pg_amop.
|
||||
* Call the Consistent function to evaluate the test. The arguments
|
||||
* are the index datum (as a GISTENTRY*), the comparison datum, and
|
||||
* the comparison operator's strategy number and subtype from pg_amop.
|
||||
*
|
||||
* (Presently there's no need to pass the subtype since it'll always
|
||||
* be zero, but might as well pass it for possible future use.)
|
||||
* (Presently there's no need to pass the subtype since it'll always be
|
||||
* zero, but might as well pass it for possible future use.)
|
||||
*/
|
||||
test = FunctionCall4(&key->sk_func,
|
||||
PointerGetDatum(&de),
|
||||
@ -399,26 +416,26 @@ gistindex_keytest(IndexTuple tuple,
|
||||
static OffsetNumber
|
||||
gistfindnext(IndexScanDesc scan, OffsetNumber n, ScanDirection dir)
|
||||
{
|
||||
OffsetNumber maxoff;
|
||||
IndexTuple it;
|
||||
GISTScanOpaque so;
|
||||
MemoryContext oldcxt;
|
||||
Page p;
|
||||
OffsetNumber maxoff;
|
||||
IndexTuple it;
|
||||
GISTScanOpaque so;
|
||||
MemoryContext oldcxt;
|
||||
Page p;
|
||||
|
||||
so = (GISTScanOpaque) scan->opaque;
|
||||
p = BufferGetPage(so->curbuf);
|
||||
maxoff = PageGetMaxOffsetNumber(p);
|
||||
|
||||
/*
|
||||
* Make sure we're in a short-lived memory context when we invoke
|
||||
* a user-supplied GiST method in gistindex_keytest(), so we don't
|
||||
* leak memory
|
||||
* Make sure we're in a short-lived memory context when we invoke a
|
||||
* user-supplied GiST method in gistindex_keytest(), so we don't leak
|
||||
* memory
|
||||
*/
|
||||
oldcxt = MemoryContextSwitchTo(so->tempCxt);
|
||||
|
||||
/*
|
||||
* If we modified the index during the scan, we may have a pointer to
|
||||
* a ghost tuple, before the scan. If this is the case, back up one.
|
||||
* If we modified the index during the scan, we may have a pointer to a
|
||||
* ghost tuple, before the scan. If this is the case, back up one.
|
||||
*/
|
||||
if (so->flags & GS_CURBEFORE)
|
||||
{
|
||||
@ -442,9 +459,8 @@ gistfindnext(IndexScanDesc scan, OffsetNumber n, ScanDirection dir)
|
||||
MemoryContextReset(so->tempCxt);
|
||||
|
||||
/*
|
||||
* If we found a matching entry, return its offset; otherwise
|
||||
* return InvalidOffsetNumber to inform the caller to go to the
|
||||
* next page.
|
||||
* If we found a matching entry, return its offset; otherwise return
|
||||
* InvalidOffsetNumber to inform the caller to go to the next page.
|
||||
*/
|
||||
if (n >= FirstOffsetNumber && n <= maxoff)
|
||||
return n;
|
||||
|
@ -10,7 +10,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistproc.c,v 1.1 2005/07/01 19:19:02 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistproc.c,v 1.2 2005/09/22 20:44:36 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -30,10 +30,10 @@ typedef struct
|
||||
|
||||
static int compare_KB(const void *a, const void *b);
|
||||
static bool gist_box_leaf_consistent(BOX *key, BOX *query,
|
||||
StrategyNumber strategy);
|
||||
StrategyNumber strategy);
|
||||
static double size_box(Datum dbox);
|
||||
static bool rtree_internal_consistent(BOX *key, BOX *query,
|
||||
StrategyNumber strategy);
|
||||
StrategyNumber strategy);
|
||||
|
||||
|
||||
/**************************************************
|
||||
@ -268,11 +268,11 @@ gist_box_picksplit(PG_FUNCTION_ARGS)
|
||||
#define ADDLIST( list, unionD, pos, num ) do { \
|
||||
if ( pos ) { \
|
||||
if ( (unionD)->high.x < cur->high.x ) (unionD)->high.x = cur->high.x; \
|
||||
if ( (unionD)->low.x > cur->low.x ) (unionD)->low.x = cur->low.x; \
|
||||
if ( (unionD)->low.x > cur->low.x ) (unionD)->low.x = cur->low.x; \
|
||||
if ( (unionD)->high.y < cur->high.y ) (unionD)->high.y = cur->high.y; \
|
||||
if ( (unionD)->low.y > cur->low.y ) (unionD)->low.y = cur->low.y; \
|
||||
if ( (unionD)->low.y > cur->low.y ) (unionD)->low.y = cur->low.y; \
|
||||
} else { \
|
||||
memcpy( (void*)(unionD), (void*) cur, sizeof( BOX ) ); \
|
||||
memcpy( (void*)(unionD), (void*) cur, sizeof( BOX ) ); \
|
||||
} \
|
||||
(list)[pos] = num; \
|
||||
(pos)++; \
|
||||
@ -411,62 +411,62 @@ gist_box_leaf_consistent(BOX *key, BOX *query, StrategyNumber strategy)
|
||||
case RTLeftStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_left,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverLeftStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_overleft,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverlapStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_overlap,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverRightStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_overright,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTRightStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_right,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTSameStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_same,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTContainsStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_contain,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTContainedByStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_contained,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverBelowStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_overbelow,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTBelowStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_below,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTAboveStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_above,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverAboveStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_overabove,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
default:
|
||||
retval = FALSE;
|
||||
@ -477,7 +477,7 @@ gist_box_leaf_consistent(BOX *key, BOX *query, StrategyNumber strategy)
|
||||
static double
|
||||
size_box(Datum dbox)
|
||||
{
|
||||
BOX *box = DatumGetBoxP(dbox);
|
||||
BOX *box = DatumGetBoxP(dbox);
|
||||
|
||||
if (box == NULL || box->high.x <= box->low.x || box->high.y <= box->low.y)
|
||||
return 0.0;
|
||||
@ -506,58 +506,58 @@ rtree_internal_consistent(BOX *key, BOX *query, StrategyNumber strategy)
|
||||
case RTLeftStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_overright,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverLeftStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_right,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverlapStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_overlap,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverRightStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_left,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTRightStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_overleft,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTSameStrategyNumber:
|
||||
case RTContainsStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_contain,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTContainedByStrategyNumber:
|
||||
retval = DatumGetBool(DirectFunctionCall2(box_overlap,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverBelowStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_above,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTBelowStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_overabove,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTAboveStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_overbelow,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
case RTOverAboveStrategyNumber:
|
||||
retval = !DatumGetBool(DirectFunctionCall2(box_below,
|
||||
PointerGetDatum(key),
|
||||
PointerGetDatum(query)));
|
||||
PointerGetDatum(query)));
|
||||
break;
|
||||
default:
|
||||
retval = FALSE;
|
||||
@ -621,8 +621,8 @@ gist_poly_consistent(PG_FUNCTION_ARGS)
|
||||
|
||||
/*
|
||||
* Since the operators are marked lossy anyway, we can just use
|
||||
* rtree_internal_consistent even at leaf nodes. (This works
|
||||
* in part because the index entries are bounding boxes not polygons.)
|
||||
* rtree_internal_consistent even at leaf nodes. (This works in part
|
||||
* because the index entries are bounding boxes not polygons.)
|
||||
*/
|
||||
result = rtree_internal_consistent(DatumGetBoxP(entry->key),
|
||||
&(query->boundbox), strategy);
|
||||
@ -651,7 +651,7 @@ gist_circle_compress(PG_FUNCTION_ARGS)
|
||||
retval = palloc(sizeof(GISTENTRY));
|
||||
if (DatumGetCircleP(entry->key) != NULL)
|
||||
{
|
||||
CIRCLE *in = DatumGetCircleP(entry->key);
|
||||
CIRCLE *in = DatumGetCircleP(entry->key);
|
||||
BOX *r;
|
||||
|
||||
r = (BOX *) palloc(sizeof(BOX));
|
||||
@ -683,7 +683,7 @@ Datum
|
||||
gist_circle_consistent(PG_FUNCTION_ARGS)
|
||||
{
|
||||
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
|
||||
CIRCLE *query = PG_GETARG_CIRCLE_P(1);
|
||||
CIRCLE *query = PG_GETARG_CIRCLE_P(1);
|
||||
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
|
||||
BOX bbox;
|
||||
bool result;
|
||||
@ -693,8 +693,8 @@ gist_circle_consistent(PG_FUNCTION_ARGS)
|
||||
|
||||
/*
|
||||
* Since the operators are marked lossy anyway, we can just use
|
||||
* rtree_internal_consistent even at leaf nodes. (This works
|
||||
* in part because the index entries are bounding boxes not circles.)
|
||||
* rtree_internal_consistent even at leaf nodes. (This works in part
|
||||
* because the index entries are bounding boxes not circles.)
|
||||
*/
|
||||
bbox.high.x = query->center.x + query->radius;
|
||||
bbox.low.x = query->center.x - query->radius;
|
||||
|
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistscan.c,v 1.60 2005/09/22 18:49:45 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistscan.c,v 1.61 2005/09/22 20:44:36 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -120,11 +120,11 @@ gistrescan(PG_FUNCTION_ARGS)
|
||||
scan->numberOfKeys * sizeof(ScanKeyData));
|
||||
|
||||
/*
|
||||
* Modify the scan key so that all the Consistent method is
|
||||
* called for all comparisons. The original operator is passed
|
||||
* to the Consistent function in the form of its strategy
|
||||
* number, which is available from the sk_strategy field, and
|
||||
* its subtype from the sk_subtype field.
|
||||
* Modify the scan key so that all the Consistent method is called for
|
||||
* all comparisons. The original operator is passed to the Consistent
|
||||
* function in the form of its strategy number, which is available
|
||||
* from the sk_strategy field, and its subtype from the sk_subtype
|
||||
* field.
|
||||
*/
|
||||
for (i = 0; i < scan->numberOfKeys; i++)
|
||||
scan->keyData[i].sk_func = so->giststate->consistentFn[scan->keyData[i].sk_attno - 1];
|
||||
@ -138,7 +138,7 @@ gistmarkpos(PG_FUNCTION_ARGS)
|
||||
{
|
||||
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
|
||||
GISTScanOpaque so;
|
||||
GISTSearchStack *o,
|
||||
GISTSearchStack *o,
|
||||
*n,
|
||||
*tmp;
|
||||
|
||||
@ -187,7 +187,7 @@ gistrestrpos(PG_FUNCTION_ARGS)
|
||||
{
|
||||
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
|
||||
GISTScanOpaque so;
|
||||
GISTSearchStack *o,
|
||||
GISTSearchStack *o,
|
||||
*n,
|
||||
*tmp;
|
||||
|
||||
@ -308,9 +308,9 @@ ReleaseResources_gist(void)
|
||||
GISTScanList next;
|
||||
|
||||
/*
|
||||
* Note: this should be a no-op during normal query shutdown. However,
|
||||
* in an abort situation ExecutorEnd is not called and so there may be
|
||||
* open index scans to clean up.
|
||||
* Note: this should be a no-op during normal query shutdown. However, in
|
||||
* an abort situation ExecutorEnd is not called and so there may be open
|
||||
* index scans to clean up.
|
||||
*/
|
||||
prev = NULL;
|
||||
|
||||
@ -338,8 +338,8 @@ gistadjscans(Relation rel, int op, BlockNumber blkno, OffsetNumber offnum, XLogR
|
||||
GISTScanList l;
|
||||
Oid relid;
|
||||
|
||||
if ( XLogRecPtrIsInvalid(newlsn) || XLogRecPtrIsInvalid(oldlsn) )
|
||||
return;
|
||||
if (XLogRecPtrIsInvalid(newlsn) || XLogRecPtrIsInvalid(oldlsn))
|
||||
return;
|
||||
|
||||
relid = RelationGetRelid(rel);
|
||||
for (l = GISTScans; l != NULL; l = l->gsl_next)
|
||||
@ -365,7 +365,7 @@ gistadjone(IndexScanDesc scan,
|
||||
BlockNumber blkno,
|
||||
OffsetNumber offnum, XLogRecPtr newlsn, XLogRecPtr oldlsn)
|
||||
{
|
||||
GISTScanOpaque so = (GISTScanOpaque) scan->opaque ;
|
||||
GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
|
||||
|
||||
adjustiptr(scan, &(scan->currentItemData), so->stack, op, blkno, offnum, newlsn, oldlsn);
|
||||
adjustiptr(scan, &(scan->currentMarkData), so->markstk, op, blkno, offnum, newlsn, oldlsn);
|
||||
@ -399,7 +399,8 @@ adjustiptr(IndexScanDesc scan,
|
||||
{
|
||||
case GISTOP_DEL:
|
||||
/* back up one if we need to */
|
||||
if (curoff >= offnum && XLByteEQ(stk->lsn, oldlsn) ) /* the same vesrion of page */
|
||||
if (curoff >= offnum && XLByteEQ(stk->lsn, oldlsn)) /* the same vesrion of
|
||||
* page */
|
||||
{
|
||||
if (curoff > FirstOffsetNumber)
|
||||
{
|
||||
@ -409,8 +410,7 @@ adjustiptr(IndexScanDesc scan,
|
||||
else
|
||||
{
|
||||
/*
|
||||
* remember that we're before the current
|
||||
* tuple
|
||||
* remember that we're before the current tuple
|
||||
*/
|
||||
ItemPointerSet(iptr, blkno, FirstOffsetNumber);
|
||||
if (iptr == &(scan->currentItemData))
|
||||
@ -435,6 +435,7 @@ gistfreestack(GISTSearchStack *s)
|
||||
while (s != NULL)
|
||||
{
|
||||
GISTSearchStack *p = s->next;
|
||||
|
||||
pfree(s);
|
||||
s = p;
|
||||
}
|
||||
|
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistutil.c,v 1.6 2005/09/22 18:49:45 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistutil.c,v 1.7 2005/09/22 20:44:36 momjian Exp $
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
@ -22,9 +22,9 @@
|
||||
#include "storage/freespace.h"
|
||||
|
||||
/* group flags ( in gistadjsubkey ) */
|
||||
#define LEFT_ADDED 0x01
|
||||
#define LEFT_ADDED 0x01
|
||||
#define RIGHT_ADDED 0x02
|
||||
#define BOTH_ADDED ( LEFT_ADDED | RIGHT_ADDED )
|
||||
#define BOTH_ADDED ( LEFT_ADDED | RIGHT_ADDED )
|
||||
|
||||
|
||||
/*
|
||||
@ -47,8 +47,7 @@
|
||||
} while(0);
|
||||
|
||||
|
||||
static void
|
||||
gistpenalty(GISTSTATE *giststate, int attno,
|
||||
static void gistpenalty(GISTSTATE *giststate, int attno,
|
||||
GISTENTRY *key1, bool isNull1,
|
||||
GISTENTRY *key2, bool isNull2, float *penalty);
|
||||
|
||||
@ -57,13 +56,13 @@ gistpenalty(GISTSTATE *giststate, int attno,
|
||||
*/
|
||||
OffsetNumber
|
||||
gistfillbuffer(Relation r, Page page, IndexTuple *itup,
|
||||
int len, OffsetNumber off)
|
||||
int len, OffsetNumber off)
|
||||
{
|
||||
OffsetNumber l = InvalidOffsetNumber;
|
||||
int i;
|
||||
|
||||
if ( off == InvalidOffsetNumber )
|
||||
off = ( PageIsEmpty(page) ) ? FirstOffsetNumber :
|
||||
if (off == InvalidOffsetNumber)
|
||||
off = (PageIsEmpty(page)) ? FirstOffsetNumber :
|
||||
OffsetNumberNext(PageGetMaxOffsetNumber(page));
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
@ -137,13 +136,13 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||
GistEntryVector *evec;
|
||||
int i;
|
||||
GISTENTRY centry[INDEX_MAX_KEYS];
|
||||
IndexTuple res;
|
||||
IndexTuple res;
|
||||
|
||||
evec = (GistEntryVector *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + GEVHDRSZ);
|
||||
|
||||
for(i = 0; i<len; i++)
|
||||
if ( GistTupleIsInvalid( itvec[i] ) )
|
||||
return gist_form_invalid_tuple( InvalidBlockNumber );
|
||||
for (i = 0; i < len; i++)
|
||||
if (GistTupleIsInvalid(itvec[i]))
|
||||
return gist_form_invalid_tuple(InvalidBlockNumber);
|
||||
|
||||
for (i = 0; i < r->rd_att->natts; i++)
|
||||
{
|
||||
@ -155,6 +154,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||
for (j = 0; j < len; j++)
|
||||
{
|
||||
bool IsNull;
|
||||
|
||||
datum = index_getattr(itvec[j], i + 1, giststate->tupdesc, &IsNull);
|
||||
if (IsNull)
|
||||
continue;
|
||||
@ -176,7 +176,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||
}
|
||||
else
|
||||
{
|
||||
int datumsize;
|
||||
int datumsize;
|
||||
|
||||
if (real_len == 1)
|
||||
{
|
||||
@ -202,7 +202,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||
}
|
||||
|
||||
res = index_form_tuple(giststate->tupdesc, attr, isnull);
|
||||
GistTupleSetValid( res );
|
||||
GistTupleSetValid(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
@ -227,9 +227,9 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
|
||||
IndexTuple newtup = NULL;
|
||||
int i;
|
||||
|
||||
if ( GistTupleIsInvalid(oldtup) || GistTupleIsInvalid(addtup) )
|
||||
return gist_form_invalid_tuple( ItemPointerGetBlockNumber( &(oldtup->t_tid) ) );
|
||||
|
||||
if (GistTupleIsInvalid(oldtup) || GistTupleIsInvalid(addtup))
|
||||
return gist_form_invalid_tuple(ItemPointerGetBlockNumber(&(oldtup->t_tid)));
|
||||
|
||||
evec = palloc(2 * sizeof(GISTENTRY) + GEVHDRSZ);
|
||||
evec->n = 2;
|
||||
ev0p = &(evec->vector[0]);
|
||||
@ -268,7 +268,7 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
|
||||
}
|
||||
else
|
||||
{
|
||||
bool result;
|
||||
bool result;
|
||||
|
||||
FunctionCall3(&giststate->equalFn[i],
|
||||
ev0p->key,
|
||||
@ -301,7 +301,7 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
|
||||
void
|
||||
gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITVEC *spl, bool isall)
|
||||
{
|
||||
int lr;
|
||||
int lr;
|
||||
|
||||
for (lr = 0; lr < 2; lr++)
|
||||
{
|
||||
@ -309,7 +309,7 @@ gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITV
|
||||
int i;
|
||||
Datum *attr;
|
||||
int len,
|
||||
*attrsize;
|
||||
*attrsize;
|
||||
bool *isnull;
|
||||
GistEntryVector *evec;
|
||||
|
||||
@ -354,7 +354,7 @@ gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITV
|
||||
&(evec->vector[real_len]),
|
||||
datum,
|
||||
NULL, NULL, (OffsetNumber) 0,
|
||||
ATTSIZE(datum, giststate->tupdesc, i + 1, IsNull),
|
||||
ATTSIZE(datum, giststate->tupdesc, i + 1, IsNull),
|
||||
FALSE, IsNull);
|
||||
real_len++;
|
||||
|
||||
@ -402,14 +402,14 @@ gistfindgroup(GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC *spl)
|
||||
int curid = 1;
|
||||
|
||||
/*
|
||||
* first key is always not null (see gistinsert), so we may not check
|
||||
* for nulls
|
||||
* first key is always not null (see gistinsert), so we may not check for
|
||||
* nulls
|
||||
*/
|
||||
for (i = 0; i < spl->spl_nleft; i++)
|
||||
{
|
||||
int j;
|
||||
int len;
|
||||
bool result;
|
||||
int j;
|
||||
int len;
|
||||
bool result;
|
||||
|
||||
if (spl->spl_idgrp[spl->spl_left[i]])
|
||||
continue;
|
||||
@ -540,12 +540,12 @@ gistadjsubkey(Relation r,
|
||||
for (j = 1; j < r->rd_att->natts; j++)
|
||||
{
|
||||
gistentryinit(entry, v->spl_lattr[j], r, NULL,
|
||||
(OffsetNumber) 0, v->spl_lattrsize[j], FALSE);
|
||||
(OffsetNumber) 0, v->spl_lattrsize[j], FALSE);
|
||||
gistpenalty(giststate, j, &entry, v->spl_lisnull[j],
|
||||
&identry[j], isnull[j], &lpenalty);
|
||||
|
||||
gistentryinit(entry, v->spl_rattr[j], r, NULL,
|
||||
(OffsetNumber) 0, v->spl_rattrsize[j], FALSE);
|
||||
(OffsetNumber) 0, v->spl_rattrsize[j], FALSE);
|
||||
gistpenalty(giststate, j, &entry, v->spl_risnull[j],
|
||||
&identry[j], isnull[j], &rpenalty);
|
||||
|
||||
@ -555,8 +555,7 @@ gistadjsubkey(Relation r,
|
||||
}
|
||||
|
||||
/*
|
||||
* add
|
||||
* XXX: refactor this to avoid duplicating code
|
||||
* add XXX: refactor this to avoid duplicating code
|
||||
*/
|
||||
if (lpenalty < rpenalty)
|
||||
{
|
||||
@ -643,12 +642,13 @@ gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */
|
||||
{
|
||||
int j;
|
||||
IndexTuple itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
|
||||
|
||||
if ( !GistPageIsLeaf(p) && GistTupleIsInvalid(itup) ) {
|
||||
|
||||
if (!GistPageIsLeaf(p) && GistTupleIsInvalid(itup))
|
||||
{
|
||||
ereport(LOG,
|
||||
(errmsg("index \"%s\" needs VACUUM or REINDEX to finish crash recovery",
|
||||
RelationGetRelationName(r))));
|
||||
continue;
|
||||
continue;
|
||||
}
|
||||
|
||||
sum_grow = 0;
|
||||
@ -683,7 +683,7 @@ gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */
|
||||
}
|
||||
}
|
||||
|
||||
if ( which == InvalidOffsetNumber )
|
||||
if (which == InvalidOffsetNumber)
|
||||
which = FirstOffsetNumber;
|
||||
|
||||
return which;
|
||||
@ -775,7 +775,8 @@ gistDeCompressAtt(GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p,
|
||||
|
||||
for (i = 0; i < r->rd_att->natts; i++)
|
||||
{
|
||||
Datum datum = index_getattr(tuple, i + 1, giststate->tupdesc, &isnull[i]);
|
||||
Datum datum = index_getattr(tuple, i + 1, giststate->tupdesc, &isnull[i]);
|
||||
|
||||
gistdentryinit(giststate, i, &attdata[i],
|
||||
datum, r, p, o,
|
||||
ATTSIZE(datum, giststate->tupdesc, i + 1, isnull[i]),
|
||||
@ -801,8 +802,8 @@ void
|
||||
GISTInitBuffer(Buffer b, uint32 f)
|
||||
{
|
||||
GISTPageOpaque opaque;
|
||||
Page page;
|
||||
Size pageSize;
|
||||
Page page;
|
||||
Size pageSize;
|
||||
|
||||
pageSize = BufferGetPageSize(b);
|
||||
page = BufferGetPage(b);
|
||||
@ -811,15 +812,16 @@ GISTInitBuffer(Buffer b, uint32 f)
|
||||
opaque = GistPageGetOpaque(page);
|
||||
opaque->flags = f;
|
||||
opaque->rightlink = InvalidBlockNumber;
|
||||
memset( &(opaque->nsn), 0, sizeof(GistNSN) );
|
||||
memset(&(opaque->nsn), 0, sizeof(GistNSN));
|
||||
}
|
||||
|
||||
void
|
||||
gistUserPicksplit(Relation r, GistEntryVector *entryvec, GIST_SPLITVEC *v,
|
||||
IndexTuple *itup, int len, GISTSTATE *giststate) {
|
||||
gistUserPicksplit(Relation r, GistEntryVector *entryvec, GIST_SPLITVEC *v,
|
||||
IndexTuple *itup, int len, GISTSTATE *giststate)
|
||||
{
|
||||
/*
|
||||
* now let the user-defined picksplit function set up the split
|
||||
* vector; in entryvec have no null value!!
|
||||
* now let the user-defined picksplit function set up the split vector; in
|
||||
* entryvec have no null value!!
|
||||
*/
|
||||
FunctionCall2(&giststate->picksplitFn[0],
|
||||
PointerGetDatum(entryvec),
|
||||
@ -837,8 +839,8 @@ gistUserPicksplit(Relation r, GistEntryVector *entryvec, GIST_SPLITVEC *v,
|
||||
v->spl_risnull[0] = false;
|
||||
|
||||
/*
|
||||
* if index is multikey, then we must to try get smaller bounding box
|
||||
* for subkey(s)
|
||||
* if index is multikey, then we must to try get smaller bounding box for
|
||||
* subkey(s)
|
||||
*/
|
||||
if (r->rd_att->natts > 1)
|
||||
{
|
||||
@ -854,35 +856,42 @@ gistUserPicksplit(Relation r, GistEntryVector *entryvec, GIST_SPLITVEC *v,
|
||||
gistunionsubkey(r, giststate, itup, v, false);
|
||||
|
||||
/*
|
||||
* if possible, we insert equivalent tuples with control by
|
||||
* penalty for a subkey(s)
|
||||
* if possible, we insert equivalent tuples with control by penalty
|
||||
* for a subkey(s)
|
||||
*/
|
||||
if (MaxGrpId > 1)
|
||||
gistadjsubkey(r, itup, len, v, giststate);
|
||||
}
|
||||
}
|
||||
|
||||
Buffer
|
||||
gistNewBuffer(Relation r) {
|
||||
Buffer buffer = InvalidBuffer;
|
||||
bool needLock;
|
||||
Buffer
|
||||
gistNewBuffer(Relation r)
|
||||
{
|
||||
Buffer buffer = InvalidBuffer;
|
||||
bool needLock;
|
||||
|
||||
while(true) {
|
||||
while (true)
|
||||
{
|
||||
BlockNumber blkno = GetFreeIndexPage(&r->rd_node);
|
||||
|
||||
if (blkno == InvalidBlockNumber)
|
||||
break;
|
||||
|
||||
buffer = ReadBuffer(r, blkno);
|
||||
if ( ConditionalLockBuffer(buffer) ) {
|
||||
Page page = BufferGetPage(buffer);
|
||||
if ( GistPageIsDeleted( page ) ) {
|
||||
GistPageSetNonDeleted( page );
|
||||
if (ConditionalLockBuffer(buffer))
|
||||
{
|
||||
Page page = BufferGetPage(buffer);
|
||||
|
||||
if (GistPageIsDeleted(page))
|
||||
{
|
||||
GistPageSetNonDeleted(page);
|
||||
return buffer;
|
||||
} else
|
||||
}
|
||||
else
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
}
|
||||
|
||||
ReleaseBuffer( buffer );
|
||||
ReleaseBuffer(buffer);
|
||||
}
|
||||
|
||||
needLock = !RELATION_IS_LOCAL(r);
|
||||
@ -895,6 +904,6 @@ gistNewBuffer(Relation r) {
|
||||
|
||||
if (needLock)
|
||||
UnlockRelationForExtension(r, ExclusiveLock);
|
||||
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistvacuum.c,v 1.8 2005/09/22 18:49:45 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/access/gist/gistvacuum.c,v 1.9 2005/09/22 20:44:36 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -25,162 +25,198 @@
|
||||
#include "storage/freespace.h"
|
||||
#include "storage/smgr.h"
|
||||
|
||||
/* filled by gistbulkdelete, cleared by gistvacuumpcleanup */
|
||||
static bool needFullVacuum = false;
|
||||
/* filled by gistbulkdelete, cleared by gistvacuumpcleanup */
|
||||
static bool needFullVacuum = false;
|
||||
|
||||
|
||||
typedef struct {
|
||||
typedef struct
|
||||
{
|
||||
GISTSTATE giststate;
|
||||
Relation index;
|
||||
MemoryContext opCtx;
|
||||
IndexBulkDeleteResult *result;
|
||||
MemoryContext opCtx;
|
||||
IndexBulkDeleteResult *result;
|
||||
} GistVacuum;
|
||||
|
||||
typedef struct {
|
||||
IndexTuple *itup;
|
||||
int ituplen;
|
||||
typedef struct
|
||||
{
|
||||
IndexTuple *itup;
|
||||
int ituplen;
|
||||
bool emptypage;
|
||||
} ArrayTuple;
|
||||
|
||||
static ArrayTuple
|
||||
gistVacuumUpdate( GistVacuum *gv, BlockNumber blkno, bool needunion ) {
|
||||
gistVacuumUpdate(GistVacuum *gv, BlockNumber blkno, bool needunion)
|
||||
{
|
||||
ArrayTuple res = {NULL, 0, false};
|
||||
Buffer buffer;
|
||||
Page page;
|
||||
OffsetNumber i, maxoff;
|
||||
OffsetNumber i,
|
||||
maxoff;
|
||||
ItemId iid;
|
||||
int lenaddon=4, curlenaddon=0, ntodelete=0;
|
||||
IndexTuple idxtuple, *addon=NULL;
|
||||
bool needwrite=false;
|
||||
OffsetNumber todelete[MaxOffsetNumber];
|
||||
ItemPointerData *completed=NULL;
|
||||
int ncompleted=0, lencompleted=16;
|
||||
int lenaddon = 4,
|
||||
curlenaddon = 0,
|
||||
ntodelete = 0;
|
||||
IndexTuple idxtuple,
|
||||
*addon = NULL;
|
||||
bool needwrite = false;
|
||||
OffsetNumber todelete[MaxOffsetNumber];
|
||||
ItemPointerData *completed = NULL;
|
||||
int ncompleted = 0,
|
||||
lencompleted = 16;
|
||||
|
||||
buffer = ReadBuffer(gv->index, blkno);
|
||||
page = (Page) BufferGetPage(buffer);
|
||||
maxoff = PageGetMaxOffsetNumber(page);
|
||||
|
||||
if ( GistPageIsLeaf(page) ) {
|
||||
if ( GistTuplesDeleted(page) ) {
|
||||
if (GistPageIsLeaf(page))
|
||||
{
|
||||
if (GistTuplesDeleted(page))
|
||||
{
|
||||
needunion = needwrite = true;
|
||||
GistClearTuplesDeleted(page);
|
||||
}
|
||||
} else {
|
||||
completed = (ItemPointerData*)palloc( sizeof(ItemPointerData)*lencompleted );
|
||||
addon=(IndexTuple*)palloc(sizeof(IndexTuple)*lenaddon);
|
||||
}
|
||||
else
|
||||
{
|
||||
completed = (ItemPointerData *) palloc(sizeof(ItemPointerData) * lencompleted);
|
||||
addon = (IndexTuple *) palloc(sizeof(IndexTuple) * lenaddon);
|
||||
|
||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
|
||||
ArrayTuple chldtuple;
|
||||
bool needchildunion;
|
||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
||||
{
|
||||
ArrayTuple chldtuple;
|
||||
bool needchildunion;
|
||||
|
||||
iid = PageGetItemId(page, i);
|
||||
idxtuple = (IndexTuple) PageGetItem(page, iid);
|
||||
needchildunion = (GistTupleIsInvalid(idxtuple)) ? true : false;
|
||||
|
||||
if ( needchildunion )
|
||||
|
||||
if (needchildunion)
|
||||
elog(DEBUG2, "gistVacuumUpdate: need union for block %u",
|
||||
ItemPointerGetBlockNumber(&(idxtuple->t_tid)));
|
||||
|
||||
chldtuple = gistVacuumUpdate( gv, ItemPointerGetBlockNumber(&(idxtuple->t_tid)),
|
||||
needchildunion );
|
||||
if ( chldtuple.ituplen || chldtuple.emptypage ) {
|
||||
PageIndexTupleDelete(page, i);
|
||||
todelete[ ntodelete++ ] = i;
|
||||
i--; maxoff--;
|
||||
needwrite=needunion=true;
|
||||
|
||||
if ( chldtuple.ituplen ) {
|
||||
while( curlenaddon + chldtuple.ituplen >= lenaddon ) {
|
||||
lenaddon*=2;
|
||||
addon=(IndexTuple*)repalloc( addon, sizeof(IndexTuple)*lenaddon );
|
||||
chldtuple = gistVacuumUpdate(gv, ItemPointerGetBlockNumber(&(idxtuple->t_tid)),
|
||||
needchildunion);
|
||||
if (chldtuple.ituplen || chldtuple.emptypage)
|
||||
{
|
||||
PageIndexTupleDelete(page, i);
|
||||
todelete[ntodelete++] = i;
|
||||
i--;
|
||||
maxoff--;
|
||||
needwrite = needunion = true;
|
||||
|
||||
if (chldtuple.ituplen)
|
||||
{
|
||||
while (curlenaddon + chldtuple.ituplen >= lenaddon)
|
||||
{
|
||||
lenaddon *= 2;
|
||||
addon = (IndexTuple *) repalloc(addon, sizeof(IndexTuple) * lenaddon);
|
||||
}
|
||||
|
||||
memcpy( addon + curlenaddon, chldtuple.itup, chldtuple.ituplen * sizeof(IndexTuple) );
|
||||
memcpy(addon + curlenaddon, chldtuple.itup, chldtuple.ituplen * sizeof(IndexTuple));
|
||||
|
||||
curlenaddon += chldtuple.ituplen;
|
||||
|
||||
if ( chldtuple.ituplen > 1 ) {
|
||||
/* child was splitted, so we need mark completion insert(split) */
|
||||
int j;
|
||||
if (chldtuple.ituplen > 1)
|
||||
{
|
||||
/*
|
||||
* child was splitted, so we need mark completion
|
||||
* insert(split)
|
||||
*/
|
||||
int j;
|
||||
|
||||
while( ncompleted + chldtuple.ituplen > lencompleted ) {
|
||||
lencompleted*=2;
|
||||
completed = (ItemPointerData*)repalloc(completed, sizeof(ItemPointerData) * lencompleted);
|
||||
}
|
||||
for(j=0;j<chldtuple.ituplen;j++) {
|
||||
ItemPointerCopy( &(chldtuple.itup[j]->t_tid), completed + ncompleted );
|
||||
ncompleted++;
|
||||
while (ncompleted + chldtuple.ituplen > lencompleted)
|
||||
{
|
||||
lencompleted *= 2;
|
||||
completed = (ItemPointerData *) repalloc(completed, sizeof(ItemPointerData) * lencompleted);
|
||||
}
|
||||
for (j = 0; j < chldtuple.ituplen; j++)
|
||||
{
|
||||
ItemPointerCopy(&(chldtuple.itup[j]->t_tid), completed + ncompleted);
|
||||
ncompleted++;
|
||||
}
|
||||
}
|
||||
pfree( chldtuple.itup );
|
||||
pfree(chldtuple.itup);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( curlenaddon ) {
|
||||
if (curlenaddon)
|
||||
{
|
||||
/* insert updated tuples */
|
||||
if (gistnospace(page, addon, curlenaddon)) {
|
||||
if (gistnospace(page, addon, curlenaddon))
|
||||
{
|
||||
/* there is no space on page to insert tuples */
|
||||
IndexTuple *vec;
|
||||
SplitedPageLayout *dist=NULL,*ptr;
|
||||
int i;
|
||||
MemoryContext oldCtx = MemoryContextSwitchTo(gv->opCtx);
|
||||
IndexTuple *vec;
|
||||
SplitedPageLayout *dist = NULL,
|
||||
*ptr;
|
||||
int i;
|
||||
MemoryContext oldCtx = MemoryContextSwitchTo(gv->opCtx);
|
||||
|
||||
vec = gistextractbuffer(buffer, &(res.ituplen));
|
||||
vec = gistjoinvector(vec, &(res.ituplen), addon, curlenaddon);
|
||||
res.itup = gistSplit(gv->index, buffer, vec, &(res.ituplen), &dist, &(gv->giststate));
|
||||
res.itup = gistSplit(gv->index, buffer, vec, &(res.ituplen), &dist, &(gv->giststate));
|
||||
MemoryContextSwitchTo(oldCtx);
|
||||
|
||||
vec = (IndexTuple*)palloc( sizeof(IndexTuple) * res.ituplen );
|
||||
for(i=0;i<res.ituplen;i++) {
|
||||
vec[i] = (IndexTuple)palloc( IndexTupleSize(res.itup[i]) );
|
||||
memcpy( vec[i], res.itup[i], IndexTupleSize(res.itup[i]) );
|
||||
vec = (IndexTuple *) palloc(sizeof(IndexTuple) * res.ituplen);
|
||||
for (i = 0; i < res.ituplen; i++)
|
||||
{
|
||||
vec[i] = (IndexTuple) palloc(IndexTupleSize(res.itup[i]));
|
||||
memcpy(vec[i], res.itup[i], IndexTupleSize(res.itup[i]));
|
||||
}
|
||||
res.itup = vec;
|
||||
res.itup = vec;
|
||||
|
||||
if ( !gv->index->rd_istemp ) {
|
||||
XLogRecPtr recptr;
|
||||
XLogRecData *rdata;
|
||||
ItemPointerData key; /* set key for incomplete insert */
|
||||
char *xlinfo;
|
||||
if (!gv->index->rd_istemp)
|
||||
{
|
||||
XLogRecPtr recptr;
|
||||
XLogRecData *rdata;
|
||||
ItemPointerData key; /* set key for incomplete
|
||||
* insert */
|
||||
char *xlinfo;
|
||||
|
||||
ItemPointerSet(&key, blkno, TUPLE_IS_VALID);
|
||||
|
||||
|
||||
rdata = formSplitRdata(gv->index->rd_node, blkno,
|
||||
&key, dist);
|
||||
&key, dist);
|
||||
xlinfo = rdata->data;
|
||||
|
||||
START_CRIT_SECTION();
|
||||
|
||||
|
||||
recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_SPLIT, rdata);
|
||||
ptr = dist;
|
||||
while(ptr) {
|
||||
while (ptr)
|
||||
{
|
||||
PageSetLSN(BufferGetPage(ptr->buffer), recptr);
|
||||
PageSetTLI(BufferGetPage(ptr->buffer), ThisTimeLineID);
|
||||
ptr=ptr->next;
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
END_CRIT_SECTION();
|
||||
pfree( xlinfo );
|
||||
pfree( rdata );
|
||||
} else {
|
||||
pfree(xlinfo);
|
||||
pfree(rdata);
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr = dist;
|
||||
while(ptr) {
|
||||
while (ptr)
|
||||
{
|
||||
PageSetLSN(BufferGetPage(ptr->buffer), XLogRecPtrForTemp);
|
||||
ptr=ptr->next;
|
||||
ptr = ptr->next;
|
||||
}
|
||||
}
|
||||
|
||||
ptr = dist;
|
||||
while(ptr) {
|
||||
if ( BufferGetBlockNumber(ptr->buffer) != blkno )
|
||||
LockBuffer( ptr->buffer, GIST_UNLOCK );
|
||||
while (ptr)
|
||||
{
|
||||
if (BufferGetBlockNumber(ptr->buffer) != blkno)
|
||||
LockBuffer(ptr->buffer, GIST_UNLOCK);
|
||||
WriteBuffer(ptr->buffer);
|
||||
ptr=ptr->next;
|
||||
ptr = ptr->next;
|
||||
}
|
||||
|
||||
if ( blkno == GIST_ROOT_BLKNO ) {
|
||||
ItemPointerData key; /* set key for incomplete insert */
|
||||
if (blkno == GIST_ROOT_BLKNO)
|
||||
{
|
||||
ItemPointerData key; /* set key for incomplete
|
||||
* insert */
|
||||
|
||||
ItemPointerSet(&key, blkno, TUPLE_IS_VALID);
|
||||
|
||||
@ -191,82 +227,98 @@ gistVacuumUpdate( GistVacuum *gv, BlockNumber blkno, bool needunion ) {
|
||||
WriteNoReleaseBuffer(buffer);
|
||||
}
|
||||
|
||||
needwrite=false;
|
||||
|
||||
needwrite = false;
|
||||
|
||||
MemoryContextReset(gv->opCtx);
|
||||
|
||||
needunion = false; /* gistSplit already forms unions */
|
||||
} else {
|
||||
needunion = false; /* gistSplit already forms unions */
|
||||
}
|
||||
else
|
||||
{
|
||||
/* enough free space */
|
||||
gistfillbuffer(gv->index, page, addon, curlenaddon, InvalidOffsetNumber);
|
||||
}
|
||||
gistfillbuffer(gv->index, page, addon, curlenaddon, InvalidOffsetNumber);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( needunion ) {
|
||||
/* forms union for page or check empty*/
|
||||
if ( PageIsEmpty(page) ) {
|
||||
if ( blkno == GIST_ROOT_BLKNO ) {
|
||||
needwrite=true;
|
||||
GistPageSetLeaf( page );
|
||||
} else {
|
||||
needwrite=true;
|
||||
res.emptypage=true;
|
||||
GistPageSetDeleted( page );
|
||||
if (needunion)
|
||||
{
|
||||
/* forms union for page or check empty */
|
||||
if (PageIsEmpty(page))
|
||||
{
|
||||
if (blkno == GIST_ROOT_BLKNO)
|
||||
{
|
||||
needwrite = true;
|
||||
GistPageSetLeaf(page);
|
||||
}
|
||||
else
|
||||
{
|
||||
needwrite = true;
|
||||
res.emptypage = true;
|
||||
GistPageSetDeleted(page);
|
||||
gv->result->pages_deleted++;
|
||||
}
|
||||
} else {
|
||||
IndexTuple *vec, tmp;
|
||||
int veclen=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
IndexTuple *vec,
|
||||
tmp;
|
||||
int veclen = 0;
|
||||
MemoryContext oldCtx = MemoryContextSwitchTo(gv->opCtx);
|
||||
|
||||
|
||||
vec = gistextractbuffer(buffer, &veclen);
|
||||
tmp = gistunion(gv->index, vec, veclen, &(gv->giststate));
|
||||
tmp = gistunion(gv->index, vec, veclen, &(gv->giststate));
|
||||
MemoryContextSwitchTo(oldCtx);
|
||||
|
||||
res.itup=(IndexTuple*)palloc( sizeof(IndexTuple) );
|
||||
res.itup = (IndexTuple *) palloc(sizeof(IndexTuple));
|
||||
res.ituplen = 1;
|
||||
res.itup[0] = (IndexTuple)palloc( IndexTupleSize(tmp) );
|
||||
memcpy( res.itup[0], tmp, IndexTupleSize(tmp) );
|
||||
res.itup[0] = (IndexTuple) palloc(IndexTupleSize(tmp));
|
||||
memcpy(res.itup[0], tmp, IndexTupleSize(tmp));
|
||||
|
||||
ItemPointerSetBlockNumber(&(res.itup[0]->t_tid), blkno);
|
||||
GistTupleSetValid( res.itup[0] );
|
||||
|
||||
GistTupleSetValid(res.itup[0]);
|
||||
|
||||
MemoryContextReset(gv->opCtx);
|
||||
}
|
||||
}
|
||||
|
||||
if ( needwrite ) {
|
||||
if ( !gv->index->rd_istemp ) {
|
||||
if (needwrite)
|
||||
{
|
||||
if (!gv->index->rd_istemp)
|
||||
{
|
||||
XLogRecData *rdata;
|
||||
XLogRecPtr recptr;
|
||||
char *xlinfo;
|
||||
char *xlinfo;
|
||||
|
||||
rdata = formUpdateRdata(gv->index->rd_node, blkno, todelete, ntodelete,
|
||||
res.emptypage, addon, curlenaddon, NULL );
|
||||
rdata = formUpdateRdata(gv->index->rd_node, blkno, todelete, ntodelete,
|
||||
res.emptypage, addon, curlenaddon, NULL);
|
||||
xlinfo = rdata->data;
|
||||
|
||||
|
||||
START_CRIT_SECTION();
|
||||
recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_ENTRY_UPDATE, rdata);
|
||||
PageSetLSN(page, recptr);
|
||||
PageSetTLI(page, ThisTimeLineID);
|
||||
END_CRIT_SECTION();
|
||||
|
||||
pfree( xlinfo );
|
||||
pfree( rdata );
|
||||
} else
|
||||
pfree(xlinfo);
|
||||
pfree(rdata);
|
||||
}
|
||||
else
|
||||
PageSetLSN(page, XLogRecPtrForTemp);
|
||||
WriteBuffer( buffer );
|
||||
} else
|
||||
ReleaseBuffer( buffer );
|
||||
WriteBuffer(buffer);
|
||||
}
|
||||
else
|
||||
ReleaseBuffer(buffer);
|
||||
|
||||
if ( ncompleted && !gv->index->rd_istemp )
|
||||
gistxlogInsertCompletion( gv->index->rd_node, completed, ncompleted );
|
||||
if (ncompleted && !gv->index->rd_istemp)
|
||||
gistxlogInsertCompletion(gv->index->rd_node, completed, ncompleted);
|
||||
|
||||
for(i=0;i<curlenaddon;i++)
|
||||
pfree( addon[i] );
|
||||
if (addon) pfree(addon);
|
||||
if (completed) pfree(completed);
|
||||
for (i = 0; i < curlenaddon; i++)
|
||||
pfree(addon[i]);
|
||||
if (addon)
|
||||
pfree(addon);
|
||||
if (completed)
|
||||
pfree(completed);
|
||||
return res;
|
||||
}
|
||||
|
||||
@ -278,17 +330,23 @@ gistVacuumUpdate( GistVacuum *gv, BlockNumber blkno, bool needunion ) {
|
||||
*/
|
||||
|
||||
Datum
|
||||
gistvacuumcleanup(PG_FUNCTION_ARGS) {
|
||||
gistvacuumcleanup(PG_FUNCTION_ARGS)
|
||||
{
|
||||
Relation rel = (Relation) PG_GETARG_POINTER(0);
|
||||
IndexVacuumCleanupInfo *info = (IndexVacuumCleanupInfo *) PG_GETARG_POINTER(1);
|
||||
IndexBulkDeleteResult *stats = (IndexBulkDeleteResult *) PG_GETARG_POINTER(2);
|
||||
BlockNumber npages, blkno;
|
||||
BlockNumber nFreePages, *freePages, maxFreePages;
|
||||
BlockNumber lastBlock = GIST_ROOT_BLKNO, lastFilledBlock = GIST_ROOT_BLKNO;
|
||||
bool needLock;
|
||||
BlockNumber npages,
|
||||
blkno;
|
||||
BlockNumber nFreePages,
|
||||
*freePages,
|
||||
maxFreePages;
|
||||
BlockNumber lastBlock = GIST_ROOT_BLKNO,
|
||||
lastFilledBlock = GIST_ROOT_BLKNO;
|
||||
bool needLock;
|
||||
|
||||
/* gistVacuumUpdate may cause hard work */
|
||||
if ( info->vacuum_full ) {
|
||||
if (info->vacuum_full)
|
||||
{
|
||||
GistVacuum gv;
|
||||
ArrayTuple res;
|
||||
|
||||
@ -300,17 +358,20 @@ gistvacuumcleanup(PG_FUNCTION_ARGS) {
|
||||
gv.result = stats;
|
||||
|
||||
/* walk through the entire index for update tuples */
|
||||
res = gistVacuumUpdate( &gv, GIST_ROOT_BLKNO, false );
|
||||
/* cleanup */
|
||||
if (res.itup) {
|
||||
int i;
|
||||
for(i=0;i<res.ituplen;i++)
|
||||
pfree( res.itup[i] );
|
||||
pfree( res.itup );
|
||||
res = gistVacuumUpdate(&gv, GIST_ROOT_BLKNO, false);
|
||||
/* cleanup */
|
||||
if (res.itup)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < res.ituplen; i++)
|
||||
pfree(res.itup[i]);
|
||||
pfree(res.itup);
|
||||
}
|
||||
freeGISTstate(&(gv.giststate));
|
||||
MemoryContextDelete(gv.opCtx);
|
||||
} else if (needFullVacuum)
|
||||
freeGISTstate(&(gv.giststate));
|
||||
MemoryContextDelete(gv.opCtx);
|
||||
}
|
||||
else if (needFullVacuum)
|
||||
ereport(NOTICE,
|
||||
(errmsg("index \"%s\" needs VACUUM FULL or REINDEX to finish crash recovery",
|
||||
RelationGetRelationName(rel))));
|
||||
@ -318,8 +379,8 @@ gistvacuumcleanup(PG_FUNCTION_ARGS) {
|
||||
needFullVacuum = false;
|
||||
|
||||
needLock = !RELATION_IS_LOCAL(rel);
|
||||
if ( info->vacuum_full )
|
||||
needLock = false; /* relation locked with AccessExclusiveLock */
|
||||
if (info->vacuum_full)
|
||||
needLock = false; /* relation locked with AccessExclusiveLock */
|
||||
|
||||
/* try to find deleted pages */
|
||||
if (needLock)
|
||||
@ -329,45 +390,52 @@ gistvacuumcleanup(PG_FUNCTION_ARGS) {
|
||||
UnlockRelationForExtension(rel, ExclusiveLock);
|
||||
|
||||
maxFreePages = npages;
|
||||
if ( maxFreePages > MaxFSMPages )
|
||||
if (maxFreePages > MaxFSMPages)
|
||||
maxFreePages = MaxFSMPages;
|
||||
|
||||
nFreePages = 0;
|
||||
freePages = (BlockNumber*) palloc (sizeof(BlockNumber) * maxFreePages);
|
||||
for(blkno=GIST_ROOT_BLKNO+1;blkno<npages;blkno++) {
|
||||
Buffer buffer = ReadBuffer(rel, blkno);
|
||||
Page page;
|
||||
freePages = (BlockNumber *) palloc(sizeof(BlockNumber) * maxFreePages);
|
||||
for (blkno = GIST_ROOT_BLKNO + 1; blkno < npages; blkno++)
|
||||
{
|
||||
Buffer buffer = ReadBuffer(rel, blkno);
|
||||
Page page;
|
||||
|
||||
LockBuffer( buffer, GIST_SHARE );
|
||||
page=(Page)BufferGetPage(buffer);
|
||||
LockBuffer(buffer, GIST_SHARE);
|
||||
page = (Page) BufferGetPage(buffer);
|
||||
|
||||
if ( GistPageIsDeleted(page) ) {
|
||||
if (nFreePages < maxFreePages) {
|
||||
freePages[ nFreePages ] = blkno;
|
||||
if (GistPageIsDeleted(page))
|
||||
{
|
||||
if (nFreePages < maxFreePages)
|
||||
{
|
||||
freePages[nFreePages] = blkno;
|
||||
nFreePages++;
|
||||
}
|
||||
} else
|
||||
}
|
||||
else
|
||||
lastFilledBlock = blkno;
|
||||
LockBuffer( buffer, GIST_UNLOCK );
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
ReleaseBuffer(buffer);
|
||||
}
|
||||
lastBlock = npages-1;
|
||||
|
||||
if ( info->vacuum_full && nFreePages>0 ) { /* try to truncate index */
|
||||
int i;
|
||||
for(i=0;i<nFreePages;i++)
|
||||
if ( freePages[i] >= lastFilledBlock ) {
|
||||
lastBlock = npages - 1;
|
||||
|
||||
if (info->vacuum_full && nFreePages > 0)
|
||||
{ /* try to truncate index */
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nFreePages; i++)
|
||||
if (freePages[i] >= lastFilledBlock)
|
||||
{
|
||||
nFreePages = i;
|
||||
break;
|
||||
}
|
||||
|
||||
if ( lastBlock > lastFilledBlock )
|
||||
RelationTruncate( rel, lastFilledBlock+1 );
|
||||
|
||||
if (lastBlock > lastFilledBlock)
|
||||
RelationTruncate(rel, lastFilledBlock + 1);
|
||||
stats->pages_removed = lastBlock - lastFilledBlock;
|
||||
}
|
||||
|
||||
RecordIndexFreeSpace( &rel->rd_node, nFreePages, freePages );
|
||||
pfree( freePages );
|
||||
|
||||
RecordIndexFreeSpace(&rel->rd_node, nFreePages, freePages);
|
||||
pfree(freePages);
|
||||
|
||||
/* return statistics */
|
||||
stats->pages_free = nFreePages;
|
||||
@ -378,33 +446,37 @@ gistvacuumcleanup(PG_FUNCTION_ARGS) {
|
||||
UnlockRelationForExtension(rel, ExclusiveLock);
|
||||
|
||||
if (info->vacuum_full)
|
||||
UnlockRelation(rel, AccessExclusiveLock);
|
||||
UnlockRelation(rel, AccessExclusiveLock);
|
||||
|
||||
PG_RETURN_POINTER(stats);
|
||||
}
|
||||
|
||||
typedef struct GistBDItem {
|
||||
typedef struct GistBDItem
|
||||
{
|
||||
GistNSN parentlsn;
|
||||
BlockNumber blkno;
|
||||
struct GistBDItem *next;
|
||||
BlockNumber blkno;
|
||||
struct GistBDItem *next;
|
||||
} GistBDItem;
|
||||
|
||||
static void
|
||||
pushStackIfSplited(Page page, GistBDItem *stack) {
|
||||
pushStackIfSplited(Page page, GistBDItem *stack)
|
||||
{
|
||||
GISTPageOpaque opaque = GistPageGetOpaque(page);
|
||||
|
||||
if ( stack->blkno!=GIST_ROOT_BLKNO && !XLogRecPtrIsInvalid( stack->parentlsn ) &&
|
||||
XLByteLT( stack->parentlsn, opaque->nsn) &&
|
||||
opaque->rightlink != InvalidBlockNumber /* sanity check */ ) {
|
||||
if (stack->blkno != GIST_ROOT_BLKNO && !XLogRecPtrIsInvalid(stack->parentlsn) &&
|
||||
XLByteLT(stack->parentlsn, opaque->nsn) &&
|
||||
opaque->rightlink != InvalidBlockNumber /* sanity check */ )
|
||||
{
|
||||
/* split page detected, install right link to the stack */
|
||||
|
||||
GistBDItem *ptr = (GistBDItem*) palloc(sizeof(GistBDItem));
|
||||
GistBDItem *ptr = (GistBDItem *) palloc(sizeof(GistBDItem));
|
||||
|
||||
ptr->blkno = opaque->rightlink;
|
||||
ptr->parentlsn = stack->parentlsn;
|
||||
ptr->next = stack->next;
|
||||
stack->next = ptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
@ -416,38 +488,44 @@ pushStackIfSplited(Page page, GistBDItem *stack) {
|
||||
* Result: a palloc'd struct containing statistical info for VACUUM displays.
|
||||
*/
|
||||
Datum
|
||||
gistbulkdelete(PG_FUNCTION_ARGS) {
|
||||
gistbulkdelete(PG_FUNCTION_ARGS)
|
||||
{
|
||||
Relation rel = (Relation) PG_GETARG_POINTER(0);
|
||||
IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1);
|
||||
void* callback_state = (void *) PG_GETARG_POINTER(2);
|
||||
IndexBulkDeleteResult *result = (IndexBulkDeleteResult*)palloc0(sizeof(IndexBulkDeleteResult));
|
||||
GistBDItem *stack, *ptr;
|
||||
bool needLock;
|
||||
|
||||
stack = (GistBDItem*) palloc0(sizeof(GistBDItem));
|
||||
void *callback_state = (void *) PG_GETARG_POINTER(2);
|
||||
IndexBulkDeleteResult *result = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
|
||||
GistBDItem *stack,
|
||||
*ptr;
|
||||
bool needLock;
|
||||
|
||||
stack = (GistBDItem *) palloc0(sizeof(GistBDItem));
|
||||
|
||||
stack->blkno = GIST_ROOT_BLKNO;
|
||||
needFullVacuum = false;
|
||||
|
||||
while( stack ) {
|
||||
Buffer buffer = ReadBuffer(rel, stack->blkno);
|
||||
Page page;
|
||||
OffsetNumber i, maxoff;
|
||||
while (stack)
|
||||
{
|
||||
Buffer buffer = ReadBuffer(rel, stack->blkno);
|
||||
Page page;
|
||||
OffsetNumber i,
|
||||
maxoff;
|
||||
IndexTuple idxtuple;
|
||||
ItemId iid;
|
||||
|
||||
LockBuffer(buffer, GIST_SHARE);
|
||||
page = (Page) BufferGetPage(buffer);
|
||||
LockBuffer(buffer, GIST_SHARE);
|
||||
page = (Page) BufferGetPage(buffer);
|
||||
|
||||
if ( GistPageIsLeaf(page) ) {
|
||||
if (GistPageIsLeaf(page))
|
||||
{
|
||||
OffsetNumber todelete[MaxOffsetNumber];
|
||||
int ntodelete = 0;
|
||||
int ntodelete = 0;
|
||||
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
LockBuffer(buffer, GIST_EXCLUSIVE);
|
||||
|
||||
page = (Page) BufferGetPage(buffer);
|
||||
if ( stack->blkno==GIST_ROOT_BLKNO && !GistPageIsLeaf(page) ) {
|
||||
page = (Page) BufferGetPage(buffer);
|
||||
if (stack->blkno == GIST_ROOT_BLKNO && !GistPageIsLeaf(page))
|
||||
{
|
||||
/* the only root can become non-leaf during relock */
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
ReleaseBuffer(buffer);
|
||||
@ -455,37 +533,46 @@ gistbulkdelete(PG_FUNCTION_ARGS) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* check for split proceeded after look at parent,
|
||||
we should check it after relock */
|
||||
/*
|
||||
* check for split proceeded after look at parent, we should check
|
||||
* it after relock
|
||||
*/
|
||||
pushStackIfSplited(page, stack);
|
||||
|
||||
maxoff = PageGetMaxOffsetNumber(page);
|
||||
|
||||
for(i=FirstOffsetNumber;i<=maxoff;i=OffsetNumberNext(i)) {
|
||||
iid = PageGetItemId(page, i);
|
||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
||||
{
|
||||
iid = PageGetItemId(page, i);
|
||||
idxtuple = (IndexTuple) PageGetItem(page, iid);
|
||||
|
||||
if ( callback(&(idxtuple->t_tid), callback_state) ) {
|
||||
if (callback(&(idxtuple->t_tid), callback_state))
|
||||
{
|
||||
PageIndexTupleDelete(page, i);
|
||||
todelete[ ntodelete ] = i;
|
||||
i--; maxoff--; ntodelete++;
|
||||
todelete[ntodelete] = i;
|
||||
i--;
|
||||
maxoff--;
|
||||
ntodelete++;
|
||||
result->tuples_removed += 1;
|
||||
Assert( maxoff == PageGetMaxOffsetNumber(page) );
|
||||
} else
|
||||
Assert(maxoff == PageGetMaxOffsetNumber(page));
|
||||
}
|
||||
else
|
||||
result->num_index_tuples += 1;
|
||||
}
|
||||
|
||||
if ( ntodelete ) {
|
||||
if (ntodelete)
|
||||
{
|
||||
GistMarkTuplesDeleted(page);
|
||||
|
||||
if (!rel->rd_istemp ) {
|
||||
if (!rel->rd_istemp)
|
||||
{
|
||||
XLogRecData *rdata;
|
||||
XLogRecPtr recptr;
|
||||
XLogRecPtr recptr;
|
||||
gistxlogEntryUpdate *xlinfo;
|
||||
|
||||
rdata = formUpdateRdata(rel->rd_node, stack->blkno, todelete, ntodelete,
|
||||
false, NULL, 0, NULL);
|
||||
xlinfo = (gistxlogEntryUpdate*)rdata->data;
|
||||
false, NULL, 0, NULL);
|
||||
xlinfo = (gistxlogEntryUpdate *) rdata->data;
|
||||
|
||||
START_CRIT_SECTION();
|
||||
recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_ENTRY_UPDATE, rdata);
|
||||
@ -493,39 +580,43 @@ gistbulkdelete(PG_FUNCTION_ARGS) {
|
||||
PageSetTLI(page, ThisTimeLineID);
|
||||
END_CRIT_SECTION();
|
||||
|
||||
pfree( xlinfo );
|
||||
pfree( rdata );
|
||||
} else
|
||||
pfree(xlinfo);
|
||||
pfree(rdata);
|
||||
}
|
||||
else
|
||||
PageSetLSN(page, XLogRecPtrForTemp);
|
||||
WriteNoReleaseBuffer( buffer );
|
||||
WriteNoReleaseBuffer(buffer);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
/* check for split proceeded after look at parent */
|
||||
pushStackIfSplited(page, stack);
|
||||
|
||||
maxoff = PageGetMaxOffsetNumber(page);
|
||||
|
||||
for(i=FirstOffsetNumber;i<=maxoff;i=OffsetNumberNext(i)) {
|
||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
||||
{
|
||||
iid = PageGetItemId(page, i);
|
||||
idxtuple = (IndexTuple) PageGetItem(page, iid);
|
||||
|
||||
ptr = (GistBDItem*) palloc(sizeof(GistBDItem));
|
||||
ptr->blkno = ItemPointerGetBlockNumber( &(idxtuple->t_tid) );
|
||||
ptr->parentlsn = PageGetLSN( page );
|
||||
ptr = (GistBDItem *) palloc(sizeof(GistBDItem));
|
||||
ptr->blkno = ItemPointerGetBlockNumber(&(idxtuple->t_tid));
|
||||
ptr->parentlsn = PageGetLSN(page);
|
||||
ptr->next = stack->next;
|
||||
stack->next = ptr;
|
||||
|
||||
if ( GistTupleIsInvalid(idxtuple) )
|
||||
if (GistTupleIsInvalid(idxtuple))
|
||||
needFullVacuum = true;
|
||||
}
|
||||
}
|
||||
|
||||
LockBuffer( buffer, GIST_UNLOCK );
|
||||
ReleaseBuffer( buffer );
|
||||
LockBuffer(buffer, GIST_UNLOCK);
|
||||
ReleaseBuffer(buffer);
|
||||
|
||||
|
||||
ptr = stack->next;
|
||||
pfree( stack );
|
||||
pfree(stack);
|
||||
stack = ptr;
|
||||
|
||||
vacuum_delay_point();
|
||||
@ -539,6 +630,5 @@ gistbulkdelete(PG_FUNCTION_ARGS) {
|
||||
if (needLock)
|
||||
UnlockRelationForExtension(rel, ExclusiveLock);
|
||||
|
||||
PG_RETURN_POINTER( result );
|
||||
PG_RETURN_POINTER(result);
|
||||
}
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user