数据库内核月报 － 2018 / 11

dberr_t row_search_mvcc(byte *buf, page_cur_mode_t mode,
                        row_prebuilt_t *prebuilt, ulint match_mode,
                        ulint direction) {
  ...
  /* This is a non-locking consistent read: if necessary, fetch
  a previous version of the record */

  if (trx->isolation_level == TRX_ISO_READ_UNCOMMITTED) {
      /* Do nothing: we let a non-locking SELECT read the
      latest version of the record */

  } else if (index == clust_index) {
    /* Fetch a previous version of the row if the current
    one is not visible in the snapshot; if we have a very
    high force recovery level set, we try to avoid crashes
    by skipping this lookup */

    if (srv_force_recovery < 5 &&
        !lock_clust_rec_cons_read_sees(rec, index, offsets,
        trx_get_read_view(trx))) {
      rec_t *old_vers;
      /* The following call returns 'offsets' associated with 'old_vers' */
      err = row_sel_build_prev_vers_for_mysql(
          trx->read_view, clust_index, prebuilt, rec, &offsets, &heap,
          &old_vers, need_vrow ? &vrow : NULL, &mtr,
          prebuilt->get_lob_undo());
}

dberr_t row_search_mvcc(byte *buf, page_cur_mode_t mode,
                        row_prebuilt_t *prebuilt, ulint match_mode,
                        ulint direction) {
  ...
  /* This is a non-locking consistent read: if necessary, fetch
  a previous version of the record */

  if (trx->isolation_level == TRX_ISO_READ_UNCOMMITTED) {
      /* Do nothing: we let a non-locking SELECT read the
      latest version of the record */

  } else if (index == clust_index) {
    ...
  } else {
    /* We are looking into a non-clustered index,
    and to get the right version of the record we
    have to look also into the clustered index: this
    is necessary, because we can only get the undo
    information via the clustered index record. */

    ut_ad(!index->is_clustered());

    if (!srv_read_only_mode &&
        !lock_sec_rec_cons_read_sees(rec, index, trx->read_view)) {
      /* We should look at the clustered index.
      However, as this is a non-locking read,
      we can skip the clustered index lookup if
      the condition does not match the secondary
      index entry. */
      switch (row_search_idx_cond_check(buf, prebuilt, rec, offsets)) {
        case ICP_NO_MATCH:
          goto next_rec;
        case ICP_OUT_OF_RANGE:
          err = DB_RECORD_NOT_FOUND;
          goto idx_cond_failed;
        case ICP_MATCH:
          goto requires_clust_rec;
      }
      ...
}

bool lock_sec_rec_cons_read_sees(
    const rec_t *rec,          /*!< in: user record which
                               should be read or passed over
                               by a read cursor */
    const dict_index_t *index, /*!< in: index */
    const ReadView *view)      /*!< in: consistent read view */
{
  ...
  trx_id_t max_trx_id = page_get_max_trx_id(page_align(rec));

  ut_ad(max_trx_id > 0);

  return (view->sees(max_trx_id));
}

/** Allocates a new transaction id.
 @return new, allocated trx id */
UNIV_INLINE
trx_id_t trx_sys_get_new_trx_id() {
  ut_ad(trx_sys_mutex_own());

  /* VERY important: after the database is started, max_trx_id value is
  divisible by TRX_SYS_TRX_ID_WRITE_MARGIN, and the following if
  will evaluate to TRUE when this function is first time called,
  and the value for trx id will be written to disk-based header!
  Thus trx id values will not overlap when the database is
  repeatedly started! */

  if (!(trx_sys->max_trx_id % TRX_SYS_TRX_ID_WRITE_MARGIN)) {
    trx_sys_flush_max_trx_id();
  }

  return (trx_sys->max_trx_id++);
}

trx_commit_low->trx_write_serialisation_history->trx_serialisation_number_get

/** Set the transaction serialisation number.
 @return true if the transaction number was added to the serialisation_list. */
static bool trx_serialisation_number_get(
    trx_t *trx,                         /*!< in/out: transaction */
    trx_undo_ptr_t *redo_rseg_undo_ptr, /*!< in/out: Set trx
                                        serialisation number in
                                        referred undo rseg. */
    trx_undo_ptr_t *temp_rseg_undo_ptr) /*!< in/out: Set trx
                                        serialisation number in
                                        referred undo rseg. */
{
    ...
    trx->no = trx_sys_get_new_trx_id();
    ...                                    
}

bool changes_visible(trx_id_t id, const table_name_t &name) const
    MY_ATTRIBUTE((warn_unused_result)) {
  ut_ad(id > 0);

  if (id < m_up_limit_id || id == m_creator_trx_id) {
    return (true);
  }

  check_trx_id_sanity(id, name);

  if (id >= m_low_limit_id) {
    return (false);

  } else if (m_ids.empty()) {
    return (true);
  }

  const ids_t::value_type *p = m_ids.data();

  return (!std::binary_search(p, p + m_ids.size(), id));
}

row_search_mvcc()
{
  case DB_LOCK_WAIT:
    /* Lock wait for R-tree should already
    be handled in sel_set_rtr_rec_lock() */
    ut_ad(!dict_index_is_spatial(index));
    /* Never unlock rows that were part of a conflict. */
    std::fill_n(prebuilt->new_rec_lock, row_prebuilt_t::LOCK_COUNT, false);

    if (UNIV_LIKELY(prebuilt->row_read_type !=
                    ROW_READ_TRY_SEMI_CONSISTENT) ||
        unique_search || index != clust_index) {
      goto lock_wait_or_error;
    }

    /* The following call returns 'offsets' associated with 'old_vers' */
    row_sel_build_committed_vers_for_mysql(clust_index, prebuilt, rec,
                                           &offsets, &heap, &old_vers,
                                           need_vrow ? &vrow : NULL, &mtr);
}