mirror of https://github.com/postgres/postgres
Tom Lane
20 years ago
parent
645adf5de8
commit
2a8d3d83ef
@ -1,31 +0,0 @@ |
|||||||
#-------------------------------------------------------------------------
|
|
||||||
#
|
|
||||||
# Makefile--
|
|
||||||
# Makefile for access/rtree
|
|
||||||
#
|
|
||||||
# IDENTIFICATION
|
|
||||||
# $PostgreSQL: pgsql/src/backend/access/rtree/Makefile,v 1.11 2003/11/29 19:51:40 pgsql Exp $
|
|
||||||
#
|
|
||||||
#-------------------------------------------------------------------------
|
|
||||||
|
|
||||||
subdir = src/backend/access/rtree
|
|
||||||
top_builddir = ../../../..
|
|
||||||
include $(top_builddir)/src/Makefile.global |
|
||||||
|
|
||||||
OBJS = rtget.o rtproc.o rtree.o rtscan.o rtstrat.o
|
|
||||||
|
|
||||||
all: SUBSYS.o |
|
||||||
|
|
||||||
SUBSYS.o: $(OBJS) |
|
||||||
$(LD) $(LDREL) $(LDOUT) SUBSYS.o $(OBJS)
|
|
||||||
|
|
||||||
depend dep: |
|
||||||
$(CC) -MM $(CFLAGS) *.c >depend
|
|
||||||
|
|
||||||
clean: |
|
||||||
rm -f SUBSYS.o $(OBJS)
|
|
||||||
|
|
||||||
ifeq (depend,$(wildcard depend)) |
|
||||||
include depend |
|
||||||
endif |
|
||||||
|
|
||||||
@ -1,281 +0,0 @@ |
|||||||
/*-------------------------------------------------------------------------
|
|
||||||
* |
|
||||||
* rtget.c |
|
||||||
* fetch tuples from an rtree scan. |
|
||||||
* |
|
||||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California |
|
||||||
* |
|
||||||
* |
|
||||||
* IDENTIFICATION |
|
||||||
* $PostgreSQL: pgsql/src/backend/access/rtree/rtget.c,v 1.37 2005/10/15 02:49:09 momjian Exp $ |
|
||||||
* |
|
||||||
*------------------------------------------------------------------------- |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "postgres.h" |
|
||||||
|
|
||||||
#include "access/iqual.h" |
|
||||||
#include "access/relscan.h" |
|
||||||
#include "access/rtree.h" |
|
||||||
#include "pgstat.h" |
|
||||||
|
|
||||||
|
|
||||||
static OffsetNumber findnext(IndexScanDesc s, OffsetNumber n, |
|
||||||
ScanDirection dir); |
|
||||||
static bool rtnext(IndexScanDesc s, ScanDirection dir); |
|
||||||
|
|
||||||
|
|
||||||
Datum |
|
||||||
rtgettuple(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); |
|
||||||
ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1); |
|
||||||
RTreeScanOpaque so = (RTreeScanOpaque) s->opaque; |
|
||||||
Page page; |
|
||||||
OffsetNumber offnum; |
|
||||||
|
|
||||||
/*
|
|
||||||
* If we've already produced a tuple and the executor has informed us that |
|
||||||
* it should be marked "killed", do so now. |
|
||||||
*/ |
|
||||||
if (s->kill_prior_tuple && ItemPointerIsValid(&(s->currentItemData))) |
|
||||||
{ |
|
||||||
offnum = ItemPointerGetOffsetNumber(&(s->currentItemData)); |
|
||||||
page = BufferGetPage(so->curbuf); |
|
||||||
PageGetItemId(page, offnum)->lp_flags |= LP_DELETE; |
|
||||||
SetBufferCommitInfoNeedsSave(so->curbuf); |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the next tuple that matches the search key; if asked to skip killed |
|
||||||
* tuples, find the first non-killed tuple that matches. Return as soon as |
|
||||||
* we've run out of matches or we've found an acceptable match. |
|
||||||
*/ |
|
||||||
for (;;) |
|
||||||
{ |
|
||||||
bool res = rtnext(s, dir); |
|
||||||
|
|
||||||
if (res && s->ignore_killed_tuples) |
|
||||||
{ |
|
||||||
offnum = ItemPointerGetOffsetNumber(&(s->currentItemData)); |
|
||||||
page = BufferGetPage(so->curbuf); |
|
||||||
if (ItemIdDeleted(PageGetItemId(page, offnum))) |
|
||||||
continue; |
|
||||||
} |
|
||||||
|
|
||||||
PG_RETURN_BOOL(res); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rtgetmulti(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
IndexScanDesc s = (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); |
|
||||||
RTreeScanOpaque so = (RTreeScanOpaque) s->opaque; |
|
||||||
bool res = true; |
|
||||||
int32 ntids = 0; |
|
||||||
|
|
||||||
/* XXX generic implementation: loop around guts of rtgettuple */ |
|
||||||
while (ntids < max_tids) |
|
||||||
{ |
|
||||||
res = rtnext(s, ForwardScanDirection); |
|
||||||
if (res && s->ignore_killed_tuples) |
|
||||||
{ |
|
||||||
Page page; |
|
||||||
OffsetNumber offnum; |
|
||||||
|
|
||||||
offnum = ItemPointerGetOffsetNumber(&(s->currentItemData)); |
|
||||||
page = BufferGetPage(so->curbuf); |
|
||||||
if (ItemIdDeleted(PageGetItemId(page, offnum))) |
|
||||||
continue; |
|
||||||
} |
|
||||||
|
|
||||||
if (!res) |
|
||||||
break; |
|
||||||
tids[ntids] = s->xs_ctup.t_self; |
|
||||||
ntids++; |
|
||||||
} |
|
||||||
|
|
||||||
*returned_tids = ntids; |
|
||||||
PG_RETURN_BOOL(res); |
|
||||||
} |
|
||||||
|
|
||||||
static bool |
|
||||||
rtnext(IndexScanDesc s, ScanDirection dir) |
|
||||||
{ |
|
||||||
Page p; |
|
||||||
OffsetNumber n; |
|
||||||
RTreePageOpaque po; |
|
||||||
RTreeScanOpaque so; |
|
||||||
|
|
||||||
so = (RTreeScanOpaque) s->opaque; |
|
||||||
|
|
||||||
if (!ItemPointerIsValid(&(s->currentItemData))) |
|
||||||
{ |
|
||||||
/* first call: start at the root */ |
|
||||||
Assert(BufferIsValid(so->curbuf) == false); |
|
||||||
so->curbuf = ReadBuffer(s->indexRelation, P_ROOT); |
|
||||||
pgstat_count_index_scan(&s->xs_pgstat_info); |
|
||||||
} |
|
||||||
|
|
||||||
p = BufferGetPage(so->curbuf); |
|
||||||
po = (RTreePageOpaque) PageGetSpecialPointer(p); |
|
||||||
|
|
||||||
if (!ItemPointerIsValid(&(s->currentItemData))) |
|
||||||
{ |
|
||||||
/* first call: start at first/last offset */ |
|
||||||
if (ScanDirectionIsForward(dir)) |
|
||||||
n = FirstOffsetNumber; |
|
||||||
else |
|
||||||
n = PageGetMaxOffsetNumber(p); |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
/* go on to the next offset */ |
|
||||||
n = ItemPointerGetOffsetNumber(&(s->currentItemData)); |
|
||||||
if (ScanDirectionIsForward(dir)) |
|
||||||
n = OffsetNumberNext(n); |
|
||||||
else |
|
||||||
n = OffsetNumberPrev(n); |
|
||||||
} |
|
||||||
|
|
||||||
for (;;) |
|
||||||
{ |
|
||||||
IndexTuple it; |
|
||||||
RTSTACK *stk; |
|
||||||
|
|
||||||
n = findnext(s, n, dir); |
|
||||||
|
|
||||||
/* no match on this page, so read in the next stack entry */ |
|
||||||
if (n == InvalidOffsetNumber) |
|
||||||
{ |
|
||||||
/* if out of stack entries, we're done */ |
|
||||||
if (so->s_stack == NULL) |
|
||||||
{ |
|
||||||
ReleaseBuffer(so->curbuf); |
|
||||||
so->curbuf = InvalidBuffer; |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
stk = so->s_stack; |
|
||||||
so->curbuf = ReleaseAndReadBuffer(so->curbuf, s->indexRelation, |
|
||||||
stk->rts_blk); |
|
||||||
p = BufferGetPage(so->curbuf); |
|
||||||
po = (RTreePageOpaque) PageGetSpecialPointer(p); |
|
||||||
|
|
||||||
if (ScanDirectionIsBackward(dir)) |
|
||||||
n = OffsetNumberPrev(stk->rts_child); |
|
||||||
else |
|
||||||
n = OffsetNumberNext(stk->rts_child); |
|
||||||
so->s_stack = stk->rts_parent; |
|
||||||
pfree(stk); |
|
||||||
|
|
||||||
continue; |
|
||||||
} |
|
||||||
|
|
||||||
if (po->flags & F_LEAF) |
|
||||||
{ |
|
||||||
ItemPointerSet(&(s->currentItemData), |
|
||||||
BufferGetBlockNumber(so->curbuf), |
|
||||||
n); |
|
||||||
it = (IndexTuple) PageGetItem(p, PageGetItemId(p, n)); |
|
||||||
s->xs_ctup.t_self = it->t_tid; |
|
||||||
return true; |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
BlockNumber blk; |
|
||||||
|
|
||||||
stk = (RTSTACK *) palloc(sizeof(RTSTACK)); |
|
||||||
stk->rts_child = n; |
|
||||||
stk->rts_blk = BufferGetBlockNumber(so->curbuf); |
|
||||||
stk->rts_parent = so->s_stack; |
|
||||||
so->s_stack = stk; |
|
||||||
|
|
||||||
it = (IndexTuple) PageGetItem(p, PageGetItemId(p, n)); |
|
||||||
blk = ItemPointerGetBlockNumber(&(it->t_tid)); |
|
||||||
|
|
||||||
/*
|
|
||||||
* Note that we release the pin on the page as we descend down the |
|
||||||
* tree, even though there's a good chance we'll eventually need |
|
||||||
* to re-read the buffer later in this scan. This may or may not |
|
||||||
* be optimal, but it doesn't seem likely to make a huge |
|
||||||
* performance difference either way. |
|
||||||
*/ |
|
||||||
so->curbuf = ReleaseAndReadBuffer(so->curbuf, s->indexRelation, blk); |
|
||||||
p = BufferGetPage(so->curbuf); |
|
||||||
po = (RTreePageOpaque) PageGetSpecialPointer(p); |
|
||||||
|
|
||||||
if (ScanDirectionIsBackward(dir)) |
|
||||||
n = PageGetMaxOffsetNumber(p); |
|
||||||
else |
|
||||||
n = FirstOffsetNumber; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* Return the offset of the next matching index entry. We begin the |
|
||||||
* search at offset "n" and search for matches in the direction |
|
||||||
* "dir". If no more matching entries are found on the page, |
|
||||||
* InvalidOffsetNumber is returned. |
|
||||||
*/ |
|
||||||
static OffsetNumber |
|
||||||
findnext(IndexScanDesc s, OffsetNumber n, ScanDirection dir) |
|
||||||
{ |
|
||||||
OffsetNumber maxoff; |
|
||||||
IndexTuple it; |
|
||||||
RTreePageOpaque po; |
|
||||||
RTreeScanOpaque so; |
|
||||||
Page p; |
|
||||||
|
|
||||||
so = (RTreeScanOpaque) s->opaque; |
|
||||||
p = BufferGetPage(so->curbuf); |
|
||||||
|
|
||||||
maxoff = PageGetMaxOffsetNumber(p); |
|
||||||
po = (RTreePageOpaque) PageGetSpecialPointer(p); |
|
||||||
|
|
||||||
/*
|
|
||||||
* 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->s_flags & RTS_CURBEFORE) |
|
||||||
{ |
|
||||||
so->s_flags &= ~RTS_CURBEFORE; |
|
||||||
n = OffsetNumberPrev(n); |
|
||||||
} |
|
||||||
|
|
||||||
while (n >= FirstOffsetNumber && n <= maxoff) |
|
||||||
{ |
|
||||||
it = (IndexTuple) PageGetItem(p, PageGetItemId(p, n)); |
|
||||||
if (po->flags & F_LEAF) |
|
||||||
{ |
|
||||||
if (index_keytest(it, |
|
||||||
RelationGetDescr(s->indexRelation), |
|
||||||
s->numberOfKeys, s->keyData)) |
|
||||||
break; |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
if (index_keytest(it, |
|
||||||
RelationGetDescr(s->indexRelation), |
|
||||||
so->s_internalNKey, so->s_internalKey)) |
|
||||||
break; |
|
||||||
} |
|
||||||
|
|
||||||
if (ScanDirectionIsBackward(dir)) |
|
||||||
n = OffsetNumberPrev(n); |
|
||||||
else |
|
||||||
n = OffsetNumberNext(n); |
|
||||||
} |
|
||||||
|
|
||||||
if (n >= FirstOffsetNumber && n <= maxoff) |
|
||||||
return n; /* found a match on this page */ |
|
||||||
else |
|
||||||
return InvalidOffsetNumber; /* no match, go to next page */ |
|
||||||
} |
|
||||||
@ -1,175 +0,0 @@ |
|||||||
/*-------------------------------------------------------------------------
|
|
||||||
* |
|
||||||
* rtproc.c |
|
||||||
* pg_amproc entries for rtrees. |
|
||||||
* |
|
||||||
* NOTE: for largely-historical reasons, the intersection functions should |
|
||||||
* return a NULL pointer (*not* an SQL null value) to indicate "no |
|
||||||
* intersection". The size functions must be prepared to accept such |
|
||||||
* a pointer and return 0. This convention means that only pass-by-reference |
|
||||||
* data types can be used as the output of the union and intersection |
|
||||||
* routines, but that's not a big problem. |
|
||||||
* |
|
||||||
* |
|
||||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California |
|
||||||
* |
|
||||||
* IDENTIFICATION |
|
||||||
* $PostgreSQL: pgsql/src/backend/access/rtree/rtproc.c,v 1.43 2005/10/15 02:49:09 momjian Exp $ |
|
||||||
* |
|
||||||
*------------------------------------------------------------------------- |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "postgres.h" |
|
||||||
|
|
||||||
#include "utils/geo_decls.h" |
|
||||||
|
|
||||||
|
|
||||||
Datum |
|
||||||
rt_box_union(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
BOX *a = PG_GETARG_BOX_P(0); |
|
||||||
BOX *b = PG_GETARG_BOX_P(1); |
|
||||||
BOX *n; |
|
||||||
|
|
||||||
n = (BOX *) palloc(sizeof(BOX)); |
|
||||||
|
|
||||||
n->high.x = Max(a->high.x, b->high.x); |
|
||||||
n->high.y = Max(a->high.y, b->high.y); |
|
||||||
n->low.x = Min(a->low.x, b->low.x); |
|
||||||
n->low.y = Min(a->low.y, b->low.y); |
|
||||||
|
|
||||||
PG_RETURN_BOX_P(n); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rt_box_inter(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
BOX *a = PG_GETARG_BOX_P(0); |
|
||||||
BOX *b = PG_GETARG_BOX_P(1); |
|
||||||
BOX *n; |
|
||||||
|
|
||||||
n = (BOX *) palloc(sizeof(BOX)); |
|
||||||
|
|
||||||
n->high.x = Min(a->high.x, b->high.x); |
|
||||||
n->high.y = Min(a->high.y, b->high.y); |
|
||||||
n->low.x = Max(a->low.x, b->low.x); |
|
||||||
n->low.y = Max(a->low.y, b->low.y); |
|
||||||
|
|
||||||
if (n->high.x < n->low.x || n->high.y < n->low.y) |
|
||||||
{ |
|
||||||
pfree(n); |
|
||||||
/* Indicate "no intersection" by returning NULL pointer */ |
|
||||||
n = NULL; |
|
||||||
} |
|
||||||
|
|
||||||
PG_RETURN_BOX_P(n); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rt_box_size(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
BOX *a = PG_GETARG_BOX_P(0); |
|
||||||
|
|
||||||
/* NB: size is an output argument */ |
|
||||||
float *size = (float *) PG_GETARG_POINTER(1); |
|
||||||
|
|
||||||
if (a == NULL || a->high.x <= a->low.x || a->high.y <= a->low.y) |
|
||||||
*size = 0.0; |
|
||||||
else |
|
||||||
*size = (float) ((a->high.x - a->low.x) * (a->high.y - a->low.y)); |
|
||||||
|
|
||||||
PG_RETURN_VOID(); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rt_poly_union(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
POLYGON *a = PG_GETARG_POLYGON_P(0); |
|
||||||
POLYGON *b = PG_GETARG_POLYGON_P(1); |
|
||||||
POLYGON *p; |
|
||||||
|
|
||||||
p = (POLYGON *) palloc0(sizeof(POLYGON)); /* zero any holes */ |
|
||||||
p->size = sizeof(POLYGON); |
|
||||||
p->npts = 0; |
|
||||||
p->boundbox.high.x = Max(a->boundbox.high.x, b->boundbox.high.x); |
|
||||||
p->boundbox.high.y = Max(a->boundbox.high.y, b->boundbox.high.y); |
|
||||||
p->boundbox.low.x = Min(a->boundbox.low.x, b->boundbox.low.x); |
|
||||||
p->boundbox.low.y = Min(a->boundbox.low.y, b->boundbox.low.y); |
|
||||||
|
|
||||||
/* Avoid leaking memory when handed toasted input. */ |
|
||||||
PG_FREE_IF_COPY(a, 0); |
|
||||||
PG_FREE_IF_COPY(b, 1); |
|
||||||
|
|
||||||
PG_RETURN_POLYGON_P(p); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rt_poly_inter(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
POLYGON *a = PG_GETARG_POLYGON_P(0); |
|
||||||
POLYGON *b = PG_GETARG_POLYGON_P(1); |
|
||||||
POLYGON *p; |
|
||||||
|
|
||||||
p = (POLYGON *) palloc0(sizeof(POLYGON)); /* zero any holes */ |
|
||||||
p->size = sizeof(POLYGON); |
|
||||||
p->npts = 0; |
|
||||||
p->boundbox.high.x = Min(a->boundbox.high.x, b->boundbox.high.x); |
|
||||||
p->boundbox.high.y = Min(a->boundbox.high.y, b->boundbox.high.y); |
|
||||||
p->boundbox.low.x = Max(a->boundbox.low.x, b->boundbox.low.x); |
|
||||||
p->boundbox.low.y = Max(a->boundbox.low.y, b->boundbox.low.y); |
|
||||||
|
|
||||||
if (p->boundbox.high.x < p->boundbox.low.x || |
|
||||||
p->boundbox.high.y < p->boundbox.low.y) |
|
||||||
{ |
|
||||||
pfree(p); |
|
||||||
/* Indicate "no intersection" by returning NULL pointer */ |
|
||||||
p = NULL; |
|
||||||
} |
|
||||||
|
|
||||||
/* Avoid leaking memory when handed toasted input. */ |
|
||||||
PG_FREE_IF_COPY(a, 0); |
|
||||||
PG_FREE_IF_COPY(b, 1); |
|
||||||
|
|
||||||
PG_RETURN_POLYGON_P(p); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rt_poly_size(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
Pointer aptr = PG_GETARG_POINTER(0); |
|
||||||
|
|
||||||
/* NB: size is an output argument */ |
|
||||||
float *size = (float *) PG_GETARG_POINTER(1); |
|
||||||
POLYGON *a; |
|
||||||
double xdim, |
|
||||||
ydim; |
|
||||||
|
|
||||||
/*
|
|
||||||
* Can't just use GETARG because of possibility that input is NULL; since |
|
||||||
* POLYGON is toastable, GETARG will try to inspect its value |
|
||||||
*/ |
|
||||||
if (aptr == NULL) |
|
||||||
{ |
|
||||||
*size = 0.0; |
|
||||||
PG_RETURN_VOID(); |
|
||||||
} |
|
||||||
/* Now safe to apply GETARG */ |
|
||||||
a = PG_GETARG_POLYGON_P(0); |
|
||||||
|
|
||||||
if (a->boundbox.high.x <= a->boundbox.low.x || |
|
||||||
a->boundbox.high.y <= a->boundbox.low.y) |
|
||||||
*size = 0.0; |
|
||||||
else |
|
||||||
{ |
|
||||||
xdim = (a->boundbox.high.x - a->boundbox.low.x); |
|
||||||
ydim = (a->boundbox.high.y - a->boundbox.low.y); |
|
||||||
|
|
||||||
*size = (float) (xdim * ydim); |
|
||||||
} |
|
||||||
|
|
||||||
/* Avoid leaking memory when handed toasted input. */ |
|
||||||
PG_FREE_IF_COPY(a, 0); |
|
||||||
|
|
||||||
PG_RETURN_VOID(); |
|
||||||
} |
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,493 +0,0 @@ |
|||||||
/*-------------------------------------------------------------------------
|
|
||||||
* |
|
||||||
* rtscan.c |
|
||||||
* routines to manage scans on index relations |
|
||||||
* |
|
||||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California |
|
||||||
* |
|
||||||
* |
|
||||||
* IDENTIFICATION |
|
||||||
* $PostgreSQL: pgsql/src/backend/access/rtree/rtscan.c,v 1.60 2005/10/15 02:49:09 momjian Exp $ |
|
||||||
* |
|
||||||
*------------------------------------------------------------------------- |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "postgres.h" |
|
||||||
|
|
||||||
#include "access/genam.h" |
|
||||||
#include "access/rtree.h" |
|
||||||
#include "utils/lsyscache.h" |
|
||||||
#include "utils/resowner.h" |
|
||||||
|
|
||||||
|
|
||||||
/* routines defined and used here */ |
|
||||||
static void rtregscan(IndexScanDesc s); |
|
||||||
static void rtdropscan(IndexScanDesc s); |
|
||||||
static void rtadjone(IndexScanDesc s, int op, BlockNumber blkno, |
|
||||||
OffsetNumber offnum); |
|
||||||
static void adjuststack(RTSTACK *stk, BlockNumber blkno); |
|
||||||
static void adjustiptr(IndexScanDesc s, ItemPointer iptr, |
|
||||||
int op, BlockNumber blkno, OffsetNumber offnum); |
|
||||||
|
|
||||||
/*
|
|
||||||
* Whenever we start an rtree scan in a backend, we register it in private |
|
||||||
* space. Then if the rtree index gets updated, we check all registered |
|
||||||
* scans and adjust them if the tuple they point at got moved by the |
|
||||||
* update. We only need to do this in private space, because when we update |
|
||||||
* an rtree we have a write lock on the tree, so no other process can have |
|
||||||
* any locks at all on it. A single transaction can have write and read |
|
||||||
* locks on the same object, so that's why we need to handle this case. |
|
||||||
*/ |
|
||||||
|
|
||||||
typedef struct RTScanListData |
|
||||||
{ |
|
||||||
IndexScanDesc rtsl_scan; |
|
||||||
ResourceOwner rtsl_owner; |
|
||||||
struct RTScanListData *rtsl_next; |
|
||||||
} RTScanListData; |
|
||||||
|
|
||||||
typedef RTScanListData *RTScanList; |
|
||||||
|
|
||||||
/* pointer to list of local scans on rtrees */ |
|
||||||
static RTScanList RTScans = NULL; |
|
||||||
|
|
||||||
Datum |
|
||||||
rtbeginscan(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
Relation r = (Relation) PG_GETARG_POINTER(0); |
|
||||||
int nkeys = PG_GETARG_INT32(1); |
|
||||||
ScanKey key = (ScanKey) PG_GETARG_POINTER(2); |
|
||||||
IndexScanDesc s; |
|
||||||
|
|
||||||
s = RelationGetIndexScan(r, nkeys, key); |
|
||||||
|
|
||||||
rtregscan(s); |
|
||||||
|
|
||||||
PG_RETURN_POINTER(s); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rtrescan(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); |
|
||||||
ScanKey key = (ScanKey) PG_GETARG_POINTER(1); |
|
||||||
RTreeScanOpaque p; |
|
||||||
int i; |
|
||||||
|
|
||||||
/*
|
|
||||||
* Clear all the pointers. |
|
||||||
*/ |
|
||||||
ItemPointerSetInvalid(&s->currentItemData); |
|
||||||
ItemPointerSetInvalid(&s->currentMarkData); |
|
||||||
|
|
||||||
p = (RTreeScanOpaque) s->opaque; |
|
||||||
if (p != NULL) |
|
||||||
{ |
|
||||||
/* rescan an existing indexscan --- reset state */ |
|
||||||
freestack(p->s_stack); |
|
||||||
freestack(p->s_markstk); |
|
||||||
p->s_stack = p->s_markstk = NULL; |
|
||||||
p->s_flags = 0x0; |
|
||||||
/* drop pins on buffers -- no locks held */ |
|
||||||
if (BufferIsValid(p->curbuf)) |
|
||||||
{ |
|
||||||
ReleaseBuffer(p->curbuf); |
|
||||||
p->curbuf = InvalidBuffer; |
|
||||||
} |
|
||||||
if (BufferIsValid(p->markbuf)) |
|
||||||
{ |
|
||||||
ReleaseBuffer(p->markbuf); |
|
||||||
p->markbuf = InvalidBuffer; |
|
||||||
} |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
/* initialize opaque data */ |
|
||||||
p = (RTreeScanOpaque) palloc(sizeof(RTreeScanOpaqueData)); |
|
||||||
p->s_stack = p->s_markstk = NULL; |
|
||||||
p->curbuf = p->markbuf = InvalidBuffer; |
|
||||||
p->s_internalNKey = s->numberOfKeys; |
|
||||||
p->s_flags = 0x0; |
|
||||||
s->opaque = p; |
|
||||||
if (s->numberOfKeys > 0) |
|
||||||
p->s_internalKey = (ScanKey) palloc(sizeof(ScanKeyData) * s->numberOfKeys); |
|
||||||
} |
|
||||||
|
|
||||||
/* Update scan key, if a new one is given */ |
|
||||||
if (key && s->numberOfKeys > 0) |
|
||||||
{ |
|
||||||
memmove(s->keyData, |
|
||||||
key, |
|
||||||
s->numberOfKeys * sizeof(ScanKeyData)); |
|
||||||
|
|
||||||
/*
|
|
||||||
* Scans on internal pages use different operators than they do on |
|
||||||
* leaf pages. For example, if the user wants all boxes that exactly |
|
||||||
* match (x1,y1,x2,y2), then on internal pages we need to find all |
|
||||||
* boxes that contain (x1,y1,x2,y2). rtstrat.c knows how to pick the |
|
||||||
* opclass member to use for internal pages. In some cases we need to |
|
||||||
* negate the result of the opclass member. |
|
||||||
*/ |
|
||||||
for (i = 0; i < s->numberOfKeys; i++) |
|
||||||
{ |
|
||||||
AttrNumber attno = s->keyData[i].sk_attno; |
|
||||||
Oid opclass; |
|
||||||
Oid subtype; |
|
||||||
StrategyNumber orig_strategy; |
|
||||||
StrategyNumber int_strategy; |
|
||||||
Oid int_oper; |
|
||||||
RegProcedure int_proc; |
|
||||||
int int_flags; |
|
||||||
|
|
||||||
opclass = s->indexRelation->rd_indclass->values[attno - 1]; |
|
||||||
subtype = s->keyData[i].sk_subtype; |
|
||||||
orig_strategy = s->keyData[i].sk_strategy; |
|
||||||
int_strategy = RTMapToInternalOperator(orig_strategy); |
|
||||||
int_oper = get_opclass_member(opclass, subtype, int_strategy); |
|
||||||
Assert(OidIsValid(int_oper)); |
|
||||||
int_proc = get_opcode(int_oper); |
|
||||||
int_flags = s->keyData[i].sk_flags; |
|
||||||
if (RTMapToInternalNegate(orig_strategy)) |
|
||||||
int_flags |= SK_NEGATE; |
|
||||||
ScanKeyEntryInitialize(&(p->s_internalKey[i]), |
|
||||||
int_flags, |
|
||||||
attno, |
|
||||||
int_strategy, |
|
||||||
subtype, |
|
||||||
int_proc, |
|
||||||
s->keyData[i].sk_argument); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
PG_RETURN_VOID(); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rtmarkpos(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); |
|
||||||
RTreeScanOpaque p; |
|
||||||
RTSTACK *o, |
|
||||||
*n, |
|
||||||
*tmp; |
|
||||||
|
|
||||||
s->currentMarkData = s->currentItemData; |
|
||||||
p = (RTreeScanOpaque) s->opaque; |
|
||||||
if (p->s_flags & RTS_CURBEFORE) |
|
||||||
p->s_flags |= RTS_MRKBEFORE; |
|
||||||
else |
|
||||||
p->s_flags &= ~RTS_MRKBEFORE; |
|
||||||
|
|
||||||
o = NULL; |
|
||||||
n = p->s_stack; |
|
||||||
|
|
||||||
/* copy the parent stack from the current item data */ |
|
||||||
while (n != NULL) |
|
||||||
{ |
|
||||||
tmp = (RTSTACK *) palloc(sizeof(RTSTACK)); |
|
||||||
tmp->rts_child = n->rts_child; |
|
||||||
tmp->rts_blk = n->rts_blk; |
|
||||||
tmp->rts_parent = o; |
|
||||||
o = tmp; |
|
||||||
n = n->rts_parent; |
|
||||||
} |
|
||||||
|
|
||||||
freestack(p->s_markstk); |
|
||||||
p->s_markstk = o; |
|
||||||
|
|
||||||
/* Update markbuf: make sure to bump ref count on curbuf */ |
|
||||||
if (BufferIsValid(p->markbuf)) |
|
||||||
{ |
|
||||||
ReleaseBuffer(p->markbuf); |
|
||||||
p->markbuf = InvalidBuffer; |
|
||||||
} |
|
||||||
if (BufferIsValid(p->curbuf)) |
|
||||||
{ |
|
||||||
IncrBufferRefCount(p->curbuf); |
|
||||||
p->markbuf = p->curbuf; |
|
||||||
} |
|
||||||
|
|
||||||
PG_RETURN_VOID(); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rtrestrpos(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); |
|
||||||
RTreeScanOpaque p; |
|
||||||
RTSTACK *o, |
|
||||||
*n, |
|
||||||
*tmp; |
|
||||||
|
|
||||||
s->currentItemData = s->currentMarkData; |
|
||||||
p = (RTreeScanOpaque) s->opaque; |
|
||||||
if (p->s_flags & RTS_MRKBEFORE) |
|
||||||
p->s_flags |= RTS_CURBEFORE; |
|
||||||
else |
|
||||||
p->s_flags &= ~RTS_CURBEFORE; |
|
||||||
|
|
||||||
o = NULL; |
|
||||||
n = p->s_markstk; |
|
||||||
|
|
||||||
/* copy the parent stack from the current item data */ |
|
||||||
while (n != NULL) |
|
||||||
{ |
|
||||||
tmp = (RTSTACK *) palloc(sizeof(RTSTACK)); |
|
||||||
tmp->rts_child = n->rts_child; |
|
||||||
tmp->rts_blk = n->rts_blk; |
|
||||||
tmp->rts_parent = o; |
|
||||||
o = tmp; |
|
||||||
n = n->rts_parent; |
|
||||||
} |
|
||||||
|
|
||||||
freestack(p->s_stack); |
|
||||||
p->s_stack = o; |
|
||||||
|
|
||||||
/* Update curbuf; be sure to bump ref count on markbuf */ |
|
||||||
if (BufferIsValid(p->curbuf)) |
|
||||||
{ |
|
||||||
ReleaseBuffer(p->curbuf); |
|
||||||
p->curbuf = InvalidBuffer; |
|
||||||
} |
|
||||||
if (BufferIsValid(p->markbuf)) |
|
||||||
{ |
|
||||||
IncrBufferRefCount(p->markbuf); |
|
||||||
p->curbuf = p->markbuf; |
|
||||||
} |
|
||||||
|
|
||||||
PG_RETURN_VOID(); |
|
||||||
} |
|
||||||
|
|
||||||
Datum |
|
||||||
rtendscan(PG_FUNCTION_ARGS) |
|
||||||
{ |
|
||||||
IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); |
|
||||||
RTreeScanOpaque p; |
|
||||||
|
|
||||||
p = (RTreeScanOpaque) s->opaque; |
|
||||||
|
|
||||||
if (p != NULL) |
|
||||||
{ |
|
||||||
freestack(p->s_stack); |
|
||||||
freestack(p->s_markstk); |
|
||||||
if (BufferIsValid(p->curbuf)) |
|
||||||
ReleaseBuffer(p->curbuf); |
|
||||||
if (BufferIsValid(p->markbuf)) |
|
||||||
ReleaseBuffer(p->markbuf); |
|
||||||
pfree(s->opaque); |
|
||||||
} |
|
||||||
|
|
||||||
rtdropscan(s); |
|
||||||
|
|
||||||
PG_RETURN_VOID(); |
|
||||||
} |
|
||||||
|
|
||||||
static void |
|
||||||
rtregscan(IndexScanDesc s) |
|
||||||
{ |
|
||||||
RTScanList l; |
|
||||||
|
|
||||||
l = (RTScanList) palloc(sizeof(RTScanListData)); |
|
||||||
l->rtsl_scan = s; |
|
||||||
l->rtsl_owner = CurrentResourceOwner; |
|
||||||
l->rtsl_next = RTScans; |
|
||||||
RTScans = l; |
|
||||||
} |
|
||||||
|
|
||||||
static void |
|
||||||
rtdropscan(IndexScanDesc s) |
|
||||||
{ |
|
||||||
RTScanList l; |
|
||||||
RTScanList prev; |
|
||||||
|
|
||||||
prev = NULL; |
|
||||||
|
|
||||||
for (l = RTScans; |
|
||||||
l != NULL && l->rtsl_scan != s; |
|
||||||
l = l->rtsl_next) |
|
||||||
prev = l; |
|
||||||
|
|
||||||
if (l == NULL) |
|
||||||
elog(ERROR, "rtree scan list corrupted -- could not find 0x%p", |
|
||||||
(void *) s); |
|
||||||
|
|
||||||
if (prev == NULL) |
|
||||||
RTScans = l->rtsl_next; |
|
||||||
else |
|
||||||
prev->rtsl_next = l->rtsl_next; |
|
||||||
|
|
||||||
pfree(l); |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* ReleaseResources_rtree() --- clean up rtree subsystem resources. |
|
||||||
* |
|
||||||
* This is here because it needs to touch this module's static var RTScans. |
|
||||||
*/ |
|
||||||
void |
|
||||||
ReleaseResources_rtree(void) |
|
||||||
{ |
|
||||||
RTScanList l; |
|
||||||
RTScanList prev; |
|
||||||
RTScanList 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. |
|
||||||
*/ |
|
||||||
prev = NULL; |
|
||||||
|
|
||||||
for (l = RTScans; l != NULL; l = next) |
|
||||||
{ |
|
||||||
next = l->rtsl_next; |
|
||||||
if (l->rtsl_owner == CurrentResourceOwner) |
|
||||||
{ |
|
||||||
if (prev == NULL) |
|
||||||
RTScans = next; |
|
||||||
else |
|
||||||
prev->rtsl_next = next; |
|
||||||
|
|
||||||
pfree(l); |
|
||||||
/* prev does not change */ |
|
||||||
} |
|
||||||
else |
|
||||||
prev = l; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void |
|
||||||
rtadjscans(Relation r, int op, BlockNumber blkno, OffsetNumber offnum) |
|
||||||
{ |
|
||||||
RTScanList l; |
|
||||||
Oid relid; |
|
||||||
|
|
||||||
relid = RelationGetRelid(r); |
|
||||||
for (l = RTScans; l != NULL; l = l->rtsl_next) |
|
||||||
{ |
|
||||||
if (RelationGetRelid(l->rtsl_scan->indexRelation) == relid) |
|
||||||
rtadjone(l->rtsl_scan, op, blkno, offnum); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* rtadjone() -- adjust one scan for update. |
|
||||||
* |
|
||||||
* By here, the scan passed in is on a modified relation. Op tells |
|
||||||
* us what the modification is, and blkno and offind tell us what |
|
||||||
* block and offset index were affected. This routine checks the |
|
||||||
* current and marked positions, and the current and marked stacks, |
|
||||||
* to see if any stored location needs to be changed because of the |
|
||||||
* update. If so, we make the change here. |
|
||||||
*/ |
|
||||||
static void |
|
||||||
rtadjone(IndexScanDesc s, |
|
||||||
int op, |
|
||||||
BlockNumber blkno, |
|
||||||
OffsetNumber offnum) |
|
||||||
{ |
|
||||||
RTreeScanOpaque so; |
|
||||||
|
|
||||||
adjustiptr(s, &(s->currentItemData), op, blkno, offnum); |
|
||||||
adjustiptr(s, &(s->currentMarkData), op, blkno, offnum); |
|
||||||
|
|
||||||
so = (RTreeScanOpaque) s->opaque; |
|
||||||
|
|
||||||
if (op == RTOP_SPLIT) |
|
||||||
{ |
|
||||||
adjuststack(so->s_stack, blkno); |
|
||||||
adjuststack(so->s_markstk, blkno); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* adjustiptr() -- adjust current and marked item pointers in the scan |
|
||||||
* |
|
||||||
* Depending on the type of update and the place it happened, we |
|
||||||
* need to do nothing, to back up one record, or to start over on |
|
||||||
* the same page. |
|
||||||
*/ |
|
||||||
static void |
|
||||||
adjustiptr(IndexScanDesc s, |
|
||||||
ItemPointer iptr, |
|
||||||
int op, |
|
||||||
BlockNumber blkno, |
|
||||||
OffsetNumber offnum) |
|
||||||
{ |
|
||||||
OffsetNumber curoff; |
|
||||||
RTreeScanOpaque so; |
|
||||||
|
|
||||||
if (ItemPointerIsValid(iptr)) |
|
||||||
{ |
|
||||||
if (ItemPointerGetBlockNumber(iptr) == blkno) |
|
||||||
{ |
|
||||||
curoff = ItemPointerGetOffsetNumber(iptr); |
|
||||||
so = (RTreeScanOpaque) s->opaque; |
|
||||||
|
|
||||||
switch (op) |
|
||||||
{ |
|
||||||
case RTOP_DEL: |
|
||||||
/* back up one if we need to */ |
|
||||||
if (curoff >= offnum) |
|
||||||
{ |
|
||||||
|
|
||||||
if (curoff > FirstOffsetNumber) |
|
||||||
{ |
|
||||||
/* just adjust the item pointer */ |
|
||||||
ItemPointerSet(iptr, blkno, OffsetNumberPrev(curoff)); |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
/*
|
|
||||||
* remember that we're before the current tuple |
|
||||||
*/ |
|
||||||
ItemPointerSet(iptr, blkno, FirstOffsetNumber); |
|
||||||
if (iptr == &(s->currentItemData)) |
|
||||||
so->s_flags |= RTS_CURBEFORE; |
|
||||||
else |
|
||||||
so->s_flags |= RTS_MRKBEFORE; |
|
||||||
} |
|
||||||
} |
|
||||||
break; |
|
||||||
|
|
||||||
case RTOP_SPLIT: |
|
||||||
/* back to start of page on split */ |
|
||||||
ItemPointerSet(iptr, blkno, FirstOffsetNumber); |
|
||||||
if (iptr == &(s->currentItemData)) |
|
||||||
so->s_flags &= ~RTS_CURBEFORE; |
|
||||||
else |
|
||||||
so->s_flags &= ~RTS_MRKBEFORE; |
|
||||||
break; |
|
||||||
|
|
||||||
default: |
|
||||||
elog(ERROR, "unrecognized operation in rtree scan adjust: %d", op); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* adjuststack() -- adjust the supplied stack for a split on a page in |
|
||||||
* the index we're scanning. |
|
||||||
* |
|
||||||
* If a page on our parent stack has split, we need to back up to the |
|
||||||
* beginning of the page and rescan it. The reason for this is that |
|
||||||
* the split algorithm for rtrees doesn't order tuples in any useful |
|
||||||
* way on a single page. This means on that a split, we may wind up |
|
||||||
* looking at some heap tuples more than once. This is handled in the |
|
||||||
* access method update code for heaps; if we've modified the tuple we |
|
||||||
* are looking at already in this transaction, we ignore the update |
|
||||||
* request. |
|
||||||
*/ |
|
||||||
static void |
|
||||||
adjuststack(RTSTACK *stk, BlockNumber blkno) |
|
||||||
{ |
|
||||||
while (stk != NULL) |
|
||||||
{ |
|
||||||
if (stk->rts_blk == blkno) |
|
||||||
stk->rts_child = FirstOffsetNumber; |
|
||||||
|
|
||||||
stk = stk->rts_parent; |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,79 +0,0 @@ |
|||||||
/*-------------------------------------------------------------------------
|
|
||||||
* |
|
||||||
* rtstrat.c |
|
||||||
* strategy map data for rtrees. |
|
||||||
* |
|
||||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California |
|
||||||
* |
|
||||||
* |
|
||||||
* IDENTIFICATION |
|
||||||
* $PostgreSQL: pgsql/src/backend/access/rtree/rtstrat.c,v 1.27 2005/06/24 20:53:30 tgl Exp $ |
|
||||||
* |
|
||||||
*------------------------------------------------------------------------- |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "postgres.h" |
|
||||||
|
|
||||||
#include "access/rtree.h" |
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Here's something peculiar to rtrees that doesn't apply to most other |
|
||||||
* indexing structures: When we're searching a tree for a given value, we |
|
||||||
* can't do the same sorts of comparisons on internal node entries as we |
|
||||||
* do at leaves. The reason is that if we're looking for (say) all boxes |
|
||||||
* that are the same as (0,0,10,10), then we need to find all leaf pages |
|
||||||
* that overlap that region. So internally we search for overlap, and at |
|
||||||
* the leaf we search for equality. |
|
||||||
* |
|
||||||
* This array maps leaf search operators to the internal search operators. |
|
||||||
*/ |
|
||||||
static const StrategyNumber RTOperMap[RTNStrategies] = { |
|
||||||
RTOverRightStrategyNumber, /* left */ |
|
||||||
RTRightStrategyNumber, /* overleft */ |
|
||||||
RTOverlapStrategyNumber, /* overlap */ |
|
||||||
RTLeftStrategyNumber, /* overright */ |
|
||||||
RTOverLeftStrategyNumber, /* right */ |
|
||||||
RTContainsStrategyNumber, /* same */ |
|
||||||
RTContainsStrategyNumber, /* contains */ |
|
||||||
RTOverlapStrategyNumber, /* contained-by */ |
|
||||||
RTAboveStrategyNumber, /* overbelow */ |
|
||||||
RTOverAboveStrategyNumber, /* below */ |
|
||||||
RTOverBelowStrategyNumber, /* above */ |
|
||||||
RTBelowStrategyNumber /* overabove */ |
|
||||||
}; |
|
||||||
|
|
||||||
/*
|
|
||||||
* We may need to negate the result of the selected operator. (This could |
|
||||||
* be avoided by expanding the set of operators required for an opclass.) |
|
||||||
*/ |
|
||||||
static const bool RTNegateMap[RTNStrategies] = { |
|
||||||
true, /* left */ |
|
||||||
true, /* overleft */ |
|
||||||
false, /* overlap */ |
|
||||||
true, /* overright */ |
|
||||||
true, /* right */ |
|
||||||
false, /* same */ |
|
||||||
false, /* contains */ |
|
||||||
false, /* contained-by */ |
|
||||||
true, /* overbelow */ |
|
||||||
true, /* below */ |
|
||||||
true, /* above */ |
|
||||||
true /* overabove */ |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
StrategyNumber |
|
||||||
RTMapToInternalOperator(StrategyNumber strat) |
|
||||||
{ |
|
||||||
Assert(strat > 0 && strat <= RTNStrategies); |
|
||||||
return RTOperMap[strat - 1]; |
|
||||||
} |
|
||||||
|
|
||||||
bool |
|
||||||
RTMapToInternalNegate(StrategyNumber strat) |
|
||||||
{ |
|
||||||
Assert(strat > 0 && strat <= RTNStrategies); |
|
||||||
return RTNegateMap[strat - 1]; |
|
||||||
} |
|
||||||
@ -1,145 +0,0 @@ |
|||||||
/*-------------------------------------------------------------------------
|
|
||||||
* |
|
||||||
* rtree.h |
|
||||||
* common declarations for the rtree access method code. |
|
||||||
* |
|
||||||
* |
|
||||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California |
|
||||||
* |
|
||||||
* $PostgreSQL: pgsql/src/include/access/rtree.h,v 1.41 2005/06/24 20:53:31 tgl Exp $ |
|
||||||
* |
|
||||||
*------------------------------------------------------------------------- |
|
||||||
*/ |
|
||||||
#ifndef RTREE_H |
|
||||||
#define RTREE_H |
|
||||||
|
|
||||||
#include "access/itup.h" |
|
||||||
#include "access/sdir.h" |
|
||||||
#include "access/skey.h" |
|
||||||
#include "access/xlog.h" |
|
||||||
#include "utils/rel.h" |
|
||||||
|
|
||||||
/* see rtstrat.c for what all this is about */ |
|
||||||
#define RTNStrategies 12 |
|
||||||
#define RTLeftStrategyNumber 1 |
|
||||||
#define RTOverLeftStrategyNumber 2 |
|
||||||
#define RTOverlapStrategyNumber 3 |
|
||||||
#define RTOverRightStrategyNumber 4 |
|
||||||
#define RTRightStrategyNumber 5 |
|
||||||
#define RTSameStrategyNumber 6 |
|
||||||
#define RTContainsStrategyNumber 7 |
|
||||||
#define RTContainedByStrategyNumber 8 |
|
||||||
#define RTOverBelowStrategyNumber 9 |
|
||||||
#define RTBelowStrategyNumber 10 |
|
||||||
#define RTAboveStrategyNumber 11 |
|
||||||
#define RTOverAboveStrategyNumber 12 |
|
||||||
|
|
||||||
#define RTNProcs 3 |
|
||||||
#define RT_UNION_PROC 1 |
|
||||||
#define RT_INTER_PROC 2 |
|
||||||
#define RT_SIZE_PROC 3 |
|
||||||
|
|
||||||
#define F_LEAF (1 << 0) |
|
||||||
|
|
||||||
typedef struct RTreePageOpaqueData |
|
||||||
{ |
|
||||||
uint32 flags; |
|
||||||
} RTreePageOpaqueData; |
|
||||||
|
|
||||||
typedef RTreePageOpaqueData *RTreePageOpaque; |
|
||||||
|
|
||||||
/*
|
|
||||||
* When we descend a tree, we keep a stack of parent pointers. |
|
||||||
*/ |
|
||||||
|
|
||||||
typedef struct RTSTACK |
|
||||||
{ |
|
||||||
struct RTSTACK *rts_parent; |
|
||||||
OffsetNumber rts_child; |
|
||||||
BlockNumber rts_blk; |
|
||||||
} RTSTACK; |
|
||||||
|
|
||||||
/*
|
|
||||||
* When we're doing a scan, we need to keep track of the parent stack |
|
||||||
* for the marked and current items. Also, rtrees have the following |
|
||||||
* property: if you're looking for the box (1,1,2,2), on the internal |
|
||||||
* nodes you have to search for all boxes that *contain* (1,1,2,2), |
|
||||||
* and not the ones that match it. We have a private scan key for |
|
||||||
* internal nodes in the opaque structure for rtrees for this reason. |
|
||||||
* See access/index-rtree/rtscan.c and rtstrat.c for how it gets |
|
||||||
* initialized. We also keep pins on the scan's current buffer and |
|
||||||
* marked buffer, if any: this avoids the need to invoke ReadBuffer() |
|
||||||
* for each tuple produced by the index scan. |
|
||||||
*/ |
|
||||||
|
|
||||||
typedef struct RTreeScanOpaqueData |
|
||||||
{ |
|
||||||
struct RTSTACK *s_stack; |
|
||||||
struct RTSTACK *s_markstk; |
|
||||||
uint16 s_flags; |
|
||||||
int s_internalNKey; |
|
||||||
ScanKey s_internalKey; |
|
||||||
Buffer curbuf; |
|
||||||
Buffer markbuf; |
|
||||||
} RTreeScanOpaqueData; |
|
||||||
|
|
||||||
typedef RTreeScanOpaqueData *RTreeScanOpaque; |
|
||||||
|
|
||||||
/*
|
|
||||||
* When we're doing a scan and updating a tree at the same time, the |
|
||||||
* updates may affect the scan. We use the flags entry of the scan's |
|
||||||
* opaque space to record our actual position in response to updates |
|
||||||
* that we can't handle simply by adjusting pointers. |
|
||||||
*/ |
|
||||||
|
|
||||||
#define RTS_CURBEFORE ((uint16) (1 << 0)) |
|
||||||
#define RTS_MRKBEFORE ((uint16) (1 << 1)) |
|
||||||
|
|
||||||
/* root page of an rtree */ |
|
||||||
#define P_ROOT 0 |
|
||||||
|
|
||||||
/*
|
|
||||||
* When we update a relation on which we're doing a scan, we need to |
|
||||||
* check the scan and fix it if the update affected any of the pages it |
|
||||||
* touches. Otherwise, we can miss records that we should see. The only |
|
||||||
* times we need to do this are for deletions and splits. See the code in |
|
||||||
* rtscan.c for how the scan is fixed. These two contants tell us what sort |
|
||||||
* of operation changed the index. |
|
||||||
*/ |
|
||||||
|
|
||||||
#define RTOP_DEL 0 |
|
||||||
#define RTOP_SPLIT 1 |
|
||||||
|
|
||||||
/* defined in rtree.c */ |
|
||||||
extern void freestack(RTSTACK *s); |
|
||||||
|
|
||||||
/*
|
|
||||||
* RTree code. |
|
||||||
* Defined in access/rtree/ |
|
||||||
*/ |
|
||||||
extern Datum rtinsert(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtbulkdelete(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtbeginscan(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtgettuple(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtgetmulti(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtendscan(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtmarkpos(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtrestrpos(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtrescan(PG_FUNCTION_ARGS); |
|
||||||
extern Datum rtbuild(PG_FUNCTION_ARGS); |
|
||||||
extern void _rtdump(Relation r); |
|
||||||
|
|
||||||
extern void rtree_redo(XLogRecPtr lsn, XLogRecord *record); |
|
||||||
extern void rtree_desc(char *buf, uint8 xl_info, char *rec); |
|
||||||
|
|
||||||
/* rtscan.c */ |
|
||||||
extern void rtadjscans(Relation r, int op, BlockNumber blkno, |
|
||||||
OffsetNumber offnum); |
|
||||||
extern void ReleaseResources_rtree(void); |
|
||||||
|
|
||||||
/* rtstrat.c */ |
|
||||||
extern StrategyNumber RTMapToInternalOperator(StrategyNumber strat); |
|
||||||
extern bool RTMapToInternalNegate(StrategyNumber strat); |
|
||||||
|
|
||||||
#endif /* RTREE_H */ |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
/*-------------------------------------------------------------------------
|
|
||||||
* |
|
||||||
* rtscan.h |
|
||||||
* routines defined in access/rtree/rtscan.c |
|
||||||
* |
|
||||||
* |
|
||||||
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group |
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California |
|
||||||
* |
|
||||||
* $PostgreSQL: pgsql/src/include/access/rtscan.h,v 1.18 2004/12/31 22:03:21 pgsql Exp $ |
|
||||||
* |
|
||||||
*------------------------------------------------------------------------- |
|
||||||
*/ |
|
||||||
#ifndef RTSCAN_H |
|
||||||
#define RTSCAN_H |
|
||||||
|
|
||||||
#include "storage/block.h" |
|
||||||
#include "storage/off.h" |
|
||||||
#include "utils/rel.h" |
|
||||||
|
|
||||||
void rtadjscans(Relation r, int op, BlockNumber blkno, OffsetNumber offnum); |
|
||||||
|
|
||||||
#endif /* RTSCAN_H */ |
|
||||||
Loading…
Reference in new issue