| /*------------------------------------------------------------------------- |
| * |
| * itup.h |
| * POSTGRES index tuple definitions. |
| * |
| * |
| * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group |
| * Portions Copyright (c) 1994, Regents of the University of California |
| * |
| * $PostgreSQL: pgsql/src/include/access/itup.h,v 1.47 2006/07/13 16:49:19 momjian Exp $ |
| * |
| *------------------------------------------------------------------------- |
| */ |
| #ifndef ITUP_H |
| #define ITUP_H |
| |
| #include "access/tupdesc.h" |
| #include "access/tupmacs.h" |
| #include "storage/bufpage.h" |
| #include "storage/itemptr.h" |
| |
| /* |
| * Index tuple header structure |
| * |
| * All index tuples start with IndexTupleData. If the HasNulls bit is set, |
| * this is followed by an IndexAttributeBitMapData. The index attribute |
| * values follow, beginning at a MAXALIGN boundary. |
| * |
| * Note that the space allocated for the bitmap does not vary with the number |
| * of attributes; that is because we don't have room to store the number of |
| * attributes in the header. Given the MAXALIGN constraint there's no space |
| * savings to be had anyway, for usual values of INDEX_MAX_KEYS. |
| */ |
| |
| typedef struct IndexTupleData |
| { |
| ItemPointerData t_tid; /* reference TID to heap tuple */ |
| |
| /* --------------- |
| * t_info is layed out in the following fashion: |
| * |
| * 15th (high) bit: has nulls |
| * 14th bit: has var-width attributes |
| * 13th bit: unused |
| * 12-0 bit: size of tuple |
| * --------------- |
| */ |
| |
| unsigned short t_info; /* various info about tuple */ |
| |
| } IndexTupleData; /* MORE DATA FOLLOWS AT END OF STRUCT */ |
| |
| typedef IndexTupleData *IndexTuple; |
| |
| typedef struct IndexAttributeBitMapData |
| { |
| bits8 bits[(INDEX_MAX_KEYS + 8 - 1) / 8]; |
| } IndexAttributeBitMapData; |
| |
| typedef IndexAttributeBitMapData *IndexAttributeBitMap; |
| |
| /* |
| * t_info manipulation macros |
| */ |
| #define INDEX_SIZE_MASK 0x1FFF |
| /* bit 0x2000 is not used at present */ |
| #define INDEX_VAR_MASK 0x4000 |
| #define INDEX_NULL_MASK 0x8000 |
| |
| #define IndexTupleSize(itup) ((Size) (((IndexTuple) (itup))->t_info & INDEX_SIZE_MASK)) |
| #define IndexTupleDSize(itup) ((Size) ((itup).t_info & INDEX_SIZE_MASK)) |
| #define IndexTupleHasNulls(itup) ((((IndexTuple) (itup))->t_info & INDEX_NULL_MASK)) |
| #define IndexTupleHasVarwidths(itup) ((((IndexTuple) (itup))->t_info & INDEX_VAR_MASK)) |
| |
| |
| /* |
| * Takes an infomask as argument (primarily because this needs to be usable |
| * at index_form_tuple time so enough space is allocated). |
| */ |
| #define IndexInfoFindDataOffset(t_info) \ |
| ( \ |
| (!((t_info) & INDEX_NULL_MASK)) ? \ |
| ( \ |
| (Size)MAXALIGN(sizeof(IndexTupleData)) \ |
| ) \ |
| : \ |
| ( \ |
| (Size)MAXALIGN(sizeof(IndexTupleData) + sizeof(IndexAttributeBitMapData)) \ |
| ) \ |
| ) |
| |
| /* ---------------- |
| * index_getattr |
| * |
| * This gets called many times, so we macro the cacheable and NULL |
| * lookups, and call nocache_index_getattr() for the rest. |
| * |
| * ---------------- |
| */ |
| #define index_getattr(tup, attnum, tupleDesc, isnull) \ |
| ( \ |
| AssertMacro(PointerIsValid(isnull) && (attnum) > 0), \ |
| *(isnull) = false, \ |
| !IndexTupleHasNulls(tup) ? \ |
| ( \ |
| (tupleDesc)->attrs[(attnum)-1]->attcacheoff >= 0 ? \ |
| ( \ |
| fetchatt((tupleDesc)->attrs[(attnum)-1], \ |
| (char *) (tup) + IndexInfoFindDataOffset((tup)->t_info) \ |
| + (tupleDesc)->attrs[(attnum)-1]->attcacheoff) \ |
| ) \ |
| : \ |
| nocache_index_getattr((tup), (attnum), (tupleDesc), (isnull)) \ |
| ) \ |
| : \ |
| ( \ |
| (att_isnull((attnum)-1, (char *)(tup) + sizeof(IndexTupleData))) ? \ |
| ( \ |
| *(isnull) = true, \ |
| (Datum)0 \ |
| ) \ |
| : \ |
| ( \ |
| nocache_index_getattr((tup), (attnum), (tupleDesc), (isnull)) \ |
| ) \ |
| ) \ |
| ) |
| |
| /* |
| * MaxIndexTuplesPerPage is an upper bound on the number of tuples that can |
| * fit on one index page. An index tuple must have either data or a null |
| * bitmap, so we can safely assume it's at least 1 byte bigger than a bare |
| * IndexTupleData struct. We arrive at the divisor because each tuple |
| * must be maxaligned, and it must have an associated item pointer. |
| */ |
| #define MaxIndexTuplesPerPage \ |
| ((int) ((BLCKSZ - offsetof(PageHeaderData, pd_linp)) / \ |
| (MAXALIGN(sizeof(IndexTupleData) + 1) + sizeof(ItemIdData)))) |
| |
| |
| /* routines in indextuple.c */ |
| extern IndexTuple index_form_tuple(TupleDesc tupleDescriptor, |
| Datum *values, bool *isnull); |
| extern Datum nocache_index_getattr(IndexTuple tup, int attnum, |
| TupleDesc tupleDesc, bool *isnull); |
| extern IndexTuple CopyIndexTuple(IndexTuple source); |
| |
| #endif /* ITUP_H */ |