MySQL 8.0.31
Source Code Documentation
lob0index.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#ifndef lob0index_h
27#define lob0index_h
28
29#include "fut0lst.h"
30#include "lob0util.h"
31#include "trx0trx.h"
32#include "univ.i"
33
34namespace lob {
35
36typedef std::map<page_no_t, buf_block_t *> BlockCache;
37struct first_page_t;
38
39/** An in-memory copy of an index_entry_t data */
51
53
54 void reset();
55
56 bool is_null() { return (m_self.is_equal(fil_addr_null)); }
57
58 page_no_t get_page_no() const { return (m_page_no); }
59
60 /** Print this object into the given output stream.
61 @param[in] out the output stream.
62 @return the output stream. */
63 std::ostream &print(std::ostream &out) const;
64};
65
66/** List of index entry memory (iem) objects. */
67using List_iem_t = std::list<index_entry_mem_t>;
68
69/** Overloading the global output operator to print the index_entry_mem_t
70object.
71@param[in,out] out the output stream.
72@param[in] obj an object of type index_entry_mem_t
73@return the output stream. */
74inline std::ostream &operator<<(std::ostream &out,
75 const index_entry_mem_t &obj) {
76 return (obj.print(out));
77}
78
79/** An index entry pointing to an LOB page. */
81 /** Index entry offsets within node. */
82 static const ulint OFFSET_PREV = 0;
84
85 /** Points to base node of the list of versions. The size of base node is
86 16 bytes. */
88
89 /** The creator trx id. */
91
92 /** The modifier trx id. */
95
96 /** The undo number of the modifier trx. */
100
101 /** The LOB version number. */
103
104 /** Total length of an index node. */
105 static const ulint SIZE = OFFSET_LOB_VERSION + 4;
106
107 /** Constructor.
108 @param[in] node the pointer where index entry is located. */
111
113 : m_node(node), m_mtr(mtr), m_index(nullptr), m_block(nullptr) {}
114
116 : m_node(node), m_mtr(mtr), m_index(index), m_block(nullptr) {}
117
118 index_entry_t(mtr_t *mtr, const dict_index_t *index)
119 : m_node(nullptr), m_mtr(mtr), m_index(index), m_block(nullptr) {}
120
121 /* Move the node pointer to a different place within the same page.
122 @param[in] addr new location of node pointer. */
123 void reset(fil_addr_t &addr) {
124 ut_ad(m_block->page.id.page_no() == addr.page);
125
127 }
128
129 /* Get the buffer block of the current index entry.
130 @return the buffer block of the current index entry.*/
131 buf_block_t *get_block() const { return (m_block); }
132
133 /* Reset the current object to point to a different node.
134 @param[in] node the new file list node. */
135 void reset(flst_node_t *node) { m_node = node; }
136
137 bool is_null() const {
138 const byte zero[SIZE] = {0x00};
139 return (m_node == nullptr || memcmp(m_node, zero, SIZE) == 0);
140 }
141
142 /** Initialize the object fully. */
143 void init() {
147 set_trx_id(0);
150 set_data_len(0);
151 }
152
153 /** Get the location of the current index entry. */
154 fil_addr_t get_self() const;
155
156 /** The versions base node is set to NULL. */
158 ut_ad(m_mtr != nullptr);
159
160 byte *base_node = get_versions_ptr();
161 flst_init(base_node, m_mtr);
162 }
163
164 /** Determine if the current index entry be rolled back.
165 @param[in] trxid the transaction that is being purged.
166 @param[in] undo_no the undo number of trx.
167 @return true if this entry can be rolled back, false otherwise. */
168 bool can_rollback(trx_id_t trxid, undo_no_t undo_no) {
169 /* For rollback, make use of creator trx id. */
170 return ((trxid == get_trx_id()) && (get_trx_undo_no() >= undo_no));
171 }
172
173 /** Determine if the current index entry be purged.
174 @param[in] trxid the transaction that is being purged.
175 @param[in] undo_no the undo number of trx.
176 @return true if this entry can be purged, false otherwise. */
177 bool can_be_purged(trx_id_t trxid, undo_no_t undo_no) {
178 return ((trxid == get_trx_id_modifier()) &&
179 (get_trx_undo_no_modifier() == undo_no));
180 }
181
182 /* The given entry becomes the old version of the current entry.
183 Move the version base node from old entry to current entry.
184 @param[in] entry the old entry */
186 flst_node_t *node = entry.get_node_ptr();
187 flst_base_node_t *version_list = get_versions_ptr();
188 ut_ad(flst_get_len(version_list) == 0);
189
190 entry.move_version_base_node(*this);
191 flst_add_first(version_list, node, m_mtr);
192 }
193
194 /** The current index entry points to a latest LOB page. It may or
195 may not have older versions. If older version is there, bring it
196 back to the index list from the versions list. Then remove the
197 current entry from the index list. Move the versions list from
198 current entry to older entry.
199 @param[in] index the clustered index containing the LOB.
200 @param[in] first_page The first lob page containing index
201 list and free list.
202 @return the location of next entry. */
204 first_page_t &first_page);
205
206 /** Purge the current entry.
207 @param[in] index the clustered index containing the LOB.
208 @param[in] lst the base node of index list.
209 @param[in] free_list the base node of free list.
210 @return the location of the next entry. */
213
215 flst_node_t *node = entry.get_node_ptr();
216 flst_base_node_t *version_list = get_versions_ptr();
217 flst_add_first(version_list, node, m_mtr);
218 }
219
221
222 /** Add this node as the last node in the given list.
223 @param[in] bnode the base node of the file list. */
225 flst_add_last(bnode, m_node, m_mtr);
226 }
227
228 /** Get the base node of the list of versions. */
231 return (flst_bnode_t(node, m_mtr));
232 }
233
235 byte *ptr = get_trxid_ptr();
236 return (mach_read_from_6(ptr));
237 }
238
240 byte *ptr = get_trxid_modifier_ptr();
241 return (mach_read_from_6(ptr));
242 }
243
245 byte *ptr = get_trx_undo_no_ptr();
246 return (mach_read_from_4(ptr));
247 }
248
249 uint32_t get_lob_version() const {
250 byte *ptr = get_lob_version_ptr();
251 return (mach_read_from_4(ptr));
252 }
253
254 /** Get the undo number of the modifier trx.
255 @return the undo number of the modifier trx. */
257 byte *ptr = get_trx_undo_no_modifier_ptr();
258 return (mach_read_from_4(ptr));
259 }
260
262 ut_ad(m_node != nullptr);
263
265 }
266
267 /** Make the current index entry object to point to the next index
268 entry object.
269 @return the buffer block in which the next index entry is available.*/
271 fil_addr_t node_loc = get_next();
272
273 if (node_loc.is_null()) {
274 return (nullptr);
275 }
276
277 if (m_block == nullptr || m_block->page.id.page_no() != node_loc.page) {
278 load_x(node_loc);
279 } else {
280 /* Next entry in the same page. */
281 reset(node_loc);
282 }
283
284 return (m_block);
285 }
286
287 /** Get the previous index entry.
288 @return The file address of previous index entry. */
291 }
292
293 /** Write the trx identifier to the index entry. No redo log
294 is generated for this modification. This is meant to be used
295 during tablespace import.
296 @param[in] id the trx identifier.*/
298 byte *ptr = get_trxid_ptr();
299 mach_write_to_6(ptr, id);
300 }
301
302 /** Write the modifier trx identifier to the index entry. No redo log
303 is generated for this modification. This is meant to be used
304 during tablespace import.
305 @param[in] id the trx identifier.*/
307 byte *ptr = get_trxid_modifier_ptr();
308 mach_write_to_6(ptr, id);
309 }
310
312 byte *ptr = get_trxid_ptr();
313 mach_write_to_6(ptr, id);
314 mlog_log_string(ptr, 6, m_mtr);
315 }
316
318 ut_ad(m_mtr != nullptr);
319
320 byte *ptr = get_trxid_modifier_ptr();
321 mach_write_to_6(ptr, id);
322 mlog_log_string(ptr, 6, m_mtr);
323 }
324
326 byte *ptr = get_trx_undo_no_ptr();
327 mlog_write_ulint(ptr, undo_no, MLOG_4BYTES, m_mtr);
328 }
329
330 /** Set the LOB version of this entry.
331 @param[in] version the LOB version number. */
332 void set_lob_version(uint32_t version) {
333 byte *ptr = get_lob_version_ptr();
335 }
336
338 ut_ad(m_mtr != nullptr);
339
340 byte *ptr = get_trx_undo_no_modifier_ptr();
341 mlog_write_ulint(ptr, undo_no, MLOG_4BYTES, m_mtr);
342 }
343
345 ut_ad(num > 0);
346 byte *ptr = get_pageno_ptr();
347 return (mlog_write_ulint(ptr, num, MLOG_4BYTES, m_mtr));
348 }
349
352 }
353
356 }
357
359 byte *ptr = get_pageno_ptr();
360 return (mach_read_from_4(ptr));
361 }
362
363 void set_data_len(ulint len) {
364 byte *ptr = get_datalen_ptr();
365 return (mlog_write_ulint(ptr, len, MLOG_2BYTES, m_mtr));
366 }
367
369 byte *ptr = get_datalen_ptr();
370 return (mach_read_from_2(ptr));
371 }
372
373 std::ostream &print(std::ostream &out) const;
374
375 bool is_same(const index_entry_t &that) { return (m_node == that.m_node); }
376
377 void read(index_entry_mem_t &entry_mem) const;
378
379 /** Load the index entry available in the given file address.
380 Take x-latch on the index page.
381 @param[in] addr the file address of the index entry.
382 @return the buffer block containing the index entry. */
383 buf_block_t *load_x(const fil_addr_t &addr);
384
385 /** Load the index entry available in the given file address.
386 Take s-latch on the index page.
387 @param[in] addr the file location of index entry.
388 @return the buffer block. */
389 buf_block_t *load_s(const fil_addr_t &addr);
390
392 flst_insert_after(base, m_node, entry.get_node(), m_mtr);
393 }
394
396 flst_insert_before(base, entry.get_node(), m_node, m_mtr);
397 }
398
399 void remove(flst_base_node_t *bnode) { flst_remove(bnode, m_node, m_mtr); }
400
401 /** Free the data page pointed to by this index entry. The data page is
402 available at offset OFFSET_PAGE_NO. After the page is freed, mark it as
403 FIL_NULL. No other fields are modified. If the index entry points to the
404 first page number of the LOB or if it is FIL_NULL, then this function is a
405 no-op.
406 @param[in] first_page_no the first page number of the LOB. */
407 void free_data_page(const page_no_t first_page_no);
408
409 private:
410 /** Move the version base node from current entry to the given entry.
411 @param[in] to_entry The index entry to which the version
412 base node is moved to.*/
414
415 /** Purge the current index entry. An index entry points to either a
416 FIRST page or DATA page. That LOB page will be freed if it is DATA
417 page. A FIRST page should not be freed. */
418 void purge(dict_index_t *index);
419
420 byte *get_versions_ptr() const { return (m_node + OFFSET_VERSIONS); }
421
422 byte *get_trxid_ptr() const { return (m_node + OFFSET_TRXID); }
423
425 return (m_node + OFFSET_TRXID_MODIFIER);
426 }
427
428 byte *get_trx_undo_no_ptr() const { return (m_node + OFFSET_TRX_UNDO_NO); }
429
430 byte *get_lob_version_ptr() const { return (m_node + OFFSET_LOB_VERSION); }
431
434 }
435
436 byte *get_pageno_ptr() const { return (m_node + OFFSET_PAGE_NO); }
437
438 byte *get_datalen_ptr() const { return (m_node + OFFSET_DATA_LEN); }
439
440 byte *get_node_ptr() const { return (m_node); }
441
442 byte *get_node() const { return (m_node); }
443
444 private:
445 byte *m_node;
449};
450
451/** Overloading the global output operator to easily print an index entry.
452@param[in] out the output stream.
453@param[in] obj the index entry.
454@return the output stream. */
455inline std::ostream &operator<<(std::ostream &out, const index_entry_t &obj) {
456 return (obj.print(out));
457}
458
459} /* namespace lob */
460
461#endif /* lob0index_h */
uint32_t page_no_t
Page number.
Definition: api0api.h:48
static buf_frame_t * buf_block_get_frame(const buf_block_t *block)
Gets a pointer to the memory frame of a block.
page_id_t id
Page id.
Definition: buf0buf.h:1319
page_no_t page_no() const
Retrieve the page number.
Definition: buf0types.h:242
Fido Client Authentication nullptr
Definition: fido_client_plugin.cc:221
fil_addr_t fil_addr_null
The null file address.
Definition: fil0fil.cc:331
constexpr page_no_t FIL_NULL
'null' (undefined) page offset in the context of file spaces
Definition: fil0fil.h:1122
constexpr size_t FIL_ADDR_SIZE
Address size is 6 bytes.
Definition: fil0types.h:127
void flst_add_last(flst_base_node_t *base, flst_node_t *node, mtr_t *mtr)
Adds a node as the last node in a list.
Definition: fut0lst.cc:89
void flst_remove(flst_base_node_t *base, flst_node_t *node2, mtr_t *mtr)
Removes a node.
Definition: fut0lst.cc:286
void flst_add_first(flst_base_node_t *base, flst_node_t *node, mtr_t *mtr)
Adds a node as the first node in a list.
Definition: fut0lst.cc:132
void flst_insert_after(flst_base_node_t *base, flst_node_t *node1, flst_node_t *node2, mtr_t *mtr)
Inserts a node after another in a list.
Definition: fut0lst.cc:171
void flst_insert_before(flst_base_node_t *base, flst_node_t *node2, flst_node_t *node3, mtr_t *mtr)
Inserts a node before another in a list.
Definition: fut0lst.cc:227
File-based list utilities.
constexpr ulint FLST_BASE_NODE_SIZE
Definition: fut0lst.h:49
static void flst_write_addr(fil_faddr_t *faddr, fil_addr_t addr, mtr_t *mtr)
Writes a file address.
byte flst_base_node_t
Definition: fut0lst.h:45
static fil_addr_t flst_read_addr(const fil_faddr_t *faddr, mtr_t *mtr)
Reads a file address.
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:46
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 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: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
@ MLOG_4BYTES
4 bytes ...
Definition: mtr0types.h:75
@ MLOG_2BYTES
2 bytes ...
Definition: mtr0types.h:72
Provides the large objects (LOB) module.
Definition: lob0del.h:31
std::list< index_entry_mem_t > List_iem_t
List of index entry memory (iem) objects.
Definition: lob0index.h:67
std::map< page_no_t, buf_block_t * > BlockCache
Definition: lob0index.h:36
std::ostream & operator<<(std::ostream &out, const plist_node_t &obj)
Definition: lob0impl.h:238
required uint64 version
Definition: replication_group_member_actions.proto:40
void free_list(I_List< i_string > *list)
Definition: sql_list.cc:30
Definition: completion_hash.h:34
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
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
bool is_equal(const fil_addr_t &rhs) const
Compare to instances.
Definition: fil0fil.h:1151
bool is_null() const
Check if the file address is null.
Definition: fil0fil.h:1157
In-memory representation of flst_base_node_t.
Definition: fut0lst.h:147
The first page of an uncompressed LOB.
Definition: lob0first.h:42
An in-memory copy of an index_entry_t data.
Definition: lob0index.h:40
trx_id_t m_trx_id_modifier
Definition: lob0index.h:46
undo_no_t m_undo_no
Definition: lob0index.h:47
undo_no_t m_undo_no_modifier
Definition: lob0index.h:48
flst_bnode_t m_versions
Definition: lob0index.h:44
fil_addr_t m_next
Definition: lob0index.h:43
fil_addr_t m_prev
Definition: lob0index.h:42
bool is_null()
Definition: lob0index.h:56
trx_id_t m_trx_id
Definition: lob0index.h:45
index_entry_mem_t()
Definition: lob0index.h:52
fil_addr_t m_self
Definition: lob0index.h:41
void reset()
Definition: lob0index.cc:207
page_no_t get_page_no() const
Definition: lob0index.h:58
std::ostream & print(std::ostream &out) const
Print this object into the given output stream.
Definition: lob0index.cc:223
ulint m_data_len
Definition: lob0index.h:50
page_no_t m_page_no
Definition: lob0index.h:49
An index entry pointing to an LOB page.
Definition: lob0index.h:80
void free_data_page(const page_no_t first_page_no)
Free the data page pointed to by this index entry.
Definition: lob0index.cc:234
void reset(flst_node_t *node)
Definition: lob0index.h:135
void insert_after(flst_base_node_t *base, index_entry_t &entry)
Definition: lob0index.h:391
ulint get_data_len() const
Definition: lob0index.h:368
void set_versions_null()
The versions base node is set to NULL.
Definition: lob0index.h:157
static const ulint OFFSET_PAGE_NO
Definition: lob0index.h:98
bool is_same(const index_entry_t &that)
Definition: lob0index.h:375
byte * get_lob_version_ptr() const
Definition: lob0index.h:430
void set_next_null()
Definition: lob0index.h:354
fil_addr_t get_self() const
Get the location of the current index entry.
Definition: lob0index.cc:143
void read(index_entry_mem_t &entry_mem) const
Definition: lob0index.cc:155
fil_addr_t get_next() const
Definition: lob0index.h:261
buf_block_t * m_block
Definition: lob0index.h:448
page_no_t get_page_no() const
Definition: lob0index.h:358
uint32_t get_lob_version() const
Definition: lob0index.h:249
index_entry_t(flst_node_t *node, mtr_t *mtr)
Definition: lob0index.h:112
static const ulint OFFSET_PREV
Index entry offsets within node.
Definition: lob0index.h:82
void push_back(flst_base_node_t *bnode)
Add this node as the last node in the given list.
Definition: lob0index.h:224
mtr_t * m_mtr
Definition: lob0index.h:446
void reset(fil_addr_t &addr)
Definition: lob0index.h:123
void set_prev_null()
Definition: lob0index.h:350
static const ulint OFFSET_NEXT
Definition: lob0index.h:83
static const ulint OFFSET_LOB_VERSION
The LOB version number.
Definition: lob0index.h:102
byte * get_node() const
Definition: lob0index.h:442
byte * get_trx_undo_no_ptr() const
Definition: lob0index.h:428
flst_bnode_t get_versions_mem() const
Get the base node of the list of versions.
Definition: lob0index.h:229
fil_addr_t make_old_version_current(dict_index_t *index, first_page_t &first_page)
The current index entry points to a latest LOB page.
Definition: lob0index.cc:46
void set_trx_id(trx_id_t id)
Definition: lob0index.h:311
byte * get_trx_undo_no_modifier_ptr() const
Definition: lob0index.h:432
void set_old_version(index_entry_t &entry)
Definition: lob0index.h:185
byte * get_trxid_modifier_ptr() const
Definition: lob0index.h:424
void add_version(index_entry_t &entry) const
Definition: lob0index.h:214
void set_trx_id_modifier(trx_id_t id)
Definition: lob0index.h:317
void set_trx_undo_no_modifier(undo_no_t undo_no)
Definition: lob0index.h:337
buf_block_t * get_block() const
Definition: lob0index.h:131
void set_trx_undo_no(undo_no_t undo_no)
Definition: lob0index.h:325
void move_version_base_node(index_entry_t &to_entry)
Move the version base node from current entry to the given entry.
Definition: lob0index.cc:38
void init()
Initialize the object fully.
Definition: lob0index.h:143
void purge(dict_index_t *index)
Purge the current index entry.
Definition: lob0index.cc:82
byte * get_pageno_ptr() const
Definition: lob0index.h:436
void set_trx_id_modifier_no_redo(trx_id_t id)
Write the modifier trx identifier to the index entry.
Definition: lob0index.h:306
buf_block_t * load_s(const fil_addr_t &addr)
Load the index entry available in the given file address.
Definition: lob0index.cc:194
fil_addr_t get_prev() const
Get the previous index entry.
Definition: lob0index.h:289
static const ulint OFFSET_VERSIONS
Points to base node of the list of versions.
Definition: lob0index.h:87
void set_page_no(page_no_t num)
Definition: lob0index.h:344
void remove(flst_base_node_t *bnode)
Definition: lob0index.h:399
flst_base_node_t * get_versions_list() const
Definition: lob0index.h:220
void set_trx_id_no_redo(trx_id_t id)
Write the trx identifier to the index entry.
Definition: lob0index.h:297
index_entry_t(flst_node_t *node)
Constructor.
Definition: lob0index.h:109
index_entry_t(flst_node_t *node, mtr_t *mtr, dict_index_t *index)
Definition: lob0index.h:115
static const ulint OFFSET_TRX_UNDO_NO_MODIFIER
The undo number of the modifier trx.
Definition: lob0index.h:97
bool can_rollback(trx_id_t trxid, undo_no_t undo_no)
Determine if the current index entry be rolled back.
Definition: lob0index.h:168
static const ulint OFFSET_TRXID_MODIFIER
The modifier trx id.
Definition: lob0index.h:93
void insert_before(flst_base_node_t *base, index_entry_t &entry)
Definition: lob0index.h:395
static const ulint OFFSET_TRX_UNDO_NO
Definition: lob0index.h:94
buf_block_t * load_x(const fil_addr_t &addr)
Load the index entry available in the given file address.
Definition: lob0index.cc:177
undo_no_t get_trx_undo_no_modifier() const
Get the undo number of the modifier trx.
Definition: lob0index.h:256
const dict_index_t * m_index
Definition: lob0index.h:447
fil_addr_t purge_version(dict_index_t *index, flst_base_node_t *lst, flst_base_node_t *free_list)
Purge the current entry.
Definition: lob0index.cc:110
buf_block_t * next()
Make the current index entry object to point to the next index entry object.
Definition: lob0index.h:270
static const ulint SIZE
Total length of an index node.
Definition: lob0index.h:105
undo_no_t get_trx_undo_no() const
Definition: lob0index.h:244
static const ulint OFFSET_DATA_LEN
Definition: lob0index.h:99
byte * m_node
Definition: lob0index.h:445
static const ulint OFFSET_TRXID
The creator trx id.
Definition: lob0index.h:90
void set_lob_version(uint32_t version)
Set the LOB version of this entry.
Definition: lob0index.h:332
byte * get_node_ptr() const
Definition: lob0index.h:440
bool is_null() const
Definition: lob0index.h:137
byte * get_versions_ptr() const
Definition: lob0index.h:420
byte * get_datalen_ptr() const
Definition: lob0index.h:438
index_entry_t(mtr_t *mtr, const dict_index_t *index)
Definition: lob0index.h:118
std::ostream & print(std::ostream &out) const
Definition: lob0index.cc:129
trx_id_t get_trx_id() const
Definition: lob0index.h:234
bool can_be_purged(trx_id_t trxid, undo_no_t undo_no)
Determine if the current index entry be purged.
Definition: lob0index.h:177
trx_id_t get_trx_id_modifier() const
Definition: lob0index.h:239
byte * get_trxid_ptr() const
Definition: lob0index.h:422
void set_data_len(ulint len)
Definition: lob0index.h:363
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:181
The transaction.
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
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:407
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:68