diff options
31 files changed, 520 insertions, 273 deletions
diff --git a/BUILD/SETUP.sh b/BUILD/SETUP.sh index 34bdfecf995..07c308b9a26 100755 --- a/BUILD/SETUP.sh +++ b/BUILD/SETUP.sh @@ -145,7 +145,7 @@ base_configs="--prefix=$prefix --enable-assembler " base_configs="$base_configs --with-extra-charsets=complex " base_configs="$base_configs --enable-thread-safe-client " base_configs="$base_configs --with-big-tables" -base_configs="$base_configs --with-plugin-maria" +base_configs="$base_configs --with-plugin-maria --with-maria-tmp-tables" if test -d "$path/../cmd-line-utils/readline" then diff --git a/include/maria.h b/include/maria.h index 00c01075d05..f2b0fc6516a 100644 --- a/include/maria.h +++ b/include/maria.h @@ -338,7 +338,7 @@ typedef struct st_maria_sort_info SORT_KEY_BLOCKS *key_block, *key_block_end; SORT_FT_BUF *ft_buf; my_off_t filelength, dupp, buff_length; - ulonglong page; + pgcache_page_no_t page; ha_rows max_records; uint current_key, total_keys; uint got_error, threads_running; @@ -392,17 +392,17 @@ typedef struct st_maria_sort_param /* functions in maria_check */ void maria_chk_init(HA_CHECK *param); int maria_chk_status(HA_CHECK *param, MARIA_HA *info); -int maria_chk_del(HA_CHECK *param, MARIA_HA *info, uint test_flag); +int maria_chk_del(HA_CHECK *param, MARIA_HA *info, ulonglong test_flag); int maria_chk_size(HA_CHECK *param, MARIA_HA *info); int maria_chk_key(HA_CHECK *param, MARIA_HA *info); -int maria_chk_data_link(HA_CHECK *param, MARIA_HA *info, int extend); -int maria_repair(HA_CHECK *param, MARIA_HA *info, char * name, uint rep_quick); +int maria_chk_data_link(HA_CHECK *param, MARIA_HA *info, my_bool extend); +int maria_repair(HA_CHECK *param, MARIA_HA *info, char * name, my_bool); int maria_sort_index(HA_CHECK *param, MARIA_HA *info, char * name); int maria_zerofill(HA_CHECK *param, MARIA_HA *info, const char *name); int maria_repair_by_sort(HA_CHECK *param, MARIA_HA *info, - const char *name, uint rep_quick); + const char *name, my_bool rep_quick); int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info, - const char *name, uint rep_quick); + const char *name, my_bool rep_quick); int maria_change_to_newfile(const char *filename, const char *old_ext, const char *new_ext, myf myflags); void maria_lock_memory(HA_CHECK *param); diff --git a/include/my_base.h b/include/my_base.h index fdf8d248879..04de6f55f44 100644 --- a/include/my_base.h +++ b/include/my_base.h @@ -235,7 +235,10 @@ enum ha_base_keytype { #define HA_MAX_KEYTYPE 31 /* Must be log2-1 */ - /* These flags kan be OR:ed to key-flag */ +/* + These flags kan be OR:ed to key-flag + Note that these can only be up to 16 bits! +*/ #define HA_NOSAME 1 /* Set if not dupplicated records */ #define HA_PACK_KEY 2 /* Pack string key to previous key */ diff --git a/mysql-test/r/maria-big.result b/mysql-test/r/maria-big.result index 8f7bbc74123..b45816367a5 100644 --- a/mysql-test/r/maria-big.result +++ b/mysql-test/r/maria-big.result @@ -61,3 +61,165 @@ count(*) affected rows: 1 drop table t1, t2; affected rows: 0 +set @@max_allowed_packet=400000000; +affected rows: 0 +create table t1 (a int, b longtext); +affected rows: 0 +insert into t1 values (1,"123456789012345678901234567890"),(2,"09876543210987654321"); +affected rows: 2 +info: Records: 2 Duplicates: 0 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=CONCAT(b,b); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +select a,length(b) from t1; +a length(b) +1 251658240 +2 167772160 +affected rows: 2 +check table t1; +Table Op Msg_type Msg_text +test.t1 check status OK +affected rows: 1 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +update t1 set b=mid(b,1,length(b)/2); +affected rows: 2 +info: Rows matched: 2 Changed: 2 Warnings: 0 +select a,length(b) from t1; +a length(b) +1 60 +2 40 +affected rows: 2 +check table t1; +Table Op Msg_type Msg_text +test.t1 check status OK +affected rows: 1 +drop table t1; +affected rows: 0 diff --git a/mysql-test/t/maria-big.test b/mysql-test/t/maria-big.test index 168bf800ea6..fd687bf925f 100644 --- a/mysql-test/t/maria-big.test +++ b/mysql-test/t/maria-big.test @@ -6,6 +6,12 @@ set global maria_log_file_size=4294967295; disable_warnings; drop table if exists t1, t2; enable_warnings; + +# +# Test generating data with insert select +# This test case failed once a long time ago +# + create table t1(a char(3)); insert into t1 values("abc"); insert into t1 select "def" from t1; @@ -25,4 +31,30 @@ create table t2 select * from t1; select count(*) from t1; select count(*) from t2; drop table t1, t2; -disable_info; + +# +# Test creating a really big blob (up to 16M) +# + +set @@max_allowed_packet=400000000; +create table t1 (a int, b longtext); +insert into t1 values (1,"123456789012345678901234567890"),(2,"09876543210987654321"); + +let $loop=23; +while ($loop) +{ + update t1 set b=CONCAT(b,b); + dec $loop; +} +select a,length(b) from t1; +check table t1; +let $loop=22; +while ($loop) +{ + update t1 set b=mid(b,1,length(b)/2); + dec $loop; +} +select a,length(b) from t1; +check table t1; + +drop table t1; diff --git a/sql/mysqld.cc b/sql/mysqld.cc index 18f3b8cf55a..c78e6c40211 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -3762,6 +3762,13 @@ server."); global_system_variables.table_plugin= plugin; } } +#if defined(WITH_MARIA_STORAGE_ENGINE) && defined(USE_MARIA_FOR_TMP_TABLES) + if (!ha_storage_engine_is_enabled(maria_hton)) + { + sql_print_error("Maria engine is not enabled or did not start. The Maria engine must be enabled to continue as mysqld was configured with --with-maria-tmp-tables"); + unireg_abort(1); + } +#endif tc_log= (total_ha_2pc > 1 ? (opt_bin_log ? (TC_LOG *) &mysql_bin_log : diff --git a/sql/sql_class.h b/sql/sql_class.h index 3689bb343d5..2342f7326a2 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -2371,7 +2371,7 @@ public: }; -#ifdef WITH_MARIA_STORAGE_ENGINE +#if defined(WITH_MARIA_STORAGE_ENGINE) && defined(USE_MARIA_FOR_TMP_TABLES) #include <maria.h> #define ENGINE_COLUMNDEF MARIA_COLUMNDEF #else diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 3267df95b63..d8b06f978bd 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -35,7 +35,7 @@ #include <my_bit.h> #include <hash.h> #include <ft_global.h> -#ifdef WITH_MARIA_STORAGE_ENGINE +#if defined(WITH_MARIA_STORAGE_ENGINE) && defined(USE_MARIA_FOR_TMP_TABLES) #include "../storage/maria/ha_maria.h" #define TMP_ENGINE_HTON maria_hton #else diff --git a/storage/maria/ha_maria.cc b/storage/maria/ha_maria.cc index 4e7d2b04471..0a1c7bfe078 100644 --- a/storage/maria/ha_maria.cc +++ b/storage/maria/ha_maria.cc @@ -302,7 +302,8 @@ static int table2maria(TABLE *table_arg, data_file_type row_type, pos= table_arg->key_info; for (i= 0; i < share->keys; i++, pos++) { - keydef[i].flag= (pos->flags & (HA_NOSAME | HA_FULLTEXT | HA_SPATIAL)); + keydef[i].flag= (uint16) (pos->flags & (HA_NOSAME | HA_FULLTEXT | + HA_SPATIAL)); keydef[i].key_alg= pos->algorithm == HA_KEY_ALG_UNDEF ? (pos->flags & HA_SPATIAL ? HA_KEY_ALG_RTREE : HA_KEY_ALG_BTREE) : pos->algorithm; @@ -927,7 +928,7 @@ int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt) error= maria_chk_status(¶m, file); // Not fatal error= maria_chk_size(¶m, file); if (!error) - error |= maria_chk_del(¶m, file, param.testflag); + error|= maria_chk_del(¶m, file, param.testflag); if (!error) error= maria_chk_key(¶m, file); if (!error) @@ -937,13 +938,14 @@ int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt) (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) || (param.testflag & (T_EXTEND | T_MEDIUM)))) || maria_is_crashed(file)) { - uint old_testflag= param.testflag; + ulonglong old_testflag= param.testflag; param.testflag |= T_MEDIUM; if (!(error= init_io_cache(¶m.read_cache, file->dfile.file, my_default_record_cache_size, READ_CACHE, share->pack.header_length, 1, MYF(MY_WME)))) { - error= maria_chk_data_link(¶m, file, param.testflag & T_EXTEND); + error= maria_chk_data_link(¶m, file, + test(param.testflag & T_EXTEND)); end_io_cache(&(param.read_cache)); } param.testflag= old_testflag; @@ -961,8 +963,9 @@ int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt) share->state.changed &= ~(STATE_CHANGED | STATE_CRASHED | STATE_CRASHED_ON_REPAIR); if (!(table->db_stat & HA_READ_ONLY)) - error= maria_update_state_info(¶m, file, UPDATE_TIME | UPDATE_OPEN_COUNT | - UPDATE_STAT); + error= maria_update_state_info(¶m, file, + UPDATE_TIME | UPDATE_OPEN_COUNT | + UPDATE_STAT); pthread_mutex_unlock(&share->intern_lock); info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE | HA_STATUS_CONST); @@ -1226,7 +1229,7 @@ int ha_maria::optimize(THD * thd, HA_CHECK_OPT *check_opt) int ha_maria::repair(THD *thd, HA_CHECK ¶m, bool do_optimize) { int error= 0; - uint local_testflag= param.testflag; + ulonglong local_testflag= param.testflag; bool optimize_done= !do_optimize, statistics_done= 0; const char *old_proc_info= thd->proc_info; char fixed_name[FN_REFLEN]; @@ -1278,7 +1281,7 @@ int ha_maria::repair(THD *thd, HA_CHECK ¶m, bool do_optimize) ulonglong key_map= ((local_testflag & T_CREATE_MISSING_KEYS) ? maria_get_mask_all_keys_active(share->base.keys) : share->state.key_map); - uint save_testflag= param.testflag; + ulonglong save_testflag= param.testflag; if (maria_test_if_sort_rep(file, file->state->records, key_map, 0) && (local_testflag & T_REP_BY_SORT)) { @@ -1295,7 +1298,7 @@ int ha_maria::repair(THD *thd, HA_CHECK ¶m, bool do_optimize) thd_proc_info(thd, buf); param.testflag|= T_REP_PARALLEL; error= maria_repair_parallel(¶m, file, fixed_name, - param.testflag & T_QUICK); + test(param.testflag & T_QUICK)); /* to reset proc_info, as it was pointing to local buffer */ thd_proc_info(thd, "Repair done"); } @@ -1304,14 +1307,15 @@ int ha_maria::repair(THD *thd, HA_CHECK ¶m, bool do_optimize) thd_proc_info(thd, "Repair by sorting"); param.testflag|= T_REP_BY_SORT; error= maria_repair_by_sort(¶m, file, fixed_name, - param.testflag & T_QUICK); + test(param.testflag & T_QUICK)); } } else { thd_proc_info(thd, "Repair with keycache"); param.testflag &= ~(T_REP_BY_SORT | T_REP_PARALLEL); - error= maria_repair(¶m, file, fixed_name, param.testflag & T_QUICK); + error= maria_repair(¶m, file, fixed_name, + test(param.testflag & T_QUICK)); /** @todo RECOVERY BUG we do things with the index file (maria_sort_index() after the above which already has logged the @@ -2551,69 +2555,68 @@ bool maria_show_status(handlerton *hton, enum ha_stat_type stat) { char engine_name[]= "maria"; - switch (stat) - { + switch (stat) { case HA_ENGINE_LOGS: + { + TRANSLOG_ADDRESS horizon= translog_get_horizon(); + uint32 last_file= LSN_FILE_NO(horizon); + uint32 first_needed= translog_get_first_needed_file(); + uint32 first_file= translog_get_first_file(horizon); + uint32 i; + const char unknown[]= "unknown"; + const char needed[]= "in use"; + const char unneeded[]= "free"; + char path[FN_REFLEN]; + + if (first_file == 0) + { + const char error[]= "error"; + print(thd, engine_name, sizeof(engine_name), + STRING_WITH_LEN(""), error, sizeof(error)); + break; + } + + for (i= first_file; i <= last_file; i++) { - TRANSLOG_ADDRESS horizon= translog_get_horizon(); - uint32 last_file= LSN_FILE_NO(horizon); - uint32 first_needed= translog_get_first_needed_file(); - uint32 first_file= translog_get_first_file(horizon); - uint32 i; - const char unknown[]= "unknown"; - const char needed[]= "in use"; - const char unneeded[]= "free"; - char path[FN_REFLEN]; - - if (first_file == 0) + char *file; + const char *status; + uint length, status_len; + MY_STAT stat_buff, *stat; + const char error[]= "can't stat"; + char object[SHOW_MSG_LEN]; + file= translog_filename_by_fileno(i, path); + if (!(stat= my_stat(file, &stat_buff, MYF(MY_WME)))) { - const char error[]= "error"; - print(thd, engine_name, sizeof(engine_name), - STRING_WITH_LEN(""), error, sizeof(error)); - break; + status= error; + status_len= sizeof(error); + length= snprintf(object, SHOW_MSG_LEN, "Size unknown ; %s", file); } - - for (i= first_file; i <= last_file; i++) + else { - char *file; - const char *status; - uint length, status_len; - MY_STAT stat_buff, *stat; - const char error[]= "can't stat"; - char object[SHOW_MSG_LEN]; - file= translog_filename_by_fileno(i, path); - if (!(stat= my_stat(file, &stat_buff, MYF(MY_WME)))) + if (first_needed == 0) { - status= error; - status_len= sizeof(error); - length= snprintf(object, SHOW_MSG_LEN, "Size unknown ; %s", file); + status= unknown; + status_len= sizeof(unknown); + } + else if (i < first_needed) + { + status= unneeded; + status_len= sizeof(unneeded); } else { - if (first_needed == 0) - { - status= unknown; - status_len= sizeof(unknown); - } - else if (i < first_needed) - { - status= unneeded; - status_len= sizeof(unneeded); - } - else - { - status= needed; - status_len= sizeof(needed); - } - length= snprintf(object, SHOW_MSG_LEN, "Size %12lu ; %s", - (ulong) stat->st_size, file); + status= needed; + status_len= sizeof(needed); } - - print(thd, engine_name, sizeof(engine_name), - object, length, status, status_len); + length= snprintf(object, SHOW_MSG_LEN, "Size %12lu ; %s", + (ulong) stat->st_size, file); } - break; + + print(thd, engine_name, sizeof(engine_name), + object, length, status, status_len); } + break; + } case HA_ENGINE_STATUS: case HA_ENGINE_MUTEX: default: @@ -2641,7 +2644,7 @@ static int ha_maria_init(void *p) maria_tmpdir= &mysql_tmpdir_list; /* For REDO */ res= maria_init() || ma_control_file_create_or_open() || !init_pagecache(maria_pagecache, - pagecache_buffer_size, pagecache_division_limit, + (size_t) pagecache_buffer_size, pagecache_division_limit, pagecache_age_threshold, MARIA_KEY_BLOCK_LENGTH, 0) || !init_pagecache(maria_log_pagecache, TRANSLOG_PAGECACHE_SIZE, 0, 0, diff --git a/storage/maria/ma_bitmap.c b/storage/maria/ma_bitmap.c index e35658f55f1..5e9fa0ca08e 100644 --- a/storage/maria/ma_bitmap.c +++ b/storage/maria/ma_bitmap.c @@ -132,7 +132,7 @@ static my_bool _ma_read_bitmap_page(MARIA_SHARE *share, MARIA_FILE_BITMAP *bitmap, - ulonglong page); + pgcache_page_no_t page); /* Write bitmap page to key cache */ @@ -237,7 +237,7 @@ my_bool _ma_bitmap_init(MARIA_SHARE *share, File file) _ma_bitmap_reset_cache(share); - if (share->state.first_bitmap_with_space == ~(ulonglong) 0) + if (share->state.first_bitmap_with_space == ~(pgcache_page_no_t) 0) { /* Start scanning for free space from start of file */ share->state.first_bitmap_with_space = 0; @@ -678,7 +678,7 @@ static void _ma_print_bitmap_changes(MARIA_FILE_BITMAP *bitmap) /* Print content of bitmap for debugging */ void _ma_print_bitmap(MARIA_FILE_BITMAP *bitmap, uchar *data, - ulonglong page) + pgcache_page_no_t page) { uchar *pos, *end; char llbuff[22]; @@ -744,7 +744,7 @@ void _ma_print_bitmap(MARIA_FILE_BITMAP *bitmap, uchar *data, static my_bool _ma_read_bitmap_page(MARIA_SHARE *share, MARIA_FILE_BITMAP *bitmap, - ulonglong page) + pgcache_page_no_t page) { my_off_t end_of_page= (page + 1) * bitmap->block_size; my_bool res; @@ -832,7 +832,7 @@ static my_bool _ma_read_bitmap_page(MARIA_SHARE *share, static my_bool _ma_change_bitmap_page(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page) + pgcache_page_no_t page) { DBUG_ENTER("_ma_change_bitmap_page"); @@ -867,7 +867,7 @@ static my_bool _ma_change_bitmap_page(MARIA_HA *info, static my_bool move_to_next_bitmap(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap) { - ulonglong page= bitmap->page; + pgcache_page_no_t page= bitmap->page; MARIA_STATE_INFO *state= &info->s->state; DBUG_ENTER("move_to_next_bitmap"); @@ -988,7 +988,7 @@ static my_bool allocate_head(MARIA_FILE_BITMAP *bitmap, uint size, continue; for (i= 0; i < 16 ; i++, bits >>= 3) { - uint pattern= bits & 7; + uint pattern= (uint) (bits & 7); if (pattern <= min_bits) { /* There is enough space here */ @@ -1074,7 +1074,7 @@ static my_bool allocate_tail(MARIA_FILE_BITMAP *bitmap, uint size, continue; for (i= 0; i < 16; i++, bits >>= 3) { - uint pattern= bits & 7; + uint pattern= (uint) (bits & 7); if (pattern <= min_bits && (!pattern || pattern >= 5)) { if ((int) pattern > (int) best_bits) @@ -1538,7 +1538,7 @@ static my_bool allocate_blobs(MARIA_HA *info, MARIA_ROW *row) This is used on update where we are updating an existing head page */ -static void use_head(MARIA_HA *info, ulonglong page, uint size, +static void use_head(MARIA_HA *info, pgcache_page_no_t page, uint size, uint block_position) { MARIA_FILE_BITMAP *bitmap= &info->s->bitmap; @@ -1817,7 +1817,7 @@ abort: */ my_bool _ma_bitmap_find_new_place(MARIA_HA *info, MARIA_ROW *row, - ulonglong page, uint free_size, + pgcache_page_no_t page, uint free_size, MARIA_BITMAP_BLOCKS *blocks) { MARIA_SHARE *share= info->s; @@ -1833,12 +1833,6 @@ my_bool _ma_bitmap_find_new_place(MARIA_HA *info, MARIA_ROW *row, info->bitmap_blocks.elements= ELEMENTS_RESERVED_FOR_MAIN_PART; pthread_mutex_lock(&share->bitmap.bitmap_lock); - bitmap_page= page / share->bitmap.pages_covered; - bitmap_page*= share->bitmap.pages_covered; - - if (share->bitmap.page != bitmap_page && - _ma_change_bitmap_page(info, &share->bitmap, bitmap_page)) - goto abort; /* First allocate all blobs (so that we can find out the needed size for @@ -1847,6 +1841,14 @@ my_bool _ma_bitmap_find_new_place(MARIA_HA *info, MARIA_ROW *row, if (row->blob_length && allocate_blobs(info, row)) goto abort; + /* Switch bitmap to current head page */ + bitmap_page= page / share->bitmap.pages_covered; + bitmap_page*= share->bitmap.pages_covered; + + if (share->bitmap.page != bitmap_page && + _ma_change_bitmap_page(info, &share->bitmap, bitmap_page)) + goto abort; + extents_length= row->extents_count * ROW_EXTENT_SIZE; if ((head_length= (row->head_length + extents_length + 3)) <= free_size) { @@ -1909,9 +1911,9 @@ abort: */ static my_bool set_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page, uint fill_pattern) + pgcache_page_no_t page, uint fill_pattern) { - ulonglong bitmap_page; + pgcache_page_no_t bitmap_page; uint offset_page, offset, tmp, org_tmp; uchar *data; DBUG_ENTER("set_page_bits"); @@ -1922,7 +1924,7 @@ static my_bool set_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, DBUG_RETURN(1); /* Find page number from start of bitmap */ - offset_page= page - bitmap->page - 1; + offset_page= (uint) (page - bitmap->page - 1); /* Mark place used by reading/writing 2 bytes at a time to handle bitmaps in overlapping bytes @@ -1967,9 +1969,9 @@ static my_bool set_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, */ uint _ma_bitmap_get_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page) + pgcache_page_no_t page) { - ulonglong bitmap_page; + pgcache_page_no_t bitmap_page; uint offset_page, offset, tmp; uchar *data; DBUG_ENTER("_ma_bitmap_get_page_bits"); @@ -1980,7 +1982,7 @@ uint _ma_bitmap_get_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, DBUG_RETURN(~ (uint) 0); /* Find page number from start of bitmap */ - offset_page= page - bitmap->page - 1; + offset_page= (uint) (page - bitmap->page - 1); /* Mark place used by reading/writing 2 bytes at a time to handle bitmaps in overlapping bytes @@ -2014,7 +2016,8 @@ uint _ma_bitmap_get_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page, uint page_count) + pgcache_page_no_t page, + uint page_count) { ulonglong bitmap_page; uint offset, bit_start, bit_count, tmp; @@ -2031,10 +2034,10 @@ my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info, DBUG_RETURN(1); /* Find page number from start of bitmap */ - page= page - bitmap->page - 1; + offset= (uint) (page - bitmap->page - 1); /* Clear bits from 'page * 3' -> '(page + page_count) * 3' */ - bit_start= page * 3; + bit_start= offset * 3; bit_count= page_count * 3; data= bitmap->map + bit_start / 8; @@ -2092,7 +2095,7 @@ my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info, my_bool _ma_bitmap_set_full_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page, uint page_count) + pgcache_page_no_t page, uint page_count) { ulonglong bitmap_page; uint offset, bit_start, bit_count, tmp; @@ -2107,10 +2110,10 @@ my_bool _ma_bitmap_set_full_page_bits(MARIA_HA *info, DBUG_RETURN(1); /* Find page number from start of bitmap */ - page= page - bitmap->page - 1; + offset= (uint) (page - bitmap->page - 1); /* Set bits from 'page * 3' -> '(page + page_count) * 3' */ - bit_start= page * 3; + bit_start= offset * 3; bit_count= page_count * 3; data= bitmap->map + bit_start / 8; @@ -2394,7 +2397,7 @@ my_bool _ma_bitmap_free_full_pages(MARIA_HA *info, const uchar *extents, pthread_mutex_lock(&bitmap->bitmap_lock); for (; count--; extents+= ROW_EXTENT_SIZE) { - ulonglong page= uint5korr(extents); + pgcache_page_no_t page= uint5korr(extents); uint page_count= (uint2korr(extents + ROW_EXTENT_PAGE_SIZE) & ~START_EXTENT_BIT); if (!(page_count & TAIL_BIT)) @@ -2430,7 +2433,7 @@ my_bool _ma_bitmap_free_full_pages(MARIA_HA *info, const uchar *extents, 1 error */ -my_bool _ma_bitmap_set(MARIA_HA *info, ulonglong page, my_bool head, +my_bool _ma_bitmap_set(MARIA_HA *info, pgcache_page_no_t page, my_bool head, uint empty_space) { MARIA_FILE_BITMAP *bitmap= &info->s->bitmap; @@ -2469,7 +2472,7 @@ my_bool _ma_bitmap_set(MARIA_HA *info, ulonglong page, my_bool head, */ my_bool _ma_check_bitmap_data(MARIA_HA *info, - enum en_page_type page_type, ulonglong page, + enum en_page_type page_type, pgcache_page_no_t page, uint empty_space, uint *bitmap_pattern) { uint bits; @@ -2517,7 +2520,7 @@ my_bool _ma_check_bitmap_data(MARIA_HA *info, my_bool _ma_check_if_right_bitmap_type(MARIA_HA *info, enum en_page_type page_type, - ulonglong page, + pgcache_page_no_t page, uint *bitmap_pattern) { if ((*bitmap_pattern= _ma_bitmap_get_page_bits(info, &info->s->bitmap, diff --git a/storage/maria/ma_blockrec.c b/storage/maria/ma_blockrec.c index a13db94534c..5e54ca00921 100644 --- a/storage/maria/ma_blockrec.c +++ b/storage/maria/ma_blockrec.c @@ -290,7 +290,7 @@ typedef struct st_maria_extent_cursor /* Position to all tails in the row. Updated when reading a row */ MARIA_RECORD_POS *tail_positions; /* Current page */ - ulonglong page; + pgcache_page_no_t page; /* How many pages in the page region */ uint page_count; /* What kind of lock to use for tail pages */ @@ -332,7 +332,7 @@ typedef struct st_maria_extent_cursor static my_bool delete_tails(MARIA_HA *info, MARIA_RECORD_POS *tails); static my_bool delete_head_or_tail(MARIA_HA *info, - ulonglong page, uint record_number, + pgcache_page_no_t page, uint record_number, my_bool head, my_bool from_update); #ifndef DBUG_OFF static void _ma_print_directory(uchar *buff, uint block_size); @@ -1870,7 +1870,7 @@ static my_bool write_full_pages(MARIA_HA *info, MARIA_BITMAP_BLOCK *block, uchar *data, ulong length) { - my_off_t page; + pgcache_page_no_t page; MARIA_SHARE *share= info->s; uint block_size= share->block_size; uint data_size= FULL_PAGE_SIZE(block_size); @@ -1993,7 +1993,7 @@ static uchar *store_page_range(uchar *to, MARIA_BITMAP_BLOCK *block, ranges= 0; do { - ulonglong page; + pgcache_page_no_t page; page= block->page; page_count= block->page_count; block++; @@ -2097,7 +2097,7 @@ static void store_extent_info(uchar *to, static my_bool extent_to_bitmap_blocks(MARIA_HA *info, MARIA_BITMAP_BLOCKS *blocks, - ulonglong head_page, + pgcache_page_no_t head_page, uint extent_count, const uchar *extent_info) { @@ -2262,7 +2262,8 @@ static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row) 1 error */ -static my_bool free_full_page_range(MARIA_HA *info, ulonglong page, uint count) +static my_bool free_full_page_range(MARIA_HA *info, pgcache_page_no_t page, + uint count) { my_bool res= 0; MARIA_SHARE *share= info->s; @@ -3355,7 +3356,7 @@ my_bool _ma_write_abort_block_record(MARIA_HA *info) if (_ma_write_clr(info, info->cur_row.orig_undo_lsn, LOGREC_UNDO_ROW_INSERT, share->calc_checksum != 0, - -info->cur_row.checksum, + (ha_checksum) 0 - info->cur_row.checksum, &lsn, (void*) 0)) res= 1; } @@ -3387,7 +3388,7 @@ static my_bool _ma_update_block_record2(MARIA_HA *info, uint rownr, org_empty_size, head_length; uint block_size= info->s->block_size; uchar *dir; - ulonglong page; + pgcache_page_no_t page; struct st_row_pos_info row_pos; my_bool res; ha_checksum old_checksum; @@ -3523,7 +3524,7 @@ err: */ static my_bool _ma_update_at_original_place(MARIA_HA *info, - ulonglong page, + pgcache_page_no_t page, uint rownr, uint length_on_head_page, uint extent_count, @@ -3779,7 +3780,7 @@ static int delete_dir_entry(uchar *buff, uint block_size, uint record_number, */ static my_bool delete_head_or_tail(MARIA_HA *info, - ulonglong page, uint record_number, + pgcache_page_no_t page, uint record_number, my_bool head, my_bool from_update) { MARIA_SHARE *share= info->s; @@ -3915,7 +3916,7 @@ static my_bool delete_tails(MARIA_HA *info, MARIA_RECORD_POS *tails) my_bool _ma_delete_block_record(MARIA_HA *info, const uchar *record) { - ulonglong page; + pgcache_page_no_t page; uint record_number; MARIA_SHARE *share= info->s; LSN lsn= LSN_IMPOSSIBLE; @@ -3959,7 +3960,7 @@ my_bool _ma_delete_block_record(MARIA_HA *info, const uchar *record) info->log_row_parts[TRANSLOG_INTERNAL_PARTS].length= sizeof(log_data) - HA_CHECKSUM_STORE_SIZE; store_checksum_in_rec(share, checksum_delta, - - info->cur_row.checksum, log_pos, + (ha_checksum) 0 - info->cur_row.checksum, log_pos, info->log_row_parts[TRANSLOG_INTERNAL_PARTS + 0].length); info->log_row_parts[TRANSLOG_INTERNAL_PARTS+1].str= @@ -4673,7 +4674,7 @@ static my_bool read_row_extent_info(MARIA_HA *info, uchar *buff, extents < end; extents+= ROW_EXTENT_SIZE) { - ulonglong page= uint5korr(extents); + pgcache_page_no_t page= uint5korr(extents); uint page_count= uint2korr(extents + ROW_EXTENT_PAGE_SIZE); if (page_count & TAIL_BIT) *(tail_pos++)= ma_recordpos(page, (page_count & ~ (TAIL_BIT | @@ -4799,7 +4800,7 @@ my_bool _ma_scan_init_block_record(MARIA_HA *info) /* Set scan variables to get _ma_scan_block() to start with reading bitmap */ info->scan.number_of_rows= 0; info->scan.bitmap_pos= info->scan.bitmap_end; - info->scan.bitmap_page= (ulong) - (long) share->bitmap.pages_covered; + info->scan.bitmap_page= (pgcache_page_no_t) 0 - share->bitmap.pages_covered; /* We have to flush bitmap as we will read the bitmap from the page cache while scanning rows @@ -4980,7 +4981,7 @@ restart_bitmap_scan: { while (likely(bits)) { - uint pattern= bits & 7; + uint pattern= (uint) (bits & 7); bits >>= 3; bit_pos++; if (pattern > 0 && pattern <= 4) @@ -5756,7 +5757,7 @@ uint _ma_apply_redo_insert_row_head_or_tail(MARIA_HA *info, LSN lsn, size_t data_length) { MARIA_SHARE *share= info->s; - ulonglong page; + pgcache_page_no_t page; uint rownr, empty_space; uint block_size= share->block_size; uint rec_offset; @@ -5954,7 +5955,7 @@ uint _ma_apply_redo_purge_row_head_or_tail(MARIA_HA *info, LSN lsn, const uchar *header) { MARIA_SHARE *share= info->s; - ulonglong page; + pgcache_page_no_t page; uint rownr, empty_space; uint block_size= share->block_size; uchar *buff= info->keyread_buff; @@ -6062,7 +6063,7 @@ uint _ma_apply_redo_free_blocks(MARIA_HA *info, { my_bool res; uint page_range; - ulonglong page, start_page; + pgcache_page_no_t page, start_page; start_page= page= page_korr(header); header+= PAGE_STORE_SIZE; @@ -6108,7 +6109,7 @@ uint _ma_apply_redo_free_head_or_tail(MARIA_HA *info, LSN lsn, { MARIA_SHARE *share= info->s; uchar *buff; - ulonglong page; + pgcache_page_no_t page; MARIA_PINNED_PAGE page_link; my_bool res; DBUG_ENTER("_ma_apply_redo_free_head_or_tail"); @@ -6211,14 +6212,15 @@ uint _ma_apply_redo_insert_row_blobs(MARIA_HA *info, header+= SUB_RANGE_SIZE; empty_space= uint2korr(header); header+= BLOCK_FILLER_SIZE; - DBUG_ASSERT(sub_ranges <= blob_count + 1 && empty_space < data_size); + DBUG_ASSERT(sub_ranges <= ranges && empty_space < data_size); + ranges-= sub_ranges; while (sub_ranges--) { uint i; uint res; uint page_range; - ulonglong page, start_page; + pgcache_page_no_t page, start_page; uchar *buff; start_page= page= page_korr(header); @@ -6346,7 +6348,7 @@ err: my_bool _ma_apply_undo_row_insert(MARIA_HA *info, LSN undo_lsn, const uchar *header) { - ulonglong page; + pgcache_page_no_t page; uint rownr; uchar *buff; my_bool res= 1; @@ -6388,7 +6390,7 @@ my_bool _ma_apply_undo_row_insert(MARIA_HA *info, LSN undo_lsn, checksum= 0; if (share->calc_checksum) - checksum= -ha_checksum_korr(header); + checksum= (ha_checksum) 0 - ha_checksum_korr(header); if (_ma_write_clr(info, undo_lsn, LOGREC_UNDO_ROW_INSERT, share->calc_checksum != 0, checksum, &lsn, (void*) 0)) goto err; @@ -6416,7 +6418,7 @@ my_bool _ma_apply_undo_row_delete(MARIA_HA *info, LSN undo_lsn, struct st_row_pos_info row_pos; uchar *record; const uchar *null_bits, *field_length_data, *extent_info; - ulonglong page; + pgcache_page_no_t page; ulong *blob_lengths; uint *null_field_lengths, extent_count, rownr, length_on_head_page; DBUG_ENTER("_ma_apply_undo_row_delete"); @@ -6445,7 +6447,7 @@ my_bool _ma_apply_undo_row_delete(MARIA_HA *info, LSN undo_lsn, We extract the checksum delta here, saving a recomputation in allocate_and_write_block_record(). It's only an optimization. */ - row.checksum= - ha_checksum_korr(header); + row.checksum= (ha_checksum) 0 - ha_checksum_korr(header); header+= HA_CHECKSUM_STORE_SIZE; } extent_info= header; @@ -6657,7 +6659,7 @@ my_bool _ma_apply_undo_row_update(MARIA_HA *info, LSN undo_lsn, MARIA_RECORD_POS record_pos; const uchar *field_length_data, *field_length_data_end, *extent_info; uchar *current_record, *orig_record; - ulonglong page; + pgcache_page_no_t page; ha_checksum checksum_delta; uint rownr, field_length_header, extent_count, length_on_head_page; int error= 1; diff --git a/storage/maria/ma_blockrec.h b/storage/maria/ma_blockrec.h index 77191d14609..a8411adc274 100644 --- a/storage/maria/ma_blockrec.h +++ b/storage/maria/ma_blockrec.h @@ -119,15 +119,16 @@ enum en_page_type { UNALLOCATED_PAGE, HEAD_PAGE, TAIL_PAGE, BLOB_PAGE, MAX_PAGE_ /* Functions to convert MARIA_RECORD_POS to/from page:offset */ -static inline MARIA_RECORD_POS ma_recordpos(ulonglong page, uint dir_entry) +static inline MARIA_RECORD_POS ma_recordpos(pgcache_page_no_t page, + uint dir_entry) { DBUG_ASSERT(dir_entry <= 255); - return (MARIA_RECORD_POS) ((page << 8) | dir_entry); + return (MARIA_RECORD_POS) (((ulonglong) page << 8) | dir_entry); } -static inline my_off_t ma_recordpos_to_page(MARIA_RECORD_POS record_pos) +static inline pgcache_page_no_t ma_recordpos_to_page(MARIA_RECORD_POS record_pos) { - return record_pos >> 8; + return (pgcache_page_no_t) (record_pos >> 8); } static inline uint ma_recordpos_to_dir_entry(MARIA_RECORD_POS record_pos) @@ -189,27 +190,29 @@ my_bool _ma_bitmap_find_place(MARIA_HA *info, MARIA_ROW *row, my_bool _ma_bitmap_release_unused(MARIA_HA *info, MARIA_BITMAP_BLOCKS *blocks); my_bool _ma_bitmap_free_full_pages(MARIA_HA *info, const uchar *extents, uint count); -my_bool _ma_bitmap_set(MARIA_HA *info, ulonglong pos, my_bool head, +my_bool _ma_bitmap_set(MARIA_HA *info, pgcache_page_no_t pos, my_bool head, uint empty_space); my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page, uint page_count); + pgcache_page_no_t page, + uint page_count); my_bool _ma_bitmap_set_full_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page, uint page_count); + pgcache_page_no_t page, uint page_count); uint _ma_free_size_to_head_pattern(MARIA_FILE_BITMAP *bitmap, uint size); my_bool _ma_bitmap_find_new_place(MARIA_HA *info, MARIA_ROW *new_row, - ulonglong page, uint free_size, + pgcache_page_no_t page, uint free_size, MARIA_BITMAP_BLOCKS *result_blocks); my_bool _ma_check_bitmap_data(MARIA_HA *info, - enum en_page_type page_type, ulonglong page, + enum en_page_type page_type, + pgcache_page_no_t page, uint empty_space, uint *bitmap_pattern); my_bool _ma_check_if_right_bitmap_type(MARIA_HA *info, enum en_page_type page_type, - ulonglong page, + pgcache_page_no_t page, uint *bitmap_pattern); uint _ma_bitmap_get_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap, - ulonglong page); + pgcache_page_no_t page); void _ma_bitmap_delete_all(MARIA_SHARE *share); int _ma_bitmap_create_first(MARIA_SHARE *share); void _ma_bitmap_flushable(MARIA_HA *info, int non_flushable_inc); @@ -217,7 +220,7 @@ void _ma_bitmap_set_pagecache_callbacks(PAGECACHE_FILE *file, MARIA_SHARE *share); #ifndef DBUG_OFF void _ma_print_bitmap(MARIA_FILE_BITMAP *bitmap, uchar *data, - ulonglong page); + pgcache_page_no_t page); #endif uint _ma_apply_redo_insert_row_head_or_tail(MARIA_HA *info, LSN lsn, diff --git a/storage/maria/ma_check.c b/storage/maria/ma_check.c index da6b6d0aa57..1acea96d05a 100644 --- a/storage/maria/ma_check.c +++ b/storage/maria/ma_check.c @@ -151,7 +151,8 @@ int maria_chk_status(HA_CHECK *param, register MARIA_HA *info) Check delete links in row data */ -int maria_chk_del(HA_CHECK *param, register MARIA_HA *info, uint test_flag) +int maria_chk_del(HA_CHECK *param, register MARIA_HA *info, + ulonglong test_flag) { MARIA_SHARE *share= info->s; reg2 ha_rows i; @@ -313,7 +314,8 @@ static int check_k_link(HA_CHECK *param, register MARIA_HA *info, DBUG_ASSERT(share->pagecache->block_size == block_size); if (!(buff= pagecache_read(share->pagecache, - &share->kfile, next_link/block_size, + &share->kfile, + (pgcache_page_no_t) (next_link / block_size), DFLT_INIT_HITS, (uchar*) info->buff, PAGECACHE_READ_UNKNOWN_PAGE, @@ -1632,7 +1634,8 @@ static my_bool check_head_page(HA_CHECK *param, MARIA_HA *info, uchar *record, /* Check that bitmap has the right marker for the found extents */ for (i= 0 ; i < info->cur_row.extents_count ; i++) { - uint extent_page, page_count, page_type; + pgcache_page_no_t extent_page; + uint page_count, page_type; extent_page= uint5korr(extents); page_count= uint2korr(extents+5) & ~START_EXTENT_BIT; extents+= ROW_EXTENT_SIZE; @@ -1683,7 +1686,7 @@ static int check_block_record(HA_CHECK *param, MARIA_HA *info, int extend, { MARIA_SHARE *share= info->s; my_off_t pos; - ulonglong page; + pgcache_page_no_t page; uchar *page_buff, *bitmap_buff, *data; char llbuff[22], llbuff2[22]; uint block_size= share->block_size; @@ -1739,7 +1742,7 @@ static int check_block_record(HA_CHECK *param, MARIA_HA *info, int extend, continue; } /* Skip pages marked as empty in bitmap */ - offset_page= ((page % share->bitmap.pages_covered) -1) * 3; + offset_page= (uint) ((page % share->bitmap.pages_covered) -1) * 3; offset= offset_page & 7; data= bitmap_buff + offset_page / 8; bitmap_pattern= uint2korr(data); @@ -1844,7 +1847,7 @@ static int check_block_record(HA_CHECK *param, MARIA_HA *info, int extend, { /* Not at end of bitmap */ uint bitmap_pattern; - offset_page= ((page % share->bitmap.pages_covered) -1) * 3; + offset_page= (uint) ((page % share->bitmap.pages_covered) -1) * 3; offset= offset_page & 7; data= bitmap_buff + offset_page / 8; bitmap_pattern= uint2korr(data); @@ -1887,7 +1890,7 @@ err: /* Check that record-link is ok */ -int maria_chk_data_link(HA_CHECK *param, MARIA_HA *info,int extend) +int maria_chk_data_link(HA_CHECK *param, MARIA_HA *info, my_bool extend) { MARIA_SHARE *share= info->s; int error; @@ -2077,7 +2080,7 @@ static int initialize_variables_for_repair(HA_CHECK *param, MARIA_SORT_INFO *sort_info, MARIA_SORT_PARAM *sort_param, MARIA_HA *info, - uint rep_quick) + my_bool rep_quick) { MARIA_SHARE *share= info->s; @@ -2095,7 +2098,7 @@ static int initialize_variables_for_repair(HA_CHECK *param, param->org_key_map= share->state.key_map; sort_param->sort_info= sort_info; - sort_param->fix_datafile= (my_bool) (! rep_quick); + sort_param->fix_datafile= ! rep_quick; sort_param->calc_checksum= test(param->testflag & T_CALC_CHECKSUM); sort_info->info= sort_info->new_info= info; sort_info->param= param; @@ -2158,7 +2161,7 @@ static int initialize_variables_for_repair(HA_CHECK *param, */ int maria_repair(HA_CHECK *param, register MARIA_HA *info, - char *name, uint rep_quick) + char *name, my_bool rep_quick) { int error, got_error; uint i; @@ -2343,7 +2346,7 @@ int maria_repair(HA_CHECK *param, register MARIA_HA *info, sort_param.current_filepos= sort_param.filepos; } } - if (error > 0 || maria_write_data_suffix(&sort_info, (my_bool)!rep_quick) || + if (error > 0 || maria_write_data_suffix(&sort_info, !rep_quick) || flush_io_cache(&sort_info.new_info->rec_cache) || param->read_cache.error < 0) goto err; @@ -2780,7 +2783,8 @@ err2: static void put_crc(char *buff, my_off_t pos, MARIA_SHARE *share) { - maria_page_crc_set_index(buff, pos / share->block_size, (uchar*) share); + maria_page_crc_set_index(buff, (pgcache_page_no_t) (pos / share->block_size), + (uchar*) share); } @@ -2891,7 +2895,7 @@ static my_bool maria_zerofill_index(HA_CHECK *param, MARIA_HA *info, MARIA_PINNED_PAGE page_link; char llbuff[21]; uchar *buff; - ulonglong page; + pgcache_page_no_t page; my_off_t pos; my_off_t key_file_length= share->state.state.key_file_length; uint block_size= share->block_size; @@ -2961,7 +2965,7 @@ static my_bool maria_zerofill_data(HA_CHECK *param, MARIA_HA *info, MARIA_PINNED_PAGE page_link; char llbuff[21]; my_off_t pos; - ulonglong page; + pgcache_page_no_t page; uint block_size= share->block_size; MARIA_FILE_BITMAP *bitmap= &share->bitmap; DBUG_ENTER("maria_zerofill_data"); @@ -3169,7 +3173,7 @@ err: */ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info, - const char * name, uint rep_quick) + const char * name, my_bool rep_quick) { int got_error; uint i; @@ -3515,7 +3519,7 @@ int maria_repair_by_sort(HA_CHECK *param, register MARIA_HA *info, goto err; } - if (rep_quick & T_FORCE_UNIQUENESS) + if (rep_quick && (param->testflag & T_FORCE_UNIQUENESS)) { my_off_t skr= (info->state->data_file_length + (sort_info.org_data_file_type == COMPRESSED_RECORD) ? @@ -3657,7 +3661,7 @@ err: */ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info, - const char * name, uint rep_quick) + const char * name, my_bool rep_quick) { #ifndef THREAD return maria_repair_by_sort(param, info, name, rep_quick); @@ -3725,7 +3729,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info, position 'new_header_length'. } */ - DBUG_PRINT("info", ("is quick repair: %d", rep_quick)); + DBUG_PRINT("info", ("is quick repair: %d", (int) rep_quick)); /* Initialize pthread structures before goto err. */ pthread_mutex_init(&sort_info.mutex, MY_MUTEX_INIT_FAST); @@ -3901,7 +3905,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info, } sort_info.total_keys=i; sort_param[0].master= 1; - sort_param[0].fix_datafile= (my_bool)(! rep_quick); + sort_param[0].fix_datafile= ! rep_quick; sort_param[0].calc_checksum= test(param->testflag & T_CALC_CHECKSUM); sort_info.got_error=0; @@ -4024,7 +4028,7 @@ int maria_repair_parallel(HA_CHECK *param, register MARIA_HA *info, goto err; } - if (rep_quick & T_FORCE_UNIQUENESS) + if (rep_quick && (param->testflag & T_FORCE_UNIQUENESS)) { my_off_t skr= (info->state->data_file_length + (sort_info.org_data_file_type == COMPRESSED_RECORD) ? @@ -6040,8 +6044,8 @@ static int _ma_safe_scan_block_record(MARIA_SORT_INFO *sort_info, MARIA_HA *info, uchar *record) { MARIA_SHARE *share= info->s; - uint record_pos= info->cur_row.nextpos; - ulonglong page= sort_info->page; + MARIA_RECORD_POS record_pos= info->cur_row.nextpos; + pgcache_page_no_t page= sort_info->page; DBUG_ENTER("_ma_safe_scan_block_record"); for (;;) @@ -6078,7 +6082,7 @@ static int _ma_safe_scan_block_record(MARIA_SORT_INFO *sort_info, { _ma_check_print_info(sort_info->param, "Wrong directory entry %3u at page %s", - record_pos, llstr(page, llbuff)); + (uint) record_pos, llstr(page, llbuff)); record_pos++; continue; } @@ -6100,7 +6104,7 @@ read_next_page: page++; if (!(page % share->bitmap.pages_covered)) page++; /* Skip bitmap */ - if ((page + 1) * share->block_size > sort_info->filelength) + if ((my_off_t) (page + 1) * share->block_size > sort_info->filelength) DBUG_RETURN(HA_ERR_END_OF_FILE); if (!(pagecache_read(share->pagecache, &info->dfile, diff --git a/storage/maria/ma_create.c b/storage/maria/ma_create.c index 7d3376cc4ec..89107e1736b 100644 --- a/storage/maria/ma_create.c +++ b/storage/maria/ma_create.c @@ -632,7 +632,7 @@ int maria_create(const char *name, enum data_file_type datafile_type, my_errno=HA_WRONG_CREATE_OPTION; goto err_no_lock; } - keydef->block_length= maria_block_size; + keydef->block_length= (uint16) maria_block_size; keydef->keylength= (uint16) key_length; keydef->minlength= (uint16) min_key_length; keydef->maxlength= (uint16) length; @@ -1007,12 +1007,12 @@ int maria_create(const char *name, enum data_file_type datafile_type, uint k; LSN lsn; log_array[TRANSLOG_INTERNAL_PARTS + 1].length= 1 + 2 + 2 + - kfile_size_before_extension; + (uint) kfile_size_before_extension; /* we are needing maybe 64 kB, so don't use the stack */ log_data= my_malloc(log_array[TRANSLOG_INTERNAL_PARTS + 1].length, MYF(0)); if ((log_data == NULL) || - my_pread(file, 1 + 2 + 2 + log_data, kfile_size_before_extension, - 0, MYF(MY_NABP))) + my_pread(file, 1 + 2 + 2 + log_data, + (size_t) kfile_size_before_extension, 0, MYF(MY_NABP))) goto err; /* remember if the data file was created or not, to know if Recovery can diff --git a/storage/maria/ma_dynrec.c b/storage/maria/ma_dynrec.c index 3b4c8215eac..b1c46d9b9bb 100644 --- a/storage/maria/ma_dynrec.c +++ b/storage/maria/ma_dynrec.c @@ -1490,7 +1490,7 @@ my_bool _ma_cmp_dynamic_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def, const uchar *record, MARIA_RECORD_POS pos) { uchar *old_rec_buff,*old_record; - my_off_t old_rec_buff_size; + size_t old_rec_buff_size; my_bool error; DBUG_ENTER("_ma_cmp_dynamic_unique"); diff --git a/storage/maria/ma_key.c b/storage/maria/ma_key.c index b13c24cce83..73152d4d475 100644 --- a/storage/maria/ma_key.c +++ b/storage/maria/ma_key.c @@ -139,11 +139,12 @@ uint _ma_make_key(register MARIA_HA *info, uint keynr, uchar *key, else if (keyseg->flag & HA_BLOB_PART) { uint tmp_length= _ma_calc_blob_length(keyseg->bit_start,pos); - memcpy_fixed(&pos,pos+keyseg->bit_start,sizeof(char*)); + uchar *blob_pos; + memcpy_fixed(&blob_pos, pos+keyseg->bit_start,sizeof(char*)); set_if_smaller(length,tmp_length); - FIX_LENGTH(cs, pos, length, char_length); + FIX_LENGTH(cs, blob_pos, length, char_length); store_key_length_inc(key,char_length); - memcpy(key,pos,(size_t) char_length); + memcpy(key, blob_pos, (size_t) char_length); key+= char_length; continue; } diff --git a/storage/maria/ma_key_recover.c b/storage/maria/ma_key_recover.c index fc543538e2a..eec65007b8d 100644 --- a/storage/maria/ma_key_recover.c +++ b/storage/maria/ma_key_recover.c @@ -112,7 +112,7 @@ my_bool _ma_write_clr(MARIA_HA *info, LSN undo_lsn, { /* Key root changed. Store new key root */ struct st_msg_to_write_hook_for_undo_key *undo_msg= extra_msg; - ulonglong page; + pgcache_page_no_t page; key_nr_store(log_pos, undo_msg->keynr); page= (undo_msg->value == HA_OFFSET_ERROR ? IMPOSSIBLE_PAGE_NO : undo_msg->value / info->s->block_size); @@ -526,8 +526,8 @@ my_bool _ma_log_add(MARIA_HA *info, my_off_t page, uchar *buff, uint _ma_apply_redo_index_new_page(MARIA_HA *info, LSN lsn, const uchar *header, uint length) { - ulonglong root_page= page_korr(header); - ulonglong free_page= page_korr(header + PAGE_STORE_SIZE); + pgcache_page_no_t root_page= page_korr(header); + pgcache_page_no_t free_page= page_korr(header + PAGE_STORE_SIZE); uint key_nr= key_nr_korr(header + PAGE_STORE_SIZE * 2); my_bool page_type_flag= header[PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE]; enum pagecache_page_lock unlock_method; @@ -647,8 +647,8 @@ uint _ma_apply_redo_index_free_page(MARIA_HA *info, LSN lsn, const uchar *header) { - ulonglong page= page_korr(header); - ulonglong free_page= page_korr(header + PAGE_STORE_SIZE); + pgcache_page_no_t page= page_korr(header); + pgcache_page_no_t free_page= page_korr(header + PAGE_STORE_SIZE); my_off_t old_link; MARIA_PINNED_PAGE page_link; MARIA_SHARE *share= info->s; @@ -745,7 +745,7 @@ uint _ma_apply_redo_index(MARIA_HA *info, LSN lsn, const uchar *header, uint head_length) { MARIA_SHARE *share= info->s; - ulonglong page= page_korr(header); + pgcache_page_no_t page= page_korr(header); MARIA_PINNED_PAGE page_link; uchar *buff; const uchar *header_end= header + head_length; diff --git a/storage/maria/ma_loghandler_lsn.h b/storage/maria/ma_loghandler_lsn.h index 7d4b5338836..c5ffb3cdc96 100644 --- a/storage/maria/ma_loghandler_lsn.h +++ b/storage/maria/ma_loghandler_lsn.h @@ -41,7 +41,7 @@ typedef int64 TRANSLOG_ADDRESS; typedef TRANSLOG_ADDRESS LSN; /* Gets file number part of a LSN/log address */ -#define LSN_FILE_NO(L) ((L) >> 32) +#define LSN_FILE_NO(L) (uint32) ((L) >> 32) /* Gets raw file number part of a LSN/log address */ #define LSN_FILE_NO_PART(L) ((L) & ((int64)0xFFFFFF00000000LL)) @@ -50,7 +50,7 @@ typedef TRANSLOG_ADDRESS LSN; #define LSN_IN_PARTS(L) (ulong)LSN_FILE_NO(L),(ulong)LSN_OFFSET(L) /* Gets record offset of a LSN/log address */ -#define LSN_OFFSET(L) ((L) & 0xFFFFFFFFL) +#define LSN_OFFSET(L) (ulong) ((L) & 0xFFFFFFFFL) /* Makes lsn/log address from file number and record offset */ #define MAKE_LSN(F,S) ((LSN) ((((uint64)(F)) << 32) | (S))) diff --git a/storage/maria/ma_page.c b/storage/maria/ma_page.c index 86d4bd7dd35..46a53c61df5 100644 --- a/storage/maria/ma_page.c +++ b/storage/maria/ma_page.c @@ -23,21 +23,20 @@ uchar *_ma_fetch_keypage(register MARIA_HA *info, MARIA_KEYDEF *keyinfo __attribute__ ((unused)), - my_off_t page, enum pagecache_page_lock lock, + my_off_t pos, enum pagecache_page_lock lock, int level, uchar *buff, int return_buffer __attribute__ ((unused)), MARIA_PINNED_PAGE **page_link_res) { uchar *tmp; - uint page_size __attribute__((unused)); MARIA_PINNED_PAGE page_link; MARIA_SHARE *share= info->s; uint block_size= share->block_size; DBUG_ENTER("_ma_fetch_keypage"); - DBUG_PRINT("enter",("page: %ld", (long) page)); + DBUG_PRINT("enter",("pos: %ld", (long) pos)); tmp= pagecache_read(share->pagecache, &share->kfile, - page / block_size, level, buff, + (pgcache_page_no_t) (pos / block_size), level, buff, share->page_type, lock, &page_link.link); if (lock != PAGECACHE_LOCK_LEFT_UNLOCKED) @@ -61,20 +60,22 @@ uchar *_ma_fetch_keypage(register MARIA_HA *info, my_errno=HA_ERR_CRASHED; DBUG_RETURN(0); } - info->last_keypage=page; + info->last_keypage= pos; #ifdef EXTRA_DEBUG - page_size= _ma_get_page_used(share, tmp); - if (page_size < 4 || page_size > block_size || - _ma_get_keynr(share, tmp) != keyinfo->key_nr) { - DBUG_PRINT("error",("page %lu had wrong page length: %u keynr: %u", - (ulong) page, page_size, - _ma_get_keynr(share, tmp))); - DBUG_DUMP("page", (char*) tmp, page_size); - info->last_keypage = HA_OFFSET_ERROR; - maria_print_error(share, HA_ERR_CRASHED); - my_errno= HA_ERR_CRASHED; - tmp= 0; + uint page_size= _ma_get_page_used(share, tmp); + if (page_size < 4 || page_size > block_size || + _ma_get_keynr(share, tmp) != keyinfo->key_nr) + { + DBUG_PRINT("error",("page %lu had wrong page length: %u keynr: %u", + (ulong) (pos / block_size), page_size, + _ma_get_keynr(share, tmp))); + DBUG_DUMP("page", (char*) tmp, page_size); + info->last_keypage = HA_OFFSET_ERROR; + maria_print_error(share, HA_ERR_CRASHED); + my_errno= HA_ERR_CRASHED; + tmp= 0; + } } #endif DBUG_RETURN(tmp); @@ -85,7 +86,7 @@ uchar *_ma_fetch_keypage(register MARIA_HA *info, int _ma_write_keypage(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo __attribute__((unused)), - my_off_t page, enum pagecache_page_lock lock, + my_off_t pos, enum pagecache_page_lock lock, int level, uchar *buff) { MARIA_SHARE *share= info->s; @@ -98,20 +99,20 @@ int _ma_write_keypage(register MARIA_HA *info, { uint page_length, nod; _ma_get_used_and_nod(share, buff, page_length, nod); - if (page < share->base.keystart || - page+block_size > info->state->key_file_length || - (page & (MARIA_MIN_KEY_BLOCK_LENGTH-1))) + if (pos < share->base.keystart || + pos+block_size > info->state->key_file_length || + (pos & (MARIA_MIN_KEY_BLOCK_LENGTH-1))) { DBUG_PRINT("error",("Trying to write inside key status region: " "key_start: %lu length: %lu page: %lu", (long) share->base.keystart, (long) info->state->key_file_length, - (long) page)); + (long) pos)); my_errno=EINVAL; DBUG_ASSERT(0); DBUG_RETURN((-1)); } - DBUG_PRINT("page",("write page at: %lu",(long) page)); + DBUG_PRINT("page",("write page at: %lu",(long) pos)); DBUG_DUMP("buff", buff, page_length); DBUG_ASSERT(page_length >= share->keypage_header + nod + keyinfo->minlength || maria_in_recovery); @@ -140,7 +141,7 @@ int _ma_write_keypage(register MARIA_HA *info, DBUG_ASSERT(share->pagecache->block_size == block_size); res= pagecache_write(share->pagecache, - &share->kfile, page / block_size, + &share->kfile, (pgcache_page_no_t) (pos / block_size), level, buff, share->page_type, lock, lock == PAGECACHE_LOCK_LEFT_WRITELOCKED ? @@ -313,7 +314,8 @@ my_off_t _ma_new(register MARIA_HA *info, int level, pos= share->current_key_del; /* Protected */ DBUG_ASSERT(share->pagecache->block_size == block_size); if (!(buff= pagecache_read(share->pagecache, - &share->kfile, pos / block_size, level, + &share->kfile, + (pgcache_page_no_t) (pos / block_size), level, 0, share->page_type, PAGECACHE_LOCK_WRITE, &(*page_link)->link))) pos= HA_OFFSET_ERROR; diff --git a/storage/maria/ma_pagecache.c b/storage/maria/ma_pagecache.c index 4b0dada3a6b..c5d5bdf2ed2 100755 --- a/storage/maria/ma_pagecache.c +++ b/storage/maria/ma_pagecache.c @@ -2212,10 +2212,10 @@ static my_bool get_wrlock(PAGECACHE *pagecache, pgcache_page_no_t pageno= block->hash_link->pageno; DBUG_ENTER("get_wrlock"); DBUG_PRINT("info", ("the block 0x%lx " - "files %d(%d) pages %d(%d)", - (ulong)block, - file.file, block->hash_link->file.file, - pageno, block->hash_link->pageno)); + "files %d(%d) pages %lu(%lu)", + (ulong) block, + file.file, block->hash_link->file.file, + (ulong) pageno, (ulong) block->hash_link->pageno)); PCBLOCK_INFO(block); while (block->wlocks && block->write_locker != user_file) { @@ -2242,10 +2242,10 @@ static my_bool get_wrlock(PAGECACHE *pagecache, pageno != block->hash_link->pageno) { DBUG_PRINT("info", ("the block 0x%lx changed => need retry " - "status: %x files %d != %d or pages %d != %d", + "status: %x files %d != %d or pages %lu != %lu", (ulong)block, block->status, file.file, block->hash_link->file.file, - pageno, block->hash_link->pageno)); + (ulong) pageno, (ulong) block->hash_link->pageno)); DBUG_RETURN(1); } } @@ -4267,13 +4267,14 @@ my_bool pagecache_collect_changed_blocks_with_lsn(PAGECACHE *pagecache, MARIA_SHARE *share; if (block->type != PAGECACHE_LSN_PAGE) continue; /* no need to store it in the checkpoint record */ - compile_time_assert(sizeof(block->hash_link->pageno) <= 4); share= (MARIA_SHARE *)(block->hash_link->file.callback_data); table_id= share->id; int2store(ptr, table_id); ptr+= 2; ptr[0]= (share->kfile.file == block->hash_link->file.file); ptr++; + /* TODO: We should fix the code here to handle 5 byte page numbers */ + DBUG_ASSERT(block->hash_link->pageno <= UINT_MAX32); int4store(ptr, block->hash_link->pageno); ptr+= 4; lsn_store(ptr, block->rec_lsn); diff --git a/storage/maria/ma_pagecache.h b/storage/maria/ma_pagecache.h index 412e867f116..930322e132a 100644 --- a/storage/maria/ma_pagecache.h +++ b/storage/maria/ma_pagecache.h @@ -75,7 +75,7 @@ enum pagecache_write_mode }; /* page number for maria */ -typedef uint32 pgcache_page_no_t; +typedef ulonglong pgcache_page_no_t; /* file descriptor for Maria */ typedef struct st_pagecache_file @@ -186,7 +186,8 @@ enum pagecache_flush_filter_result }; /** @brief a filter function type for flush_pagecache_blocks_with_filter() */ typedef enum pagecache_flush_filter_result -(*PAGECACHE_FLUSH_FILTER)(enum pagecache_page_type type, pgcache_page_no_t page, +(*PAGECACHE_FLUSH_FILTER)(enum pagecache_page_type type, + pgcache_page_no_t page, LSN rec_lsn, void *arg); /* The default key cache */ diff --git a/storage/maria/ma_pagecrc.c b/storage/maria/ma_pagecrc.c index 10cb82e46f7..0e413418ef8 100644 --- a/storage/maria/ma_pagecrc.c +++ b/storage/maria/ma_pagecrc.c @@ -78,6 +78,24 @@ static my_bool maria_page_crc_check(uchar *page, res= test(new_crc != crc); if (res) { + /* + Bitmap pages may be totally zero filled in some cases. + This happens when we get a crash after the pagecache has written + out a page that is on a newly created bitmap page and we get + a crash before the bitmap page is written out. + + We handle this case with the following logic: + When reading, approve of bitmap pages where all bytes are zero + (This is after all a bitmap pages where no data is reserved and + the CRC will be corrected at next write) + */ + if (no_crc_val == MARIA_NO_CRC_BITMAP_PAGE && + crc == 0 && _ma_check_if_zero(page, data_length)) + { + DBUG_PRINT("warning", ("Found bitmap page that was not initialized")); + DBUG_RETURN(0); + } + DBUG_PRINT("error", ("Page: %lu crc: %lu calculated crc: %lu", (ulong) page_no, (ulong) crc, (ulong) new_crc)); my_errno= HA_ERR_WRONG_CRC; @@ -104,7 +122,7 @@ my_bool maria_page_crc_set_normal(uchar *page, MARIA_SHARE *share= (MARIA_SHARE *)data_ptr; int data_length= share->block_size - CRC_SIZE; uint32 crc= maria_page_crc(page_no & UINT_MAX32, page, data_length); - DBUG_ENTER("maria_page_crc_set"); + DBUG_ENTER("maria_page_crc_set_normal"); DBUG_PRINT("info", ("Page %lu crc: %lu", (ulong) page_no, (ulong)crc)); /* crc is on the stack so it is aligned, pagecache buffer is aligned, too */ diff --git a/storage/maria/ma_preload.c b/storage/maria/ma_preload.c index c2a6d405932..6f519b09eac 100644 --- a/storage/maria/ma_preload.c +++ b/storage/maria/ma_preload.c @@ -80,7 +80,8 @@ int maria_preload(MARIA_HA *info, ulonglong key_map, my_bool ignore_leaves) { DBUG_ASSERT(share->pagecache->block_size == block_length); if (pagecache_write(share->pagecache, - &share->kfile, pos / block_length, + &share->kfile, + (pgcache_page_no_t) (pos / block_length), DFLT_INIT_HITS, (uchar*) buff, PAGECACHE_PLAIN_PAGE, diff --git a/storage/maria/ma_recovery.c b/storage/maria/ma_recovery.c index 4c8910ce632..922895fa1cc 100644 --- a/storage/maria/ma_recovery.c +++ b/storage/maria/ma_recovery.c @@ -376,7 +376,7 @@ int maria_apply_log(LSN from_lsn, enum maria_apply_log_way apply, now= my_getsystime(); if (recovery_message_printed == REC_MSG_REDO) { - float phase_took= (now - old_now)/10000000.0; + double phase_took= (now - old_now)/10000000.0; /* Detailed progress info goes to stderr, because ma_message_no_user() cannot put several messages on one line. @@ -428,7 +428,7 @@ int maria_apply_log(LSN from_lsn, enum maria_apply_log_way apply, now= my_getsystime(); if (recovery_message_printed == REC_MSG_UNDO) { - float phase_took= (now - old_now)/10000000.0; + double phase_took= (now - old_now)/10000000.0; procent_printed= 1; fprintf(stderr, " (%.1f seconds); ", phase_took); } @@ -447,7 +447,7 @@ int maria_apply_log(LSN from_lsn, enum maria_apply_log_way apply, now= my_getsystime(); if (recovery_message_printed == REC_MSG_FLUSH) { - float phase_took= (now - old_now)/10000000.0; + double phase_took= (now - old_now)/10000000.0; procent_printed= 1; fprintf(stderr, " (%.1f seconds); ", phase_took); } @@ -1008,7 +1008,7 @@ prototype_redo_exec_hook(REDO_REPAIR_TABLE) MARIA_HA *info; HA_CHECK param; char *name; - uint quick_repair; + my_bool quick_repair; DBUG_ENTER("exec_REDO_LOGREC_REDO_REPAIR_TABLE"); if (skip_DDLs) @@ -1036,8 +1036,7 @@ prototype_redo_exec_hook(REDO_REPAIR_TABLE) DBUG_ASSERT(maria_tmpdir); info->s->state.key_map= uint8korr(rec->header + FILEID_STORE_SIZE + 8); - quick_repair= param.testflag & T_QUICK; - + quick_repair= test(param.testflag & T_QUICK); if (param.testflag & T_REP_PARALLEL) { @@ -2748,7 +2747,8 @@ static MARIA_HA *get_MARIA_HA_from_UNDO_record(const static LSN parse_checkpoint_record(LSN lsn) { - ulong i, nb_dirty_pages; + ulong i; + ulonglong nb_dirty_pages; TRANSLOG_HEADER_BUFFER rec; TRANSLOG_ADDRESS start_address; int len; @@ -3078,11 +3078,14 @@ void _ma_reenable_logging_for_table(MARIA_HA *info) static void print_redo_phase_progress(TRANSLOG_ADDRESS addr) { - static int end_logno= FILENO_IMPOSSIBLE, end_offset, percentage_printed= 0; + static uint end_logno= FILENO_IMPOSSIBLE, percentage_printed= 0; + static ulong end_offset; static ulonglong initial_remainder= -1; - int cur_logno, cur_offset; + + uint cur_logno; + ulong cur_offset; ulonglong local_remainder; - int percentage_done; + uint percentage_done; if (tracef == stdout) return; @@ -3107,12 +3110,12 @@ static void print_redo_phase_progress(TRANSLOG_ADDRESS addr) end_offset); if (initial_remainder == (ulonglong)(-1)) initial_remainder= local_remainder; - percentage_done= ((initial_remainder - local_remainder) * ULL(100) / - initial_remainder); + percentage_done= (uint) ((initial_remainder - local_remainder) * ULL(100) / + initial_remainder); if ((percentage_done - percentage_printed) >= 10) { percentage_printed= percentage_done; - fprintf(stderr, " %d%%", percentage_done); + fprintf(stderr, " %u%%", percentage_done); procent_printed= 1; } } diff --git a/storage/maria/ma_test2.c b/storage/maria/ma_test2.c index 6b6a1e8079d..bdda66747e3 100644 --- a/storage/maria/ma_test2.c +++ b/storage/maria/ma_test2.c @@ -18,12 +18,6 @@ #ifndef USE_MY_FUNC /* We want to be able to dbug this !! */ #define USE_MY_FUNC #endif -#ifdef DBUG_OFF -#undef DBUG_OFF -#endif -#ifndef SAFEMALLOC -#define SAFEMALLOC -#endif #include "maria_def.h" #include "trnman.h" #include <m_ctype.h> diff --git a/storage/maria/maria_chk.c b/storage/maria/maria_chk.c index 90c4238ad91..f1a6cf05c2d 100644 --- a/storage/maria/maria_chk.c +++ b/storage/maria/maria_chk.c @@ -850,7 +850,7 @@ static void get_options(register int *argc,register char ***argv) static int maria_chk(HA_CHECK *param, char *filename) { int error,lock_type,recreate; - int rep_quick= param->testflag & (T_QUICK | T_FORCE_UNIQUENESS); + my_bool rep_quick= test(param->testflag & (T_QUICK | T_FORCE_UNIQUENESS)); MARIA_HA *info; File datafile; char llbuff[22],llbuff2[22]; @@ -1013,7 +1013,7 @@ static int maria_chk(HA_CHECK *param, char *filename) param->testflag|=T_REP_BY_SORT; /* if only STATISTICS */ if (!(param->testflag & T_SILENT)) printf("- '%s' has old table-format. Recreating index\n",filename); - rep_quick|=T_QUICK; + rep_quick= 1; } share= info->s; share->tot_locks-= share->r_locks; @@ -1215,7 +1215,8 @@ static int maria_chk(HA_CHECK *param, char *filename) maria_lock_memory(param); if ((info->s->data_file_type != STATIC_RECORD) || (param->testflag & (T_EXTEND | T_MEDIUM))) - error|=maria_chk_data_link(param, info, param->testflag & T_EXTEND); + error|=maria_chk_data_link(param, info, + test(param->testflag & T_EXTEND)); error|= _ma_flush_table_files_after_repair(param, info); VOID(end_io_cache(¶m->read_cache)); } diff --git a/storage/maria/maria_def.h b/storage/maria/maria_def.h index 05a1dbe2d56..f7acb49d60e 100644 --- a/storage/maria/maria_def.h +++ b/storage/maria/maria_def.h @@ -83,7 +83,7 @@ typedef struct st_maria_state_info MARIA_STATUS_INFO state; ha_rows split; /* number of split blocks */ my_off_t dellink; /* Link to next removed block */ - ulonglong first_bitmap_with_space; + pgcache_page_no_t first_bitmap_with_space; ulonglong auto_increment; ulong process; /* process that updated table last */ ulong unique; /* Unique number for this process */ @@ -220,7 +220,7 @@ typedef struct st_maria_pack typedef struct st_maria_file_bitmap { uchar *map; - ulonglong page; /* Page number for current bitmap */ + pgcache_page_no_t page; /* Page number for current bitmap */ uint used_size; /* Size of bitmap head that is not 0 */ my_bool changed; /* 1 if page needs to be flushed */ my_bool flush_all_requested; /**< If _ma_bitmap_flush_all waiting */ @@ -373,7 +373,7 @@ typedef uchar MARIA_BITMAP_BUFFER; typedef struct st_maria_bitmap_block { - ulonglong page; /* Page number */ + pgcache_page_no_t page; /* Page number */ /* Number of continuous pages. TAIL_BIT is set if this is a tail page */ uint page_count; uint empty_space; /* Set for head and tail pages */ @@ -422,7 +422,7 @@ typedef struct st_maria_block_scan { uchar *bitmap_buff, *bitmap_pos, *bitmap_end, *page_buff; uchar *dir, *dir_end; - ulong bitmap_page; + pgcache_page_no_t bitmap_page; ulonglong bits; uint number_of_rows, bit_pos; MARIA_RECORD_POS row_base_page; diff --git a/storage/maria/maria_pack.c b/storage/maria/maria_pack.c index dc0afdd4b64..5232ddf9b63 100644 --- a/storage/maria/maria_pack.c +++ b/storage/maria/maria_pack.c @@ -122,8 +122,8 @@ typedef struct st_isam_mrg { extern int main(int argc,char * *argv); static void get_options(int *argc,char ***argv); -static MARIA_HA *open_isam_file(char *name,int mode); -static bool open_isam_files(PACK_MRG_INFO *mrg,char **names,uint count); +static MARIA_HA *open_maria_file(char *name,int mode); +static bool open_maria_files(PACK_MRG_INFO *mrg,char **names,uint count); static int compress(PACK_MRG_INFO *file,char *join_name); static HUFF_COUNTS *init_huff_count(MARIA_HA *info,my_off_t records); static void free_counts_and_tree_and_queue(HUFF_TREE *huff_trees, @@ -158,7 +158,7 @@ static uint *make_offset_code_tree(HUFF_TREE *huff_tree, HUFF_ELEMENT *element, uint *offset); static uint max_bit(uint value); -static int compress_isam_file(PACK_MRG_INFO *file,HUFF_COUNTS *huff_counts); +static int compress_maria_file(PACK_MRG_INFO *file,HUFF_COUNTS *huff_counts); static char *make_new_name(char *new_name,char *old_name); static char *make_old_name(char *new_name,char *old_name); static void init_file_buffer(File file,pbool read_buffer); @@ -216,14 +216,14 @@ int main(int argc, char **argv) error=ok=isamchk_neaded=0; if (join_table) { /* Join files into one */ - if (open_isam_files(&merge,argv,(uint) argc) || + if (open_maria_files(&merge,argv,(uint) argc) || compress(&merge,join_table)) error=1; } else while (argc--) { MARIA_HA *isam_file; - if (!(isam_file=open_isam_file(*argv++,O_RDWR))) + if (!(isam_file=open_maria_file(*argv++,O_RDWR))) error=1; else { @@ -400,11 +400,11 @@ static void get_options(int *argc,char ***argv) } -static MARIA_HA *open_isam_file(char *name,int mode) +static MARIA_HA *open_maria_file(char *name,int mode) { MARIA_HA *isam_file; MARIA_SHARE *share; - DBUG_ENTER("open_isam_file"); + DBUG_ENTER("open_maria_file"); if (!(isam_file=maria_open(name,mode, (opt_wait ? HA_OPEN_WAIT_IF_LOCKED : @@ -439,7 +439,7 @@ static MARIA_HA *open_isam_file(char *name,int mode) } -static bool open_isam_files(PACK_MRG_INFO *mrg,char **names,uint count) +static bool open_maria_files(PACK_MRG_INFO *mrg,char **names,uint count) { uint i,j; mrg->count=0; @@ -449,7 +449,7 @@ static bool open_isam_files(PACK_MRG_INFO *mrg,char **names,uint count) mrg->src_file_has_indexes_disabled= 0; for (i=0; i < count ; i++) { - if (!(mrg->file[i]=open_isam_file(names[i],O_RDONLY))) + if (!(mrg->file[i]=open_maria_file(names[i],O_RDONLY))) goto error; mrg->src_file_has_indexes_disabled|= @@ -489,7 +489,7 @@ static bool open_isam_files(PACK_MRG_INFO *mrg,char **names,uint count) static int compress(PACK_MRG_INFO *mrg,char *result_table) { int error; - File new_file,join_isam_file; + File new_file,join_maria_file; MARIA_HA *isam_file; MARIA_SHARE *share; char org_name[FN_REFLEN],new_name[FN_REFLEN],temp_name[FN_REFLEN]; @@ -501,7 +501,7 @@ static int compress(PACK_MRG_INFO *mrg,char *result_table) isam_file=mrg->file[0]; /* Take this as an example */ share=isam_file->s; - new_file=join_isam_file= -1; + new_file=join_maria_file= -1; trees=fields=0; huff_trees=0; huff_counts=0; @@ -529,14 +529,14 @@ static int compress(PACK_MRG_INFO *mrg,char *result_table) uchar *buff; strmov(org_name,result_table); /* Fix error messages */ VOID(fn_format(new_name,result_table,"",MARIA_NAME_IEXT,2)); - if ((join_isam_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME))) + if ((join_maria_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME))) < 0) goto err; length=(uint) share->base.keystart; if (!(buff= (uchar*) my_malloc(length,MYF(MY_WME)))) goto err; if (my_pread(share->kfile.file, buff, length, 0L, MYF(MY_WME | MY_NABP)) || - my_write(join_isam_file,buff,length, + my_write(join_maria_file,buff,length, MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL))) { my_free(buff,MYF(0)); @@ -653,7 +653,7 @@ static int compress(PACK_MRG_INFO *mrg,char *result_table) DBUG_PRINT("info", ("- Compressing file")); if (write_loop || verbose) VOID(printf("- Compressing file\n")); - error=compress_isam_file(mrg,huff_counts); + error=compress_maria_file(mrg,huff_counts); new_length=file_buffer.pos_in_file; if (!error && !test_only) { @@ -701,7 +701,7 @@ static int compress(PACK_MRG_INFO *mrg,char *result_table) { if (result_table) { - error=save_state_mrg(join_isam_file,mrg,new_length,glob_crc); + error=save_state_mrg(join_maria_file,mrg,new_length,glob_crc); } else { @@ -742,8 +742,8 @@ static int compress(PACK_MRG_INFO *mrg,char *result_table) } } error|=mrg_close(mrg); - if (join_isam_file >= 0) - error|=my_close(join_isam_file,MYF(MY_WME)); + if (join_maria_file >= 0) + error|=my_close(join_maria_file,MYF(MY_WME)); if (error) { VOID(fprintf(stderr, "Aborting: %s is not compressed\n", org_name)); @@ -766,8 +766,8 @@ static int compress(PACK_MRG_INFO *mrg,char *result_table) free_counts_and_tree_and_queue(huff_trees,trees,huff_counts,fields); if (new_file >= 0) VOID(my_close(new_file,MYF(0))); - if (join_isam_file >= 0) - VOID(my_close(join_isam_file,MYF(0))); + if (join_maria_file >= 0) + VOID(my_close(join_maria_file,MYF(0))); mrg_close(mrg); VOID(fprintf(stderr, "Aborted: %s is not compressed\n", org_name)); DBUG_RETURN(-1); @@ -2413,7 +2413,7 @@ static uint max_bit(register uint value) } -static int compress_isam_file(PACK_MRG_INFO *mrg, HUFF_COUNTS *huff_counts) +static int compress_maria_file(PACK_MRG_INFO *mrg, HUFF_COUNTS *huff_counts) { int error; uint i,max_calc_length,pack_ref_length,min_record_length,max_record_length; @@ -2426,7 +2426,7 @@ static int compress_isam_file(PACK_MRG_INFO *mrg, HUFF_COUNTS *huff_counts) HUFF_TREE *tree; MARIA_HA *isam_file=mrg->file[0]; uint pack_version= (uint) isam_file->s->pack.version; - DBUG_ENTER("compress_isam_file"); + DBUG_ENTER("compress_maria_file"); /* Allocate a buffer for the records (excluding blobs). */ if (!(record=(uchar*) my_alloca(isam_file->s->base.reclength))) diff --git a/storage/maria/plug.in b/storage/maria/plug.in index 1ce64f6e2bb..01ef2443978 100644 --- a/storage/maria/plug.in +++ b/storage/maria/plug.in @@ -6,3 +6,14 @@ MYSQL_PLUGIN_STATIC(maria, [libmaria.a]) # Maria will probably go first into max builds, not all builds, # so we don't declare it mandatory. MYSQL_PLUGIN_DEPENDS_ON_MYSQL_INTERNALS(maria, [ha_maria.cc]) + +AC_ARG_WITH(maria-tmp-tables, + [ --with-maria-tmp-tables Use Maria for internal temporary tables.], + [with_maria_tmp_tables=$withval], + [with_maria_tmp_tables=yes] +) + +if test "$with_maria_tmp_tables" = "yes" +then + AC_DEFINE([USE_MARIA_FOR_TMP_TABLES], [1], [Maria is used for internal temporary tables]) +fi diff --git a/storage/maria/trnman.c b/storage/maria/trnman.c index 147675456aa..11ac8614e29 100644 --- a/storage/maria/trnman.c +++ b/storage/maria/trnman.c @@ -221,7 +221,8 @@ static TrID new_trid() static void set_short_trid(TRN *trn) { - int i= (global_trid_generator + (intptr)trn) * 312089 % SHORT_TRID_MAX + 1; + int i= (int) ((global_trid_generator + (intptr)trn) * 312089 % + SHORT_TRID_MAX + 1); for ( ; !trn->short_id ; i= 1) { my_atomic_rwlock_wrlock(&LOCK_short_trid_to_trn); diff --git a/storage/myisam/mi_test2.c b/storage/myisam/mi_test2.c index e75a09702ce..c29d495194f 100644 --- a/storage/myisam/mi_test2.c +++ b/storage/myisam/mi_test2.c @@ -18,12 +18,6 @@ #ifndef USE_MY_FUNC /* We want to be able to dbug this !! */ #define USE_MY_FUNC #endif -#ifdef DBUG_OFF -#undef DBUG_OFF -#endif -#ifndef SAFEMALLOC -#define SAFEMALLOC -#endif #include "myisamdef.h" #include <m_ctype.h> #include <my_bit.h> |