PostgreSQL Source Code: src/include/access/itup.h Source File

PostgreSQL Source Code git master
itup.h
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * itup.h
4 * POSTGRES index tuple definitions.
5 *
6 *
7 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 * src/include/access/itup.h
11 *
12 *-------------------------------------------------------------------------
13 */
14#ifndef ITUP_H
15#define ITUP_H
16
17#include "access/tupdesc.h"
18#include "access/tupmacs.h"
19#include "storage/bufpage.h"
20#include "storage/itemptr.h"
21
22/*
23 * Index tuple header structure
24 *
25 * All index tuples start with IndexTupleData. If the HasNulls bit is set,
26 * this is followed by an IndexAttributeBitMapData. The index attribute
27 * values follow, beginning at a MAXALIGN boundary.
28 *
29 * Note that the space allocated for the bitmap does not vary with the number
30 * of attributes; that is because we don't have room to store the number of
31 * attributes in the header. Given the MAXALIGN constraint there's no space
32 * savings to be had anyway, for usual values of INDEX_MAX_KEYS.
33 */
34
35 typedef struct IndexTupleData
36{
37 ItemPointerData t_tid; /* reference TID to heap tuple */
38
39 /* ---------------
40 * t_info is laid out in the following fashion:
41 *
42 * 15th (high) bit: has nulls
43 * 14th bit: has var-width attributes
44 * 13th bit: AM-defined meaning
45 * 12-0 bit: size of tuple
46 * ---------------
47 */
48
49 unsigned short t_info; /* various info about tuple */
50
51 } IndexTupleData; /* MORE DATA FOLLOWS AT END OF STRUCT */
52
53 typedef IndexTupleData *IndexTuple;
54
55 typedef struct IndexAttributeBitMapData
56{
57 bits8 bits[(INDEX_MAX_KEYS + 8 - 1) / 8];
58 } IndexAttributeBitMapData;
59
60 typedef IndexAttributeBitMapData * IndexAttributeBitMap;
61
62/*
63 * t_info manipulation macros
64 */
65 #define INDEX_SIZE_MASK 0x1FFF
66 #define INDEX_AM_RESERVED_BIT 0x2000 /* reserved for index-AM specific
67 * usage */
68 #define INDEX_VAR_MASK 0x4000
69#define INDEX_NULL_MASK 0x8000
70
71 static inline Size
72IndexTupleSize(const IndexTupleData *itup)
73{
74 return (itup->t_info & INDEX_SIZE_MASK);
75}
76
77 static inline bool
78IndexTupleHasNulls(const IndexTupleData *itup)
79{
80 return itup->t_info & INDEX_NULL_MASK;
81}
82
83 static inline bool
84IndexTupleHasVarwidths(const IndexTupleData *itup)
85{
86 return itup->t_info & INDEX_VAR_MASK;
87}
88
89
90/* routines in indextuple.c */
91extern IndexTuple index_form_tuple(TupleDesc tupleDescriptor,
92 const Datum *values, const bool *isnull);
93extern IndexTuple index_form_tuple_context(TupleDesc tupleDescriptor,
94 const Datum *values, const bool *isnull,
95 MemoryContext context);
96extern Datum nocache_index_getattr(IndexTuple tup, int attnum,
97 TupleDesc tupleDesc);
98extern void index_deform_tuple(IndexTuple tup, TupleDesc tupleDescriptor,
99 Datum *values, bool *isnull);
100extern void index_deform_tuple_internal(TupleDesc tupleDescriptor,
101 Datum *values, bool *isnull,
102 char *tp, bits8 *bp, int hasnulls);
103extern IndexTuple CopyIndexTuple(IndexTuple source);
104extern IndexTuple index_truncate_tuple(TupleDesc sourceDescriptor,
105 IndexTuple source, int leavenatts);
106
107
108/*
109 * Takes an infomask as argument (primarily because this needs to be usable
110 * at index_form_tuple time so enough space is allocated).
111 */
112 static inline Size
113IndexInfoFindDataOffset(unsigned short t_info)
114{
115 if (!(t_info & INDEX_NULL_MASK))
116 return MAXALIGN(sizeof(IndexTupleData));
117 else
118 return MAXALIGN(sizeof(IndexTupleData) + sizeof(IndexAttributeBitMapData));
119}
120
121#ifndef FRONTEND
122
123/* ----------------
124 * index_getattr
125 *
126 * This gets called many times, so we macro the cacheable and NULL
127 * lookups, and call nocache_index_getattr() for the rest.
128 *
129 * ----------------
130 */
131 static inline Datum
132index_getattr(IndexTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
133{
134 Assert(isnull);
135 Assert(attnum > 0);
136
137 *isnull = false;
138
139 if (!IndexTupleHasNulls(tup))
140 {
141 CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, attnum - 1);
142
143 if (attr->attcacheoff >= 0)
144 {
145 return fetchatt(attr,
146 (char *) tup + IndexInfoFindDataOffset(tup->t_info) +
147 attr->attcacheoff);
148 }
149 else
150 return nocache_index_getattr(tup, attnum, tupleDesc);
151 }
152 else
153 {
154 if (att_isnull(attnum - 1, (bits8 *) tup + sizeof(IndexTupleData)))
155 {
156 *isnull = true;
157 return (Datum) 0;
158 }
159 else
160 return nocache_index_getattr(tup, attnum, tupleDesc);
161 }
162}
163
164#endif
165
166/*
167 * MaxIndexTuplesPerPage is an upper bound on the number of tuples that can
168 * fit on one index page. An index tuple must have either data or a null
169 * bitmap, so we can safely assume it's at least 1 byte bigger than a bare
170 * IndexTupleData struct. We arrive at the divisor because each tuple
171 * must be maxaligned, and it must have an associated line pointer.
172 *
173 * To be index-type-independent, this does not account for any special space
174 * on the page, and is thus conservative.
175 *
176 * Note: in btree non-leaf pages, the first tuple has no key (it's implicitly
177 * minus infinity), thus breaking the "at least 1 byte bigger" assumption.
178 * On such a page, N tuples could take one MAXALIGN quantum less space than
179 * estimated here, seemingly allowing one more tuple than estimated here.
180 * But such a page always has at least MAXALIGN special space, so we're safe.
181 */
182#define MaxIndexTuplesPerPage \
183 ((int) ((BLCKSZ - SizeOfPageHeaderData) / \
184 (MAXALIGN(sizeof(IndexTupleData) + 1) + sizeof(ItemIdData))))
185
186#endif /* ITUP_H */
static Datum values[MAXATTR]
Definition: bootstrap.c:153
#define MAXALIGN(LEN)
Definition: c.h:810
uint8 bits8
Definition: c.h:545
size_t Size
Definition: c.h:610
Assert(PointerIsAligned(start, uint64))
#define INDEX_VAR_MASK
Definition: itup.h:67
void index_deform_tuple(IndexTuple tup, TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: indextuple.c:456
IndexTuple index_truncate_tuple(TupleDesc sourceDescriptor, IndexTuple source, int leavenatts)
Definition: indextuple.c:576
#define INDEX_NULL_MASK
Definition: itup.h:68
struct IndexAttributeBitMapData IndexAttributeBitMapData
static bool IndexTupleHasVarwidths(const IndexTupleData *itup)
Definition: itup.h:83
IndexTupleData * IndexTuple
Definition: itup.h:53
IndexTuple CopyIndexTuple(IndexTuple source)
Definition: indextuple.c:547
static bool IndexTupleHasNulls(const IndexTupleData *itup)
Definition: itup.h:77
static Datum index_getattr(IndexTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: itup.h:131
IndexAttributeBitMapData * IndexAttributeBitMap
Definition: itup.h:60
void index_deform_tuple_internal(TupleDesc tupleDescriptor, Datum *values, bool *isnull, char *tp, bits8 *bp, int hasnulls)
Definition: indextuple.c:479
IndexTuple index_form_tuple_context(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull, MemoryContext context)
Definition: indextuple.c:65
struct IndexTupleData IndexTupleData
static Size IndexTupleSize(const IndexTupleData *itup)
Definition: itup.h:71
Datum nocache_index_getattr(IndexTuple tup, int attnum, TupleDesc tupleDesc)
Definition: indextuple.c:241
IndexTuple index_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: indextuple.c:44
static Size IndexInfoFindDataOffset(unsigned short t_info)
Definition: itup.h:112
#define INDEX_SIZE_MASK
Definition: itup.h:65
int16 attnum
Definition: pg_attribute.h:74
#define INDEX_MAX_KEYS
static rewind_source * source
Definition: pg_rewind.c:89
uint64_t Datum
Definition: postgres.h:70
int32 attcacheoff
Definition: tupdesc.h:70
bits8 bits[(INDEX_MAX_KEYS+8 - 1)/8]
Definition: itup.h:57
ItemPointerData t_tid
Definition: itup.h:37
unsigned short t_info
Definition: itup.h:49
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:175
static bool att_isnull(int ATT, const bits8 *BITS)
Definition: tupmacs.h:26
#define fetchatt(A, T)
Definition: tupmacs.h:44

AltStyle によって変換されたページ (->オリジナル) /