MySQL 8.0.31
Source Code Documentation
lob0first.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 2016, 2022, 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 also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27#ifndef lob0first_h
28#define lob0first_h
29
30#include "btr0btr.h"
31#include "buf0buf.h"
32#include "dict0dict.h"
33#include "fut0lst.h"
34#include "lob0index.h"
35#include "lob0lob.h"
36#include "lob0util.h"
37#include "mtr0log.h"
38
39namespace lob {
40
41/** The first page of an uncompressed LOB. */
42struct first_page_t : public basic_page_t {
43 /** Version information. One byte. */
45
46 /** One byte of flag bits. Currently only one bit (the least
47 significant bit) is used, other 7 bits are available for future use.*/
48 static const ulint OFFSET_FLAGS = FIL_PAGE_DATA + 1;
49
50 /** LOB version. 4 bytes.*/
51 static const uint32_t OFFSET_LOB_VERSION = OFFSET_FLAGS + 1;
52
53 /** The latest transaction that modified this LOB. */
55
56 /** The latest transaction undo_no that modified this LOB. */
58
59 /** Length of data stored in this page. 4 bytes. */
61
62 /** The trx that created the data stored in this page. */
64
65 /** The offset where the list base node is located. This is the list
66 of LOB pages. */
68
69 /** The offset where the list base node is located. This is the list
70 of free nodes. */
73
74 /** The offset where the contents of the first page begins. */
75 static const ulint LOB_PAGE_DATA =
77
79
80 /** The default constructor. */
81 first_page_t() = default;
82
83 /** Constructor.
84 @param[in] block Buffer block of the first page.
85 @param[in] mtr Mini-transaction context. */
86 first_page_t(buf_block_t *block, mtr_t *mtr) : basic_page_t(block, mtr) {}
87
88 /** Constructor.
89 @param[in] block the buffer block of the first page.*/
91
92 /** Constructor.
93 @param[in] block Buffer block of the first page.
94 @param[in] mtr Mini-transaction context.
95 @param[in] index Clustered index containing the LOB. */
97 : basic_page_t(block, mtr, index) {}
98
99 /** Constructor.
100 @param[in] mtr Mini-transaction context.
101 @param[in] index Clustered index containing the LOB. */
103 : basic_page_t(nullptr, mtr, index) {}
104
105 /** Set the LOB format version number to 0. */
108 }
109
110 /** Obtain the flags value. This has 8 bits of which only the first
111 bit is used.
112 @return one byte flag */
113 uint8_t get_flags() { return (mach_read_from_1(frame() + OFFSET_FLAGS)); }
114
115 /** When the bit is set, the LOB is not partially updatable anymore.
116 @return true, if partially updatable.
117 @return false, if partially NOT updatable. */
119 uint8_t flags = get_flags();
120 return (!(flags & 0x01));
121 }
122
123 /** Do tablespace import. */
124 void import(trx_id_t trx_id);
125
126 /** When the bit is set, the LOB is not partially updatable anymore.
127 Enable the bit.
128 @param[in] trx the current transaction. */
130
131 /** Allocate the first page for uncompressed LOB.
132 @param[in,out] alloc_mtr the allocation mtr.
133 @param[in] is_bulk true if it is bulk operation.
134 (OPCODE_INSERT_BULK)
135 return the allocated buffer block.*/
136 buf_block_t *alloc(mtr_t *alloc_mtr, bool is_bulk);
137
138 /** Free all the index pages. The list of index pages can be accessed
139 by traversing via the FIL_PAGE_NEXT field.*/
141
142 /** Free all the data pages. The data pages can be accessed through
143 index entry. */
144 void free_all_data_pages();
145
146 /** Load the first page of LOB with s-latch.
147 @param[in] page_id the page identifier of the first page.
148 @param[in] page_size the page size information.
149 @return the buffer block of the first page. */
151 m_block =
152 buf_page_get(page_id, page_size, RW_S_LATCH, UT_LOCATION_HERE, m_mtr);
153 return (m_block);
154 }
155
156 /** Load the first page of LOB with x-latch.
157 @param[in] page_id Page identifier of the first page.
158 @param[in] page_size Page size information.
159 @param[in] mtr Mini-transaction context for latch.
160 @return the buffer block of the first page. */
161 buf_block_t *load_x(const page_id_t &page_id, const page_size_t &page_size,
162 mtr_t *mtr);
163
164 /** Load the first page of LOB with x-latch in the given mtr context.
165 The first page must already be x-latched by the m_mtr.
166 @param[in] mtr Mini-transaction context for latch.
167 @return the buffer block of the first page. */
168 buf_block_t *load_x(mtr_t *mtr) const {
172 ut_ad(tmp == m_block);
173 return (tmp);
174 }
175
176 /** Load the first page of LOB with x-latch.
177 @param[in] page_id the page identifier of the first page.
178 @param[in] page_size the page size information.
179 @return the buffer block of the first page. */
180 buf_block_t *load_x(const page_id_t &page_id, const page_size_t &page_size) {
181 return (load_x(page_id, page_size, m_mtr));
182 }
183
184 /** Get the buffer block of the LOB first page.
185 @return the buffer block. */
187
188 /** Load the file list node from the given location. An x-latch is taken
189 on the page containing the file list node.
190 @param[in] addr Location of file list node.
191 @param[in] mtr Mini-transaction context to be used.
192 @return the file list node.*/
193 flst_node_t *addr2ptr_x(const fil_addr_t &addr, mtr_t *mtr) const;
194
195 /** Load the file list node from the given location. An x-latch is taken
196 on the page containing the file list node.
197 @param[in] addr the location of file list node.
198 @return the file list node.*/
200 return (addr2ptr_x(addr, m_mtr));
201 }
202
203 /** Load the file list node from the given location, assuming that it
204 exists in the first page itself.
205 @param[in] addr the location of file list node.
206 @return the file list node.*/
208 ut_ad(m_block->page.id.page_no() == addr.page);
209 return (buf_block_get_frame(m_block) + addr.boffset);
210 }
211
212 /** Load the file list node from the given location. An s-latch is taken
213 on the page containing the file list node.
214 @param[in] addr the location of file list node.
215 @return the file list node.*/
218 const page_size_t page_size = dict_table_page_size(m_index->table);
219 return (fut_get_ptr(space, page_size, addr, RW_S_LATCH, m_mtr));
220 }
221
222 /** Load the file list node from the given location. An s-latch is taken
223 on the page containing the file list node. The given cache is checked to
224 see if the page is already loaded.
225 @param[in] cache cache of loaded buffer blocks.
226 @param[in] addr the location of file list node.
227 @return the file list node.*/
228 flst_node_t *addr2ptr_s_cache(std::map<page_no_t, buf_block_t *> &cache,
229 fil_addr_t &addr) const {
230 byte *result;
232 const page_size_t page_size = dict_table_page_size(m_index->table);
233
234 auto iter = cache.find(addr.page);
235
236 if (iter == cache.end()) {
237 /* Not there in cached blocks. Add the loaded block to cache. */
238 buf_block_t *block = nullptr;
239 result = fut_get_ptr(space, page_size, addr, RW_S_LATCH, m_mtr, &block);
240 cache.insert(std::make_pair(addr.page, block));
241 } else {
242 buf_block_t *block = iter->second;
243 ut_ad(block->page.id.page_no() == addr.page);
244 result = buf_block_get_frame(block) + addr.boffset;
245 }
246 return (result);
247 }
248
249 /** Free the first page. This is done when all other LOB pages have
250 been freed. */
251 void dealloc();
252
253 /** Free all the pages associated with this LOB. */
254 void destroy();
255
256 /** Free all the pages associated with this LOB, except the first page. */
257 void make_empty();
258
259 /** Check if the index list is empty or not.
260 @return true if empty, false otherwise. */
261 bool is_empty() const {
263 ut_ad(base != nullptr);
264 return (flst_get_len(base) == 0);
265 }
266
267 /** Allocate one index entry. If required an index page (of type
268 FIL_PAGE_TYPE_LOB_INDEX) will be allocated.
269 @param[in] bulk true if it is a bulk operation
270 (OPCODE_INSERT_BULK), false otherwise.
271 @return the file list node of the index entry. */
272 flst_node_t *alloc_index_entry(bool bulk);
273
274 /** Get a pointer to the beginning of the index entry nodes in the
275 first part of the page.
276 @return the first index entry node. */
277 byte *nodes_begin() const { return (frame() + LOB_PAGE_DATA); }
278
279 /** Calculate and return the payload.
280 @return the payload possible in this page. */
281 static ulint payload() {
283 }
284
285 /** Set the transaction identifier in the first page header without
286 generating redo logs.
287 @param[in] id the transaction identifier. */
289 byte *ptr = frame() + OFFSET_TRX_ID;
290 mach_write_to_6(ptr, id);
291 }
292
293 /** Set the transaction identifier in the first page header.
294 @param[in] id the transaction identifier. */
296 byte *ptr = frame() + OFFSET_TRX_ID;
297 mach_write_to_6(ptr, id);
298 mlog_log_string(ptr, 6, m_mtr);
299 }
300
301 /** Initialize the LOB version to 1. */
303 ut_ad(m_mtr != nullptr);
304
306 }
307
308 /** Get the lob version number.
309 @return the lob version. */
310 uint32_t get_lob_version() {
312 }
313
314 /** Increment the lob version by 1. */
315 uint32_t incr_lob_version();
316
317 /** Set the last transaction identifier, without generating redo log
318 records.
319 @param[in] id the trx identifier. */
321 byte *ptr = frame() + OFFSET_LAST_TRX_ID;
322 mach_write_to_6(ptr, id);
323 }
324
325 /** Set the last transaction identifier.
326 @param[in] id the trx identifier. */
328 byte *ptr = frame() + OFFSET_LAST_TRX_ID;
329 mach_write_to_6(ptr, id);
330 mlog_log_string(ptr, 6, m_mtr);
331 }
332
333 /** Set the last transaction undo number.
334 @param[in] undo_no the trx undo number. */
336 ut_ad(m_mtr != nullptr);
337
338 byte *ptr = frame() + OFFSET_LAST_UNDO_NO;
339 mlog_write_ulint(ptr, undo_no, MLOG_4BYTES, m_mtr);
340 }
341
342 /** Get the last transaction identifier.
343 @return the transaction identifier. */
345 byte *ptr = frame() + OFFSET_LAST_TRX_ID;
346 return (mach_read_from_6(ptr));
347 }
348
349 /** Get the last transaction undo number.
350 @return the transaction undo number. */
352 byte *ptr = frame() + OFFSET_LAST_UNDO_NO;
353 return (mach_read_from_4(ptr));
354 }
355
356 /** Set the length of data stored in bytes.
357 @param[in] len amount of data stored in bytes. */
358 void set_data_len(ulint len) {
359 ut_ad(m_mtr != nullptr);
360
362 }
363
364 /** Write as much as possible of the given data into the page.
365 @param[in] trxid the current transaction.
366 @param[in] data the data to be written.
367 @param[in] len the length of the given data.
368 @return number of bytes actually written. */
369 ulint write(trx_id_t trxid, const byte *&data, ulint &len);
370
371 /** Replace data in the page by making a copy-on-write.
372 @param[in] trx Current transaction.
373 @param[in] offset Location where replace operation starts.
374 @param[in,out] ptr Buffer containing new data. after the call it will
375 point to remaining data.
376 @param[in,out] want Requested amount of data to be replaced. After the
377 call it will contain amount of data yet to be replaced.
378 @param[in] mtr Mini-transaction context.
379 @return the newly allocated buffer block.
380 @return nullptr if new page could not be allocated
381 (DB_OUT_OF_FILE_SPACE). */
382 buf_block_t *replace(trx_t *trx, ulint offset, const byte *&ptr, ulint &want,
383 mtr_t *mtr);
384
385 /** Replace data in the page inline.
386 @param[in] offset Location where replace operation starts.
387 @param[in,out] ptr Buffer containing new data. after the
388 call it will point to remaining data.
389 @param[in,out] want Requested amount of data to be replaced.
390 after the call it will contain amount of
391 data yet to be replaced.
392 @param[in] mtr Mini-transaction context.*/
393 void replace_inline(ulint offset, const byte *&ptr, ulint &want, mtr_t *mtr);
394
397 }
398
399 /** Read data from the first page.
400 @param[in] offset the offset from where read starts.
401 @param[out] ptr the output buffer
402 @param[in] want number of bytes to read.
403 @return number of bytes read. */
404 ulint read(ulint offset, byte *ptr, ulint want);
405
407 ut_ad(m_mtr != nullptr);
408
411 }
412
414
416 return (frame() + OFFSET_INDEX_FREE_NODES);
417 }
418
419 /** Get the number of bytes used to store LOB data in the first page
420 of uncompressed LOB.
421 @return Number of bytes available for LOB data. */
423 const ulint index_array_size = node_count() * index_entry_t::SIZE;
424
425 return (payload() - index_array_size);
426 }
427
428 /** Get the number of index entries this page can hold.
429 @return Number of index entries this page can hold. */
430 constexpr static ulint node_count() {
431 /* Each index entry is of size 60 bytes. We store only 10
432 index entries in the first page of the LOB. This means that
433 only 600 bytes are used for index data in the first page of
434 LOB. This will help to reserve more space in the first page
435 for the LOB data.*/
436 return (10);
437 }
438
439 std::ostream &print_index_entries(std::ostream &out) const;
440
441 std::ostream &print_index_entries_cache_s(std::ostream &out,
442 BlockCache &cache) const;
443
444 /** Obtain the location where the data begins.
445 @return pointer to location within page where data begins. */
446 byte *data_begin() const {
448
449 constexpr ulint index_array_size = node_count() * index_entry_t::SIZE;
450
451 return (frame() + LOB_PAGE_DATA + index_array_size);
452 }
453
454 /** Append data into a LOB first page. */
455 ulint append(trx_id_t trxid, byte *&data, ulint &len);
456
457#ifdef UNIV_DEBUG
458 /** Validate the first page. */
459 bool validate() const;
460#endif /* UNIV_DEBUG */
461
463
465 const page_id_t &page_id,
466 const page_size_t &page_size) {
467 mtr_t local_mtr;
468 mtr_start(&local_mtr);
469 first_page_t first(&local_mtr, index);
470 first.load_x(page_id, page_size);
471 page_type_t page_type = first.get_page_type();
472 mtr_commit(&local_mtr);
473 return (page_type);
474 }
475
476 public:
477 /** Restart the given mtr. The first page must already be x-latched by
478 the m_mtr.
479 @param[in] mtr Mini-transaction context which is to be restarted. */
480 void restart_mtr(mtr_t *mtr) {
481 ut_ad(mtr != m_mtr);
482 mtr_commit(mtr);
483 mtr_start(mtr);
485 load_x(mtr);
486 }
487};
488
489} /* namespace lob */
490
491#endif /* lob0first_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:50
The B-tree.
The database buffer pool high-level routines.
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:425
page_zip_des_t * buf_block_get_page_zip(buf_block_t *block) noexcept
Gets the compressed page descriptor corresponding to an uncompressed page if applicable.
Definition: buf0buf.h:2600
page_id_t id
Page id.
Definition: buf0buf.h:1319
Page identifier.
Definition: buf0types.h:206
page_no_t page_no() const
Retrieve the page number.
Definition: buf0types.h:242
Page size descriptor.
Definition: page0size.h:49
Data dictionary system.
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.
Fido Client Authentication nullptr
Definition: fido_client_plugin.cc:221
constexpr page_type_t FIL_PAGE_TYPE_LOB_FIRST
The first page of an uncompressed LOB.
Definition: fil0fil.h:1271
uint16_t page_type_t
Definition: fil0fil.h:1184
constexpr uint32_t FIL_PAGE_TYPE
file page type: FIL_PAGE_INDEX,..., 2 bytes.
Definition: fil0types.h:75
constexpr uint32_t FIL_PAGE_DATA
start of the data on the page
Definition: fil0types.h:110
constexpr uint32_t FIL_PAGE_DATA_END
size of the page trailer
Definition: fil0types.h:118
static byte * fut_get_ptr(space_id_t space, const page_size_t &page_size, fil_addr_t addr, rw_lock_type_t rw_latch, mtr_t *mtr, buf_block_t **ptr_block=nullptr)
Gets a pointer to a file address and latches the page.
File-based list utilities.
constexpr ulint FLST_BASE_NODE_SIZE
Definition: fut0lst.h:49
byte flst_base_node_t
Definition: fut0lst.h:45
static ulint flst_get_len(const flst_base_node_t *base)
Get the length of a list.
byte flst_node_t
Definition: fut0lst.h:46
static int flags[50]
Definition: hp_test1.cc:39
Implements the large objects (LOB) module.
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.
Mini-transaction logging routines.
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:341
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:255
#define mtr_commit(m)
Commit a mini-transaction.
Definition: mtr0mtr.h:58
#define mtr_memo_contains(m, o, t)
Check if memo contains the given item.
Definition: mtr0mtr.h:106
#define mtr_start(m)
Start a mini-transaction.
Definition: mtr0mtr.h:49
@ MLOG_4BYTES
4 bytes ...
Definition: mtr0types.h:75
@ MLOG_1BYTE
one byte is written
Definition: mtr0types.h:69
@ MLOG_2BYTES
2 bytes ...
Definition: mtr0types.h:72
@ MTR_MEMO_PAGE_X_FIX
Definition: mtr0types.h:272
Provides the large objects (LOB) module.
Definition: lob0del.h:31
std::map< page_no_t, buf_block_t * > BlockCache
Definition: lob0index.h:36
struct result result
Definition: result.h:33
The buffer control block structure.
Definition: buf0buf.h:1664
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:1670
Data structure for an index.
Definition: dict0mem.h:1021
dict_table_t * table
back pointer to table
Definition: dict0mem.h:1035
page_size_t get_page_size() const
Get the page size of the tablespace to which this index belongs.
Definition: dict0mem.cc:894
File space address.
Definition: fil0fil.h:1139
uint32_t boffset
Byte offset within the page.
Definition: fil0fil.h:1171
page_no_t page
Page number within a space.
Definition: fil0fil.h:1168
Definition: lob0util.h:41
mtr_t * m_mtr
Definition: lob0util.h:128
dict_index_t * m_index
Definition: lob0util.h:129
page_type_t get_page_type() const
Definition: lob0util.h:94
buf_block_t * m_block
Definition: lob0util.h:127
byte * frame() const
Definition: lob0util.h:98
The first page of an uncompressed LOB.
Definition: lob0first.h:42
flst_base_node_t * index_list() const
Definition: lob0first.h:413
void set_version_0()
Set the LOB format version number to 0.
Definition: lob0first.h:106
flst_node_t * addr2ptr_x(fil_addr_t &addr) const
Load the file list node from the given location.
Definition: lob0first.h:199
byte * data_begin() const
Obtain the location where the data begins.
Definition: lob0first.h:446
buf_block_t * load_x(const page_id_t &page_id, const page_size_t &page_size, mtr_t *mtr)
Load the first page of LOB with x-latch.
Definition: lob0first.cc:360
first_page_t(mtr_t *mtr, dict_index_t *index)
Constructor.
Definition: lob0first.h:102
static const ulint OFFSET_INDEX_LIST
The offset where the list base node is located.
Definition: lob0first.h:67
undo_no_t get_last_trx_undo_no() const
Get the last transaction undo number.
Definition: lob0first.h:351
static ulint max_space_available()
Get the number of bytes used to store LOB data in the first page of uncompressed LOB.
Definition: lob0first.h:422
void set_last_trx_id(trx_id_t id)
Set the last transaction identifier.
Definition: lob0first.h:327
buf_block_t * get_block()
Get the buffer block of the LOB first page.
Definition: lob0first.h:186
std::ostream & print_index_entries(std::ostream &out) const
Definition: lob0first.cc:163
static const ulint OFFSET_LAST_TRX_ID
The latest transaction that modified this LOB.
Definition: lob0first.h:54
uint32_t incr_lob_version()
Increment the lob version by 1.
Definition: lob0first.cc:391
void set_last_trx_id_no_redo(trx_id_t id)
Set the last transaction identifier, without generating redo log records.
Definition: lob0first.h:320
void dealloc()
Free the first page.
Definition: lob0first.cc:466
bool can_be_partially_updated()
When the bit is set, the LOB is not partially updatable anymore.
Definition: lob0first.h:118
void free_all_data_pages()
Free all the data pages.
Definition: lob0first.cc:281
buf_block_t * alloc(mtr_t *alloc_mtr, bool is_bulk)
Allocate the first page for uncompressed LOB.
Definition: lob0first.cc:219
first_page_t()=default
The default constructor.
void restart_mtr(mtr_t *mtr)
Restart the given mtr.
Definition: lob0first.h:480
ulint get_data_len() const
Definition: lob0first.h:395
page_type_t get_page_type()
Definition: lob0first.h:462
std::ostream & print_index_entries_cache_s(std::ostream &out, BlockCache &cache) const
Definition: lob0first.cc:123
flst_base_node_t * free_list() const
Definition: lob0first.h:415
byte * nodes_begin() const
Get a pointer to the beginning of the index entry nodes in the first part of the page.
Definition: lob0first.h:277
bool is_empty() const
Check if the index list is empty or not.
Definition: lob0first.h:261
ulint read(ulint offset, byte *ptr, ulint want)
Read data from the first page.
Definition: lob0first.cc:419
static const ulint LOB_PAGE_TRAILER_LEN
Definition: lob0first.h:78
static const ulint OFFSET_LAST_UNDO_NO
The latest transaction undo_no that modified this LOB.
Definition: lob0first.h:57
ulint append(trx_id_t trxid, byte *&data, ulint &len)
Append data into a LOB first page.
flst_node_t * alloc_index_entry(bool bulk)
Allocate one index entry.
Definition: lob0first.cc:263
static const ulint LOB_PAGE_DATA
The offset where the contents of the first page begins.
Definition: lob0first.h:75
void free_all_index_pages()
Free all the index pages.
Definition: lob0first.cc:324
buf_block_t * load_s(page_id_t page_id, page_size_t page_size)
Load the first page of LOB with s-latch.
Definition: lob0first.h:150
flst_node_t * addr2ptr(const fil_addr_t &addr)
Load the file list node from the given location, assuming that it exists in the first page itself.
Definition: lob0first.h:207
flst_node_t * addr2ptr_s_cache(std::map< page_no_t, buf_block_t * > &cache, fil_addr_t &addr) const
Load the file list node from the given location.
Definition: lob0first.h:228
void set_trx_id(trx_id_t id)
Set the transaction identifier in the first page header.
Definition: lob0first.h:295
static const ulint OFFSET_FLAGS
One byte of flag bits.
Definition: lob0first.h:48
buf_block_t * load_x(const page_id_t &page_id, const page_size_t &page_size)
Load the first page of LOB with x-latch.
Definition: lob0first.h:180
static const uint32_t OFFSET_LOB_VERSION
LOB version.
Definition: lob0first.h:51
void destroy()
Free all the pages associated with this LOB.
Definition: lob0first.cc:474
void replace_inline(ulint offset, const byte *&ptr, ulint &want, mtr_t *mtr)
Replace data in the page inline.
Definition: lob0first.cc:35
void set_trx_id_no_redo(trx_id_t id)
Set the transaction identifier in the first page header without generating redo logs.
Definition: lob0first.h:288
void set_last_trx_undo_no(undo_no_t undo_no)
Set the last transaction undo number.
Definition: lob0first.h:335
buf_block_t * load_x(mtr_t *mtr) const
Load the first page of LOB with x-latch in the given mtr context.
Definition: lob0first.h:168
static const ulint OFFSET_INDEX_FREE_NODES
The offset where the list base node is located.
Definition: lob0first.h:71
first_page_t(buf_block_t *block, mtr_t *mtr)
Constructor.
Definition: lob0first.h:86
first_page_t(buf_block_t *block, mtr_t *mtr, dict_index_t *index)
Constructor.
Definition: lob0first.h:96
uint8_t get_flags()
Obtain the flags value.
Definition: lob0first.h:113
static page_type_t get_page_type(dict_index_t *index, const page_id_t &page_id, const page_size_t &page_size)
Definition: lob0first.h:464
constexpr static ulint node_count()
Get the number of index entries this page can hold.
Definition: lob0first.h:430
buf_block_t * replace(trx_t *trx, ulint offset, const byte *&ptr, ulint &want, mtr_t *mtr)
Replace data in the page by making a copy-on-write.
Definition: lob0first.cc:59
ulint write(trx_id_t trxid, const byte *&data, ulint &len)
Write as much as possible of the given data into the page.
Definition: lob0first.cc:434
flst_node_t * addr2ptr_s(fil_addr_t &addr)
Load the file list node from the given location.
Definition: lob0first.h:216
void set_page_type()
Definition: lob0first.h:406
static const ulint OFFSET_TRX_ID
The trx that created the data stored in this page.
Definition: lob0first.h:63
flst_node_t * addr2ptr_x(const fil_addr_t &addr, mtr_t *mtr) const
Load the file list node from the given location.
Definition: lob0first.cc:484
void set_data_len(ulint len)
Set the length of data stored in bytes.
Definition: lob0first.h:358
uint32_t get_lob_version()
Get the lob version number.
Definition: lob0first.h:310
void make_empty()
Free all the pages associated with this LOB, except the first page.
Definition: lob0first.cc:479
trx_id_t get_last_trx_id() const
Get the last transaction identifier.
Definition: lob0first.h:344
static const ulint OFFSET_DATA_LEN
Length of data stored in this page.
Definition: lob0first.h:60
first_page_t(buf_block_t *block)
Constructor.
Definition: lob0first.h:90
static ulint payload()
Calculate and return the payload.
Definition: lob0first.h:281
static const ulint OFFSET_VERSION
Version information.
Definition: lob0first.h:44
void init_lob_version()
Initialize the LOB version to 1.
Definition: lob0first.h:302
bool validate() const
Validate the first page.
Definition: lob0first.cc:207
void mark_cannot_be_partially_updated(trx_t *trx)
When the bit is set, the LOB is not partially updatable anymore.
Definition: lob0first.cc:402
static const ulint SIZE
Total length of an index node.
Definition: lob0index.h:105
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:181
mtr_log_t set_log_mode(mtr_log_t mode)
Change the logging mode.
Definition: mtr0mtr.cc:470
mtr_log_t get_log_mode() const
Get the logging mode.
Definition: mtr0mtr.ic:175
Definition: result.h:29
Definition: trx0trx.h:680
@ RW_X_LATCH
Definition: sync0rw.h:95
@ RW_S_LATCH
Definition: sync0rw.h:94
ib_id_t undo_no_t
Undo number.
Definition: trx0types.h:141
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:137
#define UNIV_PAGE_SIZE
The universal page size of the database.
Definition: univ.i:295
unsigned long int ulint
Definition: univ.i:407
#define UT_LOCATION_HERE
Definition: ut0core.h:46
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:68