diff options
Diffstat (limited to 'storage/innobase/trx/trx0rec.cc')
| -rw-r--r-- | storage/innobase/trx/trx0rec.cc | 167 |
1 files changed, 100 insertions, 67 deletions
diff --git a/storage/innobase/trx/trx0rec.cc b/storage/innobase/trx/trx0rec.cc index b87eac9362e..a698b37c2a6 100644 --- a/storage/innobase/trx/trx0rec.cc +++ b/storage/innobase/trx/trx0rec.cc @@ -287,7 +287,7 @@ trx_undo_rec_get_pars( TRX_UNDO_INSERT_REC, ... */ ulint* cmpl_info, /*!< out: compiler info, relevant only for update type records */ - ibool* updated_extern, /*!< out: TRUE if we updated an + bool* updated_extern, /*!< out: true if we updated an externally stored fild */ undo_no_t* undo_no, /*!< out: undo log record number */ table_id_t* table_id) /*!< out: table id */ @@ -300,12 +300,8 @@ trx_undo_rec_get_pars( type_cmpl = mach_read_from_1(ptr); ptr++; - if (type_cmpl & TRX_UNDO_UPD_EXTERN) { - *updated_extern = TRUE; - type_cmpl -= TRX_UNDO_UPD_EXTERN; - } else { - *updated_extern = FALSE; - } + *updated_extern = !!(type_cmpl & TRX_UNDO_UPD_EXTERN); + type_cmpl &= ~TRX_UNDO_UPD_EXTERN; *type = type_cmpl & (TRX_UNDO_CMPL_INFO_MULT - 1); *cmpl_info = type_cmpl / TRX_UNDO_CMPL_INFO_MULT; @@ -588,6 +584,7 @@ trx_undo_page_report_modify( /* Store first some general parameters to the undo log */ if (!update) { + ut_ad(!rec_get_deleted_flag(rec, dict_table_is_comp(table))); type_cmpl = TRX_UNDO_DEL_MARK_REC; } else if (rec_get_deleted_flag(rec, dict_table_is_comp(table))) { type_cmpl = TRX_UNDO_UPD_DEL_REC; @@ -1040,8 +1037,9 @@ trx_undo_update_rec_get_update( } /*******************************************************************//** -Builds a partial row from an update undo log record. It contains the -columns which occur as ordering in any index of the table. +Builds a partial row from an update undo log record, for purge. +It contains the columns which occur as ordering in any index of the table. +Any missing columns are indicated by col->mtype == DATA_MISSING. @return pointer to remaining part of undo record */ UNIV_INTERN byte* @@ -1075,7 +1073,12 @@ trx_undo_rec_get_partial_row( *row = dtuple_create(heap, row_len); - dict_table_copy_types(*row, index->table); + /* Mark all columns in the row uninitialized, so that + we can distinguish missing fields from fields that are SQL NULL. */ + for (ulint i = 0; i < row_len; i++) { + dfield_get_type(dtuple_get_nth_field(*row, i)) + ->mtype = DATA_MISSING; + } end_ptr = ptr + mach_read_from_2(ptr); ptr += 2; @@ -1097,7 +1100,9 @@ trx_undo_rec_get_partial_row( ptr = trx_undo_rec_get_col_val(ptr, &field, &len, &orig_len); dfield = dtuple_get_nth_field(*row, col_no); - + dict_col_copy_type( + dict_table_get_nth_col(index->table, col_no), + dfield_get_type(dfield)); dfield_set_data(dfield, field, len); if (len != UNIV_SQL_NULL @@ -1177,7 +1182,7 @@ transaction and in consistent reads that must look to the history of this transaction. @return DB_SUCCESS or error code */ UNIV_INTERN -ulint +dberr_t trx_undo_report_row_operation( /*==========================*/ ulint flags, /*!< in: if BTR_NO_UNDO_LOG_FLAG bit is @@ -1196,6 +1201,7 @@ trx_undo_report_row_operation( const rec_t* rec, /*!< in: in case of an update or delete marking, the record in the clustered index, otherwise NULL */ + const ulint* offsets, /*!< in: rec_get_offsets(rec) */ roll_ptr_t* roll_ptr) /*!< out: rollback pointer to the inserted undo log record, 0 if BTR_NO_UNDO_LOG @@ -1207,16 +1213,14 @@ trx_undo_report_row_operation( buf_block_t* undo_block; trx_rseg_t* rseg; mtr_t mtr; - ulint err = DB_SUCCESS; - mem_heap_t* heap = NULL; - ulint offsets_[REC_OFFS_NORMAL_SIZE]; - ulint* offsets = offsets_; + dberr_t err = DB_SUCCESS; #ifdef UNIV_DEBUG int loop_count = 0; #endif /* UNIV_DEBUG */ - rec_offs_init(offsets_); + ut_ad(!srv_read_only_mode); ut_a(dict_index_is_clust(index)); + ut_ad(!rec || rec_offs_validate(rec, index, offsets)); if (flags & BTR_NO_UNDO_LOG_FLAG) { @@ -1230,6 +1234,17 @@ trx_undo_report_row_operation( || (clust_entry && !update && !rec)); trx = thr_get_trx(thr); + + /* This table is visible only to the session that created it. */ + if (trx->read_only) { + ut_ad(!srv_read_only_mode); + /* MySQL should block writes to non-temporary tables. */ + ut_a(DICT_TF2_FLAG_IS_SET(index->table, DICT_TF2_TEMPORARY)); + if (trx->rseg == 0) { + trx_assign_rseg(trx); + } + } + rseg = trx->rseg; mtr_start(&mtr); @@ -1272,8 +1287,6 @@ trx_undo_report_row_operation( } ut_ad(err == DB_SUCCESS); - offsets = rec_get_offsets(rec, index, offsets, - ULINT_UNDEFINED, &heap); } page_no = undo->last_page_no; @@ -1352,8 +1365,7 @@ trx_undo_report_row_operation( *roll_ptr = trx_undo_build_roll_ptr( op_type == TRX_UNDO_INSERT_OP, rseg->id, page_no, offset); - err = DB_SUCCESS; - goto func_exit; + return(DB_SUCCESS); } ut_ad(page_no == undo->last_page_no); @@ -1380,10 +1392,6 @@ trx_undo_report_row_operation( err_exit: mutex_exit(&trx->undo_mutex); mtr_commit(&mtr); -func_exit: - if (UNIV_LIKELY_NULL(heap)) { - mem_heap_free(heap); - } return(err); } @@ -1428,39 +1436,34 @@ trx_undo_get_undo_rec_low( /******************************************************************//** Copies an undo record to heap. -NOTE: the caller must have latches on the clustered index page and -purge_view. +NOTE: the caller must have latches on the clustered index page. -@return DB_SUCCESS, or DB_MISSING_HISTORY if the undo log has been -truncated and we cannot fetch the old version */ -static -ulint +@retval true if the undo log has been +truncated and we cannot fetch the old version +@retval false if the undo log record is available */ +static __attribute__((nonnull, warn_unused_result)) +bool trx_undo_get_undo_rec( /*==================*/ roll_ptr_t roll_ptr, /*!< in: roll pointer to record */ trx_id_t trx_id, /*!< in: id of the trx that generated the roll pointer: it points to an undo log of this transaction */ - trx_undo_rec_t** undo_rec, /*!< out, own: copy of the record */ + trx_undo_rec_t**undo_rec, /*!< out, own: copy of the record */ mem_heap_t* heap) /*!< in: memory heap where copied */ { - ibool missing_history; + bool missing_history; rw_lock_s_lock(&purge_sys->latch); missing_history = read_view_sees_trx_id(purge_sys->view, trx_id); - rw_lock_s_unlock(&purge_sys->latch); - - if (UNIV_UNLIKELY(missing_history)) { - /* It may be that the necessary undo log has already been - deleted */ - - return(DB_MISSING_HISTORY); + if (!missing_history) { + *undo_rec = trx_undo_get_undo_rec_low(roll_ptr, heap); } - *undo_rec = trx_undo_get_undo_rec_low(roll_ptr, heap); + rw_lock_s_unlock(&purge_sys->latch); - return(DB_SUCCESS); + return(missing_history); } #ifdef UNIV_DEBUG @@ -1471,13 +1474,13 @@ trx_undo_get_undo_rec( /*******************************************************************//** Build a previous version of a clustered index record. The caller must -hold a latch on the index page of the clustered index record, to -guarantee that the stack of versions is locked all the way down to the -purge_sys->view. -@return DB_SUCCESS, or DB_MISSING_HISTORY if the previous version is -earlier than purge_view, which means that it may have been removed */ +hold a latch on the index page of the clustered index record. +@retval true if previous version was built, or if it was an insert +or the table has been rebuilt +@retval false if the previous version is earlier than purge_view, +which means that it may have been removed */ UNIV_INTERN -ulint +bool trx_undo_prev_version_build( /*========================*/ const rec_t* index_rec ATTRIB_USED_ONLY_IN_DEBUG, @@ -1488,7 +1491,7 @@ trx_undo_prev_version_build( index_rec page and purge_view */ const rec_t* rec, /*!< in: version of a clustered index record */ dict_index_t* index, /*!< in: clustered index */ - ulint* offsets,/*!< in: rec_get_offsets(rec, index) */ + ulint* offsets,/*!< in/out: rec_get_offsets(rec, index) */ mem_heap_t* heap, /*!< in: memory heap from which the memory needed is allocated */ rec_t** old_vers)/*!< out, own: previous version, or NULL if @@ -1509,9 +1512,8 @@ trx_undo_prev_version_build( byte* ptr; ulint info_bits; ulint cmpl_info; - ibool dummy_extern; + bool dummy_extern; byte* buf; - ulint err; #ifdef UNIV_SYNC_DEBUG ut_ad(!rw_lock_own(&purge_sys->latch, RW_LOCK_SHARED)); #endif /* UNIV_SYNC_DEBUG */ @@ -1526,28 +1528,28 @@ trx_undo_prev_version_build( *old_vers = NULL; if (trx_undo_roll_ptr_is_insert(roll_ptr)) { - /* The record rec is the first inserted version */ - - return(DB_SUCCESS); + return(true); } rec_trx_id = row_get_rec_trx_id(rec, index, offsets); - err = trx_undo_get_undo_rec(roll_ptr, rec_trx_id, &undo_rec, heap); - - if (UNIV_UNLIKELY(err != DB_SUCCESS)) { - /* The undo record may already have been purged. - This should never happen for user transactions, but - it can happen in purge. */ - ut_ad(err == DB_MISSING_HISTORY); - - return(err); + if (trx_undo_get_undo_rec(roll_ptr, rec_trx_id, &undo_rec, heap)) { + /* The undo record may already have been purged, + during purge or semi-consistent read. */ + return(false); } ptr = trx_undo_rec_get_pars(undo_rec, &type, &cmpl_info, &dummy_extern, &undo_no, &table_id); + if (table_id != index->table->id) { + /* The table should have been rebuilt, but purge has + not yet removed the undo log records for the + now-dropped old table (table_id). */ + return(true); + } + ptr = trx_undo_update_rec_get_sys_cols(ptr, &trx_id, &roll_ptr, &info_bits); @@ -1578,7 +1580,6 @@ trx_undo_prev_version_build( ptr = trx_undo_update_rec_get_update(ptr, index, type, trx_id, roll_ptr, info_bits, NULL, heap, &update); - ut_a(table_id == index->table->id); ut_a(ptr); # if defined UNIV_DEBUG || defined UNIV_BLOB_LIGHT_DEBUG @@ -1588,14 +1589,46 @@ trx_undo_prev_version_build( if (row_upd_changes_field_size_or_external(index, offsets, update)) { ulint n_ext; + /* We should confirm the existence of disowned external data, + if the previous version record is delete marked. If the trx_id + of the previous record is seen by purge view, we should treat + it as missing history, because the disowned external data + might be purged already. + + The inherited external data (BLOBs) can be freed (purged) + after trx_id was committed, provided that no view was started + before trx_id. If the purge view can see the committed + delete-marked record by trx_id, no transactions need to access + the BLOB. */ + + /* the row_upd_changes_disowned_external(update) call could be + omitted, but the synchronization on purge_sys->latch is likely + more expensive. */ + + if ((update->info_bits & REC_INFO_DELETED_FLAG) + && row_upd_changes_disowned_external(update)) { + bool missing_extern; + + rw_lock_s_lock(&purge_sys->latch); + missing_extern = read_view_sees_trx_id(purge_sys->view, + trx_id); + rw_lock_s_unlock(&purge_sys->latch); + + if (missing_extern) { + /* treat as a fresh insert, not to + cause assertion error at the caller. */ + return(true); + } + } + /* We have to set the appropriate extern storage bits in the old version of the record: the extern bits in rec for those fields that update does NOT update, as well as the bits for those fields that update updates to become externally stored fields. Store the info: */ - entry = row_rec_to_index_entry(ROW_COPY_DATA, rec, index, - offsets, &n_ext, heap); + entry = row_rec_to_index_entry( + rec, index, offsets, &n_ext, heap); n_ext += btr_push_update_extern_fields(entry, update, heap); /* The page containing the clustered index record corresponding to entry is latched in mtr. Thus the @@ -1618,6 +1651,6 @@ trx_undo_prev_version_build( row_upd_rec_in_place(*old_vers, index, offsets, update, NULL); } - return(DB_SUCCESS); + return(true); } #endif /* !UNIV_HOTBACKUP */ |