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-2019, 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  */
62 typedef 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  */
80 typedef struct xl_hash_add_ovfl_page
81 {
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 {
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.
111  *
112  * This data record is used for XLOG_HASH_SPLIT_COMPLETE
113  *
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  */
159 typedef 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.
178  *
179  * This data record is used for XLOG_HASH_DELETE
180  *
181  * Backup Blk 0: primary bucket page
182  * Backup Blk 1: page from which tuples are deleted
183  */
184 typedef 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
198  *
199  * Backup Blk 0: meta page
200  */
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
213  *
214  * Backup Blk 0: meta page
215  */
217 {
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.
228  *
229  * This data record is used for XLOG_HASH_INIT_BITMAP_PAGE
230  *
231  * Backup Blk 0: bitmap page
232  * Backup Blk 1: meta page
233  */
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.
245  *
246  * This data record is used for XLOG_HASH_VACUUM_ONE_PAGE
247  *
248  * Backup Blk 0: bucket page
249  * Backup Blk 1: meta page
250  */
252 {
254  int ntuples;
255 
256  /* TARGET OFFSET NUMBERS FOLLOW AT THE END */
258 
259 #define SizeOfHashVacuumOnePage \
260  (offsetof(xl_hash_vacuum_one_page, ntuples) + sizeof(int))
261 
262 extern void hash_redo(XLogReaderState *record);
263 extern void hash_desc(StringInfo buf, XLogReaderState *record);
264 extern const char *hash_identify(uint8 info);
265 extern void hash_mask(char *pagedata, BlockNumber blkno);
266 
267 #endif /* HASH_XLOG_H */
struct xl_hash_init_meta_page xl_hash_init_meta_page
struct xl_hash_delete xl_hash_delete
uint32 TransactionId
Definition: c.h:507
struct xl_hash_add_ovfl_page xl_hash_add_ovfl_page
regproc RegProcedure
Definition: c.h:505
unsigned char uint8
Definition: c.h:356
bool clear_dead_marking
Definition: hash_xlog.h:186
uint32 BlockNumber
Definition: block.h:31
struct xl_hash_move_page_contents xl_hash_move_page_contents
BlockNumber prevblkno
Definition: hash_xlog.h:161
bool is_prim_bucket_same_wrt
Definition: hash_xlog.h:164
uint16 OffsetNumber
Definition: off.h:24
unsigned short uint16
Definition: c.h:357
BlockNumber nextblkno
Definition: hash_xlog.h:162
bool is_primary_bucket_page
Definition: hash_xlog.h:188
void hash_mask(char *pagedata, BlockNumber blkno)
Definition: hash_xlog.c:1108
static char * buf
Definition: pg_test_fsync.c:68
unsigned int uint32
Definition: c.h:358
void hash_desc(StringInfo buf, XLogReaderState *record)
Definition: hashdesc.c:20
void hash_redo(XLogReaderState *record)
Definition: hash_xlog.c:1054
struct xl_hash_insert xl_hash_insert
struct xl_hash_init_bitmap_page xl_hash_init_bitmap_page
struct xl_hash_vacuum_one_page xl_hash_vacuum_one_page
struct xl_hash_split_complete xl_hash_split_complete
struct xl_hash_split_allocate_page xl_hash_split_allocate_page
TransactionId latestRemovedXid
Definition: hash_xlog.h:253
bool is_prev_bucket_same_wrt
Definition: hash_xlog.h:167
OffsetNumber offnum
Definition: hash_xlog.h:64
struct xl_hash_update_meta_page xl_hash_update_meta_page
RegProcedure procid
Definition: hash_xlog.h:219
struct xl_hash_squeeze_page xl_hash_squeeze_page
const char * hash_identify(uint8 info)
Definition: hashdesc.c:125