MySQL 9.0.0
Source Code Documentation
trx0types.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1996, 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
28/** @file include/trx0types.h
29 Transaction system global type definitions
30
31 Created 3/26/1996 Heikki Tuuri
32 *******************************************************/
33
34#ifndef trx0types_h
35#define trx0types_h
36
37#include "page0size.h"
38#include "sync0rw.h"
39#include "ut0byte.h"
40#include "ut0mutex.h"
41#include "ut0new.h"
42
43#include <atomic>
44#include <queue>
45#include <set>
46#include <vector>
47
48/** printf(3) format used for printing DB_TRX_ID and other system fields */
49#define TRX_ID_FMT IB_ID_FMT
50
51/** Space id of the transaction system page (the system tablespace) */
52static const space_id_t TRX_SYS_SPACE = 0;
53
54/** Page number of the transaction system page */
56
57/** Random value to check for corruption of trx_t */
58static const ulint TRX_MAGIC_N = 91118598;
59
60/** If this flag is set then the transaction cannot be rolled back
61asynchronously. */
62static const uint32_t TRX_FORCE_ROLLBACK_DISABLE = 1 << 29;
63
64/** Mark the transaction for forced rollback */
65static const uint32_t TRX_FORCE_ROLLBACK = 1U << 31;
66
67/** For masking out the above flags */
68static const uint32_t TRX_FORCE_ROLLBACK_MASK = 0x1FFFFFFF;
69
70/** Transaction execution states when trx->state == TRX_STATE_ACTIVE */
72 TRX_QUE_RUNNING, /*!< transaction is running */
73 TRX_QUE_LOCK_WAIT, /*!< transaction is waiting for
74 a lock */
75 TRX_QUE_ROLLING_BACK, /*!< transaction is rolling back */
76 TRX_QUE_COMMITTING /*!< transaction is committing */
77};
78
79/** Transaction states (trx_t::state) */
81
83
84 /** Same as not started but with additional semantics that it
85 was rolled back asynchronously the last time it was active. */
87
89
90 /** Support for 2PC/XA */
92
94};
95
96/** Type of data dictionary operation */
98 /** The transaction is not modifying the data dictionary. */
100 /** The transaction is creating a table or an index, or
101 dropping a table. The table must be dropped in crash
102 recovery. This and TRX_DICT_OP_NONE are the only possible
103 operation modes in crash recovery. */
105 /** The transaction is creating or dropping an index in an
106 existing table. In crash recovery, the data dictionary
107 must be locked, but the table must not be dropped. */
110
111/** Memory objects */
112/** @{ */
113/** Transaction */
114struct trx_t;
115/** The locks and state of an active transaction */
116struct trx_lock_t;
117/** Transaction system */
118struct trx_sys_t;
119/** Signal */
120struct trx_sig_t;
121/** Rollback segment */
122struct trx_rseg_t;
123/** Transaction undo log */
124struct trx_undo_t;
125/** The control structure used in the purge operation */
126struct trx_purge_t;
127/** Rollback command node in a query graph */
128struct roll_node_t;
129/** Commit command node in a query graph */
130struct commit_node_t;
131/** SAVEPOINT command node in a query graph */
132struct trx_named_savept_t;
133/** @} */
134
135/** Row identifier (DB_ROW_ID, DATA_ROW_ID) */
137/** Transaction identifier (DB_TRX_ID, DATA_TRX_ID) */
139/** Rollback pointer (DB_ROLL_PTR, DATA_ROLL_PTR) */
141/** Undo number */
143
144/** Maximum transaction identifier */
146
147/** Transaction savepoint */
149 undo_no_t least_undo_no; /*!< least undo number to undo */
150};
151
152/** File objects */
153/** @{ */
154/** Transaction system header */
155typedef byte trx_sysf_t;
156/** Rollback segment array header */
157typedef byte trx_rsegsf_t;
158/** Rollback segment header */
159typedef byte trx_rsegf_t;
160/** Undo segment header */
161typedef byte trx_usegf_t;
162/** Undo log header */
163typedef byte trx_ulogf_t;
164/** Undo log page header */
165typedef byte trx_upagef_t;
166/** Undo log record */
167typedef byte trx_undo_rec_t;
168/** @} */
169
170typedef ib_mutex_t RsegMutex;
171typedef ib_mutex_t TrxMutex;
172typedef ib_mutex_t UndoMutex;
173typedef ib_mutex_t PQMutex;
174typedef ib_mutex_t TrxSysMutex;
175
176/** The rollback segment memory object */
178#ifdef UNIV_DEBUG
179 /** Validate the curr_size member by re-calculating it.
180 @param[in] take_mutex take the rseg->mutex. default is true.
181 @return true if valid, false otherwise. */
182 bool validate_curr_size(bool take_mutex = true);
183#endif /* UNIV_DEBUG */
184
185 /** Enter the rseg->mutex. */
186 void latch() {
189 }
190
191 /** Exit the rseg->mutex. */
192 void unlatch() {
195 }
196
197 /** Decrement the current size of the rollback segment by the given number
198 of pages.
199 @param[in] npages number of pages to reduce in size. */
200 void decr_curr_size(page_no_t npages = 1) {
201 ut_ad(curr_size >= npages);
202 curr_size -= npages;
203 }
204
205 /** Increment the current size of the rollback segment by the given number
206 of pages. */
208
209 /* Get the current size of the rollback segment in pages.
210 @return current size of the rollback segment in pages. */
211 page_no_t get_curr_size() const { return (curr_size); }
212
213 /* Set the current size of the rollback segment in pages.
214 @param[in] npages new value for the current size. */
215 void set_curr_size(page_no_t npages) { curr_size = npages; }
216
217 /*--------------------------------------------------------*/
218 /** rollback segment id == the index of its slot in the trx
219 system file copy */
220 size_t id{};
221
222 /** mutex protecting the fields in this struct except id,space,page_no
223 which are constant */
225
226 /** space ID where the rollback segment header is placed */
228
229 /** page number of the rollback segment header */
231
232 /** page size of the relevant tablespace */
234
235 /** maximum allowed size in pages */
237
238 private:
239 /** current size in pages */
241
242 public:
244 /*--------------------------------------------------------*/
245 /* Fields for update undo logs */
246 /** List of update undo logs */
248
249 /** List of update undo log segments cached for fast reuse */
251
252 /*--------------------------------------------------------*/
253 /* Fields for insert undo logs */
254 /** List of insert undo logs */
256
257 /** List of insert undo log segments cached for fast reuse */
259
260 /*--------------------------------------------------------*/
261
262 /** Page number of the last not yet purged log header in the history
263 list; FIL_NULL if all list purged */
265
266 /** Byte offset of the last not yet purged log header */
267 size_t last_offset{};
268
269 /** Transaction number of the last not yet purged log */
271
272 /** true if the last not yet purged log needs purging */
274
275 /** Reference counter to track rseg allocated transactions. */
276 std::atomic<size_t> trx_ref_count{};
277
278 std::ostream &print(std::ostream &out) const {
279 out << "[trx_rseg_t: this=" << (void *)this << ", id=" << id
280 << ", space_id=" << space_id << ", page_no=" << page_no
281 << ", curr_size=" << curr_size << "]";
282 return (out);
283 }
284};
285
286inline std::ostream &operator<<(std::ostream &out, const trx_rseg_t &rseg) {
287 return (rseg.print(out));
288}
289
290using Rsegs_Vector = std::vector<trx_rseg_t *, ut::allocator<trx_rseg_t *>>;
291using Rseg_Iterator = Rsegs_Vector::iterator;
292
293/** This is a wrapper for a std::vector of trx_rseg_t object pointers. */
294class Rsegs {
295 public:
296 /** Default constructor */
298#ifndef UNIV_HOTBACKUP
299 init();
300#endif /* !UNIV_HOTBACKUP */
301 }
302
304#ifndef UNIV_HOTBACKUP
305 deinit();
306#endif /* !UNIV_HOTBACKUP */
307 }
308
309 /** Initialize */
310 void init();
311
312 /** De-initialize */
313 void deinit();
314
315 /** Clear the vector of cached rollback segments leaving the
316 reserved space allocated. */
317 void clear();
318
319 /** Add rollback segment.
320 @param[in] rseg rollback segment to add. */
321 void push_back(trx_rseg_t *rseg) { m_rsegs.push_back(rseg); }
322
323 /** Number of registered rsegs.
324 @return size of rseg list. */
325 ulint size() { return (m_rsegs.size()); }
326
327 /** beginning iterator
328 @return an iterator to the first element */
329 Rseg_Iterator begin() { return (m_rsegs.begin()); }
330
331 /** ending iterator
332 @return an iterator to the end */
333 Rseg_Iterator end() { return (m_rsegs.end()); }
334
335 /** Find the rseg at the given slot in this vector.
336 @param[in] slot a slot within the vector.
337 @return an iterator to the end */
338 trx_rseg_t *at(ulint slot) { return (m_rsegs.at(slot)); }
339
340 /** Find an rseg in the std::vector that uses the rseg_id given.
341 @param[in] rseg_id A slot in a durable array such as
342 the TRX_SYS page or RSEG_ARRAY page.
343 @return a pointer to an trx_rseg_t that uses the rseg_id. */
344 trx_rseg_t *find(ulint rseg_id);
345
346 /** Sort the vector on trx_rseg_t::id */
347 void sort() {
348 if (m_rsegs.empty()) {
349 return;
350 }
351
352 std::sort(
353 m_rsegs.begin(), m_rsegs.end(),
354 [](trx_rseg_t *lhs, trx_rseg_t *rhs) { return (rhs->id > lhs->id); });
355 }
356
357 /** Acquire the shared lock on m_rsegs. */
359
360 /** Release the shared lock on m_rsegs. */
362
363 /** Acquire the exclusive lock on m_rsegs. */
365
366 /** Release the exclusive lock on m_rsegs. */
368
369 /** Return whether the undo tablespace is active.
370 @return true if active */
371 bool is_active() { return (m_state == ACTIVE); }
372
373 /** Return whether the undo tablespace is inactive due to
374 implicit selection by the purge thread.
375 @return true if marked for truncation by the purge thread */
377
378 /** Return whether the undo tablespace was made inactive by
379 ALTER TABLESPACE.
380 @return true if altered */
382
383 /** Return whether the undo tablespace is empty and ready
384 to be dropped.
385 @return true if empty */
386 bool is_empty() { return (m_state == EMPTY); }
387
388 /** Return whether the undo tablespace is being initialized.
389 @return true if empty */
390 bool is_init() { return (m_state == INIT); }
391
392 /** Set the state of the rollback segments in this undo tablespace
393 to ACTIVE for use by new transactions. */
395
396 /** Set the state of the rollback segments in this undo
397 tablespace to inactive_implicit. This means that it will be
398 truncated and then made active again by the purge thread.
399 It will not be used for new transactions until it becomes
400 active again. */
404 }
405
406 /** Make the undo tablespace inactive so that it will not be
407 used for new transactions. The purge thread will clear out
408 all the undo logs, truncate it, and then mark it empty. */
410
411 /** Set the state of the undo tablespace to empty so that it
412 can be dropped. */
413 void set_empty() {
415 m_state == INIT || m_state == EMPTY);
416 m_state = EMPTY;
417 }
418
419 /** std::vector of rollback segments */
421
422 private:
423 /** RW lock to protect m_rsegs vector, m_active, and each
424 trx_rseg_t::trx_ref_count within it.
425 m_rsegs: x for adding elements, s for scanning, size etc.
426 m_active: x for modification, s for read
427 each trx_rseg_t::trx_ref_count within m_rsegs
428 s and atomic increment for modification, x for read */
430
431 /* The four states of an undo tablespace.
432 INIT: The initial state of an undo space that is being created or opened.
433 ACTIVE: The rollback segments in this tablespace can be allocated to new
434 transactions. The undo tablespace is ready for undo logs.
435 INACTIVE_IMPLICIT: These rollback segments are no longer being used by new
436 transactions. They are 'inactive'. The truncate process
437 is happening. This undo tablespace was selected by the
438 purge thread implicitly. When the truncation process
439 is complete, the next state is ACTIVE.
440 INACTIVE_EXPLICIT: These rollback segments are no longer being used by new
441 transactions. They are 'inactive'. The truncate process
442 is happening. This undo tablespace was selected by the
443 an ALTER UNDO TABLESPACE SET INACTIVE command. When the
444 truncation process is complete, the next state is EMPTY.
445 EMPTY: The undo tablespace has been truncated but is no longer
446 active. It is ready to be either dropped or set active
447 explicitly. This state is also used when the undo tablespace and
448 its rollback segments are being inititalized.
449
450 These states are changed under an exclusive lock on m_latch and are read
451 under a shared lock.
452
453 The following actions can cause changes in these states:
454 Init: Implicit undo spaces are created at startup.
455 Create: Explicit undo tablespace creation at runtime.
456 Mark: Purge thread implicitly selects an undo space to truncate.
457 SetInactive: This ALTER UNDO TABLESPACE causes an explicit truncation.
458 SetActive: This ALTER UNDO TABLESPACE changes the target state from
459 EMPTY to ACTIVE.
460 Truncate: The truncate process is completed by the purge thread.
461 Drop: Delete an EMPTY undo tablespace
462 Crash: A crash occurs
463 Fixup: At startup, if an undo space was being truncated with a crash.
464 SaveDDState: At startup, once the DD is available the state saved there
465 will be applied. INACTIVE_IMPLICIT is never saved to the DD.
466 So the DD state INACTIVE means INACTIVE_EXPLICIT.
467 See apply_dd_undo_state()
468
469 State changes allowed: (Actions on states not mentioned are not allowed.)
470 Init from null -> INIT -> ACTIVE see srv_start()
471 from null -> INIT -> EMPTY see trx_rsegs_init()
472 Create from null -> EMPTY -> ACTIVE
473 Mark from INACTIVE_EXPLICIT -> INACTIVE_EXPLICIT -> Truncate
474 from ACTIVE -> INACTIVE_IMPLICIT -> Truncate
475 SetInactive from ACTIVE -> INACTIVE_EXPLICIT -> Mark
476 from INACTIVE_IMPLICIT -> INACTIVE_EXPLICIT
477 from INACTIVE_EXPLICIT -> INACTIVE_EXPLICIT
478 from EMPTY -> EMPTY
479 SetActive from ACTIVE -> ACTIVE
480 from INACTIVE_IMPLICIT -> INACTIVE_IMPLICIT
481 from INACTIVE_EXPLICIT -> INACTIVE_IMPLICIT
482 from EMPTY -> ACTIVE
483 Truncate from INACTIVE_IMPLICIT -> ACTIVE
484 from INACTIVE_EXPLICIT -> EMPTY
485 Drop if ACTIVE -> error returned
486 if INACTIVE_IMPLICIT -> error returned
487 if INACTIVE_EXPLICIT -> error returned
488 from EMPTY -> null
489 Crash if ACTIVE, at startup: ACTIVE
490 if INACTIVE_IMPLICIT, at startup: Fixup
491 if INACTIVE_EXPLICIT, at startup: Fixup
492 if EMPTY, at startup: EMPTY
493 Fixup from INACTIVE_IMPLICIT before crash -> INACTIVE_IMPLICIT -> Mark
494 from INACTIVE_EXPLICIT before crash -> INACTIVE_IMPLICIT -> Mark
495 SaveDDState from ACTIVE before crash -> ACTIVE
496 from INACTIVE_IMPLICIT before crash -> ACTIVE
497 from INACTIVE_EXPLICIT before crash -> INACTIVE_EXPLICIT -> Mark
498 from EMPTY -> EMPTY
499 */
505 EMPTY
506 };
507
508 /** The current state of this undo tablespace. */
510};
511
512template <size_t N>
513using Rsegs_array = std::array<trx_rseg_t *, N>;
514
515/** Rollback segments from a given transaction with trx-no
516scheduled for purge. */
518 public:
519 explicit TrxUndoRsegs(trx_id_t trx_no) : m_trx_no(trx_no) {
520 for (auto &rseg : m_rsegs) {
521 rseg = nullptr;
522 }
523 }
524
525 /** Default constructor */
527
528 void set_trx_no(trx_id_t trx_no) { m_trx_no = trx_no; }
529
530 /** Get transaction number
531 @return trx_id_t - get transaction number. */
532 trx_id_t get_trx_no() const { return (m_trx_no); }
533
534 /** Add rollback segment.
535 @param rseg rollback segment to add. */
536 void insert(trx_rseg_t *rseg) {
537 for (size_t i = 0; i < m_rsegs_n; ++i) {
538 if (m_rsegs[i] == rseg) {
539 return;
540 }
541 }
542 ut_a(m_rsegs_n < 2);
543 m_rsegs[m_rsegs_n++] = rseg;
544 }
545
546 /** Number of registered rsegs.
547 @return size of rseg list. */
548 size_t size() const { return (m_rsegs_n); }
549
550 /**
551 @return an iterator to the first element */
552 typename Rsegs_array<2>::iterator begin() { return m_rsegs.begin(); }
553
554 /**
555 @return an iterator to the end */
557 return m_rsegs.begin() + m_rsegs_n;
558 }
559
560 /** Append rollback segments from referred instance to current
561 instance. */
562 void insert(const TrxUndoRsegs &append_from) {
563 ut_ad(get_trx_no() == append_from.get_trx_no());
564 for (size_t i = 0; i < append_from.m_rsegs_n; ++i) {
565 insert(append_from.m_rsegs[i]);
566 }
567 }
568
569 /** Compare two TrxUndoRsegs based on trx_no.
570 @param lhs first element to compare
571 @param rhs second element to compare
572 @return true if elem1 > elem2 else false.*/
573 bool operator()(const TrxUndoRsegs &lhs, const TrxUndoRsegs &rhs) {
574 return (lhs.m_trx_no > rhs.m_trx_no);
575 }
576
577 /** Compiler defined copy-constructor/assignment operator
578 should be fine given that there is no reference to a memory
579 object outside scope of class object.*/
580
581 private:
582 /** The rollback segments transaction number. */
584
585 size_t m_rsegs_n{};
586
587 /** Rollback segments of a transaction, scheduled for purge. */
589};
590
591typedef std::priority_queue<
592 TrxUndoRsegs, std::vector<TrxUndoRsegs, ut::allocator<TrxUndoRsegs>>,
595
596typedef std::vector<trx_id_t, ut::allocator<trx_id_t>> trx_ids_t;
597
599 TrxVersion(trx_t *trx);
600
602 uint64_t m_version;
603};
604
605typedef std::vector<TrxVersion, ut::allocator<TrxVersion>> hit_list_t;
606#endif /* trx0types_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:47
uint32_t page_no_t
Page number.
Definition: api0api.h:45
This is a wrapper for a std::vector of trx_rseg_t object pointers.
Definition: trx0types.h:294
~Rsegs()
Definition: trx0types.h:303
void set_empty()
Set the state of the undo tablespace to empty so that it can be dropped.
Definition: trx0types.h:413
void set_inactive_implicit()
Set the state of the rollback segments in this undo tablespace to inactive_implicit.
Definition: trx0types.h:401
rw_lock_t * m_latch
RW lock to protect m_rsegs vector, m_active, and each trx_rseg_t::trx_ref_count within it.
Definition: trx0types.h:429
trx_rseg_t * find(ulint rseg_id)
Find an rseg in the std::vector that uses the rseg_id given.
Definition: trx0rseg.cc:776
void clear()
Clear the vector of cached rollback segments leaving the reserved space allocated.
Definition: trx0rseg.cc:764
Rsegs_Vector m_rsegs
std::vector of rollback segments
Definition: trx0types.h:420
void push_back(trx_rseg_t *rseg)
Add rollback segment.
Definition: trx0types.h:321
void set_active()
Set the state of the rollback segments in this undo tablespace to ACTIVE for use by new transactions.
Definition: trx0types.h:394
void s_lock()
Acquire the shared lock on m_rsegs.
Definition: trx0types.h:358
bool is_empty()
Return whether the undo tablespace is empty and ready to be dropped.
Definition: trx0types.h:386
undo_space_states m_state
The current state of this undo tablespace.
Definition: trx0types.h:509
Rseg_Iterator end()
ending iterator
Definition: trx0types.h:333
Rsegs()
Default constructor.
Definition: trx0types.h:297
void sort()
Sort the vector on trx_rseg_t::id.
Definition: trx0types.h:347
bool is_init()
Return whether the undo tablespace is being initialized.
Definition: trx0types.h:390
bool is_inactive_implicit()
Return whether the undo tablespace is inactive due to implicit selection by the purge thread.
Definition: trx0types.h:376
bool is_inactive_explicit()
Return whether the undo tablespace was made inactive by ALTER TABLESPACE.
Definition: trx0types.h:381
ulint size()
Number of registered rsegs.
Definition: trx0types.h:325
void s_unlock()
Release the shared lock on m_rsegs.
Definition: trx0types.h:361
void set_inactive_explicit()
Make the undo tablespace inactive so that it will not be used for new transactions.
Definition: trx0types.h:409
bool is_active()
Return whether the undo tablespace is active.
Definition: trx0types.h:371
Rseg_Iterator begin()
beginning iterator
Definition: trx0types.h:329
void x_unlock()
Release the exclusive lock on m_rsegs.
Definition: trx0types.h:367
undo_space_states
Definition: trx0types.h:500
@ EMPTY
Definition: trx0types.h:505
@ INACTIVE_IMPLICIT
Definition: trx0types.h:503
@ INIT
Definition: trx0types.h:501
@ ACTIVE
Definition: trx0types.h:502
@ INACTIVE_EXPLICIT
Definition: trx0types.h:504
void deinit()
De-initialize.
Definition: trx0rseg.cc:754
void x_lock()
Acquire the exclusive lock on m_rsegs.
Definition: trx0types.h:364
trx_rseg_t * at(ulint slot)
Find the rseg at the given slot in this vector.
Definition: trx0types.h:338
void init()
Initialize.
Definition: trx0rseg.cc:744
Rollback segments from a given transaction with trx-no scheduled for purge.
Definition: trx0types.h:517
TrxUndoRsegs(trx_id_t trx_no)
Definition: trx0types.h:519
trx_id_t get_trx_no() const
Get transaction number.
Definition: trx0types.h:532
Rsegs_array< 2 > m_rsegs
Rollback segments of a transaction, scheduled for purge.
Definition: trx0types.h:588
size_t size() const
Number of registered rsegs.
Definition: trx0types.h:548
Rsegs_array< 2 >::iterator end()
Definition: trx0types.h:556
trx_id_t m_trx_no
Compiler defined copy-constructor/assignment operator should be fine given that there is no reference...
Definition: trx0types.h:583
size_t m_rsegs_n
Definition: trx0types.h:585
Rsegs_array< 2 >::iterator begin()
Definition: trx0types.h:552
bool operator()(const TrxUndoRsegs &lhs, const TrxUndoRsegs &rhs)
Compare two TrxUndoRsegs based on trx_no.
Definition: trx0types.h:573
void set_trx_no(trx_id_t trx_no)
Definition: trx0types.h:528
void insert(const TrxUndoRsegs &append_from)
Append rollback segments from referred instance to current instance.
Definition: trx0types.h:562
TrxUndoRsegs()
Default constructor.
Definition: trx0types.h:526
void insert(trx_rseg_t *rseg)
Add rollback segment.
Definition: trx0types.h:536
Page size descriptor.
Definition: page0size.h:50
constexpr uint32_t FSP_TRX_SYS_PAGE_NO
transaction system header, in tablespace 0
Definition: fsp0types.h:170
A class describing a page size.
Definition: trx0types.h:598
uint64_t m_version
Definition: trx0types.h:602
TrxVersion(trx_t *trx)
Constructor.
Definition: trx0trx.cc:97
trx_t * m_trx
Definition: trx0types.h:601
Commit command node in a query graph.
Definition: trx0trx.h:1346
Rollback command node in a query graph.
Definition: trx0roll.h:156
The structure used in the spin lock implementation of a read-write lock.
Definition: sync0rw.h:363
Latching protocol for trx_lock_t::que_state.
Definition: trx0trx.h:410
A savepoint set with SQL's "SAVEPOINT savepoint_id" command.
Definition: trx0roll.h:168
The control structure used in the purge operation.
Definition: trx0purge.h:986
The rollback segment memory object.
Definition: trx0types.h:177
std::ostream & print(std::ostream &out) const
Definition: trx0types.h:278
trx_id_t last_trx_no
Transaction number of the last not yet purged log.
Definition: trx0types.h:270
Undo_list insert_undo_list
List of insert undo logs.
Definition: trx0types.h:255
size_t last_offset
Byte offset of the last not yet purged log header.
Definition: trx0types.h:267
bool last_del_marks
true if the last not yet purged log needs purging
Definition: trx0types.h:273
page_no_t get_curr_size() const
Definition: trx0types.h:211
void set_curr_size(page_no_t npages)
Definition: trx0types.h:215
RsegMutex mutex
mutex protecting the fields in this struct except id,space,page_no which are constant
Definition: trx0types.h:224
space_id_t space_id
space ID where the rollback segment header is placed
Definition: trx0types.h:227
void decr_curr_size(page_no_t npages=1)
Decrement the current size of the rollback segment by the given number of pages.
Definition: trx0types.h:200
page_no_t curr_size
current size in pages
Definition: trx0types.h:240
page_no_t page_no
page number of the rollback segment header
Definition: trx0types.h:230
page_size_t page_size
page size of the relevant tablespace
Definition: trx0types.h:233
Undo_list update_undo_cached
List of update undo log segments cached for fast reuse.
Definition: trx0types.h:250
std::atomic< size_t > trx_ref_count
Reference counter to track rseg allocated transactions.
Definition: trx0types.h:276
page_no_t max_size
maximum allowed size in pages
Definition: trx0types.h:236
void incr_curr_size()
Increment the current size of the rollback segment by the given number of pages.
Definition: trx0types.h:207
bool validate_curr_size(bool take_mutex=true)
Validate the curr_size member by re-calculating it.
Definition: trx0rseg.cc:1171
page_no_t last_page_no
Page number of the last not yet purged log header in the history list; FIL_NULL if all list purged.
Definition: trx0types.h:264
UT_LIST_BASE_NODE_T_EXTERN(trx_undo_t, undo_list) Undo_list
Definition: trx0types.h:243
Undo_list update_undo_list
List of update undo logs.
Definition: trx0types.h:247
Undo_list insert_undo_cached
List of insert undo log segments cached for fast reuse.
Definition: trx0types.h:258
void unlatch()
Exit the rseg->mutex.
Definition: trx0types.h:192
void latch()
Enter the rseg->mutex.
Definition: trx0types.h:186
Transaction savepoint.
Definition: trx0types.h:148
undo_no_t least_undo_no
least undo number to undo
Definition: trx0types.h:149
The transaction system central memory data structure.
Definition: trx0sys.h:453
Definition: trx0trx.h:684
Transaction undo log memory object; this is protected by the undo_mutex in the corresponding transact...
Definition: trx0undo.h:339
The read-write lock (for threads, not for database transactions)
static void rw_lock_s_unlock(rw_lock_t *L)
Definition: sync0rw.h:808
static void rw_lock_x_lock(rw_lock_t *M, ut::Location L)
Definition: sync0rw.h:782
static void rw_lock_s_lock(rw_lock_t *M, ut::Location L)
Definition: sync0rw.h:731
static void rw_lock_x_unlock(rw_lock_t *L)
Definition: sync0rw.h:811
static const uint32_t TRX_FORCE_ROLLBACK_MASK
For masking out the above flags.
Definition: trx0types.h:68
ib_mutex_t TrxMutex
Definition: trx0types.h:171
std::vector< trx_rseg_t *, ut::allocator< trx_rseg_t * > > Rsegs_Vector
Definition: trx0types.h:290
byte trx_undo_rec_t
Undo log record.
Definition: trx0types.h:167
Rsegs_Vector::iterator Rseg_Iterator
Definition: trx0types.h:291
trx_state_t
Transaction states (trx_t::state)
Definition: trx0types.h:80
@ TRX_STATE_FORCED_ROLLBACK
Same as not started but with additional semantics that it was rolled back asynchronously the last tim...
Definition: trx0types.h:86
@ TRX_STATE_ACTIVE
Definition: trx0types.h:88
@ TRX_STATE_COMMITTED_IN_MEMORY
Definition: trx0types.h:93
@ TRX_STATE_NOT_STARTED
Definition: trx0types.h:82
@ TRX_STATE_PREPARED
Support for 2PC/XA.
Definition: trx0types.h:91
constexpr trx_id_t TRX_ID_MAX
Maximum transaction identifier.
Definition: trx0types.h:145
static const ulint TRX_MAGIC_N
Random value to check for corruption of trx_t.
Definition: trx0types.h:58
trx_que_t
Transaction execution states when trx->state == TRX_STATE_ACTIVE.
Definition: trx0types.h:71
@ TRX_QUE_LOCK_WAIT
transaction is waiting for a lock
Definition: trx0types.h:73
@ TRX_QUE_RUNNING
transaction is running
Definition: trx0types.h:72
@ TRX_QUE_COMMITTING
transaction is committing
Definition: trx0types.h:76
@ TRX_QUE_ROLLING_BACK
transaction is rolling back
Definition: trx0types.h:75
std::priority_queue< TrxUndoRsegs, std::vector< TrxUndoRsegs, ut::allocator< TrxUndoRsegs > >, TrxUndoRsegs > purge_pq_t
Definition: trx0types.h:594
std::vector< trx_id_t, ut::allocator< trx_id_t > > trx_ids_t
Definition: trx0types.h:596
ib_id_t row_id_t
Row identifier (DB_ROW_ID, DATA_ROW_ID)
Definition: trx0types.h:132
ib_id_t undo_no_t
Undo number.
Definition: trx0types.h:142
byte trx_upagef_t
Undo log page header.
Definition: trx0types.h:165
byte trx_usegf_t
Undo segment header.
Definition: trx0types.h:161
std::ostream & operator<<(std::ostream &out, const trx_rseg_t &rseg)
Definition: trx0types.h:286
byte trx_rsegsf_t
Rollback segment array header.
Definition: trx0types.h:157
static const uint32_t TRX_FORCE_ROLLBACK
Mark the transaction for forced rollback.
Definition: trx0types.h:65
byte trx_ulogf_t
Undo log header.
Definition: trx0types.h:163
std::array< trx_rseg_t *, N > Rsegs_array
Definition: trx0types.h:513
ib_mutex_t PQMutex
Definition: trx0types.h:173
byte trx_rsegf_t
Rollback segment header.
Definition: trx0types.h:159
ib_mutex_t RsegMutex
Definition: trx0types.h:170
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:138
constexpr uint32_t TRX_SYS_PAGE_NO
Page number of the transaction system page.
Definition: trx0types.h:55
byte trx_sysf_t
File objects.
Definition: trx0types.h:155
static const uint32_t TRX_FORCE_ROLLBACK_DISABLE
If this flag is set then the transaction cannot be rolled back asynchronously.
Definition: trx0types.h:62
ib_mutex_t UndoMutex
Definition: trx0types.h:172
std::vector< TrxVersion, ut::allocator< TrxVersion > > hit_list_t
Definition: trx0types.h:605
static const space_id_t TRX_SYS_SPACE
Space id of the transaction system page (the system tablespace)
Definition: trx0types.h:52
ib_id_t roll_ptr_t
Rollback pointer (DB_ROLL_PTR, DATA_ROLL_PTR)
Definition: trx0types.h:140
ib_mutex_t TrxSysMutex
Definition: trx0types.h:174
trx_dict_op_t
Type of data dictionary operation.
Definition: trx0types.h:97
@ TRX_DICT_OP_TABLE
The transaction is creating a table or an index, or dropping a table.
Definition: trx0types.h:104
@ TRX_DICT_OP_NONE
The transaction is not modifying the data dictionary.
Definition: trx0types.h:99
@ TRX_DICT_OP_INDEX
The transaction is creating or dropping an index in an existing table.
Definition: trx0types.h:108
uint64_t ib_id_t
The generic InnoDB system object identifier data type.
Definition: univ.i:443
unsigned long int ulint
Definition: univ.i:406
constexpr ib_id_t IB_ID_MAX
Definition: univ.i:444
Utilities for byte operations.
#define UT_LOCATION_HERE
Definition: ut0core.h:73
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:105
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:93
#define UT_LIST_BASE_NODE_T_EXTERN(t, m)
A variant of UT_LIST_BASE_NODE_T to be used in rare cases where the full definition of t is not yet i...
Definition: ut0lst.h:279
Policy based mutexes.
#define mutex_exit(M)
Definition: ut0mutex.h:123
#define mutex_enter(M)
Definition: ut0mutex.h:117
Dynamic memory allocation routines and custom allocators specifically crafted to support memory instr...