diff options
Diffstat (limited to 'sql')
50 files changed, 424 insertions, 424 deletions
diff --git a/sql/create_options.cc b/sql/create_options.cc index 99562faa077..96893aa172e 100644 --- a/sql/create_options.cc +++ b/sql/create_options.cc @@ -124,8 +124,8 @@ static bool set_one_value(ha_create_table_option *opt, MEM_ROOT *root) { DBUG_ENTER("set_one_value"); - DBUG_PRINT("enter", ("opt: 0x%lx type: %u name '%s' value: '%s'", - (ulong) opt, + DBUG_PRINT("enter", ("opt: %p type: %u name '%s' value: '%s'", + opt, opt->type, opt->name, (value->str ? value->str : "<DEFAULT>"))); switch (opt->type) diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index ab022c770b8..4a4a93757ef 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -681,8 +681,8 @@ static st_debug_sync_action *debug_sync_get_action(THD *thd, } DBUG_ASSERT(action >= ds_control->ds_action); DBUG_ASSERT(action < ds_control->ds_action + ds_control->ds_active); - DBUG_PRINT("debug_sync", ("action: 0x%lx array: 0x%lx count: %u", - (long) action, (long) ds_control->ds_action, + DBUG_PRINT("debug_sync", ("action: %p array: %p count: %u", + action, ds_control->ds_action, ds_control->ds_active)); DBUG_RETURN(action); diff --git a/sql/event_data_objects.cc b/sql/event_data_objects.cc index 9e1ee6f30f9..86866edffd9 100644 --- a/sql/event_data_objects.cc +++ b/sql/event_data_objects.cc @@ -911,9 +911,9 @@ Event_queue_element::compute_next_execution_time() { my_time_t time_now; DBUG_ENTER("Event_queue_element::compute_next_execution_time"); - DBUG_PRINT("enter", ("starts: %lu ends: %lu last_executed: %lu this: 0x%lx", + DBUG_PRINT("enter", ("starts: %lu ends: %lu last_executed: %lu this: %p", (long) starts, (long) ends, (long) last_executed, - (long) this)); + this)); if (status != Event_parse_data::ENABLED) { diff --git a/sql/event_db_repository.cc b/sql/event_db_repository.cc index ca4d93eb240..50bc84883a0 100644 --- a/sql/event_db_repository.cc +++ b/sql/event_db_repository.cc @@ -1060,7 +1060,7 @@ Event_db_repository::load_named_event(THD *thd, LEX_STRING dbname, TABLE_LIST event_table; DBUG_ENTER("Event_db_repository::load_named_event"); - DBUG_PRINT("enter",("thd: 0x%lx name: %*s", (long) thd, + DBUG_PRINT("enter",("thd: %p name: %*s", thd, (int) name.length, name.str)); event_table.init_one_table("mysql", 5, "event", 5, "event", TL_READ); @@ -1183,7 +1183,7 @@ Event_db_repository::check_system_tables(THD *thd) const unsigned int event_priv_column_position= 29; DBUG_ENTER("Event_db_repository::check_system_tables"); - DBUG_PRINT("enter", ("thd: 0x%lx", (long) thd)); + DBUG_PRINT("enter", ("thd: %p", thd)); /* Check mysql.db */ tables.init_one_table("mysql", 5, "db", 2, "db", TL_READ); diff --git a/sql/event_parse_data.cc b/sql/event_parse_data.cc index 6c123c8e641..6fa0c25508e 100644 --- a/sql/event_parse_data.cc +++ b/sql/event_parse_data.cc @@ -497,9 +497,9 @@ Event_parse_data::check_parse_data(THD *thd) { bool ret; DBUG_ENTER("Event_parse_data::check_parse_data"); - DBUG_PRINT("info", ("execute_at: 0x%lx expr=0x%lx starts=0x%lx ends=0x%lx", - (long) item_execute_at, (long) item_expression, - (long) item_starts, (long) item_ends)); + DBUG_PRINT("info", ("execute_at: %p expr=%p starts=%p ends=%p", + item_execute_at, item_expression, + item_starts, item_ends)); init_name(thd, identifier); @@ -532,9 +532,9 @@ Event_parse_data::init_definer(THD *thd) size_t definer_user_len= thd->lex->definer->user.length; size_t definer_host_len= thd->lex->definer->host.length; - DBUG_PRINT("info",("init definer_user thd->mem_root: 0x%lx " - "definer_user: 0x%lx", (long) thd->mem_root, - (long) definer_user)); + DBUG_PRINT("info",("init definer_user thd->mem_root: %p " + "definer_user: %p", thd->mem_root, + definer_user)); /* + 1 for @ */ DBUG_PRINT("info",("init definer as whole")); diff --git a/sql/event_queue.cc b/sql/event_queue.cc index ae8ba258717..01a1507f6f2 100644 --- a/sql/event_queue.cc +++ b/sql/event_queue.cc @@ -135,7 +135,7 @@ bool Event_queue::init_queue(THD *thd) { DBUG_ENTER("Event_queue::init_queue"); - DBUG_PRINT("enter", ("this: 0x%lx", (long) this)); + DBUG_PRINT("enter", ("this: %p", this)); LOCK_QUEUE_DATA(); @@ -201,7 +201,7 @@ Event_queue::create_event(THD *thd, Event_queue_element *new_element, bool *created) { DBUG_ENTER("Event_queue::create_event"); - DBUG_PRINT("enter", ("thd: 0x%lx et=%s.%s", (long) thd, + DBUG_PRINT("enter", ("thd: %p et=%s.%s", thd, new_element->dbname.str, new_element->name.str)); /* Will do nothing if the event is disabled */ @@ -213,7 +213,7 @@ Event_queue::create_event(THD *thd, Event_queue_element *new_element, DBUG_RETURN(FALSE); } - DBUG_PRINT("info", ("new event in the queue: 0x%lx", (long) new_element)); + DBUG_PRINT("info", ("new event in the queue: %p", new_element)); LOCK_QUEUE_DATA(); *created= (queue_insert_safe(&queue, (uchar *) new_element) == FALSE); @@ -242,7 +242,7 @@ Event_queue::update_event(THD *thd, LEX_STRING dbname, LEX_STRING name, Event_queue_element *new_element) { DBUG_ENTER("Event_queue::update_event"); - DBUG_PRINT("enter", ("thd: 0x%lx et=[%s.%s]", (long) thd, dbname.str, name.str)); + DBUG_PRINT("enter", ("thd: %p et=[%s.%s]", thd, dbname.str, name.str)); if ((new_element->status == Event_parse_data::DISABLED) || (new_element->status == Event_parse_data::SLAVESIDE_DISABLED)) @@ -264,7 +264,7 @@ Event_queue::update_event(THD *thd, LEX_STRING dbname, LEX_STRING name, /* If not disabled event */ if (new_element) { - DBUG_PRINT("info", ("new event in the queue: 0x%lx", (long) new_element)); + DBUG_PRINT("info", ("new event in the queue: %p", new_element)); queue_insert_safe(&queue, (uchar *) new_element); mysql_cond_broadcast(&COND_queue_state); } @@ -290,7 +290,7 @@ void Event_queue::drop_event(THD *thd, LEX_STRING dbname, LEX_STRING name) { DBUG_ENTER("Event_queue::drop_event"); - DBUG_PRINT("enter", ("thd: 0x%lx db :%s name: %s", (long) thd, + DBUG_PRINT("enter", ("thd: %p db :%s name: %s", thd, dbname.str, name.str)); LOCK_QUEUE_DATA(); @@ -545,7 +545,7 @@ Event_queue::dbug_dump_queue(my_time_t when) i++) { et= ((Event_queue_element*)queue_element(&queue, i)); - DBUG_PRINT("info", ("et: 0x%lx name: %s.%s", (long) et, + DBUG_PRINT("info", ("et: %p name: %s.%s", et, et->dbname.str, et->name.str)); DBUG_PRINT("info", ("exec_at: %lu starts: %lu ends: %lu execs_so_far: %u " "expr: %ld et.exec_at: %ld now: %ld " @@ -673,8 +673,8 @@ Event_queue::get_top_for_execution_if_time(THD *thd, end: UNLOCK_QUEUE_DATA(); - DBUG_PRINT("info", ("returning %d et_new: 0x%lx ", - ret, (long) *event_name)); + DBUG_PRINT("info", ("returning %d et_new: %p ", + ret, *event_name)); if (*event_name) { diff --git a/sql/event_scheduler.cc b/sql/event_scheduler.cc index 8ed5901b69a..57bbf0e1eea 100644 --- a/sql/event_scheduler.cc +++ b/sql/event_scheduler.cc @@ -295,7 +295,7 @@ Event_worker_thread::run(THD *thd, Event_queue_element_for_exec *event) res= post_init_event_thread(thd); DBUG_ENTER("Event_worker_thread::run"); - DBUG_PRINT("info", ("Time is %ld, THD: 0x%lx", (long) my_time(0), (long) thd)); + DBUG_PRINT("info", ("Time is %u, THD: %p", (uint)my_time(0), thd)); inc_thread_running(); if (res) @@ -420,7 +420,7 @@ Event_scheduler::start(int *err_no) scheduler_thd= new_thd; DBUG_PRINT("info", ("Setting state go RUNNING")); state= RUNNING; - DBUG_PRINT("info", ("Forking new thread for scheduler. THD: 0x%lx", (long) new_thd)); + DBUG_PRINT("info", ("Forking new thread for scheduler. THD: %p", new_thd)); if ((*err_no= mysql_thread_create(key_thread_event_scheduler, &th, &connection_attrib, event_scheduler_thread, @@ -485,7 +485,7 @@ Event_scheduler::run(THD *thd) } DBUG_PRINT("info", ("get_top_for_execution_if_time returned " - "event_name=0x%lx", (long) event_name)); + "event_name=%p", event_name)); if (event_name) { if ((res= execute_top(event_name))) @@ -566,7 +566,7 @@ Event_scheduler::execute_top(Event_queue_element_for_exec *event_name) started_events++; executed_events++; // For SHOW STATUS - DBUG_PRINT("info", ("Event is in THD: 0x%lx", (long) new_thd)); + DBUG_PRINT("info", ("Event is in THD: %p", new_thd)); DBUG_RETURN(FALSE); error: @@ -617,7 +617,7 @@ Event_scheduler::stop() { THD *thd= current_thd; DBUG_ENTER("Event_scheduler::stop"); - DBUG_PRINT("enter", ("thd: 0x%lx", (long) thd)); + DBUG_PRINT("enter", ("thd: %p", thd)); LOCK_DATA(); DBUG_PRINT("info", ("state before action %s", scheduler_states_names[state].str)); diff --git a/sql/events.cc b/sql/events.cc index ecba97649b7..11d54894d1d 100644 --- a/sql/events.cc +++ b/sql/events.cc @@ -1120,7 +1120,7 @@ Events::load_events_from_db(THD *thd) uint count= 0; ulong saved_master_access; DBUG_ENTER("Events::load_events_from_db"); - DBUG_PRINT("enter", ("thd: 0x%lx", (long) thd)); + DBUG_PRINT("enter", ("thd: %p", thd)); /* NOTE: even if we run in read-only mode, we should be able to lock the diff --git a/sql/field.cc b/sql/field.cc index a18bb808573..50c372bf53d 100644 --- a/sql/field.cc +++ b/sql/field.cc @@ -8361,8 +8361,8 @@ const uchar *Field_blob::unpack(uchar *to, const uchar *from, const uchar *from_end, uint param_data) { DBUG_ENTER("Field_blob::unpack"); - DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx; param_data: %u", - (ulong) to, (ulong) from, param_data)); + DBUG_PRINT("enter", ("to: %p; from: %p; param_data: %u", + to, from, param_data)); uint const master_packlength= param_data > 0 ? param_data & 0xFF : packlength; if (from + master_packlength > from_end) @@ -9216,8 +9216,8 @@ Field_bit::do_last_null_byte() const bits. On systems with CHAR_BIT > 8 (not very common), the storage will lose the extra bits. */ - DBUG_PRINT("test", ("bit_ofs: %d, bit_len: %d bit_ptr: 0x%lx", - bit_ofs, bit_len, (long) bit_ptr)); + DBUG_PRINT("test", ("bit_ofs: %d, bit_len: %d bit_ptr: %p", + bit_ofs, bit_len, bit_ptr)); uchar *result; if (bit_len == 0) result= null_ptr; diff --git a/sql/gen_lex_token.cc b/sql/gen_lex_token.cc index eefe9163819..bd2b9728177 100644 --- a/sql/gen_lex_token.cc +++ b/sql/gen_lex_token.cc @@ -79,7 +79,7 @@ void set_token(int tok, const char *str) } compiled_token_array[tok].m_token_string= str; - compiled_token_array[tok].m_token_length= strlen(str); + compiled_token_array[tok].m_token_length= (int)strlen(str); compiled_token_array[tok].m_append_space= true; compiled_token_array[tok].m_start_expr= false; } diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc index 54c777975e0..4375e891f1f 100644 --- a/sql/ha_partition.cc +++ b/sql/ha_partition.cc @@ -4803,8 +4803,8 @@ int ha_partition::rnd_init(bool scan) } /* Now we see what the index of our first important partition is */ - DBUG_PRINT("info", ("m_part_info->read_partitions: 0x%lx", - (long) m_part_info->read_partitions.bitmap)); + DBUG_PRINT("info", ("m_part_info->read_partitions: %p", + m_part_info->read_partitions.bitmap)); part_id= bitmap_get_first_set(&(m_part_info->read_partitions)); DBUG_PRINT("info", ("m_part_spec.start_part %d", part_id)); diff --git a/sql/handler.cc b/sql/handler.cc index 034a3f5f750..e87ee03d0ee 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -257,7 +257,7 @@ handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc, { handler *file; DBUG_ENTER("get_new_handler"); - DBUG_PRINT("enter", ("alloc: 0x%lx", (long) alloc)); + DBUG_PRINT("enter", ("alloc: %p", alloc)); if (db_type && db_type->state == SHOW_OPTION_YES && db_type->create) { @@ -3191,8 +3191,8 @@ void handler::column_bitmaps_signal() { DBUG_ENTER("column_bitmaps_signal"); if (table) - DBUG_PRINT("info", ("read_set: 0x%lx write_set: 0x%lx", - (long) table->read_set, (long) table->write_set)); + DBUG_PRINT("info", ("read_set: %p write_set: %p", + table->read_set, table->write_set)); DBUG_VOID_RETURN; } @@ -5741,9 +5741,9 @@ bool handler::check_table_binlog_row_based_internal(bool binlog_row) static int write_locked_table_maps(THD *thd) { DBUG_ENTER("write_locked_table_maps"); - DBUG_PRINT("enter", ("thd: 0x%lx thd->lock: 0x%lx " - "thd->extra_lock: 0x%lx", - (long) thd, (long) thd->lock, (long) thd->extra_lock)); + DBUG_PRINT("enter", ("thd:%p thd->lock:%p " + "thd->extra_lock: %p", + thd, thd->lock, thd->extra_lock)); DBUG_PRINT("debug", ("get_binlog_table_maps(): %d", thd->get_binlog_table_maps())); diff --git a/sql/item.cc b/sql/item.cc index 1b29b3edf50..74c5d94ec98 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -6293,8 +6293,8 @@ void Item_field::save_org_in_field(Field *to, fast_field_copier fast_field_copier_func) { DBUG_ENTER("Item_field::save_org_in_field"); - DBUG_PRINT("enter", ("setup: 0x%lx data: 0x%lx", - (ulong) to, (ulong) fast_field_copier_func)); + DBUG_PRINT("enter", ("setup: %p data: %p", + to, fast_field_copier_func)); if (fast_field_copier_func) { if (field->is_null()) diff --git a/sql/item.h b/sql/item.h index 3bf1fd1113c..38bbd6edcd5 100644 --- a/sql/item.h +++ b/sql/item.h @@ -3438,7 +3438,7 @@ public: DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII) { } Item_string_ascii(THD *thd, const char *str): - Item_string(thd, str, strlen(str), &my_charset_latin1, + Item_string(thd, str, (uint)strlen(str), &my_charset_latin1, DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII) { } }; diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc index da50bd13352..9a8a158f9e6 100644 --- a/sql/item_cmpfunc.cc +++ b/sql/item_cmpfunc.cc @@ -3744,7 +3744,7 @@ uchar *in_row::get_value(Item *item) void in_row::set(uint pos, Item *item) { DBUG_ENTER("in_row::set"); - DBUG_PRINT("enter", ("pos: %u item: 0x%lx", pos, (ulong) item)); + DBUG_PRINT("enter", ("pos: %u item: %p", pos,item)); ((cmp_item_row*) base)[pos].store_value_by_template(current_thd, &tmp, item); DBUG_VOID_RETURN; } @@ -3909,7 +3909,7 @@ cmp_item* cmp_item_row::make_same() cmp_item_row::~cmp_item_row() { DBUG_ENTER("~cmp_item_row"); - DBUG_PRINT("enter",("this: 0x%lx", (long) this)); + DBUG_PRINT("enter",("this: %p", this)); if (comparators) { for (uint i= 0; i < n; i++) diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc index 191380b38b1..29433be4af8 100644 --- a/sql/item_subselect.cc +++ b/sql/item_subselect.cc @@ -58,7 +58,7 @@ Item_subselect::Item_subselect(THD *thd_arg): changed(0), is_correlated(FALSE), with_recursive_reference(0) { DBUG_ENTER("Item_subselect::Item_subselect"); - DBUG_PRINT("enter", ("this: 0x%lx", (ulong) this)); + DBUG_PRINT("enter", ("this: %p", this)); sortbuffer.str= 0; #ifndef DBUG_OFF @@ -84,8 +84,8 @@ void Item_subselect::init(st_select_lex *select_lex, */ DBUG_ENTER("Item_subselect::init"); - DBUG_PRINT("enter", ("select_lex: 0x%lx this: 0x%lx", - (ulong) select_lex, (ulong) this)); + DBUG_PRINT("enter", ("select_lex: %p this: %p", + select_lex, this)); unit= select_lex->master_unit(); if (unit->item) @@ -130,7 +130,7 @@ void Item_subselect::init(st_select_lex *select_lex, /* The subquery is an expression cache candidate */ upper->expr_cache_may_be_used[upper->parsing_place]= TRUE; } - DBUG_PRINT("info", ("engine: 0x%lx", (ulong)engine)); + DBUG_PRINT("info", ("engine: %p", engine)); DBUG_VOID_RETURN; } @@ -215,7 +215,7 @@ void Item_allany_subselect::cleanup() Item_subselect::~Item_subselect() { DBUG_ENTER("Item_subselect::~Item_subselect"); - DBUG_PRINT("enter", ("this: 0x%lx", (ulong) this)); + DBUG_PRINT("enter", ("this: %p", this)); if (own_engine) delete engine; else diff --git a/sql/log.cc b/sql/log.cc index de501d94100..a249f102dbd 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -5611,8 +5611,8 @@ int THD::binlog_write_table_map(TABLE *table, bool is_transactional, { int error; DBUG_ENTER("THD::binlog_write_table_map"); - DBUG_PRINT("enter", ("table: 0x%lx (%s: #%lu)", - (long) table, table->s->table_name.str, + DBUG_PRINT("enter", ("table: %p (%s: #%lu)", + table, table->s->table_name.str, table->s->table_map_id)); /* Ensure that all events in a GTID group are in the same cache */ @@ -5763,7 +5763,7 @@ MYSQL_BIN_LOG::flush_and_set_pending_rows_event(THD *thd, { DBUG_ENTER("MYSQL_BIN_LOG::flush_and_set_pending_rows_event(event)"); DBUG_ASSERT(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()); - DBUG_PRINT("enter", ("event: 0x%lx", (long) event)); + DBUG_PRINT("enter", ("event: %p", event)); int error= 0; binlog_cache_mngr *const cache_mngr= @@ -5774,7 +5774,7 @@ MYSQL_BIN_LOG::flush_and_set_pending_rows_event(THD *thd, binlog_cache_data *cache_data= cache_mngr->get_binlog_cache_data(use_trans_cache(thd, is_transactional)); - DBUG_PRINT("info", ("cache_mngr->pending(): 0x%lx", (long) cache_data->pending())); + DBUG_PRINT("info", ("cache_mngr->pending(): %p", cache_data->pending())); if (Rows_log_event* pending= cache_data->pending()) { diff --git a/sql/log_event.cc b/sql/log_event.cc index b4fdd9eb8e7..19bb3a51671 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -2427,9 +2427,9 @@ void Log_event::print_header(IO_CACHE* file, if (checksum_alg != BINLOG_CHECKSUM_ALG_OFF && checksum_alg != BINLOG_CHECKSUM_ALG_UNDEF) { - char checksum_buf[BINLOG_CHECKSUM_LEN * 2 + 4]; // to fit to "0x%lx " + char checksum_buf[BINLOG_CHECKSUM_LEN * 2 + 4]; // to fit to "%p " size_t const bytes_written= - my_snprintf(checksum_buf, sizeof(checksum_buf), "0x%08lx ", (ulong) crc); + my_snprintf(checksum_buf, sizeof(checksum_buf), "0x%08x ", crc); my_b_printf(file, "%s ", get_type(&binlog_checksum_typelib, checksum_alg)); my_b_printf(file, checksum_buf, bytes_written); } @@ -4345,8 +4345,8 @@ Query_log_event::Query_log_event(const char* buf, uint event_len, break; } case Q_CATALOG_NZ_CODE: - DBUG_PRINT("info", ("case Q_CATALOG_NZ_CODE; pos: 0x%lx; end: 0x%lx", - (ulong) pos, (ulong) end)); + DBUG_PRINT("info", ("case Q_CATALOG_NZ_CODE; pos:%p; end:%p", + pos, end)); if (get_str_len_and_pointer(&pos, &catalog, &catalog_len, end)) { DBUG_PRINT("info", ("query= 0")); @@ -10456,7 +10456,7 @@ int Rows_log_event::do_add_row_data(uchar *row_data, size_t length) would save binlog space. TODO */ DBUG_ENTER("Rows_log_event::do_add_row_data"); - DBUG_PRINT("enter", ("row_data: 0x%lx length: %lu", (ulong) row_data, + DBUG_PRINT("enter", ("row_data:%p length: %lu", row_data, (ulong) length)); /* @@ -10836,8 +10836,8 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi) table= m_table= rgi->m_table_map.get_table(m_table_id); - DBUG_PRINT("debug", ("m_table: 0x%lx, m_table_id: %lu%s", - (ulong) m_table, m_table_id, + DBUG_PRINT("debug", ("m_table:%p, m_table_id: %lu%s", + m_table, m_table_id, table && master_had_triggers ? " (master had triggers)" : "")); if (table) @@ -10957,8 +10957,8 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi) m_curr_row_end. */ - DBUG_PRINT("info", ("curr_row: 0x%lu; curr_row_end: 0x%lu; rows_end: 0x%lu", - (ulong) m_curr_row, (ulong) m_curr_row_end, (ulong) m_rows_end)); + DBUG_PRINT("info", ("curr_row: %p; curr_row_end: %p; rows_end:%p", + m_curr_row, m_curr_row_end, m_rows_end)); if (!m_curr_row_end && !error) error= unpack_current_row(rgi); diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc index 8f1cfe17656..36c4a3867b2 100644 --- a/sql/log_event_old.cc +++ b/sql/log_event_old.cc @@ -364,10 +364,10 @@ copy_extra_record_fields(TABLE *table, my_ptrdiff_t master_fields) { DBUG_ENTER("copy_extra_record_fields(table, master_reclen, master_fields)"); - DBUG_PRINT("info", ("Copying to 0x%lx " + DBUG_PRINT("info", ("Copying to %p " "from field %lu at offset %lu " "to field %d at offset %lu", - (long) table->record[0], + table->record[0], (ulong) master_fields, (ulong) master_reclength, table->s->fields, table->s->reclength)); /* @@ -625,8 +625,8 @@ replace_record(THD *thd, TABLE *table, static int find_and_fetch_row(TABLE *table, uchar *key) { DBUG_ENTER("find_and_fetch_row(TABLE *table, uchar *key, uchar *record)"); - DBUG_PRINT("enter", ("table: 0x%lx, key: 0x%lx record: 0x%lx", - (long) table, (long) key, (long) table->record[1])); + DBUG_PRINT("enter", ("table: %p, key: %p record: %p", + table, key, table->record[1])); DBUG_ASSERT(table->in_use != NULL); @@ -1254,8 +1254,8 @@ Old_rows_log_event::Old_rows_log_event(const char *buf, uint event_len, const uchar* const ptr_rows_data= (const uchar*) ptr_after_width; size_t const data_size= event_len - (ptr_rows_data - (const uchar *) buf); - DBUG_PRINT("info",("m_table_id: %lu m_flags: %d m_width: %lu data_size: %lu", - m_table_id, m_flags, m_width, (ulong) data_size)); + DBUG_PRINT("info",("m_table_id: %lu m_flags: %d m_width: %lu data_size: %zu", + m_table_id, m_flags, m_width, data_size)); DBUG_DUMP("rows_data", (uchar*) ptr_rows_data, data_size); m_rows_buf= (uchar*) my_malloc(data_size, MYF(MY_WME)); @@ -1310,8 +1310,8 @@ int Old_rows_log_event::do_add_row_data(uchar *row_data, size_t length) would save binlog space. TODO */ DBUG_ENTER("Old_rows_log_event::do_add_row_data"); - DBUG_PRINT("enter", ("row_data: 0x%lx length: %lu", (ulong) row_data, - (ulong) length)); + DBUG_PRINT("enter", ("row_data: %p length: %zu",row_data, + length)); /* Don't print debug messages when running valgrind since they can trigger false warnings. @@ -1599,8 +1599,8 @@ int Old_rows_log_event::do_apply_event(rpl_group_info *rgi) */ DBUG_PRINT("info", ("error: %d", error)); - DBUG_PRINT("info", ("curr_row: 0x%lu; curr_row_end: 0x%lu; rows_end: 0x%lu", - (ulong) m_curr_row, (ulong) m_curr_row_end, (ulong) m_rows_end)); + DBUG_PRINT("info", ("curr_row: %p; curr_row_end:%p; rows_end: %p", + m_curr_row, m_curr_row_end, m_rows_end)); if (!m_curr_row_end && !error) unpack_current_row(rgi); diff --git a/sql/mysqld.cc b/sql/mysqld.cc index e552d0b05a6..05e25d99e13 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -1594,8 +1594,8 @@ static void close_connections(void) /* kill connection thread */ #if !defined(__WIN__) - DBUG_PRINT("quit", ("waiting for select thread: 0x%lx", - (ulong) select_thread)); + DBUG_PRINT("quit", ("waiting for select thread: %lu", + (ulong)select_thread)); mysql_mutex_lock(&LOCK_start_thread); while (select_thread_in_use) @@ -2893,7 +2893,7 @@ void signal_thd_deleted() void unlink_thd(THD *thd) { DBUG_ENTER("unlink_thd"); - DBUG_PRINT("enter", ("thd: 0x%lx", (long) thd)); + DBUG_PRINT("enter", ("thd: %p", thd)); /* Do not decrement when its wsrep system thread. wsrep_applier is set for @@ -4848,7 +4848,7 @@ static void init_ssl() opt_ssl_ca, opt_ssl_capath, opt_ssl_cipher, &error, opt_ssl_crl, opt_ssl_crlpath); - DBUG_PRINT("info",("ssl_acceptor_fd: 0x%lx", (long) ssl_acceptor_fd)); + DBUG_PRINT("info",("ssl_acceptor_fd: %p", ssl_acceptor_fd)); if (!ssl_acceptor_fd) { sql_print_warning("Failed to setup SSL"); diff --git a/sql/opt_range.cc b/sql/opt_range.cc index c15810ba686..f8f1d0a3efd 100644 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@ -1321,7 +1321,7 @@ QUICK_RANGE_SELECT::~QUICK_RANGE_SELECT() file->ha_end_keyread(); if (free_file) { - DBUG_PRINT("info", ("Freeing separate handler 0x%lx (free: %d)", (long) file, + DBUG_PRINT("info", ("Freeing separate handler %p (free: %d)", file, free_file)); file->ha_external_lock(current_thd, F_UNLCK); file->ha_close(); @@ -1483,7 +1483,7 @@ int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler, in_ror_merged_scan= 1; if (reuse_handler) { - DBUG_PRINT("info", ("Reusing handler 0x%lx", (long) file)); + DBUG_PRINT("info", ("Reusing handler %p", file)); if (init()) { DBUG_RETURN(1); @@ -10217,7 +10217,7 @@ void SEL_ARG::test_use_count(SEL_ARG *root) ulong count=count_key_part_usage(root,pos->next_key_part); if (count > pos->next_key_part->use_count) { - sql_print_information("Use_count: Wrong count for key at 0x%lx, %lu " + sql_print_information("Use_count: Wrong count for key at %p, %lu " "should be %lu", (long unsigned int)pos, pos->next_key_part->use_count, count); return; @@ -10226,7 +10226,7 @@ void SEL_ARG::test_use_count(SEL_ARG *root) } } if (e_count != elements) - sql_print_warning("Wrong use count: %u (should be %u) for tree at 0x%lx", + sql_print_warning("Wrong use count: %u (should be %u) for tree at %p", e_count, elements, (long unsigned int) this); } #endif @@ -14612,7 +14612,7 @@ static void print_sel_tree(PARAM *param, SEL_TREE *tree, key_map *tree_map, if (!tmp.length()) tmp.append(STRING_WITH_LEN("(empty)")); - DBUG_PRINT("info", ("SEL_TREE: 0x%lx (%s) scans: %s", (long) tree, msg, + DBUG_PRINT("info", ("SEL_TREE: %p (%s) scans: %s", tree, msg, tmp.c_ptr_safe())); DBUG_VOID_RETURN; diff --git a/sql/parse_file.cc b/sql/parse_file.cc index 1cd294c1c7a..8f3e26d5e03 100644 --- a/sql/parse_file.cc +++ b/sql/parse_file.cc @@ -258,9 +258,9 @@ sql_create_definition_file(const LEX_STRING *dir, const LEX_STRING *file_name, int path_end; File_option *param; DBUG_ENTER("sql_create_definition_file"); - DBUG_PRINT("enter", ("Dir: %s, file: %s, base 0x%lx", + DBUG_PRINT("enter", ("Dir: %s, file: %s, base %p", dir ? dir->str : "", - file_name->str, (ulong) base)); + file_name->str, base)); if (dir) { diff --git a/sql/rpl_record.cc b/sql/rpl_record.cc index 0ef13c2cbb7..44d407e0a60 100644 --- a/sql/rpl_record.cc +++ b/sql/rpl_record.cc @@ -105,10 +105,10 @@ pack_row(TABLE *table, MY_BITMAP const* cols, #endif pack_ptr= field->pack(pack_ptr, field->ptr + offset, field->max_data_length()); - DBUG_PRINT("debug", ("field: %s; real_type: %d, pack_ptr: 0x%lx;" - " pack_ptr':0x%lx; bytes: %d", + DBUG_PRINT("debug", ("field: %s; real_type: %d, pack_ptr: %p;" + " pack_ptr':%p; bytes: %d", field->field_name, field->real_type(), - (ulong) old_pack_ptr, (ulong) pack_ptr, + old_pack_ptr,pack_ptr, (int) (pack_ptr - old_pack_ptr))); DBUG_DUMP("packed_data", old_pack_ptr, pack_ptr - old_pack_ptr); } @@ -322,9 +322,9 @@ unpack_row(rpl_group_info *rgi, pack_ptr= f->unpack(f->ptr, pack_ptr, row_end, metadata); DBUG_PRINT("debug", ("field: %s; metadata: 0x%x;" - " pack_ptr: 0x%lx; pack_ptr': 0x%lx; bytes: %d", + " pack_ptr: %p; pack_ptr': %p; bytes: %d", f->field_name, metadata, - (ulong) old_pack_ptr, (ulong) pack_ptr, + old_pack_ptr, pack_ptr, (int) (pack_ptr - old_pack_ptr))); if (!pack_ptr) { @@ -336,8 +336,8 @@ unpack_row(rpl_group_info *rgi, Galera Node throws "Could not read field" error and drops out of cluster */ WSREP_WARN("ROW event unpack field: %s metadata: 0x%x;" - " pack_ptr: 0x%lx; conv_table %p conv_field %p table %s" - " row_end: 0x%lx", + " pack_ptr: %p; conv_table %p conv_field %p table %s" + " row_end: %p", f->field_name, metadata, (ulong) old_pack_ptr, conv_table, conv_field, (table_found) ? "found" : "not found", (ulong)row_end diff --git a/sql/rpl_tblmap.cc b/sql/rpl_tblmap.cc index 4c521cf0c16..48111bc5d0a 100644 --- a/sql/rpl_tblmap.cc +++ b/sql/rpl_tblmap.cc @@ -66,8 +66,8 @@ TABLE* table_mapping::get_table(ulong table_id) entry *e= find_entry(table_id); if (e) { - DBUG_PRINT("info", ("tid %lu -> table 0x%lx (%s)", - table_id, (long) e->table, + DBUG_PRINT("info", ("tid %lu -> table %p (%s)", + table_id, e->table, MAYBE_TABLE_NAME(e->table))); DBUG_RETURN(e->table); } @@ -105,9 +105,9 @@ int table_mapping::expand() int table_mapping::set_table(ulong table_id, TABLE* table) { DBUG_ENTER("table_mapping::set_table(ulong,TABLE*)"); - DBUG_PRINT("enter", ("table_id: %lu table: 0x%lx (%s)", + DBUG_PRINT("enter", ("table_id: %lu table: %p (%s)", table_id, - (long) table, MAYBE_TABLE_NAME(table))); + table, MAYBE_TABLE_NAME(table))); entry *e= find_entry(table_id); if (e == 0) { @@ -133,8 +133,8 @@ int table_mapping::set_table(ulong table_id, TABLE* table) DBUG_RETURN(ERR_MEMORY_ALLOCATION); } - DBUG_PRINT("info", ("tid %lu -> table 0x%lx (%s)", - table_id, (long) e->table, + DBUG_PRINT("info", ("tid %lu -> table %p (%s)", + table_id, e->table, MAYBE_TABLE_NAME(e->table))); DBUG_RETURN(0); // All OK } diff --git a/sql/slave.cc b/sql/slave.cc index 828f74772ef..3fb28b587a6 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -3462,11 +3462,11 @@ sql_delay_event(Log_event *ev, THD *thd, rpl_group_info *rgi) "ev->when= %lu " "rli->mi->clock_diff_with_master= %lu " "now= %ld " - "sql_delay_end= %lu " + "sql_delay_end= %llu " "nap_time= %ld", sql_delay, (long)ev->when, rli->mi->clock_diff_with_master, - (long)now, sql_delay_end, (long)nap_time)); + (long)now, (ulonglong)sql_delay_end, (long)nap_time)); if (sql_delay_end > now) { diff --git a/sql/sp.cc b/sql/sp.cc index a31b2a2cfc5..fcbf4dc43d4 100644 --- a/sql/sp.cc +++ b/sql/sp.cc @@ -1754,11 +1754,11 @@ sp_find_routine(THD *thd, stored_procedure_type type, sp_name *name, String retstr(64); retstr.set_charset(sp->get_creation_ctx()->get_client_cs()); - DBUG_PRINT("info", ("found: 0x%lx", (ulong)sp)); + DBUG_PRINT("info", ("found:%p", sp)); if (sp->m_first_free_instance) { - DBUG_PRINT("info", ("first free: 0x%lx level: %lu flags %x", - (ulong)sp->m_first_free_instance, + DBUG_PRINT("info", ("first free:%p level: %lu flags %x", + sp->m_first_free_instance, sp->m_first_free_instance->m_recursion_level, sp->m_first_free_instance->m_flags)); DBUG_ASSERT(!(sp->m_first_free_instance->m_flags & sp_head::IS_INVOKED)); @@ -1798,8 +1798,8 @@ sp_find_routine(THD *thd, stored_procedure_type type, sp_name *name, new_sp->m_recursion_level= level; new_sp->m_first_instance= sp; sp->m_last_cached_sp= sp->m_first_free_instance= new_sp; - DBUG_PRINT("info", ("added level: 0x%lx, level: %lu, flags %x", - (ulong)new_sp, new_sp->m_recursion_level, + DBUG_PRINT("info", ("added level:%p, level: %lu, flags %x", + new_sp, new_sp->m_recursion_level, new_sp->m_flags)); DBUG_RETURN(new_sp); } @@ -1810,8 +1810,8 @@ sp_find_routine(THD *thd, stored_procedure_type type, sp_name *name, if (db_find_routine(thd, type, name, &sp) == SP_OK) { sp_cache_insert(cp, sp); - DBUG_PRINT("info", ("added new: 0x%lx, level: %lu, flags %x", - (ulong)sp, sp->m_recursion_level, + DBUG_PRINT("info", ("added new:%p, level: %lu, flags %x", + sp, sp->m_recursion_level, sp->m_flags)); } } diff --git a/sql/sp_head.cc b/sql/sp_head.cc index 473e1929369..b3edcdca474 100644 --- a/sql/sp_head.cc +++ b/sql/sp_head.cc @@ -549,7 +549,7 @@ sp_head::operator new(size_t size) throw() if (sp == NULL) DBUG_RETURN(NULL); sp->main_mem_root= own_root; - DBUG_PRINT("info", ("mem_root 0x%lx", (ulong) &sp->mem_root)); + DBUG_PRINT("info", ("mem_root %p", &sp->mem_root)); DBUG_RETURN(sp); } @@ -566,8 +566,8 @@ sp_head::operator delete(void *ptr, size_t size) throw() /* Make a copy of main_mem_root as free_root will free the sp */ own_root= sp->main_mem_root; - DBUG_PRINT("info", ("mem_root 0x%lx moved to 0x%lx", - (ulong) &sp->mem_root, (ulong) &own_root)); + DBUG_PRINT("info", ("mem_root %p moved to %p", + &sp->mem_root, &own_root)); free_root(&own_root, MYF(0)); DBUG_VOID_RETURN; @@ -1154,9 +1154,9 @@ sp_head::execute(THD *thd, bool merge_da_on_success) if (m_next_cached_sp) { DBUG_PRINT("info", - ("first free for 0x%lx ++: 0x%lx->0x%lx level: %lu flags %x", - (ulong)m_first_instance, (ulong) this, - (ulong) m_next_cached_sp, + ("first free for %p ++: %p->%p level: %lu flags %x", + m_first_instance, this, + m_next_cached_sp, m_next_cached_sp->m_recursion_level, m_next_cached_sp->m_flags)); } @@ -1454,10 +1454,10 @@ sp_head::execute(THD *thd, bool merge_da_on_success) } m_flags&= ~IS_INVOKED; DBUG_PRINT("info", - ("first free for 0x%lx --: 0x%lx->0x%lx, level: %lu, flags %x", - (ulong) m_first_instance, - (ulong) m_first_instance->m_first_free_instance, - (ulong) this, m_recursion_level, m_flags)); + ("first free for %p --: %p->%p, level: %lu, flags %x", + m_first_instance, + m_first_instance->m_first_free_instance, + this, m_recursion_level, m_flags)); /* Check that we have one of following: @@ -2346,8 +2346,8 @@ sp_head::backpatch(sp_label *lab) { if (bp->lab == lab) { - DBUG_PRINT("info", ("backpatch: (m_ip %d, label 0x%lx <%s>) to dest %d", - bp->instr->m_ip, (ulong) lab, lab->name.str, dest)); + DBUG_PRINT("info", ("backpatch: (m_ip %d, label %p <%s>) to dest %d", + bp->instr->m_ip, lab, lab->name.str, dest)); bp->instr->backpatch(dest, lab->ctx); } } @@ -2483,8 +2483,8 @@ sp_head::reset_thd_mem_root(THD *thd) DBUG_ENTER("sp_head::reset_thd_mem_root"); m_thd_root= thd->mem_root; thd->mem_root= &main_mem_root; - DBUG_PRINT("info", ("mem_root 0x%lx moved to thd mem root 0x%lx", - (ulong) &mem_root, (ulong) &thd->mem_root)); + DBUG_PRINT("info", ("mem_root %p moved to thd mem root %p", + &mem_root, &thd->mem_root)); free_list= thd->free_list; // Keep the old list thd->free_list= NULL; // Start a new one m_thd= thd; @@ -2514,8 +2514,8 @@ sp_head::restore_thd_mem_root(THD *thd) set_query_arena(thd); // Get new free_list and mem_root state= STMT_INITIALIZED_FOR_SP; - DBUG_PRINT("info", ("mem_root 0x%lx returned from thd mem root 0x%lx", - (ulong) &mem_root, (ulong) &thd->mem_root)); + DBUG_PRINT("info", ("mem_root %p returned from thd mem root %p", + &mem_root, &thd->mem_root)); thd->free_list= flist; // Restore the old one thd->mem_root= m_thd_root; m_thd= NULL; diff --git a/sql/sql_admin.cc b/sql/sql_admin.cc index 95c2163f043..fcbcd5d31bf 100644 --- a/sql/sql_admin.cc +++ b/sql/sql_admin.cc @@ -585,7 +585,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables, } } #endif - DBUG_PRINT("admin", ("table: 0x%lx", (long) table->table)); + DBUG_PRINT("admin", ("table: %p", table->table)); if (prepare_func) { diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 5ecb897b295..22bb837e6c0 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -716,8 +716,8 @@ void close_thread_tables(THD *thd) #ifdef EXTRA_DEBUG DBUG_PRINT("tcache", ("open tables:")); for (table= thd->open_tables; table; table= table->next) - DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str, - table->s->table_name.str, (long) table)); + DBUG_PRINT("tcache", ("table: '%s'.'%s' %p", table->s->db.str, + table->s->table_name.str, table)); #endif #if defined(ENABLED_DEBUG_SYNC) @@ -857,8 +857,8 @@ void close_thread_table(THD *thd, TABLE **table_ptr) { TABLE *table= *table_ptr; DBUG_ENTER("close_thread_table"); - DBUG_PRINT("tcache", ("table: '%s'.'%s' 0x%lx", table->s->db.str, - table->s->table_name.str, (long) table)); + DBUG_PRINT("tcache", ("table: '%s'.'%s' %p", table->s->db.str, + table->s->table_name.str, table)); DBUG_ASSERT(!table->file->keyread_enabled()); DBUG_ASSERT(!table->file || table->file->inited == handler::NONE); @@ -1192,8 +1192,8 @@ bool wait_while_table_is_used(THD *thd, TABLE *table, { DBUG_ENTER("wait_while_table_is_used"); DBUG_ASSERT(!table->s->tmp_table); - DBUG_PRINT("enter", ("table: '%s' share: 0x%lx db_stat: %u version: %lu", - table->s->table_name.str, (ulong) table->s, + DBUG_PRINT("enter", ("table: '%s' share: %p db_stat: %u version: %lu", + table->s->table_name.str, table->s, table->db_stat, table->s->tdc->version)); if (thd->mdl_context.upgrade_shared_lock( @@ -5188,8 +5188,8 @@ find_field_in_view(THD *thd, TABLE_LIST *table_list, { DBUG_ENTER("find_field_in_view"); DBUG_PRINT("enter", - ("view: '%s', field name: '%s', item name: '%s', ref 0x%lx", - table_list->alias, name, item_name, (ulong) ref)); + ("view: '%s', field name: '%s', item name: '%s', ref %p", + table_list->alias, name, item_name, ref)); Field_iterator_view field_it; field_it.set(table_list); Query_arena *arena= 0, backup; @@ -5290,8 +5290,8 @@ find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name, Field *UNINIT_VAR(found_field); Query_arena *UNINIT_VAR(arena), backup; DBUG_ENTER("find_field_in_natural_join"); - DBUG_PRINT("enter", ("field name: '%s', ref 0x%lx", - name, (ulong) ref)); + DBUG_PRINT("enter", ("field name: '%s', ref %p", + name, ref)); DBUG_ASSERT(table_ref->is_natural_join && table_ref->join_columns); DBUG_ASSERT(*actual_table == NULL); @@ -5521,8 +5521,8 @@ find_field_in_table_ref(THD *thd, TABLE_LIST *table_list, DBUG_ASSERT(name); DBUG_ASSERT(item_name); DBUG_PRINT("enter", - ("table: '%s' field name: '%s' item name: '%s' ref 0x%lx", - table_list->alias, name, item_name, (ulong) ref)); + ("table: '%s' field name: '%s' item name: '%s' ref %p", + table_list->alias, name, item_name, ref)); /* Check that the table and database that qualify the current field name @@ -7412,7 +7412,7 @@ insert_fields(THD *thd, Name_resolution_context *context, const char *db_name, bool found; char name_buff[SAFE_NAME_LEN+1]; DBUG_ENTER("insert_fields"); - DBUG_PRINT("arena", ("stmt arena: 0x%lx", (ulong)thd->stmt_arena)); + DBUG_PRINT("arena", ("stmt arena: %p",thd->stmt_arena)); if (db_name && lower_case_table_names) { diff --git a/sql/sql_binlog.cc b/sql/sql_binlog.cc index 5f554a3cd92..f58bcf2e8fe 100644 --- a/sql/sql_binlog.cc +++ b/sql/sql_binlog.cc @@ -192,8 +192,8 @@ void mysql_client_binlog_statement(THD* thd) since it will read from unassigned memory. */ DBUG_PRINT("info", - ("bytes_decoded: %d strptr: 0x%lx endptr: 0x%lx ('%c':%d)", - bytes_decoded, (long) strptr, (long) endptr, *endptr, + ("bytes_decoded: %d strptr: %p endptr: %p ('%c':%d)", + bytes_decoded, strptr, endptr, *endptr, *endptr)); #endif diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc index b43b6af96e1..d68bf72aedc 100644 --- a/sql/sql_cache.cc +++ b/sql/sql_cache.cc @@ -356,27 +356,27 @@ const uchar *query_state_map; #endif #if defined(EXTRA_DEBUG) && !defined(DBUG_OFF) -#define RW_WLOCK(M) {DBUG_PRINT("lock", ("rwlock wlock 0x%lx",(ulong)(M))); \ +#define RW_WLOCK(M) {DBUG_PRINT("lock", ("rwlock wlock %p",(M))); \ if (!mysql_rwlock_wrlock(M)) DBUG_PRINT("lock", ("rwlock wlock ok")); \ else DBUG_PRINT("lock", ("rwlock wlock FAILED %d", errno)); } -#define RW_RLOCK(M) {DBUG_PRINT("lock", ("rwlock rlock 0x%lx", (ulong)(M))); \ +#define RW_RLOCK(M) {DBUG_PRINT("lock", ("rwlock rlock %p",(M))); \ if (!mysql_rwlock_rdlock(M)) DBUG_PRINT("lock", ("rwlock rlock ok")); \ else DBUG_PRINT("lock", ("rwlock wlock FAILED %d", errno)); } -#define RW_UNLOCK(M) {DBUG_PRINT("lock", ("rwlock unlock 0x%lx",(ulong)(M))); \ +#define RW_UNLOCK(M) {DBUG_PRINT("lock", ("rwlock unlock %p",(M))); \ if (!mysql_rwlock_unlock(M)) DBUG_PRINT("lock", ("rwlock unlock ok")); \ else DBUG_PRINT("lock", ("rwlock unlock FAILED %d", errno)); } -#define BLOCK_LOCK_WR(B) {DBUG_PRINT("lock", ("%d LOCK_WR 0x%lx",\ - __LINE__,(ulong)(B))); \ +#define BLOCK_LOCK_WR(B) {DBUG_PRINT("lock", ("%d LOCK_WR %p",\ + __LINE__,(B))); \ B->query()->lock_writing();} -#define BLOCK_LOCK_RD(B) {DBUG_PRINT("lock", ("%d LOCK_RD 0x%lx",\ - __LINE__,(ulong)(B))); \ +#define BLOCK_LOCK_RD(B) {DBUG_PRINT("lock", ("%d LOCK_RD %p",\ + __LINE__,(B))); \ B->query()->lock_reading();} #define BLOCK_UNLOCK_WR(B) { \ - DBUG_PRINT("lock", ("%d UNLOCK_WR 0x%lx",\ - __LINE__,(ulong)(B)));B->query()->unlock_writing();} + DBUG_PRINT("lock", ("%d UNLOCK_WR %p",\ + __LINE__,(B)));B->query()->unlock_writing();} #define BLOCK_UNLOCK_RD(B) { \ - DBUG_PRINT("lock", ("%d UNLOCK_RD 0x%lx",\ - __LINE__,(ulong)(B)));B->query()->unlock_reading();} + DBUG_PRINT("lock", ("%d UNLOCK_RD %p",\ + __LINE__,(B)));B->query()->unlock_reading();} #define DUMP(C) DBUG_EXECUTE("qcache", {\ (C)->cache_dump(); (C)->queries_dump();(C)->tables_dump();}) #else @@ -647,7 +647,7 @@ bool Query_cache::try_lock(THD *thd, Cache_try_lock_mode mode) else if (mode == TIMEOUT) { struct timespec waittime; - set_timespec_nsec(waittime,(ulong)(50000000L)); /* Wait for 50 msec */ + set_timespec_nsec(waittime,50000000UL); /* Wait for 50 msec */ int res= mysql_cond_timedwait(&COND_cache_status_changed, &structure_guard_mutex, &waittime); if (res == ETIMEDOUT) @@ -821,7 +821,7 @@ inline Query_cache_block * Query_cache_block_table::block() void Query_cache_block::init(ulong block_length) { DBUG_ENTER("Query_cache_block::init"); - DBUG_PRINT("qcache", ("init block: 0x%lx length: %lu", (ulong) this, + DBUG_PRINT("qcache", ("init block: %p length: %lu", this, block_length)); length = block_length; used = 0; @@ -833,8 +833,8 @@ void Query_cache_block::init(ulong block_length) void Query_cache_block::destroy() { DBUG_ENTER("Query_cache_block::destroy"); - DBUG_PRINT("qcache", ("destroy block 0x%lx, type %d", - (ulong) this, type)); + DBUG_PRINT("qcache", ("destroy block %p, type %d", + this, type)); type = INCOMPLETE; DBUG_VOID_RETURN; } @@ -936,7 +936,7 @@ bool Query_cache_query::try_lock_writing() DBUG_PRINT("info", ("can't lock rwlock")); DBUG_RETURN(0); } - DBUG_PRINT("info", ("rwlock 0x%lx locked", (ulong) &lock)); + DBUG_PRINT("info", ("rwlock %p locked", &lock)); DBUG_RETURN(1); } @@ -965,9 +965,9 @@ void Query_cache_query::init_n_lock() res=0; wri = 0; len = 0; ready= 0; mysql_rwlock_init(key_rwlock_query_cache_query_lock, &lock); lock_writing(); - DBUG_PRINT("qcache", ("inited & locked query for block 0x%lx", - (long) (((uchar*) this) - - ALIGN_SIZE(sizeof(Query_cache_block))))); + DBUG_PRINT("qcache", ("inited & locked query for block %p", + (uchar*) this - + ALIGN_SIZE(sizeof(Query_cache_block)))); DBUG_VOID_RETURN; } @@ -975,9 +975,9 @@ void Query_cache_query::init_n_lock() void Query_cache_query::unlock_n_destroy() { DBUG_ENTER("Query_cache_query::unlock_n_destroy"); - DBUG_PRINT("qcache", ("destroyed & unlocked query for block 0x%lx", - (long) (((uchar*) this) - - ALIGN_SIZE(sizeof(Query_cache_block))))); + DBUG_PRINT("qcache", ("destroyed & unlocked query for block %p", + (uchar*) this - + ALIGN_SIZE(sizeof(Query_cache_block)))); /* The following call is not needed on system where one can destroy an active semaphore @@ -1110,7 +1110,7 @@ Query_cache::insert(THD *thd, Query_cache_tls *query_cache_tls, { DBUG_PRINT("warning", ("Can't append data")); header->result(result); - DBUG_PRINT("qcache", ("free query 0x%lx", (ulong) query_block)); + DBUG_PRINT("qcache", ("free query %p", query_block)); // The following call will remove the lock on query_block query_cache.free_query(query_block); query_cache.refused++; @@ -1446,7 +1446,7 @@ void Query_cache::store_query(THD *thd, TABLE_LIST *tables_used) flags.default_week_format= thd->variables.default_week_format; DBUG_PRINT("qcache", ("\ long %d, 4.1: %d, eof: %d, bin_proto: %d, more results %d, pkt_nr: %d, \ -CS client: %u, CS result: %u, CS conn: %u, limit: %lu, TZ: 0x%lx, \ +CS client: %u, CS result: %u, CS conn: %u, limit: %llu, TZ: %p, \ sql mode: 0x%llx, sort len: %lu, conncat len: %lu, div_precision: %lu, \ def_week_frmt: %lu, in_trans: %d, autocommit: %d", (int)flags.client_long_flag, @@ -1458,8 +1458,8 @@ def_week_frmt: %lu, in_trans: %d, autocommit: %d", flags.character_set_client_num, flags.character_set_results_num, flags.collation_connection_num, - (ulong) flags.limit, - (ulong) flags.time_zone, + (ulonglong)flags.limit, + flags.time_zone, flags.sql_mode, flags.max_sort_length, flags.group_concat_max_len, @@ -1522,7 +1522,7 @@ def_week_frmt: %lu, in_trans: %d, autocommit: %d", /* Check if another thread is processing the same query? */ Query_cache_block *competitor = (Query_cache_block *) my_hash_search(&queries, (uchar*) query, tot_length); - DBUG_PRINT("qcache", ("competitor 0x%lx", (ulong) competitor)); + DBUG_PRINT("qcache", ("competitor %p", competitor)); if (competitor == 0) { /* Query is not in cache and no one is working with it; Store it */ @@ -1532,8 +1532,8 @@ def_week_frmt: %lu, in_trans: %d, autocommit: %d", Query_cache_block::QUERY, local_tables); if (query_block != 0) { - DBUG_PRINT("qcache", ("query block 0x%lx allocated, %lu", - (ulong) query_block, query_block->used)); + DBUG_PRINT("qcache", ("query block %p allocated, %lu", + query_block, query_block->used)); Query_cache_query *header = query_block->query(); header->init_n_lock(); @@ -1944,7 +1944,7 @@ Query_cache::send_result_to_client(THD *thd, char *org_sql, uint query_length) flags.lc_time_names= thd->variables.lc_time_names; DBUG_PRINT("qcache", ("\ long %d, 4.1: %d, eof: %d, bin_proto: %d, more results %d, pkt_nr: %d, \ -CS client: %u, CS result: %u, CS conn: %u, limit: %lu, TZ: 0x%lx, \ +CS client: %u, CS result: %u, CS conn: %u, limit: %llu, TZ: %p, \ sql mode: 0x%llx, sort len: %lu, conncat len: %lu, div_precision: %lu, \ def_week_frmt: %lu, in_trans: %d, autocommit: %d", (int)flags.client_long_flag, @@ -1956,8 +1956,8 @@ def_week_frmt: %lu, in_trans: %d, autocommit: %d", flags.character_set_client_num, flags.character_set_results_num, flags.collation_connection_num, - (ulong) flags.limit, - (ulong) flags.time_zone, + (ulonglong) flags.limit, + flags.time_zone, flags.sql_mode, flags.max_sort_length, flags.group_concat_max_len, @@ -1984,7 +1984,7 @@ lookup: DBUG_PRINT("qcache", ("No query in query hash or no results")); goto err_unlock; } - DBUG_PRINT("qcache", ("Query in query hash 0x%lx", (ulong)query_block)); + DBUG_PRINT("qcache", ("Query in query hash %p",query_block)); #ifdef WITH_WSREP if (once_more && WSREP_CLIENT(thd) && wsrep_must_sync_wait(thd)) @@ -2015,7 +2015,7 @@ lookup: BLOCK_UNLOCK_RD(query_block); goto err_unlock; } - DBUG_PRINT("qcache", ("Query have result 0x%lx", (ulong) query)); + DBUG_PRINT("qcache", ("Query have result %p", query)); if (thd->in_multi_stmt_transaction_mode() && (query->tables_type() & HA_CACHE_TBL_TRANSACT)) @@ -2112,9 +2112,9 @@ lookup: if (engine_data != table->engine_data()) { DBUG_PRINT("qcache", - ("Handler require invalidation queries of %.*s %lu-%lu", + ("Handler require invalidation queries of %.*s %llu-%llu", qcache_se_key_len, qcache_se_key_name, - (ulong) engine_data, (ulong) table->engine_data())); + engine_data, table->engine_data())); invalidate_table_internal(thd, (uchar *) table->db(), table->key_length()); @@ -2152,9 +2152,9 @@ lookup: THD_STAGE_INFO(thd, stage_sending_cached_result_to_client); do { - DBUG_PRINT("qcache", ("Results (len: %lu used: %lu headers: %lu)", + DBUG_PRINT("qcache", ("Results (len: %lu used: %lu headers: %u)", result_block->length, result_block->used, - (ulong) (result_block->headers_len()+ + (uint) (result_block->headers_len()+ ALIGN_SIZE(sizeof(Query_cache_result))))); Query_cache_result *result = result_block->result(); @@ -2192,7 +2192,7 @@ lookup: thd->get_stmt_da()->disable_status(); BLOCK_UNLOCK_RD(query_block); - MYSQL_QUERY_CACHE_HIT(thd->query(), (ulong) thd->limit_found_rows); + MYSQL_QUERY_CACHE_HIT(thd->query(), thd->limit_found_rows); DBUG_RETURN(1); // Result sent to client err_unlock: @@ -2899,8 +2899,8 @@ my_bool Query_cache::free_old_query() void Query_cache::free_query_internal(Query_cache_block *query_block) { DBUG_ENTER("Query_cache::free_query_internal"); - DBUG_PRINT("qcache", ("free query 0x%lx %lu bytes result", - (ulong) query_block, + DBUG_PRINT("qcache", ("free query %p %lu bytes result", + query_block, query_block->query()->length() )); queries_in_cache--; @@ -2969,8 +2969,8 @@ void Query_cache::free_query_internal(Query_cache_block *query_block) void Query_cache::free_query(Query_cache_block *query_block) { DBUG_ENTER("Query_cache::free_query"); - DBUG_PRINT("qcache", ("free query 0x%lx %lu bytes result", - (ulong) query_block, + DBUG_PRINT("qcache", ("free query %p %lu bytes result", + query_block, query_block->query()->length() )); my_hash_delete(&queries,(uchar *) query_block); @@ -3017,8 +3017,8 @@ Query_cache::append_result_data(Query_cache_block **current_block, Query_cache_block *query_block) { DBUG_ENTER("Query_cache::append_result_data"); - DBUG_PRINT("qcache", ("append %lu bytes to 0x%lx query", - data_len, (long) query_block)); + DBUG_PRINT("qcache", ("append %lu bytes to %p query", + data_len, query_block)); if (query_block->query()->add(data_len) > query_cache_limit) { @@ -3035,8 +3035,8 @@ Query_cache::append_result_data(Query_cache_block **current_block, } Query_cache_block *last_block = (*current_block)->prev; - DBUG_PRINT("qcache", ("lastblock 0x%lx len %lu used %lu", - (ulong) last_block, last_block->length, + DBUG_PRINT("qcache", ("lastblock %p len %lu used %lu", + last_block, last_block->length, last_block->used)); my_bool success = 1; ulong last_block_free_space= last_block->length - last_block->used; @@ -3081,8 +3081,8 @@ Query_cache::append_result_data(Query_cache_block **current_block, if (success && last_block_free_space > 0) { ulong to_copy = MY_MIN(data_len,last_block_free_space); - DBUG_PRINT("qcache", ("use free space %lub at block 0x%lx to copy %lub", - last_block_free_space, (ulong)last_block, to_copy)); + DBUG_PRINT("qcache", ("use free space %lub at block %p to copy %lub", + last_block_free_space,last_block, to_copy)); memcpy((uchar*) last_block + last_block->used, data, to_copy); last_block->used+=to_copy; } @@ -3123,8 +3123,8 @@ my_bool Query_cache::write_result_data(Query_cache_block **result_block, { block->type = type; ulong length = block->used - headers_len; - DBUG_PRINT("qcache", ("write %lu byte in block 0x%lx",length, - (ulong)block)); + DBUG_PRINT("qcache", ("write %lu byte in block %p",length, + block)); memcpy((uchar*) block+headers_len, rest, length); rest += length; block = block->next; @@ -3387,12 +3387,12 @@ Query_cache::register_tables_from_list(THD *thd, TABLE_LIST *tables_used, else { DBUG_PRINT("qcache", - ("table: %s db: %s openinfo: 0x%lx keylen: %lu key: 0x%lx", + ("table: %s db: %s openinfo: %p keylen: %zu key: %p", tables_used->table->s->table_name.str, tables_used->table->s->table_cache_key.str, - (ulong) tables_used->table, - (ulong) tables_used->table->s->table_cache_key.length, - (ulong) tables_used->table->s->table_cache_key.str)); + tables_used->table, + tables_used->table->s->table_cache_key.length, + tables_used->table->s->table_cache_key.str)); if (!insert_table(thd, tables_used->table->s->table_cache_key.length, tables_used->table->s->table_cache_key.str, @@ -3429,8 +3429,8 @@ my_bool Query_cache::register_all_tables(THD *thd, TABLE_COUNTER_TYPE tables_arg) { TABLE_COUNTER_TYPE n; - DBUG_PRINT("qcache", ("register tables block 0x%lx, n %d, header %x", - (ulong) block, (int) tables_arg, + DBUG_PRINT("qcache", ("register tables block %p, n %d, header %x", + block, (int) tables_arg, (int) ALIGN_SIZE(sizeof(Query_cache_block)))); Query_cache_block_table *block_table = block->table(0); @@ -3469,8 +3469,8 @@ Query_cache::insert_table(THD *thd, uint key_len, const char *key, my_bool hash) { DBUG_ENTER("Query_cache::insert_table"); - DBUG_PRINT("qcache", ("insert table node 0x%lx, len %d", - (ulong)node, key_len)); + DBUG_PRINT("qcache", ("insert table node %p, len %d", + node, key_len)); Query_cache_block *table_block= (hash ? @@ -3481,11 +3481,11 @@ Query_cache::insert_table(THD *thd, uint key_len, const char *key, table_block->table()->engine_data() != engine_data) { DBUG_PRINT("qcache", - ("Handler require invalidation queries of %s.%s %lu-%lu", + ("Handler require invalidation queries of %s.%s %llu-%llu", table_block->table()->db(), table_block->table()->table(), - (ulong) engine_data, - (ulong) table_block->table()->engine_data())); + engine_data, + table_block->table()->engine_data())); /* as far as we delete all queries with this table, table block will be deleted, too @@ -3500,8 +3500,8 @@ Query_cache::insert_table(THD *thd, uint key_len, const char *key, if (table_block == 0) { - DBUG_PRINT("qcache", ("new table block from 0x%lx (%u)", - (ulong) key, (int) key_len)); + DBUG_PRINT("qcache", ("new table block from %p (%u)", + key, (int) key_len)); table_block= write_block_data(key_len, (uchar*) key, ALIGN_SIZE(sizeof(Query_cache_table)), Query_cache_block::TABLE, 1); @@ -3710,7 +3710,7 @@ Query_cache::get_free_block(ulong len, my_bool not_less, ulong min) if (block != 0) exclude_from_free_memory_list(block); - DBUG_PRINT("qcache",("getting block 0x%lx", (ulong) block)); + DBUG_PRINT("qcache",("getting block %p", block)); DBUG_RETURN(block); } @@ -3721,9 +3721,9 @@ void Query_cache::free_memory_block(Query_cache_block *block) block->used=0; block->type= Query_cache_block::FREE; // mark block as free in any case DBUG_PRINT("qcache", - ("first_block 0x%lx, block 0x%lx, pnext 0x%lx pprev 0x%lx", - (ulong) first_block, (ulong) block, (ulong) block->pnext, - (ulong) block->pprev)); + ("first_block %p, block %p, pnext %p pprev %p", + first_block, block, block->pnext, + block->pprev)); if (block->pnext != first_block && block->pnext->is_free()) block = join_free_blocks(block, block->pnext); @@ -3755,8 +3755,8 @@ void Query_cache::split_block(Query_cache_block *block, ulong len) else free_memory_block(new_block); - DBUG_PRINT("qcache", ("split 0x%lx (%lu) new 0x%lx", - (ulong) block, len, (ulong) new_block)); + DBUG_PRINT("qcache", ("split %p (%lu) new %p", + block, len, new_block)); DBUG_VOID_RETURN; } @@ -3768,9 +3768,9 @@ Query_cache::join_free_blocks(Query_cache_block *first_block_arg, Query_cache_block *second_block; DBUG_ENTER("Query_cache::join_free_blocks"); DBUG_PRINT("qcache", - ("join first 0x%lx, pnext 0x%lx, in list 0x%lx", - (ulong) first_block_arg, (ulong) first_block_arg->pnext, - (ulong) block_in_list)); + ("join first %p, pnext %p, in list %p", + first_block_arg, first_block_arg->pnext, + block_in_list)); exclude_from_free_memory_list(block_in_list); second_block = first_block_arg->pnext; @@ -3792,7 +3792,7 @@ my_bool Query_cache::append_next_free_block(Query_cache_block *block, { Query_cache_block *next_block = block->pnext; DBUG_ENTER("Query_cache::append_next_free_block"); - DBUG_PRINT("enter", ("block 0x%lx, add_size %lu", (ulong) block, + DBUG_PRINT("enter", ("block %p, add_size %lu", block, add_size)); if (next_block != first_block && next_block->is_free()) @@ -3824,8 +3824,8 @@ void Query_cache::exclude_from_free_memory_list(Query_cache_block *free_block) bin->number--; free_memory-=free_block->length; free_memory_blocks--; - DBUG_PRINT("qcache",("exclude block 0x%lx, bin 0x%lx", (ulong) free_block, - (ulong) bin)); + DBUG_PRINT("qcache",("exclude block %p, bin %p", free_block, + bin)); DBUG_VOID_RETURN; } @@ -3842,8 +3842,8 @@ void Query_cache::insert_into_free_memory_list(Query_cache_block *free_block) free_block->data()); *bin_ptr = bins+idx; (*bin_ptr)->number++; - DBUG_PRINT("qcache",("insert block 0x%lx, bin[%d] 0x%lx", - (ulong) free_block, idx, (ulong) *bin_ptr)); + DBUG_PRINT("qcache",("insert block %p, bin[%d] %p", + free_block, idx, *bin_ptr)); DBUG_VOID_RETURN; } @@ -3940,7 +3940,7 @@ Query_cache::double_linked_list_simple_include(Query_cache_block *point, list_pointer) { DBUG_ENTER("Query_cache::double_linked_list_simple_include"); - DBUG_PRINT("qcache", ("including block 0x%lx", (ulong) point)); + DBUG_PRINT("qcache", ("including block %p", point)); if (*list_pointer == 0) *list_pointer=point->next=point->prev=point; else @@ -3959,8 +3959,8 @@ Query_cache::double_linked_list_exclude(Query_cache_block *point, Query_cache_block **list_pointer) { DBUG_ENTER("Query_cache::double_linked_list_exclude"); - DBUG_PRINT("qcache", ("excluding block 0x%lx, list 0x%lx", - (ulong) point, (ulong) list_pointer)); + DBUG_PRINT("qcache", ("excluding block %p, list %p", + point, list_pointer)); if (point->next == point) *list_pointer = 0; // empty list else @@ -4255,7 +4255,7 @@ my_bool Query_cache::move_by_type(uchar **border, switch (block->type) { case Query_cache_block::FREE: { - DBUG_PRINT("qcache", ("block 0x%lx FREE", (ulong) block)); + DBUG_PRINT("qcache", ("block %p FREE", block)); if (*border == 0) { *border = (uchar *) block; @@ -4274,7 +4274,7 @@ my_bool Query_cache::move_by_type(uchar **border, case Query_cache_block::TABLE: { HASH_SEARCH_STATE record_idx; - DBUG_PRINT("qcache", ("block 0x%lx TABLE", (ulong) block)); + DBUG_PRINT("qcache", ("block %p TABLE", block)); if (*border == 0) break; ulong len = block->length, used = block->used; @@ -4310,9 +4310,9 @@ my_bool Query_cache::move_by_type(uchar **border, nlist_root->prev = tprev; tprev->next = nlist_root; DBUG_PRINT("qcache", - ("list_root: 0x%lx tnext 0x%lx tprev 0x%lx tprev->next 0x%lx tnext->prev 0x%lx", - (ulong) list_root, (ulong) tnext, (ulong) tprev, - (ulong)tprev->next, (ulong)tnext->prev)); + ("list_root: %p tnext %p tprev %p tprev->next %p tnext->prev %p", + list_root, tnext, tprev, + tprev->next,tnext->prev)); /* Go through all queries that uses this table and change them to point to the new table object @@ -4327,14 +4327,14 @@ my_bool Query_cache::move_by_type(uchar **border, /* Fix hash to point at moved block */ my_hash_replace(&tables, &record_idx, (uchar*) new_block); - DBUG_PRINT("qcache", ("moved %lu bytes to 0x%lx, new gap at 0x%lx", - len, (ulong) new_block, (ulong) *border)); + DBUG_PRINT("qcache", ("moved %lu bytes to %p, new gap at %p", + len, new_block, *border)); break; } case Query_cache_block::QUERY: { HASH_SEARCH_STATE record_idx; - DBUG_PRINT("qcache", ("block 0x%lx QUERY", (ulong) block)); + DBUG_PRINT("qcache", ("block %p QUERY", block)); if (*border == 0) break; BLOCK_LOCK_WR(block); @@ -4420,8 +4420,8 @@ my_bool Query_cache::move_by_type(uchar **border, } /* Fix hash to point at moved block */ my_hash_replace(&queries, &record_idx, (uchar*) new_block); - DBUG_PRINT("qcache", ("moved %lu bytes to 0x%lx, new gap at 0x%lx", - len, (ulong) new_block, (ulong) *border)); + DBUG_PRINT("qcache", ("moved %lu bytes to %p, new gap at %p", + len, new_block, *border)); break; } case Query_cache_block::RES_INCOMPLETE: @@ -4429,7 +4429,7 @@ my_bool Query_cache::move_by_type(uchar **border, case Query_cache_block::RES_CONT: case Query_cache_block::RESULT: { - DBUG_PRINT("qcache", ("block 0x%lx RES* (%d)", (ulong) block, + DBUG_PRINT("qcache", ("block %p RES* (%d)", block, (int) block->type)); if (*border == 0) break; @@ -4469,13 +4469,13 @@ my_bool Query_cache::move_by_type(uchar **border, new_block->length -= free_space; } BLOCK_UNLOCK_WR(query_block); - DBUG_PRINT("qcache", ("moved %lu bytes to 0x%lx, new gap at 0x%lx", - len, (ulong) new_block, (ulong) *border)); + DBUG_PRINT("qcache", ("moved %lu bytes to %p, new gap at %p", + len, new_block, *border)); break; } default: - DBUG_PRINT("error", ("unexpected block type %d, block 0x%lx", - (int)block->type, (ulong) block)); + DBUG_PRINT("error", ("unexpected block type %d, block %p", + (int)block->type, block)); ok = 0; } DBUG_RETURN(ok); @@ -4676,16 +4676,16 @@ void Query_cache::bins_dump() DBUG_PRINT("qcache", ("-------------------------")); for (i=0; i < mem_bin_num; i++) { - DBUG_PRINT("qcache", ("%10lu %3d 0x%lx", bins[i].size, bins[i].number, - (ulong)&(bins[i]))); + DBUG_PRINT("qcache", ("%10lu %3d %p", bins[i].size, bins[i].number, + &(bins[i]))); if (bins[i].free_blocks) { Query_cache_block *block = bins[i].free_blocks; do{ - DBUG_PRINT("qcache", ("\\-- %lu 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx", - block->length, (ulong)block, - (ulong)block->next, (ulong)block->prev, - (ulong)block->pnext, (ulong)block->pprev)); + DBUG_PRINT("qcache", ("\\-- %lu %p %p %p %p %p", + block->length,block, + block->next,block->prev, + block->pnext,block->pprev)); block = block->next; } while ( block != bins[i].free_blocks ); } @@ -4709,11 +4709,11 @@ void Query_cache::cache_dump() do { DBUG_PRINT("qcache", - ("%10lu %10lu %1d %2d 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx", + ("%10lu %10lu %1d %2d %p %p %p %p %p", i->length, i->used, (int)i->type, - i->n_tables, (ulong)i, - (ulong)i->next, (ulong)i->prev, (ulong)i->pnext, - (ulong)i->pprev)); + i->n_tables,i, + i->next,i->prev,i->pnext, + i->pprev)); i = i->pnext; } while ( i != first_block ); DBUG_PRINT("qcache", ("-------------------------------------")); @@ -4743,15 +4743,15 @@ void Query_cache::queries_dump() Query_cache_query_flags flags; memcpy(&flags, str+len, QUERY_CACHE_FLAGS_SIZE); str[len]= 0; // make zero ending DB name - DBUG_PRINT("qcache", ("F: %u C: %u L: %lu T: '%s' (%lu) '%s' '%s'", + DBUG_PRINT("qcache", ("F: %u C: %u L: %llu T: '%s' (%zu) '%s' '%s'", flags.client_long_flag, flags.character_set_client_num, - (ulong)flags.limit, + flags.limit, flags.time_zone->get_name()->ptr(), - (ulong) len, str, strend(str)+1)); - DBUG_PRINT("qcache", ("-b- 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx", (ulong) block, - (ulong) block->next, (ulong) block->prev, - (ulong)block->pnext, (ulong)block->pprev)); + len, str, strend(str)+1)); + DBUG_PRINT("qcache", ("-b- %p %p %p %p %p", block, + block->next, block->prev, + block->pnext,block->pprev)); memcpy(str + len, &flags, QUERY_CACHE_FLAGS_SIZE); // restore flags for (TABLE_COUNTER_TYPE t= 0; t < block->n_tables; t++) { @@ -4765,14 +4765,14 @@ void Query_cache::queries_dump() Query_cache_block *result_beg = result_block; do { - DBUG_PRINT("qcache", ("-r- %u %lu/%lu 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx", + DBUG_PRINT("qcache", ("-r- %u %lu/%lu %p %p %p %p %p", (uint) result_block->type, result_block->length, result_block->used, - (ulong) result_block, - (ulong) result_block->next, - (ulong) result_block->prev, - (ulong) result_block->pnext, - (ulong) result_block->pprev)); + result_block, + result_block->next, + result_block->prev, + result_block->pnext, + result_block->pprev)); result_block = result_block->next; } while ( result_block != result_beg ); } @@ -4851,14 +4851,14 @@ my_bool Query_cache::check_integrity(bool locked) if (!block) break; - DBUG_PRINT("qcache", ("block 0x%lx, type %u...", - (ulong) block, (uint) block->type)); + DBUG_PRINT("qcache", ("block %p, type %u...", + block, (uint) block->type)); // Check allignment - if ((((long)block) % (long) ALIGN_SIZE(1)) != - (((long)first_block) % (long)ALIGN_SIZE(1))) + if ((((size_t)block) % ALIGN_SIZE(1)) != + (((size_t)first_block) % ALIGN_SIZE(1))) { DBUG_PRINT("error", - ("block 0x%lx do not aligned by %d", (ulong) block, + ("block %p do not aligned by %d", block, (int) ALIGN_SIZE(1))); result = 1; } @@ -4869,10 +4869,10 @@ my_bool Query_cache::check_integrity(bool locked) ((uchar*)first_block) + query_cache_size) { DBUG_PRINT("error", - ("block 0x%lx, type %u, ended at 0x%lx, but cache ended at 0x%lx", - (ulong) block, (uint) block->type, - (ulong) (((uchar*)block) + block->length), - (ulong) (((uchar*)first_block) + query_cache_size))); + ("block %p, type %u, ended at %p, but cache ended at %p", + block, (uint) block->type, + (((uchar*)block) + block->length), + (((uchar*)first_block) + query_cache_size))); result = 1; } } @@ -4880,10 +4880,10 @@ my_bool Query_cache::check_integrity(bool locked) if (((uchar*)block) + block->length != ((uchar*)block->pnext)) { DBUG_PRINT("error", - ("block 0x%lx, type %u, ended at 0x%lx, but next block beginning at 0x%lx", - (ulong) block, (uint) block->type, - (ulong) (((uchar*)block) + block->length), - (ulong) ((uchar*)block->pnext))); + ("block %p, type %u, ended at %p, but next block beginning at %p", + block, (uint) block->type, + (((uchar*)block) + block->length), + ((uchar*)block->pnext))); } if (block->type == Query_cache_block::FREE) free+= block->length; @@ -4899,11 +4899,11 @@ my_bool Query_cache::check_integrity(bool locked) ((uchar*)bin) >= ((uchar*)first_block)) { DBUG_PRINT("error", - ("free block 0x%lx have bin pointer 0x%lx beyaond of bins array bounds [0x%lx,0x%lx]", - (ulong) block, - (ulong) bin, - (ulong) bins, - (ulong) first_block)); + ("free block %p have bin pointer %p beyaond of bins array bounds [%p,%p]", + block, + bin, + bins, + first_block)); result = 1; } else @@ -4950,11 +4950,11 @@ my_bool Query_cache::check_integrity(bool locked) ((uchar*)query_block) >= (((uchar*)first_block) + query_cache_size)) { DBUG_PRINT("error", - ("result block 0x%lx have query block pointer 0x%lx beyaond of block pool bounds [0x%lx,0x%lx]", - (ulong) block, - (ulong) query_block, - (ulong) first_block, - (ulong) (((uchar*)first_block) + query_cache_size))); + ("result block %p have query block pointer %p beyaond of block pool bounds [%p,%p]", + block, + query_block, + first_block, + (((uchar*)first_block) + query_cache_size))); result = 1; } else @@ -4970,8 +4970,8 @@ my_bool Query_cache::check_integrity(bool locked) break; } default: - DBUG_PRINT("error", ("block 0x%lx have incorrect type %u", - (long) block, block->type)); + DBUG_PRINT("error", ("block %p have incorrect type %u", + block, block->type)); result = 1; } @@ -4999,15 +4999,15 @@ my_bool Query_cache::check_integrity(bool locked) { do { - DBUG_PRINT("qcache", ("block 0x%lx, type %u...", - (ulong) block, (uint) block->type)); + DBUG_PRINT("qcache", ("block %p, type %u...", + block, (uint) block->type)); size_t length; uchar *key = query_cache_query_get_key((uchar*) block, &length, 0); uchar* val = my_hash_search(&queries, key, length); if (((uchar*)block) != val) { - DBUG_PRINT("error", ("block 0x%lx found in queries hash like 0x%lx", - (ulong) block, (ulong) val)); + DBUG_PRINT("error", ("block %p found in queries hash like %p", + block, val)); } if (in_blocks(block)) result = 1; @@ -5017,8 +5017,8 @@ my_bool Query_cache::check_integrity(bool locked) Query_cache_block * result_block = results; do { - DBUG_PRINT("qcache", ("block 0x%lx, type %u...", - (ulong) block, (uint) block->type)); + DBUG_PRINT("qcache", ("block %p, type %u...", + block, (uint) block->type)); if (in_blocks(result_block)) result = 1; @@ -5034,15 +5034,15 @@ my_bool Query_cache::check_integrity(bool locked) { do { - DBUG_PRINT("qcache", ("block 0x%lx, type %u...", - (ulong) block, (uint) block->type)); + DBUG_PRINT("qcache", ("block %p, type %u...", + block, (uint) block->type)); size_t length; uchar *key = query_cache_table_get_key((uchar*) block, &length, 0); uchar* val = my_hash_search(&tables, key, length); if (((uchar*)block) != val) { - DBUG_PRINT("error", ("block 0x%lx found in tables hash like 0x%lx", - (ulong) block, (ulong) val)); + DBUG_PRINT("error", ("block %p found in tables hash like %p", + block, val)); } if (in_blocks(block)) @@ -5059,8 +5059,8 @@ my_bool Query_cache::check_integrity(bool locked) uint count = 0; do { - DBUG_PRINT("qcache", ("block 0x%lx, type %u...", - (ulong) block, (uint) block->type)); + DBUG_PRINT("qcache", ("block %p, type %u...", + block, (uint) block->type)); if (in_blocks(block)) result = 1; @@ -5092,13 +5092,13 @@ my_bool Query_cache::in_blocks(Query_cache_block * point) if (block->pprev->pnext != block) { DBUG_PRINT("error", - ("block 0x%lx in physical list is incorrect linked, prev block 0x%lx refered as next to 0x%lx (check from 0x%lx)", - (ulong) block, (ulong) block->pprev, - (ulong) block->pprev->pnext, - (ulong) point)); + ("block %p in physical list is incorrect linked, prev block %p refered as next to %p (check from %p)", + block, block->pprev, + block->pprev->pnext, + point)); //back trace for (; block != point; block = block->pnext) - DBUG_PRINT("error", ("back trace 0x%lx", (ulong) block)); + DBUG_PRINT("error", ("back trace %p", block)); result = 1; goto err1; } @@ -5107,8 +5107,8 @@ my_bool Query_cache::in_blocks(Query_cache_block * point) if (block != first_block) { DBUG_PRINT("error", - ("block 0x%lx (0x%lx<-->0x%lx) not owned by pysical list", - (ulong) block, (ulong) block->pprev, (ulong )block->pnext)); + ("block %p (%p<-->%p) not owned by pysical list", + block, block->pprev, block->pnext)); return 1; } @@ -5120,13 +5120,13 @@ err1: if (block->pnext->pprev != block) { DBUG_PRINT("error", - ("block 0x%lx in physicel list is incorrect linked, next block 0x%lx refered as prev to 0x%lx (check from 0x%lx)", - (ulong) block, (ulong) block->pnext, - (ulong) block->pnext->pprev, - (ulong) point)); + ("block %p in physicel list is incorrect linked, next block %p refered as prev to %p (check from %p)", + block, block->pnext, + block->pnext->pprev, + point)); //back trace for (; block != point; block = block->pprev) - DBUG_PRINT("error", ("back trace 0x%lx", (ulong) block)); + DBUG_PRINT("error", ("back trace %p", block)); result = 1; goto err2; } @@ -5149,13 +5149,13 @@ my_bool Query_cache::in_list(Query_cache_block * root, if (block->prev->next != block) { DBUG_PRINT("error", - ("block 0x%lx in list '%s' 0x%lx is incorrect linked, prev block 0x%lx refered as next to 0x%lx (check from 0x%lx)", - (ulong) block, name, (ulong) root, (ulong) block->prev, - (ulong) block->prev->next, - (ulong) point)); + ("block %p in list '%s' %p is incorrect linked, prev block %p refered as next to %p (check from %p)", + block, name, root, block->prev, + block->prev->next, + point)); //back trace for (; block != point; block = block->next) - DBUG_PRINT("error", ("back trace 0x%lx", (ulong) block)); + DBUG_PRINT("error", ("back trace %p", block)); result = 1; goto err1; } @@ -5164,10 +5164,10 @@ my_bool Query_cache::in_list(Query_cache_block * root, if (block != root) { DBUG_PRINT("error", - ("block 0x%lx (0x%lx<-->0x%lx) not owned by list '%s' 0x%lx", - (ulong) block, - (ulong) block->prev, (ulong) block->next, - name, (ulong) root)); + ("block %p (%p<-->%p) not owned by list '%s' %p", + block, + block->prev, block->next, + name, root)); return 1; } err1: @@ -5178,13 +5178,13 @@ err1: if (block->next->prev != block) { DBUG_PRINT("error", - ("block 0x%lx in list '%s' 0x%lx is incorrect linked, next block 0x%lx refered as prev to 0x%lx (check from 0x%lx)", - (ulong) block, name, (ulong) root, (ulong) block->next, - (ulong) block->next->prev, - (ulong) point)); + ("block %p in list '%s' %p is incorrect linked, next block %p refered as prev to %p (check from %p)", + block, name, root, block->next, + block->next->prev, + point)); //back trace for (; block != point; block = block->prev) - DBUG_PRINT("error", ("back trace 0x%lx", (ulong) block)); + DBUG_PRINT("error", ("back trace %p", block)); result = 1; goto err2; } @@ -5197,13 +5197,13 @@ err2: void dump_node(Query_cache_block_table * node, const char * call, const char * descr) { - DBUG_PRINT("qcache", ("%s: %s: node: 0x%lx", call, descr, (ulong) node)); - DBUG_PRINT("qcache", ("%s: %s: node block: 0x%lx", - call, descr, (ulong) node->block())); - DBUG_PRINT("qcache", ("%s: %s: next: 0x%lx", call, descr, - (ulong) node->next)); - DBUG_PRINT("qcache", ("%s: %s: prev: 0x%lx", call, descr, - (ulong) node->prev)); + DBUG_PRINT("qcache", ("%s: %s: node: %p", call, descr, node)); + DBUG_PRINT("qcache", ("%s: %s: node block: %p", + call, descr, node->block())); + DBUG_PRINT("qcache", ("%s: %s: next: %p", call, descr, + node->next)); + DBUG_PRINT("qcache", ("%s: %s: prev: %p", call, descr, + node->prev)); } my_bool Query_cache::in_table_list(Query_cache_block_table * root, @@ -5220,17 +5220,17 @@ my_bool Query_cache::in_table_list(Query_cache_block_table * root, if (table->prev->next != table) { DBUG_PRINT("error", - ("table 0x%lx(0x%lx) in list '%s' 0x%lx(0x%lx) is incorrect linked, prev table 0x%lx(0x%lx) refered as next to 0x%lx(0x%lx) (check from 0x%lx(0x%lx))", - (ulong) table, (ulong) table->block(), name, - (ulong) root, (ulong) root->block(), - (ulong) table->prev, (ulong) table->prev->block(), - (ulong) table->prev->next, - (ulong) table->prev->next->block(), - (ulong) point, (ulong) point->block())); + ("table %p(%p) in list '%s' %p(%p) is incorrect linked, prev table %p(%p) refered as next to %p(%p) (check from %p(%p))", + table, table->block(), name, + root, root->block(), + table->prev, table->prev->block(), + table->prev->next, + table->prev->next->block(), + point, point->block())); //back trace for (; table != point; table = table->next) - DBUG_PRINT("error", ("back trace 0x%lx(0x%lx)", - (ulong) table, (ulong) table->block())); + DBUG_PRINT("error", ("back trace %p(%p)", + table, table->block())); result = 1; goto err1; } @@ -5239,11 +5239,11 @@ my_bool Query_cache::in_table_list(Query_cache_block_table * root, if (table != root) { DBUG_PRINT("error", - ("table 0x%lx(0x%lx) (0x%lx(0x%lx)<-->0x%lx(0x%lx)) not owned by list '%s' 0x%lx(0x%lx)", - (ulong) table, (ulong) table->block(), - (ulong) table->prev, (ulong) table->prev->block(), - (ulong) table->next, (ulong) table->next->block(), - name, (ulong) root, (ulong) root->block())); + ("table %p(%p) (%p(%p)<-->%p(%p)) not owned by list '%s' %p(%p)", + table, table->block(), + table->prev, table->prev->block(), + table->next, table->next->block(), + name, root, root->block())); return 1; } err1: @@ -5255,17 +5255,17 @@ err1: if (table->next->prev != table) { DBUG_PRINT("error", - ("table 0x%lx(0x%lx) in list '%s' 0x%lx(0x%lx) is incorrect linked, next table 0x%lx(0x%lx) refered as prev to 0x%lx(0x%lx) (check from 0x%lx(0x%lx))", - (ulong) table, (ulong) table->block(), - name, (ulong) root, (ulong) root->block(), - (ulong) table->next, (ulong) table->next->block(), - (ulong) table->next->prev, - (ulong) table->next->prev->block(), - (ulong) point, (ulong) point->block())); + ("table %p(%p) in list '%s' %p(%p) is incorrect linked, next table %p(%p) refered as prev to %p(%p) (check from %p(%p))", + table, table->block(), + name, root, root->block(), + table->next, table->next->block(), + table->next->prev, + table->next->prev->block(), + point, point->block())); //back trace for (; table != point; table = table->prev) - DBUG_PRINT("error", ("back trace 0x%lx(0x%lx)", - (ulong) table, (ulong) table->block())); + DBUG_PRINT("error", ("back trace %p(%p)", + table, table->block())); result = 1; goto err2; } diff --git a/sql/sql_class.cc b/sql/sql_class.cc index 82b2faf6a02..4d2cd46fda1 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -551,7 +551,7 @@ char *thd_get_error_context_description(THD *thd, char *buffer, const char *proc_info= thd->proc_info; len= my_snprintf(header, sizeof(header), - "MySQL thread id %lu, OS thread handle 0x%lx, query id %lu", + "MySQL thread id %lu, OS thread handle %lu, query id %lu", thd->thread_id, (ulong) thd->real_id, (ulong) thd->query_id); str.length(0); str.append(header, len); @@ -915,7 +915,7 @@ THD::THD(my_thread_id id, bool is_wsrep_applier) by adding the address of the stack. */ tmp= (ulong) (my_rnd(&sql_rand) * 0xffffffff); - my_rnd_init(&rand, tmp + (ulong) &rand, tmp + (ulong) ::global_query_id); + my_rnd_init(&rand, tmp + (ulong)((size_t) &rand), tmp + (ulong) ::global_query_id); substitute_null_with_insert_id = FALSE; lock_info.mysql_thd= (void *)this; @@ -3537,7 +3537,7 @@ void Query_arena::free_items() { next= free_list->next; DBUG_ASSERT(free_list != next); - DBUG_PRINT("info", ("free item: 0x%lx", (ulong) free_list)); + DBUG_PRINT("info", ("free item: %p", free_list)); free_list->delete_self(); } /* Postcondition: free_list is 0 */ @@ -3987,7 +3987,7 @@ int select_materialize_with_stats::send_data(List<Item> &items) void TMP_TABLE_PARAM::init() { DBUG_ENTER("TMP_TABLE_PARAM::init"); - DBUG_PRINT("enter", ("this: 0x%lx", (ulong)this)); + DBUG_PRINT("enter", ("this: %p", this)); field_count= sum_func_count= func_count= hidden_field_count= 0; group_parts= group_length= group_null_parts= 0; quick_group= 1; diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc index bc5007e0880..691592c25ea 100644 --- a/sql/sql_derived.cc +++ b/sql/sql_derived.cc @@ -641,7 +641,7 @@ bool mysql_derived_prepare(THD *thd, LEX *lex, TABLE_LIST *derived) SELECT_LEX_UNIT *unit= derived->get_unit(); DBUG_ENTER("mysql_derived_prepare"); bool res= FALSE; - DBUG_PRINT("enter", ("unit 0x%lx", (ulong) unit)); + DBUG_PRINT("enter", ("unit %p", unit)); if (!unit) DBUG_RETURN(FALSE); diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index 3a9bcf39555..a226ea17eb3 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -1470,8 +1470,8 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list, bool res= 0; table_map map= 0; DBUG_ENTER("mysql_prepare_insert"); - DBUG_PRINT("enter", ("table_list: 0x%lx table: 0x%lx view: %d", - (ulong)table_list, (ulong)table, + DBUG_PRINT("enter", ("table_list: %p table: %p view: %d", + table_list, table, (int)insert_into_view)); /* INSERT should have a SELECT or VALUES clause */ DBUG_ASSERT (!select_insert || !values); diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc index f9330bc4375..4d776671ee7 100644 --- a/sql/sql_lex.cc +++ b/sql/sql_lex.cc @@ -759,7 +759,7 @@ void lex_start(THD *thd) void lex_end(LEX *lex) { DBUG_ENTER("lex_end"); - DBUG_PRINT("enter", ("lex: 0x%lx", (long) lex)); + DBUG_PRINT("enter", ("lex: %p", lex)); lex_end_stage1(lex); lex_end_stage2(lex); @@ -2594,7 +2594,7 @@ bool st_select_lex::add_gorder_to_list(THD *thd, Item *item, bool asc) bool st_select_lex::add_item_to_list(THD *thd, Item *item) { DBUG_ENTER("st_select_lex::add_item_to_list"); - DBUG_PRINT("info", ("Item: 0x%lx", (long) item)); + DBUG_PRINT("info", ("Item: %p", item)); DBUG_RETURN(item_list.push_back(item, thd->mem_root)); } @@ -4657,9 +4657,9 @@ bool LEX::set_arena_for_set_stmt(Query_arena *backup) Query_arena_memroot(mem_root_for_set_stmt, Query_arena::STMT_INITIALIZED))) DBUG_RETURN(1); - DBUG_PRINT("info", ("mem_root: 0x%lx arena: 0x%lx", - (ulong) mem_root_for_set_stmt, - (ulong) arena_for_set_stmt)); + DBUG_PRINT("info", ("mem_root: %p arena: %p", + mem_root_for_set_stmt, + arena_for_set_stmt)); thd->set_n_backup_active_arena(arena_for_set_stmt, backup); DBUG_RETURN(0); } @@ -4670,9 +4670,9 @@ void LEX::reset_arena_for_set_stmt(Query_arena *backup) DBUG_ENTER("LEX::reset_arena_for_set_stmt"); DBUG_ASSERT(arena_for_set_stmt); thd->restore_active_arena(arena_for_set_stmt, backup); - DBUG_PRINT("info", ("mem_root: 0x%lx arena: 0x%lx", - (ulong) arena_for_set_stmt->mem_root, - (ulong) arena_for_set_stmt)); + DBUG_PRINT("info", ("mem_root: %p arena: %p", + arena_for_set_stmt->mem_root, + arena_for_set_stmt)); DBUG_VOID_RETURN; } @@ -4682,9 +4682,9 @@ void LEX::free_arena_for_set_stmt() DBUG_ENTER("LEX::free_arena_for_set_stmt"); if (!arena_for_set_stmt) return; - DBUG_PRINT("info", ("mem_root: 0x%lx arena: 0x%lx", - (ulong) arena_for_set_stmt->mem_root, - (ulong) arena_for_set_stmt)); + DBUG_PRINT("info", ("mem_root: %p arena: %p", + arena_for_set_stmt->mem_root, + arena_for_set_stmt)); arena_for_set_stmt->free_items(); delete(arena_for_set_stmt); free_root(mem_root_for_set_stmt, MYF(MY_KEEP_PREALLOC)); diff --git a/sql/sql_manager.cc b/sql/sql_manager.cc index 8cf849b97d0..8c8aee0cb03 100644 --- a/sql/sql_manager.cc +++ b/sql/sql_manager.cc @@ -159,7 +159,7 @@ void stop_handle_manager() if (manager_thread_in_use) { mysql_mutex_lock(&LOCK_manager); - DBUG_PRINT("quit", ("initiate shutdown of handle manager thread: 0x%lx", + DBUG_PRINT("quit", ("initiate shutdown of handle manager thread: %lu", (ulong)manager_thread)); mysql_cond_signal(&COND_manager); mysql_mutex_unlock(&LOCK_manager); diff --git a/sql/sql_partition.cc b/sql/sql_partition.cc index f29614ba864..6e4da0fbbf2 100644 --- a/sql/sql_partition.cc +++ b/sql/sql_partition.cc @@ -4884,7 +4884,7 @@ that are reorganised. { if (!alt_part_info->use_default_partitions) { - DBUG_PRINT("info", ("part_info: 0x%lx", (long) tab_part_info)); + DBUG_PRINT("info", ("part_info: %p", tab_part_info)); tab_part_info->use_default_partitions= FALSE; } tab_part_info->use_default_num_partitions= FALSE; diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc index 97ef24f44ed..eb18a5ba36f 100644 --- a/sql/sql_plugin.cc +++ b/sql/sql_plugin.cc @@ -775,7 +775,7 @@ static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report) if (global_system_variables.log_warnings > 2) { struct link_map *lm = (struct link_map*) plugin_dl.handle; - sql_print_information("Loaded '%s' with offset 0x%lx", dl->str, lm->l_addr); + sql_print_information("Loaded '%s' with offset 0x%zx", dl->str, (size_t)lm->l_addr); } #endif @@ -976,8 +976,8 @@ static plugin_ref intern_plugin_lock(LEX *lex, plugin_ref rc) *plugin= pi; #endif pi->ref_count++; - DBUG_PRINT("lock",("thd: 0x%lx plugin: \"%s\" LOCK ref_count: %d", - (long) current_thd, pi->name.str, pi->ref_count)); + DBUG_PRINT("lock",("thd: %p plugin: \"%s\" LOCK ref_count: %d", + current_thd, pi->name.str, pi->ref_count)); if (lex) insert_dynamic(&lex->plugins, (uchar*)&plugin); @@ -1338,8 +1338,8 @@ static void intern_plugin_unlock(LEX *lex, plugin_ref plugin) DBUG_ASSERT(pi->ref_count); pi->ref_count--; - DBUG_PRINT("lock",("thd: 0x%lx plugin: \"%s\" UNLOCK ref_count: %d", - (long) current_thd, pi->name.str, pi->ref_count)); + DBUG_PRINT("lock",("thd: %p plugin: \"%s\" UNLOCK ref_count: %d", + current_thd, pi->name.str, pi->ref_count)); if (pi->state == PLUGIN_IS_DELETED && !pi->ref_count) reap_needed= true; @@ -3243,8 +3243,8 @@ static void plugin_vars_free_values(sys_var *vars) { /* Free the string from global_system_variables. */ char **valptr= (char**) piv->real_value_ptr(NULL, OPT_GLOBAL); - DBUG_PRINT("plugin", ("freeing value for: '%s' addr: 0x%lx", - var->name.str, (long) valptr)); + DBUG_PRINT("plugin", ("freeing value for: '%s' addr: %p", + var->name.str, valptr)); my_free(*valptr); *valptr= NULL; } diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index c8ebbb08f15..6724346a490 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -3236,7 +3236,7 @@ void mysql_sql_stmt_execute(THD *thd) DBUG_VOID_RETURN; } - DBUG_PRINT("info",("stmt: 0x%lx", (long) stmt)); + DBUG_PRINT("info",("stmt: %p", stmt)); if (lex->prepared_stmt_params_fix_fields(thd)) DBUG_VOID_RETURN; @@ -3763,8 +3763,8 @@ void Prepared_statement::setup_set_params() Prepared_statement::~Prepared_statement() { DBUG_ENTER("Prepared_statement::~Prepared_statement"); - DBUG_PRINT("enter",("stmt: 0x%lx cursor: 0x%lx", - (long) this, (long) cursor)); + DBUG_PRINT("enter",("stmt: %p cursor: %p", + this, cursor)); delete cursor; /* We have to call free on the items even if cleanup is called as some items, @@ -3791,7 +3791,7 @@ Query_arena::Type Prepared_statement::type() const void Prepared_statement::cleanup_stmt() { DBUG_ENTER("Prepared_statement::cleanup_stmt"); - DBUG_PRINT("enter",("stmt: 0x%lx", (long) this)); + DBUG_PRINT("enter",("stmt: %p", this)); thd->restore_set_statement_var(); cleanup_items(free_list); thd->cleanup_after_query(); diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 326e87f9d91..513c02b99e4 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -10274,8 +10274,8 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond) tmp_cond= new (thd->mem_root) Item_func_trig_cond(thd, tmp_cond, &first_inner_tab-> not_null_compl); - DBUG_PRINT("info", ("Item_func_trig_cond 0x%lx", - (ulong) tmp_cond)); + DBUG_PRINT("info", ("Item_func_trig_cond %p", + tmp_cond)); if (tmp_cond) tmp_cond->quick_fix_field(); /* Add the predicate to other pushed down predicates */ @@ -10283,8 +10283,8 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond) *sel_cond_ref= !(*sel_cond_ref) ? tmp_cond : new (thd->mem_root) Item_cond_and(thd, *sel_cond_ref, tmp_cond); - DBUG_PRINT("info", ("Item_cond_and 0x%lx", - (ulong)(*sel_cond_ref))); + DBUG_PRINT("info", ("Item_cond_and %p", + (*sel_cond_ref))); if (!(*sel_cond_ref)) DBUG_RETURN(1); (*sel_cond_ref)->quick_fix_field(); @@ -20033,9 +20033,9 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)), Item *item= *group->item; if (group->fast_field_copier_setup != group->field) { - DBUG_PRINT("info", ("new setup 0x%lx -> 0x%lx", - (ulong)group->fast_field_copier_setup, - (ulong)group->field)); + DBUG_PRINT("info", ("new setup %p -> %p", + group->fast_field_copier_setup, + group->field)); group->fast_field_copier_setup= group->field; group->fast_field_copier_func= item->setup_fast_field_copier(group->field); @@ -24667,8 +24667,8 @@ int JOIN::save_explain_data_intern(Explain_query *output, JOIN *join= this; /* Legacy: this code used to be a non-member function */ int cur_error= 0; DBUG_ENTER("JOIN::save_explain_data_intern"); - DBUG_PRINT("info", ("Select 0x%lx, type %s, message %s", - (ulong)join->select_lex, join->select_lex->type, + DBUG_PRINT("info", ("Select %p, type %s, message %s", + join->select_lex, join->select_lex->type, message ? message : "NULL")); DBUG_ASSERT(have_query_plan == QEP_AVAILABLE); /* fake_select_lex is created/printed by Explain_union */ diff --git a/sql/sql_servers.cc b/sql/sql_servers.cc index 836b0563e23..ca721b9e366 100644 --- a/sql/sql_servers.cc +++ b/sql/sql_servers.cc @@ -350,8 +350,8 @@ get_server_from_table_to_cache(TABLE *table) DBUG_PRINT("info", ("server->socket %s", server->socket)); if (my_hash_insert(&servers_cache, (uchar*) server)) { - DBUG_PRINT("info", ("had a problem inserting server %s at %lx", - server->server_name, (long unsigned int) server)); + DBUG_PRINT("info", ("had a problem inserting server %s at %p", + server->server_name, server)); // error handling needed here DBUG_RETURN(TRUE); } @@ -431,13 +431,13 @@ insert_server_record_into_cache(FOREIGN_SERVER *server) We succeded in insertion of the server to the table, now insert the server to the cache */ - DBUG_PRINT("info", ("inserting server %s at %lx, length %d", - server->server_name, (long unsigned int) server, + DBUG_PRINT("info", ("inserting server %s at %p, length %d", + server->server_name, server, server->server_name_length)); if (my_hash_insert(&servers_cache, (uchar*) server)) { - DBUG_PRINT("info", ("had a problem inserting server %s at %lx", - server->server_name, (long unsigned int) server)); + DBUG_PRINT("info", ("had a problem inserting server %s at %p", + server->server_name, server)); // error handling needed here error= 1; } @@ -804,8 +804,8 @@ int update_server_record_in_cache(FOREIGN_SERVER *existing, */ if (my_hash_insert(&servers_cache, (uchar*)altered)) { - DBUG_PRINT("info", ("had a problem inserting server %s at %lx", - altered->server_name, (long unsigned int) altered)); + DBUG_PRINT("info", ("had a problem inserting server %s at %p", + altered->server_name,altered)); error= ER_OUT_OF_RESOURCES; } diff --git a/sql/sql_string.h b/sql/sql_string.h index 9a9fff8522c..1310819d2e3 100644 --- a/sql/sql_string.h +++ b/sql/sql_string.h @@ -466,8 +466,8 @@ public: } bool append(const String &s); bool append(const char *s); - bool append(const LEX_STRING *ls) { return append(ls->str, ls->length); } - bool append(const LEX_CSTRING *ls) { return append(ls->str, ls->length); } + bool append(const LEX_STRING *ls) { return append(ls->str, (uint32)ls->length); } + bool append(const LEX_CSTRING *ls) { return append(ls->str, (uint32)ls->length); } bool append(const char *s, uint32 arg_length); bool append(const char *s, uint32 arg_length, CHARSET_INFO *cs); bool append_ulonglong(ulonglong val); @@ -634,7 +634,7 @@ public: } bool append_for_single_quote(const char *st) { - return append_for_single_quote(st, strlen(st)); + return append_for_single_quote(st, (uint)strlen(st)); } /* Swap two string objects. Efficient way to exchange data without memcpy. */ diff --git a/sql/sql_table.cc b/sql/sql_table.cc index afa27d790d4..2ea8779c1a9 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -2272,9 +2272,9 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists, size_t db_length= table->db_length; handlerton *table_type= 0; - DBUG_PRINT("table", ("table_l: '%s'.'%s' table: 0x%lx s: 0x%lx", - table->db, table->table_name, (long) table->table, - table->table ? (long) table->table->s : (long) -1)); + DBUG_PRINT("table", ("table_l: '%s'.'%s' table: %p s: %p", + table->db, table->table_name, table->table, + table->table ? table->table->s : NULL)); /* If we are in locked tables mode and are dropping a temporary table, @@ -2517,8 +2517,8 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists, mysql_audit_drop_table(thd, table); } - DBUG_PRINT("table", ("table: 0x%lx s: 0x%lx", (long) table->table, - table->table ? (long) table->table->s : (long) -1)); + DBUG_PRINT("table", ("table: %p s: %p", table->table, + table->table ? table->table->s : NULL)); } DEBUG_SYNC(thd, "rm_table_no_locks_before_binlog"); thd->thread_specific_used|= (trans_tmp_table_deleted || diff --git a/sql/sql_view.cc b/sql/sql_view.cc index 55550ddfb8a..d39dc739893 100644 --- a/sql/sql_view.cc +++ b/sql/sql_view.cc @@ -1151,7 +1151,7 @@ bool mysql_make_view(THD *thd, TABLE_SHARE *share, TABLE_LIST *table, bool result, view_is_mergeable; TABLE_LIST *UNINIT_VAR(view_main_select_tables); DBUG_ENTER("mysql_make_view"); - DBUG_PRINT("info", ("table: 0x%lx (%s)", (ulong) table, table->table_name)); + DBUG_PRINT("info", ("table: %p (%s)", table, table->table_name)); if (table->required_type == FRMTYPE_TABLE) { diff --git a/sql/strfunc.cc b/sql/strfunc.cc index bf5fe9d6f00..4928e939e27 100644 --- a/sql/strfunc.cc +++ b/sql/strfunc.cc @@ -158,7 +158,7 @@ uint find_type2(const TYPELIB *typelib, const char *x, uint length, int pos; const char *j; DBUG_ENTER("find_type2"); - DBUG_PRINT("enter",("x: '%.*s' lib: 0x%lx", length, x, (long) typelib)); + DBUG_PRINT("enter",("x: '%.*s' lib: %p", length, x, typelib)); if (!typelib->count) { diff --git a/sql/table.cc b/sql/table.cc index 5896b0a4c7a..7e75015deb9 100644 --- a/sql/table.cc +++ b/sql/table.cc @@ -3001,8 +3001,8 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share, Field **field_ptr; uint8 save_context_analysis_only= thd->lex->context_analysis_only; DBUG_ENTER("open_table_from_share"); - DBUG_PRINT("enter",("name: '%s.%s' form: 0x%lx", share->db.str, - share->table_name.str, (long) outparam)); + DBUG_PRINT("enter",("name: '%s.%s' form: %p", share->db.str, + share->table_name.str, outparam)); thd->lex->context_analysis_only&= ~CONTEXT_ANALYSIS_ONLY_VIEW; // not a view @@ -3406,7 +3406,7 @@ int closefrm(register TABLE *table) { int error=0; DBUG_ENTER("closefrm"); - DBUG_PRINT("enter", ("table: 0x%lx", (long) table)); + DBUG_PRINT("enter", ("table: %p", table)); if (table->db_stat) error=table->file->ha_close(); diff --git a/sql/table_cache.cc b/sql/table_cache.cc index 2feace30672..f7296ca72c8 100644 --- a/sql/table_cache.cc +++ b/sql/table_cache.cc @@ -913,8 +913,8 @@ retry: } end: - DBUG_PRINT("exit", ("share: 0x%lx ref_count: %u", - (ulong) share, share->tdc->ref_count)); + DBUG_PRINT("exit", ("share: %p ref_count: %u", + share, share->tdc->ref_count)); if (flags & GTS_NOLOCK) { tdc_release_share(share); @@ -945,8 +945,8 @@ void tdc_release_share(TABLE_SHARE *share) mysql_mutex_lock(&share->tdc->LOCK_table_share); DBUG_PRINT("enter", - ("share: 0x%lx table: %s.%s ref_count: %u version: %lu", - (ulong) share, share->db.str, share->table_name.str, + ("share: %p table: %s.%s ref_count: %u version: %lu", + share, share->db.str, share->table_name.str, share->tdc->ref_count, share->tdc->version)); DBUG_ASSERT(share->tdc->ref_count); diff --git a/sql/temporary_tables.cc b/sql/temporary_tables.cc index 42ebb87cbe4..8077324d202 100644 --- a/sql/temporary_tables.cc +++ b/sql/temporary_tables.cc @@ -1127,8 +1127,8 @@ TABLE *THD::open_temporary_table(TMP_TABLE_SHARE *share, thread_safe_increment32(&slave_open_temp_tables); } - DBUG_PRINT("tmptable", ("Opened table: '%s'.'%s' 0x%lx", table->s->db.str, - table->s->table_name.str, (long) table)); + DBUG_PRINT("tmptable", ("Opened table: '%s'.'%s'%p", table->s->db.str, + table->s->table_name.str, table)); DBUG_RETURN(table); } @@ -1221,9 +1221,9 @@ void THD::close_temporary_table(TABLE *table) { DBUG_ENTER("THD::close_temporary_table"); - DBUG_PRINT("tmptable", ("closing table: '%s'.'%s' 0x%lx alias: '%s'", + DBUG_PRINT("tmptable", ("closing table: '%s'.'%s'%p alias: '%s'", table->s->db.str, table->s->table_name.str, - (long) table, table->alias.c_ptr())); + table, table->alias.c_ptr())); closefrm(table); my_free(table); diff --git a/sql/threadpool_generic.cc b/sql/threadpool_generic.cc index 2ab874b2232..880593a17e9 100644 --- a/sql/threadpool_generic.cc +++ b/sql/threadpool_generic.cc @@ -450,7 +450,7 @@ static void* native_event_get_userdata(native_event *event) static int io_poll_create() { HANDLE h= CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0); - return (int)h; + return PtrToInt(h); } @@ -476,7 +476,7 @@ int io_poll_start_read(int pollfd, int fd, void *, void *opt) static int io_poll_associate_fd(int pollfd, int fd, void *data, void *opt) { - HANDLE h= CreateIoCompletionPort((HANDLE)fd, (HANDLE)pollfd, (ULONG_PTR)data, 0); + HANDLE h= CreateIoCompletionPort(IntToPtr(fd), IntToPtr(pollfd), (ULONG_PTR)data, 0); if (!h) return -1; return io_poll_start_read(pollfd,fd, 0, opt); diff --git a/sql/unireg.cc b/sql/unireg.cc index 0bb8a4e77c6..8dbfed1cd7e 100644 --- a/sql/unireg.cc +++ b/sql/unireg.cc @@ -452,9 +452,9 @@ static uint pack_keys(uchar *keybuff, uint key_count, KEY *keyinfo, int2store(pos+6, key->block_size); pos+=8; key_parts+=key->user_defined_key_parts; - DBUG_PRINT("loop", ("flags: %lu key_parts: %d key_part: 0x%lx", + DBUG_PRINT("loop", ("flags: %lu key_parts: %d key_part: %p", key->flags, key->user_defined_key_parts, - (long) key->key_part)); + key->key_part)); for (key_part=key->key_part,key_part_end=key_part+key->user_defined_key_parts ; key_part != key_part_end ; key_part++) |