diff options
Diffstat (limited to 'storage/innobase/include/mtr0mtr.h')
| -rw-r--r-- | storage/innobase/include/mtr0mtr.h | 696 |
1 files changed, 696 insertions, 0 deletions
diff --git a/storage/innobase/include/mtr0mtr.h b/storage/innobase/include/mtr0mtr.h new file mode 100644 index 00000000..f3db0008 --- /dev/null +++ b/storage/innobase/include/mtr0mtr.h @@ -0,0 +1,696 @@ +/***************************************************************************** + +Copyright (c) 1995, 2017, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2012, Facebook Inc. +Copyright (c) 2013, 2021, MariaDB Corporation. + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; version 2 of the License. + +This program is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with +this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA + +*****************************************************************************/ + +/**************************************************//** +@file include/mtr0mtr.h +Mini-transaction buffer + +Created 11/26/1995 Heikki Tuuri +*******************************************************/ + +#ifndef mtr0mtr_h +#define mtr0mtr_h + +#include "fil0fil.h" +#include "dyn0buf.h" + +/** Start a mini-transaction. */ +#define mtr_start(m) (m)->start() + +/** Commit a mini-transaction. */ +#define mtr_commit(m) (m)->commit() + +/** Set and return a savepoint in mtr. +@return savepoint */ +#define mtr_set_savepoint(m) (m)->get_savepoint() + +/** Release the (index tree) s-latch stored in an mtr memo after a +savepoint. */ +#define mtr_release_s_latch_at_savepoint(m, s, l) \ + (m)->release_s_latch_at_savepoint((s), (l)) + +/** Change the logging mode of a mini-transaction. +@return old mode */ +#define mtr_set_log_mode(m, d) (m)->set_log_mode((d)) + +/** Release an object in the memo stack. +@return true if released */ +#define mtr_memo_release(m, o, t) \ + (m)->memo_release((o), (t)) + +/** Print info of an mtr handle. */ +#define mtr_print(m) (m)->print() + +/** Return the log object of a mini-transaction buffer. +@return log */ +#define mtr_get_log(m) (m)->get_log() + +/** Push an object to an mtr memo stack. */ +#define mtr_memo_push(m, o, t) (m)->memo_push(o, t) + +#define mtr_x_lock_space(s, m) (m)->x_lock_space((s), __FILE__, __LINE__) +#define mtr_sx_lock_space(s, m) (m)->sx_lock_space((s), __FILE__, __LINE__) + +#define mtr_s_lock_index(i, m) (m)->s_lock(&(i)->lock, __FILE__, __LINE__) +#define mtr_x_lock_index(i, m) (m)->x_lock(&(i)->lock, __FILE__, __LINE__) +#define mtr_sx_lock_index(i, m) (m)->sx_lock(&(i)->lock, __FILE__, __LINE__) + +#define mtr_release_block_at_savepoint(m, s, b) \ + (m)->release_block_at_savepoint((s), (b)) + +#define mtr_block_sx_latch_at_savepoint(m, s, b) \ + (m)->sx_latch_at_savepoint((s), (b)) + +#define mtr_block_x_latch_at_savepoint(m, s, b) \ + (m)->x_latch_at_savepoint((s), (b)) + +/** Mini-transaction memo stack slot. */ +struct mtr_memo_slot_t { + /** pointer to the object */ + void* object; + + /** type of the stored object */ + mtr_memo_type_t type; +}; + +/** Mini-transaction handle and buffer */ +struct mtr_t { + /** Start a mini-transaction. */ + void start(); + + /** Commit the mini-transaction. */ + void commit(); + + /** Commit a mini-transaction that did not modify any pages, + but generated some redo log on a higher level, such as + FILE_MODIFY records and an optional FILE_CHECKPOINT marker. + The caller must hold log_sys.mutex. + This is to be used at log_checkpoint(). + @param checkpoint_lsn the log sequence number of a checkpoint, or 0 */ + void commit_files(lsn_t checkpoint_lsn= 0); + + /** @return mini-transaction savepoint (current size of m_memo) */ + ulint get_savepoint() const { ut_ad(is_active()); return m_memo.size(); } + + /** Release the (index tree) s-latch stored in an mtr memo after a + savepoint. + @param savepoint value returned by @see set_savepoint. + @param lock latch to release */ + inline void release_s_latch_at_savepoint( + ulint savepoint, + rw_lock_t* lock); + + /** Release the block in an mtr memo after a savepoint. */ + inline void release_block_at_savepoint( + ulint savepoint, + buf_block_t* block); + + /** SX-latch a not yet latched block after a savepoint. */ + inline void sx_latch_at_savepoint(ulint savepoint, buf_block_t* block); + + /** X-latch a not yet latched block after a savepoint. */ + inline void x_latch_at_savepoint(ulint savepoint, buf_block_t* block); + + /** @return the logging mode */ + mtr_log_t get_log_mode() const + { + static_assert(MTR_LOG_ALL == 0, "efficiency"); + ut_ad(m_log_mode <= MTR_LOG_NO_REDO); + return static_cast<mtr_log_t>(m_log_mode); + } + + /** Change the logging mode. + @param mode logging mode + @return old mode */ + mtr_log_t set_log_mode(mtr_log_t mode) + { + const mtr_log_t old_mode= get_log_mode(); + m_log_mode= mode & 3; + return old_mode; + } + + /** Check if we are holding a block latch in exclusive mode + @param block buffer pool block to search for */ + bool have_x_latch(const buf_block_t &block) const; + + /** Copy the tablespaces associated with the mini-transaction + (needed for generating FILE_MODIFY records) + @param[in] mtr mini-transaction that may modify + the same set of tablespaces as this one */ + void set_spaces(const mtr_t& mtr) + { + ut_ad(!m_user_space_id); + ut_ad(!m_user_space); + + ut_d(m_user_space_id = mtr.m_user_space_id); + m_user_space = mtr.m_user_space; + } + + /** Set the tablespace associated with the mini-transaction + (needed for generating a FILE_MODIFY record) + @param[in] space_id user or system tablespace ID + @return the tablespace */ + fil_space_t* set_named_space_id(ulint space_id) + { + ut_ad(!m_user_space_id); + ut_d(m_user_space_id = static_cast<uint32_t>(space_id)); + if (!space_id) { + return fil_system.sys_space; + } else { + ut_ad(m_user_space_id == space_id); + ut_ad(!m_user_space); + m_user_space = fil_space_get(space_id); + ut_ad(m_user_space); + return m_user_space; + } + } + + /** Set the tablespace associated with the mini-transaction + (needed for generating a FILE_MODIFY record) + @param[in] space user or system tablespace */ + void set_named_space(fil_space_t* space) + { + ut_ad(!m_user_space_id); + ut_d(m_user_space_id = static_cast<uint32_t>(space->id)); + if (space->id) { + m_user_space = space; + } + } + +#ifdef UNIV_DEBUG + /** Check the tablespace associated with the mini-transaction + (needed for generating a FILE_MODIFY record) + @param[in] space tablespace + @return whether the mini-transaction is associated with the space */ + bool is_named_space(ulint space) const; + /** Check the tablespace associated with the mini-transaction + (needed for generating a FILE_MODIFY record) + @param[in] space tablespace + @return whether the mini-transaction is associated with the space */ + bool is_named_space(const fil_space_t* space) const; +#endif /* UNIV_DEBUG */ + + /** Acquire a tablespace X-latch. + @param[in] space_id tablespace ID + @param[in] file file name from where called + @param[in] line line number in file + @return the tablespace object (never NULL) */ + fil_space_t* x_lock_space( + ulint space_id, + const char* file, + unsigned line); + + /** Acquire a shared rw-latch. + @param[in] lock rw-latch + @param[in] file file name from where called + @param[in] line line number in file */ + void s_lock(rw_lock_t* lock, const char* file, unsigned line) + { + rw_lock_s_lock_inline(lock, 0, file, line); + memo_push(lock, MTR_MEMO_S_LOCK); + } + + /** Acquire an exclusive rw-latch. + @param[in] lock rw-latch + @param[in] file file name from where called + @param[in] line line number in file */ + void x_lock(rw_lock_t* lock, const char* file, unsigned line) + { + rw_lock_x_lock_inline(lock, 0, file, line); + memo_push(lock, MTR_MEMO_X_LOCK); + } + + /** Acquire an shared/exclusive rw-latch. + @param[in] lock rw-latch + @param[in] file file name from where called + @param[in] line line number in file */ + void sx_lock(rw_lock_t* lock, const char* file, unsigned line) + { + rw_lock_sx_lock_inline(lock, 0, file, line); + memo_push(lock, MTR_MEMO_SX_LOCK); + } + + /** Acquire a tablespace X-latch. + @param[in] space tablespace + @param[in] file file name from where called + @param[in] line line number in file */ + void x_lock_space(fil_space_t* space, const char* file, unsigned line) + { + ut_ad(space->purpose == FIL_TYPE_TEMPORARY + || space->purpose == FIL_TYPE_IMPORT + || space->purpose == FIL_TYPE_TABLESPACE); + memo_push(space, MTR_MEMO_SPACE_X_LOCK); + rw_lock_x_lock_inline(&space->latch, 0, file, line); + } + + /** Acquire a tablespace SX-latch. + @param[in] space tablespace + @param[in] file file name from where called + @param[in] line line number in file */ + void sx_lock_space(fil_space_t *space, const char *file, unsigned line) + { + ut_ad(space->purpose == FIL_TYPE_TEMPORARY + || space->purpose == FIL_TYPE_IMPORT + || space->purpose == FIL_TYPE_TABLESPACE); + sx_lock(&space->latch, file, line); + } + + /** Release an object in the memo stack. + @param object object + @param type object type + @return bool if lock released */ + bool memo_release(const void* object, ulint type); + /** Release a page latch. + @param[in] ptr pointer to within a page frame + @param[in] type object type: MTR_MEMO_PAGE_X_FIX, ... */ + void release_page(const void* ptr, mtr_memo_type_t type); + +private: + /** Note that the mini-transaction will modify data. */ + void flag_modified() { m_modifications = true; } + /** Mark the given latched page as modified. + @param block page that will be modified */ + void modify(const buf_block_t& block); +public: + /** Note that the mini-transaction will modify a block. */ + void set_modified(const buf_block_t &block) + { flag_modified(); if (m_log_mode != MTR_LOG_NONE) modify(block); } + + /** Set the state to not-modified. This will not log the changes. + This is only used during redo log apply, to avoid logging the changes. */ + void discard_modifications() { m_modifications = false; } + + /** Get the LSN of commit(). + @return the commit LSN + @retval 0 if the transaction only modified temporary tablespaces */ + lsn_t commit_lsn() const { ut_ad(has_committed()); return m_commit_lsn; } + + /** Note that we are inside the change buffer code. */ + void enter_ibuf() { m_inside_ibuf= true; } + + /** Note that we have exited from the change buffer code. */ + void exit_ibuf() { m_inside_ibuf= false; } + + /** @return true if we are inside the change buffer code */ + bool is_inside_ibuf() const { return m_inside_ibuf; } + + /** Note that pages has been trimed */ + void set_trim_pages() { m_trim_pages= true; } + + /** @return true if pages has been trimed */ + bool is_trim_pages() { return m_trim_pages; } + +#ifdef UNIV_DEBUG + /** Check if we are holding an rw-latch in this mini-transaction + @param lock latch to search for + @param type held latch type + @return whether (lock,type) is contained */ + bool memo_contains(const rw_lock_t &lock, mtr_memo_type_t type) + MY_ATTRIBUTE((warn_unused_result)); + /** Check if we are holding exclusive tablespace latch + @param space tablespace to search for + @return whether space.latch is being held */ + bool memo_contains(const fil_space_t& space) + MY_ATTRIBUTE((warn_unused_result)); + + + /** Check if memo contains the given item. + @param object object to search + @param flags specify types of object (can be ORred) of + MTR_MEMO_PAGE_S_FIX ... values + @return true if contains */ + bool memo_contains_flagged(const void* ptr, ulint flags) const; + + /** Check if memo contains the given page. + @param[in] ptr pointer to within buffer frame + @param[in] flags specify types of object with OR of + MTR_MEMO_PAGE_S_FIX... values + @return the block + @retval NULL if not found */ + buf_block_t* memo_contains_page_flagged( + const byte* ptr, + ulint flags) const; + + /** Print info of an mtr handle. */ + void print() const; + + /** @return true if mini-transaction contains modifications. */ + bool has_modifications() const { return m_modifications; } + + /** @return the memo stack */ + const mtr_buf_t* get_memo() const { return &m_memo; } + + /** @return the memo stack */ + mtr_buf_t* get_memo() { return &m_memo; } +#endif /* UNIV_DEBUG */ + + /** @return true if a record was added to the mini-transaction */ + bool is_dirty() const { return m_made_dirty; } + + /** Get the buffered redo log of this mini-transaction. + @return redo log */ + const mtr_buf_t* get_log() const { return &m_log; } + + /** Get the buffered redo log of this mini-transaction. + @return redo log */ + mtr_buf_t* get_log() { return &m_log; } + + /** Push an object to an mtr memo stack. + @param object object + @param type object type: MTR_MEMO_S_LOCK, ... */ + inline void memo_push(void* object, mtr_memo_type_t type); + + /** Check if this mini-transaction is dirtying a clean page. + @param block block being x-fixed + @return true if the mtr is dirtying a clean page. */ + static inline bool is_block_dirtied(const buf_block_t* block) + MY_ATTRIBUTE((warn_unused_result)); + + /** Write request types */ + enum write_type + { + /** the page is guaranteed to always change */ + NORMAL= 0, + /** optional: the page contents might not change */ + MAYBE_NOP, + /** force a write, even if the page contents is not changing */ + FORCED + }; + + /** Write 1, 2, 4, or 8 bytes to a file page. + @param[in] block file page + @param[in,out] ptr pointer in file page + @param[in] val value to write + @tparam l number of bytes to write + @tparam w write request type + @tparam V type of val + @return whether any log was written */ + template<unsigned l,write_type w= NORMAL,typename V> + inline bool write(const buf_block_t &block, void *ptr, V val) + MY_ATTRIBUTE((nonnull)); + + /** Log a write of a byte string to a page. + @param[in] b buffer page + @param[in] ofs byte offset from b->frame + @param[in] len length of the data to write */ + inline void memcpy(const buf_block_t &b, ulint ofs, ulint len); + + /** Write a byte string to a page. + @param[in,out] b buffer page + @param[in] dest destination within b.frame + @param[in] str the data to write + @param[in] len length of the data to write + @tparam w write request type */ + template<write_type w= NORMAL> + inline void memcpy(const buf_block_t &b, void *dest, const void *str, + ulint len); + + /** Log a write of a byte string to a ROW_FORMAT=COMPRESSED page. + @param[in] b ROW_FORMAT=COMPRESSED index page + @param[in] offset byte offset from b.zip.data + @param[in] len length of the data to write */ + inline void zmemcpy(const buf_block_t &b, ulint offset, ulint len); + + /** Write a byte string to a ROW_FORMAT=COMPRESSED page. + @param[in] b ROW_FORMAT=COMPRESSED index page + @param[in] dest destination within b.zip.data + @param[in] str the data to write + @param[in] len length of the data to write + @tparam w write request type */ + template<write_type w= NORMAL> + inline void zmemcpy(const buf_block_t &b, void *dest, const void *str, + ulint len); + + /** Log an initialization of a string of bytes. + @param[in] b buffer page + @param[in] ofs byte offset from b->frame + @param[in] len length of the data to write + @param[in] val the data byte to write */ + inline void memset(const buf_block_t &b, ulint ofs, ulint len, byte val); + + /** Initialize a string of bytes. + @param[in,out] b buffer page + @param[in] ofs byte offset from b->frame + @param[in] len length of the data to write + @param[in] val the data byte to write */ + inline void memset(const buf_block_t *b, ulint ofs, ulint len, byte val); + + /** Log an initialization of a repeating string of bytes. + @param[in] b buffer page + @param[in] ofs byte offset from b->frame + @param[in] len length of the data to write, in bytes + @param[in] str the string to write + @param[in] size size of str, in bytes */ + inline void memset(const buf_block_t &b, ulint ofs, size_t len, + const void *str, size_t size); + + /** Initialize a repeating string of bytes. + @param[in,out] b buffer page + @param[in] ofs byte offset from b->frame + @param[in] len length of the data to write, in bytes + @param[in] str the string to write + @param[in] size size of str, in bytes */ + inline void memset(const buf_block_t *b, ulint ofs, size_t len, + const void *str, size_t size); + + /** Log that a string of bytes was copied from the same page. + @param[in] b buffer page + @param[in] d destination offset within the page + @param[in] s source offset within the page + @param[in] len length of the data to copy */ + inline void memmove(const buf_block_t &b, ulint d, ulint s, ulint len); + + /** Initialize an entire page. + @param[in,out] b buffer page */ + void init(buf_block_t *b); + /** Free a page. + @param[in] space tablespace contains page to be freed + @param[in] offset page offset to be freed */ + inline void free(fil_space_t &space, uint32_t offset); + /** Write log for partly initializing a B-tree or R-tree page. + @param block B-tree or R-tree page + @param comp false=ROW_FORMAT=REDUNDANT, true=COMPACT or DYNAMIC */ + inline void page_create(const buf_block_t &block, bool comp); + + /** Write log for inserting a B-tree or R-tree record in + ROW_FORMAT=REDUNDANT. + @param block B-tree or R-tree page + @param reuse false=allocate from PAGE_HEAP_TOP; true=reuse PAGE_FREE + @param prev_rec byte offset of the predecessor of the record to insert, + starting from PAGE_OLD_INFIMUM + @param info_bits info_bits of the record + @param n_fields_s number of fields << 1 | rec_get_1byte_offs_flag() + @param hdr_c number of common record header bytes with prev_rec + @param data_c number of common data bytes with prev_rec + @param hdr record header bytes to copy to the log + @param hdr_l number of copied record header bytes + @param data record payload bytes to copy to the log + @param data_l number of copied record data bytes */ + inline void page_insert(const buf_block_t &block, bool reuse, + ulint prev_rec, byte info_bits, + ulint n_fields_s, size_t hdr_c, size_t data_c, + const byte *hdr, size_t hdr_l, + const byte *data, size_t data_l); + /** Write log for inserting a B-tree or R-tree record in + ROW_FORMAT=COMPACT or ROW_FORMAT=DYNAMIC. + @param block B-tree or R-tree page + @param reuse false=allocate from PAGE_HEAP_TOP; true=reuse PAGE_FREE + @param prev_rec byte offset of the predecessor of the record to insert, + starting from PAGE_NEW_INFIMUM + @param info_status rec_get_info_and_status_bits() + @param shift unless !reuse: number of bytes the PAGE_FREE is moving + @param hdr_c number of common record header bytes with prev_rec + @param data_c number of common data bytes with prev_rec + @param hdr record header bytes to copy to the log + @param hdr_l number of copied record header bytes + @param data record payload bytes to copy to the log + @param data_l number of copied record data bytes */ + inline void page_insert(const buf_block_t &block, bool reuse, + ulint prev_rec, byte info_status, + ssize_t shift, size_t hdr_c, size_t data_c, + const byte *hdr, size_t hdr_l, + const byte *data, size_t data_l); + /** Write log for deleting a B-tree or R-tree record in ROW_FORMAT=REDUNDANT. + @param block B-tree or R-tree page + @param prev_rec byte offset of the predecessor of the record to delete, + starting from PAGE_OLD_INFIMUM */ + inline void page_delete(const buf_block_t &block, ulint prev_rec); + /** Write log for deleting a COMPACT or DYNAMIC B-tree or R-tree record. + @param block B-tree or R-tree page + @param prev_rec byte offset of the predecessor of the record to delete, + starting from PAGE_NEW_INFIMUM + @param hdr_size record header size, excluding REC_N_NEW_EXTRA_BYTES + @param data_size data payload size, in bytes */ + inline void page_delete(const buf_block_t &block, ulint prev_rec, + size_t hdr_size, size_t data_size); + + /** Write log for initializing an undo log page. + @param block undo page */ + inline void undo_create(const buf_block_t &block); + /** Write log for appending an undo log record. + @param block undo page + @param data record within the undo page + @param len length of the undo record, in bytes */ + inline void undo_append(const buf_block_t &block, + const void *data, size_t len); + /** Trim the end of a tablespace. + @param id first page identifier that will not be in the file */ + inline void trim_pages(const page_id_t id); + + /** Write a log record about a file operation. + @param type file operation + @param space_id tablespace identifier + @param path file path + @param new_path new file path for type=FILE_RENAME */ + inline void log_file_op(mfile_type_t type, ulint space_id, + const char *path, + const char *new_path= nullptr); + + /** Add freed page numbers to freed_pages */ + void add_freed_offset(fil_space_t *space, uint32_t page) + { + ut_ad(is_named_space(space)); + if (!m_freed_pages) + { + m_freed_pages= new range_set(); + ut_ad(!m_freed_space); + m_freed_space= space; + } + else + ut_ad(m_freed_space == space); + m_freed_pages->add_value(page); + } + + /** Determine the added buffer fix count of a block. + @param block block to be checked + @return number of buffer count added by this mtr */ + uint32_t get_fix_count(const buf_block_t *block) const; + + /** type of page flushing is needed during commit() */ + enum page_flush_ahead + { + /** no need to trigger page cleaner */ + PAGE_FLUSH_NO= 0, + /** asynchronous flushing is needed */ + PAGE_FLUSH_ASYNC, + /** furious flushing is needed */ + PAGE_FLUSH_SYNC + }; + +private: + /** Log a write of a byte string to a page. + @param block buffer page + @param offset byte offset within page + @param data data to be written + @param len length of the data, in bytes */ + inline void memcpy_low(const buf_block_t &block, uint16_t offset, + const void *data, size_t len); + /** + Write a log record. + @tparam type redo log record type + @param id persistent page identifier + @param bpage buffer pool page, or nullptr + @param len number of additional bytes to write + @param alloc whether to allocate the additional bytes + @param offset byte offset, or 0 if the record type does not allow one + @return end of mini-transaction log, minus len */ + template<byte type> + inline byte *log_write(const page_id_t id, const buf_page_t *bpage, + size_t len= 0, bool alloc= false, size_t offset= 0); + + /** Write an EXTENDED log record. + @param block buffer pool page + @param type extended record subtype; @see mrec_ext_t */ + inline void log_write_extended(const buf_block_t &block, byte type); + + /** Prepare to write the mini-transaction log to the redo log buffer. + @return number of bytes to write in finish_write() */ + inline ulint prepare_write(); + + /** Append the redo log records to the redo log buffer. + @param len number of bytes to write + @return {start_lsn,flush_ahead} */ + inline std::pair<lsn_t,page_flush_ahead> finish_write(ulint len); + + /** Release the resources */ + inline void release_resources(); + +#ifdef UNIV_DEBUG +public: + /** @return whether the mini-transaction is active */ + bool is_active() const + { ut_ad(!m_commit || m_start); return m_start && !m_commit; } + /** @return whether the mini-transaction has been committed */ + bool has_committed() const { ut_ad(!m_commit || m_start); return m_commit; } +private: + /** whether start() has been called */ + bool m_start= false; + /** whether commit() has been called */ + bool m_commit= false; +#endif + + /** The page of the most recent m_log record written, or NULL */ + const buf_page_t* m_last; + /** The current byte offset in m_last, or 0 */ + uint16_t m_last_offset; + + /** specifies which operations should be logged; default MTR_LOG_ALL */ + uint16_t m_log_mode:2; + + /** whether at least one buffer pool page was written to */ + uint16_t m_modifications:1; + + /** whether at least one previously clean buffer pool page was written to */ + uint16_t m_made_dirty:1; + + /** whether change buffer is latched; only needed in non-debug builds + to suppress some read-ahead operations, @see ibuf_inside() */ + uint16_t m_inside_ibuf:1; + + /** whether the pages has been trimmed */ + uint16_t m_trim_pages:1; + +#ifdef UNIV_DEBUG + /** Persistent user tablespace associated with the + mini-transaction, or 0 (TRX_SYS_SPACE) if none yet */ + uint32_t m_user_space_id; +#endif /* UNIV_DEBUG */ + + /** acquired dict_index_t::lock, fil_space_t::latch, buf_block_t */ + mtr_buf_t m_memo; + + /** mini-transaction log */ + mtr_buf_t m_log; + + /** user tablespace that is being modified by the mini-transaction */ + fil_space_t* m_user_space; + + /** LSN at commit time */ + lsn_t m_commit_lsn; + + /** tablespace where pages have been freed */ + fil_space_t *m_freed_space= nullptr; + /** set of freed page ids */ + range_set *m_freed_pages= nullptr; +}; + +#include "mtr0mtr.ic" + +#endif /* mtr0mtr_h */ |