src/include/access/hash_xlog.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * hash_xlog.h
   4  *        header file for Postgres hash AM implementation
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2021, 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 {
  64         OffsetNumber offnum;
  65 } xl_hash_insert;
  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 {
  82         uint16          bmsize;
  83         bool            bmpage_found;
  84 } xl_hash_add_ovfl_page;
  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  */
  98 typedef struct xl_hash_split_allocate_page
  99 {
 100         uint32          new_bucket;
 101         uint16          old_bucket_flag;
 102         uint16          new_bucket_flag;
 103         uint8           flags;
 104 } xl_hash_split_allocate_page;
 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  */
 117 typedef struct xl_hash_split_complete
 118 {
 119         uint16          old_bucket_flag;
 120         uint16          new_bucket_flag;
 121 } xl_hash_split_complete;
 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  */
 136 typedef struct xl_hash_move_page_contents
 137 {
 138         uint16          ntups;
 139         bool            is_prim_bucket_same_wrt;        /* true if the page to which
 140                                                                                          * tuples are moved is same as
 141                                                                                          * primary bucket page */
 142 } xl_hash_move_page_contents;
 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 {
 161         BlockNumber prevblkno;
 162         BlockNumber nextblkno;
 163         uint16          ntups;
 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 */
 171 } xl_hash_squeeze_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 */
 190 } xl_hash_delete;
 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  */
 201 typedef struct xl_hash_update_meta_page
 202 {
 203         double          ntuples;
 204 } xl_hash_update_meta_page;
 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  */
 216 typedef struct xl_hash_init_meta_page
 217 {
 218         double          num_tuples;
 219         RegProcedure procid;
 220         uint16          ffactor;
 221 } xl_hash_init_meta_page;
 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  */
 234 typedef struct xl_hash_init_bitmap_page
 235 {
 236         uint16          bmsize;
 237 } xl_hash_init_bitmap_page;
 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  */
 251 typedef struct xl_hash_vacuum_one_page
 252 {
 253         TransactionId latestRemovedXid;
 254         int                     ntuples;
 255
 256         /* TARGET OFFSET NUMBERS FOLLOW AT THE END */
 257 } xl_hash_vacuum_one_page;
 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 */