mirror of
https://github.com/postgres/postgres.git
synced 2025-11-12 05:01:15 +03:00
413 lines
11 KiB
C
413 lines
11 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* ginget.c
|
|
* fetch tuples from a GIN scan.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* IDENTIFICATION
|
|
* $PostgreSQL: pgsql/src/backend/access/gin/ginget.c,v 1.1 2006/05/02 11:28:54 teodor Exp $
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
#include "access/genam.h"
|
|
#include "access/gin.h"
|
|
#include "access/heapam.h"
|
|
#include "catalog/index.h"
|
|
#include "miscadmin.h"
|
|
#include "storage/freespace.h"
|
|
#include "utils/memutils.h"
|
|
|
|
static OffsetNumber
|
|
findItemInPage( Page page, ItemPointer item, OffsetNumber off ) {
|
|
OffsetNumber maxoff = GinPageGetOpaque(page)->maxoff;
|
|
int res;
|
|
|
|
for(; off<=maxoff; off++) {
|
|
res = compareItemPointers( item, (ItemPointer)GinDataPageGetItem(page, off) );
|
|
Assert( res>= 0 );
|
|
|
|
if ( res == 0 )
|
|
return off;
|
|
}
|
|
|
|
return InvalidOffsetNumber;
|
|
}
|
|
|
|
/*
|
|
* Start* functions setup state of searches: find correct buffer and locks it,
|
|
* Stop* functions unlock buffer (but don't release!)
|
|
*/
|
|
static void
|
|
startScanEntry( Relation index, GinState *ginstate, GinScanEntry entry, bool firstCall ) {
|
|
if ( entry->master != NULL ) {
|
|
entry->isFinished = entry->master->isFinished;
|
|
return;
|
|
}
|
|
|
|
if ( firstCall ) {
|
|
/* at first call we should find entry, and
|
|
begin scan of posting tree or just store posting list in memory */
|
|
GinBtreeData btreeEntry;
|
|
GinBtreeStack *stackEntry;
|
|
Page page;
|
|
bool needUnlock = TRUE;
|
|
|
|
prepareEntryScan( &btreeEntry, index, entry->entry, ginstate );
|
|
btreeEntry.searchMode = TRUE;
|
|
stackEntry = ginFindLeafPage(&btreeEntry, NULL);
|
|
page = BufferGetPage( stackEntry->buffer );
|
|
|
|
entry->isFinished = TRUE;
|
|
entry->buffer = InvalidBuffer;
|
|
entry->offset = InvalidOffsetNumber;
|
|
entry->list = NULL;
|
|
entry->nlist = 0;
|
|
entry->reduceResult = FALSE;
|
|
entry->predictNumberResult = 0;
|
|
|
|
if ( btreeEntry.findItem( &btreeEntry, stackEntry ) ) {
|
|
IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stackEntry->off));
|
|
|
|
if ( GinIsPostingTree(itup) ) {
|
|
BlockNumber rootPostingTree = GinGetPostingTree(itup);
|
|
GinPostingTreeScan *gdi;
|
|
Page page;
|
|
|
|
LockBuffer(stackEntry->buffer, GIN_UNLOCK);
|
|
needUnlock = FALSE;
|
|
gdi = prepareScanPostingTree( index, rootPostingTree, TRUE );
|
|
|
|
entry->buffer = scanBeginPostingTree( gdi );
|
|
IncrBufferRefCount( entry->buffer );
|
|
|
|
page = BufferGetPage( entry->buffer );
|
|
entry->predictNumberResult = gdi->stack->predictNumber * GinPageGetOpaque(page)->maxoff;
|
|
|
|
freeGinBtreeStack( gdi->stack );
|
|
pfree( gdi );
|
|
entry->isFinished = FALSE;
|
|
} else if ( GinGetNPosting(itup) > 0 ) {
|
|
entry->nlist = GinGetNPosting(itup);
|
|
entry->list = (ItemPointerData*)palloc( sizeof(ItemPointerData) * entry->nlist );
|
|
memcpy( entry->list, GinGetPosting(itup), sizeof(ItemPointerData) * entry->nlist );
|
|
entry->isFinished = FALSE;
|
|
}
|
|
}
|
|
|
|
if ( needUnlock )
|
|
LockBuffer(stackEntry->buffer, GIN_UNLOCK);
|
|
freeGinBtreeStack( stackEntry );
|
|
} else if ( entry->buffer != InvalidBuffer ) {
|
|
/* we should find place were we was stopped */
|
|
BlockNumber blkno;
|
|
Page page;
|
|
|
|
LockBuffer( entry->buffer, GIN_SHARE );
|
|
|
|
if ( !ItemPointerIsValid( &entry->curItem ) )
|
|
/* start position */
|
|
return;
|
|
Assert( entry->offset!=InvalidOffsetNumber );
|
|
|
|
page = BufferGetPage( entry->buffer );
|
|
|
|
/* try to find curItem in current buffer */
|
|
if ( (entry->offset=findItemInPage(page , &entry->curItem, entry->offset))!=InvalidOffsetNumber )
|
|
return;
|
|
|
|
/* walk to right */
|
|
while( (blkno = GinPageGetOpaque( page )->rightlink)!=InvalidBlockNumber ) {
|
|
LockBuffer( entry->buffer, GIN_UNLOCK );
|
|
entry->buffer = ReleaseAndReadBuffer( entry->buffer, index, blkno );
|
|
LockBuffer( entry->buffer, GIN_SHARE );
|
|
page = BufferGetPage( entry->buffer );
|
|
|
|
if ( (entry->offset=findItemInPage(page , &entry->curItem, FirstOffsetNumber))!=InvalidOffsetNumber )
|
|
return;
|
|
}
|
|
|
|
elog(ERROR,"Logic error: lost previously founded ItemId");
|
|
}
|
|
}
|
|
|
|
static void
|
|
stopScanEntry( GinScanEntry entry ) {
|
|
if ( entry->buffer != InvalidBuffer )
|
|
LockBuffer( entry->buffer, GIN_UNLOCK );
|
|
}
|
|
|
|
static void
|
|
startScanKey( Relation index, GinState *ginstate, GinScanKey key ) {
|
|
uint32 i;
|
|
|
|
for(i=0;i<key->nentries;i++)
|
|
startScanEntry( index, ginstate, key->scanEntry+i, key->firstCall );
|
|
|
|
if ( key->firstCall ) {
|
|
memset( key->entryRes, TRUE, sizeof(bool) * key->nentries );
|
|
key->isFinished = FALSE;
|
|
key->firstCall = FALSE;
|
|
|
|
if ( GinFuzzySearchLimit > 0 ) {
|
|
/*
|
|
* If all of keys more than treshold we will try to reduce
|
|
* result, we hope (and only hope, for intersection operation of array
|
|
* our supposition isn't true), that total result will not more
|
|
* than minimal predictNumberResult.
|
|
*/
|
|
|
|
for(i=0;i<key->nentries;i++)
|
|
if ( key->scanEntry[i].predictNumberResult <= key->nentries * GinFuzzySearchLimit )
|
|
return;
|
|
|
|
for(i=0;i<key->nentries;i++)
|
|
if ( key->scanEntry[i].predictNumberResult > key->nentries * GinFuzzySearchLimit ) {
|
|
key->scanEntry[i].predictNumberResult /= key->nentries;
|
|
key->scanEntry[i].reduceResult = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
stopScanKey( GinScanKey key ) {
|
|
uint32 i;
|
|
|
|
for(i=0;i<key->nentries;i++)
|
|
stopScanEntry( key->scanEntry+i );
|
|
}
|
|
|
|
static void
|
|
startScan( IndexScanDesc scan ) {
|
|
uint32 i;
|
|
GinScanOpaque so = (GinScanOpaque) scan->opaque;
|
|
|
|
for(i=0; i<so->nkeys; i++)
|
|
startScanKey( scan->indexRelation, &so->ginstate, so->keys + i );
|
|
}
|
|
|
|
static void
|
|
stopScan( IndexScanDesc scan ) {
|
|
uint32 i;
|
|
GinScanOpaque so = (GinScanOpaque) scan->opaque;
|
|
|
|
for(i=0; i<so->nkeys; i++)
|
|
stopScanKey( so->keys + i );
|
|
}
|
|
|
|
|
|
static void
|
|
entryGetNextItem( Relation index, GinScanEntry entry ) {
|
|
Page page = BufferGetPage( entry->buffer );
|
|
|
|
entry->offset++;
|
|
if ( entry->offset <= GinPageGetOpaque( page )->maxoff && GinPageGetOpaque( page )->maxoff >= FirstOffsetNumber ) {
|
|
entry->curItem = *(ItemPointerData*)GinDataPageGetItem(page, entry->offset);
|
|
} else {
|
|
BlockNumber blkno = GinPageGetOpaque( page )->rightlink;
|
|
|
|
LockBuffer( entry->buffer, GIN_UNLOCK );
|
|
if ( blkno == InvalidBlockNumber ) {
|
|
ReleaseBuffer( entry->buffer );
|
|
entry->buffer = InvalidBuffer;
|
|
entry->isFinished = TRUE;
|
|
} else {
|
|
entry->buffer = ReleaseAndReadBuffer( entry->buffer, index, blkno );
|
|
LockBuffer( entry->buffer, GIN_SHARE );
|
|
entry->offset = InvalidOffsetNumber;
|
|
entryGetNextItem(index, entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
#define gin_rand() (((double) random()) / ((double) MAX_RANDOM_VALUE))
|
|
#define dropItem(e) ( gin_rand() > ((double)GinFuzzySearchLimit)/((double)((e)->predictNumberResult)) )
|
|
|
|
/*
|
|
* Sets entry->curItem to new found heap item pointer for one
|
|
* entry of one scan key
|
|
*/
|
|
static bool
|
|
entryGetItem( Relation index, GinScanEntry entry ) {
|
|
if ( entry->master ) {
|
|
entry->isFinished = entry->master->isFinished;
|
|
entry->curItem = entry->master->curItem;
|
|
} else if ( entry->list ) {
|
|
entry->offset++;
|
|
if ( entry->offset <= entry->nlist )
|
|
entry->curItem = entry->list[ entry->offset - 1 ];
|
|
else {
|
|
ItemPointerSet( &entry->curItem, InvalidBlockNumber, InvalidOffsetNumber );
|
|
entry->isFinished = TRUE;
|
|
}
|
|
} else {
|
|
do {
|
|
entryGetNextItem(index, entry);
|
|
} while ( entry->isFinished == FALSE && entry->reduceResult == TRUE && dropItem(entry) );
|
|
}
|
|
|
|
return entry->isFinished;
|
|
}
|
|
|
|
/*
|
|
* Sets key->curItem to new found heap item pointer for one scan key
|
|
* returns isFinished!
|
|
*/
|
|
static bool
|
|
keyGetItem( Relation index, GinState *ginstate, MemoryContext tempCtx, GinScanKey key ) {
|
|
uint32 i;
|
|
GinScanEntry entry;
|
|
bool res;
|
|
MemoryContext oldCtx;
|
|
|
|
if ( key->isFinished )
|
|
return TRUE;
|
|
|
|
do {
|
|
/* move forward from previously value and set new curItem,
|
|
which is minimal from entries->curItems */
|
|
ItemPointerSetMax( &key->curItem );
|
|
for(i=0;i<key->nentries;i++) {
|
|
entry = key->scanEntry+i;
|
|
|
|
if ( key->entryRes[i] ) {
|
|
if ( entry->isFinished == FALSE && entryGetItem(index, entry) == FALSE ) {
|
|
if (compareItemPointers( &entry->curItem, &key->curItem ) < 0)
|
|
key->curItem = entry->curItem;
|
|
} else
|
|
key->entryRes[i] = FALSE;
|
|
} else if ( entry->isFinished == FALSE ) {
|
|
if (compareItemPointers( &entry->curItem, &key->curItem ) < 0)
|
|
key->curItem = entry->curItem;
|
|
}
|
|
}
|
|
|
|
if ( ItemPointerIsMax( &key->curItem ) ) {
|
|
/* all entries are finished */
|
|
key->isFinished = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
if ( key->nentries == 1 ) {
|
|
/* we can do not call consistentFn !! */
|
|
key->entryRes[0] = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/* setting up array for consistentFn */
|
|
for(i=0;i<key->nentries;i++) {
|
|
entry = key->scanEntry+i;
|
|
|
|
if ( entry->isFinished == FALSE && compareItemPointers( &entry->curItem, &key->curItem )==0 )
|
|
key->entryRes[i] = TRUE;
|
|
else
|
|
key->entryRes[i] = FALSE;
|
|
}
|
|
|
|
oldCtx = MemoryContextSwitchTo(tempCtx);
|
|
res = DatumGetBool( FunctionCall3(
|
|
&ginstate->consistentFn,
|
|
PointerGetDatum( key->entryRes ),
|
|
UInt16GetDatum( key->strategy ),
|
|
key->query
|
|
));
|
|
MemoryContextSwitchTo(oldCtx);
|
|
MemoryContextReset(tempCtx);
|
|
} while( !res );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Get heap item pointer from scan
|
|
* returns true if found
|
|
*/
|
|
static bool
|
|
scanGetItem( IndexScanDesc scan, ItemPointerData *item ) {
|
|
uint32 i;
|
|
GinScanOpaque so = (GinScanOpaque) scan->opaque;
|
|
|
|
ItemPointerSetMin( item );
|
|
for(i=0;i<so->nkeys;i++) {
|
|
GinScanKey key = so->keys+i;
|
|
|
|
if ( keyGetItem( scan->indexRelation, &so->ginstate, so->tempCtx, key )==FALSE ) {
|
|
if ( compareItemPointers( item, &key->curItem ) < 0 )
|
|
*item = key->curItem;
|
|
} else
|
|
return FALSE; /* finshed one of keys */
|
|
}
|
|
|
|
for(i=1;i<=so->nkeys;i++) {
|
|
GinScanKey key = so->keys+i-1;
|
|
|
|
for(;;) {
|
|
int cmp = compareItemPointers( item, &key->curItem );
|
|
|
|
if ( cmp == 0 )
|
|
break;
|
|
else if ( cmp > 0 ) {
|
|
if ( keyGetItem( scan->indexRelation, &so->ginstate, so->tempCtx, key )==TRUE )
|
|
return FALSE; /* finshed one of keys */
|
|
} else { /* returns to begin */
|
|
*item = key->curItem;
|
|
i=0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#define GinIsNewKey(s) ( ((GinScanOpaque) scan->opaque)->keys == NULL )
|
|
|
|
Datum
|
|
gingetmulti(PG_FUNCTION_ARGS) {
|
|
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
|
|
ItemPointer tids = (ItemPointer) PG_GETARG_POINTER(1);
|
|
int32 max_tids = PG_GETARG_INT32(2);
|
|
int32 *returned_tids = (int32 *) PG_GETARG_POINTER(3);
|
|
|
|
if ( GinIsNewKey(scan) )
|
|
newScanKey( scan );
|
|
|
|
startScan( scan );
|
|
|
|
*returned_tids = 0;
|
|
|
|
do {
|
|
if ( scanGetItem( scan, tids + *returned_tids ) )
|
|
(*returned_tids)++;
|
|
else
|
|
break;
|
|
} while ( *returned_tids < max_tids );
|
|
|
|
stopScan( scan );
|
|
|
|
PG_RETURN_BOOL(*returned_tids == max_tids);
|
|
}
|
|
|
|
Datum
|
|
gingettuple(PG_FUNCTION_ARGS) {
|
|
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
|
|
ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1);
|
|
bool res;
|
|
|
|
if ( dir != ForwardScanDirection )
|
|
elog(ERROR, "Gin doesn't support other scan directions than forward");
|
|
|
|
if ( GinIsNewKey(scan) )
|
|
newScanKey( scan );
|
|
|
|
startScan( scan );
|
|
res = scanGetItem(scan, &scan->xs_ctup.t_self);
|
|
stopScan( scan );
|
|
|
|
PG_RETURN_BOOL(res);
|
|
}
|