mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-05-16 20:07:13 +02:00
Code Issues Projects Releases Packages Wiki Activity

Bug#54728: Replace the dulint struct with a 64-bit integer.

Browse source
This commit is contained in:
Marko Mäkelä 2010-06-23 14:06:59 +03:00
commit c1567ecebd
89 changed files with 874 additions and 1572 deletions
Download patch file Download diff file Expand all files Collapse all files

6
storage/innobase/btr/btr0btr.c
View file

@ -737,7 +737,7 @@ btr_create(
ulint space, /*!< in: space where created */
ulint zip_size,/*!< in: compressed page size in bytes
or 0 for uncompressed pages */
dulint index_id,/*!< in: index id */
index_id_t index_id,/*!< in: index id */
dict_index_t* index, /*!< in: index */
mtr_t* mtr) /*!< in: mini-transaction handle */
{
@ -1020,7 +1020,7 @@ btr_page_reorganize_low(
/* In crash recovery, dict_index_is_sec_or_ibuf() always
returns TRUE, even for clustered indexes. max_trx_id is
unused in clustered index pages. */
ut_ad(!ut_dulint_is_zero(max_trx_id) || recovery);
ut_ad(max_trx_id != 0 || recovery);
}
if (UNIV_LIKELY_NULL(page_zip)
@ -2883,7 +2883,7 @@ btr_discard_only_page_on_level(
ibuf_reset_free_bits(block);
if (page_is_leaf(buf_block_get_frame(block))) {
ut_a(!ut_dulint_is_zero(max_trx_id));
ut_a(max_trx_id);
page_set_max_trx_id(block,
buf_block_get_page_zip(block),
max_trx_id, mtr);

12
storage/innobase/btr/btr0cur.c
View file

@ -660,7 +660,7 @@ retry_page_get:
buf_block_dbg_add_level(block, SYNC_TREE_NODE);
}
ut_ad(0 == ut_dulint_cmp(index->id, btr_page_get_index_id(page)));
ut_ad(index->id == btr_page_get_index_id(page));
if (UNIV_UNLIKELY(height == ULINT_UNDEFINED)) {
/* We are in the root node */
@ -854,8 +854,7 @@ btr_cur_open_at_index_side_func(
RW_NO_LATCH, NULL, BUF_GET,
file, line, mtr);
page = buf_block_get_frame(block);
ut_ad(0 == ut_dulint_cmp(index->id,
btr_page_get_index_id(page)));
ut_ad(index->id == btr_page_get_index_id(page));
block->check_index_page_at_flush = TRUE;
@ -975,8 +974,7 @@ btr_cur_open_at_rnd_pos_func(
RW_NO_LATCH, NULL, BUF_GET,
file, line, mtr);
page = buf_block_get_frame(block);
ut_ad(0 == ut_dulint_cmp(index->id,
btr_page_get_index_id(page)));
ut_ad(index->id == btr_page_get_index_id(page));
if (height == ULINT_UNDEFINED) {
/* We are in the root node */
@ -1135,7 +1133,7 @@ btr_cur_trx_report(
const char* op) /*!< in: operation */
{
fprintf(stderr, "Trx with id " TRX_ID_FMT " going to ",
TRX_ID_PREP_PRINTF(trx->id));
(ullint) trx->id);
fputs(op, stderr);
dict_index_name_print(stderr, trx, index);
putc('\n', stderr);
@ -1826,7 +1824,7 @@ btr_cur_update_in_place(
page_zip_des_t* page_zip;
ulint err;
rec_t* rec;
roll_ptr_t roll_ptr = ut_dulint_zero;
roll_ptr_t roll_ptr = 0;
trx_t* trx;
ulint was_delete_marked;
mem_heap_t* heap = NULL;

47
storage/innobase/btr/btr0sea.c
View file

@ -523,9 +523,9 @@ btr_search_update_hash_ref(
buf_block_t* block, /*!< in: buffer block where cursor positioned */
btr_cur_t* cursor) /*!< in: cursor */
{
ulint fold;
rec_t* rec;
dulint index_id;
ulint fold;
rec_t* rec;
index_id_t index_id;
ut_ad(cursor->flag == BTR_CUR_HASH_FAIL);
#ifdef UNIV_SYNC_DEBUG
@ -830,7 +830,7 @@ btr_search_guess_on_hash(
buf_block_t* block;
rec_t* rec;
ulint fold;
dulint index_id;
index_id_t index_id;
#ifdef notdefined
btr_cur_t cursor2;
btr_pcur_t pcur;
@ -922,8 +922,7 @@ btr_search_guess_on_hash(
is positioned on. We cannot look at the next of the previous
record to determine if our guess for the cursor position is
right. */
if (UNIV_EXPECT
(ut_dulint_cmp(index_id, btr_page_get_index_id(block->frame)), 0)
if (UNIV_UNLIKELY(index_id != btr_page_get_index_id(block->frame))
|| !btr_search_check_guess(cursor,
has_search_latch,
tuple, mode, mtr)) {
@ -1028,7 +1027,7 @@ btr_search_drop_page_hash_index(
const rec_t* rec;
ulint fold;
ulint prev_fold;
dulint index_id;
index_id_t index_id;
ulint n_cached;
ulint n_recs;
ulint* folds;
@ -1088,7 +1087,7 @@ retry:
index_id = btr_page_get_index_id(page);
ut_a(0 == ut_dulint_cmp(index_id, index->id));
ut_a(index_id == index->id);
prev_fold = 0;
@ -1245,7 +1244,7 @@ btr_search_build_page_hash_index(
rec_t* next_rec;
ulint fold;
ulint next_fold;
dulint index_id;
index_id_t index_id;
ulint n_cached;
ulint n_recs;
ulint* folds;
@ -1498,7 +1497,7 @@ btr_search_update_hash_on_delete(
buf_block_t* block;
rec_t* rec;
ulint fold;
dulint index_id;
index_id_t index_id;
ibool found;
ulint offsets_[REC_OFFS_NORMAL_SIZE];
mem_heap_t* heap = NULL;
@ -1604,7 +1603,7 @@ btr_search_update_hash_on_insert(
rec_t* rec;
rec_t* ins_rec;
rec_t* next_rec;
dulint index_id;
index_id_t index_id;
ulint fold;
ulint ins_fold;
ulint next_fold = 0; /* remove warning (??? bug ???) */
@ -1784,6 +1783,7 @@ btr_search_validate(void)
= buf_block_align(node->data);
const buf_block_t* hash_block;
buf_pool_t* buf_pool;
index_id_t page_index_id;
buf_pool = buf_pool_from_bpage((buf_page_t*) block);
@ -1828,12 +1828,15 @@ btr_search_validate(void)
+ (block->curr_n_bytes > 0),
&heap);
if (!block->is_hashed || node->fold
!= rec_fold((rec_t*)(node->data),
offsets,
block->curr_n_fields,
block->curr_n_bytes,
btr_page_get_index_id(block->frame))) {
page_index_id = btr_page_get_index_id(block->frame);
if (UNIV_UNLIKELY
(!block->is_hashed || node->fold
!= rec_fold((rec_t*)(node->data),
offsets,
block->curr_n_fields,
block->curr_n_bytes,
page_index_id))) {
const page_t* page = block->frame;
ok = FALSE;
@ -1843,21 +1846,17 @@ btr_search_validate(void)
" InnoDB: Error in an adaptive hash"
" index pointer to page %lu\n"
"InnoDB: ptr mem address %p"
" index id %lu %lu,"
" index id %llu,"
" node fold %lu, rec fold %lu\n",
(ulong) page_get_page_no(page),
node->data,
(ulong) ut_dulint_get_high(
btr_page_get_index_id(page)),
(ulong) ut_dulint_get_low(
btr_page_get_index_id(page)),
(ullint) page_index_id,
(ulong) node->fold,
(ulong) rec_fold((rec_t*)(node->data),
offsets,
block->curr_n_fields,
block->curr_n_bytes,
btr_page_get_index_id(
page)));
page_index_id));
fputs("InnoDB: Record ", stderr);
rec_print_new(stderr, (rec_t*)node->data,

31
storage/innobase/buf/buf0buf.c
View file

@ -522,7 +522,9 @@ buf_page_is_corrupted(
ib_uint64_t current_lsn;
if (log_peek_lsn(&current_lsn)
&& current_lsn < mach_read_ull(read_buf + FIL_PAGE_LSN)) {
&& UNIV_UNLIKELY
(current_lsn
< mach_read_from_8(read_buf + FIL_PAGE_LSN))) {
ut_print_timestamp(stderr);
fprintf(stderr,
@ -538,7 +540,7 @@ buf_page_is_corrupted(
"InnoDB: for more information.\n",
(ulong) mach_read_from_4(read_buf
+ FIL_PAGE_OFFSET),
mach_read_ull(read_buf + FIL_PAGE_LSN),
mach_read_from_8(read_buf + FIL_PAGE_LSN),
current_lsn);
}
}
@ -735,17 +737,15 @@ buf_page_print(
#endif /* !UNIV_HOTBACKUP */
switch (fil_page_get_type(read_buf)) {
index_id_t index_id;
case FIL_PAGE_INDEX:
index_id = btr_page_get_index_id(read_buf);
fprintf(stderr,
"InnoDB: Page may be an index page where"
" index id is %lu %lu\n",
(ulong) ut_dulint_get_high(
btr_page_get_index_id(read_buf)),
(ulong) ut_dulint_get_low(
btr_page_get_index_id(read_buf)));
" index id is %llu\n",
(ullint) index_id);
#ifndef UNIV_HOTBACKUP
index = dict_index_find_on_id_low(
btr_page_get_index_id(read_buf));
index = dict_index_find_on_id_low(index_id);
if (index) {
fputs("InnoDB: (", stderr);
dict_index_name_print(stderr, NULL, index);
@ -4461,12 +4461,12 @@ buf_print_instance(
/*===============*/
buf_pool_t* buf_pool)
{
dulint* index_ids;
index_id_t* index_ids;
ulint* counts;
ulint size;
ulint i;
ulint j;
dulint id;
index_id_t id;
ulint n_found;
buf_chunk_t* chunk;
dict_index_t* index;
@ -4475,7 +4475,7 @@ buf_print_instance(
size = buf_pool->curr_size;
index_ids = mem_alloc(sizeof(dulint) * size);
index_ids = mem_alloc(size * sizeof *index_ids);
counts = mem_alloc(sizeof(ulint) * size);
buf_pool_mutex_enter(buf_pool);
@ -4530,8 +4530,7 @@ buf_print_instance(
while (j < n_found) {
if (ut_dulint_cmp(index_ids[j],
id) == 0) {
if (index_ids[j] == id) {
counts[j]++;
break;
@ -4554,8 +4553,8 @@ buf_print_instance(
index = dict_index_get_if_in_cache(index_ids[i]);
fprintf(stderr,
"Block count for index %lu in buffer is about %lu",
(ulong) ut_dulint_get_low(index_ids[i]),
"Block count for index %llu in buffer is about %lu",
(ullint) index_ids[i],
(ulong) counts[i]);
if (index) {

14
storage/innobase/buf/buf0flu.c
View file

@ -982,8 +982,8 @@ buf_flush_init_for_writing(
case FIL_PAGE_TYPE_ZBLOB:
case FIL_PAGE_TYPE_ZBLOB2:
case FIL_PAGE_INDEX:
mach_write_ull(page_zip->data
+ FIL_PAGE_LSN, newest_lsn);
mach_write_to_8(page_zip->data
+ FIL_PAGE_LSN, newest_lsn);
memset(page_zip->data + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
mach_write_to_4(page_zip->data
+ FIL_PAGE_SPACE_OR_CHKSUM,
@ -1005,10 +1005,10 @@ buf_flush_init_for_writing(
}
/* Write the newest modification lsn to the page header and trailer */
mach_write_ull(page + FIL_PAGE_LSN, newest_lsn);
mach_write_to_8(page + FIL_PAGE_LSN, newest_lsn);
mach_write_ull(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
newest_lsn);
mach_write_to_8(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM,
newest_lsn);
/* Store the new formula checksum */
@ -1096,8 +1096,8 @@ buf_flush_write_block_low(
ut_a(mach_read_from_4(frame + FIL_PAGE_SPACE_OR_CHKSUM)
== page_zip_calc_checksum(frame, zip_size));
}
mach_write_ull(frame + FIL_PAGE_LSN,
bpage->newest_modification);
mach_write_to_8(frame + FIL_PAGE_LSN,
bpage->newest_modification);
memset(frame + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
break;
case BUF_BLOCK_FILE_PAGE:

10
storage/innobase/buf/buf0lru.c
View file

@ -2278,19 +2278,17 @@ buf_LRU_print_instance(
case BUF_BLOCK_FILE_PAGE:
frame = buf_block_get_frame((buf_block_t*) bpage);
fprintf(stderr, "\ntype %lu"
" index id %lu\n",
" index id %llu\n",
(ulong) fil_page_get_type(frame),
(ulong) ut_dulint_get_low(
btr_page_get_index_id(frame)));
(ullint) btr_page_get_index_id(frame));
break;
case BUF_BLOCK_ZIP_PAGE:
frame = bpage->zip.data;
fprintf(stderr, "\ntype %lu size %lu"
" index id %lu\n",
" index id %llu\n",
(ulong) fil_page_get_type(frame),
(ulong) buf_page_get_zip_size(bpage),
(ulong) ut_dulint_get_low(
btr_page_get_index_id(frame)));
(ullint) btr_page_get_index_id(frame));
break;
default:

28
storage/innobase/data/data0data.c
View file

@ -367,7 +367,7 @@ dfield_print_also_hex(
prtype = dtype_get_prtype(dfield_get_type(dfield));
switch (dtype_get_mtype(dfield_get_type(dfield))) {
dulint id;
ib_id_t id;
case DATA_INT:
switch (len) {
ulint val;
@ -417,22 +417,16 @@ dfield_print_also_hex(
case 6:
id = mach_read_from_6(data);
fprintf(stderr, "{%lu %lu}",
ut_dulint_get_high(id),
ut_dulint_get_low(id));
fprintf(stderr, "%llu", (ullint) id);
break;
case 7:
id = mach_read_from_7(data);
fprintf(stderr, "{%lu %lu}",
ut_dulint_get_high(id),
ut_dulint_get_low(id));
fprintf(stderr, "%llu", (ullint) id);
break;
case 8:
id = mach_read_from_8(data);
fprintf(stderr, "{%lu %lu}",
ut_dulint_get_high(id),
ut_dulint_get_low(id));
fprintf(stderr, "%llu", (ullint) id);
break;
default:
goto print_hex;
@ -444,29 +438,25 @@ dfield_print_also_hex(
case DATA_TRX_ID:
id = mach_read_from_6(data);
fprintf(stderr, "trx_id " TRX_ID_FMT,
TRX_ID_PREP_PRINTF(id));
fprintf(stderr, "trx_id " TRX_ID_FMT, (ullint) id);
break;
case DATA_ROLL_PTR:
id = mach_read_from_7(data);
fprintf(stderr, "roll_ptr {%lu %lu}",
ut_dulint_get_high(id), ut_dulint_get_low(id));
fprintf(stderr, "roll_ptr " TRX_ID_FMT, (ullint) id);
break;
case DATA_ROW_ID:
id = mach_read_from_6(data);
fprintf(stderr, "row_id {%lu %lu}",
ut_dulint_get_high(id), ut_dulint_get_low(id));
fprintf(stderr, "row_id " TRX_ID_FMT, (ullint) id);
break;
default:
id = mach_dulint_read_compressed(data);
id = mach_ull_read_compressed(data);
fprintf(stderr, "mix_id {%lu %lu}",
ut_dulint_get_high(id), ut_dulint_get_low(id));
fprintf(stderr, "mix_id " TRX_ID_FMT, (ullint) id);
}
break;

47
storage/innobase/dict/dict0boot.c
View file

@ -67,12 +67,15 @@ UNIV_INTERN
void
dict_hdr_get_new_id(
/*================*/
dulint* table_id, /*!< out: table id (not assigned if NULL) */
dulint* index_id, /*!< out: index id (not assigned if NULL) */
ulint* space_id) /*!< out: space id (not assigned if NULL) */
table_id_t* table_id, /*!< out: table id
(not assigned if NULL) */
index_id_t* index_id, /*!< out: index id
(not assigned if NULL) */
ulint* space_id) /*!< out: space id
(not assigned if NULL) */
{
dict_hdr_t* dict_hdr;
dulint id;
ib_id_t id;
mtr_t mtr;
mtr_start(&mtr);
@ -80,16 +83,16 @@ dict_hdr_get_new_id(
dict_hdr = dict_hdr_get(&mtr);
if (table_id) {
id = mtr_read_dulint(dict_hdr + DICT_HDR_TABLE_ID, &mtr);
id = ut_dulint_add(id, 1);
mlog_write_dulint(dict_hdr + DICT_HDR_TABLE_ID, id, &mtr);
id = mach_read_from_8(dict_hdr + DICT_HDR_TABLE_ID);
id++;
mlog_write_ull(dict_hdr + DICT_HDR_TABLE_ID, id, &mtr);
*table_id = id;
}
if (index_id) {
id = mtr_read_dulint(dict_hdr + DICT_HDR_INDEX_ID, &mtr);
id = ut_dulint_add(id, 1);
mlog_write_dulint(dict_hdr + DICT_HDR_INDEX_ID, id, &mtr);
id = mach_read_from_8(dict_hdr + DICT_HDR_INDEX_ID);
id++;
mlog_write_ull(dict_hdr + DICT_HDR_INDEX_ID, id, &mtr);
*index_id = id;
}
@ -114,7 +117,7 @@ dict_hdr_flush_row_id(void)
/*=======================*/
{
dict_hdr_t* dict_hdr;
dulint id;
row_id_t id;
mtr_t mtr;
ut_ad(mutex_own(&(dict_sys->mutex)));
@ -125,7 +128,7 @@ dict_hdr_flush_row_id(void)
dict_hdr = dict_hdr_get(&mtr);
mlog_write_dulint(dict_hdr + DICT_HDR_ROW_ID, id, &mtr);
mlog_write_ull(dict_hdr + DICT_HDR_ROW_ID, id, &mtr);
mtr_commit(&mtr);
}
@ -157,14 +160,14 @@ dict_hdr_create(
/* Start counting row, table, index, and tree ids from
DICT_HDR_FIRST_ID */
mlog_write_dulint(dict_header + DICT_HDR_ROW_ID,
ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
mlog_write_ull(dict_header + DICT_HDR_ROW_ID,
DICT_HDR_FIRST_ID, mtr);
mlog_write_dulint(dict_header + DICT_HDR_TABLE_ID,
ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
mlog_write_ull(dict_header + DICT_HDR_TABLE_ID,
DICT_HDR_FIRST_ID, mtr);
mlog_write_dulint(dict_header + DICT_HDR_INDEX_ID,
ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
mlog_write_ull(dict_header + DICT_HDR_INDEX_ID,
DICT_HDR_FIRST_ID, mtr);
mlog_write_ulint(dict_header + DICT_HDR_MAX_SPACE_ID,
0, MLOG_4BYTES, mtr);
@ -273,11 +276,9 @@ dict_boot(void)
..._MARGIN, it will immediately be updated to the disk-based
header. */
dict_sys->row_id = ut_dulint_add(
ut_dulint_align_up(mtr_read_dulint(dict_hdr + DICT_HDR_ROW_ID,
&mtr),
DICT_HDR_ROW_ID_WRITE_MARGIN),
DICT_HDR_ROW_ID_WRITE_MARGIN);
dict_sys->row_id = DICT_HDR_ROW_ID_WRITE_MARGIN
+ ut_uint64_align_up(mach_read_from_8(dict_hdr + DICT_HDR_ROW_ID),
DICT_HDR_ROW_ID_WRITE_MARGIN);
/* Insert into the dictionary cache the descriptions of the basic
system tables */

13
storage/innobase/dict/dict0crea.c
View file

@ -578,7 +578,7 @@ dict_build_index_def_step(
ins_node_set_new_row(node->ind_def, row);
/* Note that the index was created by this transaction. */
index->trx_id = (ib_uint64_t) ut_conv_dulint_to_longlong(trx->id);
index->trx_id = trx->id;
return(DB_SUCCESS);
}
@ -749,7 +749,7 @@ dict_truncate_index_tree(
ibool drop = !space;
ulint zip_size;
ulint type;
dulint index_id;
index_id_t index_id;
rec_t* rec;
const byte* ptr;
ulint len;
@ -842,7 +842,7 @@ create:
for (index = UT_LIST_GET_FIRST(table->indexes);
index;
index = UT_LIST_GET_NEXT(indexes, index)) {
if (!ut_dulint_cmp(index->id, index_id)) {
if (index->id == index_id) {
root_page_no = btr_create(type, space, zip_size,
index_id, index, mtr);
index->page = (unsigned int) root_page_no;
@ -852,10 +852,9 @@ create:
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Index %lu %lu of table %s is missing\n"
" InnoDB: Index %llu of table %s is missing\n"
"InnoDB: from the data dictionary during TRUNCATE!\n",
ut_dulint_get_high(index_id),
ut_dulint_get_low(index_id),
(ullint) index_id,
table->name);
return(FIL_NULL);
@ -1107,7 +1106,7 @@ dict_create_index_step(
if (node->state == INDEX_ADD_TO_CACHE) {
dulint index_id = node->index->id;
index_id_t index_id = node->index->id;
err = dict_index_add_to_cache(
node->table, node->index, FIL_NULL,

50
storage/innobase/dict/dict0dict.c
View file

@ -256,8 +256,8 @@ dict_mutex_exit_for_mysql(void)
/** Get the mutex that protects index->stat_n_diff_key_vals[] */
#define GET_INDEX_STAT_MUTEX(index) \
(&dict_index_stat_mutex[ut_fold_dulint(index->id) \
% DICT_INDEX_STAT_MUTEX_SIZE])
(&dict_index_stat_mutex[ut_fold_ull(index->id) \
% DICT_INDEX_STAT_MUTEX_SIZE])
/**********************************************************************//**
Lock the appropriate mutex to protect index->stat_n_diff_key_vals[].
@ -425,14 +425,14 @@ dict_index_t*
dict_index_get_on_id_low(
/*=====================*/
dict_table_t* table, /*!< in: table */
dulint id) /*!< in: index id */
index_id_t id) /*!< in: index id */
{
dict_index_t* index;
index = dict_table_get_first_index(table);
while (index) {
if (0 == ut_dulint_cmp(id, index->id)) {
if (id == index->id) {
/* Found */
return(index);
@ -574,12 +574,12 @@ UNIV_INTERN
dict_table_t*
dict_table_get_on_id(
/*=================*/
dulint table_id, /*!< in: table id */
trx_t* trx) /*!< in: transaction handle */
table_id_t table_id, /*!< in: table id */
trx_t* trx) /*!< in: transaction handle */
{
dict_table_t* table;
if (ut_dulint_cmp(table_id, DICT_FIELDS_ID) <= 0
if (table_id <= DICT_FIELDS_ID
|| trx->dict_operation_lock_mode == RW_X_LATCH) {
/* It is a system table which will always exist in the table
cache: we avoid acquiring the dictionary mutex, because
@ -800,7 +800,7 @@ dict_table_add_to_cache(
table->cached = TRUE;
fold = ut_fold_string(table->name);
id_fold = ut_fold_dulint(table->id);
id_fold = ut_fold_ull(table->id);
row_len = 0;
for (i = 0; i < table->n_def; i++) {
@ -842,7 +842,7 @@ dict_table_add_to_cache(
dict_table_t* table2;
HASH_SEARCH(id_hash, dict_sys->table_id_hash, id_fold,
dict_table_t*, table2, ut_ad(table2->cached),
ut_dulint_cmp(table2->id, table->id) == 0);
table2->id == table->id);
ut_a(table2 == NULL);
#ifdef UNIV_DEBUG
@ -877,7 +877,7 @@ UNIV_INTERN
dict_index_t*
dict_index_find_on_id_low(
/*======================*/
dulint id) /*!< in: index id */
index_id_t id) /*!< in: index id */
{
dict_table_t* table;
dict_index_t* index;
@ -888,7 +888,7 @@ dict_index_find_on_id_low(
index = dict_table_get_first_index(table);
while (index) {
if (0 == ut_dulint_cmp(id, index->id)) {
if (id == index->id) {
/* Found */
return(index);
@ -1144,7 +1144,7 @@ void
dict_table_change_id_in_cache(
/*==========================*/
dict_table_t* table, /*!< in/out: table object already in cache */
dulint new_id) /*!< in: new id to set */
table_id_t new_id) /*!< in: new id to set */
{
ut_ad(table);
ut_ad(mutex_own(&(dict_sys->mutex)));
@ -1153,12 +1153,12 @@ dict_table_change_id_in_cache(
/* Remove the table from the hash table of id's */
HASH_DELETE(dict_table_t, id_hash, dict_sys->table_id_hash,
ut_fold_dulint(table->id), table);
ut_fold_ull(table->id), table);
table->id = new_id;
/* Add the table back to the hash table */
HASH_INSERT(dict_table_t, id_hash, dict_sys->table_id_hash,
ut_fold_dulint(table->id), table);
ut_fold_ull(table->id), table);
}
/**********************************************************************//**
@ -1214,7 +1214,7 @@ dict_table_remove_from_cache(
HASH_DELETE(dict_table_t, name_hash, dict_sys->table_hash,
ut_fold_string(table->name), table);
HASH_DELETE(dict_table_t, id_hash, dict_sys->table_id_hash,
ut_fold_dulint(table->id), table);
ut_fold_ull(table->id), table);
/* Remove table from LRU list of tables */
UT_LIST_REMOVE(table_LRU, dict_sys->table_LRU, table);
@ -2476,8 +2476,7 @@ dict_table_get_index_by_max_id(
/* We found a matching index, select
the index with the higher id*/
if (!found
|| ut_dulint_cmp(index->id, found->id) > 0) {
if (!found || index->id > found->id) {
found = index;
}
@ -3965,7 +3964,7 @@ UNIV_INTERN
dict_index_t*
dict_index_get_if_in_cache_low(
/*===========================*/
dulint index_id) /*!< in: index id */
index_id_t index_id) /*!< in: index id */
{
ut_ad(mutex_own(&(dict_sys->mutex)));
@ -3980,7 +3979,7 @@ UNIV_INTERN
dict_index_t*
dict_index_get_if_in_cache(
/*=======================*/
dulint index_id) /*!< in: index id */
index_id_t index_id) /*!< in: index id */
{
dict_index_t* index;
@ -4376,12 +4375,11 @@ dict_table_print_low(
fprintf(stderr,
"--------------------------------------\n"
"TABLE: name %s, id %lu %lu, flags %lx, columns %lu,"
"TABLE: name %s, id %llu, flags %lx, columns %lu,"
" indexes %lu, appr.rows %lu\n"
" COLUMNS: ",
table->name,
(ulong) ut_dulint_get_high(table->id),
(ulong) ut_dulint_get_low(table->id),
(ullint) table->id,
(ulong) table->flags,
(ulong) table->n_cols,
(ulong) UT_LIST_GET_LEN(table->indexes),
@ -4470,14 +4468,13 @@ dict_index_print_low(
}
fprintf(stderr,
" INDEX: name %s, id %lu %lu, fields %lu/%lu,"
" INDEX: name %s, id %llu, fields %lu/%lu,"
" uniq %lu, type %lu\n"
" root page %lu, appr.key vals %lu,"
" leaf pages %lu, size pages %lu\n"
" FIELDS: ",
index->name,
(ulong) ut_dulint_get_high(index->id),
(ulong) ut_dulint_get_low(index->id),
(ullint) index->id,
(ulong) index->n_user_defined_cols,
(ulong) index->n_fields,
(ulong) index->n_uniq,
@ -4849,8 +4846,7 @@ dict_table_get_index_on_name_and_min_id(
while (index != NULL) {
if (ut_strcmp(index->name, name) == 0) {
if (!min_index
|| ut_dulint_cmp(index->id, min_index->id) < 0) {
if (!min_index || index->id < min_index->id) {
min_index = index;
}

29
storage/innobase/dict/dict0load.c
View file

@ -364,7 +364,7 @@ dict_process_sys_indexes_rec(
mem_heap_t* heap, /*!< in/out: heap memory */
const rec_t* rec, /*!< in: current SYS_INDEXES rec */
dict_index_t* index, /*!< out: index to be filled */
dulint* table_id) /*!< out: index table id */
table_id_t* table_id) /*!< out: index table id */
{
const char* err_msg;
byte* buf;
@ -390,7 +390,7 @@ dict_process_sys_columns_rec(
mem_heap_t* heap, /*!< in/out: heap memory */
const rec_t* rec, /*!< in: current SYS_COLUMNS rec */
dict_col_t* column, /*!< out: dict_col_t to be filled */
dulint* table_id, /*!< out: table id */
table_id_t* table_id, /*!< out: table id */
const char** col_name) /*!< out: column name */
{
const char* err_msg;
@ -414,8 +414,8 @@ dict_process_sys_fields_rec(
dict_field_t* sys_field, /*!< out: dict_field_t to be
filled */
ulint* pos, /*!< out: Field position */
dulint* index_id, /*!< out: current index id */
dulint last_id) /*!< in: previous index id */
index_id_t* index_id, /*!< out: current index id */
index_id_t last_id) /*!< in: previous index id */
{
byte* buf;
byte* last_index_id;
@ -789,7 +789,7 @@ dict_load_column_low(
for temporary storage */
dict_col_t* column, /*!< out: dict_column_t to fill,
or NULL if table != NULL */
dulint* table_id, /*!< out: table id */
table_id_t* table_id, /*!< out: table id */
const char** col_name, /*!< out: column name */
const rec_t* rec) /*!< in: SYS_COLUMNS record */
{
@ -819,8 +819,7 @@ err_len:
if (table_id) {
*table_id = mach_read_from_8(field);
} else if (UNIV_UNLIKELY(ut_dulint_cmp(table->id,
mach_read_from_8(field)))) {
} else if (UNIV_UNLIKELY(table->id != mach_read_from_8(field))) {
return("SYS_COLUMNS.TABLE_ID mismatch");
}
@ -1199,7 +1198,7 @@ dict_load_index_low(
ulint len;
ulint name_len;
char* name_buf;
dulint id;
index_id_t id;
ulint n_fields;
ulint type;
ulint space;
@ -1316,19 +1315,11 @@ dict_load_indexes(
dfield_t* dfield;
const rec_t* rec;
byte* buf;
ibool is_sys_table;
mtr_t mtr;
ulint error = DB_SUCCESS;
ut_ad(mutex_own(&(dict_sys->mutex)));
if ((ut_dulint_get_high(table->id) == 0)
&& (ut_dulint_get_low(table->id) < DICT_HDR_FIRST_ID)) {
is_sys_table = TRUE;
} else {
is_sys_table = FALSE;
}
mtr_start(&mtr);
sys_indexes = dict_table_get_low("SYS_INDEXES");
@ -1414,7 +1405,7 @@ corrupted:
" is not clustered!\n", stderr);
goto corrupted;
} else if (is_sys_table
} else if (table->id < DICT_HDR_FIRST_ID
&& (dict_index_is_clust(index)
|| ((table == dict_sys->sys_tables)
&& !strcmp("ID_IND", index->name)))) {
@ -1774,7 +1765,7 @@ UNIV_INTERN
dict_table_t*
dict_load_table_on_id(
/*==================*/
dulint table_id) /*!< in: table id */
table_id_t table_id) /*!< in: table id */
{
byte id_buf[8];
btr_pcur_t pcur;
@ -1837,7 +1828,7 @@ dict_load_table_on_id(
ut_ad(len == 8);
/* Check if the table id in record is the one searched for */
if (ut_dulint_cmp(table_id, mach_read_from_8(field)) != 0) {
if (table_id != mach_read_from_8(field)) {
btr_pcur_close(&pcur);
mtr_commit(&mtr);

10
storage/innobase/fil/fil0fil.c
View file

@ -1705,7 +1705,7 @@ fil_write_lsn_and_arch_no_to_file(
fil_read(TRUE, 0, 0, sum_of_sizes, 0, UNIV_PAGE_SIZE, buf, NULL);
mach_write_ull(buf + FIL_PAGE_FILE_FLUSH_LSN, lsn);
mach_write_to_8(buf + FIL_PAGE_FILE_FLUSH_LSN, lsn);
fil_write(TRUE, 0, 0, sum_of_sizes, 0, UNIV_PAGE_SIZE, buf, NULL);
@ -1799,7 +1799,7 @@ fil_read_flushed_lsn_and_arch_log_no(
os_file_read(data_file, buf, 0, 0, UNIV_PAGE_SIZE);
flushed_lsn = mach_read_ull(buf + FIL_PAGE_FILE_FLUSH_LSN);
flushed_lsn = mach_read_from_8(buf + FIL_PAGE_FILE_FLUSH_LSN);
ut_free(buf2);
@ -2850,7 +2850,7 @@ fil_reset_too_high_lsns(
/* We have to read the file flush lsn from the header of the file */
flush_lsn = mach_read_ull(page + FIL_PAGE_FILE_FLUSH_LSN);
flush_lsn = mach_read_from_8(page + FIL_PAGE_FILE_FLUSH_LSN);
if (current_lsn >= flush_lsn) {
/* Ok */
@ -2898,7 +2898,7 @@ fil_reset_too_high_lsns(
goto func_exit;
}
if (mach_read_ull(page + FIL_PAGE_LSN) > current_lsn) {
if (mach_read_from_8(page + FIL_PAGE_LSN) > current_lsn) {
/* We have to reset the lsn */
if (zip_size) {
@ -2940,7 +2940,7 @@ fil_reset_too_high_lsns(
goto func_exit;
}
mach_write_ull(page + FIL_PAGE_FILE_FLUSH_LSN, current_lsn);
mach_write_to_8(page + FIL_PAGE_FILE_FLUSH_LSN, current_lsn);
success = os_file_write(filepath, file, page, 0, 0,
zip_size ? zip_size : UNIV_PAGE_SIZE);

141
storage/innobase/fsp/fsp0fsp.c
View file

@ -127,9 +127,8 @@ typedef byte fseg_inode_t;
#define FSEG_ARR_OFFSET (FSEG_PAGE_DATA + FLST_NODE_SIZE)
/*-------------------------------------*/
#define FSEG_ID 0 /* 8 bytes of segment id: if this is
ut_dulint_zero, it means that the
header is unused */
#define FSEG_ID 0 /* 8 bytes of segment id: if this is 0,
it means that the header is unused */
#define FSEG_NOT_FULL_N_USED 8
/* number of used segment pages in
the FSEG_NOT_FULL list */
@ -999,11 +998,11 @@ fsp_header_init(
flst_init(header + FSP_SEG_INODES_FULL, mtr);
flst_init(header + FSP_SEG_INODES_FREE, mtr);
mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1), mtr);
mlog_write_ull(header + FSP_SEG_ID, 1, mtr);
if (space == 0) {
fsp_fill_free_list(FALSE, space, header, mtr);
btr_create(DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF,
0, 0, ut_dulint_add(DICT_IBUF_ID_MIN, space),
0, 0, DICT_IBUF_ID_MIN + space,
dict_ind_redundant, mtr);
} else {
fsp_fill_free_list(TRUE, space, header, mtr);
@ -1841,7 +1840,7 @@ fsp_seg_inode_page_find_used(
inode = fsp_seg_inode_page_get_nth_inode(
page, i, zip_size, mtr);
if (!ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))) {
if (mach_read_from_8(inode + FSEG_ID)) {
/* This is used */
ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
@ -1872,7 +1871,7 @@ fsp_seg_inode_page_find_free(
inode = fsp_seg_inode_page_get_nth_inode(
page, i, zip_size, mtr);
if (ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))) {
if (!mach_read_from_8(inode + FSEG_ID)) {
/* This is unused */
return(i);
@ -1931,7 +1930,7 @@ fsp_alloc_seg_inode_page(
inode = fsp_seg_inode_page_get_nth_inode(page, i,
zip_size, mtr);
mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
mlog_write_ull(inode + FSEG_ID, 0, mtr);
}
flst_add_last(space_header + FSP_SEG_INODES_FREE,
@ -1998,7 +1997,7 @@ fsp_alloc_seg_inode(
page + FSEG_INODE_PAGE_NODE, mtr);
}
ut_ad(ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))
ut_ad(!mach_read_from_8(inode + FSEG_ID)
|| mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
return(inode);
}
@ -2036,7 +2035,7 @@ fsp_free_seg_inode(
page + FSEG_INODE_PAGE_NODE, mtr);
}
mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
mlog_write_ull(inode + FSEG_ID, 0, mtr);
mlog_write_ulint(inode + FSEG_MAGIC_N, 0xfa051ce3, MLOG_4BYTES, mtr);
if (ULINT_UNDEFINED
@ -2073,8 +2072,7 @@ fseg_inode_try_get(
inode = fut_get_ptr(space, zip_size, inode_addr, RW_X_LATCH, mtr);
if (UNIV_UNLIKELY
(ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID)))) {
if (UNIV_UNLIKELY(!mach_read_from_8(inode + FSEG_ID))) {
inode = NULL;
} else {
@ -2249,7 +2247,7 @@ fseg_create_general(
ulint zip_size;
fsp_header_t* space_header;
fseg_inode_t* inode;
dulint seg_id;
ib_id_t seg_id;
buf_block_t* block = 0; /* remove warning */
fseg_header_t* header = 0; /* remove warning */
rw_lock_t* latch;
@ -2303,12 +2301,11 @@ fseg_create_general(
/* Read the next segment id from space header and increment the
value in space header */
seg_id = mtr_read_dulint(space_header + FSP_SEG_ID, mtr);
seg_id = mach_read_from_8(space_header + FSP_SEG_ID);
mlog_write_dulint(space_header + FSP_SEG_ID, ut_dulint_add(seg_id, 1),
mtr);
mlog_write_ull(space_header + FSP_SEG_ID, seg_id + 1, mtr);
mlog_write_dulint(inode + FSEG_ID, seg_id, mtr);
mlog_write_ull(inode + FSEG_ID, seg_id, mtr);
mlog_write_ulint(inode + FSEG_NOT_FULL_N_USED, 0, MLOG_4BYTES, mtr);
flst_init(inode + FSEG_FREE, mtr);
@ -2460,7 +2457,7 @@ fseg_fill_free_list(
{
xdes_t* descr;
ulint i;
dulint seg_id;
ib_id_t seg_id;
ulint reserved;
ulint used;
@ -2497,10 +2494,10 @@ fseg_fill_free_list(
xdes_set_state(descr, XDES_FSEG, mtr);
seg_id = mtr_read_dulint(inode + FSEG_ID, mtr);
seg_id = mach_read_from_8(inode + FSEG_ID);
ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
== FSEG_MAGIC_N_VALUE);
mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
mlog_write_ull(descr + XDES_ID, seg_id, mtr);
flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
hint += FSP_EXTENT_SIZE;
@ -2524,7 +2521,7 @@ fseg_alloc_free_extent(
mtr_t* mtr) /*!< in: mtr */
{
xdes_t* descr;
dulint seg_id;
ib_id_t seg_id;
fil_addr_t first;
ut_ad(!((page_offset(inode) - FSEG_ARR_OFFSET) % FSEG_INODE_SIZE));
@ -2545,10 +2542,10 @@ fseg_alloc_free_extent(
return(NULL);
}
seg_id = mtr_read_dulint(inode + FSEG_ID, mtr);
seg_id = mach_read_from_8(inode + FSEG_ID);
xdes_set_state(descr, XDES_FSEG, mtr);
mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
mlog_write_ull(descr + XDES_ID, seg_id, mtr);
flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
/* Try to fill the segment free list */
@ -2583,7 +2580,7 @@ fseg_alloc_free_page_low(
{
fsp_header_t* space_header;
ulint space_size;
dulint seg_id;
ib_id_t seg_id;
ulint used;
ulint reserved;
xdes_t* descr; /*!< extent of the hinted page */
@ -2599,9 +2596,9 @@ fseg_alloc_free_page_low(
ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N)
== FSEG_MAGIC_N_VALUE);
ut_ad(!((page_offset(seg_inode) - FSEG_ARR_OFFSET) % FSEG_INODE_SIZE));
seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr);
seg_id = mach_read_from_8(seg_inode + FSEG_ID);
ut_ad(!ut_dulint_is_zero(seg_id));
ut_ad(seg_id);
reserved = fseg_n_reserved_pages_low(seg_inode, &used, mtr);
@ -2619,8 +2616,7 @@ fseg_alloc_free_page_low(
/* In the big if-else below we look for ret_page and ret_descr */
/*-------------------------------------------------------------*/
if ((xdes_get_state(descr, mtr) == XDES_FSEG)
&& (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
mtr), seg_id))
&& mach_read_from_8(descr + XDES_ID) == seg_id
&& (xdes_get_bit(descr, XDES_FREE_BIT,
hint % FSP_EXTENT_SIZE, mtr) == TRUE)) {
@ -2642,7 +2638,7 @@ fseg_alloc_free_page_low(
ut_a(ret_descr == descr);
xdes_set_state(ret_descr, XDES_FSEG, mtr);
mlog_write_dulint(ret_descr + XDES_ID, seg_id, mtr);
mlog_write_ull(ret_descr + XDES_ID, seg_id, mtr);
flst_add_last(seg_inode + FSEG_FREE,
ret_descr + XDES_FLST_NODE, mtr);
@ -2671,8 +2667,7 @@ fseg_alloc_free_page_low(
}
/*-----------------------------------------------------------*/
} else if ((xdes_get_state(descr, mtr) == XDES_FSEG)
&& (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
mtr), seg_id))
&& mach_read_from_8(descr + XDES_ID) == seg_id
&& (!xdes_is_full(descr, mtr))) {
/* 4. We can take the page from the same extent as the
@ -3243,8 +3238,8 @@ fseg_free_page_low(
xdes_t* descr;
ulint not_full_n_used;
ulint state;
dulint descr_id;
dulint seg_id;
ib_id_t descr_id;
ib_id_t seg_id;
ulint i;
ut_ad(seg_inode && mtr);
@ -3303,20 +3298,18 @@ crash:
/* If we get here, the page is in some extent of the segment */
descr_id = mtr_read_dulint(descr + XDES_ID, mtr);
seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr);
descr_id = mach_read_from_8(descr + XDES_ID);
seg_id = mach_read_from_8(seg_inode + FSEG_ID);
#if 0
fprintf(stderr,
"InnoDB: InnoDB is freeing space %lu page %lu,\n"
"InnoDB: which belongs to descr seg %lu %lu\n"
"InnoDB: segment %lu %lu.\n",
"InnoDB: which belongs to descr seg %llu\n"
"InnoDB: segment %llu.\n",
(ulong) space, (ulong) page,
(ulong) ut_dulint_get_high(descr_id),
(ulong) ut_dulint_get_low(descr_id),
(ulong) ut_dulint_get_high(seg_id),
(ulong) ut_dulint_get_low(seg_id));
(ullint) descr_id,
(ullint) seg_id);
#endif /* 0 */
if (0 != ut_dulint_cmp(descr_id, seg_id)) {
if (UNIV_UNLIKELY(descr_id != seg_id)) {
fputs("InnoDB: Dump of the tablespace extent descriptor: ",
stderr);
ut_print_buf(stderr, descr, 40);
@ -3328,13 +3321,11 @@ crash:
"InnoDB: Serious error: InnoDB is trying to"
" free space %lu page %lu,\n"
"InnoDB: which does not belong to"
" segment %lu %lu but belongs\n"
"InnoDB: to segment %lu %lu.\n",
" segment %llu but belongs\n"
"InnoDB: to segment %llu.\n",
(ulong) space, (ulong) page,
(ulong) ut_dulint_get_high(descr_id),
(ulong) ut_dulint_get_low(descr_id),
(ulong) ut_dulint_get_high(seg_id),
(ulong) ut_dulint_get_low(seg_id));
(ullint) descr_id,
(ullint) seg_id);
goto crash;
}
@ -3423,8 +3414,7 @@ fseg_free_extent(
descr = xdes_get_descriptor(space, zip_size, page, mtr);
ut_a(xdes_get_state(descr, mtr) == XDES_FSEG);
ut_a(0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, mtr),
mtr_read_dulint(seg_inode + FSEG_ID, mtr)));
ut_a(!memcmp(descr + XDES_ID, seg_inode + FSEG_ID, 8));
ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N)
== FSEG_MAGIC_N_VALUE);
@ -3684,7 +3674,7 @@ fseg_validate_low(
mtr_t* mtr2) /*!< in: mtr */
{
ulint space;
dulint seg_id;
ib_id_t seg_id;
mtr_t mtr;
xdes_t* descr;
fil_addr_t node_addr;
@ -3696,7 +3686,7 @@ fseg_validate_low(
space = page_get_space_id(page_align(inode));
seg_id = mtr_read_dulint(inode + FSEG_ID, mtr2);
seg_id = mach_read_from_8(inode + FSEG_ID);
n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED,
MLOG_4BYTES, mtr2);
flst_validate(inode + FSEG_FREE, mtr2);
@ -3719,8 +3709,7 @@ fseg_validate_low(
ut_a(xdes_get_n_used(descr, &mtr) == 0);
ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
ut_a(!ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, &mtr),
seg_id));
ut_a(mach_read_from_8(descr + XDES_ID) == seg_id);
node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
mtr_commit(&mtr);
@ -3744,8 +3733,7 @@ fseg_validate_low(
ut_a(xdes_get_n_used(descr, &mtr) > 0);
ut_a(xdes_get_n_used(descr, &mtr) < FSP_EXTENT_SIZE);
ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
ut_a(!ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, &mtr),
seg_id));
ut_a(mach_read_from_8(descr + XDES_ID) == seg_id);
n_used2 += xdes_get_n_used(descr, &mtr);
@ -3770,8 +3758,7 @@ fseg_validate_low(
ut_a(xdes_get_n_used(descr, &mtr) == FSP_EXTENT_SIZE);
ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
ut_a(!ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, &mtr),
seg_id));
ut_a(mach_read_from_8(descr + XDES_ID) == seg_id);
node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
mtr_commit(&mtr);
@ -3822,8 +3809,6 @@ fseg_print_low(
mtr_t* mtr) /*!< in: mtr */
{
ulint space;
ulint seg_id_low;
ulint seg_id_high;
ulint n_used;
ulint n_frag;
ulint n_free;
@ -3832,7 +3817,7 @@ fseg_print_low(
ulint reserved;
ulint used;
ulint page_no;
dulint d_var;
ib_id_t seg_id;
ut_ad(mtr_memo_contains_page(mtr, inode, MTR_MEMO_PAGE_X_FIX));
space = page_get_space_id(page_align(inode));
@ -3840,10 +3825,7 @@ fseg_print_low(
reserved = fseg_n_reserved_pages_low(inode, &used, mtr);
d_var = mtr_read_dulint(inode + FSEG_ID, mtr);
seg_id_low = ut_dulint_get_low(d_var);
seg_id_high = ut_dulint_get_high(d_var);
seg_id = mach_read_from_8(inode + FSEG_ID);
n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED,
MLOG_4BYTES, mtr);
@ -3853,11 +3835,11 @@ fseg_print_low(
n_full = flst_get_len(inode + FSEG_FULL, mtr);
fprintf(stderr,
"SEGMENT id %lu %lu space %lu; page %lu;"
"SEGMENT id %llu space %lu; page %lu;"
" res %lu used %lu; full ext %lu\n"
"fragm pages %lu; free extents %lu;"
" not full extents %lu: pages %lu\n",
(ulong) seg_id_high, (ulong) seg_id_low,
(ullint) seg_id,
(ulong) space, (ulong) page_no,
(ulong) reserved, (ulong) used, (ulong) n_full,
(ulong) n_frag, (ulong) n_free, (ulong) n_not_full,
@ -4059,8 +4041,7 @@ fsp_validate(
seg_inode = fsp_seg_inode_page_get_nth_inode(
seg_inode_page, n, zip_size, &mtr);
ut_a(!ut_dulint_is_zero(
mach_read_from_8(seg_inode + FSEG_ID)));
ut_a(mach_read_from_8(seg_inode + FSEG_ID) != 0);
fseg_validate_low(seg_inode, &mtr);
descr_count += flst_get_len(seg_inode + FSEG_FREE,
@ -4105,8 +4086,7 @@ fsp_validate(
seg_inode = fsp_seg_inode_page_get_nth_inode(
seg_inode_page, n, zip_size, &mtr);
if (!ut_dulint_is_zero(
mach_read_from_8(seg_inode + FSEG_ID))) {
if (mach_read_from_8(seg_inode + FSEG_ID)) {
fseg_validate_low(seg_inode, &mtr);
descr_count += flst_get_len(
@ -4168,11 +4148,9 @@ fsp_print(
ulint n_free;
ulint n_free_frag;
ulint n_full_frag;
ulint seg_id_low;
ulint seg_id_high;
ib_id_t seg_id;
ulint n;
ulint n_segs = 0;
dulint d_var;
mtr_t mtr;
mtr_t mtr2;
@ -4202,21 +4180,18 @@ fsp_print(
n_free_frag = flst_get_len(header + FSP_FREE_FRAG, &mtr);
n_full_frag = flst_get_len(header + FSP_FULL_FRAG, &mtr);
d_var = mtr_read_dulint(header + FSP_SEG_ID, &mtr);
seg_id_low = ut_dulint_get_low(d_var);
seg_id_high = ut_dulint_get_high(d_var);
seg_id = mach_read_from_8(header + FSP_SEG_ID);
fprintf(stderr,
"FILE SPACE INFO: id %lu\n"
"size %lu, free limit %lu, free extents %lu\n"
"not full frag extents %lu: used pages %lu,"
" full frag extents %lu\n"
"first seg id not used %lu %lu\n",
"first seg id not used %llu\n",
(ulong) space,
(ulong) size, (ulong) free_limit, (ulong) n_free,
(ulong) n_free_frag, (ulong) frag_n_used, (ulong) n_full_frag,
(ulong) seg_id_high, (ulong) seg_id_low);
(ullint) seg_id);
mtr_commit(&mtr);
@ -4246,8 +4221,7 @@ fsp_print(
seg_inode = fsp_seg_inode_page_get_nth_inode(
seg_inode_page, n, zip_size, &mtr);
ut_a(!ut_dulint_is_zero(
mach_read_from_8(seg_inode + FSEG_ID)));
ut_a(mach_read_from_8(seg_inode + FSEG_ID) != 0);
fseg_print_low(seg_inode, &mtr);
n_segs++;
@ -4284,8 +4258,7 @@ fsp_print(
seg_inode = fsp_seg_inode_page_get_nth_inode(
seg_inode_page, n, zip_size, &mtr);
if (!ut_dulint_is_zero(
mach_read_from_8(seg_inode + FSEG_ID))) {
if (mach_read_from_8(seg_inode + FSEG_ID)) {
fseg_print_low(seg_inode, &mtr);
n_segs++;

4
storage/innobase/handler/ha_innodb.cc
View file

@ -2967,9 +2967,9 @@ innobase_close_connection(
global_system_variables.log_warnings) {
sql_print_warning(
"MySQL is closing a connection that has an active "
"InnoDB transaction. %lu row modifications will "
"InnoDB transaction. %llu row modifications will "
"roll back.",
(ulong) trx->undo_no.low);
(ullint) trx->undo_no);
}
innobase_rollback_trx(trx);

45
storage/innobase/handler/i_s.cc
View file

@ -1973,16 +1973,13 @@ i_s_dict_fill_sys_tables(
dict_table_t* table, /*!< in: table */
TABLE* table_to_fill) /*!< in/out: fill this table */
{
longlong table_id;
Field** fields;
DBUG_ENTER("i_s_dict_fill_sys_tables");
fields = table_to_fill->field;
table_id = ut_conv_dulint_to_longlong(table->id);
OK(fields[SYS_TABLE_ID]->store(table_id, TRUE));
OK(fields[SYS_TABLE_ID]->store(longlong(table->id), TRUE));
OK(field_store_string(fields[SYS_TABLE_NAME], table->name));
@ -2238,16 +2235,13 @@ i_s_dict_fill_sys_tablestats(
dict_table_t* table, /*!< in: table */
TABLE* table_to_fill) /*!< in/out: fill this table */
{
longlong table_id;
Field** fields;
DBUG_ENTER("i_s_dict_fill_sys_tablestats");
fields = table_to_fill->field;
table_id = ut_conv_dulint_to_longlong(table->id);
OK(fields[SYS_TABLESTATS_ID]->store(table_id, TRUE));
OK(fields[SYS_TABLESTATS_ID]->store(longlong(table->id), TRUE));
OK(field_store_string(fields[SYS_TABLESTATS_NAME], table->name));
@ -2495,27 +2489,22 @@ int
i_s_dict_fill_sys_indexes(
/*======================*/
THD* thd, /*!< in: thread */
dulint tableid, /*!< in: table id */
table_id_t table_id, /*!< in: table id */
dict_index_t* index, /*!< in: populated dict_index_t
struct with index info */
TABLE* table_to_fill) /*!< in/out: fill this table */
{
longlong table_id;
longlong index_id;
Field** fields;
DBUG_ENTER("i_s_dict_fill_sys_indexes");
fields = table_to_fill->field;
table_id = ut_conv_dulint_to_longlong(tableid);
index_id = ut_conv_dulint_to_longlong(index->id);
OK(fields[SYS_INDEX_ID]->store(index_id, TRUE));
OK(fields[SYS_INDEX_ID]->store(longlong(index->id), TRUE));
OK(field_store_string(fields[SYS_INDEX_NAME], index->name));
OK(fields[SYS_INDEX_TABLE_ID]->store(table_id, TRUE));
OK(fields[SYS_INDEX_TABLE_ID]->store(longlong(table_id), TRUE));
OK(fields[SYS_INDEX_TYPE]->store(index->type));
@ -2564,7 +2553,7 @@ i_s_sys_indexes_fill_table(
/* Process each record in the table */
while (rec) {
const char* err_msg;;
dulint table_id;
table_id_t table_id;
dict_index_t index_rec;
/* Populate a dict_index_t structure with information from
@ -2737,22 +2726,19 @@ int
i_s_dict_fill_sys_columns(
/*======================*/
THD* thd, /*!< in: thread */
dulint tableid, /*!< in: table ID */
table_id_t table_id, /*!< in: table ID */
const char* col_name, /*!< in: column name */
dict_col_t* column, /*!< in: dict_col_t struct holding
more column information */
TABLE* table_to_fill) /*!< in/out: fill this table */
{
longlong table_id;
Field** fields;
DBUG_ENTER("i_s_dict_fill_sys_columns");
fields = table_to_fill->field;
table_id = ut_conv_dulint_to_longlong(tableid);
OK(fields[SYS_COLUMN_TABLE_ID]->store(table_id, TRUE));
OK(fields[SYS_COLUMN_TABLE_ID]->store(longlong(table_id), TRUE));
OK(field_store_string(fields[SYS_COLUMN_NAME], col_name));
@ -2803,7 +2789,7 @@ i_s_sys_columns_fill_table(
while (rec) {
const char* err_msg;
dict_col_t column_rec;
dulint table_id;
table_id_t table_id;
/* populate a dict_col_t structure with information from
a SYS_COLUMNS row */
@ -2948,21 +2934,18 @@ int
i_s_dict_fill_sys_fields(
/*=====================*/
THD* thd, /*!< in: thread */
dulint indexid, /*!< in: index id for the field */
index_id_t index_id, /*!< in: index id for the field */
dict_field_t* field, /*!< in: table */
ulint pos, /*!< in: Field position */
TABLE* table_to_fill) /*!< in/out: fill this table */
{
longlong index_id;
Field** fields;
DBUG_ENTER("i_s_dict_fill_sys_fields");
fields = table_to_fill->field;
index_id = ut_conv_dulint_to_longlong(indexid);
OK(fields[SYS_FIELD_INDEX_ID]->store(index_id, TRUE));
OK(fields[SYS_FIELD_INDEX_ID]->store(longlong(index_id), TRUE));
OK(field_store_string(fields[SYS_FIELD_NAME], field->name));
@ -2988,7 +2971,7 @@ i_s_sys_fields_fill_table(
btr_pcur_t pcur;
const rec_t* rec;
mem_heap_t* heap;
dulint last_id;
index_id_t last_id;
mtr_t mtr;
DBUG_ENTER("i_s_sys_fields_fill_table");
@ -3005,14 +2988,14 @@ i_s_sys_fields_fill_table(
/* will save last index id so that we know whether we move to
the next index. This is used to calculate prefix length */
last_id = ut_dulint_create(0, 0);
last_id = 0;
rec = dict_startscan_system(&pcur, &mtr, SYS_FIELDS);
while (rec) {
ulint pos;
const char* err_msg;
dulint index_id;
index_id_t index_id;
dict_field_t field_rec;
/* Populate a dict_field_t structure with information from

4
storage/innobase/ibuf/ibuf0ibuf.c
View file

@ -565,7 +565,7 @@ ibuf_init_at_db_start(void)
dict_mem_table_add_col(table, heap, "DUMMY_COLUMN", DATA_BINARY, 0, 0);
table->id = ut_dulint_add(DICT_IBUF_ID_MIN, IBUF_SPACE_ID);
table->id = DICT_IBUF_ID_MIN + IBUF_SPACE_ID;
dict_table_add_to_cache(table, heap);
mem_heap_free(heap);
@ -576,7 +576,7 @@ ibuf_init_at_db_start(void)
dict_mem_index_add_field(index, "DUMMY_COLUMN", 0);
index->id = ut_dulint_add(DICT_IBUF_ID_MIN, IBUF_SPACE_ID);
index->id = DICT_IBUF_ID_MIN + IBUF_SPACE_ID;
error = dict_index_add_to_cache(table, index,
FSP_IBUF_TREE_ROOT_PAGE_NO, FALSE);

4
storage/innobase/include/btr0btr.h
View file

@ -130,7 +130,7 @@ btr_page_get(
Gets the index id field of a page.
@return index id */
UNIV_INLINE
dulint
index_id_t
btr_page_get_index_id(
/*==================*/
const page_t* page); /*!< in: index page */
@ -226,7 +226,7 @@ btr_create(
ulint space, /*!< in: space where created */
ulint zip_size,/*!< in: compressed page size in bytes
or 0 for uncompressed pages */
dulint index_id,/*!< in: index id */
index_id_t index_id,/*!< in: index id */
dict_index_t* index, /*!< in: index */
mtr_t* mtr); /*!< in: mini-transaction handle */
/************************************************************//**

7
storage/innobase/include/btr0btr.ic
View file

@ -86,7 +86,7 @@ btr_page_set_index_id(
page_t* page, /*!< in: page to be created */
page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed
part will be updated, or NULL */
dulint id, /*!< in: index id */
index_id_t id, /*!< in: index id */
mtr_t* mtr) /*!< in: mtr */
{
if (UNIV_LIKELY_NULL(page_zip)) {
@ -95,8 +95,7 @@ btr_page_set_index_id(
page + (PAGE_HEADER + PAGE_INDEX_ID),
8, mtr);
} else {
mlog_write_dulint(page + (PAGE_HEADER + PAGE_INDEX_ID),
id, mtr);
mlog_write_ull(page + (PAGE_HEADER + PAGE_INDEX_ID), id, mtr);
}
}
#endif /* !UNIV_HOTBACKUP */
@ -105,7 +104,7 @@ btr_page_set_index_id(
Gets the index id field of a page.
@return index id */
UNIV_INLINE
dulint
index_id_t
btr_page_get_index_id(
/*==================*/
const page_t* page) /*!< in: index page */

2
storage/innobase/include/data0data.h
View file

@ -309,7 +309,7 @@ dtuple_fold(
ulint n_fields,/*!< in: number of complete fields to fold */
ulint n_bytes,/*!< in: number of bytes to fold in an
incomplete last field */
dulint tree_id)/*!< in: index tree id */
index_id_t tree_id)/*!< in: index tree id */
__attribute__((pure));
/*******************************************************************//**
Sets types of fields binary in a tuple. */

4
storage/innobase/include/data0data.ic
View file

@ -518,7 +518,7 @@ dtuple_fold(
ulint n_fields,/*!< in: number of complete fields to fold */
ulint n_bytes,/*!< in: number of bytes to fold in an
incomplete last field */
dulint tree_id)/*!< in: index tree id */
index_id_t tree_id)/*!< in: index tree id */
{
const dfield_t* field;
ulint i;
@ -530,7 +530,7 @@ dtuple_fold(
ut_ad(tuple->magic_n == DATA_TUPLE_MAGIC_N);
ut_ad(dtuple_check_typed(tuple));
fold = ut_fold_dulint(tree_id);
fold = ut_fold_ull(tree_id);
for (i = 0; i < n_fields; i++) {
field = dtuple_get_nth_field(tuple, i);

2
storage/innobase/include/data0type.h
View file

@ -128,7 +128,7 @@ columns, and for them the precise type is usually not used at all.
/* Precise data types for system columns and the length of those columns;
NOTE: the values must run from 0 up in the order given! All codes must
be less than 256 */
#define DATA_ROW_ID 0 /* row id: a dulint */
#define DATA_ROW_ID 0 /* row id: a 48-bit integer */
#define DATA_ROW_ID_LEN 6 /* stored length for row id */
#define DATA_TRX_ID 1 /* transaction id: 6 bytes */

31
storage/innobase/include/dict0boot.h
View file

@ -51,32 +51,35 @@ UNIV_INTERN
void
dict_hdr_get_new_id(
/*================*/
dulint* table_id, /*!< out: table id (not assigned if NULL) */
dulint* index_id, /*!< out: index id (not assigned if NULL) */
ulint* space_id); /*!< out: space id (not assigned if NULL) */
table_id_t* table_id, /*!< out: table id
(not assigned if NULL) */
index_id_t* index_id, /*!< out: index id
(not assigned if NULL) */
ulint* space_id); /*!< out: space id
(not assigned if NULL) */
/**********************************************************************//**
Returns a new row id.
@return the new id */
UNIV_INLINE
dulint
row_id_t
dict_sys_get_new_row_id(void);
/*=========================*/
/**********************************************************************//**
Reads a row id from a record or other 6-byte stored form.
@return row id */
UNIV_INLINE
dulint
row_id_t
dict_sys_read_row_id(
/*=================*/
byte* field); /*!< in: record field */
const byte* field); /*!< in: record field */
/**********************************************************************//**
Writes a row id to a record or other 6-byte stored form. */
UNIV_INLINE
void
dict_sys_write_row_id(
/*==================*/
byte* field, /*!< in: record field */
dulint row_id);/*!< in: row id */
byte* field, /*!< in: record field */
row_id_t row_id);/*!< in: row id */
/*****************************************************************//**
Initializes the data dictionary memory structures when the database is
started. This function is also called when the data dictionary is created. */
@ -97,12 +100,12 @@ dict_create(void);
#define DICT_HDR_PAGE_NO FSP_DICT_HDR_PAGE_NO
/* The ids for the basic system tables and their indexes */
#define DICT_TABLES_ID ut_dulint_create(0, 1)
#define DICT_COLUMNS_ID ut_dulint_create(0, 2)
#define DICT_INDEXES_ID ut_dulint_create(0, 3)
#define DICT_FIELDS_ID ut_dulint_create(0, 4)
#define DICT_TABLES_ID 1
#define DICT_COLUMNS_ID 2
#define DICT_INDEXES_ID 3
#define DICT_FIELDS_ID 4
/* The following is a secondary index on SYS_TABLES */
#define DICT_TABLE_IDS_ID ut_dulint_create(0, 5)
#define DICT_TABLE_IDS_ID 5
#define DICT_HDR_FIRST_ID 10 /* the ids for tables etc. start
from this number, except for basic
@ -110,7 +113,7 @@ dict_create(void);
indexes; ibuf tables and indexes are
assigned as the id the number
DICT_IBUF_ID_MIN plus the space id */
#define DICT_IBUF_ID_MIN ut_dulint_create(0xFFFFFFFFUL, 0)
#define DICT_IBUF_ID_MIN 0xFFFFFFFF00000000ULL
/* The offset of the dictionary header on the page */
#define DICT_HDR FSEG_PAGE_DATA

16
storage/innobase/include/dict0boot.ic
View file

@ -36,22 +36,22 @@ dict_hdr_flush_row_id(void);
Returns a new row id.
@return the new id */
UNIV_INLINE
dulint
row_id_t
dict_sys_get_new_row_id(void)
/*=========================*/
{
dulint id;
row_id_t id;
mutex_enter(&(dict_sys->mutex));
id = dict_sys->row_id;
if (0 == (ut_dulint_get_low(id) % DICT_HDR_ROW_ID_WRITE_MARGIN)) {
if (0 == (id % DICT_HDR_ROW_ID_WRITE_MARGIN)) {
dict_hdr_flush_row_id();
}
UT_DULINT_INC(dict_sys->row_id);
dict_sys->row_id++;
mutex_exit(&(dict_sys->mutex));
@ -62,10 +62,10 @@ dict_sys_get_new_row_id(void)
Reads a row id from a record or other 6-byte stored form.
@return row id */
UNIV_INLINE
dulint
row_id_t
dict_sys_read_row_id(
/*=================*/
byte* field) /*!< in: record field */
const byte* field) /*!< in: record field */
{
#if DATA_ROW_ID_LEN != 6
# error "DATA_ROW_ID_LEN != 6"
@ -80,8 +80,8 @@ UNIV_INLINE
void
dict_sys_write_row_id(
/*==================*/
byte* field, /*!< in: record field */
dulint row_id) /*!< in: row id */
byte* field, /*!< in: record field */
row_id_t row_id) /*!< in: row id */
{
#if DATA_ROW_ID_LEN != 6
# error "DATA_ROW_ID_LEN != 6"

18
storage/innobase/include/dict0dict.h
View file

@ -75,8 +75,8 @@ UNIV_INTERN
dict_table_t*
dict_table_get_on_id(
/*=================*/
dulint table_id, /*!< in: table id */
trx_t* trx); /*!< in: transaction handle */
table_id_t table_id, /*!< in: table id */
trx_t* trx); /*!< in: transaction handle */
/********************************************************************//**
Decrements the count of open MySQL handles to a table. */
UNIV_INTERN
@ -277,7 +277,7 @@ void
dict_table_change_id_in_cache(
/*==========================*/
dict_table_t* table, /*!< in/out: table object already in cache */
dulint new_id);/*!< in: new id to set */
table_id_t new_id);/*!< in: new id to set */
/**********************************************************************//**
Adds a foreign key constraint object to the dictionary cache. May free
the object if there already is an object with the same identifier in.
@ -397,7 +397,7 @@ dict_index_t*
dict_index_get_on_id_low(
/*=====================*/
dict_table_t* table, /*!< in: table */
dulint index_id); /*!< in: index id */
index_id_t index_id); /*!< in: index id */
/**********************************************************************//**
Checks if a table is in the dictionary cache.
@return table, NULL if not found */
@ -423,7 +423,7 @@ UNIV_INLINE
dict_table_t*
dict_table_get_on_id_low(
/*=====================*/
dulint table_id); /*!< in: table id */
table_id_t table_id); /*!< in: table id */
/**********************************************************************//**
Find an index that is equivalent to the one passed in and is not marked
for deletion.
@ -710,7 +710,7 @@ UNIV_INTERN
dict_index_t*
dict_index_find_on_id_low(
/*======================*/
dulint id); /*!< in: index id */
index_id_t id); /*!< in: index id */
/**********************************************************************//**
Adds an index to the dictionary cache.
@return DB_SUCCESS, DB_TOO_BIG_RECORD, or DB_CORRUPTION */
@ -901,7 +901,7 @@ UNIV_INTERN
dict_index_t*
dict_index_get_if_in_cache_low(
/*===========================*/
dulint index_id); /*!< in: index id */
index_id_t index_id); /*!< in: index id */
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
/**********************************************************************//**
Returns an index object if it is found in the dictionary cache.
@ -910,7 +910,7 @@ UNIV_INTERN
dict_index_t*
dict_index_get_if_in_cache(
/*=======================*/
dulint index_id); /*!< in: index id */
index_id_t index_id); /*!< in: index id */
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
#ifdef UNIV_DEBUG
/**********************************************************************//**
@ -1135,7 +1135,7 @@ struct dict_sys_struct{
and DROP TABLE, as well as reading
the dictionary data for a table from
system tables */
dulint row_id; /*!< the next row id to assign;
row_id_t row_id; /*!< the next row id to assign;
NOTE that at a checkpoint this
must be written to the dict system
header and flushed to a file; in

6
storage/innobase/include/dict0dict.ic
View file

@ -780,7 +780,7 @@ UNIV_INLINE
dict_table_t*
dict_table_get_on_id_low(
/*=====================*/
dulint table_id) /*!< in: table id */
table_id_t table_id) /*!< in: table id */
{
dict_table_t* table;
ulint fold;
@ -788,11 +788,11 @@ dict_table_get_on_id_low(
ut_ad(mutex_own(&(dict_sys->mutex)));
/* Look for the table name in the hash table */
fold = ut_fold_dulint(table_id);
fold = ut_fold_ull(table_id);
HASH_SEARCH(id_hash, dict_sys->table_id_hash, fold,
dict_table_t*, table, ut_ad(table->cached),
!ut_dulint_cmp(table->id, table_id));
table->id == table_id);
if (table == NULL) {
table = dict_load_table_on_id(table_id);
}

12
storage/innobase/include/dict0load.h
View file

@ -111,7 +111,7 @@ dict_load_column_low(
for temporary storage */
dict_col_t* column, /*!< out: dict_column_t to fill,
or NULL if table != NULL */
dulint* table_id, /*!< out: table id */
table_id_t* table_id, /*!< out: table id */
const char** col_name, /*!< out: column name */
const rec_t* rec); /*!< in: SYS_COLUMNS record */
/********************************************************************//**
@ -174,7 +174,7 @@ UNIV_INTERN
dict_table_t*
dict_load_table_on_id(
/*==================*/
dulint table_id); /*!< in: table id */
table_id_t table_id); /*!< in: table id */
/********************************************************************//**
This function is called when the database is booted.
Loads system table index definitions except for the clustered index which
@ -256,7 +256,7 @@ dict_process_sys_indexes_rec(
const rec_t* rec, /*!< in: current SYS_INDEXES rec */
dict_index_t* index, /*!< out: dict_index_t to be
filled */
dulint* table_id); /*!< out: table id */
table_id_t* table_id); /*!< out: table id */
/********************************************************************//**
This function parses a SYS_COLUMNS record and populate a dict_column_t
structure with the information from the record.
@ -268,7 +268,7 @@ dict_process_sys_columns_rec(
mem_heap_t* heap, /*!< in/out: heap memory */
const rec_t* rec, /*!< in: current SYS_COLUMNS rec */
dict_col_t* column, /*!< out: dict_col_t to be filled */
dulint* table_id, /*!< out: table id */
table_id_t* table_id, /*!< out: table id */
const char** col_name); /*!< out: column name */
/********************************************************************//**
This function parses a SYS_FIELDS record and populate a dict_field_t
@ -283,8 +283,8 @@ dict_process_sys_fields_rec(
dict_field_t* sys_field, /*!< out: dict_field_t to be
filled */
ulint* pos, /*!< out: Field position */
dulint* index_id, /*!< out: current index id */
dulint last_id); /*!< in: previous index id */
index_id_t* index_id, /*!< out: current index id */
index_id_t last_id); /*!< in: previous index id */
/********************************************************************//**
This function parses a SYS_FOREIGN record and populate a dict_foreign_t
structure with the information from the record. For detail information

6
storage/innobase/include/dict0mem.h
View file

@ -293,7 +293,7 @@ struct dict_field_struct{
/** Data structure for an index. Most fields will be
initialized to 0, NULL or FALSE in dict_mem_index_create(). */
struct dict_index_struct{
dulint id; /*!< id of the index */
index_id_t id; /*!< id of the index */
mem_heap_t* heap; /*!< memory heap */
const char* name; /*!< index name */
const char* table_name;/*!< table name */
@ -349,7 +349,7 @@ struct dict_index_struct{
/* @} */
rw_lock_t lock; /*!< read-write lock protecting the
upper levels of the index tree */
ib_uint64_t trx_id; /*!< id of the transaction that created this
trx_id_t trx_id; /*!< id of the transaction that created this
index, or 0 if the index existed
when InnoDB was started up */
#endif /* !UNIV_HOTBACKUP */
@ -414,7 +414,7 @@ a foreign key constraint is enforced, therefore RESTRICT just means no flag */
/** Data structure for a database table. Most fields will be
initialized to 0, NULL or FALSE in dict_mem_table_create(). */
struct dict_table_struct{
dulint id; /*!< id of the table */
table_id_t id; /*!< id of the table */
mem_heap_t* heap; /*!< memory heap */
char* name; /*!< table name */
const char* dir_path_of_temp_table;/*!< NULL or the directory path

3
storage/innobase/include/dict0types.h
View file

@ -45,4 +45,7 @@ typedef struct tab_node_struct tab_node_t;
#define DICT_HDR_SPACE 0 /* the SYSTEM tablespace */
#define DICT_HDR_PAGE_NO FSP_DICT_HDR_PAGE_NO
typedef ib_id_t table_id_t;
typedef ib_id_t index_id_t;
#endif

1
storage/innobase/include/fil0fil.h
View file

@ -26,6 +26,7 @@ Created 10/25/1995 Heikki Tuuri
#ifndef fil0fil_h
#define fil0fil_h
#include "univ.i"
#include "dict0types.h"
#include "ut0byte.h"
#include "os0file.h"

4
storage/innobase/include/lock0lock.h
View file

@ -670,7 +670,7 @@ lock_get_type(
Gets the id of the transaction owning a lock.
@return transaction id */
UNIV_INTERN
ullint
trx_id_t
lock_get_trx_id(
/*============*/
const lock_t* lock); /*!< in: lock */
@ -699,7 +699,7 @@ lock_get_type_str(
Gets the id of the table on which the lock is.
@return id of the table */
UNIV_INTERN
ullint
table_id_t
lock_get_table_id(
/*==============*/
const lock_t* lock); /*!< in: lock */

111
storage/innobase/include/mach0data.h
View file

@ -166,14 +166,14 @@ UNIV_INLINE
void
mach_write_to_6(
/*============*/
byte* b, /*!< in: pointer to 6 bytes where to store */
dulint n); /*!< in: dulint integer to be stored */
byte* b, /*!< in: pointer to 6 bytes where to store */
ib_uint64_t id); /*!< in: 48-bit integer */
/********************************************************//**
The following function is used to fetch data from 6 consecutive
bytes. The most significant byte is at the lowest address.
@return dulint integer */
@return 48-bit integer */
UNIV_INLINE
dulint
ib_uint64_t
mach_read_from_6(
/*=============*/
const byte* b) /*!< in: pointer to 6 bytes */
@ -185,14 +185,14 @@ UNIV_INLINE
void
mach_write_to_7(
/*============*/
byte* b, /*!< in: pointer to 7 bytes where to store */
dulint n); /*!< in: dulint integer to be stored */
byte* b, /*!< in: pointer to 7 bytes where to store */
ib_uint64_t n); /*!< in: 56-bit integer */
/********************************************************//**
The following function is used to fetch data from 7 consecutive
bytes. The most significant byte is at the lowest address.
@return dulint integer */
@return 56-bit integer */
UNIV_INLINE
dulint
ib_uint64_t
mach_read_from_7(
/*=============*/
const byte* b) /*!< in: pointer to 7 bytes */
@ -204,88 +204,69 @@ UNIV_INLINE
void
mach_write_to_8(
/*============*/
byte* b, /*!< in: pointer to 8 bytes where to store */
dulint n); /*!< in: dulint integer to be stored */
/*******************************************************//**
The following function is used to store data in 8 consecutive
bytes. We store the most significant byte to the lowest address. */
UNIV_INLINE
void
mach_write_ull(
/*===========*/
byte* b, /*!< in: pointer to 8 bytes where to store */
ib_uint64_t n); /*!< in: 64-bit integer to be stored */
/********************************************************//**
The following function is used to fetch data from 8 consecutive
bytes. The most significant byte is at the lowest address.
@return dulint integer */
UNIV_INLINE
dulint
mach_read_from_8(
/*=============*/
const byte* b) /*!< in: pointer to 8 bytes */
__attribute__((nonnull, pure));
/********************************************************//**
The following function is used to fetch data from 8 consecutive
bytes. The most significant byte is at the lowest address.
@return 64-bit integer */
UNIV_INLINE
ib_uint64_t
mach_read_ull(
/*==========*/
mach_read_from_8(
/*=============*/
const byte* b) /*!< in: pointer to 8 bytes */
__attribute__((nonnull, pure));
/*********************************************************//**
Writes a dulint in a compressed form (5..9 bytes).
Writes a 64-bit integer in a compressed form (5..9 bytes).
@return size in bytes */
UNIV_INLINE
ulint
mach_dulint_write_compressed(
/*=========================*/
byte* b, /*!< in: pointer to memory where to store */
dulint n); /*!< in: dulint integer to be stored */
mach_ull_write_compressed(
/*======================*/
byte* b, /*!< in: pointer to memory where to store */
ib_uint64_t n); /*!< in: 64-bit integer to be stored */
/*********************************************************//**
Returns the size of a dulint when written in the compressed form.
Returns the size of a 64-bit integer when written in the compressed form.
@return compressed size in bytes */
UNIV_INLINE
ulint
mach_dulint_get_compressed_size(
/*============================*/
dulint n); /*!< in: dulint integer to be stored */
mach_ull_get_compressed_size(
/*=========================*/
ib_uint64_t n); /*!< in: 64-bit integer to be stored */
/*********************************************************//**
Reads a dulint in a compressed form.
@return read dulint */
Reads a 64-bit integer in a compressed form.
@return the value read */
UNIV_INLINE
dulint
mach_dulint_read_compressed(
/*========================*/
ib_uint64_t
mach_ull_read_compressed(
/*=====================*/
const byte* b) /*!< in: pointer to memory from where to read */
__attribute__((nonnull, pure));
/*********************************************************//**
Writes a dulint in a compressed form (1..11 bytes).
Writes a 64-bit integer in a compressed form (1..11 bytes).
@return size in bytes */
UNIV_INLINE
ulint
mach_dulint_write_much_compressed(
/*==============================*/
byte* b, /*!< in: pointer to memory where to store */
dulint n); /*!< in: dulint integer to be stored */
mach_ull_write_much_compressed(
/*===========================*/
byte* b, /*!< in: pointer to memory where to store */
ib_uint64_t n); /*!< in: 64-bit integer to be stored */
/*********************************************************//**
Returns the size of a dulint when written in the compressed form.
Returns the size of a 64-bit integer when written in the compressed form.
@return compressed size in bytes */
UNIV_INLINE
ulint
mach_dulint_get_much_compressed_size(
/*=================================*/
dulint n) /*!< in: dulint integer to be stored */
mach_ull_get_much_compressed_size(
/*==============================*/
ib_uint64_t n) /*!< in: 64-bit integer to be stored */
__attribute__((const));
/*********************************************************//**
Reads a dulint in a compressed form.
@return read dulint */
Reads a 64-bit integer in a compressed form.
@return the value read */
UNIV_INLINE
dulint
mach_dulint_read_much_compressed(
/*=============================*/
ib_uint64_t
mach_ull_read_much_compressed(
/*==========================*/
const byte* b) /*!< in: pointer to memory from where to read */
__attribute__((nonnull, pure));
/*********************************************************//**
@ -299,15 +280,17 @@ mach_parse_compressed(
byte* end_ptr,/*!< in: pointer to end of the buffer */
ulint* val); /*!< out: read value */
/*********************************************************//**
Reads a dulint in a compressed form if the log record fully contains it.
@return pointer to end of the stored field, NULL if not complete */
Reads a 64-bit integer in a compressed form
if the log record fully contains it.
@return pointer to end of the stored field, NULL if not complete */
UNIV_INTERN
byte*
mach_dulint_parse_compressed(
/*=========================*/
byte* ptr, /*!< in: pointer to buffer from where to read */
byte* end_ptr,/*!< in: pointer to end of the buffer */
dulint* val); /*!< out: read value */
mach_ull_parse_compressed(
/*======================*/
byte* ptr, /*!< in: pointer to buffer from where to read */
byte* end_ptr,/*!< in: pointer to end of the buffer */
ib_uint64_t* val) /*!< out: read value */
__attribute__((nonnull, pure));
#ifndef UNIV_HOTBACKUP
/*********************************************************//**
Reads a double. It is stored in a little-endian format.

189
storage/innobase/include/mach0data.ic
View file

@ -280,22 +280,6 @@ UNIV_INLINE
void
mach_write_to_8(
/*============*/
byte* b, /*!< in: pointer to 8 bytes where to store */
dulint n) /*!< in: dulint integer to be stored */
{
ut_ad(b);
mach_write_to_4(b, ut_dulint_get_high(n));
mach_write_to_4(b + 4, ut_dulint_get_low(n));
}
/*******************************************************//**
The following function is used to store data in 8 consecutive
bytes. We store the most significant byte to the lowest address. */
UNIV_INLINE
void
mach_write_ull(
/*===========*/
byte* b, /*!< in: pointer to 8 bytes where to store */
ib_uint64_t n) /*!< in: 64-bit integer to be stored */
{
@ -305,35 +289,14 @@ mach_write_ull(
mach_write_to_4(b + 4, (ulint) n);
}
/********************************************************//**
The following function is used to fetch data from 8 consecutive
bytes. The most significant byte is at the lowest address.
@return dulint integer */
UNIV_INLINE
dulint
mach_read_from_8(
/*=============*/
const byte* b) /*!< in: pointer to 8 bytes */
{
ulint high;
ulint low;
ut_ad(b);
high = mach_read_from_4(b);
low = mach_read_from_4(b + 4);
return(ut_dulint_create(high, low));
}
/********************************************************//**
The following function is used to fetch data from 8 consecutive
bytes. The most significant byte is at the lowest address.
@return 64-bit integer */
UNIV_INLINE
ib_uint64_t
mach_read_ull(
/*==========*/
mach_read_from_8(
/*=============*/
const byte* b) /*!< in: pointer to 8 bytes */
{
ib_uint64_t ull;
@ -351,34 +314,28 @@ UNIV_INLINE
void
mach_write_to_7(
/*============*/
byte* b, /*!< in: pointer to 7 bytes where to store */
dulint n) /*!< in: dulint integer to be stored */
byte* b, /*!< in: pointer to 7 bytes where to store */
ib_uint64_t n) /*!< in: 56-bit integer */
{
ut_ad(b);
mach_write_to_3(b, ut_dulint_get_high(n));
mach_write_to_4(b + 3, ut_dulint_get_low(n));
mach_write_to_3(b, (ulint) (n >> 32));
mach_write_to_4(b + 3, (ulint) n);
}
/********************************************************//**
The following function is used to fetch data from 7 consecutive
bytes. The most significant byte is at the lowest address.
@return dulint integer */
@return 56-bit integer */
UNIV_INLINE
dulint
ib_uint64_t
mach_read_from_7(
/*=============*/
const byte* b) /*!< in: pointer to 7 bytes */
{
ulint high;
ulint low;
ut_ad(b);
high = mach_read_from_3(b);
low = mach_read_from_4(b + 3);
return(ut_dulint_create(high, low));
return(ut_ull_create(mach_read_from_3(b), mach_read_from_4(b + 3)));
}
/*******************************************************//**
@ -388,162 +345,156 @@ UNIV_INLINE
void
mach_write_to_6(
/*============*/
byte* b, /*!< in: pointer to 6 bytes where to store */
dulint n) /*!< in: dulint integer to be stored */
byte* b, /*!< in: pointer to 6 bytes where to store */
ib_uint64_t n) /*!< in: 48-bit integer */
{
ut_ad(b);
mach_write_to_2(b, ut_dulint_get_high(n));
mach_write_to_4(b + 2, ut_dulint_get_low(n));
mach_write_to_2(b, (ulint) (n >> 32));
mach_write_to_4(b + 2, (ulint) n);
}
/********************************************************//**
The following function is used to fetch data from 6 consecutive
bytes. The most significant byte is at the lowest address.
@return dulint integer */
@return 48-bit integer */
UNIV_INLINE
dulint
ib_uint64_t
mach_read_from_6(
/*=============*/
const byte* b) /*!< in: pointer to 6 bytes */
{
ulint high;
ulint low;
ut_ad(b);
high = mach_read_from_2(b);
low = mach_read_from_4(b + 2);
return(ut_dulint_create(high, low));
return(ut_ull_create(mach_read_from_2(b), mach_read_from_4(b + 2)));
}
/*********************************************************//**
Writes a dulint in a compressed form (5..9 bytes).
Writes a 64-bit integer in a compressed form (5..9 bytes).
@return size in bytes */
UNIV_INLINE
ulint
mach_dulint_write_compressed(
/*=========================*/
byte* b, /*!< in: pointer to memory where to store */
dulint n) /*!< in: dulint integer to be stored */
mach_ull_write_compressed(
/*======================*/
byte* b, /*!< in: pointer to memory where to store */
ib_uint64_t n) /*!< in: 64-bit integer to be stored */
{
ulint size;
ut_ad(b);
size = mach_write_compressed(b, ut_dulint_get_high(n));
mach_write_to_4(b + size, ut_dulint_get_low(n));
size = mach_write_compressed(b, (ulint) (n >> 32));
mach_write_to_4(b + size, (ulint) n);
return(size + 4);
}
/*********************************************************//**
Returns the size of a dulint when written in the compressed form.
Returns the size of a 64-bit integer when written in the compressed form.
@return compressed size in bytes */
UNIV_INLINE
ulint
mach_dulint_get_compressed_size(
/*============================*/
dulint n) /*!< in: dulint integer to be stored */
mach_ull_get_compressed_size(
/*=========================*/
ib_uint64_t n) /*!< in: 64-bit integer to be stored */
{
return(4 + mach_get_compressed_size(ut_dulint_get_high(n)));
return(4 + mach_get_compressed_size((ulint) (n >> 32)));
}
/*********************************************************//**
Reads a dulint in a compressed form.
@return read dulint */
Reads a 64-bit integer in a compressed form.
@return the value read */
UNIV_INLINE
dulint
mach_dulint_read_compressed(
/*========================*/
ib_uint64_t
mach_ull_read_compressed(
/*=====================*/
const byte* b) /*!< in: pointer to memory from where to read */
{
ulint high;
ulint low;
ulint size;
ib_uint64_t n;
ulint size;
ut_ad(b);
high = mach_read_compressed(b);
n = (ib_uint64_t) mach_read_compressed(b);
size = mach_get_compressed_size(high);
size = mach_get_compressed_size((ulint) n);
low = mach_read_from_4(b + size);
n <<= 32;
n |= (ib_uint64_t) mach_read_from_4(b + size);
return(ut_dulint_create(high, low));
return(n);
}
/*********************************************************//**
Writes a dulint in a compressed form (1..11 bytes).
Writes a 64-bit integer in a compressed form (1..11 bytes).
@return size in bytes */
UNIV_INLINE
ulint
mach_dulint_write_much_compressed(
/*==============================*/
byte* b, /*!< in: pointer to memory where to store */
dulint n) /*!< in: dulint integer to be stored */
mach_ull_write_much_compressed(
/*===========================*/
byte* b, /*!< in: pointer to memory where to store */
ib_uint64_t n) /*!< in: 64-bit integer to be stored */
{
ulint size;
ut_ad(b);
if (ut_dulint_get_high(n) == 0) {
return(mach_write_compressed(b, ut_dulint_get_low(n)));
if (!(n >> 32)) {
return(mach_write_compressed(b, (ulint) n));
}
*b = (byte)0xFF;
size = 1 + mach_write_compressed(b + 1, ut_dulint_get_high(n));
size = 1 + mach_write_compressed(b + 1, (ulint) (n >> 32));
size += mach_write_compressed(b + size, ut_dulint_get_low(n));
size += mach_write_compressed(b + size, (ulint) n & 0xFFFFFFFF);
return(size);
}
/*********************************************************//**
Returns the size of a dulint when written in the compressed form.
Returns the size of a 64-bit integer when written in the compressed form.
@return compressed size in bytes */
UNIV_INLINE
ulint
mach_dulint_get_much_compressed_size(
/*=================================*/
dulint n) /*!< in: dulint integer to be stored */
mach_ull_get_much_compressed_size(
/*==============================*/
ib_uint64_t n) /*!< in: 64-bit integer to be stored */
{
if (0 == ut_dulint_get_high(n)) {
return(mach_get_compressed_size(ut_dulint_get_low(n)));
if (!(n >> 32)) {
return(mach_get_compressed_size((ulint) n));
}
return(1 + mach_get_compressed_size(ut_dulint_get_high(n))
+ mach_get_compressed_size(ut_dulint_get_low(n)));
return(1 + mach_get_compressed_size((ulint) (n >> 32))
+ mach_get_compressed_size((ulint) n & ULINT32_MASK));
}
/*********************************************************//**
Reads a dulint in a compressed form.
@return read dulint */
Reads a 64-bit integer in a compressed form.
@return the value read */
UNIV_INLINE
dulint
mach_dulint_read_much_compressed(
/*=============================*/
ib_uint64_t
mach_ull_read_much_compressed(
/*==========================*/
const byte* b) /*!< in: pointer to memory from where to read */
{
ulint high;
ulint low;
ulint size;
ib_uint64_t n;
ulint size;
ut_ad(b);
if (*b != (byte)0xFF) {
high = 0;
n = 0;
size = 0;
} else {
high = mach_read_compressed(b + 1);
n = (ib_uint64_t) mach_read_compressed(b + 1);
size = 1 + mach_get_compressed_size(high);
size = 1 + mach_get_compressed_size((ulint) n);
n <<= 32;
}
low = mach_read_compressed(b + size);
n |= mach_read_compressed(b + size);
return(ut_dulint_create(high, low));
return(n);
}
#ifndef UNIV_HOTBACKUP
/*********************************************************//**

22
storage/innobase/include/mtr0log.h
View file

@ -47,11 +47,11 @@ Writes 8 bytes to a file page buffered in the buffer pool.
Writes the corresponding log record to the mini-transaction log. */
UNIV_INTERN
void
mlog_write_dulint(
/*==============*/
byte* ptr, /*!< in: pointer where to write */
dulint val, /*!< in: value to write */
mtr_t* mtr); /*!< in: mini-transaction handle */
mlog_write_ull(
/*===========*/
byte* ptr, /*!< in: pointer where to write */
ib_uint64_t val, /*!< in: value to write */
mtr_t* mtr); /*!< in: mini-transaction handle */
/********************************************************//**
Writes a string to a file page buffered in the buffer pool. Writes the
corresponding log record to the mini-transaction log. */
@ -125,13 +125,13 @@ mlog_catenate_ulint_compressed(
mtr_t* mtr, /*!< in: mtr */
ulint val); /*!< in: value to write */
/********************************************************//**
Catenates a compressed dulint to mlog. */
Catenates a compressed 64-bit integer to mlog. */
UNIV_INLINE
void
mlog_catenate_dulint_compressed(
/*============================*/
mtr_t* mtr, /*!< in: mtr */
dulint val); /*!< in: value to write */
mlog_catenate_ull_compressed(
/*=========================*/
mtr_t* mtr, /*!< in: mtr */
ib_uint64_t val); /*!< in: value to write */
/********************************************************//**
Opens a buffer to mlog. It must be closed with mlog_close.
@return buffer, NULL if log mode MTR_LOG_NONE */
@ -183,7 +183,7 @@ mlog_parse_initial_log_record(
ulint* space, /*!< out: space id */
ulint* page_no);/*!< out: page number */
/********************************************************//**
Parses a log record written by mlog_write_ulint or mlog_write_dulint.
Parses a log record written by mlog_write_ulint or mlog_write_ull.
@return parsed record end, NULL if not a complete record */
UNIV_INTERN
byte*

12
storage/innobase/include/mtr0log.ic
View file

@ -142,13 +142,13 @@ mlog_catenate_ulint_compressed(
}
/********************************************************//**
Catenates a compressed dulint to mlog. */
Catenates a compressed 64-bit integer to mlog. */
UNIV_INLINE
void
mlog_catenate_dulint_compressed(
/*============================*/
mtr_t* mtr, /*!< in: mtr */
dulint val) /*!< in: value to write */
mlog_catenate_ull_compressed(
/*=========================*/
mtr_t* mtr, /*!< in: mtr */
ib_uint64_t val) /*!< in: value to write */
{
byte* log_ptr;
@ -160,7 +160,7 @@ mlog_catenate_dulint_compressed(
return;
}
log_ptr += mach_dulint_write_compressed(log_ptr, val);
log_ptr += mach_ull_write_compressed(log_ptr, val);
mlog_close(mtr, log_ptr);
}

9
storage/innobase/include/mtr0mtr.h
View file

@ -264,15 +264,6 @@ mtr_read_ulint(
const byte* ptr, /*!< in: pointer from where to read */
ulint type, /*!< in: MLOG_1BYTE, MLOG_2BYTES, MLOG_4BYTES */
mtr_t* mtr); /*!< in: mini-transaction handle */
/********************************************************//**
Reads 8 bytes from a file page buffered in the buffer pool.
@return value read */
UNIV_INTERN
dulint
mtr_read_dulint(
/*============*/
const byte* ptr, /*!< in: pointer from where to read */
mtr_t* mtr); /*!< in: mini-transaction handle */
#ifndef UNIV_HOTBACKUP
/*********************************************************************//**
This macro locks an rw-lock in s-mode. */

2
storage/innobase/include/page0page.h
View file

@ -66,7 +66,7 @@ typedef byte page_header_t;
direction */
#define PAGE_N_RECS 16 /* number of user records on the page */
#define PAGE_MAX_TRX_ID 18 /* highest id of a trx which may have modified
a record on the page; a dulint; defined only
a record on the page; trx_id_t; defined only
in secondary indexes and in the insert buffer
tree; NOTE: this may be modified only
when the thread has an x-latch to the page,

5
storage/innobase/include/page0page.ic
View file

@ -94,11 +94,10 @@ page_update_max_trx_id(
TRUE for the dummy indexes constructed during redo log
application). In that case, PAGE_MAX_TRX_ID is unused,
and trx_id is usually zero. */
ut_ad(!ut_dulint_is_zero(trx_id) || recv_recovery_is_on());
ut_ad(trx_id || recv_recovery_is_on());
ut_ad(page_is_leaf(buf_block_get_frame(block)));
if (ut_dulint_cmp(page_get_max_trx_id(buf_block_get_frame(block)),
trx_id) < 0) {
if (page_get_max_trx_id(buf_block_get_frame(block)) < trx_id) {
page_set_max_trx_id(block, page_zip, trx_id, mtr);
}

25
storage/innobase/include/pars0pars.h
View file

@ -520,35 +520,18 @@ pars_info_add_int4_literal(
Equivalent to:
char buf[8];
mach_write_ull(buf, val);
pars_info_add_literal(info, name, buf, 8, DATA_INT, 0);
mach_write_to_8(buf, val);
pars_info_add_literal(info, name, buf, 8, DATA_FIXBINARY, 0);
except that the buffer is dynamically allocated from the info struct's
heap. */
UNIV_INTERN
void
pars_info_add_uint64_literal(
/*=========================*/
pars_info_add_ull_literal(
/*======================*/
pars_info_t* info, /*!< in: info struct */
const char* name, /*!< in: name */
ib_uint64_t val); /*!< in: value */
/****************************************************************//**
Equivalent to:
char buf[8];
mach_write_to_8(buf, val);
pars_info_add_literal(info, name, buf, 8, DATA_BINARY, 0);
except that the buffer is dynamically allocated from the info struct's
heap. */
UNIV_INTERN
void
pars_info_add_dulint_literal(
/*=========================*/
pars_info_t* info, /*!< in: info struct */
const char* name, /*!< in: name */
dulint val); /*!< in: value */
/****************************************************************//**
Add user function. */
UNIV_INTERN

3
storage/innobase/include/que0que.h
View file

@ -421,9 +421,6 @@ struct que_fork_struct{
ibool cur_on_row; /*!< TRUE if cursor is on a row, i.e.,
it is not before the first row or
after the last row */
dulint n_inserts; /*!< number of rows inserted */
dulint n_updates; /*!< number of rows updated */
dulint n_deletes; /*!< number of rows deleted */
sel_node_t* last_sel_node; /*!< last executed select node, or NULL
if none */
UT_LIST_NODE_T(que_fork_t)

10
storage/innobase/include/read0read.h
View file

@ -43,8 +43,7 @@ read_view_t*
read_view_open_now(
/*===============*/
trx_id_t cr_trx_id, /*!< in: trx_id of creating
transaction, or ut_dulint_zero
used in purge */
transaction, or 0 used in purge */
mem_heap_t* heap); /*!< in: memory heap from which
allocated */
/*********************************************************************//**
@ -56,8 +55,7 @@ read_view_t*
read_view_oldest_copy_or_open_new(
/*==============================*/
trx_id_t cr_trx_id, /*!< in: trx_id of creating
transaction, or ut_dulint_zero
used in purge */
transaction, or 0 used in purge */
mem_heap_t* heap); /*!< in: memory heap from which
allocated */
/*********************************************************************//**
@ -125,7 +123,7 @@ read should not see the modifications to the database. */
struct read_view_struct{
ulint type; /*!< VIEW_NORMAL, VIEW_HIGH_GRANULARITY */
undo_no_t undo_no;/*!< ut_dulint_zero or if type is
undo_no_t undo_no;/*!< 0 or if type is
VIEW_HIGH_GRANULARITY
transaction undo_no when this high-granularity
consistent read view was created */
@ -156,7 +154,7 @@ struct read_view_struct{
that is, up_limit_id and low_limit_id. */
trx_id_t creator_trx_id;
/*!< trx id of creating transaction, or
ut_dulint_zero used in purge */
0 used in purge */
UT_LIST_NODE_T(read_view_t) view_list;
/*!< List of read views in trx_sys */
};

14
storage/innobase/include/read0read.ic
View file

@ -64,15 +64,14 @@ read_view_sees_trx_id(
trx_id_t trx_id) /*!< in: trx id */
{
ulint n_ids;
int cmp;
ulint i;
if (ut_dulint_cmp(trx_id, view->up_limit_id) < 0) {
if (trx_id < view->up_limit_id) {
return(TRUE);
}
if (ut_dulint_cmp(trx_id, view->low_limit_id) >= 0) {
if (trx_id >= view->low_limit_id) {
return(FALSE);
}
@ -85,12 +84,11 @@ read_view_sees_trx_id(
n_ids = view->n_trx_ids;
for (i = 0; i < n_ids; i++) {
trx_id_t view_trx_id
= read_view_get_nth_trx_id(view, n_ids - i - 1);
cmp = ut_dulint_cmp(
trx_id,
read_view_get_nth_trx_id(view, n_ids - i - 1));
if (cmp <= 0) {
return(cmp < 0);
if (trx_id <= view_trx_id) {
return(trx_id != view_trx_id);
}
}

2
storage/innobase/include/rem0rec.h
View file

@ -659,7 +659,7 @@ rec_fold(
fields to fold */
ulint n_bytes, /*!< in: number of bytes to fold
in an incomplete last field */
dulint tree_id) /*!< in: index tree id */
index_id_t tree_id) /*!< in: index tree id */
__attribute__((pure));
#endif /* !UNIV_HOTBACKUP */
/*********************************************************//**

4
storage/innobase/include/rem0rec.ic
View file

@ -1594,7 +1594,7 @@ rec_fold(
fields to fold */
ulint n_bytes, /*!< in: number of bytes to fold
in an incomplete last field */
dulint tree_id) /*!< in: index tree id */
index_id_t tree_id) /*!< in: index tree id */
{
ulint i;
const byte* data;
@ -1618,7 +1618,7 @@ rec_fold(
n_bytes = 0;
}
fold = ut_fold_dulint(tree_id);
fold = ut_fold_ull(tree_id);
for (i = 0; i < n_fields; i++) {
data = rec_get_nth_field(rec, offsets, i, &len);

2
storage/innobase/include/row0upd.h
View file

@ -132,7 +132,7 @@ row_upd_index_entry_sys_field(
them */
dict_index_t* index, /*!< in: clustered index */
ulint type, /*!< in: DATA_TRX_ID or DATA_ROLL_PTR */
dulint val); /*!< in: value to write */
ib_uint64_t val); /*!< in: value to write */
/*********************************************************************//**
Creates an update node for a query graph.
@return own: update node */

6
storage/innobase/include/srv0srv.h
View file

@ -161,9 +161,9 @@ is 5% of the max where max is srv_io_capacity. */
#define PCT_IO(p) ((ulong) (srv_io_capacity * ((double) p / 100.0)))
#ifdef UNIV_LOG_ARCHIVE
extern ibool srv_log_archive_on;
extern ibool srv_archive_recovery;
extern dulint srv_archive_recovery_limit_lsn;
extern ibool srv_log_archive_on;
extern ibool srv_archive_recovery;
extern ib_uint64_t srv_archive_recovery_limit_lsn;
#endif /* UNIV_LOG_ARCHIVE */
extern char* srv_file_flush_method_str;

13
storage/innobase/include/trx0i_s.h
View file

@ -30,6 +30,7 @@ Created July 17, 2007 Vasil Dimov
#include "univ.i"
#include "trx0types.h"
#include "dict0types.h"
#include "ut0ut.h"
/** The maximum amount of memory that can be consumed by innodb_trx,
@ -95,7 +96,7 @@ struct i_s_hash_chain_struct {
/** This structure represents INFORMATION_SCHEMA.innodb_locks row */
struct i_s_locks_row_struct {
ullint lock_trx_id; /*!< transaction identifier */
trx_id_t lock_trx_id; /*!< transaction identifier */
const char* lock_mode; /*!< lock mode from
lock_get_mode_str() */
const char* lock_type; /*!< lock type from
@ -116,7 +117,7 @@ struct i_s_locks_row_struct {
/** The following are auxiliary and not included in the table */
/* @{ */
ullint lock_table_id;
table_id_t lock_table_id;
/*!< table identifier from
lock_get_table_id */
i_s_hash_chain_t hash_chain; /*!< hash table chain node for
@ -126,10 +127,10 @@ struct i_s_locks_row_struct {
/** This structure represents INFORMATION_SCHEMA.innodb_trx row */
struct i_s_trx_row_struct {
ullint trx_id; /*!< transaction identifier */
const char* trx_state; /*!< transaction state from
trx_get_que_state_str() */
ib_time_t trx_started; /*!< trx_struct::start_time */
trx_id_t trx_id; /*!< transaction identifier */
const char* trx_state; /*!< transaction state from
trx_get_que_state_str() */
ib_time_t trx_started; /*!< trx_struct::start_time */
const i_s_locks_row_t* requested_lock_row;
/*!< pointer to a row
in innodb_locks if trx

4
storage/innobase/include/trx0rec.h
View file

@ -108,7 +108,7 @@ trx_undo_rec_get_pars(
ibool* updated_extern, /*!< out: TRUE if we updated an
externally stored fild */
undo_no_t* undo_no, /*!< out: undo log record number */
dulint* table_id); /*!< out: table id */
table_id_t* table_id); /*!< out: table id */
/*******************************************************************//**
Builds a row reference from an undo log record.
@return pointer to remaining part of undo record */
@ -227,7 +227,7 @@ trx_undo_report_row_operation(
index, otherwise NULL */
roll_ptr_t* roll_ptr); /*!< out: rollback pointer to the
inserted undo log record,
ut_dulint_zero if BTR_NO_UNDO_LOG
0 if BTR_NO_UNDO_LOG
flag was specified */
/******************************************************************//**
Copies an undo record to heap. This function can be called if we know that

4
storage/innobase/include/trx0rec.ic
View file

@ -78,7 +78,7 @@ trx_undo_rec_get_undo_no(
ptr = undo_rec + 3;
return(mach_dulint_read_much_compressed(ptr));
return(mach_ull_read_much_compressed(ptr));
}
/**********************************************************************//**
@ -90,7 +90,7 @@ trx_undo_rec_get_offset(
/*====================*/
undo_no_t undo_no) /*!< in: undo no read from node */
{
return (3 + mach_dulint_get_much_compressed_size(undo_no));
return (3 + mach_ull_get_much_compressed_size(undo_no));
}
/***********************************************************************//**

5
storage/innobase/include/trx0sys.h
View file

@ -573,6 +573,11 @@ identifier is added to this constant. */
#define TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW 3645922177UL
/** Contents of TRX_SYS_FILE_FORMAT_TAG+4 when valid */
#define TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH 2745987765UL
/** Contents of TRX_SYS_FILE_FORMAT_TAG when valid. The file format
identifier is added to this 64-bit constant. */
#define TRX_SYS_FILE_FORMAT_TAG_MAGIC_N \
((ib_uint64_t) TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH << 32 \
| TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW)
/* @} */
/** Doublewrite control struct */

13
storage/innobase/include/trx0sys.ic
View file

@ -266,7 +266,7 @@ trx_get_on_id(
trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
while (trx != NULL) {
if (0 == ut_dulint_cmp(trx_id, trx->id)) {
if (trx_id == trx->id) {
return(trx);
}
@ -315,12 +315,12 @@ trx_is_active(
ut_ad(mutex_own(&(kernel_mutex)));
if (ut_dulint_cmp(trx_id, trx_list_get_min_trx_id()) < 0) {
if (trx_id < trx_list_get_min_trx_id()) {
return(FALSE);
}
if (ut_dulint_cmp(trx_id, trx_sys->max_trx_id) >= 0) {
if (UNIV_UNLIKELY(trx_id >= trx_sys->max_trx_id)) {
/* There must be corruption: we return TRUE because this
function is only called by lock_clust_rec_some_has_impl()
@ -359,15 +359,12 @@ trx_sys_get_new_trx_id(void)
Thus trx id values will not overlap when the database is
repeatedly started! */
if (ut_dulint_get_low(trx_sys->max_trx_id)
% TRX_SYS_TRX_ID_WRITE_MARGIN == 0) {
if ((ulint) trx_sys->max_trx_id % TRX_SYS_TRX_ID_WRITE_MARGIN == 0) {
trx_sys_flush_max_trx_id();
}
id = trx_sys->max_trx_id;
UT_DULINT_INC(trx_sys->max_trx_id);
id = trx_sys->max_trx_id++;
return(id);
}

24
storage/innobase/include/trx0trx.h
View file

@ -408,30 +408,20 @@ Calculates the "weight" of a transaction. The weight of one transaction
is estimated as the number of altered rows + the number of locked rows.
@param t transaction
@return transaction weight */
#define TRX_WEIGHT(t) \
ut_dulint_add((t)->undo_no, UT_LIST_GET_LEN((t)->trx_locks))
#define TRX_WEIGHT(t) ((t)->undo_no + UT_LIST_GET_LEN((t)->trx_locks))
/*******************************************************************//**
Compares the "weight" (or size) of two transactions. Transactions that
have edited non-transactional tables are considered heavier than ones
that have not.
@return <0, 0 or >0; similar to strcmp(3) */
@return TRUE if weight(a) >= weight(b) */
UNIV_INTERN
int
trx_weight_cmp(
/*===========*/
ibool
trx_weight_ge(
/*==========*/
const trx_t* a, /*!< in: the first transaction to be compared */
const trx_t* b); /*!< in: the second transaction to be compared */
/*******************************************************************//**
Retrieves transacion's id, represented as unsigned long long.
@return transaction's id */
UNIV_INLINE
ullint
trx_get_id(
/*=======*/
const trx_t* trx); /*!< in: transaction */
/* Maximum length of a string that can be returned by
trx_get_que_state_str(). */
#define TRX_QUE_STATE_STR_MAX_LEN 12 /* "ROLLING BACK" */
@ -555,8 +545,8 @@ struct trx_struct{
max trx id when the transaction is
moved to COMMITTED_IN_MEMORY state */
ib_uint64_t commit_lsn; /*!< lsn at the time of the commit */
trx_id_t table_id; /*!< Table to drop iff dict_operation
is TRUE, or ut_dulint_zero. */
table_id_t table_id; /*!< Table to drop iff dict_operation
is TRUE, or 0. */
/*------------------------------*/
void* mysql_thd; /*!< MySQL thread handle corresponding
to this trx, or NULL */

12
storage/innobase/include/trx0trx.ic
View file

@ -68,18 +68,6 @@ trx_get_error_info(
return(trx->error_info);
}
/*******************************************************************//**
Retrieves transacion's id, represented as unsigned long long.
@return transaction's id */
UNIV_INLINE
ullint
trx_get_id(
/*=======*/
const trx_t* trx) /*!< in: transaction */
{
return((ullint)ut_conv_dulint_to_longlong(trx->id));
}
/*******************************************************************//**
Retrieves transaction's que state in a human readable string. The string
should not be free()'d or modified.

13
storage/innobase/include/trx0types.h
View file

@ -28,10 +28,7 @@ Created 3/26/1996 Heikki Tuuri
#include "ut0byte.h"
/** prepare trx_t::id for being printed via printf(3) */
#define TRX_ID_PREP_PRINTF(id) (ullint) ut_conv_dulint_to_longlong(id)
/** printf(3) format used for printing TRX_ID_PRINTF_PREP() */
/** printf(3) format used for printing DB_TRX_ID and other system fields */
#define TRX_ID_FMT "%llX"
/** maximum length that a formatted trx_t::id could take, not including
@ -81,12 +78,14 @@ enum trx_rb_ctx {
in crash recovery */
};
/** Row identifier (DB_ROW_ID, DATA_ROW_ID) */
typedef ib_id_t row_id_t;
/** Transaction identifier (DB_TRX_ID, DATA_TRX_ID) */
typedef dulint trx_id_t;
typedef ib_id_t trx_id_t;
/** Rollback pointer (DB_ROLL_PTR, DATA_ROLL_PTR) */
typedef dulint roll_ptr_t;
typedef ib_id_t roll_ptr_t;
/** Undo number */
typedef dulint undo_no_t;
typedef ib_id_t undo_no_t;
/** Transaction savepoint */
typedef struct trx_savept_struct trx_savept_t;

2
storage/innobase/include/trx0undo.h
View file

@ -383,7 +383,7 @@ struct trx_undo_struct{
XID xid; /*!< X/Open XA transaction
identification */
ibool dict_operation; /*!< TRUE if a dict operation trx */
dulint table_id; /*!< if a dict operation, then the table
table_id_t table_id; /*!< if a dict operation, then the table
id */
trx_rseg_t* rseg; /*!< rseg where the undo log belongs */
/*-----------------------------*/

39
storage/innobase/include/trx0undo.ic
View file

@ -39,16 +39,19 @@ trx_undo_build_roll_ptr(
ulint page_no, /*!< in: page number */
ulint offset) /*!< in: offset of the undo entry within page */
{
roll_ptr_t roll_ptr;
#if DATA_ROLL_PTR_LEN != 7
# error "DATA_ROLL_PTR_LEN != 7"
#endif
ut_ad(is_insert <= 1);
ut_ad(rseg_id < TRX_SYS_N_RSEGS);
ut_ad(offset < 65536);
return(ut_dulint_create(is_insert * 128 * 256 * 256
+ rseg_id * 256 * 256
+ (page_no / 256) / 256,
(page_no % (256 * 256)) * 256 * 256
+ offset));
roll_ptr = (roll_ptr_t) is_insert << 55
| (roll_ptr_t) rseg_id << 48
| (roll_ptr_t) page_no << 16
| offset;
return(roll_ptr);
}
/***********************************************************************//**
@ -64,24 +67,20 @@ trx_undo_decode_roll_ptr(
ulint* offset) /*!< out: offset of the undo
entry within page */
{
ulint low;
ulint high;
#if DATA_ROLL_PTR_LEN != 7
# error "DATA_ROLL_PTR_LEN != 7"
#endif
#if TRUE != 1
# error "TRUE != 1"
#endif
high = ut_dulint_get_high(roll_ptr);
low = ut_dulint_get_low(roll_ptr);
*offset = low % (256 * 256);
*is_insert = high / (256 * 256 * 128); /* TRUE == 1 */
*rseg_id = (high / (256 * 256)) % 128;
*page_no = (high % (256 * 256)) * 256 * 256
+ (low / 256) / 256;
ut_ad(roll_ptr < (1ULL << 56));
*offset = (ulint) roll_ptr & 0xFFFF;
roll_ptr >>= 16;
*page_no = (ulint) roll_ptr & 0xFFFFFFFF;
roll_ptr >>= 32;
*rseg_id = (ulint) roll_ptr & 0x7F;
roll_ptr >>= 7;
*is_insert = (ibool) roll_ptr; /* TRUE==1 */
}
/***********************************************************************//**
@ -93,16 +92,14 @@ trx_undo_roll_ptr_is_insert(
/*========================*/
roll_ptr_t roll_ptr) /*!< in: roll pointer */
{
ulint high;
#if DATA_ROLL_PTR_LEN != 7
# error "DATA_ROLL_PTR_LEN != 7"
#endif
#if TRUE != 1
# error "TRUE != 1"
#endif
high = ut_dulint_get_high(roll_ptr);
return(high / (256 * 256 * 128));
ut_ad(roll_ptr < (1ULL << 56));
return((ibool) (roll_ptr >> 55));
}
#endif /* !UNIV_HOTBACKUP */

7
storage/innobase/include/univ.i
View file

@ -371,8 +371,10 @@ typedef unsigned long long int ullint;
/* The 'undefined' value for a ulint */
#define ULINT_UNDEFINED ((ulint)(-1))
/** The bitmask of 32-bit unsigned integer */
#define ULINT32_MASK 0xFFFFFFFF
/* The undefined 32-bit unsigned integer */
#define ULINT32_UNDEFINED 0xFFFFFFFF
#define ULINT32_UNDEFINED ULINT32_MASK
/* Maximum value for a ulint */
#define ULINT_MAX ((ulint)(-2))
@ -380,6 +382,9 @@ typedef unsigned long long int ullint;
/* Maximum value for ib_uint64_t */
#define IB_ULONGLONG_MAX ((ib_uint64_t) (~0ULL))
/** The generic InnoDB system object identifier data type */
typedef ib_uint64_t ib_id_t;
/* This 'ibool' type is used within Innobase. Remember that different included
headers may define 'bool' differently. Do not assume that 'bool' is a ulint! */
#define ibool ulint

169
storage/innobase/include/ut0byte.h
View file

@ -27,145 +27,22 @@ Created 1/20/1994 Heikki Tuuri
#define ut0byte_h
#include "univ.i"
/** Pair of ulint integers. */
typedef struct dulint_struct dulint;
/** Type definition for a 64-bit unsigned integer, which works also
in 32-bit machines. NOTE! Access the fields only with the accessor
functions. This definition appears here only for the compiler to
know the size of a dulint. */
struct dulint_struct{
ulint high; /*!< most significant 32 bits */
ulint low; /*!< least significant 32 bits */
};
/** Zero value for a dulint */
extern const dulint ut_dulint_zero;
/** Maximum value for a dulint */
extern const dulint ut_dulint_max;
/*******************************************************//**
Creates a 64-bit dulint out of two ulints.
Creates a 64-bit integer out of two 32-bit integers.
@return created dulint */
UNIV_INLINE
dulint
ut_dulint_create(
/*=============*/
ib_uint64_t
ut_ull_create(
/*==========*/
ulint high, /*!< in: high-order 32 bits */
ulint low); /*!< in: low-order 32 bits */
/*******************************************************//**
Gets the high-order 32 bits of a dulint.
@return 32 bits in ulint */
UNIV_INLINE
ulint
ut_dulint_get_high(
/*===============*/
dulint d); /*!< in: dulint */
/*******************************************************//**
Gets the low-order 32 bits of a dulint.
@return 32 bits in ulint */
UNIV_INLINE
ulint
ut_dulint_get_low(
/*==============*/
dulint d); /*!< in: dulint */
/*******************************************************//**
Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
integer type.
@return value in ib_int64_t type */
UNIV_INLINE
ib_int64_t
ut_conv_dulint_to_longlong(
/*=======================*/
dulint d); /*!< in: dulint */
/*******************************************************//**
Tests if a dulint is zero.
@return TRUE if zero */
UNIV_INLINE
ibool
ut_dulint_is_zero(
/*==============*/
dulint a); /*!< in: dulint */
/*******************************************************//**
Compares two dulints.
@return -1 if a < b, 0 if a == b, 1 if a > b */
UNIV_INLINE
int
ut_dulint_cmp(
/*==========*/
dulint a, /*!< in: dulint */
dulint b); /*!< in: dulint */
/*******************************************************//**
Calculates the max of two dulints.
@return max(a, b) */
UNIV_INLINE
dulint
ut_dulint_get_max(
/*==============*/
dulint a, /*!< in: dulint */
dulint b); /*!< in: dulint */
/*******************************************************//**
Calculates the min of two dulints.
@return min(a, b) */
UNIV_INLINE
dulint
ut_dulint_get_min(
/*==============*/
dulint a, /*!< in: dulint */
dulint b); /*!< in: dulint */
/*******************************************************//**
Adds a ulint to a dulint.
@return sum a + b */
UNIV_INLINE
dulint
ut_dulint_add(
/*==========*/
dulint a, /*!< in: dulint */
ulint b); /*!< in: ulint */
/*******************************************************//**
Subtracts a ulint from a dulint.
@return a - b */
UNIV_INLINE
dulint
ut_dulint_subtract(
/*===============*/
dulint a, /*!< in: dulint */
ulint b); /*!< in: ulint, b <= a */
/*******************************************************//**
Subtracts a dulint from another. NOTE that the difference must be positive
and smaller that 4G.
@return a - b */
UNIV_INLINE
ulint
ut_dulint_minus(
/*============*/
dulint a, /*!< in: dulint; NOTE a must be >= b and at most
2 to power 32 - 1 greater */
dulint b); /*!< in: dulint */
ulint low) /*!< in: low-order 32 bits */
__attribute__((const));
/********************************************************//**
Rounds a dulint downward to a multiple of a power of 2.
@return rounded value */
UNIV_INLINE
dulint
ut_dulint_align_down(
/*=================*/
dulint n, /*!< in: number to be rounded */
ulint align_no); /*!< in: align by this number which must be a
power of 2 */
/********************************************************//**
Rounds a dulint upward to a multiple of a power of 2.
@return rounded value */
UNIV_INLINE
dulint
ut_dulint_align_up(
/*===============*/
dulint n, /*!< in: number to be rounded */
ulint align_no); /*!< in: align by this number which must be a
power of 2 */
/********************************************************//**
Rounds a dulint downward to a multiple of a power of 2.
Rounds a 64-bit integer downward to a multiple of a power of 2.
@return rounded value */
UNIV_INLINE
ib_uint64_t
@ -184,34 +61,6 @@ ut_uint64_align_up(
ib_uint64_t n, /*!< in: number to be rounded */
ulint align_no); /*!< in: align by this number
which must be a power of 2 */
/*******************************************************//**
Increments a dulint variable by 1. */
#define UT_DULINT_INC(D)\
{\
if ((D).low == 0xFFFFFFFFUL) {\
(D).high = (D).high + 1;\
(D).low = 0;\
} else {\
(D).low = (D).low + 1;\
}\
}
/*******************************************************//**
Tests if two dulints are equal. */
#define UT_DULINT_EQ(D1, D2) (((D1).low == (D2).low)\
&& ((D1).high == (D2).high))
#ifdef notdefined
/************************************************************//**
Sort function for dulint arrays. */
UNIV_INTERN
void
ut_dulint_sort(
/*===========*/
dulint* arr, /*!< in/out: array to be sorted */
dulint* aux_arr,/*!< in/out: auxiliary array (same size as arr) */
ulint low, /*!< in: low bound of sort interval, inclusive */
ulint high); /*!< in: high bound of sort interval, noninclusive */
#endif /* notdefined */
/*********************************************************//**
The following function rounds up a pointer to the nearest aligned address.
@return aligned pointer */

254
storage/innobase/include/ut0byte.ic
View file

@ -24,260 +24,22 @@ Created 5/30/1994 Heikki Tuuri
*******************************************************************/
/*******************************************************//**
Creates a 64-bit dulint out of two ulints.
Creates a 64-bit integer out of two 32-bit integers.
@return created dulint */
UNIV_INLINE
dulint
ut_dulint_create(
/*=============*/
ib_uint64_t
ut_ull_create(
/*==========*/
ulint high, /*!< in: high-order 32 bits */
ulint low) /*!< in: low-order 32 bits */
{
dulint res;
ut_ad(high <= 0xFFFFFFFF);
ut_ad(low <= 0xFFFFFFFF);
res.high = high;
res.low = low;
return(res);
}
/*******************************************************//**
Gets the high-order 32 bits of a dulint.
@return 32 bits in ulint */
UNIV_INLINE
ulint
ut_dulint_get_high(
/*===============*/
dulint d) /*!< in: dulint */
{
return(d.high);
}
/*******************************************************//**
Gets the low-order 32 bits of a dulint.
@return 32 bits in ulint */
UNIV_INLINE
ulint
ut_dulint_get_low(
/*==============*/
dulint d) /*!< in: dulint */
{
return(d.low);
}
/*******************************************************//**
Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
integer type.
@return value in ib_int64_t type */
UNIV_INLINE
ib_int64_t
ut_conv_dulint_to_longlong(
/*=======================*/
dulint d) /*!< in: dulint */
{
return((ib_int64_t)d.low
+ (((ib_int64_t)d.high) << 32));
}
/*******************************************************//**
Tests if a dulint is zero.
@return TRUE if zero */
UNIV_INLINE
ibool
ut_dulint_is_zero(
/*==============*/
dulint a) /*!< in: dulint */
{
if ((a.low == 0) && (a.high == 0)) {
return(TRUE);
}
return(FALSE);
}
/*******************************************************//**
Compares two dulints.
@return -1 if a < b, 0 if a == b, 1 if a > b */
UNIV_INLINE
int
ut_dulint_cmp(
/*==========*/
dulint a, /*!< in: dulint */
dulint b) /*!< in: dulint */
{
if (a.high > b.high) {
return(1);
} else if (a.high < b.high) {
return(-1);
} else if (a.low > b.low) {
return(1);
} else if (a.low < b.low) {
return(-1);
} else {
return(0);
}
}
/*******************************************************//**
Calculates the max of two dulints.
@return max(a, b) */
UNIV_INLINE
dulint
ut_dulint_get_max(
/*==============*/
dulint a, /*!< in: dulint */
dulint b) /*!< in: dulint */
{
if (ut_dulint_cmp(a, b) > 0) {
return(a);
}
return(b);
}
/*******************************************************//**
Calculates the min of two dulints.
@return min(a, b) */
UNIV_INLINE
dulint
ut_dulint_get_min(
/*==============*/
dulint a, /*!< in: dulint */
dulint b) /*!< in: dulint */
{
if (ut_dulint_cmp(a, b) > 0) {
return(b);
}
return(a);
}
/*******************************************************//**
Adds a ulint to a dulint.
@return sum a + b */
UNIV_INLINE
dulint
ut_dulint_add(
/*==========*/
dulint a, /*!< in: dulint */
ulint b) /*!< in: ulint */
{
if (0xFFFFFFFFUL - b >= a.low) {
a.low += b;
return(a);
}
a.low = a.low - (0xFFFFFFFFUL - b) - 1;
a.high++;
return(a);
}
/*******************************************************//**
Subtracts a ulint from a dulint.
@return a - b */
UNIV_INLINE
dulint
ut_dulint_subtract(
/*===============*/
dulint a, /*!< in: dulint */
ulint b) /*!< in: ulint, b <= a */
{
if (a.low >= b) {
a.low -= b;
return(a);
}
b -= a.low + 1;
a.low = 0xFFFFFFFFUL - b;
ut_ad(a.high > 0);
a.high--;
return(a);
}
/*******************************************************//**
Subtracts a dulint from another. NOTE that the difference must be positive
and smaller that 4G.
@return a - b */
UNIV_INLINE
ulint
ut_dulint_minus(
/*============*/
dulint a, /*!< in: dulint; NOTE a must be >= b and at most
2 to power 32 - 1 greater */
dulint b) /*!< in: dulint */
{
ulint diff;
if (a.high == b.high) {
ut_ad(a.low >= b.low);
return(a.low - b.low);
}
ut_ad(a.high == b.high + 1);
diff = (ulint)(0xFFFFFFFFUL - b.low);
diff += 1 + a.low;
ut_ad(diff > a.low);
return(diff);
ut_ad(high <= ULINT32_MAX);
ut_ad(low <= ULINT32_MAX);
return(((ib_uint64_t) high) << 32 | low);
}
/********************************************************//**
Rounds a dulint downward to a multiple of a power of 2.
@return rounded value */
UNIV_INLINE
dulint
ut_dulint_align_down(
/*=================*/
dulint n, /*!< in: number to be rounded */
ulint align_no) /*!< in: align by this number which must be a
power of 2 */
{
ulint low, high;
ut_ad(align_no > 0);
ut_ad(((align_no - 1) & align_no) == 0);
low = ut_dulint_get_low(n);
high = ut_dulint_get_high(n);
low = low & ~(align_no - 1);
return(ut_dulint_create(high, low));
}
/********************************************************//**
Rounds a dulint upward to a multiple of a power of 2.
@return rounded value */
UNIV_INLINE
dulint
ut_dulint_align_up(
/*===============*/
dulint n, /*!< in: number to be rounded */
ulint align_no) /*!< in: align by this number which must be a
power of 2 */
{
return(ut_dulint_align_down(ut_dulint_add(n, align_no - 1), align_no));
}
/********************************************************//**
Rounds ib_uint64_t downward to a multiple of a power of 2.
Rounds a 64-bit integer downward to a multiple of a power of 2.
@return rounded value */
UNIV_INLINE
ib_uint64_t

8
storage/innobase/include/ut0rnd.h
View file

@ -97,13 +97,13 @@ ut_fold_ulint_pair(
ulint n2) /*!< in: ulint */
__attribute__((const));
/*************************************************************//**
Folds a dulint.
Folds a 64-bit integer.
@return folded value */
UNIV_INLINE
ulint
ut_fold_dulint(
/*===========*/
dulint d) /*!< in: dulint */
ut_fold_ull(
/*========*/
ib_uint64_t d) /*!< in: 64-bit integer */
__attribute__((const));
/*************************************************************//**
Folds a character string ending in the null character.

12
storage/innobase/include/ut0rnd.ic
View file

@ -173,16 +173,16 @@ ut_fold_ulint_pair(
}
/*************************************************************//**
Folds a dulint.
Folds a 64-bit integer.
@return folded value */
UNIV_INLINE
ulint
ut_fold_dulint(
/*===========*/
dulint d) /*!< in: dulint */
ut_fold_ull(
/*========*/
ib_uint64_t d) /*!< in: 64-bit integer */
{
return(ut_fold_ulint_pair(ut_dulint_get_low(d),
ut_dulint_get_high(d)));
return(ut_fold_ulint_pair((ulint) d & ULINT32_MASK,
(ulint) (d >> 32)));
}
/*************************************************************//**

77
storage/innobase/lock/lock0lock.c
View file

@ -468,7 +468,7 @@ lock_check_trx_id_sanity(
/* A sanity check: the trx_id in rec must be smaller than the global
trx id counter */
if (ut_dulint_cmp(trx_id, trx_sys->max_trx_id) >= 0) {
if (UNIV_UNLIKELY(trx_id >= trx_sys->max_trx_id)) {
ut_print_timestamp(stderr);
fputs(" InnoDB: Error: transaction id associated"
" with record\n",
@ -481,8 +481,7 @@ lock_check_trx_id_sanity(
" global trx id counter " TRX_ID_FMT "!\n"
"InnoDB: The table is corrupt. You have to do"
" dump + drop + reimport.\n",
TRX_ID_PREP_PRINTF(trx_id),
TRX_ID_PREP_PRINTF(trx_sys->max_trx_id));
(ullint) trx_id, (ullint) trx_sys->max_trx_id);
is_ok = FALSE;
}
@ -556,9 +555,9 @@ lock_sec_rec_cons_read_sees(
}
max_trx_id = page_get_max_trx_id(page_align(rec));
ut_ad(!ut_dulint_is_zero(max_trx_id));
ut_ad(max_trx_id);
return(ut_dulint_cmp(max_trx_id, view->up_limit_id) < 0);
return(max_trx_id < view->up_limit_id);
}
/*********************************************************************//**
@ -1594,8 +1593,7 @@ lock_sec_rec_some_has_impl_off_kernel(
max trx id to the log, and therefore during recovery, this value
for a page may be incorrect. */
if (!(ut_dulint_cmp(page_get_max_trx_id(page),
trx_list_get_min_trx_id()) >= 0)
if (page_get_max_trx_id(page) < trx_list_get_min_trx_id()
&& !recv_recovery_is_on()) {
return(NULL);
@ -1820,8 +1818,8 @@ lock_rec_enqueue_waiting(
#ifdef UNIV_DEBUG
if (lock_print_waits) {
fprintf(stderr, "Lock wait for trx %lu in index ",
(ulong) ut_dulint_get_low(trx->id));
fprintf(stderr, "Lock wait for trx " TRX_ID_FMT " in index ",
(ullint) trx->id);
ut_print_name(stderr, trx, FALSE, index->name);
}
#endif /* UNIV_DEBUG */
@ -2193,8 +2191,8 @@ lock_grant(
#ifdef UNIV_DEBUG
if (lock_print_waits) {
fprintf(stderr, "Lock wait for trx %lu ends\n",
(ulong) ut_dulint_get_low(lock->trx->id));
fprintf(stderr, "Lock wait for trx " TRX_ID_FMT " ends\n",
(ullint) lock->trx->id);
}
#endif /* UNIV_DEBUG */
@ -3486,8 +3484,7 @@ lock_deadlock_recursive(
}
#endif /* UNIV_DEBUG */
if (trx_weight_cmp(wait_lock->trx,
start) >= 0) {
if (trx_weight_ge(wait_lock->trx, start)) {
/* Our recursion starting point
transaction is 'smaller', let us
choose 'start' as the victim and roll
@ -4023,7 +4020,7 @@ lock_release_off_kernel(
ut_ad(lock_get_type_low(lock) & LOCK_TABLE);
if (lock_get_mode(lock) != LOCK_IS
&& !ut_dulint_is_zero(trx->undo_no)) {
&& trx->undo_no != 0) {
/* The trx may have modified the table. We
block the use of the MySQL query cache for
@ -4222,8 +4219,7 @@ lock_table_print(
fputs("TABLE LOCK table ", file);
ut_print_name(file, lock->trx, TRUE,
lock->un_member.tab_lock.table->name);
fprintf(file, " trx id " TRX_ID_FMT,
TRX_ID_PREP_PRINTF(lock->trx->id));
fprintf(file, " trx id " TRX_ID_FMT, (ullint) lock->trx->id);
if (lock_get_mode(lock) == LOCK_S) {
fputs(" lock mode S", file);
@ -4276,8 +4272,7 @@ lock_rec_print(
(ulong) space, (ulong) page_no,
(ulong) lock_rec_get_n_bits(lock));
dict_index_name_print(file, lock->trx, lock->index);
fprintf(file, " trx id " TRX_ID_FMT,
TRX_ID_PREP_PRINTF(lock->trx->id));
fprintf(file, " trx id " TRX_ID_FMT, (ullint) lock->trx->id);
if (lock_get_mode(lock) == LOCK_S) {
fputs(" lock mode S", file);
@ -4412,13 +4407,13 @@ lock_print_info_summary(
"------------\n", file);
fprintf(file, "Trx id counter " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(trx_sys->max_trx_id));
(ullint) trx_sys->max_trx_id);
fprintf(file,
"Purge done for trx's n:o < " TRX_ID_FMT
" undo n:o < " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(purge_sys->purge_trx_no),
TRX_ID_PREP_PRINTF(purge_sys->purge_undo_no));
(ullint) purge_sys->purge_trx_no,
(ullint) purge_sys->purge_undo_no);
fprintf(file,
"History list length %lu\n",
@ -4495,10 +4490,8 @@ loop:
"Trx read view will not see trx with"
" id >= " TRX_ID_FMT
", sees < " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(
trx->read_view->low_limit_id),
TRX_ID_PREP_PRINTF(
trx->read_view->up_limit_id));
(ullint) trx->read_view->low_limit_id,
(ullint) trx->read_view->up_limit_id);
}
if (trx->que_state == TRX_QUE_LOCK_WAIT) {
@ -4912,12 +4905,12 @@ ibool
lock_validate(void)
/*===============*/
{
lock_t* lock;
trx_t* trx;
dulint limit;
ulint space;
ulint page_no;
ulint i;
lock_t* lock;
trx_t* trx;
ib_uint64_t limit;
ulint space;
ulint page_no;
ulint i;
lock_mutex_enter_kernel();
@ -4941,20 +4934,21 @@ lock_validate(void)
for (i = 0; i < hash_get_n_cells(lock_sys->rec_hash); i++) {
limit = ut_dulint_zero;
limit = 0;
for (;;) {
lock = HASH_GET_FIRST(lock_sys->rec_hash, i);
while (lock) {
ib_uint64_t space_page;
ut_a(trx_in_trx_list(lock->trx));
space = lock->un_member.rec_lock.space;
page_no = lock->un_member.rec_lock.page_no;
if (ut_dulint_cmp(
ut_dulint_create(space, page_no),
limit) >= 0) {
space_page = ut_ull_create(space, page_no);
if (space_page >= limit) {
break;
}
@ -4974,7 +4968,7 @@ lock_validate(void)
lock_mutex_enter_kernel();
limit = ut_dulint_create(space, page_no + 1);
limit = ut_ull_create(space, page_no + 1);
}
}
@ -5348,8 +5342,7 @@ lock_sec_rec_read_check_and_lock(
if the max trx id for the page >= min trx id for the trx list or a
database recovery is running. */
if (((ut_dulint_cmp(page_get_max_trx_id(block->frame),
trx_list_get_min_trx_id()) >= 0)
if ((page_get_max_trx_id(block->frame) >= trx_list_get_min_trx_id()
|| recv_recovery_is_on())
&& !page_rec_is_supremum(rec)) {
@ -5572,12 +5565,12 @@ lock_get_type(
Gets the id of the transaction owning a lock.
@return transaction id */
UNIV_INTERN
ullint
trx_id_t
lock_get_trx_id(
/*============*/
const lock_t* lock) /*!< in: lock */
{
return(trx_get_id(lock->trx));
return(lock->trx->id);
}
/*******************************************************************//**
@ -5671,7 +5664,7 @@ lock_get_table(
Gets the id of the table on which the lock is.
@return id of the table */
UNIV_INTERN
ullint
table_id_t
lock_get_table_id(
/*==============*/
const lock_t* lock) /*!< in: lock */
@ -5680,7 +5673,7 @@ lock_get_table_id(
table = lock_get_table(lock);
return((ullint)ut_conv_dulint_to_longlong(table->id));
return(table->id);
}
/*******************************************************************//**

22
storage/innobase/log/log0log.c
View file

@ -1166,7 +1166,7 @@ log_group_file_header_flush(
buf = *(group->file_header_bufs + nth_file);
mach_write_to_4(buf + LOG_GROUP_ID, group->id);
mach_write_ull(buf + LOG_FILE_START_LSN, start_lsn);
mach_write_to_8(buf + LOG_FILE_START_LSN, start_lsn);
/* Wipe over possible label of ibbackup --restore */
memcpy(buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP, " ", 4);
@ -1769,8 +1769,8 @@ log_group_checkpoint(
buf = group->checkpoint_buf;
mach_write_ull(buf + LOG_CHECKPOINT_NO, log_sys->next_checkpoint_no);
mach_write_ull(buf + LOG_CHECKPOINT_LSN, log_sys->next_checkpoint_lsn);
mach_write_to_8(buf + LOG_CHECKPOINT_NO, log_sys->next_checkpoint_no);
mach_write_to_8(buf + LOG_CHECKPOINT_LSN, log_sys->next_checkpoint_lsn);
mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
log_group_calc_lsn_offset(
@ -1790,9 +1790,9 @@ log_group_checkpoint(
}
}
mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, archived_lsn);
mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, archived_lsn);
#else /* UNIV_LOG_ARCHIVE */
mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
#endif /* UNIV_LOG_ARCHIVE */
for (i = 0; i < LOG_MAX_N_GROUPS; i++) {
@ -1884,7 +1884,7 @@ log_reset_first_header_and_checkpoint(
ib_uint64_t lsn;
mach_write_to_4(hdr_buf + LOG_GROUP_ID, 0);
mach_write_ull(hdr_buf + LOG_FILE_START_LSN, start);
mach_write_to_8(hdr_buf + LOG_FILE_START_LSN, start);
lsn = start + LOG_BLOCK_HDR_SIZE;
@ -1896,15 +1896,15 @@ log_reset_first_header_and_checkpoint(
+ (sizeof "ibbackup ") - 1));
buf = hdr_buf + LOG_CHECKPOINT_1;
mach_write_ull(buf + LOG_CHECKPOINT_NO, 0);
mach_write_ull(buf + LOG_CHECKPOINT_LSN, lsn);
mach_write_to_8(buf + LOG_CHECKPOINT_NO, 0);
mach_write_to_8(buf + LOG_CHECKPOINT_LSN, lsn);
mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
LOG_FILE_HDR_SIZE + LOG_BLOCK_HDR_SIZE);
mach_write_to_4(buf + LOG_CHECKPOINT_LOG_BUF_SIZE, 2 * 1024 * 1024);
mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
fold = ut_fold_binary(buf, LOG_CHECKPOINT_CHECKSUM_1);
mach_write_to_4(buf + LOG_CHECKPOINT_CHECKSUM_1, fold);
@ -2272,7 +2272,7 @@ log_group_archive_file_header_write(
buf = *(group->archive_file_header_bufs + nth_file);
mach_write_to_4(buf + LOG_GROUP_ID, group->id);
mach_write_ull(buf + LOG_FILE_START_LSN, start_lsn);
mach_write_to_8(buf + LOG_FILE_START_LSN, start_lsn);
mach_write_to_4(buf + LOG_FILE_NO, file_no);
mach_write_to_4(buf + LOG_FILE_ARCH_COMPLETED, FALSE);
@ -2308,7 +2308,7 @@ log_group_archive_completed_header_write(
buf = *(group->archive_file_header_bufs + nth_file);
mach_write_to_4(buf + LOG_FILE_ARCH_COMPLETED, TRUE);
mach_write_ull(buf + LOG_FILE_END_LSN, end_lsn);
mach_write_to_8(buf + LOG_FILE_END_LSN, end_lsn);
dest_offset = nth_file * group->file_size + LOG_FILE_ARCH_COMPLETED;

40
storage/innobase/log/log0recv.c
View file

@ -704,11 +704,11 @@ recv_find_max_checkpoint(
group->state = LOG_GROUP_OK;
group->lsn = mach_read_ull(
group->lsn = mach_read_from_8(
buf + LOG_CHECKPOINT_LSN);
group->lsn_offset = mach_read_from_4(
buf + LOG_CHECKPOINT_OFFSET);
checkpoint_no = mach_read_ull(
checkpoint_no = mach_read_from_8(
buf + LOG_CHECKPOINT_NO);
#ifdef UNIV_DEBUG
@ -778,14 +778,14 @@ recv_read_cp_info_for_backup(
cp_buf = hdr + LOG_CHECKPOINT_1;
if (recv_check_cp_is_consistent(cp_buf)) {
max_cp_no = mach_read_ull(cp_buf + LOG_CHECKPOINT_NO);
max_cp_no = mach_read_from_8(cp_buf + LOG_CHECKPOINT_NO);
max_cp = LOG_CHECKPOINT_1;
}
cp_buf = hdr + LOG_CHECKPOINT_2;
if (recv_check_cp_is_consistent(cp_buf)) {
if (mach_read_ull(cp_buf + LOG_CHECKPOINT_NO) > max_cp_no) {
if (mach_read_from_8(cp_buf + LOG_CHECKPOINT_NO) > max_cp_no) {
max_cp = LOG_CHECKPOINT_2;
}
}
@ -796,7 +796,7 @@ recv_read_cp_info_for_backup(
cp_buf = hdr + max_cp;
*lsn = mach_read_ull(cp_buf + LOG_CHECKPOINT_LSN);
*lsn = mach_read_from_8(cp_buf + LOG_CHECKPOINT_LSN);
*offset = mach_read_from_4(cp_buf + LOG_CHECKPOINT_OFFSET);
/* If the user is running a pre-3.23.50 version of InnoDB, its
@ -816,9 +816,9 @@ recv_read_cp_info_for_backup(
/* fprintf(stderr, "fsp limit %lu MB\n", *fsp_limit); */
*cp_no = mach_read_ull(cp_buf + LOG_CHECKPOINT_NO);
*cp_no = mach_read_from_8(cp_buf + LOG_CHECKPOINT_NO);
*first_header_lsn = mach_read_ull(hdr + LOG_FILE_START_LSN);
*first_header_lsn = mach_read_from_8(hdr + LOG_FILE_START_LSN);
return(TRUE);
}
@ -1541,7 +1541,7 @@ recv_recover_page_func(
#endif /* !UNIV_HOTBACKUP */
/* Read the newest modification lsn from the page */
page_lsn = mach_read_ull(page + FIL_PAGE_LSN);
page_lsn = mach_read_from_8(page + FIL_PAGE_LSN);
#ifndef UNIV_HOTBACKUP
/* It may be that the page has been modified in the buffer
@ -1616,14 +1616,14 @@ recv_recover_page_func(
block, &mtr);
end_lsn = recv->start_lsn + recv->len;
mach_write_ull(FIL_PAGE_LSN + page, end_lsn);
mach_write_ull(UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM
+ page, end_lsn);
mach_write_to_8(FIL_PAGE_LSN + page, end_lsn);
mach_write_to_8(UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM
+ page, end_lsn);
if (page_zip) {
mach_write_ull(FIL_PAGE_LSN
+ page_zip->data, end_lsn);
mach_write_to_8(FIL_PAGE_LSN
+ page_zip->data, end_lsn);
}
}
@ -1995,7 +1995,7 @@ recv_apply_log_recs_for_backup(void)
buf_flush_init_for_writing(
block->frame, buf_block_get_page_zip(block),
mach_read_ull(block->frame + FIL_PAGE_LSN));
mach_read_from_8(block->frame + FIL_PAGE_LSN));
if (zip_size) {
error = fil_io(OS_FILE_WRITE, TRUE,
@ -2961,9 +2961,9 @@ recv_recovery_from_checkpoint_start_func(
buf = log_sys->checkpoint_buf;
checkpoint_lsn = mach_read_ull(buf + LOG_CHECKPOINT_LSN);
checkpoint_no = mach_read_ull(buf + LOG_CHECKPOINT_NO);
archived_lsn = mach_read_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN);
checkpoint_lsn = mach_read_from_8(buf + LOG_CHECKPOINT_LSN);
checkpoint_no = mach_read_from_8(buf + LOG_CHECKPOINT_NO);
archived_lsn = mach_read_from_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN);
/* Read the first log file header to print a note if this is
a recovery from a restored InnoDB Hot Backup */
@ -3613,8 +3613,8 @@ ask_again:
return(TRUE);
}
start_lsn = mach_read_ull(buf + LOG_FILE_START_LSN);
file_end_lsn = mach_read_ull(buf + LOG_FILE_END_LSN);
start_lsn = mach_read_from_8(buf + LOG_FILE_START_LSN);
file_end_lsn = mach_read_from_8(buf + LOG_FILE_END_LSN);
if (!recv_sys->scanned_lsn) {

32
storage/innobase/mach/mach0data.c
View file

@ -94,30 +94,31 @@ mach_parse_compressed(
}
/*********************************************************//**
Reads a dulint in a compressed form if the log record fully contains it.
@return pointer to end of the stored field, NULL if not complete */
Reads a 64-bit integer in a compressed form
if the log record fully contains it.
@return pointer to end of the stored field, NULL if not complete */
UNIV_INTERN
byte*
mach_dulint_parse_compressed(
/*=========================*/
byte* ptr, /*!< in: pointer to buffer from where to read */
byte* end_ptr,/*!< in: pointer to end of the buffer */
dulint* val) /*!< out: read value */
mach_ull_parse_compressed(
/*======================*/
byte* ptr, /* in: pointer to buffer from where to read */
byte* end_ptr,/* in: pointer to end of the buffer */
ib_uint64_t* val) /* out: read value */
{
ulint high;
ulint low;
ulint size;
ulint size;
ut_ad(ptr && end_ptr && val);
ut_ad(ptr);
ut_ad(end_ptr);
ut_ad(val);
if (end_ptr < ptr + 5) {
return(NULL);
}
high = mach_read_compressed(ptr);
*val = mach_read_compressed(ptr);
size = mach_get_compressed_size(high);
size = mach_get_compressed_size((ulint) *val);
ptr += size;
@ -126,9 +127,8 @@ mach_dulint_parse_compressed(
return(NULL);
}
low = mach_read_from_4(ptr);
*val = ut_dulint_create(high, low);
*val <<= 32;
*val |= mach_read_from_4(ptr);
return(ptr + 4);
}

22
storage/innobase/mtr/mtr0log.c
View file

@ -133,7 +133,7 @@ mlog_parse_initial_log_record(
}
/********************************************************//**
Parses a log record written by mlog_write_ulint or mlog_write_dulint.
Parses a log record written by mlog_write_ulint or mlog_write_ull.
@return parsed record end, NULL if not a complete record or a corrupt record */
UNIV_INTERN
byte*
@ -145,9 +145,9 @@ mlog_parse_nbytes(
byte* page, /*!< in: page where to apply the log record, or NULL */
void* page_zip)/*!< in/out: compressed page, or NULL */
{
ulint offset;
ulint val;
dulint dval;
ulint offset;
ulint val;
ib_uint64_t dval;
ut_a(type <= MLOG_8BYTES);
ut_a(!page || !page_zip || fil_page_get_type(page) != FIL_PAGE_INDEX);
@ -167,7 +167,7 @@ mlog_parse_nbytes(
}
if (type == MLOG_8BYTES) {
ptr = mach_dulint_parse_compressed(ptr, end_ptr, &dval);
ptr = mach_ull_parse_compressed(ptr, end_ptr, &dval);
if (ptr == NULL) {
@ -290,11 +290,11 @@ Writes 8 bytes to a file page buffered in the buffer pool.
Writes the corresponding log record to the mini-transaction log. */
UNIV_INTERN
void
mlog_write_dulint(
/*==============*/
byte* ptr, /*!< in: pointer where to write */
dulint val, /*!< in: value to write */
mtr_t* mtr) /*!< in: mini-transaction handle */
mlog_write_ull(
/*===========*/
byte* ptr, /*!< in: pointer where to write */
ib_uint64_t val, /*!< in: value to write */
mtr_t* mtr) /*!< in: mini-transaction handle */
{
byte* log_ptr;
@ -316,7 +316,7 @@ mlog_write_dulint(
mach_write_to_2(log_ptr, page_offset(ptr));
log_ptr += 2;
log_ptr += mach_dulint_write_compressed(log_ptr, val);
log_ptr += mach_ull_write_compressed(log_ptr, val);
mlog_close(mtr, log_ptr);
}

17
storage/innobase/mtr/mtr0mtr.c
View file

@ -375,23 +375,6 @@ mtr_read_ulint(
}
}
/********************************************************//**
Reads 8 bytes from a file page buffered in the buffer pool.
@return value read */
UNIV_INTERN
dulint
mtr_read_dulint(
/*============*/
const byte* ptr, /*!< in: pointer from where to read */
mtr_t* mtr __attribute__((unused)))
/*!< in: mini-transaction handle */
{
ut_ad(mtr->state == MTR_ACTIVE);
ut_ad(mtr_memo_contains_page(mtr, ptr, MTR_MEMO_PAGE_S_FIX)
|| mtr_memo_contains_page(mtr, ptr, MTR_MEMO_PAGE_X_FIX));
return(mach_read_from_8(ptr));
}
#ifdef UNIV_DEBUG
# ifndef UNIV_HOTBACKUP
/**********************************************************//**

6
storage/innobase/page/page0page.c
View file

@ -235,8 +235,8 @@ page_set_max_trx_id(
8, mtr);
#ifndef UNIV_HOTBACKUP
} else if (mtr) {
mlog_write_dulint(page + (PAGE_HEADER + PAGE_MAX_TRX_ID),
trx_id, mtr);
mlog_write_ull(page + (PAGE_HEADER + PAGE_MAX_TRX_ID),
trx_id, mtr);
#endif /* !UNIV_HOTBACKUP */
} else {
mach_write_to_8(page + (PAGE_HEADER + PAGE_MAX_TRX_ID), trx_id);
@ -457,7 +457,7 @@ page_create_low(
page_header_set_field(page, NULL, PAGE_DIRECTION, PAGE_NO_DIRECTION);
page_header_set_field(page, NULL, PAGE_N_DIRECTION, 0);
page_header_set_field(page, NULL, PAGE_N_RECS, 0);
page_set_max_trx_id(block, NULL, ut_dulint_zero, NULL);
page_set_max_trx_id(block, NULL, 0, NULL);
memset(heap_top, 0, UNIV_PAGE_SIZE - PAGE_EMPTY_DIR_START
- page_offset(heap_top));

4
storage/innobase/page/page0zip.c
View file

@ -4468,7 +4468,7 @@ page_zip_reorganize(
/* Copy max trx id to recreated page */
trx_id_t max_trx_id = page_get_max_trx_id(temp_page);
page_set_max_trx_id(block, NULL, max_trx_id, NULL);
ut_ad(!ut_dulint_is_zero(max_trx_id));
ut_ad(max_trx_id != 0);
}
/* Restore logging. */
@ -4528,7 +4528,7 @@ page_zip_copy_recs(
/* The PAGE_MAX_TRX_ID must be set on leaf pages of secondary
indexes. It does not matter on other pages. */
ut_a(dict_index_is_clust(index) || !page_is_leaf(src)
|| !ut_dulint_is_zero(page_get_max_trx_id(src)));
|| page_get_max_trx_id(src));
UNIV_MEM_ASSERT_W(page, UNIV_PAGE_SIZE);
UNIV_MEM_ASSERT_W(page_zip->data, page_zip_get_size(page_zip));

29
storage/innobase/pars/pars0pars.c
View file

@ -2030,29 +2030,6 @@ pars_info_add_int4_literal(
/****************************************************************//**
Equivalent to:
char buf[8];
mach_write_ull(buf, val);
pars_info_add_literal(info, name, buf, 8, DATA_INT, 0);
except that the buffer is dynamically allocated from the info struct's
heap. */
UNIV_INTERN
void
pars_info_add_uint64_literal(
/*=========================*/
pars_info_t* info, /*!< in: info struct */
const char* name, /*!< in: name */
ib_uint64_t val) /*!< in: value */
{
byte* buf = mem_heap_alloc(info->heap, 8);
mach_write_ull(buf, val);
pars_info_add_literal(info, name, buf, 8, DATA_INT, 0);
}
/****************************************************************//**
Equivalent to:
char buf[8];
mach_write_to_8(buf, val);
pars_info_add_literal(info, name, buf, 8, DATA_FIXBINARY, 0);
@ -2061,11 +2038,11 @@ except that the buffer is dynamically allocated from the info struct's
heap. */
UNIV_INTERN
void
pars_info_add_dulint_literal(
/*=========================*/
pars_info_add_ull_literal(
/*======================*/
pars_info_t* info, /*!< in: info struct */
const char* name, /*!< in: name */
dulint val) /*!< in: value */
ib_uint64_t val) /*!< in: value */
{
byte* buf = mem_heap_alloc(info->heap, 8);

42
storage/innobase/read/read0read.c
View file

@ -168,8 +168,7 @@ read_view_t*
read_view_oldest_copy_or_open_new(
/*==============================*/
trx_id_t cr_trx_id, /*!< in: trx_id of creating
transaction, or ut_dulint_zero
used in purge */
transaction, or 0 used in purge */
mem_heap_t* heap) /*!< in: memory heap from which
allocated */
{
@ -191,7 +190,7 @@ read_view_oldest_copy_or_open_new(
n = old_view->n_trx_ids;
if (!ut_dulint_is_zero(old_view->creator_trx_id)) {
if (old_view->creator_trx_id) {
n++;
} else {
needs_insert = FALSE;
@ -206,9 +205,8 @@ read_view_oldest_copy_or_open_new(
while (i < n) {
if (needs_insert
&& (i >= old_view->n_trx_ids
|| ut_dulint_cmp(old_view->creator_trx_id,
read_view_get_nth_trx_id(old_view, i))
> 0)) {
|| old_view->creator_trx_id
> read_view_get_nth_trx_id(old_view, i))) {
read_view_set_nth_trx_id(view_copy, i,
old_view->creator_trx_id);
@ -252,8 +250,7 @@ read_view_t*
read_view_open_now(
/*===============*/
trx_id_t cr_trx_id, /*!< in: trx_id of creating
transaction, or ut_dulint_zero
used in purge */
transaction, or 0 used in purge */
mem_heap_t* heap) /*!< in: memory heap from which
allocated */
{
@ -267,7 +264,7 @@ read_view_open_now(
view->creator_trx_id = cr_trx_id;
view->type = VIEW_NORMAL;
view->undo_no = ut_dulint_zero;
view->undo_no = 0;
/* No future transactions should be visible in the view */
@ -280,7 +277,7 @@ read_view_open_now(
/* No active transaction should be visible, except cr_trx */
while (trx) {
if (ut_dulint_cmp(trx->id, cr_trx_id) != 0
if (trx->id != cr_trx_id
&& (trx->conc_state == TRX_ACTIVE
|| trx->conc_state == TRX_PREPARED)) {
@ -292,9 +289,9 @@ read_view_open_now(
trx_sys->max_trx_id can still be active, if it is
in the middle of its commit! Note that when a
transaction starts, we initialize trx->no to
ut_dulint_max. */
IB_ULONGLONG_MAX. */
if (ut_dulint_cmp(view->low_limit_no, trx->no) > 0) {
if (view->low_limit_no > trx->no) {
view->low_limit_no = trx->no;
}
@ -367,22 +364,20 @@ read_view_print(
if (view->type == VIEW_HIGH_GRANULARITY) {
fprintf(stderr,
"High-granularity read view undo_n:o %lu %lu\n",
(ulong) ut_dulint_get_high(view->undo_no),
(ulong) ut_dulint_get_low(view->undo_no));
"High-granularity read view undo_n:o %llu\n",
(ullint) view->undo_no);
} else {
fprintf(stderr, "Normal read view\n");
}
fprintf(stderr, "Read view low limit trx n:o %lu %lu\n",
(ulong) ut_dulint_get_high(view->low_limit_no),
(ulong) ut_dulint_get_low(view->low_limit_no));
fprintf(stderr, "Read view low limit trx n:o " TRX_ID_FMT "\n",
(ullint) view->low_limit_no);
fprintf(stderr, "Read view up limit trx id " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(view->up_limit_id));
(ullint) view->up_limit_id);
fprintf(stderr, "Read view low limit trx id " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(view->low_limit_id));
(ullint) view->low_limit_id);
fprintf(stderr, "Read view individually stored trx ids:\n");
@ -390,8 +385,7 @@ read_view_print(
for (i = 0; i < n_ids; i++) {
fprintf(stderr, "Read view trx id " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(
read_view_get_nth_trx_id(view, i)));
(ullint) read_view_get_nth_trx_id(view, i));
}
}
@ -460,9 +454,9 @@ read_cursor_view_create_for_mysql(
trx_sys->max_trx_id can still be active, if it is
in the middle of its commit! Note that when a
transaction starts, we initialize trx->no to
ut_dulint_max. */
IB_ULONGLONG_MAX. */
if (ut_dulint_cmp(view->low_limit_no, trx->no) > 0) {
if (view->low_limit_no > trx->no) {
view->low_limit_no = trx->no;
}

8
storage/innobase/row/row0ins.c
View file

@ -87,7 +87,7 @@ ins_node_create(
node->select = NULL;
node->trx_id = ut_dulint_zero;
node->trx_id = 0;
node->entry_sys_heap = mem_heap_create(128);
@ -207,7 +207,7 @@ ins_node_set_new_row(
/* As we allocated a new trx id buf, the trx id should be written
there again: */
node->trx_id = ut_dulint_zero;
node->trx_id = 0;
}
/*******************************************************************//**
@ -2279,7 +2279,7 @@ row_ins_alloc_row_id_step(
/*======================*/
ins_node_t* node) /*!< in: row insert node */
{
dulint row_id;
row_id_t row_id;
ut_ad(node->state == INS_NODE_ALLOC_ROW_ID);
@ -2466,7 +2466,7 @@ row_ins_step(
/* It may be that the current session has not yet started
its transaction, or it has been committed: */
if (UT_DULINT_EQ(trx->id, node->trx_id)) {
if (trx->id == node->trx_id) {
/* No need to do IX-locking */
goto same_trx;

15
storage/innobase/row/row0merge.c
View file

@ -2023,7 +2023,7 @@ row_merge_drop_index(
ut_ad(index && table && trx);
pars_info_add_dulint_literal(info, "indexid", index->id);
pars_info_add_ull_literal(info, "indexid", index->id);
trx_start_if_not_started(trx);
trx->op_info = "dropping index";
@ -2093,7 +2093,7 @@ row_merge_drop_temp_indexes(void)
const rec_t* rec;
const byte* field;
ulint len;
dulint table_id;
table_id_t table_id;
dict_table_t* table;
btr_pcur_move_to_next_user_rec(&pcur, &mtr);
@ -2320,7 +2320,7 @@ row_merge_rename_indexes(
trx->op_info = "renaming indexes";
pars_info_add_dulint_literal(info, "tableid", table->id);
pars_info_add_ull_literal(info, "tableid", table->id);
err = que_eval_sql(info, rename_indexes, FALSE, trx);
@ -2508,8 +2508,7 @@ row_merge_create_index(
/* Note the id of the transaction that created this
index, we use it to restrict readers from accessing
this index, to ensure read consistency. */
index->trx_id = (ib_uint64_t)
ut_conv_dulint_to_longlong(trx->id);
index->trx_id = trx->id;
} else {
index = NULL;
}
@ -2526,10 +2525,8 @@ row_merge_is_index_usable(
const trx_t* trx, /*!< in: transaction */
const dict_index_t* index) /*!< in: index to check */
{
return(!trx->read_view || read_view_sees_trx_id(
trx->read_view,
ut_dulint_create((ulint) (index->trx_id >> 32),
(ulint) index->trx_id & 0xFFFFFFFF)));
return(!trx->read_view
|| read_view_sees_trx_id(trx->read_view, index->trx_id));
}
/*********************************************************************//**

12
storage/innobase/row/row0mysql.c
View file

@ -1532,7 +1532,7 @@ row_unlock_for_mysql(
}
}
if (ut_dulint_cmp(rec_trx_id, trx->id) != 0) {
if (rec_trx_id != trx->id) {
/* We did not update the record: unlock it */
rec = btr_pcur_get_rec(pcur);
@ -2283,7 +2283,7 @@ row_discard_tablespace_for_mysql(
trx_t* trx) /*!< in: transaction handle */
{
dict_foreign_t* foreign;
dulint new_id;
table_id_t new_id;
dict_table_t* table;
ibool success;
ulint err;
@ -2405,7 +2405,7 @@ row_discard_tablespace_for_mysql(
info = pars_info_create();
pars_info_add_str_literal(info, "table_name", name);
pars_info_add_dulint_literal(info, "new_id", new_id);
pars_info_add_ull_literal(info, "new_id", new_id);
err = que_eval_sql(info,
"PROCEDURE DISCARD_TABLESPACE_PROC () IS\n"
@ -2619,7 +2619,7 @@ row_truncate_table_for_mysql(
dict_index_t* sys_index;
btr_pcur_t pcur;
mtr_t mtr;
dulint new_id;
table_id_t new_id;
ulint recreate_space = 0;
pars_info_t* info = NULL;
@ -2873,8 +2873,8 @@ next_rec:
info = pars_info_create();
pars_info_add_int4_literal(info, "space", (lint) table->space);
pars_info_add_dulint_literal(info, "old_id", table->id);
pars_info_add_dulint_literal(info, "new_id", new_id);
pars_info_add_ull_literal(info, "old_id", table->id);
pars_info_add_ull_literal(info, "new_id", new_id);
err = que_eval_sql(info,
"PROCEDURE RENUMBER_TABLESPACE_PROC () IS\n"

9
storage/innobase/row/row0purge.c
View file

@ -151,10 +151,9 @@ row_purge_remove_clust_if_poss_low(
rec = btr_pcur_get_rec(pcur);
if (0 != ut_dulint_cmp(node->roll_ptr, row_get_rec_roll_ptr(
rec, index, rec_get_offsets(
rec, index, offsets_,
ULINT_UNDEFINED, &heap)))) {
if (node->roll_ptr != row_get_rec_roll_ptr(
rec, index, rec_get_offsets(rec, index, offsets_,
ULINT_UNDEFINED, &heap))) {
if (UNIV_LIKELY_NULL(heap)) {
mem_heap_free(heap);
}
@ -617,7 +616,7 @@ row_purge_parse_undo_rec(
byte* ptr;
trx_t* trx;
undo_no_t undo_no;
dulint table_id;
table_id_t table_id;
trx_id_t trx_id;
roll_ptr_t roll_ptr;
ulint info_bits;

3
storage/innobase/row/row0sel.c
View file

@ -4622,8 +4622,7 @@ row_search_check_if_query_cache_permitted(
IX type locks actually would require ret = FALSE. */
if (UT_LIST_GET_LEN(table->locks) == 0
&& ut_dulint_cmp(trx->id,
table->query_cache_inv_trx_id) >= 0) {
&& trx->id >= table->query_cache_inv_trx_id) {
ret = TRUE;

4
storage/innobase/row/row0uins.c
View file

@ -78,7 +78,7 @@ row_undo_ins_remove_clust_rec(
&mtr);
ut_a(success);
if (ut_dulint_cmp(node->table->id, DICT_INDEXES_ID) == 0) {
if (node->table->id == DICT_INDEXES_ID) {
ut_ad(node->trx->dict_operation_lock_mode == RW_X_LATCH);
/* Drop the index tree associated with the row in
@ -260,7 +260,7 @@ row_undo_ins_parse_undo_rec(
dict_index_t* clust_index;
byte* ptr;
undo_no_t undo_no;
dulint table_id;
table_id_t table_id;
ulint type;
ulint dummy;
ibool dummy_extern;

8
storage/innobase/row/row0umod.c
View file

@ -85,9 +85,9 @@ row_undo_mod_undo_also_prev_vers(
trx = node->trx;
if (0 != ut_dulint_cmp(node->new_trx_id, trx->id)) {
if (node->new_trx_id != trx->id) {
*undo_no = ut_dulint_zero;
*undo_no = 0;
return(FALSE);
}
@ -95,7 +95,7 @@ row_undo_mod_undo_also_prev_vers(
*undo_no = trx_undo_rec_get_undo_no(undo_rec);
return(ut_dulint_cmp(trx->roll_limit, *undo_no) <= 0);
return(trx->roll_limit <= *undo_no);
}
/***********************************************************//**
@ -790,7 +790,7 @@ row_undo_mod_parse_undo_rec(
dict_index_t* clust_index;
byte* ptr;
undo_no_t undo_no;
dulint table_id;
table_id_t table_id;
trx_id_t trx_id;
roll_ptr_t roll_ptr;
ulint info_bits;

5
storage/innobase/row/row0undo.c
View file

@ -185,9 +185,8 @@ row_undo_search_clust_to_pcur(
offsets = rec_get_offsets(rec, clust_index, offsets,
ULINT_UNDEFINED, &heap);
if (!found || 0 != ut_dulint_cmp(node->roll_ptr,
row_get_rec_roll_ptr(rec, clust_index,
offsets))) {
if (!found || node->roll_ptr
!= row_get_rec_roll_ptr(rec, clust_index, offsets)) {
/* We must remove the reservation on the undo log record
BEFORE releasing the latch on the clustered index page: this

9
storage/innobase/row/row0upd.c
View file

@ -377,7 +377,7 @@ row_upd_index_entry_sys_field(
them */
dict_index_t* index, /*!< in: clustered index */
ulint type, /*!< in: DATA_TRX_ID or DATA_ROLL_PTR */
dulint val) /*!< in: value to write */
ib_uint64_t val) /*!< in: value to write */
{
dfield_t* dfield;
byte* field;
@ -536,7 +536,7 @@ row_upd_write_sys_vals_to_log(
trx_write_roll_ptr(log_ptr, roll_ptr);
log_ptr += DATA_ROLL_PTR_LEN;
log_ptr += mach_dulint_write_compressed(log_ptr, trx->id);
log_ptr += mach_ull_write_compressed(log_ptr, trx->id);
return(log_ptr);
}
@ -570,7 +570,7 @@ row_upd_parse_sys_vals(
*roll_ptr = trx_read_roll_ptr(ptr);
ptr += DATA_ROLL_PTR_LEN;
ptr = mach_dulint_parse_compressed(ptr, end_ptr, trx_id);
ptr = mach_ull_parse_compressed(ptr, end_ptr, trx_id);
return(ptr);
}
@ -1912,8 +1912,7 @@ row_upd_clust_step(
then we have to free the file segments of the index tree associated
with the index */
if (node->is_delete
&& ut_dulint_cmp(node->table->id, DICT_INDEXES_ID) == 0) {
if (node->is_delete && node->table->id == DICT_INDEXES_ID) {
dict_drop_index_tree(btr_pcur_get_rec(pcur), mtr);

12
storage/innobase/row/row0vers.c
View file

@ -209,7 +209,7 @@ row_vers_impl_x_locked_off_kernel(
prev_trx_id must have already committed for the trx_id
to be able to modify the row. Therefore, prev_trx_id
cannot hold any implicit lock. */
if (vers_del && 0 != ut_dulint_cmp(trx_id, prev_trx_id)) {
if (vers_del && trx_id != prev_trx_id) {
mutex_enter(&kernel_mutex);
break;
@ -280,7 +280,7 @@ row_vers_impl_x_locked_off_kernel(
break;
}
if (0 != ut_dulint_cmp(trx_id, prev_trx_id)) {
if (trx_id != prev_trx_id) {
/* The versions modified by the trx_id transaction end
to prev_version: no implicit x-lock */
@ -533,7 +533,7 @@ row_vers_build_for_consistent_read(
undo_no of the record is < undo_no in the view. */
if (view->type == VIEW_HIGH_GRANULARITY
&& ut_dulint_cmp(view->creator_trx_id, trx_id) == 0) {
&& view->creator_trx_id == trx_id) {
roll_ptr = row_get_rec_roll_ptr(version, index,
*offsets);
@ -541,7 +541,7 @@ row_vers_build_for_consistent_read(
undo_no = trx_undo_rec_get_undo_no(undo_rec);
mem_heap_empty(heap);
if (ut_dulint_cmp(view->undo_no, undo_no) > 0) {
if (view->undo_no > undo_no) {
/* The view already sees this version: we can
copy it to in_heap and return */
@ -632,7 +632,7 @@ row_vers_build_for_semi_consistent_read(
mem_heap_t* heap = NULL;
byte* buf;
ulint err;
trx_id_t rec_trx_id = ut_dulint_zero;
trx_id_t rec_trx_id = 0;
ut_ad(dict_index_is_clust(index));
ut_ad(mtr_memo_contains_page(mtr, rec, MTR_MEMO_PAGE_X_FIX)
@ -684,7 +684,7 @@ row_vers_build_for_semi_consistent_read(
rolled back and the transaction is removed from
the global list of transactions. */
if (!ut_dulint_cmp(rec_trx_id, version_trx_id)) {
if (rec_trx_id == version_trx_id) {
/* The transaction was committed while
we searched for earlier versions.
Return the current version as a

6
storage/innobase/trx/trx0i_s.c
View file

@ -444,7 +444,7 @@ fill_trx_row(
ut_ad(mutex_own(&kernel_mutex));
row->trx_id = trx_get_id(trx);
row->trx_id = trx->id;
row->trx_started = (ib_time_t) trx->start_time;
row->trx_state = trx_get_que_state_str(trx);
@ -462,7 +462,7 @@ fill_trx_row(
row->trx_wait_started = 0;
}
row->trx_weight = (ullint) ut_conv_dulint_to_longlong(TRX_WEIGHT(trx));
row->trx_weight = (ullint) TRX_WEIGHT(trx);
if (trx->mysql_thd == NULL) {
/* For internal transactions e.g., purge and transactions
@ -527,7 +527,7 @@ thd_done:
row->trx_rows_locked = lock_number_of_rows_locked(trx);
row->trx_rows_modified = ut_conv_dulint_to_longlong(trx->undo_no);
row->trx_rows_modified = trx->undo_no;
row->trx_concurrency_tickets = trx->n_tickets_to_enter_innodb;

106
storage/innobase/trx/trx0purge.c
View file

@ -145,47 +145,44 @@ void
trx_purge_arr_get_biggest(
/*======================*/
trx_undo_arr_t* arr, /*!< in: purge array */
trx_id_t* trx_no, /*!< out: transaction number: ut_dulint_zero
trx_id_t* trx_no, /*!< out: transaction number: 0
if array is empty */
undo_no_t* undo_no)/*!< out: undo number */
{
trx_undo_inf_t* cell;
trx_id_t pair_trx_no;
undo_no_t pair_undo_no;
int trx_cmp;
ulint n_used;
ulint i;
ulint n;
n = 0;
n_used = arr->n_used;
pair_trx_no = ut_dulint_zero;
pair_undo_no = ut_dulint_zero;
n = arr->n_used;
pair_trx_no = 0;
pair_undo_no = 0;
for (i = 0;; i++) {
cell = trx_undo_arr_get_nth_info(arr, i);
if (n) {
for (i = 0;; i++) {
cell = trx_undo_arr_get_nth_info(arr, i);
if (cell->in_use) {
n++;
trx_cmp = ut_dulint_cmp(cell->trx_no, pair_trx_no);
if (!cell->in_use) {
continue;
}
if ((trx_cmp > 0)
|| ((trx_cmp == 0)
&& (ut_dulint_cmp(cell->undo_no,
pair_undo_no) >= 0))) {
if ((cell->trx_no > pair_trx_no)
|| ((cell->trx_no == pair_trx_no)
&& cell->undo_no >= pair_undo_no)) {
pair_trx_no = cell->trx_no;
pair_undo_no = cell->undo_no;
}
}
if (n == n_used) {
*trx_no = pair_trx_no;
*undo_no = pair_undo_no;
return;
if (!--n) {
break;
}
}
}
*trx_no = pair_trx_no;
*undo_no = pair_undo_no;
}
/****************************************************************//**
@ -233,8 +230,8 @@ trx_purge_sys_create(void)
purge_sys->n_pages_handled = 0;
purge_sys->purge_trx_no = ut_dulint_zero;
purge_sys->purge_undo_no = ut_dulint_zero;
purge_sys->purge_trx_no = 0;
purge_sys->purge_undo_no = 0;
purge_sys->next_stored = FALSE;
rw_lock_create(trx_purge_latch_key,
@ -257,7 +254,7 @@ trx_purge_sys_create(void)
purge_sys->query = trx_purge_graph_build();
purge_sys->view = read_view_oldest_copy_or_open_new(ut_dulint_zero,
purge_sys->view = read_view_oldest_copy_or_open_new(0,
purge_sys->heap);
}
@ -370,7 +367,7 @@ trx_purge_add_update_undo_to_history(
}
/* Write the trx number to the undo log header */
mlog_write_dulint(undo_header + TRX_UNDO_TRX_NO, trx->no, mtr);
mlog_write_ull(undo_header + TRX_UNDO_TRX_NO, trx->no, mtr);
/* Write information about delete markings to the undo log header */
if (!undo->del_marks) {
@ -512,9 +509,9 @@ trx_purge_truncate_rseg_history(
page_t* undo_page;
trx_ulogf_t* log_hdr;
trx_usegf_t* seg_hdr;
int cmp;
ulint n_removed_logs = 0;
mtr_t mtr;
trx_id_t undo_trx_no;
ut_ad(mutex_own(&(purge_sys->mutex)));
@ -540,15 +537,16 @@ loop:
hdr_addr.page, &mtr);
log_hdr = undo_page + hdr_addr.boffset;
undo_trx_no = mach_read_from_8(log_hdr + TRX_UNDO_TRX_NO);
cmp = ut_dulint_cmp(mach_read_from_8(log_hdr + TRX_UNDO_TRX_NO),
limit_trx_no);
if (cmp == 0) {
trx_undo_truncate_start(rseg, rseg->space, hdr_addr.page,
hdr_addr.boffset, limit_undo_no);
}
if (undo_trx_no >= limit_trx_no) {
if (undo_trx_no == limit_trx_no) {
trx_undo_truncate_start(rseg, rseg->space,
hdr_addr.page,
hdr_addr.boffset,
limit_undo_no);
}
if (cmp >= 0) {
mutex_enter(&kernel_mutex);
ut_a(trx_sys->rseg_history_len >= n_removed_logs);
trx_sys->rseg_history_len -= n_removed_logs;
@ -614,7 +612,7 @@ trx_purge_truncate_history(void)
trx_purge_arr_get_biggest(purge_sys->arr, &limit_trx_no,
&limit_undo_no);
if (ut_dulint_is_zero(limit_trx_no)) {
if (limit_trx_no == 0) {
limit_trx_no = purge_sys->purge_trx_no;
limit_undo_no = purge_sys->purge_undo_no;
@ -623,13 +621,12 @@ trx_purge_truncate_history(void)
/* We play safe and set the truncate limit at most to the purge view
low_limit number, though this is not necessary */
if (ut_dulint_cmp(limit_trx_no, purge_sys->view->low_limit_no) >= 0) {
if (limit_trx_no >= purge_sys->view->low_limit_no) {
limit_trx_no = purge_sys->view->low_limit_no;
limit_undo_no = ut_dulint_zero;
limit_undo_no = 0;
}
ut_ad((ut_dulint_cmp(limit_trx_no,
purge_sys->view->low_limit_no) <= 0));
ut_ad(limit_trx_no <= purge_sys->view->low_limit_no);
rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
@ -684,8 +681,8 @@ trx_purge_rseg_get_next_history_log(
ut_a(rseg->last_page_no != FIL_NULL);
purge_sys->purge_trx_no = ut_dulint_add(rseg->last_trx_no, 1);
purge_sys->purge_undo_no = ut_dulint_zero;
purge_sys->purge_trx_no = rseg->last_trx_no + 1;
purge_sys->purge_undo_no = 0;
purge_sys->next_stored = FALSE;
mtr_start(&mtr);
@ -787,7 +784,7 @@ trx_purge_choose_next_log(void)
rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
min_trx_no = ut_dulint_max;
min_trx_no = IB_ULONGLONG_MAX;
min_rseg = NULL;
@ -796,9 +793,8 @@ trx_purge_choose_next_log(void)
if (rseg->last_page_no != FIL_NULL) {
if ((min_rseg == NULL)
|| (ut_dulint_cmp(min_trx_no,
rseg->last_trx_no) > 0)) {
if (min_rseg == NULL
|| min_trx_no > rseg->last_trx_no) {
min_rseg = rseg;
min_trx_no = rseg->last_trx_no;
@ -848,7 +844,7 @@ trx_purge_choose_next_log(void)
if (rec == &trx_purge_dummy_rec) {
purge_sys->purge_undo_no = ut_dulint_zero;
purge_sys->purge_undo_no = 0;
purge_sys->page_no = page_no;
purge_sys->offset = 0;
} else {
@ -1041,8 +1037,7 @@ trx_purge_fetch_next_rec(
return(NULL);
}
if (ut_dulint_cmp(purge_sys->purge_trx_no,
purge_sys->view->low_limit_no) >= 0) {
if (purge_sys->purge_trx_no >= purge_sys->view->low_limit_no) {
purge_sys->state = TRX_STOP_PURGE;
trx_purge_truncate_if_arr_empty();
@ -1052,10 +1047,10 @@ trx_purge_fetch_next_rec(
return(NULL);
}
/* fprintf(stderr, "Thread %lu purging trx %lu undo record %lu\n",
/* fprintf(stderr, "Thread %lu purging trx %llu undo record %llu\n",
os_thread_get_curr_id(),
ut_dulint_get_low(purge_sys->purge_trx_no),
ut_dulint_get_low(purge_sys->purge_undo_no)); */
(ullint) purge_sys->purge_trx_no,
(ullint) purge_sys->purge_undo_no); */
*roll_ptr = trx_undo_build_roll_ptr(FALSE, (purge_sys->rseg)->id,
purge_sys->page_no,
@ -1064,8 +1059,7 @@ trx_purge_fetch_next_rec(
*cell = trx_purge_arr_store_info(purge_sys->purge_trx_no,
purge_sys->purge_undo_no);
ut_ad(ut_dulint_cmp(purge_sys->purge_trx_no,
(purge_sys->view)->low_limit_no) < 0);
ut_ad(purge_sys->purge_trx_no < purge_sys->view->low_limit_no);
/* The following call will advance the stored values of purge_trx_no
and purge_undo_no, therefore we had to store them first */
@ -1157,7 +1151,7 @@ trx_purge(
}
}
purge_sys->view = read_view_oldest_copy_or_open_new(ut_dulint_zero,
purge_sys->view = read_view_oldest_copy_or_open_new(0,
purge_sys->heap);
mutex_exit(&kernel_mutex);
@ -1215,8 +1209,8 @@ trx_purge_sys_print(void)
fprintf(stderr, "InnoDB: Purge trx n:o " TRX_ID_FMT
", undo n:o " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(purge_sys->purge_trx_no),
TRX_ID_PREP_PRINTF(purge_sys->purge_undo_no));
(ullint) purge_sys->purge_trx_no,
(ullint) purge_sys->purge_undo_no);
fprintf(stderr,
"InnoDB: Purge next stored %lu, page_no %lu, offset %lu,\n"
"InnoDB: Purge hdr_page_no %lu, hdr_offset %lu\n",

64
storage/innobase/trx/trx0rec.c
View file

@ -242,8 +242,8 @@ trx_undo_page_report_insert(
/* Store first some general parameters to the undo log */
*ptr++ = TRX_UNDO_INSERT_REC;
ptr += mach_dulint_write_much_compressed(ptr, trx->undo_no);
ptr += mach_dulint_write_much_compressed(ptr, index->table->id);
ptr += mach_ull_write_much_compressed(ptr, trx->undo_no);
ptr += mach_ull_write_much_compressed(ptr, index->table->id);
/*----------------------------------------*/
/* Store then the fields required to uniquely determine the record
to be inserted in the clustered index */
@ -289,7 +289,7 @@ trx_undo_rec_get_pars(
ibool* updated_extern, /*!< out: TRUE if we updated an
externally stored fild */
undo_no_t* undo_no, /*!< out: undo log record number */
dulint* table_id) /*!< out: table id */
table_id_t* table_id) /*!< out: table id */
{
byte* ptr;
ulint type_cmpl;
@ -309,11 +309,11 @@ trx_undo_rec_get_pars(
*type = type_cmpl & (TRX_UNDO_CMPL_INFO_MULT - 1);
*cmpl_info = type_cmpl / TRX_UNDO_CMPL_INFO_MULT;
*undo_no = mach_dulint_read_much_compressed(ptr);
ptr += mach_dulint_get_much_compressed_size(*undo_no);
*undo_no = mach_ull_read_much_compressed(ptr);
ptr += mach_ull_get_much_compressed_size(*undo_no);
*table_id = mach_dulint_read_much_compressed(ptr);
ptr += mach_dulint_get_much_compressed_size(*table_id);
*table_id = mach_ull_read_much_compressed(ptr);
ptr += mach_ull_get_much_compressed_size(*table_id);
return(ptr);
}
@ -598,9 +598,9 @@ trx_undo_page_report_modify(
type_cmpl_ptr = ptr;
*ptr++ = (byte) type_cmpl;
ptr += mach_dulint_write_much_compressed(ptr, trx->undo_no);
ptr += mach_ull_write_much_compressed(ptr, trx->undo_no);
ptr += mach_dulint_write_much_compressed(ptr, table->id);
ptr += mach_ull_write_much_compressed(ptr, table->id);
/*----------------------------------------*/
/* Store the state of the info bits */
@ -620,16 +620,16 @@ trx_undo_page_report_modify(
by some other trx as it must have committed by now for us to
allow an over-write. */
if (ignore_prefix) {
ignore_prefix = ut_dulint_cmp(trx_id, trx->id) != 0;
ignore_prefix = (trx_id != trx->id);
}
ptr += mach_dulint_write_compressed(ptr, trx_id);
ptr += mach_ull_write_compressed(ptr, trx_id);
field = rec_get_nth_field(rec, offsets,
dict_index_get_sys_col_pos(
index, DATA_ROLL_PTR), &flen);
ut_ad(flen == DATA_ROLL_PTR_LEN);
ptr += mach_dulint_write_compressed(ptr, trx_read_roll_ptr(field));
ptr += mach_ull_write_compressed(ptr, trx_read_roll_ptr(field));
/*----------------------------------------*/
/* Store then the fields required to uniquely determine the
@ -848,11 +848,11 @@ trx_undo_update_rec_get_sys_cols(
/* Read the values of the system columns */
*trx_id = mach_dulint_read_compressed(ptr);
ptr += mach_dulint_get_compressed_size(*trx_id);
*trx_id = mach_ull_read_compressed(ptr);
ptr += mach_ull_get_compressed_size(*trx_id);
*roll_ptr = mach_dulint_read_compressed(ptr);
ptr += mach_dulint_get_compressed_size(*roll_ptr);
*roll_ptr = mach_ull_read_compressed(ptr);
ptr += mach_ull_get_compressed_size(*roll_ptr);
return(ptr);
}
@ -1168,7 +1168,7 @@ trx_undo_report_row_operation(
index, otherwise NULL */
roll_ptr_t* roll_ptr) /*!< out: rollback pointer to the
inserted undo log record,
ut_dulint_zero if BTR_NO_UNDO_LOG
0 if BTR_NO_UNDO_LOG
flag was specified */
{
trx_t* trx;
@ -1186,7 +1186,7 @@ trx_undo_report_row_operation(
if (flags & BTR_NO_UNDO_LOG_FLAG) {
*roll_ptr = ut_dulint_zero;
*roll_ptr = 0;
return(DB_SUCCESS);
}
@ -1284,7 +1284,7 @@ trx_undo_report_row_operation(
undo->top_undo_no = trx->undo_no;
undo->guess_block = undo_block;
UT_DULINT_INC(trx->undo_no);
trx->undo_no++;
mutex_exit(&trx->undo_mutex);
@ -1433,7 +1433,7 @@ trx_undo_prev_version_build(
trx_id_t rec_trx_id;
ulint type;
undo_no_t undo_no;
dulint table_id;
table_id_t table_id;
trx_id_t trx_id;
roll_ptr_t roll_ptr;
roll_ptr_t old_roll_ptr;
@ -1523,7 +1523,7 @@ trx_undo_prev_version_build(
roll_ptr, info_bits,
NULL, heap, &update);
if (ut_dulint_cmp(table_id, index->table->id) != 0) {
if (UNIV_UNLIKELY(table_id != index->table->id)) {
ptr = NULL;
fprintf(stderr,
@ -1544,16 +1544,14 @@ trx_undo_prev_version_build(
fprintf(stderr,
"InnoDB: table %s, index %s, n_uniq %lu\n"
"InnoDB: undo rec address %p, type %lu cmpl_info %lu\n"
"InnoDB: undo rec table id %lu %lu,"
" index table id %lu %lu\n"
"InnoDB: undo rec table id %llu,"
" index table id %llu\n"
"InnoDB: dump of 150 bytes in undo rec: ",
index->table_name, index->name,
(ulong) dict_index_get_n_unique(index),
undo_rec, (ulong) type, (ulong) cmpl_info,
(ulong) ut_dulint_get_high(table_id),
(ulong) ut_dulint_get_low(table_id),
(ulong) ut_dulint_get_high(index->table->id),
(ulong) ut_dulint_get_low(index->table->id));
(ullint) table_id,
(ullint) index->table->id);
ut_print_buf(stderr, undo_rec, 150);
fputs("\n"
"InnoDB: index record ", stderr);
@ -1564,14 +1562,10 @@ trx_undo_prev_version_build(
fprintf(stderr, "\n"
"InnoDB: Record trx id " TRX_ID_FMT
", update rec trx id " TRX_ID_FMT "\n"
"InnoDB: Roll ptr in rec %lu %lu, in update rec"
" %lu %lu\n",
TRX_ID_PREP_PRINTF(rec_trx_id),
TRX_ID_PREP_PRINTF(trx_id),
(ulong) ut_dulint_get_high(old_roll_ptr),
(ulong) ut_dulint_get_low(old_roll_ptr),
(ulong) ut_dulint_get_high(roll_ptr),
(ulong) ut_dulint_get_low(roll_ptr));
"InnoDB: Roll ptr in rec " TRX_ID_FMT
", in update rec" TRX_ID_FMT "\n",
(ullint) rec_trx_id, (ullint) trx_id,
(ullint) old_roll_ptr, (ullint) roll_ptr);
trx_purge_sys_print();
return(DB_ERROR);

77
storage/innobase/trx/trx0roll.c
View file

@ -52,7 +52,7 @@ static trx_t* trx_roll_crash_recv_trx = NULL;
/** In crash recovery we set this to the undo n:o of the current trx to be
rolled back. Then we can print how many % the rollback has progressed. */
static ib_int64_t trx_roll_max_undo_no;
static undo_no_t trx_roll_max_undo_no;
/** Auxiliary variable which tells the previous progress % we printed */
static ulint trx_roll_progress_printed_pct;
@ -443,7 +443,7 @@ trx_rollback_active(
ut_a(thr == que_fork_start_command(fork));
trx_roll_crash_recv_trx = trx;
trx_roll_max_undo_no = ut_conv_dulint_to_longlong(trx->undo_no);
trx_roll_max_undo_no = trx->undo_no;
trx_roll_progress_printed_pct = 0;
rows_to_undo = trx_roll_max_undo_no;
@ -456,7 +456,7 @@ trx_rollback_active(
fprintf(stderr,
" InnoDB: Rolling back trx with id " TRX_ID_FMT ", %lu%s"
" rows to undo\n",
TRX_ID_PREP_PRINTF(trx->id),
(ullint) trx->id,
(ulong) rows_to_undo, unit);
mutex_exit(&kernel_mutex);
@ -478,8 +478,9 @@ trx_rollback_active(
mutex_exit(&kernel_mutex);
fprintf(stderr,
"InnoDB: Waiting for rollback of trx id %lu to end\n",
(ulong) ut_dulint_get_low(trx->id));
"InnoDB: Waiting for rollback of trx id "
TRX_ID_FMT " to end\n",
(ullint) trx->id);
os_thread_sleep(100000);
mutex_enter(&kernel_mutex);
@ -488,16 +489,15 @@ trx_rollback_active(
mutex_exit(&kernel_mutex);
if (trx_get_dict_operation(trx) != TRX_DICT_OP_NONE
&& !ut_dulint_is_zero(trx->table_id)) {
&& trx->table_id != 0) {
/* If the transaction was for a dictionary operation, we
drop the relevant table, if it still exists */
fprintf(stderr,
"InnoDB: Dropping table with id %lu %lu"
"InnoDB: Dropping table with id %llu"
" in recovery if it exists\n",
(ulong) ut_dulint_get_high(trx->table_id),
(ulong) ut_dulint_get_low(trx->table_id));
(ullint) trx->table_id);
table = dict_table_get_on_id_low(trx->table_id);
@ -521,7 +521,7 @@ trx_rollback_active(
fprintf(stderr, "\nInnoDB: Rolling back of trx id " TRX_ID_FMT
" completed\n",
TRX_ID_PREP_PRINTF(trx->id));
(ullint) trx->id);
mem_heap_free(heap);
trx_roll_crash_recv_trx = NULL;
@ -574,7 +574,7 @@ loop:
fprintf(stderr,
"InnoDB: Cleaning up trx with id "
TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(trx->id));
(ullint) trx->id);
trx_cleanup_at_db_startup(trx);
goto loop;
@ -710,7 +710,7 @@ trx_undo_arr_store_info(
} else {
n++;
if (0 == ut_dulint_cmp(cell->undo_no, undo_no)) {
if (cell->undo_no == undo_no) {
if (stored_here) {
stored_here->in_use = FALSE;
@ -754,7 +754,7 @@ trx_undo_arr_remove_info(
cell = trx_undo_arr_get_nth_info(arr, i);
if (cell->in_use
&& 0 == ut_dulint_cmp(cell->undo_no, undo_no)) {
&& cell->undo_no == undo_no) {
cell->in_use = FALSE;
@ -769,7 +769,7 @@ trx_undo_arr_remove_info(
/*******************************************************************//**
Gets the biggest undo number in an array.
@return biggest value, ut_dulint_zero if the array is empty */
@return biggest value, 0 if the array is empty */
static
undo_no_t
trx_undo_arr_get_biggest(
@ -784,14 +784,14 @@ trx_undo_arr_get_biggest(
n = 0;
n_used = arr->n_used;
biggest = ut_dulint_zero;
biggest = 0;
for (i = 0;; i++) {
cell = trx_undo_arr_get_nth_info(arr, i);
if (cell->in_use) {
n++;
if (ut_dulint_cmp(cell->undo_no, biggest) > 0) {
if (cell->undo_no > biggest) {
biggest = cell->undo_no;
}
@ -827,9 +827,9 @@ trx_roll_try_truncate(
if (arr->n_used > 0) {
biggest = trx_undo_arr_get_biggest(arr);
if (ut_dulint_cmp(biggest, limit) >= 0) {
if (biggest >= limit) {
limit = ut_dulint_add(biggest, 1);
limit = biggest + 1;
}
}
@ -865,9 +865,9 @@ trx_roll_pop_top_rec(
undo->top_page_no, mtr);
offset = undo->top_offset;
/* fprintf(stderr, "Thread %lu undoing trx %lu undo record %lu\n",
os_thread_get_curr_id(), ut_dulint_get_low(trx->id),
ut_dulint_get_low(undo->top_undo_no)); */
/* fprintf(stderr, "Thread %lu undoing trx " TRX_ID_FMT
" undo record " TRX_ID_FMT "\n",
os_thread_get_curr_id(), trx->id, undo->top_undo_no); */
prev_rec = trx_undo_get_prev_rec(undo_page + offset,
undo->hdr_page_no, undo->hdr_offset,
@ -938,15 +938,14 @@ try_again:
undo = upd_undo;
} else if (!upd_undo || upd_undo->empty) {
undo = ins_undo;
} else if (ut_dulint_cmp(upd_undo->top_undo_no,
ins_undo->top_undo_no) > 0) {
} else if (upd_undo->top_undo_no > ins_undo->top_undo_no) {
undo = upd_undo;
} else {
undo = ins_undo;
}
if (!undo || undo->empty
|| (ut_dulint_cmp(limit, undo->top_undo_no) > 0)) {
|| limit > undo->top_undo_no) {
if ((trx->undo_no_arr)->n_used == 0) {
/* Rollback is ending */
@ -978,7 +977,7 @@ try_again:
undo_no = trx_undo_rec_get_undo_no(undo_rec);
ut_ad(ut_dulint_cmp(ut_dulint_add(undo_no, 1), trx->undo_no) == 0);
ut_ad(undo_no + 1 == trx->undo_no);
/* We print rollback progress info if we are in a crash recovery
and the transaction has at least 1000 row operations to undo. */
@ -986,8 +985,7 @@ try_again:
if (trx == trx_roll_crash_recv_trx && trx_roll_max_undo_no > 1000) {
progress_pct = 100 - (ulint)
((ut_conv_dulint_to_longlong(undo_no) * 100)
/ trx_roll_max_undo_no);
((undo_no * 100) / trx_roll_max_undo_no);
if (progress_pct != trx_roll_progress_printed_pct) {
if (trx_roll_progress_printed_pct == 0) {
fprintf(stderr,
@ -1090,22 +1088,21 @@ trx_rollback(
/* Initialize the rollback field in the transaction */
if (sig->type == TRX_SIG_TOTAL_ROLLBACK) {
trx->roll_limit = ut_dulint_zero;
} else if (sig->type == TRX_SIG_ROLLBACK_TO_SAVEPT) {
switch (sig->type) {
case TRX_SIG_TOTAL_ROLLBACK:
trx->roll_limit = 0;
break;
case TRX_SIG_ROLLBACK_TO_SAVEPT:
trx->roll_limit = (sig->savept).least_undo_no;
} else if (sig->type == TRX_SIG_ERROR_OCCURRED) {
break;
case TRX_SIG_ERROR_OCCURRED:
trx->roll_limit = trx->last_sql_stat_start.least_undo_no;
} else {
break;
default:
ut_error;
}
ut_a(ut_dulint_cmp(trx->roll_limit, trx->undo_no) <= 0);
ut_a(trx->roll_limit <= trx->undo_no);
trx->pages_undone = 0;
@ -1269,8 +1266,8 @@ trx_finish_rollback_off_kernel(
#ifdef UNIV_DEBUG
if (lock_print_waits) {
fprintf(stderr, "Trx %lu rollback finished\n",
(ulong) ut_dulint_get_low(trx->id));
fprintf(stderr, "Trx " TRX_ID_FMT " rollback finished\n",
(ullint) trx->id);
}
#endif /* UNIV_DEBUG */

4
storage/innobase/trx/trx0rseg.c
View file

@ -236,8 +236,8 @@ trx_rseg_mem_create(
node_addr.page,
mtr) + node_addr.boffset;
rseg->last_trx_no = mtr_read_dulint(
undo_log_hdr + TRX_UNDO_TRX_NO, mtr);
rseg->last_trx_no = mach_read_from_8(
undo_log_hdr + TRX_UNDO_TRX_NO);
rseg->last_del_marks = mtr_read_ulint(
undo_log_hdr + TRX_UNDO_DEL_MARKS, MLOG_2BYTES, mtr);
} else {

57
storage/innobase/trx/trx0sys.c
View file

@ -664,8 +664,8 @@ trx_sys_flush_max_trx_id(void)
sys_header = trx_sysf_get(&mtr);
mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE,
trx_sys->max_trx_id, &mtr);
mlog_write_ull(sys_header + TRX_SYS_TRX_ID_STORE,
trx_sys->max_trx_id, &mtr);
mtr_commit(&mtr);
}
@ -912,8 +912,7 @@ trx_sysf_create(
sys_header = trx_sysf_get(mtr);
/* Start counting transaction ids from number 1 up */
mach_write_to_8(sys_header + TRX_SYS_TRX_ID_STORE,
ut_dulint_create(0, 1));
mach_write_to_8(sys_header + TRX_SYS_TRX_ID_STORE, 1);
/* Reset the rollback segment slots. Old versions of InnoDB
define TRX_SYS_N_RSEGS as 256 (TRX_SYS_OLD_N_RSEGS) and expect
@ -950,7 +949,7 @@ trx_sys_init_at_db_start(void)
/*==========================*/
{
trx_sysf_t* sys_header;
ib_int64_t rows_to_undo = 0;
ib_uint64_t rows_to_undo = 0;
const char* unit = "";
trx_t* trx;
mtr_t mtr;
@ -976,12 +975,10 @@ trx_sys_init_at_db_start(void)
to the disk-based header! Thus trx id values will not overlap when
the database is repeatedly started! */
trx_sys->max_trx_id = ut_dulint_add(
ut_dulint_align_up(mtr_read_dulint(
sys_header
+ TRX_SYS_TRX_ID_STORE, &mtr),
TRX_SYS_TRX_ID_WRITE_MARGIN),
2 * TRX_SYS_TRX_ID_WRITE_MARGIN);
trx_sys->max_trx_id = 2 * TRX_SYS_TRX_ID_WRITE_MARGIN
+ ut_uint64_align_up(mach_read_from_8(sys_header
+ TRX_SYS_TRX_ID_STORE),
TRX_SYS_TRX_ID_WRITE_MARGIN);
UT_LIST_INIT(trx_sys->mysql_trx_list);
trx_dummy_sess = sess_open();
@ -992,9 +989,8 @@ trx_sys_init_at_db_start(void)
for (;;) {
if ( trx->conc_state != TRX_PREPARED) {
rows_to_undo += ut_conv_dulint_to_longlong(
trx->undo_no);
if (trx->conc_state != TRX_PREPARED) {
rows_to_undo += trx->undo_no;
}
trx = UT_LIST_GET_NEXT(trx_list, trx);
@ -1017,7 +1013,7 @@ trx_sys_init_at_db_start(void)
(ulong) rows_to_undo, unit);
fprintf(stderr, "InnoDB: Trx id counter is " TRX_ID_FMT "\n",
TRX_ID_PREP_PRINTF(trx_sys->max_trx_id));
(ullint) trx_sys->max_trx_id);
}
UT_LIST_INIT(trx_sys->view_list);
@ -1061,7 +1057,7 @@ trx_sys_file_format_max_write(
mtr_t mtr;
byte* ptr;
buf_block_t* block;
ulint tag_value_low;
ib_uint64_t tag_value;
mtr_start(&mtr);
@ -1072,17 +1068,13 @@ trx_sys_file_format_max_write(
file_format_max.name = trx_sys_file_format_id_to_name(format_id);
ptr = buf_block_get_frame(block) + TRX_SYS_FILE_FORMAT_TAG;
tag_value_low = format_id + TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
tag_value = format_id + TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
if (name) {
*name = file_format_max.name;
}
mlog_write_dulint(
ptr,
ut_dulint_create(TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH,
tag_value_low),
&mtr);
mlog_write_ull(ptr, tag_value, &mtr);
mtr_commit(&mtr);
@ -1100,8 +1092,7 @@ trx_sys_file_format_max_read(void)
mtr_t mtr;
const byte* ptr;
const buf_block_t* block;
ulint format_id;
dulint file_format_id;
ib_id_t file_format_id;
/* Since this is called during the startup phase it's safe to
read the value without a covering mutex. */
@ -1115,16 +1106,15 @@ trx_sys_file_format_max_read(void)
mtr_commit(&mtr);
format_id = file_format_id.low - TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
file_format_id -= TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
if (file_format_id.high != TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH
|| format_id >= FILE_FORMAT_NAME_N) {
if (file_format_id >= FILE_FORMAT_NAME_N) {
/* Either it has never been tagged, or garbage in it. */
return(ULINT_UNDEFINED);
}
return(format_id);
return((ulint) file_format_id);
}
/*****************************************************************//**
@ -1416,7 +1406,7 @@ trx_sys_read_file_format_id(
byte buf[UNIV_PAGE_SIZE * 2];
page_t* page = ut_align(buf, UNIV_PAGE_SIZE);
const byte* ptr;
dulint file_format_id;
ib_id_t file_format_id;
*format_id = ULINT_UNDEFINED;
@ -1465,17 +1455,16 @@ trx_sys_read_file_format_id(
/* get the file format from the page */
ptr = page + TRX_SYS_FILE_FORMAT_TAG;
file_format_id = mach_read_from_8(ptr);
file_format_id -= TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
*format_id = file_format_id.low - TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
if (file_format_id.high != TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH
|| *format_id >= FILE_FORMAT_NAME_N) {
if (file_format_id >= FILE_FORMAT_NAME_N) {
/* Either it has never been tagged, or garbage in it. */
*format_id = ULINT_UNDEFINED;
return(TRUE);
}
*format_id = (ulint) file_format_id;
return(TRUE);
}

96
storage/innobase/trx/trx0trx.c
View file

@ -109,8 +109,8 @@ trx_create(
trx->isolation_level = TRX_ISO_REPEATABLE_READ;
trx->id = ut_dulint_zero;
trx->no = ut_dulint_max;
trx->id = 0;
trx->no = IB_ULONGLONG_MAX;
trx->support_xa = TRUE;
@ -121,7 +121,7 @@ trx_create(
trx->must_flush_log_later = FALSE;
trx->dict_operation = TRX_DICT_OP_NONE;
trx->table_id = ut_dulint_zero;
trx->table_id = 0;
trx->mysql_thd = NULL;
trx->active_trans = 0;
@ -137,8 +137,8 @@ trx_create(
trx->rseg = NULL;
trx->undo_no = ut_dulint_zero;
trx->last_sql_stat_start.least_undo_no = ut_dulint_zero;
trx->undo_no = 0;
trx->last_sql_stat_start.least_undo_no = 0;
trx->insert_undo = NULL;
trx->update_undo = NULL;
trx->undo_no_arr = NULL;
@ -392,9 +392,9 @@ trx_list_insert_ordered(
trx2 = UT_LIST_GET_FIRST(trx_sys->trx_list);
while (trx2 != NULL) {
if (ut_dulint_cmp(trx->id, trx2->id) >= 0) {
if (trx->id >= trx2->id) {
ut_ad(ut_dulint_cmp(trx->id, trx2->id) == 1);
ut_ad(trx->id > trx2->id);
break;
}
trx2 = UT_LIST_GET_NEXT(trx_list, trx2);
@ -463,7 +463,7 @@ trx_lists_init_at_db_start(void)
TRX_ID_FMT
" was in the"
" XA prepared state.\n",
TRX_ID_PREP_PRINTF(trx->id));
(ullint) trx->id);
if (srv_force_recovery == 0) {
@ -495,9 +495,9 @@ trx_lists_init_at_db_start(void)
trx->conc_state = TRX_ACTIVE;
/* A running transaction always has the number
field inited to ut_dulint_max */
field inited to IB_ULONGLONG_MAX */
trx->no = ut_dulint_max;
trx->no = IB_ULONGLONG_MAX;
}
if (undo->dict_operation) {
@ -507,8 +507,7 @@ trx_lists_init_at_db_start(void)
}
if (!undo->empty) {
trx->undo_no = ut_dulint_add(undo->top_undo_no,
1);
trx->undo_no = undo->top_undo_no + 1;
}
trx_list_insert_ordered(trx);
@ -539,8 +538,7 @@ trx_lists_init_at_db_start(void)
"InnoDB: Transaction "
TRX_ID_FMT " was in the"
" XA prepared state.\n",
TRX_ID_PREP_PRINTF(
trx->id));
(ullint) trx->id);
if (srv_force_recovery == 0) {
@ -571,9 +569,9 @@ trx_lists_init_at_db_start(void)
/* A running transaction always has
the number field inited to
ut_dulint_max */
IB_ULONGLONG_MAX */
trx->no = ut_dulint_max;
trx->no = IB_ULONGLONG_MAX;
}
trx->rseg = rseg;
@ -589,11 +587,9 @@ trx_lists_init_at_db_start(void)
trx->update_undo = undo;
if ((!undo->empty)
&& (ut_dulint_cmp(undo->top_undo_no,
trx->undo_no) >= 0)) {
&& undo->top_undo_no >= trx->undo_no) {
trx->undo_no = ut_dulint_add(undo->top_undo_no,
1);
trx->undo_no = undo->top_undo_no + 1;
}
undo = UT_LIST_GET_NEXT(undo_list, undo);
@ -655,7 +651,7 @@ trx_start_low(
ut_ad(trx->rseg == NULL);
if (trx->is_purge) {
trx->id = ut_dulint_zero;
trx->id = 0;
trx->conc_state = TRX_ACTIVE;
trx->start_time = time(NULL);
@ -673,10 +669,10 @@ trx_start_low(
trx->id = trx_sys_get_new_trx_id();
/* The initial value for trx->no: ut_dulint_max is used in
/* The initial value for trx->no: IB_ULONGLONG_MAX is used in
read_view_open_now: */
trx->no = ut_dulint_max;
trx->no = IB_ULONGLONG_MAX;
trx->rseg = rseg;
@ -941,8 +937,8 @@ trx_commit_off_kernel(
trx->conc_state = TRX_NOT_STARTED;
trx->rseg = NULL;
trx->undo_no = ut_dulint_zero;
trx->last_sql_stat_start.least_undo_no = ut_dulint_zero;
trx->undo_no = 0;
trx->last_sql_stat_start.least_undo_no = 0;
ut_ad(UT_LIST_GET_LEN(trx->wait_thrs) == 0);
ut_ad(UT_LIST_GET_LEN(trx->trx_locks) == 0);
@ -967,8 +963,8 @@ trx_cleanup_at_db_startup(
trx->conc_state = TRX_NOT_STARTED;
trx->rseg = NULL;
trx->undo_no = ut_dulint_zero;
trx->last_sql_stat_start.least_undo_no = ut_dulint_zero;
trx->undo_no = 0;
trx->last_sql_stat_start.least_undo_no = 0;
UT_LIST_REMOVE(trx_list, trx_sys->trx_list, trx);
}
@ -1631,7 +1627,7 @@ trx_mark_sql_stat_end(
ut_a(trx);
if (trx->conc_state == TRX_NOT_STARTED) {
trx->undo_no = ut_dulint_zero;
trx->undo_no = 0;
}
trx->last_sql_stat_start.least_undo_no = trx->undo_no;
@ -1651,7 +1647,7 @@ trx_print(
{
ibool newline;
fprintf(f, "TRANSACTION " TRX_ID_FMT, TRX_ID_PREP_PRINTF(trx->id));
fprintf(f, "TRANSACTION " TRX_ID_FMT, (ullint) trx->id);
switch (trx->conc_state) {
case TRX_NOT_STARTED:
@ -1735,10 +1731,10 @@ trx_print(
fputs(", holds adaptive hash latch", f);
}
if (!ut_dulint_is_zero(trx->undo_no)) {
if (trx->undo_no != 0) {
newline = TRUE;
fprintf(f, ", undo log entries %lu",
(ulong) ut_dulint_get_low(trx->undo_no));
fprintf(f, ", undo log entries %llu",
(ullint) trx->undo_no);
}
if (newline) {
@ -1754,11 +1750,11 @@ trx_print(
Compares the "weight" (or size) of two transactions. Transactions that
have edited non-transactional tables are considered heavier than ones
that have not.
@return <0, 0 or >0; similar to strcmp(3) */
@return TRUE if weight(a) >= weight(b) */
UNIV_INTERN
int
trx_weight_cmp(
/*===========*/
ibool
trx_weight_ge(
/*==========*/
const trx_t* a, /*!< in: the first transaction to be compared */
const trx_t* b) /*!< in: the second transaction to be compared */
{
@ -1769,19 +1765,14 @@ trx_weight_cmp(
not edited non-transactional tables. */
a_notrans_edit = a->mysql_thd != NULL
&& thd_has_edited_nontrans_tables(a->mysql_thd);
&& thd_has_edited_nontrans_tables(a->mysql_thd);
b_notrans_edit = b->mysql_thd != NULL
&& thd_has_edited_nontrans_tables(b->mysql_thd);
&& thd_has_edited_nontrans_tables(b->mysql_thd);
if (a_notrans_edit && !b_notrans_edit) {
if (a_notrans_edit != b_notrans_edit) {
return(1);
}
if (!a_notrans_edit && b_notrans_edit) {
return(-1);
return(a_notrans_edit);
}
/* Either both had edited non-transactional tables or both had
@ -1792,13 +1783,11 @@ trx_weight_cmp(
fprintf(stderr,
"%s TRX_WEIGHT(a): %lld+%lu, TRX_WEIGHT(b): %lld+%lu\n",
__func__,
ut_conv_dulint_to_longlong(a->undo_no),
UT_LIST_GET_LEN(a->trx_locks),
ut_conv_dulint_to_longlong(b->undo_no),
UT_LIST_GET_LEN(b->trx_locks));
a->undo_no, UT_LIST_GET_LEN(a->trx_locks),
b->undo_no, UT_LIST_GET_LEN(b->trx_locks));
#endif
return(ut_dulint_cmp(TRX_WEIGHT(a), TRX_WEIGHT(b)));
return(TRX_WEIGHT(a) >= TRX_WEIGHT(b));
}
/****************************************************************//**
@ -1980,14 +1969,13 @@ trx_recover_for_mysql(
fprintf(stderr,
" InnoDB: Transaction " TRX_ID_FMT " in"
" prepared state after recovery\n",
TRX_ID_PREP_PRINTF(trx->id));
(ullint) trx->id);
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Transaction contains changes"
" to %lu rows\n",
(ulong) ut_conv_dulint_to_longlong(
trx->undo_no));
" to %llu rows\n",
(ullint) trx->undo_no);
count++;

23
storage/innobase/trx/trx0undo.c
View file

@ -515,7 +515,7 @@ trx_undo_header_create_log(
{
mlog_write_initial_log_record(undo_page, MLOG_UNDO_HDR_CREATE, mtr);
mlog_catenate_dulint_compressed(mtr, trx_id);
mlog_catenate_ull_compressed(mtr, trx_id);
}
#else /* !UNIV_HOTBACKUP */
# define trx_undo_header_create_log(undo_page,trx_id,mtr) ((void) 0)
@ -687,7 +687,7 @@ trx_undo_insert_header_reuse_log(
{
mlog_write_initial_log_record(undo_page, MLOG_UNDO_HDR_REUSE, mtr);
mlog_catenate_dulint_compressed(mtr, trx_id);
mlog_catenate_ull_compressed(mtr, trx_id);
}
#else /* !UNIV_HOTBACKUP */
# define trx_undo_insert_header_reuse_log(undo_page,trx_id,mtr) ((void) 0)
@ -708,7 +708,7 @@ trx_undo_parse_page_header(
{
trx_id_t trx_id;
ptr = mach_dulint_parse_compressed(ptr, end_ptr, &trx_id);
ptr = mach_ull_parse_compressed(ptr, end_ptr, &trx_id);
if (ptr == NULL) {
@ -1098,8 +1098,7 @@ trx_undo_truncate_end(
break;
}
if (ut_dulint_cmp(trx_undo_rec_get_undo_no(rec), limit)
>= 0) {
if (trx_undo_rec_get_undo_no(rec) >= limit) {
/* Truncate at least this record off, maybe
more */
trunc_here = rec;
@ -1152,7 +1151,7 @@ trx_undo_truncate_start(
ut_ad(mutex_own(&(rseg->mutex)));
if (ut_dulint_is_zero(limit)) {
if (!limit) {
return;
}
@ -1174,7 +1173,7 @@ loop:
last_rec = trx_undo_page_get_last_rec(undo_page, hdr_page_no,
hdr_offset);
if (ut_dulint_cmp(trx_undo_rec_get_undo_no(last_rec), limit) >= 0) {
if (trx_undo_rec_get_undo_no(last_rec) >= limit) {
mtr_commit(&mtr);
@ -1296,7 +1295,7 @@ trx_undo_mem_create_at_db_start(
undo_header = undo_page + offset;
trx_id = mtr_read_dulint(undo_header + TRX_UNDO_TRX_ID, mtr);
trx_id = mach_read_from_8(undo_header + TRX_UNDO_TRX_ID);
xid_exists = mtr_read_ulint(undo_header + TRX_UNDO_XID_EXISTS,
MLOG_1BYTE, mtr);
@ -1320,7 +1319,7 @@ trx_undo_mem_create_at_db_start(
undo->dict_operation = mtr_read_ulint(
undo_header + TRX_UNDO_DICT_TRANS, MLOG_1BYTE, mtr);
undo->table_id = mtr_read_dulint(undo_header + TRX_UNDO_TABLE_ID, mtr);
undo->table_id = mach_read_from_8(undo_header + TRX_UNDO_TABLE_ID);
undo->state = state;
undo->size = flst_get_len(seg_header + TRX_UNDO_PAGE_LIST, mtr);
@ -1709,7 +1708,7 @@ trx_undo_mark_as_dict_operation(
ut_error;
case TRX_DICT_OP_INDEX:
/* Do not discard the table on recovery. */
undo->table_id = ut_dulint_zero;
undo->table_id = 0;
break;
case TRX_DICT_OP_TABLE:
undo->table_id = trx->table_id;
@ -1720,8 +1719,8 @@ trx_undo_mark_as_dict_operation(
+ TRX_UNDO_DICT_TRANS,
TRUE, MLOG_1BYTE, mtr);
mlog_write_dulint(hdr_page + undo->hdr_offset + TRX_UNDO_TABLE_ID,
undo->table_id, mtr);
mlog_write_ull(hdr_page + undo->hdr_offset + TRX_UNDO_TABLE_ID,
undo->table_id, mtr);
undo->dict_operation = TRUE;
}

25
storage/innobase/ut/ut0byte.c
View file

@ -28,28 +28,3 @@ Created 5/11/1994 Heikki Tuuri
#ifdef UNIV_NONINL
#include "ut0byte.ic"
#endif
/** Zero value for a dulint */
UNIV_INTERN const dulint ut_dulint_zero = {0, 0};
/** Maximum value for a dulint */
UNIV_INTERN const dulint ut_dulint_max = {0xFFFFFFFFUL, 0xFFFFFFFFUL};
#ifdef notdefined /* unused code */
#include "ut0sort.h"
/************************************************************//**
Sort function for dulint arrays. */
UNIV_INTERN
void
ut_dulint_sort(
/*===========*/
dulint* arr, /*!< in/out: array to be sorted */
dulint* aux_arr,/*!< in/out: auxiliary array (same size as arr) */
ulint low, /*!< in: low bound of sort interval, inclusive */
ulint high) /*!< in: high bound of sort interval, noninclusive */
{
UT_SORT_FUNCTION_BODY(ut_dulint_sort, arr, aux_arr, low, high,
ut_dulint_cmp);
}
#endif /* notdefined */