174 lines
6.9 KiB
C
174 lines
6.9 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* skey.h
|
|
* POSTGRES scan key definitions.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* src/include/access/skey.h
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef SKEY_H
|
|
#define SKEY_H
|
|
|
|
#include "access/attnum.h"
|
|
#include "fmgr.h"
|
|
|
|
|
|
/*
|
|
* Strategy numbers identify the semantics that particular operators have
|
|
* with respect to particular operator classes. In some cases a strategy
|
|
* subtype (an OID) is used as further information.
|
|
*/
|
|
typedef uint16 StrategyNumber;
|
|
|
|
#define InvalidStrategy ((StrategyNumber) 0)
|
|
|
|
/*
|
|
* We define the strategy numbers for B-tree indexes here, to avoid having
|
|
* to import access/nbtree.h into a lot of places that shouldn't need it.
|
|
*/
|
|
#define BTLessStrategyNumber 1
|
|
#define BTLessEqualStrategyNumber 2
|
|
#define BTEqualStrategyNumber 3
|
|
#define BTGreaterEqualStrategyNumber 4
|
|
#define BTGreaterStrategyNumber 5
|
|
|
|
#define BTMaxStrategyNumber 5
|
|
|
|
|
|
/*
|
|
* A ScanKey represents the application of a comparison operator between
|
|
* a table or index column and a constant. When it's part of an array of
|
|
* ScanKeys, the comparison conditions are implicitly ANDed. The index
|
|
* column is the left argument of the operator, if it's a binary operator.
|
|
* (The data structure can support unary indexable operators too; in that
|
|
* case sk_argument would go unused. This is not currently implemented.)
|
|
*
|
|
* For an index scan, sk_strategy and sk_subtype must be set correctly for
|
|
* the operator. When using a ScanKey in a heap scan, these fields are not
|
|
* used and may be set to InvalidStrategy/InvalidOid.
|
|
*
|
|
* If the operator is collation-sensitive, sk_collation must be set
|
|
* correctly as well.
|
|
*
|
|
* A ScanKey can also represent a ScalarArrayOpExpr, that is a condition
|
|
* "column op ANY(ARRAY[...])". This is signaled by the SK_SEARCHARRAY
|
|
* flag bit. The sk_argument is not a value of the operator's right-hand
|
|
* argument type, but rather an array of such values, and the per-element
|
|
* comparisons are to be ORed together.
|
|
*
|
|
* A ScanKey can also represent a condition "column IS NULL" or "column
|
|
* IS NOT NULL"; these cases are signaled by the SK_SEARCHNULL and
|
|
* SK_SEARCHNOTNULL flag bits respectively. The argument is always NULL,
|
|
* and the sk_strategy, sk_subtype, sk_collation, and sk_func fields are
|
|
* not used (unless set by the index AM).
|
|
*
|
|
* SK_SEARCHARRAY, SK_SEARCHNULL and SK_SEARCHNOTNULL are supported only
|
|
* for index scans, not heap scans; and not all index AMs support them,
|
|
* only those that set amsearcharray or amsearchnulls respectively.
|
|
*
|
|
* A ScanKey can also represent an ordering operator invocation, that is
|
|
* an ordering requirement "ORDER BY indexedcol op constant". This looks
|
|
* the same as a comparison operator, except that the operator doesn't
|
|
* (usually) yield boolean. We mark such ScanKeys with SK_ORDER_BY.
|
|
* SK_SEARCHARRAY, SK_SEARCHNULL, SK_SEARCHNOTNULL cannot be used here.
|
|
*
|
|
* Note: in some places, ScanKeys are used as a convenient representation
|
|
* for the invocation of an access method support procedure. In this case
|
|
* sk_strategy/sk_subtype are not meaningful (but sk_collation can be); and
|
|
* sk_func may refer to a function that returns something other than boolean.
|
|
*/
|
|
typedef struct ScanKeyData
|
|
{
|
|
int sk_flags; /* flags, see below */
|
|
AttrNumber sk_attno; /* table or index column number */
|
|
StrategyNumber sk_strategy; /* operator strategy number */
|
|
Oid sk_subtype; /* strategy subtype */
|
|
Oid sk_collation; /* collation to use, if needed */
|
|
FmgrInfo sk_func; /* lookup info for function to call */
|
|
Datum sk_argument; /* data to compare */
|
|
} ScanKeyData;
|
|
|
|
typedef ScanKeyData *ScanKey;
|
|
|
|
/*
|
|
* About row comparisons:
|
|
*
|
|
* The ScanKey data structure also supports row comparisons, that is ordered
|
|
* tuple comparisons like (x, y) > (c1, c2), having the SQL-spec semantics
|
|
* "x > c1 OR (x = c1 AND y > c2)". Note that this is currently only
|
|
* implemented for btree index searches, not for heapscans or any other index
|
|
* type. A row comparison is represented by a "header" ScanKey entry plus
|
|
* a separate array of ScanKeys, one for each column of the row comparison.
|
|
* The header entry has these properties:
|
|
* sk_flags = SK_ROW_HEADER
|
|
* sk_attno = index column number for leading column of row comparison
|
|
* sk_strategy = btree strategy code for semantics of row comparison
|
|
* (ie, < <= > or >=)
|
|
* sk_subtype, sk_collation, sk_func: not used
|
|
* sk_argument: pointer to subsidiary ScanKey array
|
|
* If the header is part of a ScanKey array that's sorted by attno, it
|
|
* must be sorted according to the leading column number.
|
|
*
|
|
* The subsidiary ScanKey array appears in logical column order of the row
|
|
* comparison, which may be different from index column order. The array
|
|
* elements are like a normal ScanKey array except that:
|
|
* sk_flags must include SK_ROW_MEMBER, plus SK_ROW_END in the last
|
|
* element (needed since row header does not include a count)
|
|
* sk_func points to the btree comparison support function for the
|
|
* opclass, NOT the operator's implementation function.
|
|
* sk_strategy must be the same in all elements of the subsidiary array,
|
|
* that is, the same as in the header entry.
|
|
* SK_SEARCHARRAY, SK_SEARCHNULL, SK_SEARCHNOTNULL cannot be used here.
|
|
*/
|
|
|
|
/*
|
|
* ScanKeyData sk_flags
|
|
*
|
|
* sk_flags bits 0-15 are reserved for system-wide use (symbols for those
|
|
* bits should be defined here). Bits 16-31 are reserved for use within
|
|
* individual index access methods.
|
|
*/
|
|
#define SK_ISNULL 0x0001 /* sk_argument is NULL */
|
|
#define SK_UNARY 0x0002 /* unary operator (not supported!) */
|
|
#define SK_ROW_HEADER 0x0004 /* row comparison header (see above) */
|
|
#define SK_ROW_MEMBER 0x0008 /* row comparison member (see above) */
|
|
#define SK_ROW_END 0x0010 /* last row comparison member */
|
|
#define SK_SEARCHARRAY 0x0020 /* scankey represents ScalarArrayOp */
|
|
#define SK_SEARCHNULL 0x0040 /* scankey represents "col IS NULL" */
|
|
#define SK_SEARCHNOTNULL 0x0080 /* scankey represents "col IS NOT
|
|
* NULL" */
|
|
#define SK_ORDER_BY 0x0100 /* scankey is for ORDER BY op */
|
|
|
|
|
|
/*
|
|
* prototypes for functions in access/common/scankey.c
|
|
*/
|
|
extern void ScanKeyInit(ScanKey entry,
|
|
AttrNumber attributeNumber,
|
|
StrategyNumber strategy,
|
|
RegProcedure procedure,
|
|
Datum argument);
|
|
extern void ScanKeyEntryInitialize(ScanKey entry,
|
|
int flags,
|
|
AttrNumber attributeNumber,
|
|
StrategyNumber strategy,
|
|
Oid subtype,
|
|
Oid collation,
|
|
RegProcedure procedure,
|
|
Datum argument);
|
|
extern void ScanKeyEntryInitializeWithInfo(ScanKey entry,
|
|
int flags,
|
|
AttrNumber attributeNumber,
|
|
StrategyNumber strategy,
|
|
Oid subtype,
|
|
Oid collation,
|
|
FmgrInfo *finfo,
|
|
Datum argument);
|
|
|
|
#endif /* SKEY_H */
|