MySQL 9.1.0
Source Code Documentation
zlob0first.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 2016, 2024, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is designed to work with certain software (including
10but not limited to OpenSSL) that is licensed under separate terms,
11as designated in a particular file or component or in included license
12documentation. The authors of MySQL hereby grant you an additional
13permission to link the program and your derivative works with the
14separately licensed software that they have either included with
15the program or referenced in the documentation.
16
17This program is distributed in the hope that it will be useful, but WITHOUT
18ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
20for more details.
21
22You should have received a copy of the GNU General Public License along with
23this program; if not, write to the Free Software Foundation, Inc.,
2451 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25
26*****************************************************************************/
27#ifndef zlob0first_h
28#define zlob0first_h
29
30#include "fil0types.h"
31#include "fut0lst.h"
32#include "lob0impl.h"
33#include "univ.i"
34
35namespace lob {
36
37/** The first page of an zlob. */
39 /** Version information. One byte. */
41
42 /** One byte of flag bits. Currently only one bit (the least
43 significant bit) is used, other 7 bits are available for future use.*/
44 static const ulint OFFSET_FLAGS = FIL_PAGE_DATA + 1;
45
46 /** LOB version. 4 bytes.*/
47 static const uint32_t OFFSET_LOB_VERSION = OFFSET_FLAGS + 1;
48
49 /** The last transaction that modified this LOB. */
51
52 /** The last transaction that modified this LOB. */
54
55 /** The length of compressed data stored in this page. */
57
58 /** The transaction that created data in the data portion. */
60
61 /** The next index page. */
63
64 /** The next frag nodes page. */
66
67 /** List of free index entries. */
69
70 /** List of index entries. */
72
73 /** List of free frag entries. */
76
77 /** List of frag entries. */
78 static const ulint OFFSET_FRAG_LIST =
80
81 /** Begin of index entries. */
84
85 /** Given the page size, what is the number of index entries the
86 first page can contain. */
88
89 /** Given the page size, what is the number of frag entries the
90 first page can contain. */
92
94
97 }
98
101 }
102
105 }
106
107 bool is_empty() const {
109 return (flst_get_len(flst) == 0);
110 }
111
112 /** Get the length of the index list.
113 @return length of the index list. */
116 return (flst_get_len(flst));
117 }
118
121 }
122
123 byte *begin_data_ptr() const { return (frame() + begin_data()); }
124
125 /** Amount of zlob data that can be stored in first page (in bytes). */
128 ut_ad(begin_data() + FIL_PAGE_DATA_END < page_size.physical());
129 return (page_size.physical() - begin_data() - FIL_PAGE_DATA_END);
130 }
131
133
135 : m_block(nullptr), m_mtr(mtr), m_index(index) {}
136
138
140 : m_block(block), m_mtr(mtr), m_index(index) {}
141
142 buf_block_t *alloc(bool bulk);
143
144 void import(trx_id_t trx_id);
145
148 }
149
150 /** Load the given page number as the first page in x-latch mode.
151 @param[in] page_no the first page number.
152 @return the buffer block of the given page number. */
154 page_id_t page_id(dict_index_get_space(m_index), page_no);
156 m_block =
157 buf_page_get(page_id, page_size, RW_X_LATCH, UT_LOCATION_HERE, m_mtr);
158 return (m_block);
159 }
160
161 /** Load the first page using given mini-transaction. The first page must
162 already be x-latched by the m_mtr.
163 @param[in] mtr the mini-transaction in which first page is to be loaded.
164 @return the buffer block of first page. */
165 buf_block_t *load_x(mtr_t *mtr) const {
169 ut_ad(tmp == m_block);
170 return (tmp);
171 }
172
173 /** Load the first page of the compressed LOB with x-latch.
174 @param[in] page_id the page identifier of first page
175 @param[in] page_size the page size information of table.
176 @return buffer block of the first page. */
177 buf_block_t *load_x(const page_id_t &page_id, const page_size_t &page_size);
178
179 /** Load the given page number as the first page in s-latch mode.
180 @param[in] page_no the first page number.
181 @return the buffer block of the given page number. */
183 ut_ad(m_block == nullptr);
184
185 page_id_t page_id(dict_index_get_space(m_index), page_no);
187 m_block =
188 buf_page_get(page_id, page_size, RW_S_LATCH, UT_LOCATION_HERE, m_mtr);
189 return (m_block);
190 }
191
192 /** Deallocate the first page of a compressed LOB. */
193 void dealloc();
194
195 /** Set the FIL_PAGE_NEXT to FIL_NULL. */
197
198 /** Set the FIL_PAGE_PREV to FIL_NULL. */
200
201 /** Set the FIL_PAGE_NEXT to the given value.
202 @param[in] page_no the page number to set in FIL_PAGE_NEXT.
203 @param[in] mtr mini trx to be used for this modification. */
204 void set_next_page_no(page_no_t page_no, mtr_t *mtr) {
205 ut_ad(mtr != nullptr);
207 }
208
209 /** Set the FIL_PAGE_PREV to the given value.
210 @param[in] page_no the page number to set in FIL_PAGE_PREV.
211 @param[in] mtr mini trx to be used for this modification. */
212 void set_prev_page_no(page_no_t page_no, mtr_t *mtr) {
213 ut_ad(mtr != nullptr);
215 }
216
217 /** Write the space identifier to the page header, without generating
218 redo log records.
219 @param[in] space_id the space identifier. */
222 nullptr);
223 }
224
225 void init() {
226 ut_ad(m_mtr != nullptr);
227
230 set_data_len(0);
233 set_trx_id(0);
234 flst_base_node_t *flst = free_list();
235 flst_init(flst, m_mtr);
237 flst_init(ilst, m_mtr);
238 flst_base_node_t *free_frag_lst = free_frag_list();
239 flst_init(free_frag_lst, m_mtr);
240 flst_base_node_t *frag_lst = frag_list();
241 flst_init(frag_lst, m_mtr);
246 }
247
248 /** Get the amount of zlob data stored in this page. */
251 }
252
253 /** Get the page number. */
254 page_no_t get_page_no() const { return (m_block->page.id.page_no()); }
255
256 /** Get the page id of the first page of compressed LOB.
257 @return page id of the first page of compressed LOB. */
259 ut_ad(m_block != nullptr);
260
261 return (m_block->page.id);
262 }
263
265 page_no_t page_no = get_page_no();
266 uint32_t offset = static_cast<uint32_t>(begin_data());
267 return (fil_addr_t(page_no, offset));
268 }
269
270 /** All the index pages are singly linked with each other, and
271 the first page contains the link to one index page.
272 @param[in] page_no the page number of an index page. */
274 set_index_page_no(page_no, m_mtr);
275 }
276
277 /** All the index pages are singly linked with each other, and
278 the first page contains the link to one index page.
279 @param[in] page_no the page number of an index page.
280 @param[in] mtr use this mini transaction context for redo logs. */
281 void set_index_page_no(page_no_t page_no, mtr_t *mtr) {
282 ut_ad(m_mtr != nullptr);
284 }
285
286 /** All the index pages are singly linked with each other, and
287 the first page contains the link to one index page. Get that index
288 page number.
289 @return the index page number. */
292 }
293
294 /** All the fragment pages are doubly linked with each other, and
295 the first page contains the link to one fragment page in FIL_PAGE_PREV. Get
296 that frag page number.
297 @return the frag page number. */
299
300 /** All the fragment pages are doubly linked with each other, and
301 the first page contains the link to one fragment page in FIL_PAGE_PREV. Get
302 that frag page number.
303 @param[in] mtr Mini-transaction to use for this read operation.
304 @return the frag page number. */
306 return (mtr_read_ulint(frame() + FIL_PAGE_PREV, MLOG_4BYTES, mtr));
307 }
308
309#ifdef UNIV_DEBUG
310 /** Verify that the page number pointed to by FIL_PAGE_PREV of the first page
311 of LOB is indeed a fragment page. It uses its own mtr internally.
312 @return true if it is a fragment page, false otherwise. */
313 bool verify_frag_page_no();
314#endif /* UNIV_DEBUG */
315
316 /** All the fragment pages (@see z_frag_page_t) are doubly linked with each
317 other, and the first page contains the link to one fragment page in
318 FIL_PAGE_PREV.
319 @param[in] mtr Mini-transaction for this modification.
320 @param[in] page_no The page number of a fragment page. */
321 void set_frag_page_no(mtr_t *mtr, page_no_t page_no) {
323 set_prev_page_no(page_no, mtr);
324 }
325
326 /** All the fragment pages (@see z_frag_page_t) are doubly linked with each
327 other, and the first page contains the link to one fragment page in
328 FIL_PAGE_PREV.
329 @param[in] page_no the page number of a fragment page. */
332 set_prev_page_no(page_no, m_mtr);
333 }
334
335 /** All the frag node pages (@see z_frag_node_page_t) are singly linked with
336 each other, and the first page contains the link to the last allocated frag
337 node page. The last allocated FIL_PAGE_TYPE_ZLOB_FRAG_ENTRY page will be the
338 first in this list. This list is used to free these pages.
339 @param[in] page_no the page number of an frag node page. */
342 }
343
344 /** All the frag node pages (@see z_frag_node_page_t) are singly linked with
345 each other, and the first page contains the link to the last allocated frag
346 node page. The last allocated FIL_PAGE_TYPE_ZLOB_FRAG_ENTRY page will be the
347 first in this list. This list is used to free these pages.
348 @param[in] page_no the page number of an frag node page.
349 @param[in] mtr mini trx context to generate redo logs. */
351 ut_ad(mtr != nullptr);
353 mtr);
354 }
355
356 /** Free all the z_frag_page_t pages. All the z_frag_page_t pages are
357 singly linked to each other. The head of the list is maintained in the
358 first page.
359 @return the number of pages freed. */
361
362 /** Free all the index pages.
363 @return the number of pages freed. */
364 size_t free_all_index_pages();
365
366 /** Free all the fragment pages.
367 @return the number of pages freed. */
368 size_t free_all_frag_pages();
369
370 private:
371 /** Free all the fragment pages when the next page of the first LOB page IS
372 NOT USED to link the fragment pages.
373 @return the number of pages freed. */
375
376 /** Free all the fragment pages when the next page of the first LOB page IS
377 USED to link the fragment pages.
378 @return the number of pages freed. */
380
381 public:
382 /** Free all the data pages.
383 @return the number of pages freed. */
384 size_t free_all_data_pages();
385
386 /** All the frag node pages are singly linked with each other, and the
387 first page contains the link to one frag node page. Get that frag node
388 page number.
389 @return the index page number. */
392 }
393
394 /** Set the page type to FIL_PAGE_TYPE_UNKNOWN. This is done while
395 deallocating this page. */
397 ut_ad(m_mtr != nullptr);
400 }
401
403 ut_ad(m_mtr != nullptr);
406 }
407
408 void set_data_len(ulint len) {
409 ut_ad(m_mtr != nullptr);
411 }
412
413 /** Update the trx id in the header.
414 @param[in] tid the given transaction identifier. */
416 byte *ptr = frame() + OFFSET_TRX_ID;
417 mach_write_to_6(ptr, tid);
418 mlog_log_string(ptr, 6, m_mtr);
419 }
420
421 /** Update the trx id in the header, without generating redo
422 log records.
423 @param[in] tid the given transaction identifier. */
425 byte *ptr = frame() + OFFSET_TRX_ID;
426 mach_write_to_6(ptr, tid);
427 }
428
429 /** Initialize the LOB version to 1. */
431 ut_ad(m_mtr != nullptr);
432
434 }
435
436 /** Get the LOB version
437 @return the LOB version. */
438 uint32_t get_lob_version() {
440 }
441
442 /** Increment LOB version by 1. */
443 uint32_t incr_lob_version();
444
445 /** Get one byte of flags
446 @return one byte of flags. */
447 uint8_t get_flags() { return (mach_read_from_1(frame() + OFFSET_FLAGS)); }
448
449 /** When the bit is set, the LOB is not partially updatable anymore.
450 @return true, if partially updatable.
451 @return false, if partially NOT updatable. */
453 uint8_t flags = get_flags();
454 return (!(flags & 0x01));
455 }
456
457 /** When the bit is set, the LOB is not partially updatable anymore.
458 Enable the bit.
459 @param[in] trx the current transaction.*/
461
463 byte *ptr = frame() + OFFSET_LAST_TRX_ID;
464 mach_write_to_6(ptr, tid);
465 mlog_log_string(ptr, 6, m_mtr);
466 }
467
468 /** Update the last transaction identifier in the header, without
469 generating redo logs.
470 @param[in] tid given transaction identifier.*/
472 byte *ptr = frame() + OFFSET_LAST_TRX_ID;
473 mach_write_to_6(ptr, tid);
474 }
475
477 ut_ad(m_mtr != nullptr);
478
479 byte *ptr = frame() + OFFSET_LAST_UNDO_NO;
480 mlog_write_ulint(ptr, undo_no, MLOG_4BYTES, m_mtr);
481 }
482
484 byte *ptr = frame() + OFFSET_LAST_TRX_ID;
485 return (mach_read_from_6(ptr));
486 }
487
489 byte *ptr = frame() + OFFSET_LAST_UNDO_NO;
490 return (mach_read_from_4(ptr));
491 }
492
494
496
498 return (frame() + OFFSET_FREE_FRAG_LIST);
499 }
500
502
504 flst_base_node_t *free_frag_lst = free_frag_list();
506 for (ulint i = 0; i < n; ++i) {
508 ptr += (i * z_frag_entry_t::SIZE);
509 z_frag_entry_t frag_entry(ptr, m_mtr);
510 frag_entry.init();
511 frag_entry.push_back(free_frag_lst);
512 }
513 }
514
515 void init_index_entries();
516
517 /** Allocate a fragment of the given size. This involves finding a
518 fragment page, that has space to store len bytes of data. If necessary,
519 allocate a new fragment page.
520 @param[in] bulk true if it is bulk operation
521 (OPCODE_INSERT_BULK), false otherwise.
522 @param[in] len length of data to be stored in
523 fragment page.
524 @param[out] frag_page the fragment page with the needed
525 free space.
526 @param[out] entry fragment page entry representing frag_page.
527 @return fragment identifier within the fragment page.
528 @return FRAG_ID_NULL if fragment could not be allocated. */
529 frag_id_t alloc_fragment(bool bulk, ulint len, z_frag_page_t &frag_page,
531
532 /** Allocate one index entry. If there is no free index entry,
533 allocate an index page (a page full of z_index_entry_t objects)
534 and service the request.
535 @return the allocated index entry. */
537
538 /** Allocate one frag page entry. If there is no free frag
539 entry, allocate an frag node page (a page full of z_frag_entry_t
540 objects) and service the request.
541 @return the allocated frag entry. */
543
544 /** Print the index entries. */
545 std::ostream &print_index_entries(std::ostream &out) const;
546
547 /** Print the index entries. */
548 std::ostream &print_frag_entries(std::ostream &out) const;
549
550 /** Print the page. */
551 std::ostream &print(std::ostream &out) const;
552
553 byte *frame() const { return (buf_block_get_frame(m_block)); }
554
555 /** Load the page, in x-latch mode, containing the given file address.
556 @param[in] addr given file address
557 @return the file list node pointer. */
559 return (addr2ptr_x(addr, m_mtr));
560 }
561
562 /** Load the page, in x-latch mode, containing the given file address.
563 @param[in] addr given file address
564 @param[in] mtr the mini-transaction context to be used.
565 @return the file list node pointer. */
568 const page_size_t page_size = dict_table_page_size(m_index->table);
569 return (fut_get_ptr(space, page_size, addr, RW_X_LATCH, mtr));
570 }
571
572 /** Load the page, in s-latch mode, containing the given file address.
573 @param[in] addr given file address
574 @return the file list node pointer. */
577 const page_size_t page_size = dict_table_page_size(m_index->table);
578 return (fut_get_ptr(space, page_size, addr, RW_S_LATCH, m_mtr));
579 }
580
581 /** Load the entry available in the given file address.
582 @param[in] addr file address
583 @param[out] entry the entry to be loaded.*/
585
586 /** Load the entry available in the given file address.
587 @param[in] addr file address
588 @param[out] entry the entry to be loaded.*/
590
591 /** Free all the pages of the zlob.
592 @return the total number of pages freed. */
593 size_t destroy();
594
595 /** Free all the pages of the zlob except the first page.
596 @return the total number of pages freed. */
597 size_t make_empty();
598
599#ifdef UNIV_DEBUG
600 private:
601 /** Validate the LOB. This is a costly function. We need to avoid using
602 this directly, instead call z_first_page_t::validate().
603 @return true if valid, false otherwise. */
604 bool validate_low();
605
606 public:
607 /** Validate the LOB.
608 @return true if valid, false otherwise. */
609 bool validate() {
610 static const uint32_t FREQ = 50;
611 static std::atomic<uint32_t> n{0};
612
613 bool valid = true;
614 if (++n % FREQ == 0) {
615 valid = validate_low();
616 }
617 return (valid);
618 }
619#endif /* UNIV_DEBUG */
620
621 /** Get the buffer block of the first page of LOB.
622 @return the buffer block of the first page of LOB. */
623 buf_block_t *get_block() const { return (m_block); }
624
625 public:
626 void set_mtr(mtr_t *mtr) { m_mtr = mtr; }
627
628 /** Restart the given mtr. The first page must already be x-latched by the
629 m_mtr.
630 @param[in] mtr the mini-transaction context which is to be restarted. */
631 void restart_mtr(mtr_t *mtr) {
632 ut_ad(mtr != m_mtr);
633
634 mtr_commit(mtr);
635 mtr_start(mtr);
637 load_x(mtr);
638 }
639
640 private:
641 /** The buffer block of the first page. */
643
644 /** The mini-transaction context. */
646
647 /** The index dictionary object. */
649
650}; // struct z_first_page_t
651
652/** Overloading the global output parameter to print object of type
653z_first_page_t into the given output stream.
654@param[in,out] out output stream.
655@param[in] obj object to be printed.
656@return the output stream. */
657inline std::ostream &operator<<(std::ostream &out, const z_first_page_t &obj) {
658 return (obj.print(out));
659}
660
661} /* namespace lob */
662
663#endif /* zlob0first_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:48
uint32_t page_no_t
Page number.
Definition: api0api.h:46
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:251
static buf_frame_t * buf_block_get_frame(const buf_block_t *block)
Gets a pointer to the memory frame of a block.
buf_block_t * buf_page_get(const page_id_t &id, const page_size_t &size, ulint latch, ut::Location location, mtr_t *mtr)
NOTE! The following macros should be used instead of buf_page_get_gen, to improve debugging.
Definition: buf0buf.h:441
page_id_t id
Page id.
Definition: buf0buf.h:1376
Page identifier.
Definition: buf0types.h:207
page_no_t page_no() const
Retrieve the page number.
Definition: buf0types.h:243
Page size descriptor.
Definition: page0size.h:50
size_t physical() const
Retrieve the physical page size (on-disk).
Definition: page0size.h:121
static const page_size_t dict_table_page_size(const dict_table_t *table)
Get the table page size.
static space_id_t dict_index_get_space(const dict_index_t *index)
Gets the space id of the root of the index tree.
uint16_t page_type_t
Definition: fil0fil.h:1218
constexpr page_no_t FIL_NULL
'null' (undefined) page offset in the context of file spaces
Definition: fil0fil.h:1156
constexpr page_type_t FIL_PAGE_TYPE_UNKNOWN
In old tablespaces, garbage in FIL_PAGE_TYPE is replaced with this value when flushing pages.
Definition: fil0fil.h:1272
constexpr page_type_t FIL_PAGE_TYPE_ZLOB_FIRST
The first page of a compressed LOB.
Definition: fil0fil.h:1308
The low-level file system page header & trailer offsets.
constexpr uint32_t FIL_PAGE_TYPE
file page type: FIL_PAGE_INDEX,..., 2 bytes.
Definition: fil0types.h:76
constexpr uint32_t FIL_PAGE_DATA
start of the data on the page
Definition: fil0types.h:111
constexpr uint32_t FIL_PAGE_SPACE_ID
alias for space id
Definition: fil0types.h:108
constexpr uint32_t FIL_PAGE_NEXT
if there is a 'natural' successor of the page, its offset.
Definition: fil0types.h:61
constexpr uint32_t FIL_PAGE_PREV
if there is a 'natural' predecessor of the page, its offset.
Definition: fil0types.h:51
constexpr uint32_t FIL_PAGE_DATA_END
size of the page trailer
Definition: fil0types.h:119
File-based list utilities.
constexpr ulint FLST_BASE_NODE_SIZE
Definition: fut0lst.h:50
byte flst_base_node_t
Definition: fut0lst.h:46
static ulint flst_get_len(const flst_base_node_t *base)
Get the length of a list.
static void flst_init(flst_base_node_t *base, mtr_t *mtr)
Initializes a list base node.
byte flst_node_t
Definition: fut0lst.h:47
static int flags[50]
Definition: hp_test1.cc:40
static uint16_t mach_read_from_2(const byte *b)
The following function is used to fetch data from 2 consecutive bytes.
static uint32_t mach_read_from_4(const byte *b)
The following function is used to fetch data from 4 consecutive bytes.
static uint8_t mach_read_from_1(const byte *b)
The following function is used to fetch data from one byte.
static void mach_write_to_6(byte *b, uint64_t id)
The following function is used to store data in 6 consecutive bytes.
static uint64_t mach_read_from_6(const byte *b)
The following function is used to fetch data from 6 consecutive bytes.
void mlog_log_string(byte *ptr, ulint len, mtr_t *mtr)
Logs a write of a string to a file page buffered in the buffer pool.
Definition: mtr0log.cc:347
void mlog_write_ulint(byte *ptr, ulint val, mlog_id_t type, mtr_t *mtr)
Writes 1, 2 or 4 bytes to a file page.
Definition: mtr0log.cc:258
#define mtr_commit(m)
Commit a mini-transaction.
Definition: mtr0mtr.h:59
#define mtr_memo_contains(m, o, t)
Check if memo contains the given item.
Definition: mtr0mtr.h:107
#define mtr_start(m)
Start a mini-transaction.
Definition: mtr0mtr.h:50
#define mtr_read_ulint(p, t, m)
Read 1 - 4 bytes from a file page buffered in the buffer pool.
Definition: mtr0mtr.h:87
@ MLOG_4BYTES
4 bytes ...
Definition: mtr0types.h:76
@ MLOG_1BYTE
one byte is written
Definition: mtr0types.h:70
@ MLOG_2BYTES
2 bytes ...
Definition: mtr0types.h:73
@ MTR_MEMO_PAGE_X_FIX
Definition: mtr0types.h:273
Used for bulk load of data.
Definition: fut0lst.cc:411
byte * fut_get_ptr(fil_addr_t addr, std::vector< buf_block_t * > &blocks)
Gets a pointer to a file address.
Definition: fut0lst.cc:499
Provides the large objects (LOB) module.
Definition: lob0bulk.h:44
ulint frag_id_t
Definition: lob0impl.h:489
std::ostream & operator<<(std::ostream &out, const plist_node_t &obj)
Definition: lob0impl.h:239
Definition: completion_hash.h:35
The buffer control block structure.
Definition: buf0buf.h:1747
buf_page_t page
page information; this must be the first field, so that buf_pool->page_hash can point to buf_page_t o...
Definition: buf0buf.h:1753
page_no_t get_prev_page_no() const
Get the prev page number of the current buffer block.
Definition: buf0buf.h:1945
Data structure for an index.
Definition: dict0mem.h:1041
dict_table_t * table
back pointer to table
Definition: dict0mem.h:1055
page_size_t get_page_size() const
Get the page size of the tablespace to which this index belongs.
Definition: dict0mem.cc:895
File space address.
Definition: fil0fil.h:1173
The first page of an zlob.
Definition: zlob0first.h:38
std::ostream & print_frag_entries(std::ostream &out) const
Print the index entries.
Definition: zlob0first.cc:145
void restart_mtr(mtr_t *mtr)
Restart the given mtr.
Definition: zlob0first.h:631
void set_page_type_unknown()
Set the page type to FIL_PAGE_TYPE_UNKNOWN.
Definition: zlob0first.h:396
void init_lob_version()
Initialize the LOB version to 1.
Definition: zlob0first.h:430
uint32_t incr_lob_version()
Increment LOB version by 1.
Definition: zlob0first.cc:455
void set_data_len(ulint len)
Definition: zlob0first.h:408
void set_frag_node_page_no(page_no_t page_no)
All the frag node pages (.
Definition: zlob0first.h:340
ulint get_n_frag_entries() const
Given the page size, what is the number of frag entries the first page can contain.
Definition: zlob0first.cc:65
static const ulint OFFSET_INDEX_PAGE_NO
The next index page.
Definition: zlob0first.h:62
buf_block_t * get_block() const
Get the buffer block of the first page of LOB.
Definition: zlob0first.h:623
size_t free_all_frag_pages()
Free all the fragment pages.
Definition: zlob0first.cc:645
static const ulint OFFSET_LAST_UNDO_NO
The last transaction that modified this LOB.
Definition: zlob0first.h:53
z_first_page_t(buf_block_t *block)
Definition: zlob0first.h:137
page_no_t get_index_page_no() const
All the index pages are singly linked with each other, and the first page contains the link to one in...
Definition: zlob0first.h:290
void init_frag_entries()
Definition: zlob0first.h:503
size_t free_all_frag_pages_old()
Free all the fragment pages when the next page of the first LOB page IS NOT USED to link the fragment...
Definition: zlob0first.cc:590
size_t make_empty()
Free all the pages of the zlob except the first page.
Definition: zlob0first.cc:688
void set_prev_page_no(page_no_t page_no, mtr_t *mtr)
Set the FIL_PAGE_PREV to the given value.
Definition: zlob0first.h:212
static const ulint OFFSET_INDEX_BEGIN
Begin of index entries.
Definition: zlob0first.h:82
static const ulint OFFSET_DATA_LEN
The length of compressed data stored in this page.
Definition: zlob0first.h:56
flst_node_t * addr2ptr_s(fil_addr_t &addr)
Load the page, in s-latch mode, containing the given file address.
Definition: zlob0first.h:575
size_t free_all_frag_node_pages()
Free all the z_frag_page_t pages.
Definition: zlob0first.cc:337
ulint size_of_index_entries() const
Definition: zlob0first.cc:399
void init()
Definition: zlob0first.h:225
uint32_t get_lob_version()
Get the LOB version.
Definition: zlob0first.h:438
bool validate()
Validate the LOB.
Definition: zlob0first.h:609
bool is_empty() const
Definition: zlob0first.h:107
size_t free_all_index_pages()
Free all the index pages.
Definition: zlob0first.cc:370
void dealloc()
Deallocate the first page of a compressed LOB.
Definition: zlob0first.cc:424
void set_last_trx_id_no_redo(trx_id_t tid)
Update the last transaction identifier in the header, without generating redo logs.
Definition: zlob0first.h:471
buf_block_t * m_block
The buffer block of the first page.
Definition: zlob0first.h:642
void set_prev_page_null()
Set the FIL_PAGE_PREV to FIL_NULL.
Definition: zlob0first.h:199
bool verify_frag_page_no()
Verify that the page number pointed to by FIL_PAGE_PREV of the first page of LOB is indeed a fragment...
Definition: zlob0first.cc:698
page_no_t get_frag_node_page_no()
All the frag node pages are singly linked with each other, and the first page contains the link to on...
Definition: zlob0first.h:390
buf_block_t * alloc(bool bulk)
Definition: zlob0first.cc:90
void set_mtr(mtr_t *mtr)
Definition: zlob0first.h:626
flst_node_t * addr2ptr_x(fil_addr_t &addr) const
Load the page, in x-latch mode, containing the given file address.
Definition: zlob0first.h:558
static const ulint OFFSET_FRAG_LIST
List of frag entries.
Definition: zlob0first.h:78
void set_next_page_null()
Set the FIL_PAGE_NEXT to FIL_NULL.
Definition: zlob0first.h:196
size_t free_all_data_pages()
Free all the data pages.
Definition: zlob0first.cc:486
z_frag_entry_t alloc_frag_entry(bool bulk)
Allocate one frag page entry.
Definition: zlob0first.cc:193
void set_next_page_no(page_no_t page_no, mtr_t *mtr)
Set the FIL_PAGE_NEXT to the given value.
Definition: zlob0first.h:204
void set_version_0()
Definition: zlob0first.h:119
void set_trx_id(trx_id_t tid)
Update the trx id in the header.
Definition: zlob0first.h:415
flst_node_t * addr2ptr_x(fil_addr_t &addr, mtr_t *mtr) const
Load the page, in x-latch mode, containing the given file address.
Definition: zlob0first.h:566
static const ulint OFFSET_FLAGS
One byte of flag bits.
Definition: zlob0first.h:44
ulint get_n_index_entries() const
Given the page size, what is the number of index entries the first page can contain.
Definition: zlob0first.cc:37
page_type_t get_page_type() const
Definition: zlob0first.h:146
page_id_t get_page_id() const
Get the page id of the first page of compressed LOB.
Definition: zlob0first.h:258
flst_base_node_t * frag_list() const
Definition: zlob0first.h:501
void set_last_trx_id(trx_id_t tid)
Definition: zlob0first.h:462
static const ulint OFFSET_TRX_ID
The transaction that created data in the data portion.
Definition: zlob0first.h:59
flst_base_node_t * free_list() const
Definition: zlob0first.h:493
ulint begin_data() const
Definition: zlob0first.h:103
bool validate_low()
Validate the LOB.
Definition: zlob0first.cc:533
static const uint32_t OFFSET_LOB_VERSION
LOB version.
Definition: zlob0first.h:47
byte * begin_data_ptr() const
Definition: zlob0first.h:123
page_no_t get_page_no() const
Get the page number.
Definition: zlob0first.h:254
void set_space_id_no_redo(space_id_t space_id)
Write the space identifier to the page header, without generating redo log records.
Definition: zlob0first.h:220
mtr_t * m_mtr
The mini-transaction context.
Definition: zlob0first.h:645
undo_no_t get_last_trx_undo_no() const
Definition: zlob0first.h:488
void set_frag_page_no(mtr_t *mtr, page_no_t page_no)
All the fragment pages (.
Definition: zlob0first.h:321
ulint get_index_list_length() const
Get the length of the index list.
Definition: zlob0first.h:114
size_t destroy()
Free all the pages of the zlob.
Definition: zlob0first.cc:681
dict_index_t * m_index
The index dictionary object.
Definition: zlob0first.h:648
z_index_entry_t alloc_index_entry(bool bulk)
Allocate one index entry.
Definition: zlob0first.cc:168
static const ulint OFFSET_FREE_LIST
List of free index entries.
Definition: zlob0first.h:68
static const ulint OFFSET_FRAG_NODES_PAGE_NO
The next frag nodes page.
Definition: zlob0first.h:65
page_no_t get_frag_page_no() const
All the fragment pages are doubly linked with each other, and the first page contains the link to one...
Definition: zlob0first.h:298
size_t free_all_frag_pages_new()
Free all the fragment pages when the next page of the first LOB page IS USED to link the fragment pag...
Definition: zlob0first.cc:655
static const ulint OFFSET_FREE_FRAG_LIST
List of free frag entries.
Definition: zlob0first.h:74
static const ulint OFFSET_INDEX_LIST
List of index entries.
Definition: zlob0first.h:71
buf_block_t * load_s(page_no_t page_no)
Load the given page number as the first page in s-latch mode.
Definition: zlob0first.h:182
z_first_page_t(mtr_t *mtr, dict_index_t *index)
Definition: zlob0first.h:134
z_first_page_t()
Definition: zlob0first.h:132
z_first_page_t(buf_block_t *block, mtr_t *mtr, dict_index_t *index)
Definition: zlob0first.h:139
void set_last_trx_undo_no(undo_no_t undo_no)
Definition: zlob0first.h:476
void set_index_page_no(page_no_t page_no)
All the index pages are singly linked with each other, and the first page contains the link to one in...
Definition: zlob0first.h:273
bool can_be_partially_updated()
When the bit is set, the LOB is not partially updatable anymore.
Definition: zlob0first.h:452
static const ulint OFFSET_LAST_TRX_ID
The last transaction that modified this LOB.
Definition: zlob0first.h:50
flst_base_node_t * index_list() const
Definition: zlob0first.h:495
uint8_t get_flags()
Get one byte of flags.
Definition: zlob0first.h:447
flst_base_node_t * free_frag_list() const
Definition: zlob0first.h:497
void set_page_type()
Definition: zlob0first.h:402
void mark_cannot_be_partially_updated(trx_t *trx)
When the bit is set, the LOB is not partially updatable anymore.
Definition: zlob0first.cc:468
fil_addr_t get_self_addr() const
Definition: zlob0first.h:264
void load_entry_s(fil_addr_t &addr, z_index_entry_t &entry)
Load the entry available in the given file address.
Definition: zlob0first.cc:415
ulint payload()
Amount of zlob data that can be stored in first page (in bytes).
Definition: zlob0first.h:126
frag_id_t alloc_fragment(bool bulk, ulint len, z_frag_page_t &frag_page, z_frag_entry_t &entry)
Allocate a fragment of the given size.
Definition: zlob0first.cc:216
void load_entry_x(fil_addr_t &addr, z_index_entry_t &entry)
Load the entry available in the given file address.
Definition: zlob0first.cc:419
void set_frag_node_page_no(page_no_t page_no, mtr_t *mtr)
All the frag node pages (.
Definition: zlob0first.h:350
std::ostream & print_index_entries(std::ostream &out) const
Print the index entries.
Definition: zlob0first.cc:107
trx_id_t get_last_trx_id() const
Definition: zlob0first.h:483
page_no_t get_frag_page_no(mtr_t *mtr) const
All the fragment pages are doubly linked with each other, and the first page contains the link to one...
Definition: zlob0first.h:305
ulint begin_frag_entries() const
Definition: zlob0first.h:99
void init_index_entries()
Definition: zlob0first.cc:403
void set_index_page_no(page_no_t page_no, mtr_t *mtr)
All the index pages are singly linked with each other, and the first page contains the link to one in...
Definition: zlob0first.h:281
void set_trx_id_no_redo(trx_id_t tid)
Update the trx id in the header, without generating redo log records.
Definition: zlob0first.h:424
byte * frame() const
Definition: zlob0first.h:553
static const ulint OFFSET_VERSION
Version information.
Definition: zlob0first.h:40
void set_frag_page_no(page_no_t page_no)
All the fragment pages (.
Definition: zlob0first.h:330
buf_block_t * load_x(mtr_t *mtr) const
Load the first page using given mini-transaction.
Definition: zlob0first.h:165
ulint get_data_len() const
Get the amount of zlob data stored in this page.
Definition: zlob0first.h:249
ulint size_of_frag_entries() const
Definition: zlob0first.h:95
std::ostream & print(std::ostream &out) const
Print the page.
Definition: zlob0first.cc:328
buf_block_t * load_x(page_no_t page_no)
Load the given page number as the first page in x-latch mode.
Definition: zlob0first.h:153
An entry representing one fragment page.
Definition: lob0impl.h:555
void init()
Initialize the fragment entry contents.
Definition: lob0impl.h:593
static const ulint SIZE
Total size of one frag entry.
Definition: lob0impl.h:579
void push_back(flst_base_node_t *bnode)
Add this node as the last node in the given list.
Definition: lob0impl.h:638
The fragment page.
Definition: lob0impl.h:1352
An index entry pointing to one zlib stream.
Definition: zlob0index.h:87
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:177
mtr_log_t set_log_mode(mtr_log_t mode)
Change the logging mode.
Definition: mtr0mtr.cc:468
mtr_log_t get_log_mode() const
Get the logging mode.
Definition: mtr0mtr.ic:153
Definition: trx0trx.h:675
@ RW_X_LATCH
Definition: sync0rw.h:99
@ RW_S_LATCH
Definition: sync0rw.h:98
ib_id_t undo_no_t
Undo number.
Definition: trx0types.h:142
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:138
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:406
#define UT_LOCATION_HERE
Definition: ut0core.h:73
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:105
int n
Definition: xcom_base.cc:509