mirror of
https://github.com/postgres/postgres.git
synced 2025-08-28 18:48:04 +03:00
Massive commit to run PGINDENT on all *.c and *.h files.
This commit is contained in:
Bruce Momjian
@@ -1,17 +1,17 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* genam.c--
|
||||
* general index access method routines
|
||||
* general index access method routines
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.7 1997/08/19 21:29:26 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.8 1997/09/07 04:38:17 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* many of the old access method routines have been turned into
|
||||
* macros and moved to genam.h -cim 4/30/91
|
||||
* many of the old access method routines have been turned into
|
||||
* macros and moved to genam.h -cim 4/30/91
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@@ -29,18 +29,18 @@
|
||||
* previous, current, next. Note that the case of reverse scans works
|
||||
* identically.
|
||||
*
|
||||
* State Result
|
||||
* (1) + + - + 0 0 (if the next item pointer is invalid)
|
||||
* (2) + X - (otherwise)
|
||||
* (3) * 0 0 * 0 0 (no change)
|
||||
* (4) + X 0 X 0 0 (shift)
|
||||
* (5) * + X + X - (shift, add unknown)
|
||||
* State Result
|
||||
* (1) + + - + 0 0 (if the next item pointer is invalid)
|
||||
* (2) + X - (otherwise)
|
||||
* (3) * 0 0 * 0 0 (no change)
|
||||
* (4) + X 0 X 0 0 (shift)
|
||||
* (5) * + X + X - (shift, add unknown)
|
||||
*
|
||||
* All other states cannot occur.
|
||||
*
|
||||
* Note:
|
||||
*It would be possible to cache the status of the previous and
|
||||
* next item pointer using the flags.
|
||||
* next item pointer using the flags.
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
@@ -51,220 +51,234 @@
|
||||
#include <storage/bufmgr.h>
|
||||
|
||||
#ifndef HAVE_MEMMOVE
|
||||
# include <regex/utils.h>
|
||||
#include <regex/utils.h>
|
||||
#else
|
||||
# include <string.h>
|
||||
#include <string.h>
|
||||
#endif
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* general access method routines
|
||||
* general access method routines
|
||||
*
|
||||
* All indexed access methods use an identical scan structure.
|
||||
* We don't know how the various AMs do locking, however, so we don't
|
||||
* do anything about that here.
|
||||
* All indexed access methods use an identical scan structure.
|
||||
* We don't know how the various AMs do locking, however, so we don't
|
||||
* do anything about that here.
|
||||
*
|
||||
* The intent is that an AM implementor will define a front-end routine
|
||||
* that calls this one, to fill in the scan, and then does whatever kind
|
||||
* of locking he wants.
|
||||
* The intent is that an AM implementor will define a front-end routine
|
||||
* that calls this one, to fill in the scan, and then does whatever kind
|
||||
* of locking he wants.
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* ----------------
|
||||
* RelationGetIndexScan -- Create and fill an IndexScanDesc.
|
||||
* RelationGetIndexScan -- Create and fill an IndexScanDesc.
|
||||
*
|
||||
* This routine creates an index scan structure and sets its contents
|
||||
* up correctly. This routine calls AMrescan to set up the scan with
|
||||
* the passed key.
|
||||
* This routine creates an index scan structure and sets its contents
|
||||
* up correctly. This routine calls AMrescan to set up the scan with
|
||||
* the passed key.
|
||||
*
|
||||
* Parameters:
|
||||
* relation -- index relation for scan.
|
||||
* scanFromEnd -- if true, begin scan at one of the index's
|
||||
* endpoints.
|
||||
* numberOfKeys -- count of scan keys (more than one won't
|
||||
* necessarily do anything useful, yet).
|
||||
* key -- the ScanKey for the starting position of the scan.
|
||||
* Parameters:
|
||||
* relation -- index relation for scan.
|
||||
* scanFromEnd -- if true, begin scan at one of the index's
|
||||
* endpoints.
|
||||
* numberOfKeys -- count of scan keys (more than one won't
|
||||
* necessarily do anything useful, yet).
|
||||
* key -- the ScanKey for the starting position of the scan.
|
||||
*
|
||||
* Returns:
|
||||
* An initialized IndexScanDesc.
|
||||
* Returns:
|
||||
* An initialized IndexScanDesc.
|
||||
*
|
||||
* Side Effects:
|
||||
* Bumps the ref count on the relation to keep it in the cache.
|
||||
*
|
||||
* Side Effects:
|
||||
* Bumps the ref count on the relation to keep it in the cache.
|
||||
*
|
||||
* ----------------
|
||||
*/
|
||||
IndexScanDesc
|
||||
RelationGetIndexScan(Relation relation,
|
||||
bool scanFromEnd,
|
||||
uint16 numberOfKeys,
|
||||
ScanKey key)
|
||||
bool scanFromEnd,
|
||||
uint16 numberOfKeys,
|
||||
ScanKey key)
|
||||
{
|
||||
IndexScanDesc scan;
|
||||
|
||||
if (! RelationIsValid(relation))
|
||||
elog(WARN, "RelationGetIndexScan: relation invalid");
|
||||
|
||||
scan = (IndexScanDesc) palloc(sizeof(IndexScanDescData));
|
||||
|
||||
scan->relation = relation;
|
||||
scan->opaque = NULL;
|
||||
scan->numberOfKeys = numberOfKeys;
|
||||
|
||||
ItemPointerSetInvalid(&scan->previousItemData);
|
||||
ItemPointerSetInvalid(&scan->currentItemData);
|
||||
ItemPointerSetInvalid(&scan->nextItemData);
|
||||
ItemPointerSetInvalid(&scan->previousMarkData);
|
||||
ItemPointerSetInvalid(&scan->currentMarkData);
|
||||
ItemPointerSetInvalid(&scan->nextMarkData);
|
||||
IndexScanDesc scan;
|
||||
|
||||
if (numberOfKeys > 0) {
|
||||
scan->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * numberOfKeys);
|
||||
} else {
|
||||
scan->keyData = NULL;
|
||||
}
|
||||
if (!RelationIsValid(relation))
|
||||
elog(WARN, "RelationGetIndexScan: relation invalid");
|
||||
|
||||
index_rescan(scan, scanFromEnd, key);
|
||||
|
||||
return (scan);
|
||||
scan = (IndexScanDesc) palloc(sizeof(IndexScanDescData));
|
||||
|
||||
scan->relation = relation;
|
||||
scan->opaque = NULL;
|
||||
scan->numberOfKeys = numberOfKeys;
|
||||
|
||||
ItemPointerSetInvalid(&scan->previousItemData);
|
||||
ItemPointerSetInvalid(&scan->currentItemData);
|
||||
ItemPointerSetInvalid(&scan->nextItemData);
|
||||
ItemPointerSetInvalid(&scan->previousMarkData);
|
||||
ItemPointerSetInvalid(&scan->currentMarkData);
|
||||
ItemPointerSetInvalid(&scan->nextMarkData);
|
||||
|
||||
if (numberOfKeys > 0)
|
||||
{
|
||||
scan->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * numberOfKeys);
|
||||
}
|
||||
else
|
||||
{
|
||||
scan->keyData = NULL;
|
||||
}
|
||||
|
||||
index_rescan(scan, scanFromEnd, key);
|
||||
|
||||
return (scan);
|
||||
}
|
||||
|
||||
#ifdef NOT_USED
|
||||
/* ----------------
|
||||
* IndexScanRestart -- Restart an index scan.
|
||||
* IndexScanRestart -- Restart an index scan.
|
||||
*
|
||||
* This routine isn't used by any existing access method. It's
|
||||
* appropriate if relation level locks are what you want.
|
||||
* This routine isn't used by any existing access method. It's
|
||||
* appropriate if relation level locks are what you want.
|
||||
*
|
||||
* Returns:
|
||||
* None.
|
||||
* Returns:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* None.
|
||||
* Side Effects:
|
||||
* None.
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
IndexScanRestart(IndexScanDesc scan,
|
||||
bool scanFromEnd,
|
||||
ScanKey key)
|
||||
bool scanFromEnd,
|
||||
ScanKey key)
|
||||
{
|
||||
if (! IndexScanIsValid(scan))
|
||||
elog(WARN, "IndexScanRestart: invalid scan");
|
||||
|
||||
ItemPointerSetInvalid(&scan->previousItemData);
|
||||
ItemPointerSetInvalid(&scan->currentItemData);
|
||||
ItemPointerSetInvalid(&scan->nextItemData);
|
||||
|
||||
if (RelationGetNumberOfBlocks(scan->relation) == 0)
|
||||
scan->flags = ScanUnmarked;
|
||||
else if (scanFromEnd)
|
||||
scan->flags = ScanUnmarked | ScanUncheckedPrevious;
|
||||
else
|
||||
scan->flags = ScanUnmarked | ScanUncheckedNext;
|
||||
|
||||
scan->scanFromEnd = (bool) scanFromEnd;
|
||||
|
||||
if (scan->numberOfKeys > 0)
|
||||
memmove(scan->keyData,
|
||||
key,
|
||||
scan->numberOfKeys * sizeof(ScanKeyData));
|
||||
if (!IndexScanIsValid(scan))
|
||||
elog(WARN, "IndexScanRestart: invalid scan");
|
||||
|
||||
ItemPointerSetInvalid(&scan->previousItemData);
|
||||
ItemPointerSetInvalid(&scan->currentItemData);
|
||||
ItemPointerSetInvalid(&scan->nextItemData);
|
||||
|
||||
if (RelationGetNumberOfBlocks(scan->relation) == 0)
|
||||
scan->flags = ScanUnmarked;
|
||||
else if (scanFromEnd)
|
||||
scan->flags = ScanUnmarked | ScanUncheckedPrevious;
|
||||
else
|
||||
scan->flags = ScanUnmarked | ScanUncheckedNext;
|
||||
|
||||
scan->scanFromEnd = (bool) scanFromEnd;
|
||||
|
||||
if (scan->numberOfKeys > 0)
|
||||
memmove(scan->keyData,
|
||||
key,
|
||||
scan->numberOfKeys * sizeof(ScanKeyData));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef NOT_USED
|
||||
/* ----------------
|
||||
* IndexScanEnd -- End and index scan.
|
||||
* IndexScanEnd -- End and index scan.
|
||||
*
|
||||
* This routine is not used by any existing access method, but is
|
||||
* suitable for use if you don't want to do sophisticated locking.
|
||||
* This routine is not used by any existing access method, but is
|
||||
* suitable for use if you don't want to do sophisticated locking.
|
||||
*
|
||||
* Returns:
|
||||
* None.
|
||||
* Returns:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* None.
|
||||
* Side Effects:
|
||||
* None.
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
IndexScanEnd(IndexScanDesc scan)
|
||||
{
|
||||
if (! IndexScanIsValid(scan))
|
||||
elog(WARN, "IndexScanEnd: invalid scan");
|
||||
|
||||
pfree(scan);
|
||||
if (!IndexScanIsValid(scan))
|
||||
elog(WARN, "IndexScanEnd: invalid scan");
|
||||
|
||||
pfree(scan);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* ----------------
|
||||
* IndexScanMarkPosition -- Mark current position in a scan.
|
||||
* IndexScanMarkPosition -- Mark current position in a scan.
|
||||
*
|
||||
* This routine isn't used by any existing access method, but is the
|
||||
* one that AM implementors should use, if they don't want to do any
|
||||
* special locking. If relation-level locking is sufficient, this is
|
||||
* the routine for you.
|
||||
* This routine isn't used by any existing access method, but is the
|
||||
* one that AM implementors should use, if they don't want to do any
|
||||
* special locking. If relation-level locking is sufficient, this is
|
||||
* the routine for you.
|
||||
*
|
||||
* Returns:
|
||||
* None.
|
||||
* Returns:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* None.
|
||||
* Side Effects:
|
||||
* None.
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
IndexScanMarkPosition(IndexScanDesc scan)
|
||||
{
|
||||
RetrieveIndexResult result;
|
||||
|
||||
if (scan->flags & ScanUncheckedPrevious) {
|
||||
result =
|
||||
index_getnext(scan, BackwardScanDirection);
|
||||
|
||||
if (result != NULL) {
|
||||
scan->previousItemData = result->index_iptr;
|
||||
} else {
|
||||
ItemPointerSetInvalid(&scan->previousItemData);
|
||||
RetrieveIndexResult result;
|
||||
|
||||
if (scan->flags & ScanUncheckedPrevious)
|
||||
{
|
||||
result =
|
||||
index_getnext(scan, BackwardScanDirection);
|
||||
|
||||
if (result != NULL)
|
||||
{
|
||||
scan->previousItemData = result->index_iptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
ItemPointerSetInvalid(&scan->previousItemData);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} else if (scan->flags & ScanUncheckedNext) {
|
||||
result = (RetrieveIndexResult)
|
||||
index_getnext(scan, ForwardScanDirection);
|
||||
|
||||
if (result != NULL) {
|
||||
scan->nextItemData = result->index_iptr;
|
||||
} else {
|
||||
ItemPointerSetInvalid(&scan->nextItemData);
|
||||
else if (scan->flags & ScanUncheckedNext)
|
||||
{
|
||||
result = (RetrieveIndexResult)
|
||||
index_getnext(scan, ForwardScanDirection);
|
||||
|
||||
if (result != NULL)
|
||||
{
|
||||
scan->nextItemData = result->index_iptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
ItemPointerSetInvalid(&scan->nextItemData);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
scan->previousMarkData = scan->previousItemData;
|
||||
scan->currentMarkData = scan->currentItemData;
|
||||
scan->nextMarkData = scan->nextItemData;
|
||||
|
||||
scan->flags = 0x0; /* XXX should have a symbolic name */
|
||||
|
||||
scan->previousMarkData = scan->previousItemData;
|
||||
scan->currentMarkData = scan->currentItemData;
|
||||
scan->nextMarkData = scan->nextItemData;
|
||||
|
||||
scan->flags = 0x0; /* XXX should have a symbolic name */
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* IndexScanRestorePosition -- Restore position on a marked scan.
|
||||
* IndexScanRestorePosition -- Restore position on a marked scan.
|
||||
*
|
||||
* This routine isn't used by any existing access method, but is the
|
||||
* one that AM implementors should use if they don't want to do any
|
||||
* special locking. If relation-level locking is sufficient, then
|
||||
* this is the one you want.
|
||||
* This routine isn't used by any existing access method, but is the
|
||||
* one that AM implementors should use if they don't want to do any
|
||||
* special locking. If relation-level locking is sufficient, then
|
||||
* this is the one you want.
|
||||
*
|
||||
* Returns:
|
||||
* None.
|
||||
* Returns:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* None.
|
||||
* Side Effects:
|
||||
* None.
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
IndexScanRestorePosition(IndexScanDesc scan)
|
||||
{
|
||||
if (scan->flags & ScanUnmarked)
|
||||
elog(WARN, "IndexScanRestorePosition: no mark to restore");
|
||||
|
||||
scan->previousItemData = scan->previousMarkData;
|
||||
scan->currentItemData = scan->currentMarkData;
|
||||
scan->nextItemData = scan->nextMarkData;
|
||||
|
||||
scan->flags = 0x0; /* XXX should have a symbolic name */
|
||||
{
|
||||
if (scan->flags & ScanUnmarked)
|
||||
elog(WARN, "IndexScanRestorePosition: no mark to restore");
|
||||
|
||||
scan->previousItemData = scan->previousMarkData;
|
||||
scan->currentItemData = scan->currentMarkData;
|
||||
scan->nextItemData = scan->nextMarkData;
|
||||
|
||||
scan->flags = 0x0; /* XXX should have a symbolic name */
|
||||
}
|
||||
|
||||
@@ -1,80 +1,80 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* indexam.c--
|
||||
* general index access method routines
|
||||
* general index access method routines
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.13 1997/08/26 23:31:28 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.14 1997/09/07 04:38:26 momjian Exp $
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
* index_open - open an index relation by relationId
|
||||
* index_openr - open a index relation by name
|
||||
* index_close - close a index relation
|
||||
* index_beginscan - start a scan of an index
|
||||
* index_rescan - restart a scan of an index
|
||||
* index_endscan - end a scan
|
||||
* index_insert - insert an index tuple into a relation
|
||||
* index_delete - delete an item from an index relation
|
||||
* index_markpos - mark a scan position
|
||||
* index_restrpos - restore a scan position
|
||||
* index_getnext - get the next tuple from a scan
|
||||
* ** index_fetch - retrieve tuple with tid
|
||||
* index_open - open an index relation by relationId
|
||||
* index_openr - open a index relation by name
|
||||
* index_close - close a index relation
|
||||
* index_beginscan - start a scan of an index
|
||||
* index_rescan - restart a scan of an index
|
||||
* index_endscan - end a scan
|
||||
* index_insert - insert an index tuple into a relation
|
||||
* index_delete - delete an item from an index relation
|
||||
* index_markpos - mark a scan position
|
||||
* index_restrpos - restore a scan position
|
||||
* index_getnext - get the next tuple from a scan
|
||||
* ** index_fetch - retrieve tuple with tid
|
||||
* ** index_replace - replace a tuple
|
||||
* ** index_getattr - get an attribute from an index tuple
|
||||
* index_getprocid - get a support procedure id from the rel tuple
|
||||
*
|
||||
* IndexScanIsValid - check index scan
|
||||
* index_getprocid - get a support procedure id from the rel tuple
|
||||
*
|
||||
* IndexScanIsValid - check index scan
|
||||
*
|
||||
* NOTES
|
||||
* This file contains the index_ routines which used
|
||||
* to be a scattered collection of stuff in access/genam.
|
||||
* This file contains the index_ routines which used
|
||||
* to be a scattered collection of stuff in access/genam.
|
||||
*
|
||||
* The ** routines: index_fetch, index_replace, and index_getattr
|
||||
* have not yet been implemented. They may not be needed.
|
||||
* The ** routines: index_fetch, index_replace, and index_getattr
|
||||
* have not yet been implemented. They may not be needed.
|
||||
*
|
||||
* old comments
|
||||
* Scans are implemented as follows:
|
||||
* Scans are implemented as follows:
|
||||
*
|
||||
* `0' represents an invalid item pointer.
|
||||
* `-' represents an unknown item pointer.
|
||||
* `X' represents a known item pointers.
|
||||
* `+' represents known or invalid item pointers.
|
||||
* `*' represents any item pointers.
|
||||
* `0' represents an invalid item pointer.
|
||||
* `-' represents an unknown item pointer.
|
||||
* `X' represents a known item pointers.
|
||||
* `+' represents known or invalid item pointers.
|
||||
* `*' represents any item pointers.
|
||||
*
|
||||
* State is represented by a triple of these symbols in the order of
|
||||
* previous, current, next. Note that the case of reverse scans works
|
||||
* identically.
|
||||
* State is represented by a triple of these symbols in the order of
|
||||
* previous, current, next. Note that the case of reverse scans works
|
||||
* identically.
|
||||
*
|
||||
* State Result
|
||||
* (1) + + - + 0 0 (if the next item pointer is invalid)
|
||||
* (2) + X - (otherwise)
|
||||
* (3) * 0 0 * 0 0 (no change)
|
||||
* (4) + X 0 X 0 0 (shift)
|
||||
* (5) * + X + X - (shift, add unknown)
|
||||
* State Result
|
||||
* (1) + + - + 0 0 (if the next item pointer is invalid)
|
||||
* (2) + X - (otherwise)
|
||||
* (3) * 0 0 * 0 0 (no change)
|
||||
* (4) + X 0 X 0 0 (shift)
|
||||
* (5) * + X + X - (shift, add unknown)
|
||||
*
|
||||
* All other states cannot occur.
|
||||
* All other states cannot occur.
|
||||
*
|
||||
* Note: It would be possible to cache the status of the previous and
|
||||
* next item pointer using the flags.
|
||||
* Note: It would be possible to cache the status of the previous and
|
||||
* next item pointer using the flags.
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <postgres.h>
|
||||
|
||||
#include <access/genam.h>
|
||||
|
||||
#include <access/genam.h>
|
||||
#include <utils/relcache.h>
|
||||
#include <fmgr.h>
|
||||
#include <storage/lmgr.h>
|
||||
#include <access/heapam.h>
|
||||
|
||||
/* ----------------
|
||||
* undefine macros we aren't going to use that would otherwise
|
||||
* get in our way.. delete is defined in c.h and the am's are
|
||||
* defined in heapam.h
|
||||
* undefine macros we aren't going to use that would otherwise
|
||||
* get in our way.. delete is defined in c.h and the am's are
|
||||
* defined in heapam.h
|
||||
* ----------------
|
||||
*/
|
||||
#undef delete
|
||||
@@ -88,314 +88,320 @@
|
||||
#undef amgettuple
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* macros used in index_ routines
|
||||
* macros used in index_ routines
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
#define RELATION_CHECKS \
|
||||
Assert(RelationIsValid(relation)); \
|
||||
Assert(PointerIsValid(relation->rd_am))
|
||||
|
||||
Assert(PointerIsValid(relation->rd_am))
|
||||
|
||||
#define SCAN_CHECKS \
|
||||
Assert(IndexScanIsValid(scan)); \
|
||||
Assert(RelationIsValid(scan->relation)); \
|
||||
Assert(PointerIsValid(scan->relation->rd_am))
|
||||
|
||||
Assert(IndexScanIsValid(scan)); \
|
||||
Assert(RelationIsValid(scan->relation)); \
|
||||
Assert(PointerIsValid(scan->relation->rd_am))
|
||||
|
||||
#define GET_REL_PROCEDURE(x,y) \
|
||||
procedure = relation->rd_am->y; \
|
||||
if (! RegProcedureIsValid(procedure)) \
|
||||
elog(WARN, "index_%s: invalid %s regproc", \
|
||||
CppAsString(x), CppAsString(y))
|
||||
|
||||
procedure = relation->rd_am->y; \
|
||||
if (! RegProcedureIsValid(procedure)) \
|
||||
elog(WARN, "index_%s: invalid %s regproc", \
|
||||
CppAsString(x), CppAsString(y))
|
||||
|
||||
#define GET_SCAN_PROCEDURE(x,y) \
|
||||
procedure = scan->relation->rd_am->y; \
|
||||
if (! RegProcedureIsValid(procedure)) \
|
||||
elog(WARN, "index_%s: invalid %s regproc", \
|
||||
CppAsString(x), CppAsString(y))
|
||||
|
||||
|
||||
procedure = scan->relation->rd_am->y; \
|
||||
if (! RegProcedureIsValid(procedure)) \
|
||||
elog(WARN, "index_%s: invalid %s regproc", \
|
||||
CppAsString(x), CppAsString(y))
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* index_ interface functions
|
||||
* index_ interface functions
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
/* ----------------
|
||||
* index_open - open an index relation by relationId
|
||||
* index_open - open an index relation by relationId
|
||||
*
|
||||
* presently the relcache routines do all the work we need
|
||||
* to open/close index relations.
|
||||
* presently the relcache routines do all the work we need
|
||||
* to open/close index relations.
|
||||
* ----------------
|
||||
*/
|
||||
Relation
|
||||
index_open(Oid relationId)
|
||||
{
|
||||
return RelationIdGetRelation(relationId);
|
||||
return RelationIdGetRelation(relationId);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_openr - open a index relation by name
|
||||
* index_openr - open a index relation by name
|
||||
*
|
||||
* presently the relcache routines do all the work we need
|
||||
* to open/close index relations.
|
||||
* presently the relcache routines do all the work we need
|
||||
* to open/close index relations.
|
||||
* ----------------
|
||||
*/
|
||||
Relation
|
||||
index_openr(char *relationName)
|
||||
{
|
||||
return RelationNameGetRelation(relationName);
|
||||
return RelationNameGetRelation(relationName);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_close - close a index relation
|
||||
* index_close - close a index relation
|
||||
*
|
||||
* presently the relcache routines do all the work we need
|
||||
* to open/close index relations.
|
||||
* presently the relcache routines do all the work we need
|
||||
* to open/close index relations.
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
index_close(Relation relation)
|
||||
{
|
||||
RelationClose(relation);
|
||||
RelationClose(relation);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_insert - insert an index tuple into a relation
|
||||
* index_insert - insert an index tuple into a relation
|
||||
* ----------------
|
||||
*/
|
||||
InsertIndexResult
|
||||
index_insert(Relation relation,
|
||||
Datum *datum,
|
||||
char *nulls,
|
||||
ItemPointer heap_t_ctid,
|
||||
Relation heapRel)
|
||||
Datum * datum,
|
||||
char *nulls,
|
||||
ItemPointer heap_t_ctid,
|
||||
Relation heapRel)
|
||||
{
|
||||
RegProcedure procedure;
|
||||
InsertIndexResult specificResult;
|
||||
|
||||
RELATION_CHECKS;
|
||||
GET_REL_PROCEDURE(insert,aminsert);
|
||||
|
||||
/* ----------------
|
||||
* have the am's insert proc do all the work.
|
||||
* ----------------
|
||||
*/
|
||||
specificResult = (InsertIndexResult)
|
||||
fmgr(procedure, relation, datum, nulls, heap_t_ctid, heapRel, NULL);
|
||||
|
||||
/* ----------------
|
||||
* the insert proc is supposed to return a "specific result" and
|
||||
* this routine has to return a "general result" so after we get
|
||||
* something back from the insert proc, we allocate a
|
||||
* "general result" and copy some crap between the two.
|
||||
*
|
||||
* As far as I'm concerned all this result shit is needlessly c
|
||||
* omplicated and should be eliminated. -cim 1/19/91
|
||||
*
|
||||
* mao concurs. regardless of how we feel here, however, it is
|
||||
* important to free memory we don't intend to return to anyone.
|
||||
* 2/28/91
|
||||
*
|
||||
* this "general result" crap is now gone. -ay 3/6/95
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
return (specificResult);
|
||||
RegProcedure procedure;
|
||||
InsertIndexResult specificResult;
|
||||
|
||||
RELATION_CHECKS;
|
||||
GET_REL_PROCEDURE(insert, aminsert);
|
||||
|
||||
/* ----------------
|
||||
* have the am's insert proc do all the work.
|
||||
* ----------------
|
||||
*/
|
||||
specificResult = (InsertIndexResult)
|
||||
fmgr(procedure, relation, datum, nulls, heap_t_ctid, heapRel, NULL);
|
||||
|
||||
/* ----------------
|
||||
* the insert proc is supposed to return a "specific result" and
|
||||
* this routine has to return a "general result" so after we get
|
||||
* something back from the insert proc, we allocate a
|
||||
* "general result" and copy some crap between the two.
|
||||
*
|
||||
* As far as I'm concerned all this result shit is needlessly c
|
||||
* omplicated and should be eliminated. -cim 1/19/91
|
||||
*
|
||||
* mao concurs. regardless of how we feel here, however, it is
|
||||
* important to free memory we don't intend to return to anyone.
|
||||
* 2/28/91
|
||||
*
|
||||
* this "general result" crap is now gone. -ay 3/6/95
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
return (specificResult);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_delete - delete an item from an index relation
|
||||
* index_delete - delete an item from an index relation
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
index_delete(Relation relation, ItemPointer indexItem)
|
||||
{
|
||||
RegProcedure procedure;
|
||||
|
||||
RELATION_CHECKS;
|
||||
GET_REL_PROCEDURE(delete,amdelete);
|
||||
|
||||
fmgr(procedure, relation, indexItem);
|
||||
RegProcedure procedure;
|
||||
|
||||
RELATION_CHECKS;
|
||||
GET_REL_PROCEDURE(delete, amdelete);
|
||||
|
||||
fmgr(procedure, relation, indexItem);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_beginscan - start a scan of an index
|
||||
* index_beginscan - start a scan of an index
|
||||
* ----------------
|
||||
*/
|
||||
IndexScanDesc
|
||||
index_beginscan(Relation relation,
|
||||
bool scanFromEnd,
|
||||
uint16 numberOfKeys,
|
||||
ScanKey key)
|
||||
bool scanFromEnd,
|
||||
uint16 numberOfKeys,
|
||||
ScanKey key)
|
||||
{
|
||||
IndexScanDesc scandesc;
|
||||
RegProcedure procedure;
|
||||
|
||||
RELATION_CHECKS;
|
||||
GET_REL_PROCEDURE(beginscan,ambeginscan);
|
||||
|
||||
RelationSetRIntentLock(relation);
|
||||
|
||||
scandesc = (IndexScanDesc)
|
||||
fmgr(procedure, relation, scanFromEnd, numberOfKeys, key);
|
||||
|
||||
return scandesc;
|
||||
IndexScanDesc scandesc;
|
||||
RegProcedure procedure;
|
||||
|
||||
RELATION_CHECKS;
|
||||
GET_REL_PROCEDURE(beginscan, ambeginscan);
|
||||
|
||||
RelationSetRIntentLock(relation);
|
||||
|
||||
scandesc = (IndexScanDesc)
|
||||
fmgr(procedure, relation, scanFromEnd, numberOfKeys, key);
|
||||
|
||||
return scandesc;
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_rescan - restart a scan of an index
|
||||
* index_rescan - restart a scan of an index
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
index_rescan(IndexScanDesc scan, bool scanFromEnd, ScanKey key)
|
||||
{
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(rescan,amrescan);
|
||||
|
||||
fmgr(procedure, scan, scanFromEnd, key);
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(rescan, amrescan);
|
||||
|
||||
fmgr(procedure, scan, scanFromEnd, key);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_endscan - end a scan
|
||||
* index_endscan - end a scan
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
index_endscan(IndexScanDesc scan)
|
||||
{
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(endscan,amendscan);
|
||||
|
||||
fmgr(procedure, scan);
|
||||
|
||||
RelationUnsetRIntentLock(scan->relation);
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(endscan, amendscan);
|
||||
|
||||
fmgr(procedure, scan);
|
||||
|
||||
RelationUnsetRIntentLock(scan->relation);
|
||||
}
|
||||
|
||||
#ifdef NOT_USED
|
||||
/* ----------------
|
||||
* index_markpos - mark a scan position
|
||||
* index_markpos - mark a scan position
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
index_markpos(IndexScanDesc scan)
|
||||
{
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(markpos,ammarkpos);
|
||||
|
||||
fmgr(procedure, scan);
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(markpos, ammarkpos);
|
||||
|
||||
fmgr(procedure, scan);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef NOT_USED
|
||||
/* ----------------
|
||||
* index_restrpos - restore a scan position
|
||||
* index_restrpos - restore a scan position
|
||||
* ----------------
|
||||
*/
|
||||
void
|
||||
index_restrpos(IndexScanDesc scan)
|
||||
{
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(restrpos,amrestrpos);
|
||||
|
||||
fmgr(procedure, scan);
|
||||
RegProcedure procedure;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(restrpos, amrestrpos);
|
||||
|
||||
fmgr(procedure, scan);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* ----------------
|
||||
* index_getnext - get the next tuple from a scan
|
||||
* index_getnext - get the next tuple from a scan
|
||||
*
|
||||
* A RetrieveIndexResult is a index tuple/heap tuple pair
|
||||
* A RetrieveIndexResult is a index tuple/heap tuple pair
|
||||
* ----------------
|
||||
*/
|
||||
RetrieveIndexResult
|
||||
index_getnext(IndexScanDesc scan,
|
||||
ScanDirection direction)
|
||||
ScanDirection direction)
|
||||
{
|
||||
RegProcedure procedure;
|
||||
RetrieveIndexResult result;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(getnext,amgettuple);
|
||||
|
||||
/* ----------------
|
||||
* have the am's gettuple proc do all the work.
|
||||
* ----------------
|
||||
*/
|
||||
result = (RetrieveIndexResult)
|
||||
fmgr(procedure, scan, direction);
|
||||
|
||||
return result;
|
||||
RegProcedure procedure;
|
||||
RetrieveIndexResult result;
|
||||
|
||||
SCAN_CHECKS;
|
||||
GET_SCAN_PROCEDURE(getnext, amgettuple);
|
||||
|
||||
/* ----------------
|
||||
* have the am's gettuple proc do all the work.
|
||||
* ----------------
|
||||
*/
|
||||
result = (RetrieveIndexResult)
|
||||
fmgr(procedure, scan, direction);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* index_getprocid
|
||||
* index_getprocid
|
||||
*
|
||||
* Some indexed access methods may require support routines that are
|
||||
* not in the operator class/operator model imposed by pg_am. These
|
||||
* access methods may store the OIDs of registered procedures they
|
||||
* need in pg_amproc. These registered procedure OIDs are ordered in
|
||||
* a way that makes sense to the access method, and used only by the
|
||||
* access method. The general index code doesn't know anything about
|
||||
* the routines involved; it just builds an ordered list of them for
|
||||
* each attribute on which an index is defined.
|
||||
* Some indexed access methods may require support routines that are
|
||||
* not in the operator class/operator model imposed by pg_am. These
|
||||
* access methods may store the OIDs of registered procedures they
|
||||
* need in pg_amproc. These registered procedure OIDs are ordered in
|
||||
* a way that makes sense to the access method, and used only by the
|
||||
* access method. The general index code doesn't know anything about
|
||||
* the routines involved; it just builds an ordered list of them for
|
||||
* each attribute on which an index is defined.
|
||||
*
|
||||
* This routine returns the requested procedure OID for a particular
|
||||
* indexed attribute.
|
||||
* This routine returns the requested procedure OID for a particular
|
||||
* indexed attribute.
|
||||
* ----------------
|
||||
*/
|
||||
RegProcedure
|
||||
index_getprocid(Relation irel,
|
||||
AttrNumber attnum,
|
||||
uint16 procnum)
|
||||
AttrNumber attnum,
|
||||
uint16 procnum)
|
||||
{
|
||||
RegProcedure *loc;
|
||||
int natts;
|
||||
|
||||
natts = irel->rd_rel->relnatts;
|
||||
|
||||
loc = irel->rd_support;
|
||||
RegProcedure *loc;
|
||||
int natts;
|
||||
|
||||
Assert(loc != NULL);
|
||||
|
||||
return (loc[(natts * (procnum - 1)) + (attnum - 1)]);
|
||||
natts = irel->rd_rel->relnatts;
|
||||
|
||||
loc = irel->rd_support;
|
||||
|
||||
Assert(loc != NULL);
|
||||
|
||||
return (loc[(natts * (procnum - 1)) + (attnum - 1)]);
|
||||
}
|
||||
|
||||
Datum
|
||||
GetIndexValue(HeapTuple tuple,
|
||||
TupleDesc hTupDesc,
|
||||
int attOff,
|
||||
AttrNumber attrNums[],
|
||||
FuncIndexInfo *fInfo,
|
||||
bool *attNull,
|
||||
Buffer buffer)
|
||||
TupleDesc hTupDesc,
|
||||
int attOff,
|
||||
AttrNumber attrNums[],
|
||||
FuncIndexInfo * fInfo,
|
||||
bool * attNull,
|
||||
Buffer buffer)
|
||||
{
|
||||
Datum returnVal;
|
||||
bool isNull;
|
||||
|
||||
if (PointerIsValid(fInfo) && FIgetProcOid(fInfo) != InvalidOid) {
|
||||
int i;
|
||||
Datum *attData = (Datum *)palloc(FIgetnArgs(fInfo)*sizeof(Datum));
|
||||
|
||||
for (i = 0; i < FIgetnArgs(fInfo); i++) {
|
||||
attData[i] = (Datum) heap_getattr(tuple,
|
||||
buffer,
|
||||
attrNums[i],
|
||||
hTupDesc,
|
||||
attNull);
|
||||
Datum returnVal;
|
||||
bool isNull;
|
||||
|
||||
if (PointerIsValid(fInfo) && FIgetProcOid(fInfo) != InvalidOid)
|
||||
{
|
||||
int i;
|
||||
Datum *attData = (Datum *) palloc(FIgetnArgs(fInfo) * sizeof(Datum));
|
||||
|
||||
for (i = 0; i < FIgetnArgs(fInfo); i++)
|
||||
{
|
||||
attData[i] = (Datum) heap_getattr(tuple,
|
||||
buffer,
|
||||
attrNums[i],
|
||||
hTupDesc,
|
||||
attNull);
|
||||
}
|
||||
returnVal = (Datum) fmgr_array_args(FIgetProcOid(fInfo),
|
||||
FIgetnArgs(fInfo),
|
||||
(char **) attData,
|
||||
&isNull);
|
||||
pfree(attData);
|
||||
*attNull = FALSE;
|
||||
}
|
||||
returnVal = (Datum)fmgr_array_args(FIgetProcOid(fInfo),
|
||||
FIgetnArgs(fInfo),
|
||||
(char **) attData,
|
||||
&isNull);
|
||||
pfree(attData);
|
||||
*attNull = FALSE;
|
||||
}else {
|
||||
returnVal = (Datum) heap_getattr(tuple, buffer, attrNums[attOff],
|
||||
hTupDesc, attNull);
|
||||
}
|
||||
return returnVal;
|
||||
else
|
||||
{
|
||||
returnVal = (Datum) heap_getattr(tuple, buffer, attrNums[attOff],
|
||||
hTupDesc, attNull);
|
||||
}
|
||||
return returnVal;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user