mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-16 12:02:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

MDEV-21174: Remove some mlog_write_initial_log_record_fast()

Browse source 
Pass buf_block_t* to more functions that write redo log.

page_zip_write_node_ptr(), page_zip_write_blob_ptr(),
page_zip_compress_write_log_no_data():
Take buf_block_t* as parameter, and do not tolerate mtr=NULL.

page_zip_compress(): Do not tolerate mtr=NULL.

page_zip_dir_insert(): Take page_cur_t* as parameter.

mlog_write_initial_log_record(): Remove. This function was unused.

RecIterator::remove(): Remove the redundant page_zip parameter.

PageConverter::m_page_zip_ptr: Remove.
This commit is contained in:
Marko Mäkelä 2019-12-13 17:53:55 +02:00
parent 2b5a269cb4
commit 745fd4b39f
9 changed files with 98 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
storage/innobase/btr/btr0btr.cc
View file

@ -780,7 +780,7 @@ inline void btr_node_ptr_set_child_page_no(buf_block_t *block,
REC_NODE_PTR_SIZE); REC_NODE_PTR_SIZE);
if (UNIV_LIKELY_NULL(block->page.zip.data)) if (UNIV_LIKELY_NULL(block->page.zip.data))
page_zip_write_node_ptr(&block->page.zip, rec, offs, page_no, mtr); page_zip_write_node_ptr(block, rec, offs, page_no, mtr);
else else
mtr->write<4>(*block, rec + offs - REC_NODE_PTR_SIZE, page_no); mtr->write<4>(*block, rec + offs - REC_NODE_PTR_SIZE, page_no);
} }

8
storage/innobase/btr/btr0cur.cc
View file

