MySQL  8.0.18
Source Code Documentation
page0zip.h
Go to the documentation of this file.
1 /*****************************************************************************
2 
3 Copyright (c) 2005, 2018, Oracle and/or its affiliates. All Rights Reserved.
4 Copyright (c) 2012, Facebook Inc.
5 
6 This program is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License, version 2.0, as published by the
8 Free Software Foundation.
9 
10 This program is also distributed with certain software (including but not
11 limited to OpenSSL) that is licensed under separate terms, as designated in a
12 particular file or component or in included license documentation. The authors
13 of MySQL hereby grant you an additional permission to link the program and
14 your derivative works with the separately licensed software that they have
15 included with MySQL.
16 
17 This program is distributed in the hope that it will be useful, but WITHOUT
18 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19 FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
20 for more details.
21 
22 You should have received a copy of the GNU General Public License along with
23 this program; if not, write to the Free Software Foundation, Inc.,
24 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 
26 *****************************************************************************/
27 
28 /** @file include/page0zip.h
29  Compressed page interface
30 
31  Created June 2005 by Marko Makela
32  *******************************************************/
33 
34 #ifndef page0zip_h
35 #define page0zip_h
36 
37 #ifdef UNIV_MATERIALIZE
38 #undef UNIV_INLINE
39 #define UNIV_INLINE
40 #endif
41 
42 #include <sys/types.h>
43 #include <zlib.h>
44 
45 #include "buf0buf.h"
46 #include "buf0checksum.h"
47 #include "buf0types.h"
48 #include "dict0types.h"
49 #include "mach0data.h"
50 #include "mem0mem.h"
51 #include "mtr0types.h"
52 #include "page/zipdecompress.h"
53 #include "page0types.h"
54 #include "srv0srv.h"
55 #include "trx0types.h"
56 #include "univ.i"
57 #include "ut0crc32.h"
58 
59 /* Compression level to be used by zlib. Settable by user. */
60 extern uint page_zip_level;
61 
62 /* Default compression level. */
63 #define DEFAULT_COMPRESSION_LEVEL 6
64 /** Start offset of the area that will be compressed */
65 #define PAGE_ZIP_START PAGE_NEW_SUPREMUM_END
66 /** Size of an compressed page directory entry */
67 #define PAGE_ZIP_DIR_SLOT_SIZE 2
68 /** Predefine the sum of DIR_SLOT, TRX_ID & ROLL_PTR */
69 #define PAGE_ZIP_CLUST_LEAF_SLOT_SIZE \
70  (PAGE_ZIP_DIR_SLOT_SIZE + DATA_TRX_ID_LEN + DATA_ROLL_PTR_LEN)
71 /** Mask of record offsets */
72 #define PAGE_ZIP_DIR_SLOT_MASK 0x3fff
73 /** 'owned' flag */
74 #define PAGE_ZIP_DIR_SLOT_OWNED 0x4000
75 /** 'deleted' flag */
76 #define PAGE_ZIP_DIR_SLOT_DEL 0x8000
77 
78 /* Whether or not to log compressed page images to avoid possible
79 compression algorithm changes in zlib. */
80 extern bool page_zip_log_pages;
81 
82 /** Set the size of a compressed page in bytes.
83 @param[in,out] page_zip compressed page
84 @param[in] size size in bytes */
85 UNIV_INLINE
86 void page_zip_set_size(page_zip_des_t *page_zip, ulint size);
87 
88 /** Determine if a record is so big that it needs to be stored externally.
89 @param[in] rec_size length of the record in bytes
90 @param[in] comp nonzero=compact format
91 @param[in] n_fields number of fields in the record; ignored if
92 tablespace is not compressed
93 @param[in] page_size page size
94 @return false if the entire record can be stored locally on the page */
95 UNIV_INLINE
96 ibool page_zip_rec_needs_ext(ulint rec_size, ulint comp, ulint n_fields,
97  const page_size_t &page_size)
98  MY_ATTRIBUTE((warn_unused_result));
99 
100 /** Determine the guaranteed free space on an empty page.
101  @return minimum payload size on the page */
102 ulint page_zip_empty_size(
103  ulint n_fields, /*!< in: number of columns in the index */
104  ulint zip_size) /*!< in: compressed page size in bytes */
105  MY_ATTRIBUTE((const));
106 
107 #ifndef UNIV_HOTBACKUP
108 /** Check whether a tuple is too big for compressed table
109 @param[in] index dict index object
110 @param[in] entry entry for the index
111 @return true if it's too big, otherwise false */
113 #endif /* !UNIV_HOTBACKUP */
114 
115 /** Initialize a compressed page descriptor. */
116 UNIV_INLINE
117 void page_zip_des_init(page_zip_des_t *page_zip); /*!< in/out: compressed page
118  descriptor */
119 
120 /** Configure the zlib allocator to use the given memory heap. */
121 void page_zip_set_alloc(void *stream, /*!< in/out: zlib stream */
122  mem_heap_t *heap); /*!< in: memory heap to use */
123 
124 /** Compress a page.
125  @return true on success, false on failure; page_zip will be left
126  intact on failure. */
127 ibool page_zip_compress(page_zip_des_t *page_zip, /*!< in: size; out: data,
128  n_blobs, m_start, m_end,
129  m_nonempty */
130  const page_t *page, /*!< in: uncompressed page */
131  dict_index_t *index, /*!< in: index tree */
132  ulint level, /*!< in: commpression level */
133  mtr_t *mtr); /*!< in/out: mini-transaction,
134  or NULL */
135 
136 /** Write the index information for the compressed page.
137  @return used size of buf */
139  ulint n, /*!< in: number of fields
140  to compress */
141  const dict_index_t *index, /*!< in: index comprising
142  at least n fields */
143  ulint trx_id_pos,
144  /*!< in: position of the trx_id column
145  in the index, or ULINT_UNDEFINED if
146  this is a non-leaf page */
147  byte *buf); /*!< out: buffer of (n + 1) * 2 bytes */
148 
149 /** Decompress a page. This function should tolerate errors on the compressed
150  page. Instead of letting assertions fail, it will return FALSE if an
151  inconsistency is detected.
152  @return true on success, false on failure */
153 ibool page_zip_decompress(
154  page_zip_des_t *page_zip, /*!< in: data, ssize;
155  out: m_start, m_end, m_nonempty, n_blobs */
156  page_t *page, /*!< out: uncompressed page, may be trashed */
157  ibool all); /*!< in: TRUE=decompress the whole page;
158  FALSE=verify but do not copy some
159  page header fields that should not change
160  after page creation */
161 
162 #ifdef UNIV_ZIP_DEBUG
163 /** Check that the compressed and decompressed pages match.
164  @return true if valid, false if not */
165 ibool page_zip_validate_low(
166  const page_zip_des_t *page_zip, /*!< in: compressed page */
167  const page_t *page, /*!< in: uncompressed page */
168  const dict_index_t *index, /*!< in: index of the page, if known */
169  ibool sloppy); /*!< in: FALSE=strict,
170  TRUE=ignore the MIN_REC_FLAG */
171 /** Check that the compressed and decompressed pages match. */
172 ibool page_zip_validate(
173  const page_zip_des_t *page_zip, /*!< in: compressed page */
174  const page_t *page, /*!< in: uncompressed page */
175  const dict_index_t *index); /*!< in: index of the page, if known */
176 #endif /* UNIV_ZIP_DEBUG */
177 
178 /** Determine how big record can be inserted without recompressing the page.
179  @return a positive number indicating the maximum size of a record
180  whose insertion is guaranteed to succeed, or zero or negative */
181 UNIV_INLINE
183  const page_zip_des_t *page_zip, /*!< in: compressed page */
184  ibool is_clust) /*!< in: TRUE if clustered index */
185  MY_ATTRIBUTE((warn_unused_result));
186 
187 /** Determine if enough space is available in the modification log.
188  @return true if page_zip_write_rec() will succeed */
189 UNIV_INLINE
190 ibool page_zip_available(
191  const page_zip_des_t *page_zip, /*!< in: compressed page */
192  bool is_clust, /*!< in: TRUE if clustered index */
193  ulint length, /*!< in: combined size of the record */
194  ulint create) /*!< in: nonzero=add the record to
195  the heap */
196  MY_ATTRIBUTE((warn_unused_result));
197 
198 /** Write data to the uncompressed header portion of a page. The data must
199 already have been written to the uncompressed page.
200 @param[in,out] page_zip compressed page
201 @param[in] str address on the uncompressed page
202 @param[in] length length of the data
203 @param[in] mtr mini-transaction, or NULL */
204 UNIV_INLINE
205 void page_zip_write_header(page_zip_des_t *page_zip, const byte *str,
206  ulint length, mtr_t *mtr);
207 
208 /** Write an entire record on the compressed page. The data must already
209  have been written to the uncompressed page. */
210 void page_zip_write_rec(
211  page_zip_des_t *page_zip, /*!< in/out: compressed page */
212  const byte *rec, /*!< in: record being written */
213  const dict_index_t *index, /*!< in: the index the record belongs to */
214  const ulint *offsets, /*!< in: rec_get_offsets(rec, index) */
215  ulint create); /*!< in: nonzero=insert, zero=update */
216 
217 /** Parses a log record of writing a BLOB pointer of a record.
218  @return end of log record or NULL */
220  byte *ptr, /*!< in: redo log buffer */
221  byte *end_ptr, /*!< in: redo log buffer end */
222  page_t *page, /*!< in/out: uncompressed page */
223  page_zip_des_t *page_zip); /*!< in/out: compressed page */
224 
225 /** Write a BLOB pointer of a record on the leaf page of a clustered index.
226  The information must already have been updated on the uncompressed page. */
228  page_zip_des_t *page_zip, /*!< in/out: compressed page */
229  const byte *rec, /*!< in/out: record whose data is being
230  written */
231  const dict_index_t *index, /*!< in: index of the page */
232  const ulint *offsets, /*!< in: rec_get_offsets(rec, index) */
233  ulint n, /*!< in: column index */
234  mtr_t *mtr); /*!< in: mini-transaction handle,
235  or NULL if no logging is needed */
236 
237 /** Parses a log record of writing the node pointer of a record.
238  @return end of log record or NULL */
240  byte *ptr, /*!< in: redo log buffer */
241  byte *end_ptr, /*!< in: redo log buffer end */
242  page_t *page, /*!< in/out: uncompressed page */
243  page_zip_des_t *page_zip); /*!< in/out: compressed page */
244 
245 /** Write the node pointer of a record on a non-leaf compressed page. */
247  page_zip_des_t *page_zip, /*!< in/out: compressed page */
248  byte *rec, /*!< in/out: record */
249  ulint size, /*!< in: data size of rec */
250  ulint ptr, /*!< in: node pointer */
251  mtr_t *mtr); /*!< in: mini-transaction, or NULL */
252 
253 /** Write the trx_id and roll_ptr of a record on a B-tree leaf node page. */
255  page_zip_des_t *page_zip, /*!< in/out: compressed page */
256  byte *rec, /*!< in/out: record */
257  const ulint *offsets, /*!< in: rec_get_offsets(rec, index) */
258  ulint trx_id_col, /*!< in: column number of TRX_ID in rec */
259  trx_id_t trx_id, /*!< in: transaction identifier */
260  roll_ptr_t roll_ptr); /*!< in: roll_ptr */
261 
262 /** Write the "deleted" flag of a record on a compressed page. The flag must
263  already have been written on the uncompressed page. */
265  page_zip_des_t *page_zip, /*!< in/out: compressed page */
266  const byte *rec, /*!< in: record on the uncompressed page */
267  ulint flag); /*!< in: the deleted flag (nonzero=TRUE) */
268 
269 /** Write the "owned" flag of a record on a compressed page. The n_owned field
270  must already have been written on the uncompressed page. */
272  page_zip_des_t *page_zip, /*!< in/out: compressed page */
273  const byte *rec, /*!< in: record on the uncompressed page */
274  ulint flag); /*!< in: the owned flag (nonzero=TRUE) */
275 
276 /** Insert a record to the dense page directory. */
278  page_zip_des_t *page_zip, /*!< in/out: compressed page */
279  const byte *prev_rec, /*!< in: record after which to insert */
280  const byte *free_rec, /*!< in: record from which rec was
281  allocated, or NULL */
282  byte *rec); /*!< in: record to insert */
283 
284 /** Shift the dense page directory and the array of BLOB pointers when a record
285 is deleted.
286 @param[in,out] page_zip compressed page
287 @param[in] rec deleted record
288 @param[in] index index of rec
289 @param[in] offsets rec_get_offsets(rec)
290 @param[in] free previous start of the free list */
291 void page_zip_dir_delete(page_zip_des_t *page_zip, byte *rec,
292  const dict_index_t *index, const ulint *offsets,
293  const byte *free);
294 
295 /** Add a slot to the dense page directory. */
297  page_zip_des_t *page_zip, /*!< in/out: compressed page */
298  bool is_clustered); /*!< in: nonzero for clustered index,
299  zero for others */
300 
301 /** Parses a log record of writing to the header of a page.
302  @return end of log record or NULL */
304  byte *ptr, /*!< in: redo log buffer */
305  byte *end_ptr, /*!< in: redo log buffer end */
306  page_t *page, /*!< in/out: uncompressed page */
307  page_zip_des_t *page_zip); /*!< in/out: compressed page */
308 
309 /** Write data to the uncompressed header portion of a page. The data must
310 already have been written to the uncompressed page.
311 However, the data portion of the uncompressed page may differ from the
312 compressed page when a record is being inserted in page_cur_insert_rec_low().
313 @param[in,out] page_zip compressed page
314 @param[in] str address on the uncompressed page
315 @param[in] length length of the data
316 @param[in] mtr mini-transaction, or NULL */
317 UNIV_INLINE
318 void page_zip_write_header(page_zip_des_t *page_zip, const byte *str,
319  ulint length, mtr_t *mtr);
320 
321 /** Reorganize and compress a page. This is a low-level operation for
322  compressed pages, to be used when page_zip_compress() fails.
323  On success, a redo log entry MLOG_ZIP_PAGE_COMPRESS will be written.
324  The function btr_page_reorganize() should be preferred whenever possible.
325  IMPORTANT: if page_zip_reorganize() is invoked on a leaf page of a
326  non-clustered index, the caller must update the insert buffer free
327  bits in the same mini-transaction in such a way that the modification
328  will be redo-logged.
329  @return true on success, false on failure; page_zip will be left
330  intact on failure, but page will be overwritten. */
331 ibool page_zip_reorganize(
332  buf_block_t *block, /*!< in/out: page with compressed page;
333  on the compressed page, in: size;
334  out: data, n_blobs,
335  m_start, m_end, m_nonempty */
336  dict_index_t *index, /*!< in: index of the B-tree node */
337  mtr_t *mtr); /*!< in: mini-transaction */
338 /** Copy the records of a page byte for byte. Do not copy the page header
339  or trailer, except those B-tree header fields that are directly
340  related to the storage of records. Also copy PAGE_MAX_TRX_ID.
341  NOTE: The caller must update the lock table and the adaptive hash index. */
342 void page_zip_copy_recs(
343  page_zip_des_t *page_zip, /*!< out: copy of src_zip
344  (n_blobs, m_start, m_end,
345  m_nonempty, data[0..size-1]) */
346  page_t *page, /*!< out: copy of src */
347  const page_zip_des_t *src_zip, /*!< in: compressed page */
348  const page_t *src, /*!< in: page */
349  dict_index_t *index, /*!< in: index of the B-tree */
350  mtr_t *mtr); /*!< in: mini-transaction */
351 #ifndef UNIV_HOTBACKUP
352 #endif /* !UNIV_HOTBACKUP */
353 
354 /** Parses a log record of compressing an index page.
355  @return end of log record or NULL */
357  byte *ptr, /*!< in: buffer */
358  byte *end_ptr, /*!< in: buffer end */
359  page_t *page, /*!< out: uncompressed page */
360  page_zip_des_t *page_zip); /*!< out: compressed page */
361 
362 /** Write a log record of compressing an index page without the data on the
363 page.
364 @param[in] level compression level
365 @param[in] page page that is compressed
366 @param[in] index index
367 @param[in] mtr mtr */
368 UNIV_INLINE
369 void page_zip_compress_write_log_no_data(ulint level, const page_t *page,
370  dict_index_t *index, mtr_t *mtr);
371 
372 /** Parses a log record of compressing an index page without the data.
373 @param[in] ptr buffer
374 @param[in] end_ptr buffer end
375 @param[in] page uncompressed page
376 @param[out] page_zip compressed page
377 @param[in] index index
378 @return end of log record or NULL */
379 UNIV_INLINE
381  page_zip_des_t *page_zip,
383 
384 #ifndef UNIV_HOTBACKUP
385 /** Reset the counters used for filling
386  INFORMATION_SCHEMA.innodb_cmp_per_index. */
387 UNIV_INLINE
389 
390 #ifdef UNIV_MATERIALIZE
391 #undef UNIV_INLINE
392 #define UNIV_INLINE UNIV_INLINE_ORIGINAL
393 #endif
394 #endif /* !UNIV_HOTBACKUP */
395 
396 #include "page0zip.ic"
397 
398 #endif /* page0zip_h */
void page_zip_set_alloc(void *stream, mem_heap_t *heap)
Configure the zlib allocator to use the given memory heap.
Definition: zipdecompress.cc:113
Compressed page descriptor.
Definition: page0types.h:197
#define free(A)
Definition: fts0ast.h:42
void page_zip_rec_set_deleted(page_zip_des_t *page_zip, const byte *rec, ulint flag)
Write the "deleted" flag of a record on a compressed page.
Definition: page0zip.cc:2226
ib_id_t roll_ptr_t
Rollback pointer (DB_ROLL_PTR, DATA_ROLL_PTR)
Definition: trx0types.h:150
uint page_zip_level
Definition: page0zip.cc:86
Compressed page interface.
void page_zip_write_rec(page_zip_des_t *page_zip, const byte *rec, const dict_index_t *index, const ulint *offsets, ulint create)
Write an entire record on the compressed page.
Definition: page0zip.cc:1670
ulint page_zip_fields_encode(ulint n, const dict_index_t *index, ulint trx_id_pos, byte *buf)
Write the index information for the compressed page.
Definition: page0zip.cc:327
The buffer control block structure.
Definition: buf0buf.h:1318
UNIV_INLINE void page_zip_des_init(page_zip_des_t *page_zip)
Initialize a compressed page descriptor.
byte * page_zip_parse_write_node_ptr(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
Parses a log record of writing the node pointer of a record.
Definition: page0zip.cc:1968
Index page routines.
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:343
UNIV_INLINE void page_zip_write_header(page_zip_des_t *page_zip, const byte *str, ulint length, mtr_t *mtr)
Write data to the uncompressed header portion of a page.
byte * page_zip_parse_compress(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
Parses a log record of compressing an index page.
Definition: page0zip.cc:2725
bool page_zip_log_pages
Definition: page0zip.cc:90
The server main program.
ibool page_zip_reorganize(buf_block_t *block, dict_index_t *index, mtr_t *mtr)
Reorganize and compress a page.
Definition: page0zip.cc:2556
int page
Definition: ctype-mb.cc:1231
char * index(const char *, int c)
Definition: mysql.cc:2862
Data dictionary global types.
UNIV_INLINE void page_zip_compress_write_log_no_data(ulint level, const page_t *page, dict_index_t *index, mtr_t *mtr)
Write a log record of compressing an index page without the data on the page.
bool page_zip_is_too_big(const dict_index_t *index, const dtuple_t *entry)
Check whether a tuple is too big for compressed table.
Definition: page0zip.cc:129
CRC32 implementation.
Structure for an SQL data tuple of fields (logical record)
Definition: data0data.h:714
void page_zip_dir_delete(page_zip_des_t *page_zip, byte *rec, const dict_index_t *index, const ulint *offsets, const byte *free)
Shift the dense page directory and the array of BLOB pointers when a record is deleted.
Definition: page0zip.cc:2336
The database buffer pool global types for the directory.
ibool page_zip_compress(page_zip_des_t *page_zip, const page_t *page, dict_index_t *index, ulint level, mtr_t *mtr)
Compress a page.
Definition: page0zip.cc:934
Buffer pool checksum functions, also linked from /extra/innochecksum.cc.
UNIV_INLINE lint page_zip_max_ins_size(const page_zip_des_t *page_zip, ibool is_clust)
Determine how big record can be inserted without recompressing the page.
ibool page_zip_decompress(page_zip_des_t *page_zip, page_t *page, ibool all)
Decompress a page.
Definition: page0zip.cc:1274
void page_zip_write_trx_id_and_roll_ptr(page_zip_des_t *page_zip, byte *rec, const ulint *offsets, ulint trx_id_col, trx_id_t trx_id, roll_ptr_t roll_ptr)
Write the trx_id and roll_ptr of a record on a B-tree leaf node page.
Definition: page0zip.cc:2095
UNIV_INLINE ibool page_zip_rec_needs_ext(ulint rec_size, ulint comp, ulint n_fields, const page_size_t &page_size)
Determine if a record is so big that it needs to be stored externally.
unsigned int uint
Definition: uca-dump.cc:29
UNIV_INLINE byte * page_zip_parse_compress_no_data(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip, dict_index_t *index)
Parses a log record of compressing an index page without the data.
Utilities for converting data from the database file to the machine format.
byte * page_zip_parse_write_header(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
Parses a log record of writing to the header of a page.
Definition: page0zip.cc:2463
void page_zip_copy_recs(page_zip_des_t *page_zip, page_t *page, const page_zip_des_t *src_zip, const page_t *src, dict_index_t *index, mtr_t *mtr)
Copy the records of a page byte for byte.
Definition: page0zip.cc:2642
UNIV_INLINE void page_zip_set_size(page_zip_des_t *page_zip, ulint size)
Set the size of a compressed page in bytes.
Transaction system global type definitions.
ulint page_zip_empty_size(ulint n_fields, ulint zip_size)
Determine the guaranteed free space on an empty page.
Definition: page0zip.cc:109
int n
Definition: xcom_base.c:425
The memory management.
byte * page_zip_parse_write_blob_ptr(byte *ptr, byte *end_ptr, page_t *page, page_zip_des_t *page_zip)
Parses a log record of writing a BLOB pointer of a record.
Definition: page0zip.cc:1838
void page_zip_write_blob_ptr(page_zip_des_t *page_zip, const byte *rec, const dict_index_t *index, const ulint *offsets, ulint n, mtr_t *mtr)
Write a BLOB pointer of a record on the leaf page of a clustered index.
Definition: page0zip.cc:1888
Page size descriptor.
Definition: page0size.h:50
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:148
static int flag
Definition: hp_test1.cc:39
UNIV_INLINE ibool page_zip_available(const page_zip_des_t *page_zip, bool is_clust, ulint length, ulint create)
Determine if enough space is available in the modification log.
UNIV_INLINE void page_zip_reset_stat_per_index()
Reset the counters used for filling INFORMATION_SCHEMA.innodb_cmp_per_index.
byte page_t
Type of the index page.
Definition: page0types.h:148
void page_zip_dir_insert(page_zip_des_t *page_zip, const byte *prev_rec, const byte *free_rec, byte *rec)
Insert a record to the dense page directory.
Definition: page0zip.cc:2262
void page_zip_write_node_ptr(page_zip_des_t *page_zip, byte *rec, ulint size, ulint ptr, mtr_t *mtr)
Write the node pointer of a record on a non-leaf compressed page.
Definition: page0zip.cc:2035
unsigned char byte
Blob class.
Definition: common.h:159
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:169
The database buffer pool high-level routines.
void page_zip_rec_set_owned(page_zip_des_t *page_zip, const byte *rec, ulint flag)
Write the "owned" flag of a record on a compressed page.
Definition: page0zip.cc:2246
Definition: completion_hash.h:34
bool length(const dd::Spatial_reference_system *srs, const Geometry *g1, double *length, bool *null) noexcept
Computes the length of linestrings and multilinestrings.
Definition: length.cc:75
Mini-transaction buffer global types.
void page_zip_dir_add_slot(page_zip_des_t *page_zip, bool is_clustered)
Add a slot to the dense page directory.
Definition: page0zip.cc:2419
Data structure for an index.
Definition: dict0mem.h:875