PostgreSQL Source Code git master
hash_xlog.h
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * hash_xlog.h
4 * header file for Postgres hash AM implementation
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/hash_xlog.h
11 *
12 *-------------------------------------------------------------------------
13 */
14#ifndef HASH_XLOG_H
15#define HASH_XLOG_H
16
17#include "access/xlogreader.h"
18#include "lib/stringinfo.h"
19#include "storage/off.h"
20
21/* Number of buffers required for XLOG_HASH_SQUEEZE_PAGE operation */
22#define HASH_XLOG_FREE_OVFL_BUFS 6
23
24/*
25 * XLOG records for hash operations
26 */
27#define XLOG_HASH_INIT_META_PAGE 0x00 /* initialize the meta page */
28#define XLOG_HASH_INIT_BITMAP_PAGE 0x10 /* initialize the bitmap page */
29#define XLOG_HASH_INSERT 0x20 /* add index tuple without split */
30#define XLOG_HASH_ADD_OVFL_PAGE 0x30 /* add overflow page */
31#define XLOG_HASH_SPLIT_ALLOCATE_PAGE 0x40 /* allocate new page for split */
32#define XLOG_HASH_SPLIT_PAGE 0x50 /* split page */
33#define XLOG_HASH_SPLIT_COMPLETE 0x60 /* completion of split operation */
34#define XLOG_HASH_MOVE_PAGE_CONTENTS 0x70 /* remove tuples from one page
35 * and add to another page */
36#define XLOG_HASH_SQUEEZE_PAGE 0x80 /* add tuples to one of the previous
37 * pages in chain and free the ovfl
38 * page */
39#define XLOG_HASH_DELETE 0x90 /* delete index tuples from a page */
40#define XLOG_HASH_SPLIT_CLEANUP 0xA0 /* clear split-cleanup flag in primary
41 * bucket page after deleting tuples
42 * that are moved due to split */
43#define XLOG_HASH_UPDATE_META_PAGE 0xB0 /* update meta page after vacuum */
44
45#define XLOG_HASH_VACUUM_ONE_PAGE 0xC0 /* remove dead tuples from index
46 * page */
47
48/*
49 * xl_hash_split_allocate_page flag values, 8 bits are available.
50 */
51#define XLH_SPLIT_META_UPDATE_MASKS (1<<0)
52#define XLH_SPLIT_META_UPDATE_SPLITPOINT (1<<1)
53
54/*
55 * This is what we need to know about simple (without split) insert.
56 *
57 * This data record is used for XLOG_HASH_INSERT
58 *
59 * Backup Blk 0: original page (data contains the inserted tuple)
60 * Backup Blk 1: metapage (HashMetaPageData)
61 */
62typedef struct xl_hash_insert
63{
66
67#define SizeOfHashInsert (offsetof(xl_hash_insert, offnum) + sizeof(OffsetNumber))
68
69/*
70 * This is what we need to know about addition of overflow page.
71 *
72 * This data record is used for XLOG_HASH_ADD_OVFL_PAGE
73 *
74 * Backup Blk 0: newly allocated overflow page
75 * Backup Blk 1: page before new overflow page in the bucket chain
76 * Backup Blk 2: bitmap page
77 * Backup Blk 3: new bitmap page
78 * Backup Blk 4: metapage
79 */
81{
83 bool bmpage_found;
85
86#define SizeOfHashAddOvflPage \
87 (offsetof(xl_hash_add_ovfl_page, bmpage_found) + sizeof(bool))
88
89/*
90 * This is what we need to know about allocating a page for split.
91 *
92 * This data record is used for XLOG_HASH_SPLIT_ALLOCATE_PAGE
93 *
94 * Backup Blk 0: page for old bucket
95 * Backup Blk 1: page for new bucket
96 * Backup Blk 2: metapage
97 */
99{
103 uint8 flags;
105
106#define SizeOfHashSplitAllocPage \
107 (offsetof(xl_hash_split_allocate_page, flags) + sizeof(uint8))
108
109/*
110 * This is what we need to know about completing the split operation.
112 * This data record is used for XLOG_HASH_SPLIT_COMPLETE
114 * Backup Blk 0: page for old bucket
115 * Backup Blk 1: page for new bucket
116 */
118{
122
123#define SizeOfHashSplitComplete \
124 (offsetof(xl_hash_split_complete, new_bucket_flag) + sizeof(uint16))
125
126/*
127 * This is what we need to know about move page contents required during
128 * squeeze operation.
129 *
130 * This data record is used for XLOG_HASH_MOVE_PAGE_CONTENTS
131 *
132 * Backup Blk 0: bucket page
133 * Backup Blk 1: page containing moved tuples
134 * Backup Blk 2: page from which tuples will be removed
135 */
137{
139 bool is_prim_bucket_same_wrt; /* true if the page to which
140 * tuples are moved is same as
141 * primary bucket page */
143
144#define SizeOfHashMovePageContents \
145 (offsetof(xl_hash_move_page_contents, is_prim_bucket_same_wrt) + sizeof(bool))
146
147/*
148 * This is what we need to know about the squeeze page operation.
149 *
150 * This data record is used for XLOG_HASH_SQUEEZE_PAGE
151 *
152 * Backup Blk 0: page containing tuples moved from freed overflow page
153 * Backup Blk 1: freed overflow page
154 * Backup Blk 2: page previous to the freed overflow page
155 * Backup Blk 3: page next to the freed overflow page
156 * Backup Blk 4: bitmap page containing info of freed overflow page
157 * Backup Blk 5: meta page
158 */
159typedef struct xl_hash_squeeze_page
160{
164 bool is_prim_bucket_same_wrt; /* true if the page to which
165 * tuples are moved is same as
166 * primary bucket page */
167 bool is_prev_bucket_same_wrt; /* true if the page to which
168 * tuples are moved is the page
169 * previous to the freed overflow
170 * page */
172
173#define SizeOfHashSqueezePage \
174 (offsetof(xl_hash_squeeze_page, is_prev_bucket_same_wrt) + sizeof(bool))
175
176/*
177 * This is what we need to know about the deletion of index tuples from a page.
179 * This data record is used for XLOG_HASH_DELETE
181 * Backup Blk 0: primary bucket page
182 * Backup Blk 1: page from which tuples are deleted
183 */
184typedef struct xl_hash_delete
185{
186 bool clear_dead_marking; /* true if this operation clears
187 * LH_PAGE_HAS_DEAD_TUPLES flag */
188 bool is_primary_bucket_page; /* true if the operation is for
189 * primary bucket page */
191
192#define SizeOfHashDelete (offsetof(xl_hash_delete, is_primary_bucket_page) + sizeof(bool))
193
194/*
195 * This is what we need for metapage update operation.
196 *
197 * This data record is used for XLOG_HASH_UPDATE_META_PAGE
199 * Backup Blk 0: meta page
200 */
201typedef struct xl_hash_update_meta_page
202{
203 double ntuples;
205
206#define SizeOfHashUpdateMetaPage \
207 (offsetof(xl_hash_update_meta_page, ntuples) + sizeof(double))
208
209/*
210 * This is what we need to initialize metapage.
211 *
212 * This data record is used for XLOG_HASH_INIT_META_PAGE
214 * Backup Blk 0: meta page
215 */
216typedef struct xl_hash_init_meta_page
218 double num_tuples;
222
223#define SizeOfHashInitMetaPage \
224 (offsetof(xl_hash_init_meta_page, ffactor) + sizeof(uint16))
225
226/*
227 * This is what we need to initialize bitmap page.
229 * This data record is used for XLOG_HASH_INIT_BITMAP_PAGE
231 * Backup Blk 0: bitmap page
232 * Backup Blk 1: meta page
233 */
234typedef struct xl_hash_init_bitmap_page
235{
238
239#define SizeOfHashInitBitmapPage \
240 (offsetof(xl_hash_init_bitmap_page, bmsize) + sizeof(uint16))
241
242/*
243 * This is what we need for index tuple deletion and to
244 * update the meta page.
246 * This data record is used for XLOG_HASH_VACUUM_ONE_PAGE
248 * Backup Blk 0: bucket page
249 * Backup Blk 1: meta page
250 */
251typedef struct xl_hash_vacuum_one_page
252{
255 bool isCatalogRel; /* to handle recovery conflict during logical
256 * decoding on standby */
257
258 /* TARGET OFFSET NUMBERS */
261
262#define SizeOfHashVacuumOnePage offsetof(xl_hash_vacuum_one_page, offsets)
263
264extern void hash_redo(XLogReaderState *record);
265extern void hash_desc(StringInfo buf, XLogReaderState *record);
266extern const char *hash_identify(uint8 info);
267extern void hash_mask(char *pagedata, BlockNumber blkno);
268
269#endif /* HASH_XLOG_H */
uint32 BlockNumber
Definition: block.h:31
uint8_t uint8
Definition: c.h:486
#define FLEXIBLE_ARRAY_MEMBER
Definition: c.h:420
regproc RegProcedure
Definition: c.h:607
uint16_t uint16
Definition: c.h:487
uint32_t uint32
Definition: c.h:488
uint32 TransactionId
Definition: c.h:609
struct xl_hash_vacuum_one_page xl_hash_vacuum_one_page
struct xl_hash_init_bitmap_page xl_hash_init_bitmap_page
struct xl_hash_delete xl_hash_delete
struct xl_hash_move_page_contents xl_hash_move_page_contents
struct xl_hash_split_complete xl_hash_split_complete
struct xl_hash_squeeze_page xl_hash_squeeze_page
struct xl_hash_init_meta_page xl_hash_init_meta_page
void hash_mask(char *pagedata, BlockNumber blkno)
Definition: hash_xlog.c:1121
struct xl_hash_update_meta_page xl_hash_update_meta_page
struct xl_hash_insert xl_hash_insert
const char * hash_identify(uint8 info)
Definition: hashdesc.c:126
struct xl_hash_add_ovfl_page xl_hash_add_ovfl_page
void hash_desc(StringInfo buf, XLogReaderState *record)
Definition: hashdesc.c:20
struct xl_hash_split_allocate_page xl_hash_split_allocate_page
void hash_redo(XLogReaderState *record)
Definition: hash_xlog.c:1067
uint16 OffsetNumber
Definition: off.h:24
static char * buf
Definition: pg_test_fsync.c:72
bool clear_dead_marking
Definition: hash_xlog.h:180
bool is_primary_bucket_page
Definition: hash_xlog.h:182
RegProcedure procid
Definition: hash_xlog.h:213
OffsetNumber offnum
Definition: hash_xlog.h:58
BlockNumber prevblkno
Definition: hash_xlog.h:155
bool is_prim_bucket_same_wrt
Definition: hash_xlog.h:158
bool is_prev_bucket_same_wrt
Definition: hash_xlog.h:161
BlockNumber nextblkno
Definition: hash_xlog.h:156
TransactionId snapshotConflictHorizon
Definition: hash_xlog.h:247
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER]
Definition: hash_xlog.h:253