@ -7153,8 +7153,7 @@ btr_cur_set_ownership_of_extern_field(
if (UNIV_LIKELY_NULL(block->page.zip.data)) { if (UNIV_LIKELY_NULL(block->page.zip.data)) {
mach_write_to_1(data + local_len + BTR_EXTERN_LEN, byte_val); mach_write_to_1(data + local_len + BTR_EXTERN_LEN, byte_val);
page_zip_write_blob_ptr(&block->page.zip, rec, index, offsets, page_zip_write_blob_ptr(block, rec, index, offsets, i, mtr);
i, mtr);
} else { } else {
mtr->write<1,mtr_t::OPT>(*block, mtr->write<1,mtr_t::OPT>(*block,
data + local_len + BTR_EXTERN_LEN, data + local_len + BTR_EXTERN_LEN,
@ -7826,7 +7825,7 @@ btr_store_big_rec_extern_fields(
/* We compress a page when finish bulk insert.*/ /* We compress a page when finish bulk insert.*/
if (UNIV_LIKELY(op != BTR_STORE_INSERT_BULK)) { if (UNIV_LIKELY(op != BTR_STORE_INSERT_BULK)) {
page_zip_write_blob_ptr( page_zip_write_blob_ptr(
page_zip, rec, index, offsets, rec_block, rec, index, offsets,
field_no, &mtr); field_no, &mtr);
} }
@ -8103,8 +8102,7 @@ btr_free_externally_stored_field(
mach_write_to_4(field_ref + BTR_EXTERN_PAGE_NO, mach_write_to_4(field_ref + BTR_EXTERN_PAGE_NO,
next_page_no); next_page_no);
memset(field_ref + BTR_EXTERN_LEN, 0, 4); memset(field_ref + BTR_EXTERN_LEN, 0, 4);
page_zip_write_blob_ptr(&block->page.zip, page_zip_write_blob_ptr(block, rec, index,
rec, index,
offsets, i, &mtr); offsets, i, &mtr);
} else { } else {
mtr.write<4>(*block, mtr.write<4>(*block,

46
storage/innobase/include/page0zip.h
View file

@ -133,12 +133,11 @@ page_zip_set_alloc(
@retval false on failure; block->page.zip will be left intact. */ @retval false on failure; block->page.zip will be left intact. */
bool bool
page_zip_compress( page_zip_compress(
buf_block_t* block, /*!< in/out: buffer block */ buf_block_t* block, /*!< in/out: buffer block */
dict_index_t* index, /*!< in: index of the B-tree dict_index_t* index, /*!< in: index of the B-tree node */
node */ ulint level, /*!< in: commpression level */
ulint level, /*!< in: commpression level */ mtr_t* mtr) /*!< in/out: mini-transaction */
mtr_t* mtr); /*!< in/out: mini-transaction, MY_ATTRIBUTE((nonnull));
or NULL */
/**********************************************************************//** /**********************************************************************//**
Write the index information for the compressed page. Write the index information for the compressed page.
@ -278,14 +277,14 @@ The information must already have been updated on the uncompressed page. */
void void
page_zip_write_blob_ptr( page_zip_write_blob_ptr(
/*====================*/ /*====================*/
page_zip_des_t* page_zip,/*!< in/out: compressed page */ buf_block_t* block, /*!< in/out: ROW_FORMAT=COMPRESSED page */
const byte* rec, /*!< in/out: record whose data is being const byte* rec, /*!< in/out: record whose data is being
written */ written */
dict_index_t* index, /*!< in: index of the page */ dict_index_t* index, /*!< in: index of the page */
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */ const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
ulint n, /*!< in: column index */ ulint n, /*!< in: column index */
mtr_t* mtr); /*!< in: mini-transaction handle, mtr_t* mtr) /*!< in/out: mini-transaction */
or NULL if no logging is needed */ MY_ATTRIBUTE((nonnull));
/***********************************************************//** /***********************************************************//**
Parses a log record of writing the node pointer of a record. Parses a log record of writing the node pointer of a record.
@ -303,11 +302,12 @@ Write the node pointer of a record on a non-leaf compressed page. */
void void
page_zip_write_node_ptr( page_zip_write_node_ptr(
/*====================*/ /*====================*/
page_zip_des_t* page_zip,/*!< in/out: compressed page */ buf_block_t* block, /*!< in/out: compressed page */
byte* rec, /*!< in/out: record */ byte* rec, /*!< in/out: record */
ulint size, /*!< in: data size of rec */ ulint size, /*!< in: data size of rec */
ulint ptr, /*!< in: node pointer */ ulint ptr, /*!< in: node pointer */
mtr_t* mtr); /*!< in: mini-transaction, or NULL */ mtr_t* mtr) /*!< in/out: mini-transaction */
MY_ATTRIBUTE((nonnull));
/** Write the DB_TRX_ID,DB_ROLL_PTR into a clustered index leaf page record. /** Write the DB_TRX_ID,DB_ROLL_PTR into a clustered index leaf page record.
@param[in,out] page_zip compressed page @param[in,out] page_zip compressed page
@ -370,8 +370,7 @@ Insert a record to the dense page directory. */
void void
page_zip_dir_insert( page_zip_dir_insert(
/*================*/ /*================*/
page_zip_des_t* page_zip,/*!< in/out: compressed page */ page_cur_t* cursor, /*!< in/out: page cursor */
const byte* prev_rec,/*!< in: record after which to insert */
const byte* free_rec,/*!< in: record from which rec was const byte* free_rec,/*!< in: record from which rec was
allocated, or NULL */ allocated, or NULL */
byte* rec); /*!< in: record to insert */ byte* rec); /*!< in: record to insert */
@ -411,22 +410,6 @@ page_zip_parse_write_header(
page_t* page, /*!< in/out: uncompressed page */ page_t* page, /*!< in/out: uncompressed page */
page_zip_des_t* page_zip);/*!< in/out: compressed page */ page_zip_des_t* page_zip);/*!< in/out: compressed page */
/**********************************************************************//**
Write data to the uncompressed header portion of a page. The data must
already have been written to the uncompressed page.
However, the data portion of the uncompressed page may differ from
the compressed page when a record is being inserted in
page_cur_insert_rec_low(). */
UNIV_INLINE
void
page_zip_write_header(
/*==================*/
page_zip_des_t* page_zip,/*!< in/out: compressed page */
const byte* str, /*!< in: address on the uncompressed page */
ulint length, /*!< in: length of the data */
mtr_t* mtr) /*!< in: mini-transaction, or NULL */
MY_ATTRIBUTE((nonnull(1,2)));
/**********************************************************************//** /**********************************************************************//**
Reorganize and compress a page. This is a low-level operation for Reorganize and compress a page. This is a low-level operation for
compressed pages, to be used when page_zip_compress() fails. compressed pages, to be used when page_zip_compress() fails.
@ -499,9 +482,10 @@ void
page_zip_compress_write_log_no_data( page_zip_compress_write_log_no_data(
/*================================*/ /*================================*/
ulint level, /*!< in: compression level */ ulint level, /*!< in: compression level */
const page_t* page, /*!< in: page that is compressed */ buf_block_t* block, /*!< in: ROW_FORMAT=COMPRESSED index page */
dict_index_t* index, /*!< in: index */ dict_index_t* index, /*!< in: index */
mtr_t* mtr); /*!< in: mtr */ mtr_t* mtr) /*!< in: mtr */
MY_ATTRIBUTE((nonnull));
/**********************************************************************//** /**********************************************************************//**
Reset the counters used for filling Reset the counters used for filling

11
storage/innobase/include/page0zip.ic
View file

@ -369,14 +369,15 @@ void
page_zip_compress_write_log_no_data( page_zip_compress_write_log_no_data(
/*================================*/ /*================================*/
ulint level, /*!< in: compression level */ ulint level, /*!< in: compression level */
const page_t* page, /*!< in: page that is compressed */ buf_block_t* block, /*!< in: ROW_FORMAT=COMPRESSED index page */
dict_index_t* index, /*!< in: index */ dict_index_t* index, /*!< in: index */
mtr_t* mtr) /*!< in: mtr */ mtr_t* mtr) /*!< in: mtr */
{ {
byte* log_ptr = mlog_open_and_write_index( if (byte* log_ptr = mlog_open(mtr, 11 + 1)) {
mtr, page, index, MLOG_ZIP_PAGE_COMPRESS_NO_DATA, 1); log_ptr = mlog_write_initial_log_record_low(
MLOG_ZIP_PAGE_COMPRESS_NO_DATA,
if (log_ptr) { block->page.id.space(), block->page.id.page_no(),
log_ptr, mtr);
mach_write_to_1(log_ptr, level); mach_write_to_1(log_ptr, level);
mlog_close(mtr, log_ptr + 1); mlog_close(mtr, log_ptr + 1);
} }

2
storage/innobase/log/log0recv.cc
View file

@ -1704,7 +1704,7 @@ parse_log:
break; break;
} }
if (page && if (page &&
!page_zip_compress(block, index, *ptr, NULL)) { !page_zip_compress(block, index, *ptr, mtr)) {
ut_error; ut_error;
} }
ptr++; ptr++;

33
storage/innobase/mtr/mtr0log.cc
View file

@ -50,38 +50,7 @@ mlog_catenate_string(
} }
/********************************************************//** /********************************************************//**
Writes the initial part of a log record consisting of one-byte item Parses an initial log record written by mlog_write_initial_log_record_low().
type and four-byte space and page numbers. Also pushes info
to the mtr memo that a buffer page has been modified. */
void
mlog_write_initial_log_record(
/*==========================*/
const byte* ptr, /*!< in: pointer to (inside) a buffer
frame holding the file page where
modification is made */
mlog_id_t type, /*!< in: log item type: MLOG_1BYTE, ... */
mtr_t* mtr) /*!< in: mini-transaction handle */
{
byte* log_ptr;
ut_ad(type <= MLOG_BIGGEST_TYPE);
ut_ad(type > MLOG_8BYTES);
log_ptr = mlog_open(mtr, 11);
/* If no logging is requested, we may return now */
if (log_ptr == NULL) {
return;
}
log_ptr = mlog_write_initial_log_record_fast(ptr, type, log_ptr, mtr);
mlog_close(mtr, log_ptr);
}
/********************************************************//**
Parses an initial log record written by mlog_write_initial_log_record.
@return parsed record end, NULL if not a complete record */ @return parsed record end, NULL if not a complete record */
const byte* const byte*
mlog_parse_initial_log_record( mlog_parse_initial_log_record(

16
storage/innobase/page/page0cur.cc
View file

@ -1772,14 +1772,20 @@ page_cur_insert_rec_zip(
ut_ad(pos > 0); ut_ad(pos > 0);
if (!log_compressed) { if (!log_compressed) {
if (page_zip_compress( const mtr_log_t log_mode = mtr->set_log_mode(
page_cur_get_block(cursor), MTR_LOG_NONE);
index, level, NULL)) { const bool ok = page_zip_compress(
page_cur_get_block(cursor),
index, level, mtr);
mtr->set_log_mode(log_mode);
if (ok) {
page_cur_insert_rec_write_log( page_cur_insert_rec_write_log(
insert_rec, rec_size, insert_rec, rec_size,
cursor->rec, index, mtr); cursor->rec, index, mtr);
page_zip_compress_write_log_no_data( page_zip_compress_write_log_no_data(
level, page, index, mtr); level,
page_cur_get_block(cursor),
index, mtr);
rec_offs_make_valid( rec_offs_make_valid(
insert_rec, index, insert_rec, index,
@ -1991,7 +1997,7 @@ use_heap:
UNIV_MEM_ASSERT_RW(rec_get_start(insert_rec, offsets), UNIV_MEM_ASSERT_RW(rec_get_start(insert_rec, offsets),
rec_offs_size(offsets)); rec_offs_size(offsets));
page_zip_dir_insert(page_zip, cursor->rec, free_rec, insert_rec); page_zip_dir_insert(cursor, free_rec, insert_rec);
/* 6. Update the last insertion info in page header */ /* 6. Update the last insertion info in page header */

79
storage/innobase/page/page0zip.cc
View file

@ -1232,12 +1232,10 @@ func_exit:
@retval false on failure; block->page.zip will be left intact. */ @retval false on failure; block->page.zip will be left intact. */
bool bool
page_zip_compress( page_zip_compress(
buf_block_t* block, /*!< in/out: buffer block */ buf_block_t* block, /*!< in/out: buffer block */
dict_index_t* index, /*!< in: index of the B-tree dict_index_t* index, /*!< in: index of the B-tree node */
node */ ulint level, /*!< in: commpression level */
ulint level, /*!< in: commpression level */ mtr_t* mtr) /*!< in/out: mini-transaction */
mtr_t* mtr) /*!< in/out: mini-transaction,
or NULL */
{ {
z_stream c_stream; z_stream c_stream;
int err; int err;
@ -1505,7 +1503,7 @@ err_exit:
fclose(logfile); fclose(logfile);
} }
#endif /* PAGE_ZIP_COMPRESS_DBG */ #endif /* PAGE_ZIP_COMPRESS_DBG */
if (page_is_leaf(page) && index) { if (page_is_leaf(page)) {
dict_index_zip_failure(index); dict_index_zip_failure(index);
} }
@ -1558,9 +1556,7 @@ err_exit:
ut_a(page_zip_validate(page_zip, page, index)); ut_a(page_zip_validate(page_zip, page, index));
#endif /* UNIV_ZIP_DEBUG */ #endif /* UNIV_ZIP_DEBUG */
if (mtr) { page_zip_compress_write_log(block, index, mtr);
page_zip_compress_write_log(block, index, mtr);
}
UNIV_MEM_ASSERT_RW(page_zip->data, page_zip_get_size(page_zip)); UNIV_MEM_ASSERT_RW(page_zip->data, page_zip_get_size(page_zip));
@ -3876,23 +3872,22 @@ The information must already have been updated on the uncompressed page. */
void void
page_zip_write_blob_ptr( page_zip_write_blob_ptr(
/*====================*/ /*====================*/
page_zip_des_t* page_zip,/*!< in/out: compressed page */ buf_block_t* block, /*!< in/out: ROW_FORMAT=COMPRESSED page */
const byte* rec, /*!< in/out: record whose data is being const byte* rec, /*!< in/out: record whose data is being
written */ written */
dict_index_t* index, /*!< in: index of the page */ dict_index_t* index, /*!< in: index of the page */
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */ const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
ulint n, /*!< in: column index */ ulint n, /*!< in: column index */
mtr_t* mtr) /*!< in: mini-transaction handle, mtr_t* mtr) /*!< in/out: mini-transaction */
or NULL if no logging is needed */
{ {
const byte* field; const byte* field;
byte* externs; byte* externs;
const page_t* page = page_align(rec); const page_t* const page = block->frame;
page_zip_des_t* const page_zip = &block->page.zip;
ulint blob_no; ulint blob_no;
ulint len; ulint len;
ut_ad(page_zip != NULL); ut_ad(page_align(rec) == page);
ut_ad(rec != NULL);
ut_ad(index != NULL); ut_ad(index != NULL);
ut_ad(offsets != NULL); ut_ad(offsets != NULL);
ut_ad(page_simple_validate_new((page_t*) page)); ut_ad(page_simple_validate_new((page_t*) page));
@ -3934,15 +3929,11 @@ page_zip_write_blob_ptr(
ut_a(page_zip_validate(page_zip, page, index)); ut_a(page_zip_validate(page_zip, page, index));
#endif /* UNIV_ZIP_DEBUG */ #endif /* UNIV_ZIP_DEBUG */
if (mtr) { if (byte* log_ptr = mlog_open(mtr, 11 + 2 + 2 + FIELD_REF_SIZE)) {
byte* log_ptr = mlog_open( log_ptr = mlog_write_initial_log_record_low(
mtr, 11 + 2 + 2 + BTR_EXTERN_FIELD_REF_SIZE); MLOG_ZIP_WRITE_BLOB_PTR,
if (UNIV_UNLIKELY(!log_ptr)) { block->page.id.space(), block->page.id.page_no(),
return; log_ptr, mtr);
}
log_ptr = mlog_write_initial_log_record_fast(
(byte*) field, MLOG_ZIP_WRITE_BLOB_PTR, log_ptr, mtr);
mach_write_to_2(log_ptr, page_offset(field)); mach_write_to_2(log_ptr, page_offset(field));
log_ptr += 2; log_ptr += 2;
mach_write_to_2(log_ptr, ulint(externs - page_zip->data)); mach_write_to_2(log_ptr, ulint(externs - page_zip->data));
@ -4033,18 +4024,17 @@ Write the node pointer of a record on a non-leaf compressed page. */
void void
page_zip_write_node_ptr( page_zip_write_node_ptr(
/*====================*/ /*====================*/
page_zip_des_t* page_zip,/*!< in/out: compressed page */ buf_block_t* block, /*!< in/out: compressed page */
byte* rec, /*!< in/out: record */ byte* rec, /*!< in/out: record */
ulint size, /*!< in: data size of rec */ ulint size, /*!< in: data size of rec */
ulint ptr, /*!< in: node pointer */ ulint ptr, /*!< in: node pointer */
mtr_t* mtr) /*!< in: mini-transaction, or NULL */ mtr_t* mtr) /*!< in/out: mini-transaction */
{ {
byte* field; byte* field;
byte* storage; byte* storage;
#ifdef UNIV_DEBUG page_zip_des_t* const page_zip = &block->page.zip;
page_t* page = page_align(rec);
#endif /* UNIV_DEBUG */
ut_d(const page_t* const page = block->frame);
ut_ad(page_simple_validate_new(page)); ut_ad(page_simple_validate_new(page));
ut_ad(page_zip_simple_validate(page_zip)); ut_ad(page_zip_simple_validate(page_zip));
ut_ad(page_zip_get_size(page_zip) ut_ad(page_zip_get_size(page_zip)
@ -4070,15 +4060,11 @@ page_zip_write_node_ptr(
mach_write_to_4(field, ptr); mach_write_to_4(field, ptr);
memcpy(storage, field, REC_NODE_PTR_SIZE); memcpy(storage, field, REC_NODE_PTR_SIZE);
if (mtr) { if (byte* log_ptr = mlog_open(mtr, 11 + 2 + 2 + REC_NODE_PTR_SIZE)) {
byte* log_ptr = mlog_open(mtr, log_ptr = mlog_write_initial_log_record_low(
11 + 2 + 2 + REC_NODE_PTR_SIZE); MLOG_ZIP_WRITE_NODE_PTR,
if (UNIV_UNLIKELY(!log_ptr)) { block->page.id.space(), block->page.id.page_no(),
return; log_ptr, mtr);
}
log_ptr = mlog_write_initial_log_record_fast(
field, MLOG_ZIP_WRITE_NODE_PTR, log_ptr, mtr);
mach_write_to_2(log_ptr, page_offset(field)); mach_write_to_2(log_ptr, page_offset(field));
log_ptr += 2; log_ptr += 2;
mach_write_to_2(log_ptr, ulint(storage - page_zip->data)); mach_write_to_2(log_ptr, ulint(storage - page_zip->data));
@ -4366,23 +4352,26 @@ Insert a record to the dense page directory. */
void void
page_zip_dir_insert( page_zip_dir_insert(
/*================*/ /*================*/
page_zip_des_t* page_zip,/*!< in/out: compressed page */ page_cur_t* cursor, /*!< in/out: page cursor */
const byte* prev_rec,/*!< in: record after which to insert */
const byte* free_rec,/*!< in: record from which rec was const byte* free_rec,/*!< in: record from which rec was
allocated, or NULL */ allocated, or NULL */
byte* rec) /*!< in: record to insert */ byte* rec) /*!< in: record to insert */
{ {
ut_ad(page_align(cursor->rec) == cursor->block->frame);
ut_ad(page_align(rec) == cursor->block->frame);
page_zip_des_t *const page_zip= &cursor->block->page.zip;
ulint n_dense; ulint n_dense;
byte* slot_rec; byte* slot_rec;
byte* slot_free; byte* slot_free;
ut_ad(prev_rec != rec); ut_ad(cursor->rec != rec);
ut_ad(page_rec_get_next((rec_t*) prev_rec) == rec); ut_ad(page_rec_get_next_const(cursor->rec) == rec);
ut_ad(page_zip_simple_validate(page_zip)); ut_ad(page_zip_simple_validate(page_zip));
UNIV_MEM_ASSERT_RW(page_zip->data, page_zip_get_size(page_zip)); UNIV_MEM_ASSERT_RW(page_zip->data, page_zip_get_size(page_zip));
if (page_rec_is_infimum(prev_rec)) { if (page_rec_is_infimum(cursor->rec)) {
/* Use the first slot. */ /* Use the first slot. */
slot_rec = page_zip->data + page_zip_get_size(page_zip); slot_rec = page_zip->data + page_zip_get_size(page_zip);
} else { } else {
@ -4398,7 +4387,7 @@ page_zip_dir_insert(
} }
slot_rec = page_zip_dir_find_low(start, end, slot_rec = page_zip_dir_find_low(start, end,
page_offset(prev_rec)); page_offset(cursor->rec));
ut_a(slot_rec); ut_a(slot_rec);
} }

54
storage/innobase/row/row0import.cc
View file

@ -256,6 +256,8 @@ public:
return(page_cur_get_rec(&m_cur)); return(page_cur_get_rec(&m_cur));
} }
buf_block_t* current_block() const { return m_cur.block; }
/** /**
@return true if cursor is at the end */ @return true if cursor is at the end */
bool end() UNIV_NOTHROW bool end() UNIV_NOTHROW
@ -267,7 +269,6 @@ public:
@return true on success */ @return true on success */
bool remove( bool remove(
const dict_index_t* index, const dict_index_t* index,
page_zip_des_t* page_zip,
ulint* offsets) UNIV_NOTHROW ulint* offsets) UNIV_NOTHROW
{ {
ut_ad(page_is_leaf(m_cur.block->frame)); ut_ad(page_is_leaf(m_cur.block->frame));
@ -287,6 +288,7 @@ public:
} }
#ifdef UNIV_ZIP_DEBUG #ifdef UNIV_ZIP_DEBUG
page_zip_des_t* page_zip = buf_block_get_page_zip(m_cur.block);
ut_a(!page_zip || page_zip_validate( ut_a(!page_zip || page_zip_validate(
page_zip, m_cur.block->frame, index)); page_zip, m_cur.block->frame, index));
#endif /* UNIV_ZIP_DEBUG */ #endif /* UNIV_ZIP_DEBUG */
@ -303,6 +305,7 @@ public:
private: private:
page_cur_t m_cur; page_cur_t m_cur;
public:
mtr_t m_mtr; mtr_t m_mtr;
}; };
@ -823,7 +826,6 @@ public:
AbstractCallback(trx, space_id), AbstractCallback(trx, space_id),
m_cfg(cfg), m_cfg(cfg),
m_index(cfg->m_indexes), m_index(cfg->m_indexes),
m_page_zip_ptr(0),
m_rec_iter(), m_rec_iter(),
m_offsets_(), m_offsets(m_offsets_), m_offsets_(), m_offsets(m_offsets_),
m_heap(0), m_heap(0),
@ -931,9 +933,6 @@ private:
/** Current index whose pages are being imported */ /** Current index whose pages are being imported */
row_index_t* m_index; row_index_t* m_index;
/** Alias for m_page_zip, only set for compressed pages. */
page_zip_des_t* m_page_zip_ptr;
/** Iterator over records in a block */ /** Iterator over records in a block */
RecIterator m_rec_iter; RecIterator m_rec_iter;
@ -1616,9 +1615,10 @@ PageConverter::adjust_cluster_index_blob_column(
mach_write_to_4(field, get_space_id()); mach_write_to_4(field, get_space_id());
if (m_page_zip_ptr) { if (UNIV_LIKELY_NULL(m_rec_iter.current_block()->page.zip.data)) {
page_zip_write_blob_ptr( page_zip_write_blob_ptr(
m_page_zip_ptr, rec, m_cluster_index, offsets, i, 0); m_rec_iter.current_block(), rec, m_cluster_index,
offsets, i, &m_rec_iter.m_mtr);
} }
return(DB_SUCCESS); return(DB_SUCCESS);
@ -1689,7 +1689,7 @@ inline bool PageConverter::purge() UNIV_NOTHROW
const dict_index_t* index = m_index->m_srv_index; const dict_index_t* index = m_index->m_srv_index;
/* We can't have a page that is empty and not root. */ /* We can't have a page that is empty and not root. */
if (m_rec_iter.remove(index, m_page_zip_ptr, m_offsets)) { if (m_rec_iter.remove(index, m_offsets)) {
++m_index->m_stats.m_n_purged; ++m_index->m_stats.m_n_purged;
@ -1720,11 +1720,13 @@ PageConverter::adjust_cluster_record(
record. */ record. */
ulint trx_id_pos = m_cluster_index->n_uniq ulint trx_id_pos = m_cluster_index->n_uniq
? m_cluster_index->n_uniq : 1; ? m_cluster_index->n_uniq : 1;
if (m_page_zip_ptr) { if (UNIV_LIKELY_NULL(m_rec_iter.current_block()
->page.zip.data)) {
page_zip_write_trx_id_and_roll_ptr( page_zip_write_trx_id_and_roll_ptr(
m_page_zip_ptr, rec, m_offsets, trx_id_pos, &m_rec_iter.current_block()->page.zip,
rec, m_offsets, trx_id_pos,
0, roll_ptr_t(1) << ROLL_PTR_INSERT_FLAG_POS, 0, roll_ptr_t(1) << ROLL_PTR_INSERT_FLAG_POS,
NULL); &m_rec_iter.m_mtr);
} else { } else {
ulint len; ulint len;
byte* ptr = rec_get_nth_field( byte* ptr = rec_get_nth_field(
@ -1843,8 +1845,8 @@ PageConverter::update_index_page(
the current index id. */ the current index id. */
mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID), mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID),
m_index->m_srv_index->id); m_index->m_srv_index->id);
if (m_page_zip_ptr) { if (UNIV_LIKELY_NULL(block->page.zip.data)) {
memcpy(&m_page_zip_ptr->data[PAGE_HEADER + PAGE_INDEX_ID], memcpy(&block->page.zip.data[PAGE_HEADER + PAGE_INDEX_ID],
&block->frame[PAGE_HEADER + PAGE_INDEX_ID], 8); &block->frame[PAGE_HEADER + PAGE_INDEX_ID], 8);
} }
@ -1891,11 +1893,11 @@ PageConverter::update_index_page(
/* Set PAGE_MAX_TRX_ID on secondary index leaf pages. */ /* Set PAGE_MAX_TRX_ID on secondary index leaf pages. */
mach_write_to_8(&block->frame[PAGE_HEADER + PAGE_MAX_TRX_ID], mach_write_to_8(&block->frame[PAGE_HEADER + PAGE_MAX_TRX_ID],
m_trx->id); m_trx->id);
if (m_page_zip_ptr) { if (UNIV_LIKELY_NULL(block->page.zip.data)) {
memcpy(&m_page_zip_ptr memcpy_aligned<8>(&block->page.zip.data
->data[PAGE_HEADER + PAGE_MAX_TRX_ID], [PAGE_HEADER + PAGE_MAX_TRX_ID],
&block->frame[PAGE_HEADER + PAGE_MAX_TRX_ID], &block->frame
8); [PAGE_HEADER + PAGE_MAX_TRX_ID], 8);
} }
} else { } else {
clear_page_max_trx_id: clear_page_max_trx_id:
@ -1904,10 +1906,12 @@ clear_page_max_trx_id:
in MySQL 5.6, 5.7 and MariaDB 10.0 and 10.1 in MySQL 5.6, 5.7 and MariaDB 10.0 and 10.1
would set the field to the transaction ID even would set the field to the transaction ID even
on clustered index pages. */ on clustered index pages. */
memset(&block->frame[PAGE_HEADER + PAGE_MAX_TRX_ID], 0, 8); memset_aligned<8>(&block->frame[PAGE_HEADER + PAGE_MAX_TRX_ID],
if (m_page_zip_ptr) { 0, 8);
memset(&m_page_zip_ptr if (UNIV_LIKELY_NULL(block->page.zip.data)) {
->data[PAGE_HEADER + PAGE_MAX_TRX_ID], 0, 8); memset_aligned<8>(&block->page.zip.data
[PAGE_HEADER + PAGE_MAX_TRX_ID],
0, 8);
} }
} }
@ -1963,12 +1967,6 @@ PageConverter::update_page(buf_block_t* block, uint16_t& page_type)
ut_ad(!block->page.zip.data == !is_compressed_table()); ut_ad(!block->page.zip.data == !is_compressed_table());
if (block->page.zip.data) {
m_page_zip_ptr = &block->page.zip;
} else {
ut_ad(!m_page_zip_ptr);
}
switch (page_type = fil_page_get_type(get_frame(block))) { switch (page_type = fil_page_get_type(get_frame(block))) {
case FIL_PAGE_TYPE_FSP_HDR: case FIL_PAGE_TYPE_FSP_HDR:
ut_a(block->page.id.page_no() == 0); ut_a(block->page.id.page_no() == 0);