diff options
Diffstat (limited to 'sql')
90 files changed, 1893 insertions, 1416 deletions
diff --git a/sql/CMakeLists.txt b/sql/CMakeLists.txt index 87461be88f3..44160c32225 100755 --- a/sql/CMakeLists.txt +++ b/sql/CMakeLists.txt @@ -92,7 +92,7 @@ TARGET_LINK_LIBRARIES(sql ${MYSQLD_STATIC_PLUGIN_LIBS} IF(WIN32) - SET(MYSQLD_SOURCE main.cc nt_servc.cc nt_servc.h message.rc) + SET(MYSQLD_SOURCE main.cc nt_servc.cc nt_servc.h message.rc) ELSE() SET(MYSQLD_SOURCE main.cc ${DTRACE_PROBES_ALL}) ENDIF() diff --git a/sql/Makefile.am b/sql/Makefile.am index 0fba8d12406..0616893a014 100644 --- a/sql/Makefile.am +++ b/sql/Makefile.am @@ -276,6 +276,3 @@ probes_libndb.o: probes_mysql.d libndb_la-ha_ndbcluster.lo fi endif - -# Don't update the files from bitkeeper -%::SCCS/s.% diff --git a/sql/authors.h b/sql/authors.h index 555fe2ae43a..5de2659f098 100644 --- a/sql/authors.h +++ b/sql/authors.h @@ -80,6 +80,7 @@ struct show_table_authors_st show_table_authors[]= { { "Eric Herman", "Amsterdam, Netherlands", "Bug fixing - federated" }, { "Andrey Hristov", "Walldorf, Germany", "Event scheduler (5.1)" }, { "Alexander (Alexi) Ivanov", "St. Petersburg, Russia", "Replication" }, + { "Mattias Jonsson", "Uppsala, Sweden", "Partitioning" }, { "Alexander (Salle) Keremidarski", "Sofia, Bulgaria", "Bug fixing" }, { "Mats Kindahl", "Storvreta, Sweden", "Replication" }, diff --git a/sql/datadict.cc b/sql/datadict.cc index 5067c13a255..33c3b6bc700 100644 --- a/sql/datadict.cc +++ b/sql/datadict.cc @@ -95,7 +95,7 @@ bool dd_check_storage_engine_flag(THD *thd, return TRUE; } - if (check_table_name(table_name, strlen(table_name))) + if (check_table_name(table_name, strlen(table_name), FALSE)) { my_error(ER_WRONG_TABLE_NAME, MYF(0), table_name); return TRUE; diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc index d16fa4b2468..dde6267331f 100644 --- a/sql/debug_sync.cc +++ b/sql/debug_sync.cc @@ -387,6 +387,13 @@ static st_debug_sync_globals debug_sync_global; /* All globals in one object */ */ extern "C" void (*debug_sync_C_callback_ptr)(const char *, size_t); +/** + Callbacks from C files. +*/ +C_MODE_START +static void debug_sync_C_callback(const char *, size_t); +static int debug_sync_qsort_cmp(const void *, const void *); +C_MODE_END /** Callback for debug sync, to be used by C files. See thr_lock.c for example. @@ -422,8 +429,8 @@ extern "C" void (*debug_sync_C_callback_ptr)(const char *, size_t); static void debug_sync_C_callback(const char *sync_point_name, size_t name_len) { - if (unlikely(opt_debug_sync_timeout)) - debug_sync(current_thd, sync_point_name, name_len); + if (unlikely(opt_debug_sync_timeout)) + debug_sync(current_thd, sync_point_name, name_len); } #ifdef HAVE_PSI_INTERFACE diff --git a/sql/derror.cc b/sql/derror.cc index 04a82860d45..7f1435e89c1 100644 --- a/sql/derror.cc +++ b/sql/derror.cc @@ -32,11 +32,12 @@ static void init_myfunc_errs(void); -const char **get_server_errmsgs() +C_MODE_START +static const char **get_server_errmsgs() { return CURRENT_THD_ERRMSGS; } - +C_MODE_END /** Read messages from errorfile. diff --git a/sql/events.cc b/sql/events.cc index 96b86e6798f..a548bda53e2 100644 --- a/sql/events.cc +++ b/sql/events.cc @@ -276,7 +276,9 @@ create_query_string(THD *thd, String *buf) /* Append definer */ append_definer(thd, buf, &(thd->lex->definer->user), &(thd->lex->definer->host)); /* Append the left part of thd->query after "DEFINER" part */ - if (buf->append(thd->lex->stmt_definition_begin)) + if (buf->append(thd->lex->stmt_definition_begin, + thd->lex->stmt_definition_end - + thd->lex->stmt_definition_begin)) return 1; return 0; diff --git a/sql/field.cc b/sql/field.cc index bd091f7eb57..88a7f43819d 100644 --- a/sql/field.cc +++ b/sql/field.cc @@ -1009,17 +1009,20 @@ test_if_important_data(CHARSET_INFO *cs, const char *str, const char *strend) Used below. In an anonymous namespace to not clash with definitions in other files. */ -namespace { - int compare(unsigned int a, unsigned int b) - { - if (a < b) - return -1; - if (b < a) - return 1; - return 0; -} + +CPP_UNNAMED_NS_START + +int compare(unsigned int a, unsigned int b) +{ + if (a < b) + return -1; + if (b < a) + return 1; + return 0; } +CPP_UNNAMED_NS_END + /** Detect Item_result by given field type of UNION merge result. @@ -8464,14 +8467,20 @@ bool Field_num::eq_def(Field *field) } +/** + Check whether two numeric fields can be considered 'equal' for table + alteration purposes. Fields are equal if they are of the same type + and retain the same pack length. +*/ + uint Field_num::is_equal(Create_field *new_field) { return ((new_field->sql_type == real_type()) && - ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags & - UNSIGNED_FLAG)) && + ((new_field->flags & UNSIGNED_FLAG) == + (uint) (flags & UNSIGNED_FLAG)) && ((new_field->flags & AUTO_INCREMENT_FLAG) == (uint) (flags & AUTO_INCREMENT_FLAG)) && - (new_field->length <= max_display_length())); + (new_field->pack_length == pack_length())); } @@ -9119,7 +9128,7 @@ void Create_field::create_length_to_internal_length(void) void Create_field::init_for_tmp_table(enum_field_types sql_type_arg, uint32 length_arg, uint32 decimals_arg, bool maybe_null, bool is_unsigned, - uint pack_length) + uint pack_length_arg) { DBUG_ENTER("Create_field::init_for_tmp_table"); @@ -9132,7 +9141,7 @@ void Create_field::init_for_tmp_table(enum_field_types sql_type_arg, geom_type= Field::GEOM_GEOMETRY; DBUG_PRINT("enter", ("sql_type: %d, length: %u, pack_length: %u", - sql_type_arg, length_arg, pack_length)); + sql_type_arg, length_arg, pack_length_arg)); /* These pack flags are crafted to get it correctly through the @@ -9196,8 +9205,8 @@ void Create_field::init_for_tmp_table(enum_field_types sql_type_arg, case MYSQL_TYPE_GEOMETRY: // If you are going to use the above types, you have to pass a // pack_length as parameter. Assert that is really done. - DBUG_ASSERT(pack_length != ~0U); - pack_flag|= pack_length_to_packflag(pack_length); + DBUG_ASSERT(pack_length_arg != ~0U); + pack_flag|= pack_length_to_packflag(pack_length_arg); break; default: /* Nothing */ @@ -9951,6 +9960,39 @@ Create_field::Create_field(Field *old_field,Field *orig_field) /** + maximum possible character length for blob. + + This method is used in Item_field::set_field to calculate + max_length for Item. + + For example: + CREATE TABLE t2 SELECT CONCAT(tinyblob_utf8_column) FROM t1; + must create a "VARCHAR(255) CHARACTER SET utf8" column. + + @return + length +*/ + +uint32 Field_blob::char_length() +{ + switch (packlength) + { + case 1: + return 255; + case 2: + return 65535; + case 3: + return 16777215; + case 4: + return (uint32) 4294967295U; + default: + DBUG_ASSERT(0); // we should never go here + return 0; + } +} + + +/** maximum possible display length for blob. @return diff --git a/sql/field.h b/sql/field.h index d1fcc40ff5d..46d8a2aa6d9 100644 --- a/sql/field.h +++ b/sql/field.h @@ -499,7 +499,7 @@ public: longlong convert_decimal2longlong(const my_decimal *val, bool unsigned_flag, int *err); /* The max. number of characters */ - inline uint32 char_length() const + virtual uint32 char_length() { return field_length / charset()->mbmaxlen; } @@ -685,6 +685,10 @@ public: int store_decimal(const my_decimal *); int store(const char *to,uint length,CHARSET_INFO *cs)=0; uint size_of() const { return sizeof(*this); } + uint repertoire(void) const + { + return my_charset_repertoire(field_charset); + } CHARSET_INFO *charset(void) const { return field_charset; } void set_charset(CHARSET_INFO *charset_arg) { field_charset= charset_arg; } enum Derivation derivation(void) const { return field_derivation; } @@ -1809,6 +1813,7 @@ public: bool has_charset(void) const { return charset() == &my_charset_bin ? FALSE : TRUE; } uint32 max_display_length(); + uint32 char_length(); uint is_equal(Create_field *new_field); inline bool in_read_set() { return bitmap_is_set(table->read_set, field_index); } inline bool in_write_set() { return bitmap_is_set(table->write_set, field_index); } diff --git a/sql/field_conv.cc b/sql/field_conv.cc index e3be33c0f3c..299865e6114 100644 --- a/sql/field_conv.cc +++ b/sql/field_conv.cc @@ -123,13 +123,18 @@ set_field_to_null(Field *field) return 0; } field->reset(); - if (field->table->in_use->count_cuted_fields == CHECK_FIELD_WARN) - { + switch (field->table->in_use->count_cuted_fields) { + case CHECK_FIELD_WARN: field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1); + /* fall through */ + case CHECK_FIELD_IGNORE: return 0; + case CHECK_FIELD_ERROR_FOR_NULL: + if (!field->table->in_use->no_errors) + my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name); + return -1; } - if (!field->table->in_use->no_errors) - my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name); + DBUG_ASSERT(0); // impossible return -1; } @@ -179,13 +184,18 @@ set_field_to_null_with_conversions(Field *field, bool no_conversions) field->table->auto_increment_field_not_null= FALSE; return 0; // field is set in fill_record() } - if (field->table->in_use->count_cuted_fields == CHECK_FIELD_WARN) - { + switch (field->table->in_use->count_cuted_fields) { + case CHECK_FIELD_WARN: field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_BAD_NULL_ERROR, 1); + /* fall through */ + case CHECK_FIELD_IGNORE: return 0; + case CHECK_FIELD_ERROR_FOR_NULL: + if (!field->table->in_use->no_errors) + my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name); + return -1; } - if (!field->table->in_use->no_errors) - my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name); + DBUG_ASSERT(0); // impossible return -1; } diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index a327aa51b53..099763b3fe9 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -4249,7 +4249,7 @@ int ha_ndbcluster::info(uint flag) } -void ha_ndbcluster::get_dynamic_partition_info(PARTITION_INFO *stat_info, +void ha_ndbcluster::get_dynamic_partition_info(PARTITION_STATS *stat_info, uint part_id) { /* @@ -4257,7 +4257,7 @@ void ha_ndbcluster::get_dynamic_partition_info(PARTITION_INFO *stat_info, implement ndb function which retrives the statistics about ndb partitions. */ - bzero((char*) stat_info, sizeof(PARTITION_INFO)); + bzero((char*) stat_info, sizeof(PARTITION_STATS)); return; } diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h index 17ba7451538..de1e36b61d2 100644 --- a/sql/ha_ndbcluster.h +++ b/sql/ha_ndbcluster.h @@ -275,7 +275,7 @@ class ha_ndbcluster: public handler ha_rows estimate_rows_upper_bound() { return HA_POS_ERROR; } int info(uint); - void get_dynamic_partition_info(PARTITION_INFO *stat_info, uint part_id); + void get_dynamic_partition_info(PARTITION_STATS *stat_info, uint part_id); int extra(enum ha_extra_function operation); int extra_opt(enum ha_extra_function operation, ulong cache_size); int reset(); diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc index cd12e5de4d6..9e06c0371d4 100644 --- a/sql/ha_partition.cc +++ b/sql/ha_partition.cc @@ -59,6 +59,9 @@ #include "sql_table.h" // tablename_to_filename #include "key.h" #include "sql_plugin.h" +#include "table.h" /* HA_DATA_PARTITION */ + +#include "debug_sync.h" static const char *ha_par_ext= ".par"; #ifdef NOT_USED @@ -692,6 +695,7 @@ int ha_partition::rename_partitions(const char *path) DBUG_ASSERT(!strcmp(path, get_canonical_filename(m_file[0], path, norm_name_buff))); + DEBUG_SYNC(ha_thd(), "before_rename_partitions"); if (temp_partitions) { /* @@ -2498,12 +2502,11 @@ err1: A destructor for partition-specific TABLE_SHARE data. */ -void ha_data_partition_destroy(void *ha_data) +void ha_data_partition_destroy(HA_DATA_PARTITION* ha_part_data) { - if (ha_data) + if (ha_part_data) { - HA_DATA_PARTITION *ha_data_partition= (HA_DATA_PARTITION*) ha_data; - pthread_mutex_destroy(&ha_data_partition->mutex); + mysql_mutex_destroy(&ha_part_data->LOCK_auto_inc); } } @@ -2643,28 +2646,30 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked) goto err_handler; /* - Use table_share->ha_data to share auto_increment_value among all handlers - for the same table. + Use table_share->ha_part_data to share auto_increment_value among + all handlers for the same table. */ if (is_not_tmp_table) mysql_mutex_lock(&table_share->LOCK_ha_data); - if (!table_share->ha_data) + if (!table_share->ha_part_data) { - HA_DATA_PARTITION *ha_data; /* currently only needed for auto_increment */ - table_share->ha_data= ha_data= (HA_DATA_PARTITION*) + table_share->ha_part_data= (HA_DATA_PARTITION*) alloc_root(&table_share->mem_root, sizeof(HA_DATA_PARTITION)); - if (!ha_data) + if (!table_share->ha_part_data) { if (is_not_tmp_table) mysql_mutex_unlock(&table_share->LOCK_ha_data); goto err_handler; } - DBUG_PRINT("info", ("table_share->ha_data 0x%p", ha_data)); - bzero(ha_data, sizeof(HA_DATA_PARTITION)); - table_share->ha_data_destroy= ha_data_partition_destroy; - pthread_mutex_init(&ha_data->mutex, MY_MUTEX_INIT_FAST); + DBUG_PRINT("info", ("table_share->ha_part_data 0x%p", + table_share->ha_part_data)); + bzero(table_share->ha_part_data, sizeof(HA_DATA_PARTITION)); + table_share->ha_part_data_destroy= ha_data_partition_destroy; + mysql_mutex_init(key_PARTITION_LOCK_auto_inc, + &table_share->ha_part_data->LOCK_auto_inc, + MY_MUTEX_INIT_FAST); } if (is_not_tmp_table) mysql_mutex_unlock(&table_share->LOCK_ha_data); @@ -2684,6 +2689,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked) DBUG_RETURN(0); err_handler: + DEBUG_SYNC(ha_thd(), "partition_open_error"); while (file-- != m_file) (*file)->close(); bitmap_free(&m_bulk_insert_started); @@ -3088,7 +3094,6 @@ int ha_partition::write_row(uchar * buf) longlong func_value; bool have_auto_increment= table->next_number_field && buf == table->record[0]; my_bitmap_map *old_map; - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; THD *thd= ha_thd(); timestamp_auto_set_type orig_timestamp_type= table->timestamp_field_type; #ifdef NOT_NEEDED @@ -3108,8 +3113,8 @@ int ha_partition::write_row(uchar * buf) */ if (have_auto_increment) { - if (!ha_data->auto_inc_initialized && - !table->s->next_number_keypart) + if (!table_share->ha_part_data->auto_inc_initialized && + !table_share->next_number_keypart) { /* If auto_increment in table_share is not initialized, start by @@ -3249,7 +3254,7 @@ int ha_partition::update_row(const uchar *old_data, uchar *new_data) exit: /* if updating an auto_increment column, update - table_share->ha_data->next_auto_inc_val if needed. + table_share->ha_part_data->next_auto_inc_val if needed. (not to be used if auto_increment on secondary field in a multi-column index) mysql_update does not set table->next_number_field, so we use @@ -3258,8 +3263,7 @@ exit: if (table->found_next_number_field && new_data == table->record[0] && !table->s->next_number_keypart) { - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; - if (!ha_data->auto_inc_initialized) + if (!table_share->ha_part_data->auto_inc_initialized) info(HA_STATUS_AUTO); set_auto_increment_if_higher(table->found_next_number_field); } @@ -3351,11 +3355,10 @@ int ha_partition::delete_all_rows() if (thd->lex->sql_command == SQLCOM_TRUNCATE) { Alter_info *alter_info= &thd->lex->alter_info; - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; /* TRUNCATE also means resetting auto_increment */ lock_auto_increment(); - ha_data->next_auto_inc_val= 0; - ha_data->auto_inc_initialized= FALSE; + table_share->ha_part_data->next_auto_inc_val= 0; + table_share->ha_part_data->auto_inc_initialized= FALSE; unlock_auto_increment(); if (alter_info->flags & ALTER_ADMIN_PARTITION) { @@ -4182,10 +4185,9 @@ int ha_partition::index_read_map(uchar *buf, const uchar *key, int ha_partition::common_index_read(uchar *buf, bool have_start_key) { int error; - uint key_len; + uint UNINIT_VAR(key_len); /* used if have_start_key==TRUE */ bool reverse_order= FALSE; DBUG_ENTER("ha_partition::common_index_read"); - LINT_INIT(key_len); /* used if have_start_key==TRUE */ DBUG_PRINT("info", ("m_ordered %u m_ordered_scan_ong %u have_start_key %u", m_ordered, m_ordered_scan_ongoing, have_start_key)); @@ -5071,22 +5073,22 @@ int ha_partition::info(uint flag) if (flag & HA_STATUS_AUTO) { bool auto_inc_is_first_in_idx= (table_share->next_number_keypart == 0); - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; DBUG_PRINT("info", ("HA_STATUS_AUTO")); if (!table->found_next_number_field) stats.auto_increment_value= 0; - else if (ha_data->auto_inc_initialized) + else if (table_share->ha_part_data->auto_inc_initialized) { lock_auto_increment(); - stats.auto_increment_value= ha_data->next_auto_inc_val; + stats.auto_increment_value= table_share->ha_part_data->next_auto_inc_val; unlock_auto_increment(); } else { lock_auto_increment(); /* to avoid two concurrent initializations, check again when locked */ - if (ha_data->auto_inc_initialized) - stats.auto_increment_value= ha_data->next_auto_inc_val; + if (table_share->ha_part_data->auto_inc_initialized) + stats.auto_increment_value= + table_share->ha_part_data->next_auto_inc_val; else { handler *file, **file_array; @@ -5106,10 +5108,11 @@ int ha_partition::info(uint flag) stats.auto_increment_value= auto_increment_value; if (auto_inc_is_first_in_idx) { - set_if_bigger(ha_data->next_auto_inc_val, auto_increment_value); - ha_data->auto_inc_initialized= TRUE; + set_if_bigger(table_share->ha_part_data->next_auto_inc_val, + auto_increment_value); + table_share->ha_part_data->auto_inc_initialized= TRUE; DBUG_PRINT("info", ("initializing next_auto_inc_val to %lu", - (ulong) ha_data->next_auto_inc_val)); + (ulong) table_share->ha_part_data->next_auto_inc_val)); } } unlock_auto_increment(); @@ -5284,7 +5287,7 @@ int ha_partition::info(uint flag) } -void ha_partition::get_dynamic_partition_info(PARTITION_INFO *stat_info, +void ha_partition::get_dynamic_partition_info(PARTITION_STATS *stat_info, uint part_id) { handler *file= m_file[part_id]; @@ -6499,11 +6502,10 @@ int ha_partition::reset_auto_increment(ulonglong value) { handler **file= m_file; int res; - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; DBUG_ENTER("ha_partition::reset_auto_increment"); lock_auto_increment(); - ha_data->auto_inc_initialized= FALSE; - ha_data->next_auto_inc_val= 0; + table_share->ha_part_data->auto_inc_initialized= FALSE; + table_share->ha_part_data->next_auto_inc_val= 0; do { if ((res= (*file)->ha_reset_auto_increment(value)) != 0) @@ -6517,7 +6519,7 @@ int ha_partition::reset_auto_increment(ulonglong value) /** This method is called by update_auto_increment which in turn is called by the individual handlers as part of write_row. We use the - table_share->ha_data->next_auto_inc_val, or search all + table_share->ha_part_data->next_auto_inc_val, or search all partitions for the highest auto_increment_value if not initialized or if auto_increment field is a secondary part of a key, we must search every partition when holding a mutex to be sure of correctness. @@ -6570,13 +6572,12 @@ void ha_partition::get_auto_increment(ulonglong offset, ulonglong increment, else { THD *thd= ha_thd(); - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; /* This is initialized in the beginning of the first write_row call. */ - DBUG_ASSERT(ha_data->auto_inc_initialized); + DBUG_ASSERT(table_share->ha_part_data->auto_inc_initialized); /* - Get a lock for handling the auto_increment in table_share->ha_data + Get a lock for handling the auto_increment in table_share->ha_part_data for avoiding two concurrent statements getting the same number. */ @@ -6603,8 +6604,9 @@ void ha_partition::get_auto_increment(ulonglong offset, ulonglong increment, } /* this gets corrected (for offset/increment) in update_auto_increment */ - *first_value= ha_data->next_auto_inc_val; - ha_data->next_auto_inc_val+= nb_desired_values * increment; + *first_value= table_share->ha_part_data->next_auto_inc_val; + table_share->ha_part_data->next_auto_inc_val+= + nb_desired_values * increment; unlock_auto_increment(); DBUG_PRINT("info", ("*first_value: %lu", (ulong) *first_value)); @@ -6624,10 +6626,9 @@ void ha_partition::release_auto_increment() } else if (next_insert_id) { - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; ulonglong next_auto_inc_val; lock_auto_increment(); - next_auto_inc_val= ha_data->next_auto_inc_val; + next_auto_inc_val= table_share->ha_part_data->next_auto_inc_val; /* If the current auto_increment values is lower than the reserved value, and the reserved value was reserved by this thread, @@ -6642,10 +6643,10 @@ void ha_partition::release_auto_increment() with SET INSERT_ID, i.e. forced/non generated values. */ if (thd->auto_inc_intervals_forced.maximum() < next_insert_id) - ha_data->next_auto_inc_val= next_insert_id; + table_share->ha_part_data->next_auto_inc_val= next_insert_id; } - DBUG_PRINT("info", ("ha_data->next_auto_inc_val: %lu", - (ulong) ha_data->next_auto_inc_val)); + DBUG_PRINT("info", ("table_share->ha_part_data->next_auto_inc_val: %lu", + (ulong) table_share->ha_part_data->next_auto_inc_val)); /* Unlock the multi row statement lock taken in get_auto_increment */ if (auto_increment_safe_stmt_log_lock) @@ -6745,127 +6746,6 @@ int ha_partition::indexes_are_disabled(void) } -/**************************************************************************** - MODULE Partition Share -****************************************************************************/ -/* - Service routines for ... methods. -------------------------------------------------------------------------- - Variables for partition share methods. A hash used to track open tables. - A mutex for the hash table and an init variable to check if hash table - is initialized. - There is also a constant ending of the partition handler file name. -*/ - -#ifdef NOT_USED -static HASH partition_open_tables; -static mysql_mutex_t partition_mutex; -static int partition_init= 0; - - -/* - Function we use in the creation of our hash to get key. -*/ - -static uchar *partition_get_key(PARTITION_SHARE *share, size_t *length, - my_bool not_used __attribute__ ((unused))) -{ - *length= share->table_name_length; - return (uchar *) share->table_name; -} - -/* - Example of simple lock controls. The "share" it creates is structure we - will pass to each partition handler. Do you have to have one of these? - Well, you have pieces that are used for locking, and they are needed to - function. -*/ - -static PARTITION_SHARE *get_share(const char *table_name, TABLE *table) -{ - PARTITION_SHARE *share; - uint length; - char *tmp_name; - - /* - So why does this exist? There is no way currently to init a storage - engine. - Innodb and BDB both have modifications to the server to allow them to - do this. Since you will not want to do this, this is probably the next - best method. - */ - if (!partition_init) - { - /* Hijack a mutex for init'ing the storage engine */ - mysql_mutex_lock(&LOCK_mysql_create_db); - if (!partition_init) - { - partition_init++; - mysql_mutex_init(INSTRUMENT_ME, &partition_mutex, MY_MUTEX_INIT_FAST); - (void) hash_init(&partition_open_tables, system_charset_info, 32, 0, 0, - (hash_get_key) partition_get_key, 0, 0); - } - mysql_mutex_unlock(&LOCK_mysql_create_db); - } - mysql_mutex_lock(&partition_mutex); - length= (uint) strlen(table_name); - - if (!(share= (PARTITION_SHARE *) hash_search(&partition_open_tables, - (uchar *) table_name, length))) - { - if (!(share= (PARTITION_SHARE *) - my_multi_malloc(MYF(MY_WME | MY_ZEROFILL), - &share, (uint) sizeof(*share), - &tmp_name, (uint) length + 1, NullS))) - { - mysql_mutex_unlock(&partition_mutex); - return NULL; - } - - share->use_count= 0; - share->table_name_length= length; - share->table_name= tmp_name; - strmov(share->table_name, table_name); - if (my_hash_insert(&partition_open_tables, (uchar *) share)) - goto error; - thr_lock_init(&share->lock); - mysql_mutex_init(INSTRUMENT_ME, &share->mutex, MY_MUTEX_INIT_FAST); - } - share->use_count++; - mysql_mutex_unlock(&partition_mutex); - - return share; - -error: - mysql_mutex_unlock(&partition_mutex); - my_free((uchar*) share, MYF(0)); - - return NULL; -} - - -/* - Free lock controls. We call this whenever we close a table. If the table - had the last reference to the share then we free memory associated with - it. -*/ - -static int free_share(PARTITION_SHARE *share) -{ - mysql_mutex_lock(&partition_mutex); - if (!--share->use_count) - { - hash_delete(&partition_open_tables, (uchar *) share); - thr_lock_delete(&share->lock); - mysql_mutex_destroy(&share->mutex); - my_free((uchar*) share, MYF(0)); - } - mysql_mutex_unlock(&partition_mutex); - - return 0; -} -#endif /* NOT_USED */ - struct st_mysql_storage_engine partition_storage_engine= { MYSQL_HANDLERTON_INTERFACE_VERSION }; diff --git a/sql/ha_partition.h b/sql/ha_partition.h index 9f499e7b4a9..eec3cb71537 100644 --- a/sql/ha_partition.h +++ b/sql/ha_partition.h @@ -29,31 +29,6 @@ enum partition_keywords PKW_COLUMNS }; -/* - PARTITION_SHARE is a structure that will be shared amoung all open handlers - The partition implements the minimum of what you will probably need. -*/ - -#ifdef NOT_USED -typedef struct st_partition_share -{ - char *table_name; - uint table_name_length, use_count; - mysql_mutex_t mutex; - THR_LOCK lock; -} PARTITION_SHARE; -#endif - -/** - Partition specific ha_data struct. - @todo: move all partition specific data from TABLE_SHARE here. -*/ -typedef struct st_ha_data_partition -{ - ulonglong next_auto_inc_val; /**< first non reserved value */ - bool auto_inc_initialized; - pthread_mutex_t mutex; -} HA_DATA_PARTITION; #define PARTITION_BYTES_IN_POS 2 #define PARTITION_ENABLED_TABLE_FLAGS (HA_FILE_BASED | HA_REC_NOT_IN_SEQ) @@ -522,7 +497,7 @@ public: ------------------------------------------------------------------------- */ virtual int info(uint); - void get_dynamic_partition_info(PARTITION_INFO *stat_info, + void get_dynamic_partition_info(PARTITION_STATS *stat_info, uint part_id); virtual int extra(enum ha_extra_function operation); virtual int extra_opt(enum ha_extra_function operation, ulong cachesize); @@ -944,16 +919,16 @@ private: /* lock already taken */ if (auto_increment_safe_stmt_log_lock) return; - DBUG_ASSERT(table_share->ha_data && !auto_increment_lock); + DBUG_ASSERT(table_share->ha_part_data && !auto_increment_lock); if(table_share->tmp_table == NO_TMP_TABLE) { auto_increment_lock= TRUE; - mysql_mutex_lock(&table_share->LOCK_ha_data); + mysql_mutex_lock(&table_share->ha_part_data->LOCK_auto_inc); } } virtual void unlock_auto_increment() { - DBUG_ASSERT(table_share->ha_data); + DBUG_ASSERT(table_share->ha_part_data); /* If auto_increment_safe_stmt_log_lock is true, we have to keep the lock. It will be set to false and thus unlocked at the end of the statement by @@ -961,20 +936,19 @@ private: */ if(auto_increment_lock && !auto_increment_safe_stmt_log_lock) { - mysql_mutex_unlock(&table_share->LOCK_ha_data); + mysql_mutex_unlock(&table_share->ha_part_data->LOCK_auto_inc); auto_increment_lock= FALSE; } } virtual void set_auto_increment_if_higher(Field *field) { - HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data; ulonglong nr= (((Field_num*) field)->unsigned_flag || field->val_int() > 0) ? field->val_int() : 0; lock_auto_increment(); - DBUG_ASSERT(ha_data->auto_inc_initialized == TRUE); + DBUG_ASSERT(table_share->ha_part_data->auto_inc_initialized == TRUE); /* must check when the mutex is taken */ - if (nr >= ha_data->next_auto_inc_val) - ha_data->next_auto_inc_val= nr + 1; + if (nr >= table_share->ha_part_data->next_auto_inc_val) + table_share->ha_part_data->next_auto_inc_val= nr + 1; unlock_auto_increment(); } diff --git a/sql/handler.cc b/sql/handler.cc index c0a5e2ff55c..11f684a8010 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -174,7 +174,7 @@ redo: } -plugin_ref ha_lock_engine(THD *thd, handlerton *hton) +plugin_ref ha_lock_engine(THD *thd, const handlerton *hton) { if (hton) { @@ -299,13 +299,14 @@ handler *get_ha_partition(partition_info *part_info) #endif -const char **handler_errmsgs; +static const char **handler_errmsgs; - -const char **get_handler_errmsgs() +C_MODE_START +static const char **get_handler_errmsgs() { return handler_errmsgs; } +C_MODE_END /** @@ -642,9 +643,13 @@ static my_bool closecon_handlerton(THD *thd, plugin_ref plugin, there's no need to rollback here as all transactions must be rolled back already */ - if (hton->state == SHOW_OPTION_YES && hton->close_connection && - thd_get_ha_data(thd, hton)) - hton->close_connection(hton, thd); + if (hton->state == SHOW_OPTION_YES && thd_get_ha_data(thd, hton)) + { + if (hton->close_connection) + hton->close_connection(hton, thd); + /* make sure ha_data is reset and ha_data_lock is released */ + thd_set_ha_data(thd, hton, NULL); + } return FALSE; } @@ -3548,7 +3553,7 @@ int handler::index_next_same(uchar *buf, const uchar *key, uint keylen) } -void handler::get_dynamic_partition_info(PARTITION_INFO *stat_info, +void handler::get_dynamic_partition_info(PARTITION_STATS *stat_info, uint part_id) { info(HA_STATUS_CONST | HA_STATUS_TIME | HA_STATUS_VARIABLE | diff --git a/sql/handler.h b/sql/handler.h index 9f21cb0f25d..ad26534d91d 100644 --- a/sql/handler.h +++ b/sql/handler.h @@ -961,7 +961,7 @@ typedef struct { ulong check_time; ulong update_time; ulonglong check_sum; -} PARTITION_INFO; +} PARTITION_STATS; #define UNDEF_NODEGROUP 65535 class Item; @@ -1560,7 +1560,7 @@ public: { return (ha_rows) 10; } virtual void position(const uchar *record)=0; virtual int info(uint)=0; // see my_base.h for full description - virtual void get_dynamic_partition_info(PARTITION_INFO *stat_info, + virtual void get_dynamic_partition_info(PARTITION_STATS *stat_info, uint part_id); virtual int extra(enum ha_extra_function operation) { return 0; } @@ -2066,7 +2066,7 @@ extern ulong total_ha, total_ha_2pc; /* lookups */ handlerton *ha_default_handlerton(THD *thd); plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name); -plugin_ref ha_lock_engine(THD *thd, handlerton *hton); +plugin_ref ha_lock_engine(THD *thd, const handlerton *hton); handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type); handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc, handlerton *db_type); diff --git a/sql/init.cc b/sql/init.cc index c72787300b7..e43b12787ab 100644 --- a/sql/init.cc +++ b/sql/init.cc @@ -33,7 +33,7 @@ void unireg_init(ulong options) { DBUG_ENTER("unireg_init"); - MYSYS_PROGRAM_DONT_USE_CURSES(); + error_handler_hook = my_message_stderr; abort_loop=0; my_disable_async_io=1; /* aioread is only in shared library */ diff --git a/sql/item.cc b/sql/item.cc index 5fea7b9c075..c59a17a0ea3 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -1,4 +1,4 @@ -/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc. +/* Copyright (c) 2000, 2010 Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -1816,7 +1816,16 @@ bool agg_item_set_converter(DTCollation &coll, const char *fname, if (!(conv= (*arg)->safe_charset_converter(coll.collation)) && ((*arg)->collation.repertoire == MY_REPERTOIRE_ASCII)) - conv= new Item_func_conv_charset(*arg, coll.collation, 1); + { + /* + We should disable const subselect item evaluation because + subselect transformation does not happen in view_prepare_mode + and thus val_...() methods can not be called for const items. + */ + bool resolve_const= ((*arg)->type() == Item::SUBSELECT_ITEM && + thd->lex->view_prepare_mode) ? FALSE : TRUE; + conv= new Item_func_conv_charset(*arg, coll.collation, resolve_const); + } if (!conv) { @@ -3425,9 +3434,9 @@ Item_param::set_param_type_and_swap_value(Item_param *src) bool Item_param::set_value(THD *thd, sp_rcontext *ctx, Item **it) { - Item *value= *it; + Item *arg= *it; - if (value->is_null()) + if (arg->is_null()) { set_null(); return FALSE; @@ -3435,12 +3444,12 @@ Item_param::set_value(THD *thd, sp_rcontext *ctx, Item **it) null_value= FALSE; - switch (value->result_type()) { + switch (arg->result_type()) { case STRING_RESULT: { char str_buffer[STRING_BUFFER_USUAL_SIZE]; String sv_buffer(str_buffer, sizeof(str_buffer), &my_charset_bin); - String *sv= value->val_str(&sv_buffer); + String *sv= arg->val_str(&sv_buffer); if (!sv) return TRUE; @@ -3457,19 +3466,19 @@ Item_param::set_value(THD *thd, sp_rcontext *ctx, Item **it) } case REAL_RESULT: - set_double(value->val_real()); + set_double(arg->val_real()); param_type= MYSQL_TYPE_DOUBLE; break; case INT_RESULT: - set_int(value->val_int(), value->max_length); + set_int(arg->val_int(), arg->max_length); param_type= MYSQL_TYPE_LONG; break; case DECIMAL_RESULT: { my_decimal dv_buf; - my_decimal *dv= value->val_decimal(&dv_buf); + my_decimal *dv= arg->val_decimal(&dv_buf); if (!dv) return TRUE; @@ -3489,8 +3498,8 @@ Item_param::set_value(THD *thd, sp_rcontext *ctx, Item **it) return FALSE; } - item_result_type= value->result_type(); - item_type= value->type(); + item_result_type= arg->result_type(); + item_type= arg->type(); return FALSE; } @@ -3785,7 +3794,7 @@ void Item_copy_decimal::copy() { my_decimal *nr= item->val_decimal(&cached_value); if (nr && nr != &cached_value) - memcpy (&cached_value, nr, sizeof (my_decimal)); + my_decimal2decimal (nr, &cached_value); null_value= item->null_value; } @@ -5330,14 +5339,22 @@ int Item_field::save_in_field(Field *to, bool no_conversions) if (result_field->is_null()) { null_value=1; - res= set_field_to_null_with_conversions(to, no_conversions); + return set_field_to_null_with_conversions(to, no_conversions); } - else + to->set_notnull(); + + /* + If we're setting the same field as the one we're reading from there's + nothing to do. This can happen in 'SET x = x' type of scenarios. + */ + if (to == result_field) { - to->set_notnull(); - res= field_conv(to,result_field); null_value=0; + return 0; } + + res= field_conv(to,result_field); + null_value=0; return res; } @@ -5623,13 +5640,25 @@ inline uint char_val(char X) X-'a'+10); } +Item_hex_string::Item_hex_string() +{ + hex_string_init("", 0); +} Item_hex_string::Item_hex_string(const char *str, uint str_length) { + hex_string_init(str, str_length); +} + +void Item_hex_string::hex_string_init(const char *str, uint str_length) +{ max_length=(str_length+1)/2; char *ptr=(char*) sql_alloc(max_length+1); if (!ptr) + { + str_value.set("", 0, &my_charset_bin); return; + } str_value.set(ptr,max_length,&my_charset_bin); char *end=ptr+max_length; if (max_length*2 != str_length) @@ -7402,7 +7431,7 @@ void Item_cache_int::store(Item *item, longlong val_arg) String *Item_cache_int::val_str(String *str) { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return NULL; str->set(value, default_charset()); return str; @@ -7412,7 +7441,7 @@ String *Item_cache_int::val_str(String *str) my_decimal *Item_cache_int::val_decimal(my_decimal *decimal_val) { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return NULL; int2my_decimal(E_DEC_FATAL_ERROR, value, unsigned_flag, decimal_val); return decimal_val; @@ -7421,7 +7450,7 @@ my_decimal *Item_cache_int::val_decimal(my_decimal *decimal_val) double Item_cache_int::val_real() { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return 0.0; return (double) value; } @@ -7429,7 +7458,7 @@ double Item_cache_int::val_real() longlong Item_cache_int::val_int() { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return 0; return value; } @@ -7485,7 +7514,7 @@ String *Item_cache_datetime::val_str(String *str) my_decimal *Item_cache_datetime::val_decimal(my_decimal *decimal_val) { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value_int()) + if (!has_value()) return NULL; int2my_decimal(E_DEC_FATAL_ERROR, int_value, unsigned_flag, decimal_val); return decimal_val; @@ -7521,7 +7550,7 @@ bool Item_cache_real::cache_value() double Item_cache_real::val_real() { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return 0.0; return value; } @@ -7529,7 +7558,7 @@ double Item_cache_real::val_real() longlong Item_cache_real::val_int() { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return 0; return (longlong) rint(value); } @@ -7538,7 +7567,7 @@ longlong Item_cache_real::val_int() String* Item_cache_real::val_str(String *str) { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return NULL; str->set_real(value, decimals, default_charset()); return str; @@ -7548,7 +7577,7 @@ String* Item_cache_real::val_str(String *str) my_decimal *Item_cache_real::val_decimal(my_decimal *decimal_val) { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return NULL; double2my_decimal(E_DEC_FATAL_ERROR, value, decimal_val); return decimal_val; @@ -7570,7 +7599,7 @@ double Item_cache_decimal::val_real() { DBUG_ASSERT(fixed); double res; - if (!value_cached && !cache_value()) + if (!has_value()) return 0.0; my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &res); return res; @@ -7580,7 +7609,7 @@ longlong Item_cache_decimal::val_int() { DBUG_ASSERT(fixed); longlong res; - if (!value_cached && !cache_value()) + if (!has_value()) return 0; my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &res); return res; @@ -7589,7 +7618,7 @@ longlong Item_cache_decimal::val_int() String* Item_cache_decimal::val_str(String *str) { DBUG_ASSERT(fixed); - if (!value_cached && !cache_value()) + if (!has_value()) return NULL; my_decimal_round(E_DEC_FATAL_ERROR, &decimal_value, decimals, FALSE, &decimal_value); @@ -7600,7 +7629,7 @@ String* Item_cache_decimal::val_str(String *str) my_decimal *Item_cache_decimal::val_decimal(my_decimal *val) { DBUG_ASSERT(fixed); - if (!value_cached && !cache_value()) + if (!has_value()) return NULL; return &decimal_value; } @@ -7636,7 +7665,7 @@ double Item_cache_str::val_real() DBUG_ASSERT(fixed == 1); int err_not_used; char *end_not_used; - if (!value_cached && !cache_value()) + if (!has_value()) return 0.0; if (value) return my_strntod(value->charset(), (char*) value->ptr(), @@ -7649,7 +7678,7 @@ longlong Item_cache_str::val_int() { DBUG_ASSERT(fixed == 1); int err; - if (!value_cached && !cache_value()) + if (!has_value()) return 0; if (value) return my_strntoll(value->charset(), value->ptr(), @@ -7662,7 +7691,7 @@ longlong Item_cache_str::val_int() String* Item_cache_str::val_str(String *str) { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return 0; return value; } @@ -7671,7 +7700,7 @@ String* Item_cache_str::val_str(String *str) my_decimal *Item_cache_str::val_decimal(my_decimal *decimal_val) { DBUG_ASSERT(fixed == 1); - if (!value_cached && !cache_value()) + if (!has_value()) return NULL; if (value) string2my_decimal(E_DEC_FATAL_ERROR, value, decimal_val); @@ -7683,7 +7712,7 @@ my_decimal *Item_cache_str::val_decimal(my_decimal *decimal_val) int Item_cache_str::save_in_field(Field *field, bool no_conversions) { - if (!value_cached && !cache_value()) + if (!has_value()) return 0; int res= Item_cache::save_in_field(field, no_conversions); return (is_varbinary && field->type() == MYSQL_TYPE_STRING && diff --git a/sql/item.h b/sql/item.h index 11b4199da2c..e18fa43037a 100644 --- a/sql/item.h +++ b/sql/item.h @@ -34,6 +34,15 @@ void item_init(void); /* Init item functions */ class Item_field; class user_var_entry; + +static inline uint32 +char_to_byte_length_safe(uint32 char_length_arg, uint32 mbmaxlen_arg) +{ + ulonglong tmp= ((ulonglong) char_length_arg) * mbmaxlen_arg; + return (tmp > UINT_MAX32) ? (uint32) UINT_MAX32 : (uint32) tmp; +} + + /* "Declared Type Collation" A combination of collation and its derivation. @@ -1171,16 +1180,23 @@ public: { return max_length / collation.collation->mbmaxlen; } void fix_length_and_charset(uint32 max_char_length_arg, CHARSET_INFO *cs) { - max_length= max_char_length_arg * cs->mbmaxlen; + max_length= char_to_byte_length_safe(max_char_length_arg, cs->mbmaxlen); collation.collation= cs; } void fix_char_length(uint32 max_char_length_arg) - { max_length= max_char_length_arg * collation.collation->mbmaxlen; } + { + max_length= char_to_byte_length_safe(max_char_length_arg, + collation.collation->mbmaxlen); + } void fix_length_and_charset_datetime(uint32 max_char_length_arg) { collation.set(&my_charset_numeric, DERIVATION_NUMERIC, MY_REPERTOIRE_ASCII); fix_char_length(max_char_length_arg); } + /* + Return TRUE if the item points to a column of an outer-joined table. + */ + virtual bool is_outer_field() const { DBUG_ASSERT(fixed); return FALSE; } }; @@ -1694,6 +1710,11 @@ public: int fix_outer_field(THD *thd, Field **field, Item **reference); virtual Item *update_value_transformer(uchar *select_arg); virtual void print(String *str, enum_query_type query_type); + bool is_outer_field() const + { + DBUG_ASSERT(fixed); + return field->table->pos_in_table_list->outer_join; + } Field::geometry_type get_geometry_type() const { DBUG_ASSERT(field_type() == MYSQL_TYPE_GEOMETRY); @@ -2302,7 +2323,7 @@ public: class Item_hex_string: public Item_basic_constant { public: - Item_hex_string() {} + Item_hex_string(); Item_hex_string(const char *str,uint str_length); enum Type type() const { return VARBIN_ITEM; } double val_real() @@ -2322,6 +2343,8 @@ public: bool eq(const Item *item, bool binary_cmp) const; virtual Item *safe_charset_converter(CHARSET_INFO *tocs); bool check_partition_func_processor(uchar *int_arg) {return FALSE;} +private: + void hex_string_init(const char *str, uint str_length); }; @@ -2504,7 +2527,13 @@ public: DBUG_ASSERT(fixed); return (*ref)->get_time(ltime); } - bool basic_const_item() { return (*ref)->basic_const_item(); } + virtual bool basic_const_item() const { return (*ref)->basic_const_item(); } + bool is_outer_field() const + { + DBUG_ASSERT(fixed); + DBUG_ASSERT(ref); + return (*ref)->is_outer_field(); + } }; @@ -3189,6 +3218,15 @@ public: { return this == item; } + /** + Check if saved item has a non-NULL value. + Will cache value of saved item if not already done. + @return TRUE if cached value is non-NULL. + */ + bool has_value() + { + return (value_cached || cache_value()) && !null_value; + } virtual void store(Item *item); virtual bool cache_value()= 0; bool basic_const_item() const @@ -3356,6 +3394,7 @@ public: cmp_context= STRING_RESULT; } + virtual void store(Item *item) { Item_cache::store(item); } void store(Item *item, longlong val_arg); double val_real(); longlong val_int(); diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc index 19e8385539f..3c871bc0663 100644 --- a/sql/item_cmpfunc.cc +++ b/sql/item_cmpfunc.cc @@ -5466,7 +5466,21 @@ void Item_equal::update_const() Item *item; while ((item= it++)) { - if (item->const_item()) + if (item->const_item() && + /* + Don't propagate constant status of outer-joined column. + Such a constant status here is a result of: + a) empty outer-joined table: in this case such a column has a + value of NULL; but at the same time other arguments of + Item_equal don't have to be NULLs and the value of the whole + multiple equivalence expression doesn't have to be NULL or FALSE + because of the outer join nature; + or + b) outer-joined table contains only 1 row: the result of + this column is equal to a row field value *or* NULL. + Both values are inacceptable as Item_equal constants. + */ + !item->is_outer_field()) { it.remove(); add(item); @@ -5505,7 +5519,8 @@ void Item_equal::update_used_tables() { item->update_used_tables(); used_tables_cache|= item->used_tables(); - const_item_cache&= item->const_item(); + /* see commentary at Item_equal::update_const() */ + const_item_cache&= item->const_item() && !item->is_outer_field(); } } diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index afd25688e79..a0b3f2c29a1 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -60,9 +60,9 @@ public: /* Allow owner function to use string buffers. */ String value1, value2; - Arg_comparator(): thd(0), a_cache(0), b_cache(0), set_null(TRUE), + Arg_comparator(): comparators(0), thd(0), a_cache(0), b_cache(0), set_null(TRUE), get_value_a_func(0), get_value_b_func(0) {}; - Arg_comparator(Item **a1, Item **a2): a(a1), b(a2), thd(0), + Arg_comparator(Item **a1, Item **a2): a(a1), b(a2), comparators(0), thd(0), a_cache(0), b_cache(0), set_null(TRUE), get_value_a_func(0), get_value_b_func(0) {}; @@ -118,6 +118,11 @@ public: return (owner->type() == Item::FUNC_ITEM && ((Item_func*)owner)->functype() == Item_func::EQUAL_FUNC); } + void cleanup() + { + delete [] comparators; + comparators= 0; + } friend class Item_func; }; @@ -371,6 +376,11 @@ public: CHARSET_INFO *compare_collation() { return cmp.cmp_collation.collation; } uint decimal_precision() const { return 1; } void top_level_item() { abort_on_null= TRUE; } + void cleanup() + { + Item_int_func::cleanup(); + cmp.cleanup(); + } friend class Arg_comparator; }; diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc index f2b34fe59ed..61febb01e93 100644 --- a/sql/item_strfunc.cc +++ b/sql/item_strfunc.cc @@ -512,7 +512,7 @@ String *Item_func_concat::val_str(String *str) } else if (str->alloced_length() >= res->length()+res2->length()) { - if (str == res2) + if (str->ptr() == res2->ptr()) str->replace(0,0,*res); else { @@ -3192,8 +3192,7 @@ String *Item_load_file::val_str(String *str) MY_RELATIVE_PATH | MY_UNPACK_FILENAME); /* Read only allowed from within dir specified by secure_file_priv */ - if (opt_secure_file_priv && - strncmp(opt_secure_file_priv, path, strlen(opt_secure_file_priv))) + if (!is_secure_file_path(path)) goto err; if (!mysql_file_stat(key_file_loadfile, path, &stat_info, MYF(0))) diff --git a/sql/item_strfunc.h b/sql/item_strfunc.h index 7b7f8d3308a..2a34babae87 100644 --- a/sql/item_strfunc.h +++ b/sql/item_strfunc.h @@ -735,8 +735,9 @@ public: String *val_str(String *); void fix_length_and_dec() { + ulonglong max_result_length= (ulonglong) args[0]->max_length * 2 + 2; + max_length= (uint32) min(max_result_length, MAX_BLOB_WIDTH); collation.set(args[0]->collation); - max_length= args[0]->max_length * 2 + 2; } }; diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc index c341dd97460..10ef992594e 100644 --- a/sql/item_subselect.cc +++ b/sql/item_subselect.cc @@ -130,6 +130,21 @@ void Item_subselect::cleanup() DBUG_VOID_RETURN; } + +/* + We cannot use generic Item::safe_charset_converter() because + Subselect transformation does not happen in view_prepare_mode + and thus we can not evaluate val_...() for const items. +*/ + +Item *Item_subselect::safe_charset_converter(CHARSET_INFO *tocs) +{ + Item_func_conv_charset *conv= + new Item_func_conv_charset(this, tocs, thd->lex->view_prepare_mode ? 0 : 1); + return conv->safe ? conv : NULL; +} + + void Item_singlerow_subselect::cleanup() { DBUG_ENTER("Item_singlerow_subselect::cleanup"); diff --git a/sql/item_subselect.h b/sql/item_subselect.h index 04daab19adc..34b09ca6fdc 100644 --- a/sql/item_subselect.h +++ b/sql/item_subselect.h @@ -138,6 +138,7 @@ public: virtual void reset_value_registration() {} enum_parsing_place place() { return parsing_place; } bool walk(Item_processor processor, bool walk_subquery, uchar *arg); + Item *safe_charset_converter(CHARSET_INFO *tocs); /** Get the SELECT_LEX structure associated with this Item. diff --git a/sql/item_sum.cc b/sql/item_sum.cc index 4746a6057c6..15927c4b11e 100644 --- a/sql/item_sum.cc +++ b/sql/item_sum.cc @@ -2827,6 +2827,7 @@ String *Item_sum_udf_str::val_str(String *str) @retval 1 : key1 > key2 */ +extern "C" int group_concat_key_cmp_with_distinct(void* arg, const void* key1, const void* key2) { @@ -2861,6 +2862,7 @@ int group_concat_key_cmp_with_distinct(void* arg, const void* key1, function of sort for syntax: GROUP_CONCAT(expr,... ORDER BY col,... ) */ +extern "C" int group_concat_key_cmp_with_order(void* arg, const void* key1, const void* key2) { @@ -2905,13 +2907,16 @@ int group_concat_key_cmp_with_order(void* arg, const void* key1, Append data from current leaf to item->result. */ -int dump_leaf_key(uchar* key, element_count count __attribute__((unused)), - Item_func_group_concat *item) +extern "C" +int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)), + void* item_arg) { + Item_func_group_concat *item= (Item_func_group_concat *) item_arg; TABLE *table= item->table; String tmp((char *)table->record[1], table->s->reclength, default_charset_info); String tmp2; + uchar *key= (uchar *) key_arg; String *result= &item->result; Item **arg= item->args, **arg_end= item->args + item->arg_count_field; uint old_length= result->length(); @@ -3385,8 +3390,7 @@ String* Item_func_group_concat::val_str(String* str) return 0; if (no_appended && tree) /* Tree is used for sorting as in ORDER BY */ - tree_walk(tree, (tree_walk_action)&dump_leaf_key, (void*)this, - left_root_right); + tree_walk(tree, &dump_leaf_key, this, left_root_right); return &result; } @@ -3411,7 +3415,7 @@ void Item_func_group_concat::print(String *str, enum_query_type query_type) { if (i) str->append(','); - (*order[i]->item)->print(str, query_type); + pargs[i + arg_count_field]->print(str, query_type); if (order[i]->asc) str->append(STRING_WITH_LEN(" ASC")); else diff --git a/sql/item_sum.h b/sql/item_sum.h index 5f2c4f166e6..99fcb14d160 100644 --- a/sql/item_sum.h +++ b/sql/item_sum.h @@ -303,6 +303,8 @@ class st_select_lex; class Item_sum :public Item_result_field { + friend class Aggregator_distinct; + protected: /** Aggregator class instance. Not set initially. Allocated only after @@ -1317,6 +1319,16 @@ public: #endif /* HAVE_DLOPEN */ +C_MODE_START +int group_concat_key_cmp_with_distinct(void* arg, const void* key1, + const void* key2); +int group_concat_key_cmp_with_order(void* arg, const void* key1, + const void* key2); +int dump_leaf_key(void* key_arg, + element_count count __attribute__((unused)), + void* item_arg); +C_MODE_END + class Item_func_group_concat : public Item_sum { TMP_TABLE_PARAM *tmp_table_param; @@ -1356,9 +1368,9 @@ class Item_func_group_concat : public Item_sum const void* key2); friend int group_concat_key_cmp_with_order(void* arg, const void* key1, const void* key2); - friend int dump_leaf_key(uchar* key, + friend int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)), - Item_func_group_concat *group_concat_item); + void* item_arg); public: Item_func_group_concat(Name_resolution_context *context_arg, diff --git a/sql/key.cc b/sql/key.cc index d593850ca10..582334620ad 100644 --- a/sql/key.cc +++ b/sql/key.cc @@ -354,6 +354,16 @@ void key_unpack(String *to,TABLE *table,uint idx) { CHARSET_INFO *cs= field->charset(); field->val_str(&tmp); + /* + For BINARY(N) strip trailing zeroes to make + the error message nice-looking + */ + if (field->binary() && field->type() == MYSQL_TYPE_STRING && tmp.length()) + { + const char *tmp_end= tmp.ptr() + tmp.length(); + while (tmp_end > tmp.ptr() && !*--tmp_end); + tmp.length(tmp_end - tmp.ptr() + 1); + } if (cs->mbmaxlen > 1 && table->field[key_part->fieldnr - 1]->field_length != key_part->length) diff --git a/sql/lock.cc b/sql/lock.cc index fbe15fde3b0..d35f2c359fb 100644 --- a/sql/lock.cc +++ b/sql/lock.cc @@ -533,20 +533,6 @@ void mysql_lock_remove(THD *thd, MYSQL_LOCK *locked,TABLE *table) } } -/* Downgrade all locks on a table to new WRITE level from WRITE_ONLY */ - -void mysql_lock_downgrade_write(THD *thd, TABLE *table, - thr_lock_type new_lock_type) -{ - MYSQL_LOCK *locked; - if ((locked = get_lock_data(thd, &table, 1, GET_LOCK_UNLOCK))) - { - for (uint i=0; i < locked->lock_count; i++) - thr_downgrade_write_lock(locked->locks[i], new_lock_type); - my_free((uchar*) locked,MYF(0)); - } -} - /** Abort all other threads waiting to get lock in table. */ diff --git a/sql/lock.h b/sql/lock.h index 5425a6ccb13..84c7bce0679 100644 --- a/sql/lock.h +++ b/sql/lock.h @@ -52,52 +52,22 @@ typedef struct st_mysql_lock MYSQL_LOCK; MYSQL_OPEN_HAS_MDL_LOCK) -#include "thr_lock.h" /* thr_lock_type */ - -struct TABLE_LIST; -class THD; -struct TABLE; -typedef struct st_mysql_lock MYSQL_LOCK; - MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **table, uint count, uint flags); void mysql_unlock_tables(THD *thd, MYSQL_LOCK *sql_lock); void mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock); void mysql_unlock_some_tables(THD *thd, TABLE **table,uint count); void mysql_lock_remove(THD *thd, MYSQL_LOCK *locked,TABLE *table); void mysql_lock_abort(THD *thd, TABLE *table, bool upgrade_lock); -void mysql_lock_downgrade_write(THD *thd, TABLE *table, - thr_lock_type new_lock_type); bool mysql_lock_abort_for_thread(THD *thd, TABLE *table); MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b); TABLE_LIST *mysql_lock_have_duplicate(THD *thd, TABLE_LIST *needle, TABLE_LIST *haystack); -bool lock_global_read_lock(THD *thd); -void unlock_global_read_lock(THD *thd); -bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh, - bool is_not_commit); -void start_waiting_global_read_lock(THD *thd); -bool make_global_read_lock_block_commit(THD *thd); -bool set_protect_against_global_read_lock(void); -void unset_protect_against_global_read_lock(void); -/* Lock based on stored routine name */ -bool lock_routine_name(THD *thd, bool is_function, const char *db, - const char *name); void broadcast_refresh(void); - /* Lock based on name */ -int lock_and_wait_for_table_name(THD *thd, TABLE_LIST *table_list); -int lock_table_name(THD *thd, TABLE_LIST *table_list, bool check_in_use); -void unlock_table_name(THD *thd, TABLE_LIST *table_list); -bool wait_for_locked_table_names(THD *thd, TABLE_LIST *table_list); bool lock_table_names(THD *thd, TABLE_LIST *table_list); void unlock_table_names(THD *thd); -bool lock_table_names_exclusively(THD *thd, TABLE_LIST *table_list); -bool is_table_name_exclusively_locked_by_this_thread(THD *thd, - TABLE_LIST *table_list); -bool is_table_name_exclusively_locked_by_this_thread(THD *thd, uchar *key, - int key_length); -void broadcast_refresh(void); - - +/* Lock based on stored routine name */ +bool lock_routine_name(THD *thd, bool is_function, const char *db, + const char *name); #endif /* LOCK_INCLUDED */ diff --git a/sql/log.cc b/sql/log.cc index 308b8349ad6..680a56ec161 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -1528,11 +1528,6 @@ binlog_flush_trx_cache(THD *thd, binlog_cache_mngr *cache_mngr, cache_mngr->trx_cache.has_incident()); cache_mngr->reset_cache(&cache_mngr->trx_cache); - /* - We need to step the table map version after writing the - transaction cache to disk. - */ - mysql_bin_log.update_table_map_version(); statistic_increment(binlog_cache_use, &LOCK_status); if (cache_log->disk_writes != 0) { @@ -1592,13 +1587,6 @@ binlog_truncate_trx_cache(THD *thd, binlog_cache_mngr *cache_mngr, bool all) else cache_mngr->trx_cache.restore_prev_position(); - /* - We need to step the table map version on a rollback to ensure that a new - table map event is generated instead of the one that was written to the - thrown-away transaction cache. - */ - mysql_bin_log.update_table_map_version(); - DBUG_ASSERT(thd->binlog_get_pending_rows_event(is_transactional) == NULL); DBUG_RETURN(error); } @@ -1650,11 +1638,6 @@ binlog_flush_stmt_cache(THD *thd, binlog_cache_mngr *cache_mngr) DBUG_RETURN(error); cache_mngr->reset_cache(&cache_mngr->stmt_cache); - /* - We need to step the table map version after writing the - transaction cache to disk. - */ - mysql_bin_log.update_table_map_version(); statistic_increment(binlog_cache_use, &LOCK_status); if (cache_log->disk_writes != 0) { @@ -1890,12 +1873,14 @@ static int binlog_savepoint_set(handlerton *hton, THD *thd, void *sv) binlog_trans_log_savepos(thd, (my_off_t*) sv); /* Write it to the binary log */ + String log_query; + if (log_query.append(STRING_WITH_LEN("SAVEPOINT ")) || + log_query.append(thd->lex->ident.str, thd->lex->ident.length)) + DBUG_RETURN(1); int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED); - int const error= - thd->binlog_query(THD::STMT_QUERY_TYPE, - thd->query(), thd->query_length(), TRUE, FALSE, FALSE, - errcode); - DBUG_RETURN(error); + Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(), + TRUE, FALSE, TRUE, errcode); + DBUG_RETURN(mysql_bin_log.write(&qinfo)); } static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv) @@ -1910,12 +1895,14 @@ static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv) if (unlikely(trans_has_updated_non_trans_table(thd) || (thd->variables.option_bits & OPTION_KEEP_LOG))) { + String log_query; + if (log_query.append(STRING_WITH_LEN("ROLLBACK TO ")) || + log_query.append(thd->lex->ident.str, thd->lex->ident.length)) + DBUG_RETURN(1); int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED); - int error= - thd->binlog_query(THD::STMT_QUERY_TYPE, - thd->query(), thd->query_length(), TRUE, FALSE, FALSE, - errcode); - DBUG_RETURN(error); + Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(), + TRUE, FALSE, TRUE, errcode); + DBUG_RETURN(mysql_bin_log.write(&qinfo)); } binlog_trans_log_truncate(thd, *(my_off_t*)sv); DBUG_RETURN(0); @@ -2658,7 +2645,7 @@ const char *MYSQL_LOG::generate_name(const char *log_name, MYSQL_BIN_LOG::MYSQL_BIN_LOG(uint *sync_period) :bytes_written(0), prepared_xids(0), file_id(1), open_count(1), - need_start_event(TRUE), m_table_map_version(0), + need_start_event(TRUE), sync_period_ptr(sync_period), is_relay_log(0), signal_cnt(0), description_event_for_exec(0), description_event_for_queue(0) @@ -4443,7 +4430,6 @@ int THD::binlog_write_table_map(TABLE *table, bool is_transactional) DBUG_RETURN(error); binlog_table_maps++; - table->s->table_map_version= mysql_bin_log.table_map_version(); DBUG_RETURN(0); } @@ -4585,21 +4571,6 @@ MYSQL_BIN_LOG::flush_and_set_pending_rows_event(THD *thd, DBUG_RETURN(1); } - /* - We step the table map version if we are writing an event - representing the end of a statement. - - In an ideal world, we could avoid stepping the table map version, - since we could then reuse the table map that was written earlier - in the cache. This does not work since STMT_END_F implies closing - all table mappings on the slave side. - - TODO: Find a solution so that table maps does not have to be - written several times within a transaction. - */ - if (pending->get_flags(Rows_log_event::STMT_END_F)) - ++m_table_map_version; - delete pending; } @@ -4657,7 +4628,9 @@ bool MYSQL_BIN_LOG::write(Log_event *event_info) */ const char *local_db= event_info->get_db(); if ((thd && !(thd->variables.option_bits & OPTION_BIN_LOG)) || - !binlog_filter->db_ok(local_db)) + (thd->lex->sql_command != SQLCOM_ROLLBACK_TO_SAVEPOINT && + thd->lex->sql_command != SQLCOM_SAVEPOINT && + !binlog_filter->db_ok(local_db))) DBUG_RETURN(0); #endif /* HAVE_REPLICATION */ @@ -4786,9 +4759,6 @@ unlock: } } - if (event_info->flags & LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F) - ++m_table_map_version; - DBUG_RETURN(error); } diff --git a/sql/log.h b/sql/log.h index e12d2475d0b..d264f62fb64 100644 --- a/sql/log.h +++ b/sql/log.h @@ -299,8 +299,6 @@ class MYSQL_BIN_LOG: public TC_LOG, private MYSQL_LOG */ bool no_auto_events; - ulonglong m_table_map_version; - /* pointer to the sync period variable, for binlog this will be sync_binlog_period, for relay log this will be sync_relay_log_period @@ -353,13 +351,6 @@ public: void unlog(ulong cookie, my_xid xid); int recover(IO_CACHE *log, Format_description_log_event *fdle); #if !defined(MYSQL_CLIENT) - bool is_table_mapped(TABLE *table) const - { - return table->s->table_map_version == table_map_version(); - } - - ulonglong table_map_version() const { return m_table_map_version; } - void update_table_map_version() { ++m_table_map_version; } int flush_and_set_pending_rows_event(THD *thd, Rows_log_event* event, bool is_transactional); diff --git a/sql/log_event.cc b/sql/log_event.cc index d5ae1c954ff..f7c6d09f98f 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -2465,95 +2465,62 @@ Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg, else time_zone_len= 0; + LEX *lex= thd->lex; /* - In what follows, we decide whether to write to the binary log or to use a - cache. + TRUE defines that either a trx-cache or stmt-cache must be used + and wrapped by a BEGIN...COMMIT. Otherwise, the statement will + be written directly to the binary log without being wrapped by + a BEGIN...COMMIT. + + Note that a cache will not be used if the parameter direct is + TRUE. */ - LEX *lex= thd->lex; - bool implicit_commit= FALSE; - bool force_trans= FALSE; + bool use_cache= FALSE; + /* + TRUE defines that the trx-cache must be used and by consequence + the use_cache is TRUE. + + Note that a cache will not be used if the parameter direct is + TRUE. + */ + bool trx_cache= FALSE; cache_type= Log_event::EVENT_INVALID_CACHE; + switch (lex->sql_command) { - case SQLCOM_ALTER_DB: - case SQLCOM_CREATE_FUNCTION: - case SQLCOM_DROP_FUNCTION: - case SQLCOM_DROP_PROCEDURE: - case SQLCOM_INSTALL_PLUGIN: - case SQLCOM_UNINSTALL_PLUGIN: - case SQLCOM_ALTER_TABLESPACE: - implicit_commit= TRUE; - break; case SQLCOM_DROP_TABLE: - force_trans= lex->drop_temporary && thd->in_multi_stmt_transaction_mode(); - implicit_commit= !force_trans; - break; - case SQLCOM_ALTER_TABLE: + use_cache= trx_cache= (lex->drop_temporary && + thd->in_multi_stmt_transaction_mode()); + break; + case SQLCOM_CREATE_TABLE: - force_trans= (lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) && - thd->in_multi_stmt_transaction_mode(); - implicit_commit= !force_trans && - !(lex->select_lex.item_list.elements && - thd->is_current_stmt_binlog_format_row()); + use_cache= trx_cache= + ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) && + thd->in_multi_stmt_transaction_mode()) || + (lex->select_lex.item_list.elements && + thd->is_current_stmt_binlog_format_row()); break; case SQLCOM_SET_OPTION: - implicit_commit= (lex->autocommit ? TRUE : FALSE); + use_cache= trx_cache= (lex->autocommit ? FALSE : TRUE); break; - /* - Replace what follows after CF_AUTO_COMMIT_TRANS is backported by: - - default: - implicit_commit= ((sql_command_flags[lex->sql_command] & - CF_AUTO_COMMIT_TRANS)); - break; - */ - case SQLCOM_CREATE_INDEX: - case SQLCOM_TRUNCATE: - case SQLCOM_CREATE_DB: - case SQLCOM_DROP_DB: - case SQLCOM_ALTER_DB_UPGRADE: - case SQLCOM_RENAME_TABLE: - case SQLCOM_DROP_INDEX: - case SQLCOM_CREATE_VIEW: - case SQLCOM_DROP_VIEW: - case SQLCOM_CREATE_TRIGGER: - case SQLCOM_DROP_TRIGGER: - case SQLCOM_CREATE_EVENT: - case SQLCOM_ALTER_EVENT: - case SQLCOM_DROP_EVENT: - case SQLCOM_REPAIR: - case SQLCOM_OPTIMIZE: - case SQLCOM_ANALYZE: - case SQLCOM_CREATE_USER: - case SQLCOM_DROP_USER: - case SQLCOM_RENAME_USER: - case SQLCOM_REVOKE_ALL: - case SQLCOM_REVOKE: - case SQLCOM_GRANT: - case SQLCOM_CREATE_PROCEDURE: - case SQLCOM_CREATE_SPFUNCTION: - case SQLCOM_ALTER_PROCEDURE: - case SQLCOM_ALTER_FUNCTION: - case SQLCOM_ASSIGN_TO_KEYCACHE: - case SQLCOM_PRELOAD_KEYS: - case SQLCOM_FLUSH: - case SQLCOM_RESET: - case SQLCOM_CHECK: - implicit_commit= TRUE; + case SQLCOM_RELEASE_SAVEPOINT: + case SQLCOM_ROLLBACK_TO_SAVEPOINT: + case SQLCOM_SAVEPOINT: + use_cache= trx_cache= TRUE; break; default: - implicit_commit= FALSE; + use_cache= sqlcom_can_generate_row_events(thd); break; } - if (implicit_commit || direct) + if (!use_cache || direct) { cache_type= Log_event::EVENT_NO_CACHE; } else { - cache_type= ((using_trans || stmt_has_updated_trans_table(thd) || - force_trans || thd->thread_temporary_used) + cache_type= ((using_trans || stmt_has_updated_trans_table(thd) + || trx_cache || thd->thread_temporary_used) ? Log_event::EVENT_TRANSACTIONAL_CACHE : Log_event::EVENT_STMT_CACHE); } @@ -3189,10 +3156,7 @@ int Query_log_event::do_apply_event(Relay_log_info const *rli, ::do_apply_event(), then the companion SET also have so we don't need to reset_one_shot_variables(). */ - if (!strncmp(query_arg, "BEGIN", q_len_arg) || - !strncmp(query_arg, "COMMIT", q_len_arg) || - !strncmp(query_arg, "ROLLBACK", q_len_arg) || - rpl_filter->db_ok(thd->db)) + if (is_trans_keyword() || rpl_filter->db_ok(thd->db)) { thd->set_time((time_t)when); thd->set_query_and_id((char*)query_arg, q_len_arg, next_query_id()); @@ -3354,11 +3318,12 @@ compare_errors: */ actual_error= thd->is_error() ? thd->stmt_da->sql_errno() : 0; DBUG_PRINT("info",("expected_error: %d sql_errno: %d", - expected_error, actual_error)); + expected_error, actual_error)); + if ((expected_error && expected_error != actual_error && !concurrency_error_code(expected_error)) && - !ignored_error_code(actual_error) && - !ignored_error_code(expected_error)) + !ignored_error_code(actual_error) && + !ignored_error_code(expected_error)) { rli->report(ERROR_LEVEL, 0, "\ @@ -3376,9 +3341,9 @@ Default database: '%s'. Query: '%s'", If we get the same error code as expected and it is not a concurrency issue, or should be ignored. */ - else if ((expected_error == actual_error && + else if ((expected_error == actual_error && !concurrency_error_code(expected_error)) || - ignored_error_code(actual_error)) + ignored_error_code(actual_error)) { DBUG_PRINT("info",("error ignored")); clear_all_errors(thd, const_cast<Relay_log_info*>(rli)); @@ -3397,7 +3362,7 @@ Default database: '%s'. Query: '%s'", If we expected a non-zero error code and get nothing and, it is a concurrency issue or should be ignored. */ - else if (expected_error && !actual_error && + else if (expected_error && !actual_error && (concurrency_error_code(expected_error) || ignored_error_code(expected_error))) trans_rollback_stmt(thd); @@ -3438,12 +3403,13 @@ Default database: '%s'. Query: '%s'", */ } /* End of if (db_ok(... */ - {/** - The following failure injecion works in cooperation with tests + { + /** + The following failure injecion works in cooperation with tests setting @@global.debug= 'd,stop_slave_middle_group'. - The sql thread receives the killed status and will proceed + The sql thread receives the killed status and will proceed to shutdown trying to finish incomplete events group. - */ + */ DBUG_EXECUTE_IF("stop_slave_middle_group", if (strcmp("COMMIT", query) != 0 && strcmp("BEGIN", query) != 0) @@ -3458,7 +3424,7 @@ end: Probably we have set thd->query, thd->db, thd->catalog to point to places in the data_buf of this event. Now the event is going to be deleted probably, so data_buf will be freed, so the thd->... listed above will be - pointers to freed memory. + pointers to freed memory. So we must set them to 0, so that those bad pointers values are not later used. Note that "cleanup" queries like automatic DROP TEMPORARY TABLE don't suffer from these assignments to 0 as DROP TEMPORARY @@ -3468,7 +3434,7 @@ end: thd->set_db(NULL, 0); /* will free the current database */ thd->set_query(NULL, 0); DBUG_PRINT("info", ("end: query= 0")); - close_thread_tables(thd); + close_thread_tables(thd); /* As a disk space optimization, future masters will not log an event for LAST_INSERT_ID() if that function returned 0 (and thus they will be able @@ -3770,7 +3736,7 @@ Format_description_log_event(uint8 binlog_ver, const char* server_ver) */ if (post_header_len) { -#ifndef DBUG_OFF +#ifndef DBUG_OFF // Allows us to sanity-check that all events initialized their // events (see the end of this 'if' block). memset(post_header_len, 255, number_of_event_types*sizeof(uint8)); @@ -4624,9 +4590,9 @@ void Load_log_event::print(FILE* file_arg, PRINT_EVENT_INFO* print_event_info, for (i = 0; i < num_fields; i++) { if (i) - my_b_printf(&cache, ","); + my_b_printf(&cache, ","); my_b_printf(&cache, "%s", field); - + field += field_lens[i] + 1; } my_b_printf(&cache, ")"); @@ -4796,9 +4762,7 @@ int Load_log_event::do_apply_event(NET* net, Relay_log_info const *rli, thd->set_query(load_data_query, (uint) (end - load_data_query)); if (sql_ex.opt_flags & REPLACE_FLAG) - { - handle_dup= DUP_REPLACE; - } + handle_dup= DUP_REPLACE; else if (sql_ex.opt_flags & IGNORE_FLAG) { ignore= 1; @@ -4807,14 +4771,14 @@ int Load_log_event::do_apply_event(NET* net, Relay_log_info const *rli, else { /* - When replication is running fine, if it was DUP_ERROR on the + When replication is running fine, if it was DUP_ERROR on the master then we could choose IGNORE here, because if DUP_ERROR suceeded on master, and data is identical on the master and slave, then there should be no uniqueness errors on slave, so IGNORE is the same as DUP_ERROR. But in the unlikely case of uniqueness errors (because the data on the master and slave happen to be different - (user error or bug), we want LOAD DATA to print an error message on - the slave to discover the problem. + (user error or bug), we want LOAD DATA to print an error message on + the slave to discover the problem. If reading from net (a 3.23 master), mysql_load() will change this to IGNORE. @@ -4846,7 +4810,7 @@ int Load_log_event::do_apply_event(NET* net, Relay_log_info const *rli, ex.opt_enclosed = (sql_ex.opt_flags & OPT_ENCLOSED_FLAG); if (sql_ex.empty_flags & FIELD_TERM_EMPTY) - ex.field_term->length(0); + ex.field_term->length(0); ex.skip_lines = skip_lines; List<Item> field_list; @@ -4855,12 +4819,10 @@ int Load_log_event::do_apply_event(NET* net, Relay_log_info const *rli, thd->variables.pseudo_thread_id= thread_id; if (net) { - // mysql_load will use thd->net to read the file - thd->net.vio = net->vio; - /* - Make sure the client does not get confused about the packet sequence - */ - thd->net.pkt_nr = net->pkt_nr; + // mysql_load will use thd->net to read the file + thd->net.vio = net->vio; + // Make sure the client does not get confused about the packet sequence + thd->net.pkt_nr = net->pkt_nr; } /* It is safe to use tmp_list twice because we are not going to @@ -4872,7 +4834,7 @@ int Load_log_event::do_apply_event(NET* net, Relay_log_info const *rli, thd->is_slave_error= 1; if (thd->cuted_fields) { - /* log_pos is the position of the LOAD event in the master log */ + /* log_pos is the position of the LOAD event in the master log */ sql_print_warning("Slave: load data infile on table '%s' at " "log position %s in log '%s' produced %ld " "warning(s). Default database: '%s'", @@ -5620,10 +5582,10 @@ User_var_log_event(const char* buf, { type= (Item_result) buf[UV_VAL_IS_NULL]; charset_number= uint4korr(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE); - val_len= uint4korr(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + - UV_CHARSET_NUMBER_SIZE); + val_len= uint4korr(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + + UV_CHARSET_NUMBER_SIZE); val= (char *) (buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + - UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE); + UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE); /** We need to check if this is from an old server @@ -5707,9 +5669,9 @@ bool User_var_log_event::write(IO_CACHE* file) return (write_header(file, event_length) || my_b_safe_write(file, (uchar*) buf, sizeof(buf)) || - my_b_safe_write(file, (uchar*) name, name_len) || - my_b_safe_write(file, (uchar*) buf1, buf1_length) || - my_b_safe_write(file, pos, val_len) || + my_b_safe_write(file, (uchar*) name, name_len) || + my_b_safe_write(file, (uchar*) buf1, buf1_length) || + my_b_safe_write(file, pos, val_len) || my_b_safe_write(file, &flags, unsigned_len)); } #endif @@ -5983,7 +5945,7 @@ Slave_log_event::Slave_log_event(THD* thd_arg, master_log_len = strlen(rli->group_master_log_name); // on OOM, just do not initialize the structure and print the error if ((mem_pool = (char*)my_malloc(get_data_size() + 1, - MYF(MY_WME)))) + MYF(MY_WME)))) { master_host = mem_pool + SL_MASTER_HOST_OFFSET ; memcpy(master_host, mi->host, master_host_len + 1); @@ -5992,7 +5954,7 @@ Slave_log_event::Slave_log_event(THD* thd_arg, master_port = mi->port; master_pos = rli->group_master_log_pos; DBUG_PRINT("info", ("master_log: %s pos: %lu", master_log, - (ulong) master_pos)); + (ulong) master_pos)); } else sql_print_error("Out of memory while recording slave event"); @@ -8941,11 +8903,28 @@ static bool record_compare(TABLE *table) { for (int i = 0 ; i < 2 ; ++i) { - saved_x[i]= table->record[i][0]; - saved_filler[i]= table->record[i][table->s->null_bytes - 1]; - table->record[i][0]|= 1U; - table->record[i][table->s->null_bytes - 1]|= - 256U - (1U << table->s->last_null_bit_pos); + /* + If we have an X bit then we need to take care of it. + */ + if (!(table->s->db_options_in_use & HA_OPTION_PACK_RECORD)) + { + saved_x[i]= table->record[i][0]; + table->record[i][0]|= 1U; + } + + /* + If (last_null_bit_pos == 0 && null_bytes > 1), then: + + X bit (if any) + N nullable fields + M Field_bit fields = 8 bits + + Ie, the entire byte is used. + */ + if (table->s->last_null_bit_pos > 0) + { + saved_filler[i]= table->record[i][table->s->null_bytes - 1]; + table->record[i][table->s->null_bytes - 1]|= + 256U - (1U << table->s->last_null_bit_pos); + } } } @@ -8985,8 +8964,11 @@ record_compare_exit: { for (int i = 0 ; i < 2 ; ++i) { - table->record[i][0]= saved_x[i]; - table->record[i][table->s->null_bytes - 1]= saved_filler[i]; + if (!(table->s->db_options_in_use & HA_OPTION_PACK_RECORD)) + table->record[i][0]= saved_x[i]; + + if (table->s->last_null_bit_pos) + table->record[i][table->s->null_bytes - 1]= saved_filler[i]; } } diff --git a/sql/log_event.h b/sql/log_event.h index e281fd6e206..bd95c74b6c5 100644 --- a/sql/log_event.h +++ b/sql/log_event.h @@ -469,10 +469,10 @@ struct sql_ex_info #define LOG_EVENT_SUPPRESS_USE_F 0x8 /* - The table map version internal to the log should be increased after - the event has been written to the binary log. + Note: this is a place holder for the flag + LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F (0x10), which is not used any + more, please do not reused this value for other flags. */ -#define LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F 0x10 /** @def LOG_EVENT_ARTIFICIAL_F @@ -1746,6 +1746,28 @@ public: /* !!! Public in this patch to allow old usage */ const char *query_arg, uint32 q_len_arg); #endif /* HAVE_REPLICATION */ + /* + If true, the event always be applied by slave SQL thread or be printed by + mysqlbinlog + */ + bool is_trans_keyword() + { + /* + Before the patch for bug#50407, The 'SAVEPOINT and ROLLBACK TO' + queries input by user was written into log events directly. + So the keywords can be written in both upper case and lower case + together, strncasecmp is used to check both cases. they also could be + binlogged with comments in the front of these keywords. for examples: + / * bla bla * / SAVEPOINT a; + / * bla bla * / ROLLBACK TO a; + but we don't handle these cases and after the patch, both quiries are + binlogged in upper case with no comments. + */ + return !strncmp(query, "BEGIN", q_len) || + !strncmp(query, "COMMIT", q_len) || + !strncasecmp(query, "SAVEPOINT", 9) || + !strncasecmp(query, "ROLLBACK", 8); + } }; diff --git a/sql/log_event_old.cc b/sql/log_event_old.cc index f6c5b5d1023..76eda43aa48 100644 --- a/sql/log_event_old.cc +++ b/sql/log_event_old.cc @@ -314,12 +314,29 @@ static bool record_compare(TABLE *table) if (table->s->null_bytes > 0) { for (int i = 0 ; i < 2 ; ++i) - { - saved_x[i]= table->record[i][0]; - saved_filler[i]= table->record[i][table->s->null_bytes - 1]; - table->record[i][0]|= 1U; - table->record[i][table->s->null_bytes - 1]|= - 256U - (1U << table->s->last_null_bit_pos); + { + /* + If we have an X bit then we need to take care of it. + */ + if (!(table->s->db_options_in_use & HA_OPTION_PACK_RECORD)) + { + saved_x[i]= table->record[i][0]; + table->record[i][0]|= 1U; + } + + /* + If (last_null_bit_pos == 0 && null_bytes > 1), then: + + X bit (if any) + N nullable fields + M Field_bit fields = 8 bits + + Ie, the entire byte is used. + */ + if (table->s->last_null_bit_pos > 0) + { + saved_filler[i]= table->record[i][table->s->null_bytes - 1]; + table->record[i][table->s->null_bytes - 1]|= + 256U - (1U << table->s->last_null_bit_pos); + } } } @@ -359,8 +376,11 @@ record_compare_exit: { for (int i = 0 ; i < 2 ; ++i) { - table->record[i][0]= saved_x[i]; - table->record[i][table->s->null_bytes - 1]= saved_filler[i]; + if (!(table->s->db_options_in_use & HA_OPTION_PACK_RECORD)) + table->record[i][0]= saved_x[i]; + + if (table->s->last_null_bit_pos > 0) + table->record[i][table->s->null_bytes - 1]= saved_filler[i]; } } diff --git a/sql/mdl.h b/sql/mdl.h index 0710155d10c..ef133520140 100644 --- a/sql/mdl.h +++ b/sql/mdl.h @@ -714,7 +714,7 @@ void mdl_destroy(); extern bool mysql_notify_thread_having_shared_lock(THD *thd, THD *in_use, bool needs_thr_lock_abort); extern void mysql_ha_flush(THD *thd); -extern "C" const char *set_thd_proc_info(THD *thd, const char *info, +extern "C" const char *set_thd_proc_info(void *thd_arg, const char *info, const char *calling_function, const char *calling_file, const unsigned int calling_line); diff --git a/sql/mysqld.cc b/sql/mysqld.cc index b35e2545a18..db0080451f2 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -400,6 +400,7 @@ ulonglong log_output_options; my_bool opt_log_queries_not_using_indexes= 0; bool opt_error_log= IF_WIN(1,0); bool opt_disable_networking=0, opt_skip_show_db=0; +bool opt_skip_name_resolve=0; my_bool opt_character_set_client_handshake= 1; bool server_id_supplied = 0; bool opt_endinfo, using_udf_functions; @@ -856,12 +857,15 @@ void Buffered_logs::print() /** Logs reported before a logger is available. */ static Buffered_logs buffered_logs; +#ifndef EMBEDDED_LIBRARY /** Error reporter that buffer log messages. @param level log message level @param format log message format string */ -void buffered_option_error_reporter(enum loglevel level, const char *format, ...) +C_MODE_START +static void buffered_option_error_reporter(enum loglevel level, + const char *format, ...) { va_list args; char buffer[1024]; @@ -871,6 +875,8 @@ void buffered_option_error_reporter(enum loglevel level, const char *format, ... va_end(args); buffered_logs.buffer(level, buffer); } +C_MODE_END +#endif /* !EMBEDDED_LIBRARY */ #endif /* WITH_PERFSCHEMA_STORAGE_ENGINE */ static my_socket unix_sock,ip_sock; @@ -972,7 +978,6 @@ uint connection_count= 0; pthread_handler_t signal_hand(void *arg); static int mysql_init_variables(void); -extern "C" void option_error_reporter(enum loglevel level, const char *format, ...); static int get_options(int *argc_ptr, char ***argv_ptr); static bool add_terminator(DYNAMIC_ARRAY *options); extern "C" my_bool mysqld_get_one_option(int, const struct my_option *, char *); @@ -3600,7 +3605,6 @@ static int init_common_variables() if (item_create_init()) return 1; item_init(); - mysys_uses_curses=0; #ifdef USE_REGEX my_regex_init(&my_charset_latin1); #endif @@ -4020,9 +4024,8 @@ static int init_server_components() } } - proc_info_hook= (const char *(*)(void *, const char *, const char *, - const char *, const unsigned int)) - set_thd_proc_info; + proc_info_hook= set_thd_proc_info; + #ifdef WITH_PERFSCHEMA_STORAGE_ENGINE /* Parsing the performance schema command line option may have reported @@ -5343,11 +5346,11 @@ inline void kill_broken_server() void handle_connections_sockets() { - my_socket sock,new_sock; + my_socket UNINIT_VAR(sock), UNINIT_VAR(new_sock); uint error_count=0; THD *thd; struct sockaddr_storage cAddr; - int ip_flags=0,socket_flags=0,flags,retval; + int ip_flags=0,socket_flags=0,flags=0,retval; st_vio *vio_tmp; #ifdef HAVE_POLL int socket_count= 0; @@ -5359,8 +5362,6 @@ void handle_connections_sockets() DBUG_ENTER("handle_connections_sockets"); - LINT_INIT(new_sock); - #ifndef HAVE_POLL FD_ZERO(&clientFDs); #endif @@ -6211,9 +6212,6 @@ Can't be set to 1 if --log-slave-updates is used.", #endif {"skip-host-cache", OPT_SKIP_HOST_CACHE, "Don't cache host names.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}, - {"skip-name-resolve", OPT_SKIP_RESOLVE, - "Don't resolve hostnames. All hostnames are IP's or 'localhost'.", - 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}, {"skip-new", OPT_SKIP_NEW, "Don't use new, possibly wrong routines.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}, {"skip-slave-start", 0, @@ -6965,6 +6963,7 @@ static int mysql_init_variables(void) opt_log= opt_slow_log= 0; opt_bin_log= 0; opt_disable_networking= opt_skip_show_db=0; + opt_skip_name_resolve= 0; opt_ignore_builtin_innodb= 0; opt_logname= opt_update_logname= opt_binlog_index_name= opt_slow_logname= 0; opt_tc_log_file= (char *)"tc.log"; // no hostname in tc_log file name ! @@ -7334,6 +7333,7 @@ mysqld_get_one_option(int optid, opt_specialflag|= SPECIAL_NO_HOST_CACHE; break; case (int) OPT_SKIP_RESOLVE: + opt_skip_name_resolve= 1; opt_specialflag|=SPECIAL_NO_RESOLVE; break; case (int) OPT_WANT_CORE: @@ -7423,10 +7423,7 @@ mysqld_get_one_option(int optid, /** Handle arguments for multiple key caches. */ -extern "C" int mysql_getopt_value(uchar **value, - const char *keyname, uint key_length, - const struct my_option *option, - int *error); +C_MODE_START static uchar* * mysql_getopt_value(const char *keyname, uint key_length, @@ -7462,7 +7459,7 @@ mysql_getopt_value(const char *keyname, uint key_length, return option->value; } -void option_error_reporter(enum loglevel level, const char *format, ...) +static void option_error_reporter(enum loglevel level, const char *format, ...) { va_list args; va_start(args, format); @@ -7476,6 +7473,7 @@ void option_error_reporter(enum loglevel level, const char *format, ...) va_end(args); } +C_MODE_END /** Get server options from the command line, @@ -7711,6 +7709,48 @@ fn_format_relative_to_data_home(char * to, const char *name, } +/** + Test a file path to determine if the path is compatible with the secure file + path restriction. + + @param path null terminated character string + + @return + @retval TRUE The path is secure + @retval FALSE The path isn't secure +*/ + +bool is_secure_file_path(char *path) +{ + char buff1[FN_REFLEN], buff2[FN_REFLEN]; + /* + All paths are secure if opt_secure_file_path is 0 + */ + if (!opt_secure_file_priv) + return TRUE; + + if (strlen(path) >= FN_REFLEN) + return FALSE; + + if (my_realpath(buff1, path, 0)) + { + /* + The supplied file path might have been a file and not a directory. + */ + int length= (int)dirname_length(path); + if (length >= FN_REFLEN) + return FALSE; + memcpy(buff2, path, length); + buff2[length]= '\0'; + if (length == 0 || my_realpath(buff1, buff2, 0)) + return FALSE; + } + convert_dirname(buff2, buff1, NullS); + if (strncmp(opt_secure_file_priv, buff2, strlen(opt_secure_file_priv))) + return FALSE; + return TRUE; +} + static int fix_paths(void) { char buff[FN_REFLEN],*pos; @@ -7771,10 +7811,26 @@ static int fix_paths(void) */ if (opt_secure_file_priv) { - convert_dirname(buff, opt_secure_file_priv, NullS); - x_free(opt_secure_file_priv); - opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE)); + if (*opt_secure_file_priv == 0) + { + opt_secure_file_priv= 0; + } + else + { + if (strlen(opt_secure_file_priv) >= FN_REFLEN) + opt_secure_file_priv[FN_REFLEN-1]= '\0'; + if (my_realpath(buff, opt_secure_file_priv, 0)) + { + sql_print_warning("Failed to normalize the argument for --secure-file-priv."); + return 1; + } + char *secure_file_real_path= (char *)my_malloc(FN_REFLEN, MYF(MY_FAE)); + convert_dirname(secure_file_real_path, buff, NullS); + my_free(opt_secure_file_priv, MYF(0)); + opt_secure_file_priv= secure_file_real_path; + } } + return 0; } @@ -7918,8 +7974,9 @@ PSI_mutex_key key_BINLOG_LOCK_index, key_BINLOG_LOCK_prep_xids, key_master_info_data_lock, key_master_info_run_lock, key_mutex_slave_reporting_capability_err_lock, key_relay_log_info_data_lock, key_relay_log_info_log_space_lock, key_relay_log_info_run_lock, - key_structure_guard_mutex, key_TABLE_SHARE_LOCK_ha_data, key_LOCK_error_messages, - key_LOG_INFO_lock, key_LOCK_thread_count; + key_structure_guard_mutex, key_TABLE_SHARE_LOCK_ha_data, + key_LOCK_error_messages, key_LOG_INFO_lock, key_LOCK_thread_count, + key_PARTITION_LOCK_auto_inc; static PSI_mutex_info all_server_mutexes[]= { @@ -7973,7 +8030,8 @@ static PSI_mutex_info all_server_mutexes[]= { &key_TABLE_SHARE_LOCK_ha_data, "TABLE_SHARE::LOCK_ha_data", 0}, { &key_LOCK_error_messages, "LOCK_error_messages", PSI_FLAG_GLOBAL}, { &key_LOG_INFO_lock, "LOG_INFO::lock", 0}, - { &key_LOCK_thread_count, "LOCK_thread_count", PSI_FLAG_GLOBAL} + { &key_LOCK_thread_count, "LOCK_thread_count", PSI_FLAG_GLOBAL}, + { &key_PARTITION_LOCK_auto_inc, "HA_DATA_PARTITION::LOCK_auto_inc", 0} }; PSI_rwlock_key key_rwlock_LOCK_grant, key_rwlock_LOCK_logger, diff --git a/sql/mysqld.h b/sql/mysqld.h index 2547100d8ff..e14cd15ceb8 100644 --- a/sql/mysqld.h +++ b/sql/mysqld.h @@ -71,6 +71,7 @@ void unlink_thd(THD *thd); bool one_thread_per_connection_end(THD *thd, bool put_in_cache); void flush_thread_cache(); void refresh_status(THD *thd); +bool is_secure_file_path(char *path); extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *system_charset_info; extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *files_charset_info ; @@ -97,6 +98,7 @@ extern ulonglong log_output_options; extern ulong log_backup_output_options; extern my_bool opt_log_queries_not_using_indexes; extern bool opt_disable_networking, opt_skip_show_db; +extern bool opt_skip_name_resolve; extern bool opt_ignore_builtin_innodb; extern my_bool opt_character_set_client_handshake; extern bool volatile abort_loop; @@ -240,8 +242,8 @@ extern PSI_mutex_key key_BINLOG_LOCK_index, key_BINLOG_LOCK_prep_xids, key_master_info_data_lock, key_master_info_run_lock, key_mutex_slave_reporting_capability_err_lock, key_relay_log_info_data_lock, key_relay_log_info_log_space_lock, key_relay_log_info_run_lock, - key_structure_guard_mutex, key_TABLE_SHARE_LOCK_ha_data, key_LOCK_error_messages, - key_LOCK_thread_count; + key_structure_guard_mutex, key_TABLE_SHARE_LOCK_ha_data, + key_LOCK_error_messages, key_LOCK_thread_count, key_PARTITION_LOCK_auto_inc; extern PSI_rwlock_key key_rwlock_LOCK_grant, key_rwlock_LOCK_logger, key_rwlock_LOCK_sys_init_connect, key_rwlock_LOCK_sys_init_slave, diff --git a/sql/net_serv.cc b/sql/net_serv.cc index fc8655ea2e7..28ed4cbdbaf 100644 --- a/sql/net_serv.cc +++ b/sql/net_serv.cc @@ -133,6 +133,9 @@ my_bool my_net_init(NET *net, Vio* vio) net->where_b = net->remain_in_buf=0; net->last_errno=0; net->unused= 0; +#if defined(MYSQL_SERVER) && !defined(EMBEDDED_LIBRARY) + net->skip_big_packet= FALSE; +#endif if (vio != 0) /* If real connection */ { @@ -967,6 +970,7 @@ my_real_read(NET *net, size_t *complen) { #if defined(MYSQL_SERVER) && !defined(NO_ALARM) if (!net->compress && + net->skip_big_packet && !my_net_skip_rest(net, (uint32) len, &alarmed, &alarm_buff)) net->error= 3; /* Successfully skiped packet */ #endif diff --git a/sql/opt_range.cc b/sql/opt_range.cc index a46bfcf2d0e..9363b637862 100644 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@ -1539,6 +1539,29 @@ QUICK_ROR_UNION_SELECT::QUICK_ROR_UNION_SELECT(THD *thd_param, /* + Comparison function to be used QUICK_ROR_UNION_SELECT::queue priority + queue. + + SYNPOSIS + QUICK_ROR_UNION_SELECT_queue_cmp() + arg Pointer to QUICK_ROR_UNION_SELECT + val1 First merged select + val2 Second merged select +*/ + +C_MODE_START + +static int QUICK_ROR_UNION_SELECT_queue_cmp(void *arg, uchar *val1, uchar *val2) +{ + QUICK_ROR_UNION_SELECT *self= (QUICK_ROR_UNION_SELECT*)arg; + return self->head->file->cmp_ref(((QUICK_SELECT_I*)val1)->last_rowid, + ((QUICK_SELECT_I*)val2)->last_rowid); +} + +C_MODE_END + + +/* Do post-constructor initialization. SYNOPSIS QUICK_ROR_UNION_SELECT::init() @@ -1552,7 +1575,7 @@ int QUICK_ROR_UNION_SELECT::init() { DBUG_ENTER("QUICK_ROR_UNION_SELECT::init"); if (init_queue(&queue, quick_selects.elements, 0, - FALSE , QUICK_ROR_UNION_SELECT::queue_cmp, + FALSE , QUICK_ROR_UNION_SELECT_queue_cmp, (void*) this)) { bzero(&queue, sizeof(QUEUE)); @@ -1567,25 +1590,6 @@ int QUICK_ROR_UNION_SELECT::init() /* - Comparison function to be used QUICK_ROR_UNION_SELECT::queue priority - queue. - - SYNPOSIS - QUICK_ROR_UNION_SELECT::queue_cmp() - arg Pointer to QUICK_ROR_UNION_SELECT - val1 First merged select - val2 Second merged select -*/ - -int QUICK_ROR_UNION_SELECT::queue_cmp(void *arg, uchar *val1, uchar *val2) -{ - QUICK_ROR_UNION_SELECT *self= (QUICK_ROR_UNION_SELECT*)arg; - return self->head->file->cmp_ref(((QUICK_SELECT_I*)val1)->last_rowid, - ((QUICK_SELECT_I*)val2)->last_rowid); -} - - -/* Initialize quick select for row retrieval. SYNOPSIS reset() @@ -8717,8 +8721,6 @@ int QUICK_RANGE_SELECT::get_next() { int result; KEY_MULTI_RANGE *mrange; - key_range *start_key; - key_range *end_key; DBUG_ENTER("QUICK_RANGE_SELECT::get_next"); DBUG_ASSERT(multi_range_length && multi_range && (cur_range >= (QUICK_RANGE**) ranges.buffer) && @@ -8758,26 +8760,9 @@ int QUICK_RANGE_SELECT::get_next() mrange_slot < mrange_end; mrange_slot++) { - start_key= &mrange_slot->start_key; - end_key= &mrange_slot->end_key; last_range= *(cur_range++); - - start_key->key= (const uchar*) last_range->min_key; - start_key->length= last_range->min_length; - start_key->flag= ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY : - (last_range->flag & EQ_RANGE) ? - HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT); - start_key->keypart_map= last_range->min_keypart_map; - end_key->key= (const uchar*) last_range->max_key; - end_key->length= last_range->max_length; - /* - We use HA_READ_AFTER_KEY here because if we are reading on a key - prefix. We want to find all keys with this prefix. - */ - end_key->flag= (last_range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY : - HA_READ_AFTER_KEY); - end_key->keypart_map= last_range->max_keypart_map; - + last_range->make_min_endpoint(&mrange_slot->start_key); + last_range->make_max_endpoint(&mrange_slot->end_key); mrange_slot->range_flag= last_range->flag; } @@ -8801,49 +8786,52 @@ end: /* Get the next record with a different prefix. - SYNOPSIS - QUICK_RANGE_SELECT::get_next_prefix() - prefix_length length of cur_prefix - cur_prefix prefix of a key to be searched for + @param prefix_length length of cur_prefix + @param group_key_parts The number of key parts in the group prefix + @param cur_prefix prefix of a key to be searched for - DESCRIPTION - Each subsequent call to the method retrieves the first record that has a - prefix with length prefix_length different from cur_prefix, such that the - record with the new prefix is within the ranges described by - this->ranges. The record found is stored into the buffer pointed by - this->record. - The method is useful for GROUP-BY queries with range conditions to - discover the prefix of the next group that satisfies the range conditions. + Each subsequent call to the method retrieves the first record that has a + prefix with length prefix_length and which is different from cur_prefix, + such that the record with the new prefix is within the ranges described by + this->ranges. The record found is stored into the buffer pointed by + this->record. The method is useful for GROUP-BY queries with range + conditions to discover the prefix of the next group that satisfies the range + conditions. + + @todo - TODO This method is a modified copy of QUICK_RANGE_SELECT::get_next(), so both methods should be unified into a more general one to reduce code duplication. - RETURN - 0 on success - HA_ERR_END_OF_FILE if returned all keys - other if some error occurred + @retval 0 on success + @retval HA_ERR_END_OF_FILE if returned all keys + @retval other if some error occurred */ int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length, - key_part_map keypart_map, + uint group_key_parts, uchar *cur_prefix) { DBUG_ENTER("QUICK_RANGE_SELECT::get_next_prefix"); + const key_part_map keypart_map= make_prev_keypart_map(group_key_parts); for (;;) { int result; - key_range start_key, end_key; if (last_range) { /* Read the next record in the same range with prefix after cur_prefix. */ - DBUG_ASSERT(cur_prefix != 0); + DBUG_ASSERT(cur_prefix != NULL); result= file->index_read_map(record, cur_prefix, keypart_map, HA_READ_AFTER_KEY); - if (result || (file->compare_key(file->end_range) <= 0)) + if (result || last_range->max_keypart_map == 0) DBUG_RETURN(result); + + key_range previous_endpoint; + last_range->make_max_endpoint(&previous_endpoint, prefix_length, keypart_map); + if (file->compare_key(&previous_endpoint) <= 0) + DBUG_RETURN(0); } uint count= ranges.elements - (cur_range - (QUICK_RANGE**) ranges.buffer); @@ -8855,21 +8843,9 @@ int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length, } last_range= *(cur_range++); - start_key.key= (const uchar*) last_range->min_key; - start_key.length= min(last_range->min_length, prefix_length); - start_key.keypart_map= last_range->min_keypart_map & keypart_map; - start_key.flag= ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY : - (last_range->flag & EQ_RANGE) ? - HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT); - end_key.key= (const uchar*) last_range->max_key; - end_key.length= min(last_range->max_length, prefix_length); - end_key.keypart_map= last_range->max_keypart_map & keypart_map; - /* - We use READ_AFTER_KEY here because if we are reading on a key - prefix we want to find all keys with this prefix - */ - end_key.flag= (last_range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY : - HA_READ_AFTER_KEY); + key_range start_key, end_key; + last_range->make_min_endpoint(&start_key, prefix_length, keypart_map); + last_range->make_max_endpoint(&end_key, prefix_length, keypart_map); result= file->read_range_first(last_range->min_keypart_map ? &start_key : 0, last_range->max_keypart_map ? &end_key : 0, @@ -8964,9 +8940,9 @@ bool QUICK_RANGE_SELECT::row_in_ranges() } /* - This is a hack: we inherit from QUICK_SELECT so that we can use the + This is a hack: we inherit from QUICK_RANGE_SELECT so that we can use the get_next() interface, but we have to hold a pointer to the original - QUICK_SELECT because its data are used all over the place. What + QUICK_RANGE_SELECT because its data are used all over the place. What should be done is to factor out the data that is needed into a base class (QUICK_SELECT), and then have two subclasses (_ASC and _DESC) which handle the ranges and implement the get_next() function. But @@ -11159,7 +11135,8 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_prefix() { uchar *cur_prefix= seen_first_key ? group_prefix : NULL; if ((result= quick_prefix_select->get_next_prefix(group_prefix_len, - make_prev_keypart_map(group_key_parts), cur_prefix))) + group_key_parts, + cur_prefix))) DBUG_RETURN(result); seen_first_key= TRUE; } diff --git a/sql/opt_range.h b/sql/opt_range.h index 3b3b36f7689..72f2eb4b51d 100644 --- a/sql/opt_range.h +++ b/sql/opt_range.h @@ -79,6 +79,85 @@ class QUICK_RANGE :public Sql_alloc { dummy=0; #endif } + + /** + Initalizes a key_range object for communication with storage engine. + + This function facilitates communication with the Storage Engine API by + translating the minimum endpoint of the interval represented by this + QUICK_RANGE into an index range endpoint specifier for the engine. + + @param Pointer to an uninitialized key_range C struct. + + @param prefix_length The length of the search key prefix to be used for + lookup. + + @param keypart_map A set (bitmap) of keyparts to be used. + */ + void make_min_endpoint(key_range *kr, uint prefix_length, + key_part_map keypart_map) { + make_min_endpoint(kr); + kr->length= min(kr->length, prefix_length); + kr->keypart_map&= keypart_map; + } + + /** + Initalizes a key_range object for communication with storage engine. + + This function facilitates communication with the Storage Engine API by + translating the minimum endpoint of the interval represented by this + QUICK_RANGE into an index range endpoint specifier for the engine. + + @param Pointer to an uninitialized key_range C struct. + */ + void make_min_endpoint(key_range *kr) { + kr->key= (const uchar*)min_key; + kr->length= min_length; + kr->keypart_map= min_keypart_map; + kr->flag= ((flag & NEAR_MIN) ? HA_READ_AFTER_KEY : + (flag & EQ_RANGE) ? HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT); + } + + /** + Initalizes a key_range object for communication with storage engine. + + This function facilitates communication with the Storage Engine API by + translating the maximum endpoint of the interval represented by this + QUICK_RANGE into an index range endpoint specifier for the engine. + + @param Pointer to an uninitialized key_range C struct. + + @param prefix_length The length of the search key prefix to be used for + lookup. + + @param keypart_map A set (bitmap) of keyparts to be used. + */ + void make_max_endpoint(key_range *kr, uint prefix_length, + key_part_map keypart_map) { + make_max_endpoint(kr); + kr->length= min(kr->length, prefix_length); + kr->keypart_map&= keypart_map; + } + + /** + Initalizes a key_range object for communication with storage engine. + + This function facilitates communication with the Storage Engine API by + translating the maximum endpoint of the interval represented by this + QUICK_RANGE into an index range endpoint specifier for the engine. + + @param Pointer to an uninitialized key_range C struct. + */ + void make_max_endpoint(key_range *kr) { + kr->key= (const uchar*)max_key; + kr->length= max_length; + kr->keypart_map= max_keypart_map; + /* + We use READ_AFTER_KEY here because if we are reading on a key + prefix we want to find all keys with this prefix + */ + kr->flag= (flag & NEAR_MAX ? HA_READ_BEFORE_KEY : HA_READ_AFTER_KEY); + } }; @@ -345,7 +424,7 @@ public: int reset(void); int get_next(); void range_end(); - int get_next_prefix(uint prefix_length, key_part_map keypart_map, + int get_next_prefix(uint prefix_length, uint group_key_parts, uchar *cur_prefix); bool reverse_sorted() { return 0; } bool unique_key_range(); @@ -578,7 +657,6 @@ public: bool have_prev_rowid; /* true if prev_rowid has valid data */ uint rowid_length; /* table rowid length */ private: - static int queue_cmp(void *arg, uchar *val1, uchar *val2); bool scans_inited; }; @@ -625,7 +703,7 @@ private: uchar *record; /* Buffer where the next record is returned. */ uchar *tmp_record; /* Temporary storage for next_min(), next_max(). */ uchar *group_prefix; /* Key prefix consisting of the GROUP fields. */ - uint group_prefix_len; /* Length of the group prefix. */ + const uint group_prefix_len; /* Length of the group prefix. */ uint group_key_parts; /* A number of keyparts in the group prefix */ uchar *last_prefix; /* Prefix of the last group for detecting EOF. */ bool have_min; /* Specify whether we are computing */ diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc index fd2040a4979..0c79c8dc797 100644 --- a/sql/opt_sum.cc +++ b/sql/opt_sum.cc @@ -90,6 +90,123 @@ static ulonglong get_exact_record_count(TABLE_LIST *tables) /** + Use index to read MIN(field) value. + + @param table Table object + @param ref Reference to the structure where we store the key value + @item_field Field used in MIN() + @range_fl Whether range endpoint is strict less than + @prefix_len Length of common key part for the range + + @retval + 0 No errors + HA_ERR_... Otherwise +*/ + +static int get_index_min_value(TABLE *table, TABLE_REF *ref, + Item_field *item_field, uint range_fl, + uint prefix_len) +{ + int error; + + if (!ref->key_length) + error= table->file->index_first(table->record[0]); + else + { + /* + Use index to replace MIN/MAX functions with their values + according to the following rules: + + 1) Insert the minimum non-null values where the WHERE clause still + matches, or + 2) a NULL value if there are only NULL values for key_part_k. + 3) Fail, producing a row of nulls + + Implementation: Read the smallest value using the search key. If + the interval is open, read the next value after the search + key. If read fails, and we're looking for a MIN() value for a + nullable column, test if there is an exact match for the key. + */ + if (!(range_fl & NEAR_MIN)) + /* + Closed interval: Either The MIN argument is non-nullable, or + we have a >= predicate for the MIN argument. + */ + error= table->file->index_read_map(table->record[0], + ref->key_buff, + make_prev_keypart_map(ref->key_parts), + HA_READ_KEY_OR_NEXT); + else + { + /* + Open interval: There are two cases: + 1) We have only MIN() and the argument column is nullable, or + 2) there is a > predicate on it, nullability is irrelevant. + We need to scan the next bigger record first. + */ + error= table->file->index_read_map(table->record[0], + ref->key_buff, + make_prev_keypart_map(ref->key_parts), + HA_READ_AFTER_KEY); + /* + If the found record is outside the group formed by the search + prefix, or there is no such record at all, check if all + records in that group have NULL in the MIN argument + column. If that is the case return that NULL. + + Check if case 1 from above holds. If it does, we should read + the skipped tuple. + */ + if (item_field->field->real_maybe_null() && + ref->key_buff[prefix_len] == 1 && + /* + Last keypart (i.e. the argument to MIN) is set to NULL by + find_key_for_maxmin only if all other keyparts are bound + to constants in a conjunction of equalities. Hence, we + can detect this by checking only if the last keypart is + NULL. + */ + (error == HA_ERR_KEY_NOT_FOUND || + key_cmp_if_same(table, ref->key_buff, ref->key, prefix_len))) + { + DBUG_ASSERT(item_field->field->real_maybe_null()); + error= table->file->index_read_map(table->record[0], + ref->key_buff, + make_prev_keypart_map(ref->key_parts), + HA_READ_KEY_EXACT); + } + } + } + return error; +} + + +/** + Use index to read MAX(field) value. + + @param table Table object + @param ref Reference to the structure where we store the key value + @range_fl Whether range endpoint is strict greater than + + @retval + 0 No errors + HA_ERR_... Otherwise +*/ + +static int get_index_max_value(TABLE *table, TABLE_REF *ref, uint range_fl) +{ + return (ref->key_length ? + table->file->index_read_map(table->record[0], ref->key_buff, + make_prev_keypart_map(ref->key_parts), + range_fl & NEAR_MAX ? + HA_READ_BEFORE_KEY : + HA_READ_PREFIX_LAST_OR_PREV) : + table->file->index_last(table->record[0])); +} + + + +/** Substitutes constants for some COUNT(), MIN() and MAX() functions. @param tables list of leaves of join table tree @@ -220,9 +337,11 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds) const_result= 0; break; case Item_sum::MIN_FUNC: + case Item_sum::MAX_FUNC: { + int is_max= test(item_sum->sum_func() == Item_sum::MAX_FUNC); /* - If MIN(expr) is the first part of a key or if all previous + If MIN/MAX(expr) is the first part of a key or if all previous parts of the key is found in the COND, then we can use indexes to find the key. */ @@ -241,89 +360,26 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds) Look for a partial key that can be used for optimization. If we succeed, ref.key_length will contain the length of this key, while prefix_len will contain the length of - the beginning of this key without field used in MIN(). + the beginning of this key without field used in MIN/MAX(). Type of range for the key part for this field will be returned in range_fl. */ if (table->file->inited || (outer_tables & table->map) || - !find_key_for_maxmin(0, &ref, item_field->field, conds, + !find_key_for_maxmin(is_max, &ref, item_field->field, conds, &range_fl, &prefix_len)) { const_result= 0; break; } - error= table->file->ha_index_init((uint) ref.key, 1); + table->file->ha_index_init((uint) ref.key, 1); + + error= is_max ? + get_index_max_value(table, &ref, range_fl) : + get_index_min_value(table, &ref, item_field, range_fl, + prefix_len); - if (!ref.key_length) - error= table->file->index_first(table->record[0]); - else - { - /* - Use index to replace MIN/MAX functions with their values - according to the following rules: - - 1) Insert the minimum non-null values where the WHERE clause still - matches, or - 2) a NULL value if there are only NULL values for key_part_k. - 3) Fail, producing a row of nulls - - Implementation: Read the smallest value using the search key. If - the interval is open, read the next value after the search - key. If read fails, and we're looking for a MIN() value for a - nullable column, test if there is an exact match for the key. - */ - if (!(range_fl & NEAR_MIN)) - /* - Closed interval: Either The MIN argument is non-nullable, or - we have a >= predicate for the MIN argument. - */ - error= table->file->index_read_map(table->record[0], - ref.key_buff, - make_prev_keypart_map(ref.key_parts), - HA_READ_KEY_OR_NEXT); - else - { - /* - Open interval: There are two cases: - 1) We have only MIN() and the argument column is nullable, or - 2) there is a > predicate on it, nullability is irrelevant. - We need to scan the next bigger record first. - */ - error= table->file->index_read_map(table->record[0], - ref.key_buff, - make_prev_keypart_map(ref.key_parts), - HA_READ_AFTER_KEY); - /* - If the found record is outside the group formed by the search - prefix, or there is no such record at all, check if all - records in that group have NULL in the MIN argument - column. If that is the case return that NULL. - - Check if case 1 from above holds. If it does, we should read - the skipped tuple. - */ - if (item_field->field->real_maybe_null() && - ref.key_buff[prefix_len] == 1 && - /* - Last keypart (i.e. the argument to MIN) is set to NULL by - find_key_for_maxmin only if all other keyparts are bound - to constants in a conjunction of equalities. Hence, we - can detect this by checking only if the last keypart is - NULL. - */ - (error == HA_ERR_KEY_NOT_FOUND || - key_cmp_if_same(table, ref.key_buff, ref.key, prefix_len))) - { - DBUG_ASSERT(item_field->field->real_maybe_null()); - error= table->file->index_read_map(table->record[0], - ref.key_buff, - make_prev_keypart_map(ref.key_parts), - HA_READ_KEY_EXACT); - } - } - } /* Verify that the read tuple indeed matches the search key */ - if (!error && reckey_in_range(0, &ref, item_field->field, + if (!error && reckey_in_range(is_max, &ref, item_field->field, conds, range_fl, prefix_len)) error= HA_ERR_KEY_NOT_FOUND; table->set_keyread(FALSE); @@ -355,100 +411,18 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds) item_sum->set_aggregator(item_sum->has_with_distinct() ? Aggregator::DISTINCT_AGGREGATOR : Aggregator::SIMPLE_AGGREGATOR); - if (!count) - { - /* If count == 0, then we know that is_exact_count == TRUE. */ - ((Item_sum_min*) item_sum)->aggregator_clear(); /* Set to NULL. */ - } - else - ((Item_sum_min*) item_sum)->reset(); /* Set to the constant value. */ - ((Item_sum_min*) item_sum)->make_const(); - recalc_const_item= 1; - break; - } - case Item_sum::MAX_FUNC: - { /* - If MAX(expr) is the first part of a key or if all previous - parts of the key is found in the COND, then we can use - indexes to find the key. + If count == 0 (so is_exact_count == TRUE) and + there're no outer joins, set to NULL, + otherwise set to the constant value. */ - Item *expr=item_sum->get_arg(0); - if (expr->real_item()->type() == Item::FIELD_ITEM) - { - uchar key_buff[MAX_KEY_LENGTH]; - TABLE_REF ref; - uint range_fl, prefix_len; - - ref.key_buff= key_buff; - Item_field *item_field= (Item_field*) (expr->real_item()); - TABLE *table= item_field->field->table; - - /* - Look for a partial key that can be used for optimization. - If we succeed, ref.key_length will contain the length of - this key, while prefix_len will contain the length of - the beginning of this key without field used in MAX(). - Type of range for the key part for this field will be - returned in range_fl. - */ - if (table->file->inited || (outer_tables & table->map) || - !find_key_for_maxmin(1, &ref, item_field->field, conds, - &range_fl, &prefix_len)) - { - const_result= 0; - break; - } - error= table->file->ha_index_init((uint) ref.key, 1); - - if (!ref.key_length) - error= table->file->index_last(table->record[0]); - else - error= table->file->index_read_map(table->record[0], key_buff, - make_prev_keypart_map(ref.key_parts), - range_fl & NEAR_MAX ? - HA_READ_BEFORE_KEY : - HA_READ_PREFIX_LAST_OR_PREV); - if (!error && reckey_in_range(1, &ref, item_field->field, - conds, range_fl, prefix_len)) - error= HA_ERR_KEY_NOT_FOUND; - table->set_keyread(FALSE); - table->file->ha_index_end(); - if (error) - { - if (error == HA_ERR_KEY_NOT_FOUND || error == HA_ERR_END_OF_FILE) - return HA_ERR_KEY_NOT_FOUND; // No rows matching WHERE - /* HA_ERR_LOCK_DEADLOCK or some other error */ - table->file->print_error(error, MYF(ME_FATALERROR)); - return(error); - } - removed_tables|= table->map; - } - else if (!expr->const_item() || !is_exact_count) - { - /* - The optimization is not applicable in both cases: - (a) 'expr' is a non-constant expression. Then we can't - replace 'expr' by a constant. - (b) 'expr' is a costant. According to ANSI, MIN/MAX must return - NULL if the query does not return any rows. Thus, if we are not - able to determine if the query returns any rows, we can't apply - the optimization and replace MIN/MAX with a constant. - */ - const_result= 0; - break; - } - item_sum->set_aggregator(item_sum->has_with_distinct() ? - Aggregator::DISTINCT_AGGREGATOR : - Aggregator::SIMPLE_AGGREGATOR); - if (!count) + if (!count && !outer_tables) { - /* If count != 1, then we know that is_exact_count == TRUE. */ - ((Item_sum_max*) item_sum)->aggregator_clear(); /* Set to NULL. */ + item_sum->aggregator_clear(); } else - ((Item_sum_max*) item_sum)->reset(); /* Set to the constant value. */ - ((Item_sum_max*) item_sum)->make_const(); + item_sum->reset(); + item_sum->make_const(); recalc_const_item= 1; break; } diff --git a/sql/partition_info.cc b/sql/partition_info.cc index f42a8ee2312..5b0b681c3a6 100644 --- a/sql/partition_info.cc +++ b/sql/partition_info.cc @@ -1,4 +1,4 @@ -/* Copyright (C) 2006-2008 MySQL AB, Sun Microsystems Inc. 2008-2009 +/* Copyright (c) 2006, 2010 Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -603,12 +603,12 @@ bool partition_info::check_engine_mix(handlerton *engine_type, { handlerton *old_engine_type= engine_type; bool first= TRUE; - uint num_parts= partitions.elements; + uint n_parts= partitions.elements; DBUG_ENTER("partition_info::check_engine_mix"); DBUG_PRINT("info", ("in: engine_type = %s, table_engine_set = %u", ha_resolve_storage_engine_name(engine_type), table_engine_set)); - if (num_parts) + if (n_parts) { List_iterator<partition_element> part_it(partitions); uint i= 0; @@ -621,7 +621,7 @@ bool partition_info::check_engine_mix(handlerton *engine_type, if (is_sub_partitioned() && part_elem->subpartitions.elements) { - uint num_subparts= part_elem->subpartitions.elements; + uint n_subparts= part_elem->subpartitions.elements; uint j= 0; List_iterator<partition_element> sub_it(part_elem->subpartitions); do @@ -633,7 +633,7 @@ bool partition_info::check_engine_mix(handlerton *engine_type, if (check_engine_condition(sub_elem, table_engine_set, &engine_type, &first)) goto error; - } while (++j < num_subparts); + } while (++j < n_subparts); /* ensure that the partition also has correct engine */ if (check_engine_condition(part_elem, table_engine_set, &engine_type, &first)) @@ -642,7 +642,7 @@ bool partition_info::check_engine_mix(handlerton *engine_type, else if (check_engine_condition(part_elem, table_engine_set, &engine_type, &first)) goto error; - } while (++i < num_parts); + } while (++i < n_parts); } DBUG_PRINT("info", ("engine_type = %s", ha_resolve_storage_engine_name(engine_type))); @@ -701,12 +701,11 @@ bool partition_info::check_range_constants(THD *thd) if (column_list) { part_column_list_val *loc_range_col_array; - part_column_list_val *current_largest_col_val; + part_column_list_val *UNINIT_VAR(current_largest_col_val); uint num_column_values= part_field_list.elements; uint size_entries= sizeof(part_column_list_val) * num_column_values; range_col_array= (part_column_list_val*)sql_calloc(num_parts * size_entries); - LINT_INIT(current_largest_col_val); if (unlikely(range_col_array == NULL)) { mem_alloc_error(num_parts * size_entries); @@ -739,12 +738,10 @@ bool partition_info::check_range_constants(THD *thd) } else { - longlong current_largest; + longlong UNINIT_VAR(current_largest); longlong part_range_value; bool signed_flag= !part_expr->unsigned_flag; - LINT_INIT(current_largest); - part_result_type= INT_RESULT; range_int_array= (longlong*)sql_alloc(num_parts * sizeof(longlong)); if (unlikely(range_int_array == NULL)) @@ -805,7 +802,8 @@ range_not_increasing_error: -1 a < b */ -int partition_info::list_part_cmp(const void* a, const void* b) +extern "C" +int partition_info_list_part_cmp(const void* a, const void* b) { longlong a1= ((LIST_PART_ENTRY*)a)->list_value; longlong b1= ((LIST_PART_ENTRY*)b)->list_value; @@ -817,7 +815,14 @@ int partition_info::list_part_cmp(const void* a, const void* b) return 0; } - /* + +int partition_info::list_part_cmp(const void* a, const void* b) +{ + return partition_info_list_part_cmp(a, b); +} + + +/* Compare two lists of column values in RANGE/LIST partitioning SYNOPSIS compare_column_values() @@ -829,8 +834,9 @@ int partition_info::list_part_cmp(const void* a, const void* b) +1 First argument is larger */ -int partition_info::compare_column_values(const void *first_arg, - const void *second_arg) +extern "C" +int partition_info_compare_column_values(const void *first_arg, + const void *second_arg) { const part_column_list_val *first= (part_column_list_val*)first_arg; const part_column_list_val *second= (part_column_list_val*)second_arg; @@ -866,6 +872,14 @@ int partition_info::compare_column_values(const void *first_arg, return 0; } + +int partition_info::compare_column_values(const void *first_arg, + const void *second_arg) +{ + return partition_info_compare_column_values(first_arg, second_arg); +} + + /* This routine allocates an array for all list constants to achieve a fast check what partition a certain value belongs to. At the same time it does @@ -894,10 +908,11 @@ bool partition_info::check_list_constants(THD *thd) part_elem_value *list_value; bool result= TRUE; longlong type_add, calc_value; - void *curr_value, *prev_value; + void *curr_value; + void *UNINIT_VAR(prev_value); partition_element* part_def; bool found_null= FALSE; - int (*compare_func)(const void *, const void*); + qsort_cmp compare_func; void *ptr; List_iterator<partition_element> list_func_it(partitions); DBUG_ENTER("partition_info::check_list_constants"); @@ -954,7 +969,7 @@ bool partition_info::check_list_constants(THD *thd) part_column_list_val *loc_list_col_array; loc_list_col_array= (part_column_list_val*)ptr; list_col_array= (part_column_list_val*)ptr; - compare_func= compare_column_values; + compare_func= partition_info_compare_column_values; i= 0; do { @@ -974,7 +989,7 @@ bool partition_info::check_list_constants(THD *thd) } else { - compare_func= list_part_cmp; + compare_func= partition_info_list_part_cmp; list_array= (LIST_PART_ENTRY*)ptr; i= 0; /* @@ -1009,7 +1024,6 @@ bool partition_info::check_list_constants(THD *thd) compare_func); i= 0; - LINT_INIT(prev_value); do { DBUG_ASSERT(i < num_list_values); @@ -1032,6 +1046,30 @@ end: DBUG_RETURN(result); } +/** + Check if we allow DATA/INDEX DIRECTORY, if not warn and set them to NULL. + + @param thd THD also containing sql_mode (looks from MODE_NO_DIR_IN_CREATE). + @param part_elem partition_element to check. +*/ +static void warn_if_dir_in_part_elem(THD *thd, partition_element *part_elem) +{ +#ifdef HAVE_READLINK + if (!my_use_symdir || (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)) +#endif + { + if (part_elem->data_file_name) + push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, + WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED), + "DATA DIRECTORY"); + if (part_elem->index_file_name) + push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, + WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED), + "INDEX DIRECTORY"); + part_elem->data_file_name= part_elem->index_file_name= NULL; + } +} + /* This code is used early in the CREATE TABLE and ALTER TABLE process. @@ -1169,20 +1207,7 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type, do { partition_element *part_elem= part_it++; -#ifdef HAVE_READLINK - if (!my_use_symdir || (thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE)) -#endif - { - if (part_elem->data_file_name) - push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, - WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED), - "DATA DIRECTORY"); - if (part_elem->index_file_name) - push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, - WARN_OPTION_IGNORED, ER(WARN_OPTION_IGNORED), - "INDEX DIRECTORY"); - part_elem->data_file_name= part_elem->index_file_name= NULL; - } + warn_if_dir_in_part_elem(thd, part_elem); if (!is_sub_partitioned()) { if (part_elem->engine_type == NULL) @@ -1191,7 +1216,7 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type, part_elem->engine_type= default_engine_type; } if (check_table_name(part_elem->partition_name, - strlen(part_elem->partition_name))) + strlen(part_elem->partition_name), FALSE)) { my_error(ER_WRONG_PARTITION_NAME, MYF(0)); goto end; @@ -1208,8 +1233,9 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type, do { sub_elem= sub_it++; + warn_if_dir_in_part_elem(thd, sub_elem); if (check_table_name(sub_elem->partition_name, - strlen(sub_elem->partition_name))) + strlen(sub_elem->partition_name), FALSE)) { my_error(ER_WRONG_PARTITION_NAME, MYF(0)); goto end; @@ -1306,15 +1332,15 @@ end: RETURN VALUES */ -void partition_info::print_no_partition_found(TABLE *table) +void partition_info::print_no_partition_found(TABLE *table_arg) { char buf[100]; char *buf_ptr= (char*)&buf; TABLE_LIST table_list; bzero(&table_list, sizeof(table_list)); - table_list.db= table->s->db.str; - table_list.table_name= table->s->table_name.str; + table_list.db= table_arg->s->db.str; + table_list.table_name= table_arg->s->table_name.str; if (check_single_table_access(current_thd, SELECT_ACL, &table_list, TRUE)) @@ -1328,13 +1354,13 @@ void partition_info::print_no_partition_found(TABLE *table) buf_ptr= (char*)"from column_list"; else { - my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->read_set); + my_bitmap_map *old_map= dbug_tmp_use_all_columns(table_arg, table_arg->read_set); if (part_expr->null_value) buf_ptr= (char*)"NULL"; else longlong2str(err_value, buf, part_expr->unsigned_flag ? 10 : -10); - dbug_tmp_restore_column_map(table->read_set, old_map); + dbug_tmp_restore_column_map(table_arg->read_set, old_map); } my_error(ER_NO_PARTITION_FOR_GIVEN_VALUE, MYF(0), buf_ptr); } @@ -1994,7 +2020,7 @@ bool partition_info::fix_column_value_functions(THD *thd, part_elem_value *val, uint part_id) { - uint num_columns= part_field_list.elements; + uint n_columns= part_field_list.elements; bool result= FALSE; uint i; part_column_list_val *col_val= val->col_val_array; @@ -2004,7 +2030,7 @@ bool partition_info::fix_column_value_functions(THD *thd, { DBUG_RETURN(FALSE); } - for (i= 0; i < num_columns; col_val++, i++) + for (i= 0; i < n_columns; col_val++, i++) { Item *column_item= col_val->item_expression; Field *field= part_field_array[i]; diff --git a/sql/partition_info.h b/sql/partition_info.h index 479714a3928..b196d0b59a2 100644 --- a/sql/partition_info.h +++ b/sql/partition_info.h @@ -151,8 +151,6 @@ public: char *part_func_string; char *subpart_func_string; - const char *part_state; - partition_element *curr_part_elem; partition_element *current_partition; part_elem_value *curr_list_val; @@ -173,7 +171,6 @@ public: partition_type subpart_type; uint part_info_len; - uint part_state_len; uint part_func_len; uint subpart_func_len; @@ -226,13 +223,12 @@ public: list_array(NULL), err_value(0), part_info_string(NULL), part_func_string(NULL), subpart_func_string(NULL), - part_state(NULL), curr_part_elem(NULL), current_partition(NULL), curr_list_object(0), num_columns(0), default_engine_type(NULL), part_result_type(INT_RESULT), part_type(NOT_A_PARTITION), subpart_type(NOT_A_PARTITION), - part_info_len(0), part_state_len(0), + part_info_len(0), part_func_len(0), subpart_func_len(0), num_parts(0), num_subparts(0), count_curr_subparts(0), part_error_code(0), diff --git a/sql/protocol.cc b/sql/protocol.cc index fd01e4a8885..ac78ac88ec6 100644 --- a/sql/protocol.cc +++ b/sql/protocol.cc @@ -747,8 +747,7 @@ bool Protocol::send_result_set_metadata(List<Item> *list, uint flags) else { /* With conversion */ - ulonglong max_length; - uint32 field_length; + uint32 field_length, max_length; int2store(pos, thd_charset->number); /* For TEXT/BLOB columns, field_length describes the maximum data @@ -771,9 +770,8 @@ bool Protocol::send_result_set_metadata(List<Item> *list, uint flags) field.type <= MYSQL_TYPE_BLOB) ? field.length / item->collation.collation->mbminlen : field.length / item->collation.collation->mbmaxlen; - max_length*= thd_charset->mbmaxlen; - field_length= (max_length > UINT_MAX32) ? - UINT_MAX32 : (uint32) max_length; + field_length= char_to_byte_length_safe(max_length, + thd_charset->mbmaxlen); int4store(pos + 2, field_length); } pos[6]= field.type; @@ -1014,8 +1012,8 @@ bool Protocol_text::store(const char *from, size_t length, { CHARSET_INFO *tocs= this->thd->variables.character_set_results; #ifndef DBUG_OFF - DBUG_PRINT("info", ("Protocol_text::store field %u (%u): %*.s", - field_pos, field_count, (int) length, from)); + DBUG_PRINT("info", ("Protocol_text::store field %u (%u): %s", field_pos, + field_count, (length == 0? "" : from))); DBUG_ASSERT(field_pos < field_count); DBUG_ASSERT(field_types == 0 || field_types[field_pos] == MYSQL_TYPE_DECIMAL || diff --git a/sql/rpl_handler.cc b/sql/rpl_handler.cc index 9cb5391075d..be0a61bcae2 100644 --- a/sql/rpl_handler.cc +++ b/sql/rpl_handler.cc @@ -89,21 +89,24 @@ int get_user_var_str(const char *name, char *value, int delegates_init() { - static unsigned long trans_mem[sizeof(Trans_delegate) / sizeof(unsigned long) + 1]; - static unsigned long storage_mem[sizeof(Binlog_storage_delegate) / sizeof(unsigned long) + 1]; + static Aligned_char_array<sizeof(Trans_delegate)> trans_mem; + static Aligned_char_array<sizeof(Binlog_storage_delegate)> storage_mem; #ifdef HAVE_REPLICATION - static unsigned long transmit_mem[sizeof(Binlog_transmit_delegate) / sizeof(unsigned long) + 1]; - static unsigned long relay_io_mem[sizeof(Binlog_relay_IO_delegate)/ sizeof(unsigned long) + 1]; + static Aligned_char_array<sizeof(Binlog_transmit_delegate)> transmit_mem; + static Aligned_char_array<sizeof(Binlog_relay_IO_delegate)> relay_io_mem; #endif - - if (!(transaction_delegate= new (trans_mem) Trans_delegate) + + if (!(transaction_delegate= new (trans_mem.arr()) Trans_delegate) || (!transaction_delegate->is_inited()) - || !(binlog_storage_delegate= new (storage_mem) Binlog_storage_delegate) + || !(binlog_storage_delegate= + new (storage_mem.arr()) Binlog_storage_delegate) || (!binlog_storage_delegate->is_inited()) #ifdef HAVE_REPLICATION - || !(binlog_transmit_delegate= new (transmit_mem) Binlog_transmit_delegate) + || !(binlog_transmit_delegate= + new (transmit_mem.arr()) Binlog_transmit_delegate) || (!binlog_transmit_delegate->is_inited()) - || !(binlog_relay_io_delegate= new (relay_io_mem) Binlog_relay_IO_delegate) + || !(binlog_relay_io_delegate= + new (relay_io_mem.arr()) Binlog_relay_IO_delegate) || (!binlog_relay_io_delegate->is_inited()) #endif /* HAVE_REPLICATION */ ) diff --git a/sql/rpl_mi.cc b/sql/rpl_mi.cc index 34051f1e74e..9b0450b3f02 100644 --- a/sql/rpl_mi.cc +++ b/sql/rpl_mi.cc @@ -131,8 +131,10 @@ enum { LINE_FOR_MASTER_SSL_VERIFY_SERVER_CERT= 15, /* 6.0 added value of master_heartbeat_period */ LINE_FOR_MASTER_HEARTBEAT_PERIOD= 16, + /* MySQL Cluster 6.3 added master_bind */ + LINE_FOR_MASTER_BIND = 17, /* 6.0 added value of master_ignore_server_id */ - LINE_FOR_REPLICATE_IGNORE_SERVER_IDS= 17, + LINE_FOR_REPLICATE_IGNORE_SERVER_IDS= 18, /* Number of lines currently used when saving master info file */ LINES_IN_MASTER_INFO= LINE_FOR_REPLICATE_IGNORE_SERVER_IDS }; @@ -143,6 +145,7 @@ int init_master_info(Master_info* mi, const char* master_info_fname, int thread_mask) { int fd,error; + char fname[FN_REFLEN+128]; DBUG_ENTER("init_master_info"); if (mi->inited) @@ -168,8 +171,7 @@ int init_master_info(Master_info* mi, const char* master_info_fname, mi->mysql=0; mi->file_id=1; - fn_format(mi->info_file_name, master_info_fname, mysql_data_home, "", - MYF(MY_UNPACK_FILENAME|MY_RETURN_REAL_PATH)); + fn_format(fname, master_info_fname, mysql_data_home, "", 4+32); /* We need a mutex while we are changing master info parameters to @@ -181,7 +183,7 @@ int init_master_info(Master_info* mi, const char* master_info_fname, /* does master.info exist ? */ - if (access(mi->info_file_name, F_OK)) + if (access(fname,F_OK)) { if (abort_if_no_master_info_file) { @@ -194,18 +196,18 @@ int init_master_info(Master_info* mi, const char* master_info_fname, */ if (fd >= 0) mysql_file_close(fd, MYF(MY_WME)); - if ((fd= mysql_file_open(key_file_master_info, mi->info_file_name, - O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ) + if ((fd= mysql_file_open(key_file_master_info, + fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ) { sql_print_error("Failed to create a new master info file (\ -file '%s', errno %d)", mi->info_file_name, my_errno); +file '%s', errno %d)", fname, my_errno); goto err; } if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0, MYF(MY_WME))) { sql_print_error("Failed to create a cache on master info file (\ -file '%s')", mi->info_file_name); +file '%s')", fname); goto err; } @@ -220,17 +222,17 @@ file '%s')", mi->info_file_name); else { if ((fd= mysql_file_open(key_file_master_info, - mi->info_file_name, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ) + fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ) { sql_print_error("Failed to open the existing master info file (\ -file '%s', errno %d)", mi->info_file_name, my_errno); +file '%s', errno %d)", fname, my_errno); goto err; } if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L, 0, MYF(MY_WME))) { sql_print_error("Failed to create a cache on master info file (\ -file '%s')", mi->info_file_name); +file '%s')", fname); goto err; } } @@ -240,6 +242,7 @@ file '%s')", mi->info_file_name); int ssl= 0, ssl_verify_server_cert= 0; float master_heartbeat_period= 0.0; char *first_non_digit; + char dummy_buf[HOSTNAME_LENGTH+1]; /* Starting from 4.1.x master.info has new format. Now its @@ -329,6 +332,13 @@ file '%s')", mi->info_file_name); init_floatvar_from_file(&master_heartbeat_period, &mi->file, 0.0)) goto errwithmsg; /* + Starting from MySQL Cluster 6.3 master_bind might be in the file + (this is just a reservation to avoid future upgrade problems) + */ + if (lines >= LINE_FOR_MASTER_BIND && + init_strvar_from_file(dummy_buf, sizeof(dummy_buf), &mi->file, "")) + goto errwithmsg; + /* Starting from 6.0 list of server_id of ignorable servers might be in the file */ @@ -344,7 +354,7 @@ file '%s')", mi->info_file_name); if (ssl) sql_print_warning("SSL information in the master info file " "('%s') are ignored because this MySQL slave was " - "compiled without SSL support.", mi->info_file_name); + "compiled without SSL support.", fname); #endif /* HAVE_OPENSSL */ /* @@ -480,14 +490,14 @@ int flush_master_info(Master_info* mi, my_sprintf(heartbeat_buf, (heartbeat_buf, "%.3f", mi->heartbeat_period)); my_b_seek(file, 0L); my_b_printf(file, - "%u\n%s\n%s\n%s\n%s\n%s\n%d\n%d\n%d\n%s\n%s\n%s\n%s\n%s\n%d\n%s\n%s\n", + "%u\n%s\n%s\n%s\n%s\n%s\n%d\n%d\n%d\n%s\n%s\n%s\n%s\n%s\n%d\n%s\n%s\n%s\n", LINES_IN_MASTER_INFO, mi->master_log_name, llstr(mi->master_log_pos, lbuf), mi->host, mi->user, mi->password, mi->port, mi->connect_retry, (int)(mi->ssl), mi->ssl_ca, mi->ssl_capath, mi->ssl_cert, mi->ssl_cipher, mi->ssl_key, mi->ssl_verify_server_cert, - heartbeat_buf, ignore_server_ids_buf); + heartbeat_buf, "", ignore_server_ids_buf); my_free(ignore_server_ids_buf, MYF(0)); err= flush_io_cache(file); if (sync_masterinfo_period && !err && diff --git a/sql/rpl_mi.h b/sql/rpl_mi.h index 89bab16b63b..c3734fdf59e 100644 --- a/sql/rpl_mi.h +++ b/sql/rpl_mi.h @@ -112,7 +112,6 @@ class Master_info : public Slave_reporting_capability ulonglong received_heartbeats; // counter of received heartbeat events DYNAMIC_ARRAY ignore_server_ids; ulong master_id; - char info_file_name[FN_REFLEN + 128]; }; void init_master_log_pos(Master_info* mi); int init_master_info(Master_info* mi, const char* master_info_fname, diff --git a/sql/rpl_utility.h b/sql/rpl_utility.h index cf28d2c8e29..25f2a60bece 100644 --- a/sql/rpl_utility.h +++ b/sql/rpl_utility.h @@ -233,7 +233,7 @@ struct RPL_TABLE_LIST /* Anonymous namespace for template functions/classes */ -namespace { +CPP_UNNAMED_NS_START /* Smart pointer that will automatically call my_afree (a macro) when @@ -260,7 +260,7 @@ namespace { Obj* get() { return m_ptr; } }; -} +CPP_UNNAMED_NS_END #endif // NB. number of printed bit values is limited to sizeof(buf) - 1 diff --git a/sql/share/Makefile.am b/sql/share/Makefile.am index 03f9a1652b7..73f2ca13bb6 100644 --- a/sql/share/Makefile.am +++ b/sql/share/Makefile.am @@ -58,6 +58,3 @@ distclean-local: # Do nothing link_sources: - -# Don't update the files from bitkeeper -%::SCCS/s.% diff --git a/sql/share/errmsg-utf8.txt b/sql/share/errmsg-utf8.txt index 598f563ac87..9c2cb40badc 100644 --- a/sql/share/errmsg-utf8.txt +++ b/sql/share/errmsg-utf8.txt @@ -6335,4 +6335,11 @@ ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE eng "Mixing self-logging and non-self-logging engines in a statement is unsafe." ER_BINLOG_UNSAFE_MIXED_STATEMENT - eng "Statements that read from both transactional (or a temporary table of any engine type) and non-transactional tables and write to any of them are unsafe." + eng "Statement accesses nontransactional table as well as transactional or temporary table, and writes to any of them." + +ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN + eng "Cannot modify @@session.sql_log_bin inside a transaction" + +ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN + eng "Cannot change the sql_log_bin inside a stored function or trigger" + diff --git a/sql/slave.cc b/sql/slave.cc index 2ecfd7be5b2..6ebdea4a42a 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -1802,8 +1802,7 @@ bool show_master_info(THD* thd, Master_info* mi) FN_REFLEN)); field_list.push_back(new Item_return_int("Master_Server_Id", sizeof(ulong), MYSQL_TYPE_LONG)); - field_list.push_back(new Item_empty_string("Master_Info_File", - sizeof(mi->info_file_name))); + if (protocol->send_result_set_metadata(&field_list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)) DBUG_RETURN(TRUE); @@ -1951,7 +1950,6 @@ bool show_master_info(THD* thd, Master_info* mi) } // Master_Server_id protocol->store((uint32) mi->master_id); - protocol->store(mi->info_file_name, &my_charset_bin); mysql_mutex_unlock(&mi->rli.err_lock); mysql_mutex_unlock(&mi->err_lock); @@ -3126,6 +3124,11 @@ pthread_handler_t handle_slave_sql(void *arg) { THD *thd; /* needs to be first for thread_stack */ char llbuff[22],llbuff1[22]; + char saved_log_name[FN_REFLEN]; + char saved_master_log_name[FN_REFLEN]; + my_off_t saved_log_pos; + my_off_t saved_master_log_pos; + my_off_t saved_skip= 0; Relay_log_info* rli = &((Master_info*)arg)->rli; const char *errmsg; @@ -3271,6 +3274,17 @@ log '%s' at position %s, relay log '%s' position: %s", RPL_LOG_NAME, do not want to wait for next event in this case. */ mysql_mutex_lock(&rli->data_lock); + if (rli->slave_skip_counter) + { + char *pos; + pos= strmake(saved_log_name, rli->group_relay_log_name, FN_REFLEN - 1); + pos= '\0'; + pos= strmake(saved_master_log_name, rli->group_master_log_name, FN_REFLEN - 1); + pos= '\0'; + saved_log_pos= rli->group_relay_log_pos; + saved_master_log_pos= rli->group_master_log_pos; + saved_skip= rli->slave_skip_counter; + } if (rli->until_condition != Relay_log_info::UNTIL_NONE && rli->is_until_satisfied(thd, NULL)) { @@ -3289,6 +3303,21 @@ log '%s' at position %s, relay log '%s' position: %s", RPL_LOG_NAME, thd_proc_info(thd, "Reading event from the relay log"); DBUG_ASSERT(rli->sql_thd == thd); THD_CHECK_SENTRY(thd); + + if (saved_skip && rli->slave_skip_counter == 0) + { + sql_print_information("'SQL_SLAVE_SKIP_COUNTER=%ld' executed at " + "relay_log_file='%s', relay_log_pos='%ld', master_log_name='%s', " + "master_log_pos='%ld' and new position at " + "relay_log_file='%s', relay_log_pos='%ld', master_log_name='%s', " + "master_log_pos='%ld' ", + (ulong) saved_skip, saved_log_name, (ulong) saved_log_pos, + saved_master_log_name, (ulong) saved_master_log_pos, + rli->group_relay_log_name, (ulong) rli->group_relay_log_pos, + rli->group_master_log_name, (ulong) rli->group_master_log_pos); + saved_skip= 0; + } + if (exec_relay_log_event(thd,rli)) { DBUG_PRINT("info", ("exec_relay_log_event() failed")); diff --git a/sql/sp_head.cc b/sql/sp_head.cc index 2d5b648e82e..61f00fdf59a 100644 --- a/sql/sp_head.cc +++ b/sql/sp_head.cc @@ -125,10 +125,10 @@ sp_get_item_value(THD *thd, Item *item, String *str) case STRING_RESULT: { String *result= item->val_str(str); - + if (!result) return NULL; - + { char buf_holder[STRING_BUFFER_USUAL_SIZE]; String buf(buf_holder, sizeof(buf_holder), result->charset()); @@ -366,7 +366,7 @@ sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr) Save original values and restore them after save. */ - + thd->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL; thd->abort_on_warning= thd->variables.sql_mode & @@ -465,7 +465,7 @@ check_routine_name(LEX_STRING *ident) { if (!ident || !ident->str || !ident->str[0] || ident->str[ident->length-1] == ' ') - { + { my_error(ER_SP_WRONG_NAME, MYF(0), ident->str); return TRUE; } @@ -502,7 +502,7 @@ sp_head::operator new(size_t size) throw() DBUG_RETURN(sp); } -void +void sp_head::operator delete(void *ptr, size_t size) throw() { DBUG_ENTER("sp_head::operator delete"); @@ -718,7 +718,7 @@ create_typelib(MEM_ROOT *mem_root, Create_field *field_def, List<String> *src) String *tmp= it++; if (String::needs_conversion(tmp->length(), tmp->charset(), - cs, &dummy)) + cs, &dummy)) { uint cnv_errs; conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs); @@ -747,21 +747,12 @@ create_typelib(MEM_ROOT *mem_root, Create_field *field_def, List<String> *src) sp_head::~sp_head() { + LEX *lex; + sp_instr *i; DBUG_ENTER("sp_head::~sp_head"); - destroy(); - delete m_next_cached_sp; - if (m_thd) - restore_thd_mem_root(m_thd); - DBUG_VOID_RETURN; -} -void -sp_head::destroy() -{ - sp_instr *i; - LEX *lex; - DBUG_ENTER("sp_head::destroy"); - DBUG_PRINT("info", ("name: %s", m_name.str)); + /* sp_head::restore_thd_mem_root() must already have been called. */ + DBUG_ASSERT(m_thd == NULL); for (uint ip = 0 ; (i = get_instr(ip)) ; ip++) delete i; @@ -772,21 +763,22 @@ sp_head::destroy() /* If we have non-empty LEX stack then we just came out of parser with error. Now we should delete all auxilary LEXes and restore original - THD::lex (In this case sp_head::restore_thd_mem_root() was not called - too, so m_thd points to the current thread context). - It is safe to not update LEX::ptr because further query string parsing - and execution will be stopped anyway. + THD::lex. It is safe to not update LEX::ptr because further query + string parsing and execution will be stopped anyway. */ - DBUG_ASSERT(m_lex.is_empty() || m_thd); while ((lex= (LEX *)m_lex.pop())) { - lex_end(m_thd->lex); - delete m_thd->lex; - m_thd->lex= lex; + THD *thd= lex->thd; + lex_end(thd->lex); + delete thd->lex; + thd->lex= lex; } my_hash_free(&m_sptabs); my_hash_free(&m_sroutines); + + delete m_next_cached_sp; + DBUG_VOID_RETURN; } @@ -823,7 +815,7 @@ sp_head::create_result_field(uint field_max_length, const char *field_name, if (field) field->init(table); - + DBUG_RETURN(field); } @@ -852,7 +844,7 @@ int cmp_splocal_locations(Item_splocal * const *a, Item_splocal * const *b) Statements that have is_update_query(stmt) == FALSE (e.g. SELECTs) are not written into binary log. Instead we catch function calls the statement makes and write it into binary log separately (see #3). - + 2. PROCEDURE calls CALL statements are not written into binary log. Instead @@ -865,8 +857,8 @@ int cmp_splocal_locations(Item_splocal * const *a, Item_splocal * const *b) This substitution is done in subst_spvars(). 3. FUNCTION calls - - In sp_head::execute_function(), we check + + In sp_head::execute_function(), we check * If this function invocation is done from a statement that is written into the binary log. * If there were any attempts to write events to the binary log during @@ -874,28 +866,28 @@ int cmp_splocal_locations(Item_splocal * const *a, Item_splocal * const *b) If the answers are No and Yes, we write the function call into the binary log as "SELECT spfunc(<param1value>, <param2value>, ...)" - - + + 4. Miscellaneous issues. - - 4.1 User variables. + + 4.1 User variables. When we call mysql_bin_log.write() for an SP statement, thd->user_var_events - must hold set<{var_name, value}> pairs for all user variables used during + must hold set<{var_name, value}> pairs for all user variables used during the statement execution. This set is produced by tracking user variable reads during statement - execution. + execution. For SPs, this has the following implications: - 1) thd->user_var_events may contain events from several SP statements and - needs to be valid after exection of these statements was finished. In + 1) thd->user_var_events may contain events from several SP statements and + needs to be valid after exection of these statements was finished. In order to achieve that, we * Allocate user_var_events array elements on appropriate mem_root (grep for user_var_events_alloc). * Use is_query_in_union() to determine if user_var_event is created. - + 2) We need to empty thd->user_var_events after we have wrote a function - call. This is currently done by making + call. This is currently done by making reset_dynamic(&thd->user_var_events); calls in several different places. (TODO cosider moving this into mysql_bin_log.write() function) @@ -914,7 +906,7 @@ int cmp_splocal_locations(Item_splocal * const *a, Item_splocal * const *b) Replace thd->query{_length} with a string that one can write to the binlog. - The binlog-suitable string is produced by replacing references to SP local + The binlog-suitable string is produced by replacing references to SP local variables with NAME_CONST('sp_var_name', value) calls. @param thd Current thread. @@ -951,11 +943,11 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str) } if (!sp_vars_uses.elements()) DBUG_RETURN(FALSE); - + /* Sort SP var refs by their occurences in the query */ sp_vars_uses.sort(cmp_splocal_locations); - /* + /* Construct a statement string where SP local var refs are replaced with "NAME_CONST(name, value)" */ @@ -963,7 +955,7 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str) cur= query_str->str; prev_pos= res= 0; thd->query_name_consts= 0; - + for (Item_splocal **splocal= sp_vars_uses.front(); splocal < sp_vars_uses.back(); splocal++) { @@ -973,13 +965,13 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str) String str_value_holder(str_buffer, sizeof(str_buffer), &my_charset_latin1); String *str_value; - + /* append the text between sp ref occurences */ res|= qbuf.append(cur + prev_pos, (*splocal)->pos_in_query - prev_pos); prev_pos= (*splocal)->pos_in_query + (*splocal)->len_in_query; - + res|= (*splocal)->fix_fields(thd, (Item **) splocal); - if (res) + if (res) break; if ((*splocal)->limit_clause_param) @@ -1006,7 +998,7 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str) res|= qbuf.append(')'); if (res) break; - + thd->query_name_consts++; } res|= qbuf.append(cur + prev_pos, query_str->length - prev_pos); @@ -1032,16 +1024,14 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str) } -/* +/** Return appropriate error about recursion limit reaching - SYNOPSIS - sp_head::recursion_level_error() - thd Thread handle + @param thd Thread handle - NOTE - For functions and triggers we return error about prohibited recursion. - For stored procedures we return about reaching recursion limit. + @remark For functions and triggers we return error about + prohibited recursion. For stored procedures we + return about reaching recursion limit. */ void sp_head::recursion_level_error(THD *thd) @@ -1061,7 +1051,7 @@ void sp_head::recursion_level_error(THD *thd) Execute the routine. The main instruction jump loop is there. Assume the parameters already set. @todo - - Will write this SP statement into binlog separately + - Will write this SP statement into binlog separately (TODO: consider changing the condition to "not inside event union") @retval @@ -1225,10 +1215,10 @@ sp_head::execute(THD *thd) do { sp_instr *i; - uint hip; // Handler ip + uint hip; #if defined(ENABLED_PROFILING) - /* + /* Treat each "instr" of a routine as discrete unit that could be profiled. Profiling only records information for segments of code that set the source of the query, and almost all kinds of instructions in s-p do not. @@ -1237,7 +1227,8 @@ sp_head::execute(THD *thd) thd->profiling.start_new_query("continuing inside routine"); #endif - i = get_instr(ip); // Returns NULL when we're done. + /* get_instr returns NULL when we're done. */ + i = get_instr(ip); if (i == NULL) { #if defined(ENABLED_PROFILING) @@ -1248,10 +1239,13 @@ sp_head::execute(THD *thd) DBUG_PRINT("execute", ("Instruction %u", ip)); - /* Don't change NOW() in FUNCTION or TRIGGER */ + /* + Make current_time() et al work. But don't change NOW() in FUNCTION + or TRIGGER. + */ if (!thd->in_sub_stmt) - thd->set_time(); // Make current_time() et al work - + thd->set_time(); + /* We have to set thd->stmt_arena before executing the instruction to store in the instruction free_list all new items, created @@ -1259,10 +1253,10 @@ sp_head::execute(THD *thd) items made during other permanent subquery transformations). */ thd->stmt_arena= i; - - /* - Will write this SP statement into binlog separately - (TODO: consider changing the condition to "not inside event union") + + /* + Will write this SP statement into binlog separately. + TODO: consider changing the condition to "not inside event union". */ if (thd->locked_tables_mode <= LTM_LOCK_TABLES) thd->user_var_events_alloc= thd->mem_root; @@ -1271,8 +1265,8 @@ sp_head::execute(THD *thd) if (i->free_list) cleanup_items(i->free_list); - - /* + + /* If we've set thd->user_var_events_alloc to mem_root of this SP statement, clean all the events allocated in it. */ @@ -1284,7 +1278,7 @@ sp_head::execute(THD *thd) /* we should cleanup free_list and memroot, used by instruction */ thd->cleanup_after_query(); - free_root(&execute_mem_root, MYF(0)); + free_root(&execute_mem_root, MYF(0)); /* Check if an exception has occurred and a handler has been found @@ -1299,7 +1293,7 @@ sp_head::execute(THD *thd) switch (ctx->found_handler(& hip, & handler_index)) { case SP_HANDLER_NONE: - break; + break; case SP_HANDLER_CONTINUE: thd->restore_active_arena(&execute_arena, &backup_arena); thd->set_n_backup_active_arena(&execute_arena, &backup_arena); @@ -1308,15 +1302,15 @@ sp_head::execute(THD *thd) default: if (ctx->end_partial_result_set) thd->protocol->end_partial_result_set(thd); - ip= hip; - err_status= FALSE; - ctx->clear_handler(); - ctx->enter_handler(hip, handler_index); + ip= hip; + err_status= FALSE; + ctx->clear_handler(); + ctx->enter_handler(hip, handler_index); thd->clear_error(); thd->is_fatal_error= 0; - thd->killed= THD::NOT_KILLED; + thd->killed= THD::NOT_KILLED; thd->mysys_var->abort= 0; - continue; + continue; } ctx->end_partial_result_set= FALSE; @@ -1359,7 +1353,7 @@ sp_head::execute(THD *thd) done: DBUG_PRINT("info", ("err_status: %d killed: %d is_slave_error: %d report_error: %d", - err_status, thd->killed, thd->is_slave_error, + err_status, thd->killed, thd->is_slave_error, thd->is_error())); if (thd->killed) @@ -1847,10 +1841,10 @@ err_with_cleanup: /** - Execute a procedure. + Execute a procedure. The function does the following steps: - - Set all parameters + - Set all parameters - changes security context for SUID routines - call sp_head::execute - copy back values of INOUT and OUT parameters @@ -1888,14 +1882,14 @@ sp_head::execute_procedure(THD *thd, List<Item> *args) save_spcont= octx= thd->spcont; if (! octx) - { // Create a temporary old context - if (!(octx= new sp_rcontext(m_pcont, NULL, octx)) || - octx->init(thd)) + { + /* Create a temporary old context. */ + if (!(octx= new sp_rcontext(m_pcont, NULL, octx)) || octx->init(thd)) { delete octx; /* Delete octx if it was init() that failed. */ DBUG_RETURN(TRUE); } - + #ifndef DBUG_OFF octx->sp= 0; #endif @@ -2155,7 +2149,7 @@ sp_head::restore_lex(THD *thd) oldlex= (LEX *)m_lex.pop(); if (! oldlex) - DBUG_RETURN(FALSE); // Nothing to restore + DBUG_RETURN(FALSE); // Nothing to restore oldlex->trg_table_fields.push_back(&sublex->trg_table_fields); @@ -2308,7 +2302,7 @@ sp_head::do_cont_backpatch() void sp_head::set_info(longlong created, longlong modified, - st_sp_chistics *chistics, ulong sql_mode) + st_sp_chistics *chistics, ulong sql_mode) { m_created= created; m_modified= modified; @@ -2318,8 +2312,8 @@ sp_head::set_info(longlong created, longlong modified, m_chistics->comment.str= 0; else m_chistics->comment.str= strmake_root(mem_root, - m_chistics->comment.str, - m_chistics->comment.length); + m_chistics->comment.str, + m_chistics->comment.length); m_sql_mode= sql_mode; } @@ -2360,7 +2354,7 @@ sp_head::reset_thd_mem_root(THD *thd) DBUG_PRINT("info", ("mem_root 0x%lx moved to thd mem root 0x%lx", (ulong) &mem_root, (ulong) &thd->mem_root)); free_list= thd->free_list; // Keep the old list - thd->free_list= NULL; // Start a new one + thd->free_list= NULL; // Start a new one m_thd= thd; DBUG_VOID_RETURN; } @@ -2369,13 +2363,13 @@ void sp_head::restore_thd_mem_root(THD *thd) { DBUG_ENTER("sp_head::restore_thd_mem_root"); - Item *flist= free_list; // The old list + Item *flist= free_list; // The old list set_query_arena(thd); // Get new free_list and mem_root state= INITIALIZED_FOR_SP; DBUG_PRINT("info", ("mem_root 0x%lx returned from thd mem root 0x%lx", (ulong) &mem_root, (ulong) &thd->mem_root)); - thd->free_list= flist; // Restore the old one + thd->free_list= flist; // Restore the old one thd->mem_root= m_thd_root; m_thd= NULL; DBUG_VOID_RETURN; @@ -2385,10 +2379,10 @@ sp_head::restore_thd_mem_root(THD *thd) /** Check if a user has access right to a routine. - @param thd Thread handler - @param sp SP - @param full_access Set to 1 if the user has SELECT right to the - 'mysql.proc' able or is the owner of the routine + @param thd Thread handler + @param sp SP + @param full_access Set to 1 if the user has SELECT right to the + 'mysql.proc' able or is the owner of the routine @retval false ok @retval @@ -2517,8 +2511,6 @@ sp_head::show_create_routine(THD *thd, int type) } - - /** Add instruction to SP. @@ -2578,11 +2570,11 @@ void sp_head::optimize() if (src != dst) { /* Move the instruction and update prev. jumps */ - sp_instr *ibp; - List_iterator_fast<sp_instr> li(bp); + sp_instr *ibp; + List_iterator_fast<sp_instr> li(bp); - set_dynamic(&m_instr, (uchar*)&i, dst); - while ((ibp= li++)) + set_dynamic(&m_instr, (uchar*)&i, dst); + while ((ibp= li++)) { sp_instr_opt_meta *im= static_cast<sp_instr_opt_meta *>(ibp); im->set_destination(src, dst); @@ -2677,7 +2669,7 @@ sp_head::show_routine_code(THD *thd) for (ip= 0; (i = get_instr(ip)) ; ip++) { - /* + /* Consistency check. If these are different something went wrong during optimization. */ @@ -2740,7 +2732,7 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp, int res= 0; DBUG_ENTER("reset_lex_and_exec_core"); - /* + /* The flag is saved at the entry to the following substatement. It's reset further in the common code part. It's merged with the saved parent's value at the exit of this func. @@ -2902,9 +2894,8 @@ sp_instr_stmt::execute(THD *thd, uint *nextp) if (unlikely((thd->variables.option_bits & OPTION_LOG_OFF)==0)) general_log_write(thd, COM_QUERY, thd->query(), thd->query_length()); - if (query_cache_send_result_to_client(thd, - thd->query(), - thd->query_length()) <= 0) + if (query_cache_send_result_to_client(thd, thd->query(), + thd->query_length()) <= 0) { res= m_lex_keeper.reset_lex_and_exec_core(thd, nextp, FALSE, this); @@ -3007,7 +2998,7 @@ sp_instr_set::exec_core(THD *thd, uint *nextp) /* If this also failed, let's abort. */ sp_rcontext *spcont= thd->spcont; - + thd->spcont= NULL; /* Avoid handlers */ my_error(ER_OUT_OF_RESOURCES, MYF(0)); spcont->clear_handler(); @@ -3051,6 +3042,7 @@ int sp_instr_set_trigger_field::execute(THD *thd, uint *nextp) { DBUG_ENTER("sp_instr_set_trigger_field::execute"); + thd->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL; DBUG_RETURN(m_lex_keeper.reset_lex_and_exec_core(thd, nextp, TRUE, this)); } @@ -3110,7 +3102,7 @@ uint sp_instr_jump::opt_mark(sp_head *sp, List<sp_instr> *leads) { m_dest= opt_shortcut_jump(sp, this); - if (m_dest != m_ip+1) /* Jumping to following instruction? */ + if (m_dest != m_ip+1) /* Jumping to following instruction? */ marked= 1; m_optdest= sp->get_instr(m_dest); return m_dest; @@ -3140,9 +3132,9 @@ void sp_instr_jump::opt_move(uint dst, List<sp_instr> *bp) { if (m_dest > m_ip) - bp->push_back(this); // Forward + bp->push_back(this); // Forward else if (m_optdest) - m_dest= m_optdest->m_ip; // Backward + m_dest= m_optdest->m_ip; // Backward m_ip= dst; } @@ -3415,7 +3407,7 @@ uint sp_instr_hreturn::opt_mark(sp_head *sp, List<sp_instr> *leads) { marked= 1; - + if (m_dest) { /* @@ -3423,7 +3415,7 @@ sp_instr_hreturn::opt_mark(sp_head *sp, List<sp_instr> *leads) */ return m_dest; } - + /* This is a CONTINUE handler; next instruction step will come from the handler stack and not from opt_mark. @@ -3740,14 +3732,14 @@ sp_instr_set_case_expr::exec_core(THD *thd, uint *nextp) */ Item *null_item= new Item_null(); - + if (!null_item || thd->spcont->set_case_expr(thd, m_case_expr_id, &null_item)) { /* If this also failed, we have to abort. */ sp_rcontext *spcont= thd->spcont; - + thd->spcont= NULL; /* Avoid handlers */ my_error(ER_OUT_OF_RESOURCES, MYF(0)); spcont->clear_handler(); @@ -3913,13 +3905,13 @@ sp_head::merge_table_list(THD *thd, TABLE_LIST *table, LEX *lex_for_tmp_check) } else { - if (!(tab= (SP_TABLE *)thd->calloc(sizeof(SP_TABLE)))) - return FALSE; - if (lex_for_tmp_check->sql_command == SQLCOM_CREATE_TABLE && - lex_for_tmp_check->query_tables == table && - lex_for_tmp_check->create_info.options & HA_LEX_CREATE_TMP_TABLE) + if (!(tab= (SP_TABLE *)thd->calloc(sizeof(SP_TABLE)))) + return FALSE; + if (lex_for_tmp_check->sql_command == SQLCOM_CREATE_TABLE && + lex_for_tmp_check->query_tables == table && + lex_for_tmp_check->create_info.options & HA_LEX_CREATE_TMP_TABLE) { - tab->temp= TRUE; + tab->temp= TRUE; tab->qname.length= tlen - alen - 1; } else @@ -3932,7 +3924,7 @@ sp_head::merge_table_list(THD *thd, TABLE_LIST *table, LEX *lex_for_tmp_check) tab->lock_type= table->lock_type; tab->lock_count= tab->query_lock_count= 1; tab->trg_event_map= table->trg_event_map; - if (my_hash_insert(&m_sptabs, (uchar *)tab)) + if (my_hash_insert(&m_sptabs, (uchar *)tab)) return FALSE; } } diff --git a/sql/sp_head.h b/sql/sp_head.h index 8975c239810..9796c49fdfb 100644 --- a/sql/sp_head.h +++ b/sql/sp_head.h @@ -305,10 +305,6 @@ public: virtual ~sp_head(); - /// Free memory - void - destroy(); - bool execute_trigger(THD *thd, const LEX_STRING *db_name, diff --git a/sql/spatial.cc b/sql/spatial.cc index 34b1f3d1f0c..fcf06119db9 100644 --- a/sql/spatial.cc +++ b/sql/spatial.cc @@ -128,6 +128,16 @@ Geometry::Class_info *Geometry::find_class(const char *name, uint32 len) } +Geometry *Geometry::create_by_typeid(Geometry_buffer *buffer, int type_id) +{ + Class_info *ci; + if (!(ci= find_class((int) type_id))) + return NULL; + (*ci->m_create_func)(buffer->buf.arr()); + return my_reinterpret_cast(Geometry *)(buffer->buf.arr()); +} + + Geometry *Geometry::construct(Geometry_buffer *buffer, const char *data, uint32 data_len) { diff --git a/sql/spatial.h b/sql/spatial.h index a4bce47d0e5..aabbb7a1b97 100644 --- a/sql/spatial.h +++ b/sql/spatial.h @@ -267,14 +267,7 @@ public: virtual int geometry_n(uint32 num, String *result) const { return -1; } public: - static Geometry *create_by_typeid(Geometry_buffer *buffer, int type_id) - { - Class_info *ci; - if (!(ci= find_class((int) type_id))) - return NULL; - (*ci->m_create_func)((void *)buffer); - return my_reinterpret_cast(Geometry *)(buffer); - } + static Geometry *create_by_typeid(Geometry_buffer *buffer, int type_id); static Geometry *construct(Geometry_buffer *buffer, const char *data, uint32 data_len); @@ -532,10 +525,9 @@ public: const Class_info *get_class_info() const; }; -const int geometry_buffer_size= sizeof(Gis_point); struct Geometry_buffer { - void *arr[(geometry_buffer_size - 1)/sizeof(void *) + 1]; + Aligned_char_array<sizeof(Gis_point)> buf; }; #endif /*HAVE_SPATAIAL*/ diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc index 55d83f49245..ec25e4cb68b 100644 --- a/sql/sql_acl.cc +++ b/sql/sql_acl.cc @@ -6261,21 +6261,21 @@ bool mysql_revoke_all(THD *thd, List <LEX_USER> &list) mysql_mutex_unlock(&acl_cache->lock); - int binlog_error= + if (result) + my_message(ER_REVOKE_GRANTS, ER(ER_REVOKE_GRANTS), MYF(0)); + + result= result | write_bin_log(thd, FALSE, thd->query(), thd->query_length()); mysql_rwlock_unlock(&LOCK_grant); close_thread_tables(thd); - /* error for writing binary log has already been reported */ - if (result && !binlog_error) - my_message(ER_REVOKE_GRANTS, ER(ER_REVOKE_GRANTS), MYF(0)); /* Restore the state of binlog format */ DBUG_ASSERT(!thd->is_current_stmt_binlog_format_row()); if (save_binlog_row_based) thd->set_current_stmt_binlog_format_row(); - DBUG_RETURN(result || binlog_error); + DBUG_RETURN(result); } diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 6d7dab15053..bea10343eb6 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -1419,6 +1419,12 @@ void close_thread_tables(THD *thd) table->s->table_name.str, (long) table)); #endif +#if defined(ENABLED_DEBUG_SYNC) + /* debug_sync may not be initialized for some slave threads */ + if (thd->debug_sync_control) + DEBUG_SYNC(thd, "before_close_thread_tables"); +#endif + /* Detach MERGE children after every statement. Even under LOCK TABLES. */ for (table= thd->open_tables; table; table= table->next) { @@ -4017,9 +4023,9 @@ thr_lock_type read_lock_type_for_table(THD *thd, prelocked mode we can't rely on OPTION_BIN_LOG flag in THD::options bitmap to determine that binary logging is turned on as this bit can be cleared before executing sub-statement. So instead we have to look - at THD::sql_log_bin_toplevel member. + at THD::variables::sql_log_bin member. */ - bool log_on= mysql_bin_log.is_open() && thd->sql_log_bin_toplevel; + bool log_on= mysql_bin_log.is_open() && thd->variables.sql_log_bin; ulong binlog_format= thd->variables.binlog_format; if ((log_on == FALSE) || (binlog_format == BINLOG_FORMAT_ROW) || (table_list->table->s->table_category == TABLE_CATEGORY_LOG) || @@ -5305,8 +5311,8 @@ bool open_and_lock_tables(THD *thd, TABLE_LIST *tables, thd - thread handler tables - list of tables for open flags - bitmap of flags to modify how the tables will be open: - MYSQL_OPEN_IGNORE_FLUSH - open table even if someone has - done a flush or namelock on it. + MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has + done a flush on it. RETURN FALSE - ok @@ -8845,8 +8851,57 @@ bool is_equal(const LEX_STRING *a, const LEX_STRING *b) /* + Unlock and close table before renaming and dropping partitions + SYNOPSIS + alter_close_tables() + lpt Struct carrying parameters + RETURN VALUES + 0 +*/ + +static int alter_close_tables(ALTER_PARTITION_PARAM_TYPE *lpt) +{ + TABLE_SHARE *share= lpt->table->s; + THD *thd= lpt->thd; + TABLE *table; + DBUG_ENTER("alter_close_tables"); + /* + We must keep LOCK_open while manipulating with thd->open_tables. + Another thread may be working on it. + */ + mysql_mutex_lock(&LOCK_open); + /* + We can safely remove locks for all tables with the same name: + later they will all be closed anyway in + alter_partition_lock_handling(). + */ + for (table= thd->open_tables; table ; table= table->next) + { + if (!strcmp(table->s->table_name.str, share->table_name.str) && + !strcmp(table->s->db.str, share->db.str)) + { + mysql_lock_remove(thd, thd->lock, table); + table->file->close(); + table->db_stat= 0; // Mark file closed + /* + Ensure that we won't end up with a crippled table instance + in the table cache if an error occurs before we reach + alter_partition_lock_handling() and the table is closed + by close_thread_tables() instead. + */ + tdc_remove_table(thd, TDC_RT_REMOVE_UNUSED, + table->s->db.str, + table->s->table_name.str); + } + } + mysql_mutex_unlock(&LOCK_open); + DBUG_RETURN(0); +} + + +/* SYNOPSIS - abort_and_upgrade_lock() + abort_and_upgrade_lock_and_close_table() lpt Parameter passing struct All parameters passed through the ALTER_PARTITION_PARAM_TYPE object RETURN VALUE @@ -8855,7 +8910,7 @@ bool is_equal(const LEX_STRING *a, const LEX_STRING *b) Remember old lock level (for possible downgrade later on), abort all waiting threads and ensure that all keeping locks currently are completed such that we own the lock exclusively and no other interaction - is ongoing. + is ongoing. Close the table and hold the name lock. thd Thread object table Table object @@ -8864,12 +8919,14 @@ bool is_equal(const LEX_STRING *a, const LEX_STRING *b) old_lock_level Old lock level */ -int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt) +int abort_and_upgrade_lock_and_close_table(ALTER_PARTITION_PARAM_TYPE *lpt) { - DBUG_ENTER("abort_and_upgrade_lock"); + DBUG_ENTER("abort_and_upgrade_lock_and_close_table"); if (wait_while_table_is_used(lpt->thd, lpt->table, HA_EXTRA_FORCE_REOPEN)) DBUG_RETURN(1); + if (alter_close_tables(lpt)) + DBUG_RETURN(1); DBUG_RETURN(0); } diff --git a/sql/sql_base.h b/sql/sql_base.h index f5751094ee0..2abddb540b8 100644 --- a/sql/sql_base.h +++ b/sql/sql_base.h @@ -217,7 +217,7 @@ TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l, thr_lock_type lock_type, uint flags); bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags); bool lock_tables(THD *thd, TABLE_LIST *tables, uint counter, uint flags); -int abort_and_upgrade_lock(ALTER_PARTITION_PARAM_TYPE *lpt); +int abort_and_upgrade_lock_and_close_table(ALTER_PARTITION_PARAM_TYPE *lpt); int decide_logging_format(THD *thd, TABLE_LIST *tables); void free_io_cache(TABLE *entry); void intern_close_table(TABLE *entry); diff --git a/sql/sql_class.cc b/sql/sql_class.cc index 789b01443f7..ac092756a74 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -261,11 +261,13 @@ int thd_tablespace_op(const THD *thd) extern "C" -const char *set_thd_proc_info(THD *thd, const char *info, +const char *set_thd_proc_info(void *thd_arg, const char *info, const char *calling_function, const char *calling_file, const unsigned int calling_line) { + THD *thd= (THD *) thd_arg; + if (!thd) thd= current_thd; @@ -305,6 +307,37 @@ void **thd_ha_data(const THD *thd, const struct handlerton *hton) return (void **) &thd->ha_data[hton->slot].ha_ptr; } + +/** + Provide a handler data getter to simplify coding +*/ +extern "C" +void *thd_get_ha_data(const THD *thd, const struct handlerton *hton) +{ + return *thd_ha_data(thd, hton); +} + + +/** + Provide a handler data setter to simplify coding + @see thd_set_ha_data() definition in plugin.h +*/ +extern "C" +void thd_set_ha_data(THD *thd, const struct handlerton *hton, + const void *ha_data) +{ + plugin_ref *lock= &thd->ha_data[hton->slot].lock; + if (ha_data && !*lock) + *lock= ha_lock_engine(NULL, (handlerton*) hton); + else if (!ha_data && *lock) + { + plugin_unlock(NULL, *lock); + *lock= NULL; + } + *thd_ha_data(thd, hton)= (void*) ha_data; +} + + extern "C" long long thd_test_options(const THD *thd, long long test_options) { @@ -460,7 +493,6 @@ THD::THD() rli_fake(0), lock_id(&main_lock_id), user_time(0), in_sub_stmt(0), - sql_log_bin_toplevel(false), binlog_unsafe_warning_flags(0), binlog_table_maps(0), table_map_for_update(0), arg_of_last_insert_id_function(FALSE), @@ -929,7 +961,11 @@ void THD::init(void) update_charset(); reset_current_stmt_binlog_format_row(); bzero((char *) &status_var, sizeof(status_var)); - sql_log_bin_toplevel= variables.option_bits & OPTION_BIN_LOG; + + if (variables.sql_log_bin) + variables.option_bits|= OPTION_BIN_LOG; + else + variables.option_bits&= ~OPTION_BIN_LOG; #if defined(ENABLED_DEBUG_SYNC) /* Initialize the Debug Sync Facility. See debug_sync.cc. */ @@ -1884,8 +1920,7 @@ static File create_file(THD *thd, char *path, sql_exchange *exchange, else (void) fn_format(path, exchange->file_name, mysql_real_data_home, "", option); - if (opt_secure_file_priv && - strncmp(opt_secure_file_priv, path, strlen(opt_secure_file_priv))) + if (!is_secure_file_path(path)) { /* Write only allowed to dir or subdir specified by secure_file_priv */ my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--secure-file-priv"); @@ -2054,9 +2089,21 @@ bool select_export::send_data(List<Item> &items) const char *from_end_pos; const char *error_pos; uint32 bytes; - bytes= well_formed_copy_nchars(write_cs, cvt_buff, sizeof(cvt_buff), + uint64 estimated_bytes= + ((uint64) res->length() / res->charset()->mbminlen + 1) * + write_cs->mbmaxlen + 1; + set_if_smaller(estimated_bytes, UINT_MAX32); + if (cvt_str.realloc((uint32) estimated_bytes)) + { + my_error(ER_OUTOFMEMORY, MYF(0), (uint32) estimated_bytes); + goto err; + } + + bytes= well_formed_copy_nchars(write_cs, (char *) cvt_str.ptr(), + cvt_str.alloced_length(), res->charset(), res->ptr(), res->length(), - sizeof(cvt_buff), + UINT_MAX32, // copy all input chars, + // i.e. ignore nchars parameter &well_formed_error_pos, &cannot_convert_error_pos, &from_end_pos); @@ -2074,6 +2121,15 @@ bool select_export::send_data(List<Item> &items) "string", printable_buff, item->name, row_count); } + else if (from_end_pos < res->ptr() + res->length()) + { + /* + result is longer than UINT_MAX32 and doesn't fit into String + */ + push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, + WARN_DATA_TRUNCATED, ER(WARN_DATA_TRUNCATED), + item->full_name(), row_count); + } cvt_str.length(bytes); res= &cvt_str; } @@ -3138,6 +3194,11 @@ extern "C" bool thd_binlog_filter_ok(const MYSQL_THD thd) { return binlog_filter->db_ok(thd->db); } + +extern "C" bool thd_sqlcom_can_generate_row_events(const MYSQL_THD thd) +{ + return sqlcom_can_generate_row_events(thd); +} #endif // INNODB_COMPATIBILITY_HOOKS */ /**************************************************************************** @@ -3185,6 +3246,7 @@ void THD::reset_sub_statement_state(Sub_statement_state *backup, #endif backup->option_bits= variables.option_bits; + backup->count_cuted_fields= count_cuted_fields; backup->in_sub_stmt= in_sub_stmt; backup->enable_slow_log= enable_slow_log; backup->limit_found_rows= limit_found_rows; @@ -3222,6 +3284,7 @@ void THD::reset_sub_statement_state(Sub_statement_state *backup, void THD::restore_sub_statement_state(Sub_statement_state *backup) { + DBUG_ENTER("THD::restore_sub_statement_state"); #ifndef EMBEDDED_LIBRARY /* BUG#33029, if we are replicating from a buggy master, restore auto_inc_intervals_forced so that the top statement can use the @@ -3248,6 +3311,7 @@ void THD::restore_sub_statement_state(Sub_statement_state *backup) /* ha_release_savepoint() never returns error. */ (void)ha_release_savepoint(this, sv); } + count_cuted_fields= backup->count_cuted_fields; transaction.savepoints= backup->savepoints; variables.option_bits= backup->option_bits; in_sub_stmt= backup->in_sub_stmt; @@ -3277,6 +3341,7 @@ void THD::restore_sub_statement_state(Sub_statement_state *backup) */ examined_row_count+= backup->examined_row_count; cuted_fields+= backup->cuted_fields; + DBUG_VOID_RETURN; } @@ -3859,7 +3924,8 @@ int THD::decide_logging_format(TABLE_LIST *tables) */ my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE), MYF(0)); } - else if (variables.binlog_format == BINLOG_FORMAT_ROW) + else if (variables.binlog_format == BINLOG_FORMAT_ROW && + sqlcom_can_generate_row_events(this)) { /* 2. Error: Cannot modify table that uses a storage engine @@ -3897,7 +3963,8 @@ int THD::decide_logging_format(TABLE_LIST *tables) */ my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_MODE), MYF(0)); } - else if ((flags_write_all_set & HA_BINLOG_STMT_CAPABLE) == 0) + else if ((flags_write_all_set & HA_BINLOG_STMT_CAPABLE) == 0 && + sqlcom_can_generate_row_events(this)) { /* 5. Error: Cannot modify table that uses a storage engine @@ -4142,7 +4209,9 @@ field_type_name(enum_field_types type) #endif -namespace { +/* Declare in unnamed namespace. */ +CPP_UNNAMED_NS_START + /** Class to handle temporary allocation of memory for row data. @@ -4261,8 +4330,8 @@ namespace { uchar *m_memory; uchar *m_ptr[2]; }; -} +CPP_UNNAMED_NS_END int THD::binlog_write_row(TABLE* table, bool is_trans, MY_BITMAP const* cols, size_t colcnt, @@ -4406,7 +4475,6 @@ int THD::binlog_flush_pending_rows_event(bool stmt_end, bool is_transactional) if (stmt_end) { pending->set_flags(Rows_log_event::STMT_END_F); - pending->flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F; binlog_table_maps= 0; } @@ -4554,8 +4622,13 @@ int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query_arg, because the warnings should be printed only if the statement is actually logged. When executing decide_logging_format(), we cannot know for sure if the statement will be logged. + + Besides, we should not try to print these warnings if it is not + possible to write statements to the binary log as it happens when + the execution is inside a function, or generaly speaking, when + the variables.option_bits & OPTION_BIN_LOG is false. */ - if (sql_log_bin_toplevel) + if (variables.option_bits & OPTION_BIN_LOG) issue_unsafe_warnings(); switch (qtype) { @@ -4592,7 +4665,6 @@ int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query_arg, { Query_log_event qinfo(this, query_arg, query_len, is_trans, direct, suppress_use, errcode); - qinfo.flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F; /* Binlog table maps will be irrelevant after a Query_log_event (they are just removed on the slave side) so after the query diff --git a/sql/sql_class.h b/sql/sql_class.h index f662181d52b..8a25112b577 100644 --- a/sql/sql_class.h +++ b/sql/sql_class.h @@ -428,6 +428,7 @@ typedef struct system_variables uint binlog_format; ///< binlog format for this thd (see enum_binlog_format) my_bool binlog_direct_non_trans_update; + my_bool sql_log_bin; uint completion_type; uint query_cache_type; uint tx_isolation; @@ -1094,6 +1095,7 @@ public: bool enable_slow_log; bool last_insert_id_used; SAVEPOINT *savepoints; + enum enum_check_fields count_cuted_fields; }; @@ -1313,7 +1315,11 @@ struct Ha_data @sa trans_register_ha() */ Ha_trx_info ha_info[2]; - + /** + NULL: engine is not bound to this thread + non-NULL: engine is bound to this thread, engine shutdown forbidden + */ + plugin_ref lock; Ha_data() :ha_ptr(NULL) {} }; @@ -1511,8 +1517,6 @@ public: /* <> 0 if we are inside of trigger or stored function. */ uint in_sub_stmt; - /* TRUE when the current top has SQL_LOG_BIN ON */ - bool sql_log_bin_toplevel; /* container for handler's private per-connection data */ Ha_data ha_data[MAX_HA]; @@ -1890,8 +1894,15 @@ public: */ ha_rows sent_row_count; - /* - number of rows we read, sent or not, including in create_sort_index() + /** + Number of rows read and/or evaluated for a statement. Used for + slow log reporting. + + An examined row is defined as a row that is read and/or evaluated + according to a statement condition, including in + create_sort_index(). Rows may be counted more than once, e.g., a + statement including ORDER BY could possibly evaluate the row in + filesort() before reading it for e.g. update. */ ha_rows examined_row_count; @@ -1951,8 +1962,6 @@ public: char scramble[SCRAMBLE_LENGTH+1]; bool slave_thread, one_shot_set; - bool locked, some_tables_deleted; - bool last_cuted_field; bool no_errors, password; /** Set to TRUE if execution of the current compound statement @@ -3454,6 +3463,12 @@ public: */ #define CF_PROTECT_AGAINST_GRL (1U << 10) +/** + Identifies statements that may generate row events + and that may end up in the binary log. +*/ +#define CF_CAN_GENERATE_ROW_EVENTS (1U << 11) + /* Bits in server_command_flags */ /** @@ -3514,7 +3529,7 @@ inline bool add_group_to_list(THD *thd, Item *item, bool asc) three calling-info parameters. */ extern "C" -const char *set_thd_proc_info(THD *thd, const char *info, +const char *set_thd_proc_info(void *thd_arg, const char *info, const char *calling_func, const char *calling_file, const unsigned int calling_line); diff --git a/sql/sql_connect.cc b/sql/sql_connect.cc index e2d0977def7..c0081c13366 100644 --- a/sql/sql_connect.cc +++ b/sql/sql_connect.cc @@ -496,6 +496,13 @@ check_user(THD *thd, enum enum_server_command command, } my_ok(thd); thd->password= test(passwd_len); // remember for error messages + /* + Allow the network layer to skip big packets. Although a malicious + authenticated session might use this to trick the server to read + big packets indefinitely, this is a previously established behavior + that needs to be preserved as to not break backwards compatibility. + */ + thd->net.skip_big_packet= TRUE; /* Ready to handle queries */ DBUG_RETURN(0); } diff --git a/sql/sql_const.h b/sql/sql_const.h index 72f34ed6be8..dca66628ddb 100644 --- a/sql/sql_const.h +++ b/sql/sql_const.h @@ -136,7 +136,6 @@ #ifndef MYSQLD_NET_RETRY_COUNT #define MYSQLD_NET_RETRY_COUNT 10 ///< Abort read after this many int. #endif -#define TEMP_POOL_SIZE 128 #define QUERY_ALLOC_BLOCK_SIZE 8192 #define QUERY_ALLOC_PREALLOC_SIZE 8192 @@ -146,11 +145,8 @@ #define ACL_ALLOC_BLOCK_SIZE 1024 #define UDF_ALLOC_BLOCK_SIZE 1024 #define TABLE_ALLOC_BLOCK_SIZE 1024 -#define BDB_LOG_ALLOC_BLOCK_SIZE 1024 #define WARN_ALLOC_BLOCK_SIZE 2048 #define WARN_ALLOC_PREALLOC_SIZE 1024 -#define PROFILE_ALLOC_BLOCK_SIZE 2048 -#define PROFILE_ALLOC_PREALLOC_SIZE 1024 /* The following parameters is to decide when to use an extra cache to @@ -194,8 +190,6 @@ */ #define MATCHING_ROWS_IN_OTHER_TABLE 10 -#define RAID_BLOCK_SIZE 1024 - #define MY_CHARSET_BIN_MB_MAXLEN 1 /** Don't pack string keys shorter than this (if PACK_KEYS=1 isn't used). */ diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc index 730cb711a05..ece72e97d0d 100644 --- a/sql/sql_delete.cc +++ b/sql/sql_delete.cc @@ -25,8 +25,7 @@ #include "sql_cache.h" // query_cache_* #include "sql_base.h" // open_temprary_table #include "sql_table.h" // build_table_filename -#include "lock.h" // lock_and_wait_for_table_name, - // unlock_table_name +#include "lock.h" // unlock_table_name #include "sql_view.h" // check_key_in_view, mysql_frm_type #include "sql_parse.h" // mysql_init_select #include "sql_acl.h" // *_ACL @@ -243,6 +242,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, free_underlaid_joins(thd, &thd->lex->select_lex); DBUG_RETURN(TRUE); } + thd->examined_row_count+= examined_rows; /* Filesort has already found and selected the rows we want to delete, so we don't need the where clause @@ -260,7 +260,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, free_underlaid_joins(thd, select_lex); DBUG_RETURN(TRUE); } - if (usable_index==MAX_KEY) + if (usable_index==MAX_KEY || (select && select->quick)) init_read_record(&info, thd, table, select, 1, 1, FALSE); else init_read_record_idx(&info, thd, table, 1, usable_index); @@ -289,6 +289,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, while (!(error=info.read_record(&info)) && !thd->killed && ! thd->is_error()) { + thd->examined_row_count++; // thd->is_error() is tested to disallow delete row on error if (!(select && select->skip_record())&& ! thd->is_error() ) { diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index 002180c74df..998d3c53e04 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -3256,7 +3256,7 @@ bool select_insert::send_data(List<Item> &values) thd->count_cuted_fields= CHECK_FIELD_WARN; // Calculate cuted fields store_values(values); - thd->count_cuted_fields= CHECK_FIELD_IGNORE; + thd->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL; if (thd->is_error()) { table->auto_increment_field_not_null= FALSE; diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc index 48474609b9b..e87204ffd40 100644 --- a/sql/sql_lex.cc +++ b/sql/sql_lex.cc @@ -2219,6 +2219,7 @@ void LEX::cleanup_lex_after_parse_error(THD *thd) */ if (thd->lex->sphead) { + thd->lex->sphead->restore_thd_mem_root(thd); delete thd->lex->sphead; thd->lex->sphead= NULL; } diff --git a/sql/sql_lex.h b/sql/sql_lex.h index 38aac9a1042..2a1b1371975 100644 --- a/sql/sql_lex.h +++ b/sql/sql_lex.h @@ -2042,6 +2042,7 @@ struct LEX: public Query_tables_list - CREATE TRIGGER (points to "TRIGGER"); - CREATE PROCEDURE (points to "PROCEDURE"); - CREATE FUNCTION (points to "FUNCTION" or "AGGREGATE"); + - CREATE EVENT (points to "EVENT") This pointer is required to add possibly omitted DEFINER-clause to the DDL-statement before dumping it to the binlog. diff --git a/sql/sql_load.cc b/sql/sql_load.cc index ff9c16d229b..2c42f29ae71 100644 --- a/sql/sql_load.cc +++ b/sql/sql_load.cc @@ -1,4 +1,4 @@ -/* Copyright (C) 2000-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc +/* Copyright (c) 2000, 2010 Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -397,16 +397,11 @@ int mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list, DBUG_ASSERT(FALSE); #endif } - else if (opt_secure_file_priv) + else if (!is_secure_file_path(name)) { - char secure_file_real_path[FN_REFLEN]; - (void) my_realpath(secure_file_real_path, opt_secure_file_priv, 0); - if (strncmp(secure_file_real_path, name, strlen(secure_file_real_path))) - { - /* Read only allowed from within dir specified by secure_file_priv */ - my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--secure-file-priv"); - DBUG_RETURN(TRUE); - } + /* Read only allowed from within dir specified by secure_file_priv */ + my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--secure-file-priv"); + DBUG_RETURN(TRUE); } } @@ -572,7 +567,6 @@ int mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list, else { Delete_file_log_event d(thd, db, transactional_table); - d.flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F; (void) mysql_bin_log.write(&d); } } @@ -748,16 +742,13 @@ static bool write_execute_load_query_log_event(THD *thd, sql_exchange* ex, strcpy(end, p); end += pl; - thd->set_query_inner(load_data_query, end - load_data_query); - Execute_load_query_log_event - e(thd, thd->query(), thd->query_length(), - (uint) ((char*) fname_start - (char*) thd->query() - 1), - (uint) ((char*) fname_end - (char*) thd->query()), + e(thd, load_data_query, end-load_data_query, + (uint) ((char*) fname_start - load_data_query - 1), + (uint) ((char*) fname_end - load_data_query), (duplicates == DUP_REPLACE) ? LOAD_DUP_REPLACE : (ignore ? LOAD_DUP_IGNORE : LOAD_DUP_ERROR), transactional_table, FALSE, FALSE, errcode); - e.flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F; return mysql_bin_log.write(&e); } @@ -1717,7 +1708,7 @@ bool READ_INFO::find_start_of_fields() /* Clear taglist from tags with a specified level */ -int READ_INFO::clear_level(int level) +int READ_INFO::clear_level(int level_arg) { DBUG_ENTER("READ_INFO::read_xml clear_level"); List_iterator<XML_TAG> xmlit(taglist); @@ -1726,7 +1717,7 @@ int READ_INFO::clear_level(int level) while ((tag= xmlit++)) { - if(tag->level >= level) + if(tag->level >= level_arg) { xmlit.remove(); delete tag; diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index adab0b8e3d0..3c4c2eb1050 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -248,8 +248,19 @@ void init_update_queries(void) /* Initialize the sql command flags array. */ memset(sql_command_flags, 0, sizeof(sql_command_flags)); + /* + In general, DDL statements do not generate row events and do not go + through a cache before being written to the binary log. However, the + CREATE TABLE...SELECT is an exception because it may generate row + events. For that reason, the SQLCOM_CREATE_TABLE which represents + a CREATE TABLE, including the CREATE TABLE...SELECT, has the + CF_CAN_GENERATE_ROW_EVENTS flag. The distinction between a regular + CREATE TABLE and the CREATE TABLE...SELECT is made in other parts of + the code, in particular in the Query_log_event's constructor. + */ sql_command_flags[SQLCOM_CREATE_TABLE]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_AUTO_COMMIT_TRANS | CF_PROTECT_AGAINST_GRL; + CF_AUTO_COMMIT_TRANS | CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_CREATE_INDEX]= CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS; sql_command_flags[SQLCOM_ALTER_TABLE]= CF_CHANGES_DATA | CF_WRITE_LOGS_COMMAND | CF_AUTO_COMMIT_TRANS | CF_PROTECT_AGAINST_GRL; @@ -257,7 +268,8 @@ void init_update_queries(void) CF_AUTO_COMMIT_TRANS | CF_PROTECT_AGAINST_GRL; sql_command_flags[SQLCOM_DROP_TABLE]= CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS; sql_command_flags[SQLCOM_LOAD]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_PROTECT_AGAINST_GRL; + CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_CREATE_DB]= CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS; sql_command_flags[SQLCOM_DROP_DB]= CF_CHANGES_DATA | CF_AUTO_COMMIT_TRANS; sql_command_flags[SQLCOM_ALTER_DB_UPGRADE]= CF_AUTO_COMMIT_TRANS; @@ -276,22 +288,32 @@ void init_update_queries(void) sql_command_flags[SQLCOM_DROP_TRIGGER]= CF_AUTO_COMMIT_TRANS; sql_command_flags[SQLCOM_UPDATE]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_PROTECT_AGAINST_GRL; + CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_UPDATE_MULTI]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_PROTECT_AGAINST_GRL; + CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_INSERT]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_PROTECT_AGAINST_GRL; + CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_INSERT_SELECT]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_PROTECT_AGAINST_GRL; + CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_DELETE]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_PROTECT_AGAINST_GRL; + CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_DELETE_MULTI]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | - CF_PROTECT_AGAINST_GRL; - sql_command_flags[SQLCOM_REPLACE]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE; - sql_command_flags[SQLCOM_REPLACE_SELECT]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE; - sql_command_flags[SQLCOM_SELECT]= CF_REEXECUTION_FRAGILE; + CF_PROTECT_AGAINST_GRL | + CF_CAN_GENERATE_ROW_EVENTS; + sql_command_flags[SQLCOM_REPLACE]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | + CF_CAN_GENERATE_ROW_EVENTS; + sql_command_flags[SQLCOM_REPLACE_SELECT]= CF_CHANGES_DATA | CF_REEXECUTION_FRAGILE | + CF_CAN_GENERATE_ROW_EVENTS; + sql_command_flags[SQLCOM_SELECT]= CF_REEXECUTION_FRAGILE | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_SET_OPTION]= CF_REEXECUTION_FRAGILE | CF_AUTO_COMMIT_TRANS; - sql_command_flags[SQLCOM_DO]= CF_REEXECUTION_FRAGILE; + sql_command_flags[SQLCOM_DO]= CF_REEXECUTION_FRAGILE | + CF_CAN_GENERATE_ROW_EVENTS; sql_command_flags[SQLCOM_SHOW_STATUS_PROC]= CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE; sql_command_flags[SQLCOM_SHOW_STATUS]= CF_STATUS_COMMAND | CF_REEXECUTION_FRAGILE; @@ -366,7 +388,9 @@ void init_update_queries(void) last called (or executed) statement is preserved. See mysql_execute_command() for how CF_ROW_COUNT is used. */ - sql_command_flags[SQLCOM_CALL]= CF_REEXECUTION_FRAGILE; + sql_command_flags[SQLCOM_CALL]= CF_REEXECUTION_FRAGILE | + CF_CAN_GENERATE_ROW_EVENTS; + sql_command_flags[SQLCOM_EXECUTE]= CF_CAN_GENERATE_ROW_EVENTS; /* The following admin table operations are allowed @@ -391,7 +415,12 @@ void init_update_queries(void) sql_command_flags[SQLCOM_CHECK]= CF_AUTO_COMMIT_TRANS; } - +bool sqlcom_can_generate_row_events(const THD *thd) +{ + return (sql_command_flags[thd->lex->sql_command] & + CF_CAN_GENERATE_ROW_EVENTS); +} + bool is_update_query(enum enum_sql_command command) { DBUG_ASSERT(command >= 0 && command <= SQLCOM_END); @@ -1161,8 +1190,23 @@ bool dispatch_command(enum enum_server_command command, THD *thd, We have name + wildcard in packet, separated by endzero */ arg_end= strend(packet); + uint arg_length= arg_end - packet; + + /* Check given table name length. */ + if (arg_length >= packet_length || arg_length > NAME_LEN) + { + my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0)); + break; + } thd->convert_string(&conv_name, system_charset_info, - packet, (uint) (arg_end - packet), thd->charset()); + packet, arg_length, thd->charset()); + if (check_table_name(conv_name.str, conv_name.length, FALSE)) + { + /* this is OK due to convert_string() null-terminating the string */ + my_error(ER_WRONG_TABLE_NAME, MYF(0), conv_name.str); + break; + } + table_list.alias= table_list.table_name= conv_name.str; packet= arg_end + 1; @@ -2657,6 +2701,10 @@ case SQLCOM_PREPARE: */ lex->unlink_first_table(&link_to_local); + /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */ + if (create_info.options & HA_LEX_CREATE_TMP_TABLE) + thd->variables.option_bits|= OPTION_KEEP_LOG; + /* select_create is currently not re-execution friendly and needs to be created for every execution of a PS/SP. @@ -2945,7 +2993,7 @@ end_with_restore_list: access is granted. We need to check if first_table->grant.privilege contains any table-specific privilege. */ - DBUG_PRINT("debug", ("first_table->grant.privilege: %x", + DBUG_PRINT("debug", ("first_table->grant.privilege: %lx", first_table->grant.privilege)); if (check_some_access(thd, SHOW_CREATE_TABLE_ACLS, first_table) || (first_table->grant.privilege & SHOW_CREATE_TABLE_ACLS) == 0) @@ -3240,7 +3288,7 @@ end_with_restore_list: TODO: this is workaround. right way will be move invalidating in the unlock procedure. */ - if (first_table->lock_type == TL_WRITE_CONCURRENT_INSERT && + if (!res && first_table->lock_type == TL_WRITE_CONCURRENT_INSERT && thd->lock) { /* INSERT ... SELECT should invalidate only the very first table */ @@ -6041,7 +6089,7 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd, DBUG_RETURN(0); // End of memory alias_str= alias ? alias->str : table->table.str; if (!test(table_options & TL_OPTION_ALIAS) && - check_table_name(table->table.str, table->table.length)) + check_table_name(table->table.str, table->table.length, FALSE)) { my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str); DBUG_RETURN(0); diff --git a/sql/sql_parse.h b/sql/sql_parse.h index ca804d5fab0..c9264b999b3 100644 --- a/sql/sql_parse.h +++ b/sql/sql_parse.h @@ -79,6 +79,7 @@ bool check_host_name(LEX_STRING *str); bool check_identifier_name(LEX_STRING *str, uint max_char_length, uint err_code, const char *param_for_err_msg); bool mysql_test_parse_for_slave(THD *thd,char *inBuf,uint length); +bool sqlcom_can_generate_row_events(const THD *thd); bool is_update_query(enum enum_sql_command command); bool is_log_table_write_query(enum enum_sql_command command); bool alloc_query(THD *thd, const char *packet, uint packet_length); diff --git a/sql/sql_partition.cc b/sql/sql_partition.cc index 0eb92dc23a9..fa9c698622b 100644 --- a/sql/sql_partition.cc +++ b/sql/sql_partition.cc @@ -3096,7 +3096,7 @@ int get_partition_id_list_col(partition_info *part_info, } else { - *part_id= (uint32)list_col_array[list_index].partition_id; + *part_id= (uint32)list_col_array[list_index*num_columns].partition_id; DBUG_RETURN(0); } } @@ -4186,7 +4186,6 @@ void get_partition_set(const TABLE *table, uchar *buf, const uint index, bool mysql_unpack_partition(THD *thd, const char *part_buf, uint part_info_len, - const char *part_state, uint part_state_len, TABLE* table, bool is_create_table_ind, handlerton *default_db_type, bool *work_part_info_used) @@ -4222,8 +4221,6 @@ bool mysql_unpack_partition(THD *thd, goto end; } part_info= lex.part_info; - part_info->part_state= part_state; - part_info->part_state_len= part_state_len; DBUG_PRINT("info", ("Parse: %s", part_buf)); if (parse_sql(thd, & parser_state, NULL) || part_info->fix_parser_data(thd)) @@ -4587,7 +4584,7 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info, partition_info *tab_part_info= table->part_info; partition_info *alt_part_info= thd->work_part_info; uint flags= 0; - bool is_last_partition_reorged; + bool is_last_partition_reorged= FALSE; part_elem_value *tab_max_elem_val= NULL; part_elem_value *alt_max_elem_val= NULL; longlong tab_max_range= 0, alt_max_range= 0; @@ -6283,54 +6280,6 @@ static void alter_partition_lock_handling(ALTER_PARTITION_PARAM_TYPE *lpt) sql_print_warning("We failed to reacquire LOCKs in ALTER TABLE"); } -/* - Unlock and close table before renaming and dropping partitions - SYNOPSIS - alter_close_tables() - lpt Struct carrying parameters - RETURN VALUES - 0 -*/ - -static int alter_close_tables(ALTER_PARTITION_PARAM_TYPE *lpt) -{ - TABLE_SHARE *share= lpt->table->s; - THD *thd= lpt->thd; - TABLE *table; - DBUG_ENTER("alter_close_tables"); - /* - We must keep LOCK_open while manipulating with thd->open_tables. - Another thread may be working on it. - */ - mysql_mutex_lock(&LOCK_open); - /* - We can safely remove locks for all tables with the same name: - later they will all be closed anyway in - alter_partition_lock_handling(). - */ - for (table= thd->open_tables; table ; table= table->next) - { - if (!strcmp(table->s->table_name.str, share->table_name.str) && - !strcmp(table->s->db.str, share->db.str)) - { - mysql_lock_remove(thd, thd->lock, table); - table->file->close(); - table->db_stat= 0; // Mark file closed - /* - Ensure that we won't end up with a crippled table instance - in the table cache if an error occurs before we reach - alter_partition_lock_handling() and the table is closed - by close_thread_tables() instead. - */ - tdc_remove_table(thd, TDC_RT_REMOVE_UNUSED, - table->s->db.str, - table->s->table_name.str); - } - } - mysql_mutex_unlock(&LOCK_open); - DBUG_RETURN(0); -} - /* Handle errors for ALTER TABLE for partitioning @@ -6629,9 +6578,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table, write_log_drop_partition(lpt) || ERROR_INJECT_CRASH("crash_drop_partition_3") || (not_completed= FALSE) || - abort_and_upgrade_lock(lpt) || - ERROR_INJECT_CRASH("crash_drop_partition_4") || - alter_close_tables(lpt) || + abort_and_upgrade_lock_and_close_table(lpt) || ERROR_INJECT_CRASH("crash_drop_partition_5") || ((!thd->lex->no_write_to_binlog) && (write_bin_log(thd, FALSE, @@ -6697,9 +6644,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table, ERROR_INJECT_CRASH("crash_add_partition_2") || mysql_change_partitions(lpt) || ERROR_INJECT_CRASH("crash_add_partition_3") || - abort_and_upgrade_lock(lpt) || - ERROR_INJECT_CRASH("crash_add_partition_4") || - alter_close_tables(lpt) || + abort_and_upgrade_lock_and_close_table(lpt) || ERROR_INJECT_CRASH("crash_add_partition_5") || ((!thd->lex->no_write_to_binlog) && (write_bin_log(thd, FALSE, @@ -6782,9 +6727,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table, write_log_final_change_partition(lpt) || ERROR_INJECT_CRASH("crash_change_partition_4") || (not_completed= FALSE) || - abort_and_upgrade_lock(lpt) || - ERROR_INJECT_CRASH("crash_change_partition_5") || - alter_close_tables(lpt) || + abort_and_upgrade_lock_and_close_table(lpt) || ERROR_INJECT_CRASH("crash_change_partition_6") || ((!thd->lex->no_write_to_binlog) && (write_bin_log(thd, FALSE, @@ -7701,7 +7644,7 @@ uint32 get_next_partition_id_range(PARTITION_ITERATOR* part_iter) DESCRIPTION This implementation of PARTITION_ITERATOR::get_next() is special for LIST partitioning: it enumerates partition ids in - part_info->list_array[i] (list_col_array[i] for COLUMNS LIST + part_info->list_array[i] (list_col_array[i*cols] for COLUMNS LIST partitioning) where i runs over [min_idx, max_idx] interval. The function conforms to partition_iter_func type. @@ -7727,9 +7670,12 @@ uint32 get_next_partition_id_list(PARTITION_ITERATOR *part_iter) { partition_info *part_info= part_iter->part_info; uint32 num_part= part_iter->part_nums.cur++; - return part_info->column_list ? - part_info->list_col_array[num_part].partition_id : - part_info->list_array[num_part].partition_id; + if (part_info->column_list) + { + uint num_columns= part_info->part_field_list.elements; + return part_info->list_col_array[num_part*num_columns].partition_id; + } + return part_info->list_array[num_part].partition_id; } } diff --git a/sql/sql_partition.h b/sql/sql_partition.h index 8542074e718..2e0ea740555 100644 --- a/sql/sql_partition.h +++ b/sql/sql_partition.h @@ -64,20 +64,6 @@ typedef struct st_lock_param_type partition_info *part_info; } ALTER_PARTITION_PARAM_TYPE; - -/*typedef struct { - ulonglong data_file_length; - ulonglong max_data_file_length; - ulonglong index_file_length; - ulonglong delete_length; - ha_rows records; - ulong mean_rec_length; - time_t create_time; - time_t check_time; - time_t update_time; - ulonglong check_sum; -} PARTITION_INFO; -*/ typedef struct { longlong list_value; uint32 partition_id; @@ -126,7 +112,6 @@ void get_full_part_id_from_key(const TABLE *table, uchar *buf, part_id_range *part_spec); bool mysql_unpack_partition(THD *thd, const char *part_buf, uint part_info_len, - const char *part_state, uint part_state_len, TABLE *table, bool is_create_table_ind, handlerton *default_db_type, bool *work_part_info_used); diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc index 31e0cced207..0282053ce7e 100644 --- a/sql/sql_plugin.cc +++ b/sql/sql_plugin.cc @@ -1755,6 +1755,12 @@ bool mysql_install_plugin(THD *thd, const LEX_STRING *name, const LEX_STRING *dl struct st_plugin_int *tmp; DBUG_ENTER("mysql_install_plugin"); + if (opt_noacl) + { + my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--skip-grant-tables"); + DBUG_RETURN(TRUE); + } + tables.init_one_table("mysql", 5, "plugin", 6, "plugin", TL_WRITE); if (check_table_access(thd, INSERT_ACL, &tables, FALSE, 1, FALSE)) DBUG_RETURN(TRUE); @@ -1829,6 +1835,12 @@ bool mysql_uninstall_plugin(THD *thd, const LEX_STRING *name) struct st_plugin_int *plugin; DBUG_ENTER("mysql_uninstall_plugin"); + if (opt_noacl) + { + my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--skip-grant-tables"); + DBUG_RETURN(TRUE); + } + tables.init_one_table("mysql", 5, "plugin", 6, "plugin", TL_WRITE); if (check_table_access(thd, DELETE_ACL, &tables, FALSE, 1, FALSE)) diff --git a/sql/sql_priv.h b/sql/sql_priv.h index 20893e0caa8..8601b10b9bf 100644 --- a/sql/sql_priv.h +++ b/sql/sql_priv.h @@ -187,10 +187,6 @@ extern char err_shared_dir[]; #define BINLOG_DUMP_NON_BLOCK 1 -/* sql_show.cc:show_log_files() */ -#define SHOW_LOG_STATUS_FREE "FREE" -#define SHOW_LOG_STATUS_INUSE "IN USE" - /* Some defines for exit codes for ::is_equal class functions. */ diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc index 1ee770f70ef..787f9dcae2c 100644 --- a/sql/sql_repl.cc +++ b/sql/sql_repl.cc @@ -1347,6 +1347,10 @@ bool change_master(THD* thd, Master_info* mi) const char* errmsg= 0; bool need_relay_log_purge= 1; bool ret= FALSE; + char saved_host[HOSTNAME_LENGTH + 1]; + uint saved_port; + char saved_log_name[FN_REFLEN]; + my_off_t saved_log_pos; DBUG_ENTER("change_master"); lock_slave_threads(mi); @@ -1389,6 +1393,17 @@ bool change_master(THD* thd, Master_info* mi) */ /* + Before processing the command, save the previous state. + */ + char *pos; + pos= strmake(saved_host, mi->host, HOSTNAME_LENGTH); + pos= '\0'; + saved_port= mi->port; + pos= strmake(saved_log_name, mi->master_log_name, FN_REFLEN - 1); + pos= '\0'; + saved_log_pos= mi->master_log_pos; + + /* If the user specified host or port without binlog or position, reset binlog's name to FIRST and position to 4. */ @@ -1586,6 +1601,15 @@ bool change_master(THD* thd, Master_info* mi) /* Clear the errors, for a clean start */ mi->rli.clear_error(); mi->rli.clear_until_condition(); + + sql_print_information("'CHANGE MASTER TO executed'. " + "Previous state master_host='%s', master_port='%u', master_log_file='%s', " + "master_log_pos='%ld'. " + "New state master_host='%s', master_port='%u', master_log_file='%s', " + "master_log_pos='%ld'.", saved_host, saved_port, saved_log_name, + (ulong) saved_log_pos, mi->host, mi->port, mi->master_log_name, + (ulong) mi->master_log_pos); + /* If we don't write new coordinates to disk now, then old will remain in relay-log.info until START SLAVE is issued; but if mysqld is shutdown diff --git a/sql/sql_select.cc b/sql/sql_select.cc index d126d0e4ec6..10884a95b74 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -44,7 +44,7 @@ #include "sql_partition.h" // make_used_partitions_str #include "sql_acl.h" // *_ACL #include "sql_test.h" // print_where, print_keyuse_array, - // print_sjm, print_plan + // print_sjm, print_plan, TEST_join #include "records.h" // init_read_record, end_read_record #include "filesort.h" // filesort_free_buffers #include "sql_union.h" // mysql_union @@ -90,8 +90,10 @@ static bool best_extension_by_limited_search(JOIN *join, double read_time, uint depth, uint prune_level); static uint determine_search_depth(JOIN* join); +C_MODE_START static int join_tab_cmp(const void* ptr1, const void* ptr2); static int join_tab_cmp_straight(const void* ptr1, const void* ptr2); +C_MODE_END /* TODO: 'find_best' is here only temporarily until 'greedy_search' is tested and approved. @@ -1126,9 +1128,8 @@ JOIN::optimize() } } - if (conds &&!outer_join && const_table_map != found_const_table_map && - (select_options & SELECT_DESCRIBE) && - select_lex->master_unit() == &thd->lex->unit) // upper level SELECT + if (conds && const_table_map != found_const_table_map && + (select_options & SELECT_DESCRIBE)) { conds=new Item_int((longlong) 0,1); // Always false } @@ -1145,13 +1146,13 @@ JOIN::optimize() elements may be lost during further having condition transformation in JOIN::exec. */ - if (having && !having->with_sum_func) + if (having && const_table_map) { - COND *const_cond= make_cond_for_table(having, const_table_map, 0); - DBUG_EXECUTE("where", print_where(const_cond, "const_having_cond", - QT_ORDINARY);); - if (const_cond && !const_cond->val_int()) + having->update_used_tables(); + having= remove_eq_conds(thd, having, &having_value); + if (having_value == Item::COND_FALSE) { + having= new Item_int((longlong) 0,1); zero_result_cause= "Impossible HAVING noticed after reading const tables"; error= 0; DBUG_RETURN(0); @@ -3006,8 +3007,7 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables_arg, COND *conds, s->quick=select->quick; s->needed_reg=select->needed_reg; select->quick=0; - if (records == 0 && s->table->reginfo.impossible_range && - (s->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT)) + if (records == 0 && s->table->reginfo.impossible_range) { /* Impossible WHERE or ON expression @@ -5162,6 +5162,11 @@ greedy_search(JOIN *join, if (best_extension_by_limited_search(join, remaining_tables, idx, record_count, read_time, search_depth, prune_level)) DBUG_RETURN(TRUE); + /* + 'best_read < DBL_MAX' means that optimizer managed to find + some plan and updated 'best_positions' array accordingly. + */ + DBUG_ASSERT(join->best_read < DBL_MAX); if (size_remain <= search_depth) { @@ -8942,8 +8947,14 @@ simplify_joins(JOIN *join, List<TABLE_LIST> *join_list, COND *conds, bool top) we still make the inner tables dependent on the outer tables. It would be enough to set dependency only on one outer table for them. Yet this is really a rare case. + Note: + RAND_TABLE_BIT mask should not be counted as it + prevents update of inner table dependences. + For example it might happen if RAND() function + is used in JOIN ON clause. */ - if (!(prev_table->on_expr->used_tables() & ~prev_used_tables)) + if (!((prev_table->on_expr->used_tables() & ~RAND_TABLE_BIT) & + ~prev_used_tables)) prev_table->dep_tables|= used_tables; } } @@ -9199,6 +9210,46 @@ static bool check_interleaving_with_nj(JOIN_TAB *next_tab) /** Nested joins perspective: Remove the last table from the join order. + The algorithm is the reciprocal of check_interleaving_with_nj(), hence + parent join nest nodes are updated only when the last table in its child + node is removed. The ASCII graphic below will clarify. + + %A table nesting such as <tt> t1 x [ ( t2 x t3 ) x ( t4 x t5 ) ] </tt>is + represented by the below join nest tree. + + @verbatim + NJ1 + _/ / \ + _/ / NJ2 + _/ / / \ + / / / \ + t1 x [ (t2 x t3) x (t4 x t5) ] + @endverbatim + + At the point in time when check_interleaving_with_nj() adds the table t5 to + the query execution plan, QEP, it also directs the node named NJ2 to mark + the table as covered. NJ2 does so by incrementing its @c counter + member. Since all of NJ2's tables are now covered by the QEP, the algorithm + proceeds up the tree to NJ1, incrementing its counter as well. All join + nests are now completely covered by the QEP. + + restore_prev_nj_state() does the above in reverse. As seen above, the node + NJ1 contains the nodes t2, t3, and NJ2. Its counter being equal to 3 means + that the plan covers t2, t3, and NJ2, @e and that the sub-plan (t4 x t5) + completely covers NJ2. The removal of t5 from the partial plan will first + decrement NJ2's counter to 1. It will then detect that NJ2 went from being + completely to partially covered, and hence the algorithm must continue + upwards to NJ1 and decrement its counter to 2. %A subsequent removal of t4 + will however not influence NJ1 since it did not un-cover the last table in + NJ2. + + SYNOPSIS + restore_prev_nj_state() + last join table to remove, it is assumed to be the last in current + partial join order. + + DESCRIPTION + Remove the last table from the partial join order and update the nested joins counters and join->cur_embedding_map. It is ok to call this function for the first table in join order (for which @@ -9212,19 +9263,20 @@ static void restore_prev_nj_state(JOIN_TAB *last) { TABLE_LIST *last_emb= last->table->pos_in_table_list->embedding; JOIN *join= last->join; - while (last_emb) + for (;last_emb != NULL; last_emb= last_emb->embedding) { - if (!(--last_emb->nested_join->counter)) - join->cur_embedding_map&= ~last_emb->nested_join->nj_map; - else if (last_emb->nested_join->join_list.elements-1 == - last_emb->nested_join->counter) - { - join->cur_embedding_map|= last_emb->nested_join->nj_map; - break; - } - else + NESTED_JOIN *nest= last_emb->nested_join; + DBUG_ASSERT(nest->counter > 0); + + bool was_fully_covered= nest->is_fully_covered(); + + if (--nest->counter == 0) + join->cur_embedding_map&= ~nest->nj_map; + + if (!was_fully_covered) break; - last_emb= last_emb->embedding; + + join->cur_embedding_map|= nest->nj_map; } } diff --git a/sql/sql_select.h b/sql/sql_select.h index ccf88c2cc5c..2c44dba74c3 100644 --- a/sql/sql_select.h +++ b/sql/sql_select.h @@ -597,7 +597,6 @@ typedef struct st_select_check { } SELECT_CHECK; extern const char *join_type_str[]; -void TEST_join(JOIN *join); /* Extern functions in sql_select.cc */ bool store_val_in_field(Field *field, Item *val, enum_check_fields check_flag); diff --git a/sql/sql_show.cc b/sql/sql_show.cc index 7fe84ce0dd4..61b61106522 100644 --- a/sql/sql_show.cc +++ b/sql/sql_show.cc @@ -48,7 +48,7 @@ #include "event_data_objects.h" #endif #include <my_dir.h> -#include "lock.h" // MYSQL_LOCK_IGNORE_FLUSH +#include "lock.h" // MYSQL_OPEN_IGNORE_FLUSH #include "debug_sync.h" #include "datadict.h" // dd_frm_type() @@ -1915,6 +1915,8 @@ int fill_schema_processlist(THD* thd, TABLE_LIST* tables, COND* cond) mysql_mutex_unlock(&mysys_var->mutex); /* INFO */ + /* Lock THD mutex that protects its data when looking at it. */ + mysql_mutex_lock(&tmp->LOCK_thd_data); if (tmp->query()) { table->field[7]->store(tmp->query(), @@ -1922,6 +1924,7 @@ int fill_schema_processlist(THD* thd, TABLE_LIST* tables, COND* cond) tmp->query_length()), cs); table->field[7]->set_notnull(); } + mysql_mutex_unlock(&tmp->LOCK_thd_data); if (schema_table_store_record(thd, table)) { @@ -1941,10 +1944,13 @@ int fill_schema_processlist(THD* thd, TABLE_LIST* tables, COND* cond) static DYNAMIC_ARRAY all_status_vars; static bool status_vars_inited= 0; + +C_MODE_START static int show_var_cmp(const void *var1, const void *var2) { return strcmp(((SHOW_VAR*)var1)->name, ((SHOW_VAR*)var2)->name); } +C_MODE_END /* deletes all the SHOW_UNDEF elements from the array and calls @@ -3296,12 +3302,17 @@ static int fill_schema_table_from_frm(THD *thd, TABLE_LIST *tables, goto end_share; } + if (!open_table_from_share(thd, share, table_name->str, 0, + (EXTRA_RECORD | OPEN_FRM_FILE_ONLY), + thd->open_options, &tbl, FALSE)) { tbl.s= share; table_list.table= &tbl; table_list.view= (LEX*) share->is_view; res= schema_table->process_table(thd, &table_list, table, res, db_name, table_name); + free_root(&tbl.mem_root, MYF(0)); + my_free((char*) tbl.alias, MYF(MY_ALLOW_ZERO_PTR)); } end_share: @@ -3544,6 +3555,7 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond) lex->sql_command= SQLCOM_SHOW_FIELDS; show_table_list->i_s_requested_object= schema_table->i_s_requested_object; + DEBUG_SYNC(thd, "before_open_in_get_all_tables"); res= open_normal_and_derived_tables(thd, show_table_list, (MYSQL_OPEN_IGNORE_FLUSH | MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL | @@ -3754,7 +3766,7 @@ static int get_schema_tables_record(THD *thd, TABLE_LIST *tables, } #ifdef WITH_PARTITION_STORAGE_ENGINE if (share->db_type() == partition_hton && - share->partition_info_len) + share->partition_info_str_len) { tmp_db_type= share->default_part_db_type; is_partitioned= TRUE; @@ -4028,7 +4040,6 @@ static int get_schema_column_record(THD *thd, TABLE_LIST *tables, const char *wild= lex->wild ? lex->wild->ptr() : NullS; CHARSET_INFO *cs= system_charset_info; TABLE *show_table; - TABLE_SHARE *show_table_share; Field **ptr, *field, *timestamp_field; int count; DBUG_ENTER("get_schema_column_record"); @@ -4051,37 +4062,11 @@ static int get_schema_column_record(THD *thd, TABLE_LIST *tables, } show_table= tables->table; - show_table_share= show_table->s; count= 0; - - if (tables->view || tables->schema_table) - { - ptr= show_table->field; - timestamp_field= show_table->timestamp_field; - show_table->use_all_columns(); // Required for default - } - else - { - ptr= show_table_share->field; - timestamp_field= show_table_share->timestamp_field; - /* - read_set may be inited in case of - temporary table - */ - if (!show_table->read_set) - { - /* to satisfy 'field->val_str' ASSERTs */ - uchar *bitmaps; - uint bitmap_size= show_table_share->column_bitmap_size; - if (!(bitmaps= (uchar*) alloc_root(thd->mem_root, bitmap_size))) - DBUG_RETURN(0); - bitmap_init(&show_table->def_read_set, - (my_bitmap_map*) bitmaps, show_table_share->fields, FALSE); - bitmap_set_all(&show_table->def_read_set); - show_table->read_set= &show_table->def_read_set; - } - bitmap_set_all(show_table->read_set); - } + ptr= show_table->field; + timestamp_field= show_table->timestamp_field; + show_table->use_all_columns(); // Required for default + restore_record(show_table, s->default_values); for (; (field= *ptr) ; ptr++) { @@ -4090,9 +4075,7 @@ static int get_schema_column_record(THD *thd, TABLE_LIST *tables, String type(tmp,sizeof(tmp), system_charset_info); char *end; - /* to satisfy 'field->val_str' ASSERTs */ - field->table= show_table; - show_table->in_use= thd; + DEBUG_SYNC(thd, "get_schema_column"); if (wild && wild[0] && wild_case_compare(system_charset_info, field->field_name,wild)) @@ -4351,6 +4334,15 @@ int fill_schema_coll_charset_app(THD *thd, TABLE_LIST *tables, COND *cond) } +static inline void copy_field_as_string(Field *to_field, Field *from_field) +{ + char buff[MAX_FIELD_WIDTH]; + String tmp_str(buff, sizeof(buff), system_charset_info); + from_field->val_str(&tmp_str); + to_field->store(tmp_str.ptr(), tmp_str.length(), system_charset_info); +} + + /** @brief Store record into I_S.PARAMETERS table @@ -4517,18 +4509,26 @@ bool store_schema_params(THD *thd, TABLE *table, TABLE *proc_table, bool store_schema_proc(THD *thd, TABLE *table, TABLE *proc_table, const char *wild, bool full_access, const char *sp_user) { - String tmp_string; - String sp_db, sp_name, definer; MYSQL_TIME time; LEX *lex= thd->lex; CHARSET_INFO *cs= system_charset_info; - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DB], &sp_db); - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_NAME], &sp_name); - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DEFINER],&definer); + char sp_db_buff[NAME_LEN + 1], sp_name_buff[NAME_LEN + 1], + definer_buff[USERNAME_LENGTH + HOSTNAME_LENGTH + 2], + returns_buff[MAX_FIELD_WIDTH]; + + String sp_db(sp_db_buff, sizeof(sp_db_buff), cs); + String sp_name(sp_name_buff, sizeof(sp_name_buff), cs); + String definer(definer_buff, sizeof(definer_buff), cs); + String returns(returns_buff, sizeof(returns_buff), cs); + + proc_table->field[MYSQL_PROC_FIELD_DB]->val_str(&sp_db); + proc_table->field[MYSQL_PROC_FIELD_NAME]->val_str(&sp_name); + proc_table->field[MYSQL_PROC_FIELD_DEFINER]->val_str(&definer); + if (!full_access) - full_access= !strcmp(sp_user, definer.ptr()); - if (!full_access && - check_some_routine_access(thd, sp_db.ptr(), sp_name.ptr(), + full_access= !strcmp(sp_user, definer.c_ptr_safe()); + if (!full_access && + check_some_routine_access(thd, sp_db.c_ptr_safe(), sp_name.c_ptr_safe(), proc_table->field[MYSQL_PROC_MYSQL_TYPE]-> val_int() == TYPE_ENUM_PROCEDURE)) return 0; @@ -4542,32 +4542,30 @@ bool store_schema_proc(THD *thd, TABLE *table, TABLE *proc_table, (sql_command_flags[lex->sql_command] & CF_STATUS_COMMAND) == 0) { restore_record(table, s->default_values); - if (!wild || !wild[0] || !wild_compare(sp_name.ptr(), wild, 0)) + if (!wild || !wild[0] || !wild_compare(sp_name.c_ptr_safe(), wild, 0)) { int enum_idx= (int) proc_table->field[MYSQL_PROC_FIELD_ACCESS]->val_int(); table->field[3]->store(sp_name.ptr(), sp_name.length(), cs); - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_SPECIFIC_NAME], - &tmp_string); - table->field[0]->store(tmp_string.ptr(), tmp_string.length(), cs); + + copy_field_as_string(table->field[0], + proc_table->field[MYSQL_PROC_FIELD_SPECIFIC_NAME]); table->field[1]->store(STRING_WITH_LEN("def"), cs); table->field[2]->store(sp_db.ptr(), sp_db.length(), cs); - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_MYSQL_TYPE], - &tmp_string); - table->field[4]->store(tmp_string.ptr(), tmp_string.length(), cs); + copy_field_as_string(table->field[4], + proc_table->field[MYSQL_PROC_MYSQL_TYPE]); + if (proc_table->field[MYSQL_PROC_MYSQL_TYPE]->val_int() == TYPE_ENUM_FUNCTION) { sp_head *sp; bool free_sp_head; - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_RETURNS], - &tmp_string); - + proc_table->field[MYSQL_PROC_FIELD_RETURNS]->val_str(&returns); sp= sp_load_for_information_schema(thd, proc_table, &sp_db, &sp_name, (ulong) proc_table-> field[MYSQL_PROC_FIELD_SQL_MODE]-> val_int(), TYPE_ENUM_FUNCTION, - tmp_string.c_ptr_safe(), + returns.c_ptr_safe(), "", &free_sp_head); if (sp) @@ -4598,24 +4596,19 @@ bool store_schema_proc(THD *thd, TABLE *table, TABLE *proc_table, if (full_access) { - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_BODY_UTF8], - &tmp_string); - table->field[14]->store(tmp_string.ptr(), tmp_string.length(), cs); + copy_field_as_string(table->field[14], + proc_table->field[MYSQL_PROC_FIELD_BODY_UTF8]); table->field[14]->set_notnull(); } table->field[13]->store(STRING_WITH_LEN("SQL"), cs); table->field[17]->store(STRING_WITH_LEN("SQL"), cs); - - - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DETERMINISTIC], - &tmp_string); - table->field[18]->store(tmp_string.ptr(), tmp_string.length(), cs); + copy_field_as_string(table->field[18], + proc_table->field[MYSQL_PROC_FIELD_DETERMINISTIC]); table->field[19]->store(sp_data_access_name[enum_idx].str, sp_data_access_name[enum_idx].length , cs); + copy_field_as_string(table->field[21], + proc_table->field[MYSQL_PROC_FIELD_SECURITY_TYPE]); - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_SECURITY_TYPE], - &tmp_string); - table->field[21]->store(tmp_string.ptr(), tmp_string.length(), cs); bzero((char *)&time, sizeof(time)); ((Field_timestamp *) proc_table->field[MYSQL_PROC_FIELD_CREATED])-> get_time(&time); @@ -4624,29 +4617,20 @@ bool store_schema_proc(THD *thd, TABLE *table, TABLE *proc_table, ((Field_timestamp *) proc_table->field[MYSQL_PROC_FIELD_MODIFIED])-> get_time(&time); table->field[23]->store_time(&time, MYSQL_TIMESTAMP_DATETIME); + copy_field_as_string(table->field[24], + proc_table->field[MYSQL_PROC_FIELD_SQL_MODE]); + copy_field_as_string(table->field[25], + proc_table->field[MYSQL_PROC_FIELD_COMMENT]); - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_SQL_MODE], - &tmp_string); - table->field[24]->store(tmp_string.ptr(), tmp_string.length(), cs); - - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_COMMENT], - &tmp_string); - table->field[25]->store(tmp_string.ptr(), tmp_string.length(), cs); table->field[26]->store(definer.ptr(), definer.length(), cs); - - get_field(thd->mem_root, - proc_table->field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT], - &tmp_string); - table->field[27]->store(tmp_string.ptr(), tmp_string.length(), cs); - - get_field(thd->mem_root, - proc_table->field[ MYSQL_PROC_FIELD_COLLATION_CONNECTION], - &tmp_string); - table->field[28]->store(tmp_string.ptr(), tmp_string.length(), cs); - - get_field(thd->mem_root, proc_table->field[MYSQL_PROC_FIELD_DB_COLLATION], - &tmp_string); - table->field[29]->store(tmp_string.ptr(), tmp_string.length(), cs); + copy_field_as_string(table->field[27], + proc_table-> + field[MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT]); + copy_field_as_string(table->field[28], + proc_table-> + field[MYSQL_PROC_FIELD_COLLATION_CONNECTION]); + copy_field_as_string(table->field[29], + proc_table->field[MYSQL_PROC_FIELD_DB_COLLATION]); return schema_table_store_record(thd, table); } @@ -5242,7 +5226,8 @@ static int get_schema_key_column_usage_record(THD *thd, #ifdef WITH_PARTITION_STORAGE_ENGINE -static void collect_partition_expr(List<char> &field_list, String *str) +static void collect_partition_expr(THD *thd, List<char> &field_list, + String *str) { List_iterator<char> part_it(field_list); ulong no_fields= field_list.elements; @@ -5250,7 +5235,7 @@ static void collect_partition_expr(List<char> &field_list, String *str) str->length(0); while ((field_str= part_it++)) { - str->append(field_str); + append_identifier(thd, str, field_str, strlen(field_str)); if (--no_fields != 0) str->append(","); } @@ -5317,7 +5302,7 @@ static void store_schema_partitions_record(THD *thd, TABLE *schema_table, { TABLE* table= schema_table; CHARSET_INFO *cs= system_charset_info; - PARTITION_INFO stat_info; + PARTITION_STATS stat_info; MYSQL_TIME time; file->get_dynamic_partition_info(&stat_info, part_id); table->field[0]->store(STRING_WITH_LEN("def"), cs); @@ -5517,7 +5502,7 @@ static int get_schema_partitions_record(THD *thd, TABLE_LIST *tables, } else if (part_info->list_of_part_fields) { - collect_partition_expr(part_info->part_field_list, &tmp_str); + collect_partition_expr(thd, part_info->part_field_list, &tmp_str); table->field[9]->store(tmp_str.ptr(), tmp_str.length(), cs); } table->field[9]->set_notnull(); @@ -5546,7 +5531,7 @@ static int get_schema_partitions_record(THD *thd, TABLE_LIST *tables, } else if (part_info->list_of_subpart_fields) { - collect_partition_expr(part_info->subpart_field_list, &tmp_str); + collect_partition_expr(thd, part_info->subpart_field_list, &tmp_str); table->field[10]->store(tmp_str.ptr(), tmp_str.length(), cs); } table->field[10]->set_notnull(); diff --git a/sql/sql_string.cc b/sql/sql_string.cc index 9fbc06b7529..762eebba031 100644 --- a/sql/sql_string.cc +++ b/sql/sql_string.cc @@ -24,13 +24,6 @@ #include <m_string.h> #include <m_ctype.h> #include <mysql_com.h> -/* - The following extern declarations are ok as these are interface functions - required by the string function -*/ - -extern uchar* sql_alloc(unsigned size); -extern void sql_element_free(void *ptr); #include "sql_string.h" diff --git a/sql/sql_table.cc b/sql/sql_table.cc index a3baeffa8a0..6fbee4f856e 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -427,6 +427,25 @@ uint filename_to_tablename(const char *from, char *to, uint to_length) /** + Check if given string begins with "#mysql50#" prefix + + @param name string to check cut + + @retval + FALSE no prefix found + @retval + TRUE prefix found +*/ + +bool check_mysql50_prefix(const char *name) +{ + return (name[0] == '#' && + !strncmp(name, MYSQL50_TABLE_NAME_PREFIX, + MYSQL50_TABLE_NAME_PREFIX_LENGTH)); +} + + +/** Check if given string begins with "#mysql50#" prefix, cut it if so. @param from string to check and cut @@ -441,9 +460,7 @@ uint filename_to_tablename(const char *from, char *to, uint to_length) uint check_n_cut_mysql50_prefix(const char *from, char *to, uint to_length) { - if (from[0] == '#' && - !strncmp(from, MYSQL50_TABLE_NAME_PREFIX, - MYSQL50_TABLE_NAME_PREFIX_LENGTH)) + if (check_mysql50_prefix(from)) return (uint) (strmake(to, from + MYSQL50_TABLE_NAME_PREFIX_LENGTH, to_length - 1) - to); return 0; @@ -470,7 +487,21 @@ uint tablename_to_filename(const char *from, char *to, uint to_length) DBUG_PRINT("enter", ("from '%s'", from)); if ((length= check_n_cut_mysql50_prefix(from, to, to_length))) + { + /* + Check if the name supplied is a valid mysql 5.0 name and + make the name a zero length string if it's not. + Note that just returning zero length is not enough : + a lot of places don't check the return value and expect + a zero terminated string. + */ + if (check_table_name(to, length, TRUE)) + { + to[0]= 0; + length= 0; + } DBUG_RETURN(length); + } length= strconvert(system_charset_info, from, &my_charset_filename, to, to_length, &errors); if (check_if_legal_tablename(to) && @@ -1752,11 +1783,12 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags) error= 1; goto err; } - share->partition_info= tmp_part_syntax_str; + share->partition_info_str= tmp_part_syntax_str; } else - memcpy((char*) share->partition_info, part_syntax_buf, syntax_len + 1); - share->partition_info_len= part_info->part_info_len= syntax_len; + memcpy((char*) share->partition_info_str, part_syntax_buf, + syntax_len + 1); + share->partition_info_str_len= part_info->part_info_len= syntax_len; part_info->part_info_string= part_syntax_buf; } #endif @@ -1899,8 +1931,8 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, bool dont_log_query) { TABLE_LIST *table; - char path[FN_REFLEN + 1], *alias; - uint path_length; + char path[FN_REFLEN + 1], *alias= NULL; + uint path_length= 0; String wrong_tables; int error= 0; int non_temp_tables_count= 0; @@ -1909,9 +1941,6 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, String built_tmp_query; DBUG_ENTER("mysql_rm_table_part2"); - LINT_INIT(alias); - LINT_INIT(path_length); - if (thd->is_current_stmt_binlog_format_row() && !dont_log_query) { built_query.set_charset(system_charset_info); @@ -6873,7 +6902,14 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, &index_add_buffer, &index_add_count, &candidate_key_count)) goto err; - + + DBUG_EXECUTE_IF("alter_table_only_metadata_change", { + if (need_copy_table_res != ALTER_TABLE_METADATA_ONLY) + goto err; }); + DBUG_EXECUTE_IF("alter_table_only_index_change", { + if (need_copy_table_res != ALTER_TABLE_INDEX_CHANGED) + goto err; }); + if (need_copy_table == ALTER_TABLE_METADATA_ONLY) need_copy_table= need_copy_table_res; } diff --git a/sql/sql_table.h b/sql/sql_table.h index 3114876f5ed..40b24605bd6 100644 --- a/sql/sql_table.h +++ b/sql/sql_table.h @@ -126,6 +126,7 @@ enum enum_explain_filename_mode uint filename_to_tablename(const char *from, char *to, uint to_length); uint tablename_to_filename(const char *from, char *to, uint to_length); uint check_n_cut_mysql50_prefix(const char *from, char *to, uint to_length); +bool check_mysql50_prefix(const char *name); uint build_table_filename(char *buff, size_t bufflen, const char *db, const char *table, const char *ext, uint flags); uint build_table_shadow_filename(char *buff, size_t bufflen, diff --git a/sql/sql_test.cc b/sql/sql_test.cc index 2f3ed0030cd..48fd5f9dff8 100644 --- a/sql/sql_test.cc +++ b/sql/sql_test.cc @@ -75,7 +75,7 @@ print_where(COND *cond,const char *info, enum_query_type query_type) /* This is for debugging purposes */ -void print_cached_tables(void) +static void print_cached_tables(void) { uint idx,count,unused; TABLE_SHARE *share; @@ -340,6 +340,11 @@ print_plan(JOIN* join, uint idx, double record_count, double read_time, #endif +C_MODE_START +static int dl_compare(const void *p1, const void *p2); +static int print_key_cache_status(const char *name, KEY_CACHE *key_cache); +C_MODE_END + typedef struct st_debug_lock { ulong thread_id; @@ -349,8 +354,13 @@ typedef struct st_debug_lock enum thr_lock_type type; } TABLE_LOCK_INFO; -static int dl_compare(TABLE_LOCK_INFO *a,TABLE_LOCK_INFO *b) +static int dl_compare(const void *p1, const void *p2) { + TABLE_LOCK_INFO *a, *b; + + a= (TABLE_LOCK_INFO *) p1; + b= (TABLE_LOCK_INFO *) p2; + if (a->thread_id > b->thread_id) return 1; if (a->thread_id < b->thread_id) @@ -400,9 +410,10 @@ static void push_locks_into_array(DYNAMIC_ARRAY *ar, THR_LOCK_DATA *data, function so that we can easily add this if we ever need this. */ -static void display_table_locks(void) +static void display_table_locks(void) { LIST *list; + void *saved_base; DYNAMIC_ARRAY saved_table_locks; (void) my_init_dynamic_array(&saved_table_locks,sizeof(TABLE_LOCK_INFO), table_cache_count + 20,50); @@ -423,13 +434,17 @@ static void display_table_locks(void) mysql_mutex_unlock(&lock->mutex); } mysql_mutex_unlock(&THR_LOCK_lock); - if (!saved_table_locks.elements) goto end; - - qsort((uchar*) dynamic_element(&saved_table_locks,0,TABLE_LOCK_INFO *),saved_table_locks.elements,sizeof(TABLE_LOCK_INFO),(qsort_cmp) dl_compare); + + if (!saved_table_locks.elements) + goto end; + + saved_base= dynamic_element(&saved_table_locks, 0, TABLE_LOCK_INFO *); + my_qsort(saved_base, saved_table_locks.elements, sizeof(TABLE_LOCK_INFO), + dl_compare); freeze_size(&saved_table_locks); puts("\nThread database.table_name Locked/Waiting Lock_type\n"); - + unsigned int i; for (i=0 ; i < saved_table_locks.elements ; i++) { diff --git a/sql/sql_test.h b/sql/sql_test.h index 539e89ec949..d7fcc126cb2 100644 --- a/sql/sql_test.h +++ b/sql/sql_test.h @@ -26,8 +26,8 @@ typedef struct st_sort_field SORT_FIELD; #ifndef DBUG_OFF void print_where(COND *cond,const char *info, enum_query_type query_type); -void print_cached_tables(void); void TEST_filesort(SORT_FIELD *sortorder,uint s_length); +void TEST_join(JOIN *join); void print_plan(JOIN* join,uint idx, double record_count, double read_time, double current_read_time, const char *info); void dump_TABLE_LIST_graph(SELECT_LEX *select_lex, TABLE_LIST* tl); diff --git a/sql/sql_update.cc b/sql/sql_update.cc index 300ca1098fb..9adfe896c73 100644 --- a/sql/sql_update.cc +++ b/sql/sql_update.cc @@ -436,6 +436,7 @@ int mysql_update(THD *thd, { goto err; } + thd->examined_row_count+= examined_rows; /* Filesort has already found and selected the rows we want to update, so we don't need the where clause @@ -482,6 +483,7 @@ int mysql_update(THD *thd, while (!(error=info.read_record(&info)) && !thd->killed) { + thd->examined_row_count++; if (!(select && select->skip_record())) { if (table->file->was_semi_consistent_read()) @@ -588,6 +590,7 @@ int mysql_update(THD *thd, while (!(error=info.read_record(&info)) && !thd->killed) { + thd->examined_row_count++; if (!(select && select->skip_record())) { if (table->file->was_semi_consistent_read()) @@ -1336,6 +1339,16 @@ int multi_update::prepare(List<Item> ¬_used_values, { table->read_set= &table->def_read_set; bitmap_union(table->read_set, &table->tmp_set); + /* + If a timestamp field settable on UPDATE is present then to avoid wrong + update force the table handler to retrieve write-only fields to be able + to compare records and detect data change. + */ + if (table->file->ha_table_flags() & HA_PARTIAL_COLUMN_READ && + table->timestamp_field && + (table->timestamp_field_type == TIMESTAMP_AUTO_SET_ON_UPDATE || + table->timestamp_field_type == TIMESTAMP_AUTO_SET_ON_BOTH)) + bitmap_union(table->read_set, table->write_set); } } diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index 879f65c0fa4..34e20374042 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -6674,7 +6674,7 @@ alter_list_item: { MYSQL_YYABORT; } - if (check_table_name($3->table.str,$3->table.length) || + if (check_table_name($3->table.str,$3->table.length, FALSE) || ($3->db.str && check_db_name(&$3->db))) { my_error(ER_WRONG_TABLE_NAME, MYF(0), $3->table.str); diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc index b8312fc3255..48a5cf06147 100644 --- a/sql/sys_vars.cc +++ b/sql/sys_vars.cc @@ -1595,6 +1595,13 @@ static Sys_var_mybool Sys_skip_networking( READ_ONLY GLOBAL_VAR(opt_disable_networking), CMD_LINE(OPT_ARG), DEFAULT(FALSE)); +static Sys_var_mybool Sys_skip_name_resolve( + "skip_name_resolve", + "Don't resolve hostnames. All hostnames are IP's or 'localhost'.", + READ_ONLY GLOBAL_VAR(opt_skip_name_resolve), + CMD_LINE(OPT_ARG, OPT_SKIP_RESOLVE), + DEFAULT(FALSE)); + static Sys_var_mybool Sys_skip_show_database( "skip_show_database", "Don't allow 'SHOW DATABASE' commands", READ_ONLY GLOBAL_VAR(opt_skip_show_db), CMD_LINE(OPT_ARG), @@ -2236,17 +2243,69 @@ static Sys_var_bit Sys_log_off( SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_LOG_OFF, DEFAULT(FALSE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_has_super)); -static bool fix_sql_log_bin(sys_var *self, THD *thd, enum_var_type type) +/** + This function sets the session variable thd->variables.sql_log_bin + to reflect changes to @@session.sql_log_bin. + + @param[IN] self A pointer to the sys_var, i.e. Sys_log_binlog. + @param[IN] type The type either session or global. + + @return @c FALSE. +*/ +static bool fix_sql_log_bin_after_update(sys_var *self, THD *thd, + enum_var_type type) { - if (type != OPT_GLOBAL && !thd->in_sub_stmt) - thd->sql_log_bin_toplevel= thd->variables.option_bits & OPTION_BIN_LOG; - return false; + if (type == OPT_SESSION) + { + if (thd->variables.sql_log_bin) + thd->variables.option_bits |= OPTION_BIN_LOG; + else + thd->variables.option_bits &= ~OPTION_BIN_LOG; + } + return FALSE; } -static Sys_var_bit Sys_log_binlog( + +/** + This function checks if the sql_log_bin can be changed, + what is possible if: + - the user is a super user; + - the set is not called from within a function/trigger; + - there is no on-going transaction. + + @param[IN] self A pointer to the sys_var, i.e. Sys_log_binlog. + @param[IN] var A pointer to the set_var created by the parser. + + @return @c FALSE if the change is allowed, otherwise @c TRUE. +*/ +static bool check_sql_log_bin(sys_var *self, THD *thd, set_var *var) +{ + if (check_has_super(self, thd, var)) + return TRUE; + + if (var->type == OPT_GLOBAL) + return FALSE; + + /* If in a stored function/trigger, it's too late to change sql_log_bin. */ + if (thd->in_sub_stmt) + { + my_error(ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN, MYF(0)); + return TRUE; + } + /* Make the session variable 'sql_log_bin' read-only inside a transaction. */ + if (thd->in_active_multi_stmt_transaction()) + { + my_error(ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN, MYF(0)); + return TRUE; + } + + return FALSE; +} + +static Sys_var_mybool Sys_log_binlog( "sql_log_bin", "sql_log_bin", - SESSION_VAR(option_bits), NO_CMD_LINE, OPTION_BIN_LOG, - DEFAULT(TRUE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_has_super), - ON_UPDATE(fix_sql_log_bin)); + SESSION_VAR(sql_log_bin), NO_CMD_LINE, + DEFAULT(TRUE), NO_MUTEX_GUARD, NOT_IN_BINLOG, ON_CHECK(check_sql_log_bin), + ON_UPDATE(fix_sql_log_bin_after_update)); static Sys_var_bit Sys_sql_warnings( "sql_warnings", "sql_warnings", @@ -2723,8 +2782,8 @@ static Sys_var_mybool Sys_log_slow( static bool fix_log_state(sys_var *self, THD *thd, enum_var_type type) { bool res; - my_bool *newvalptr, newval, oldval; - uint log_type; + my_bool *UNINIT_VAR(newvalptr), newval, UNINIT_VAR(oldval); + uint UNINIT_VAR(log_type); if (self == &Sys_general_log || self == &Sys_log) { diff --git a/sql/table.cc b/sql/table.cc index e19cd8cf6f4..84153f6d9c5 100644 --- a/sql/table.cc +++ b/sql/table.cc @@ -311,13 +311,6 @@ TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key, share->version= refresh_version; /* - This constant is used to mark that no table map version has been - assigned. No arithmetic is done on the value: it will be - overwritten with a value taken from MYSQL_BIN_LOG. - */ - share->table_map_version= ~(ulonglong)0; - - /* Since alloc_table_share() can be called without any locking (for example, ha_create_table... functions), we do not assign a table map id here. Instead we assign a value that is not used @@ -383,11 +376,6 @@ void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key, share->path.length= share->normalized_path.length= strlen(path); share->frm_version= FRM_VER_TRUE_VARCHAR; - /* - Temporary tables are not replicated, but we set up these fields - anyway to be able to catch errors. - */ - share->table_map_version= ~(ulonglong)0; share->cached_row_logging_check= -1; /* @@ -500,6 +488,26 @@ inline bool is_system_table_name(const char *name, uint length) } +/** + Check if a string contains path elements +*/ + +static inline bool has_disabled_path_chars(const char *str) +{ + for (; *str; str++) + switch (*str) + { + case FN_EXTCHAR: + case '/': + case '\\': + case '~': + case '@': + return TRUE; + } + return FALSE; +} + + /* Read table definition from a binary / text based .frm file @@ -556,7 +564,8 @@ int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags) This kind of tables must have been opened only by the mysql_file_open() above. */ - if (strchr(share->table_name.str, '@') || + if (has_disabled_path_chars(share->table_name.str) || + has_disabled_path_chars(share->db.str) || !strncmp(share->db.str, MYSQL50_TABLE_NAME_PREFIX, MYSQL50_TABLE_NAME_PREFIX_LENGTH) || !strncmp(share->table_name.str, MYSQL50_TABLE_NAME_PREFIX, @@ -967,28 +976,28 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head, } if (next_chunk + 5 < buff_end) { - uint32 partition_info_len = uint4korr(next_chunk); + uint32 partition_info_str_len = uint4korr(next_chunk); #ifdef WITH_PARTITION_STORAGE_ENGINE if ((share->partition_info_buffer_size= - share->partition_info_len= partition_info_len)) + share->partition_info_str_len= partition_info_str_len)) { - if (!(share->partition_info= (char*) + if (!(share->partition_info_str= (char*) memdup_root(&share->mem_root, next_chunk + 4, - partition_info_len + 1))) + partition_info_str_len + 1))) { my_free(buff, MYF(0)); goto err; } } #else - if (partition_info_len) + if (partition_info_str_len) { DBUG_PRINT("info", ("WITH_PARTITION_STORAGE_ENGINE is not defined")); my_free(buff, MYF(0)); goto err; } #endif - next_chunk+= 5 + partition_info_len; + next_chunk+= 5 + partition_info_str_len; } #if MYSQL_VERSION_ID < 50200 if (share->mysql_version >= 50106 && share->mysql_version <= 50109) @@ -1651,6 +1660,10 @@ static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head, my_hash_free(&share->name_hash); if (share->ha_data_destroy) share->ha_data_destroy(share->ha_data); +#ifdef WITH_PARTITION_STORAGE_ENGINE + if (share->ha_part_data_destroy) + share->ha_part_data_destroy(share->ha_part_data); +#endif open_table_error(share, error, share->open_errno, errarg); DBUG_RETURN(error); @@ -1842,7 +1855,7 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias, } #ifdef WITH_PARTITION_STORAGE_ENGINE - if (share->partition_info_len && outparam->file) + if (share->partition_info_str_len && outparam->file) { /* In this execution we must avoid calling thd->change_item_tree since @@ -1863,10 +1876,8 @@ int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias, bool tmp; bool work_part_info_used; - tmp= mysql_unpack_partition(thd, share->partition_info, - share->partition_info_len, - share->part_state, - share->part_state_len, + tmp= mysql_unpack_partition(thd, share->partition_info_str, + share->partition_info_str_len, outparam, is_create_table, share->default_part_db_type, &work_part_info_used); @@ -2738,35 +2749,21 @@ bool check_db_name(LEX_STRING *org_name) { char *name= org_name->str; uint name_length= org_name->length; + bool check_for_path_chars; if (!name_length || name_length > NAME_LEN) return 1; + if ((check_for_path_chars= check_mysql50_prefix(name))) + { + name+= MYSQL50_TABLE_NAME_PREFIX_LENGTH; + name_length-= MYSQL50_TABLE_NAME_PREFIX_LENGTH; + } + if (lower_case_table_names && name != any_db) my_casedn_str(files_charset_info, name); -#if defined(USE_MB) && defined(USE_MB_IDENT) - if (use_mb(system_charset_info)) - { - name_length= 0; - bool last_char_is_space= TRUE; - char *end= name + org_name->length; - while (name < end) - { - int len; - last_char_is_space= my_isspace(system_charset_info, *name); - len= my_ismbchar(system_charset_info, name, end); - if (!len) - len= 1; - name+= len; - name_length++; - } - return (last_char_is_space || name_length > NAME_CHAR_LEN); - } - else -#endif - return ((org_name->str[org_name->length - 1] != ' ') || - (name_length > NAME_CHAR_LEN)); /* purecov: inspected */ + return check_table_name(name, name_length, check_for_path_chars); } @@ -2776,8 +2773,7 @@ bool check_db_name(LEX_STRING *org_name) returns 1 on error */ - -bool check_table_name(const char *name, size_t length) +bool check_table_name(const char *name, size_t length, bool check_for_path_chars) { // name length in symbols size_t name_length= 0; @@ -2806,6 +2802,9 @@ bool check_table_name(const char *name, size_t length) } } #endif + if (check_for_path_chars && + (*name == '/' || *name == '\\' || *name == '~' || *name == FN_EXTCHAR)) + return 1; name++; name_length++; } diff --git a/sql/table.h b/sql/table.h index 6430e505a13..52fc0f1a7d9 100644 --- a/sql/table.h +++ b/sql/table.h @@ -481,6 +481,19 @@ typedef struct st_table_field_def } TABLE_FIELD_DEF; +#ifdef WITH_PARTITION_STORAGE_ENGINE +/** + Partition specific ha_data struct. +*/ +typedef struct st_ha_data_partition +{ + bool auto_inc_initialized; + mysql_mutex_t LOCK_auto_inc; /**< protecting auto_inc val */ + ulonglong next_auto_inc_val; /**< first non reserved value */ +} HA_DATA_PARTITION; +#endif + + class Table_check_intact { protected: @@ -610,7 +623,6 @@ struct TABLE_SHARE bool crashed; bool is_view; ulong table_map_id; /* for row-based replication */ - ulonglong table_map_version; /* Cache for row-based replication table share checks that does not @@ -621,13 +633,11 @@ struct TABLE_SHARE int cached_row_logging_check; #ifdef WITH_PARTITION_STORAGE_ENGINE - /** @todo: Move into *ha_data for partitioning */ + /* filled in when reading from frm */ bool auto_partitioned; - const char *partition_info; - uint partition_info_len; + const char *partition_info_str; + uint partition_info_str_len; uint partition_info_buffer_size; - const char *part_state; - uint part_state_len; handlerton *default_part_db_type; #endif @@ -647,6 +657,14 @@ struct TABLE_SHARE void *ha_data; void (*ha_data_destroy)(void *); /* An optional destructor for ha_data */ +#ifdef WITH_PARTITION_STORAGE_ENGINE + /** place to store partition specific data, LOCK_ha_data hold while init. */ + HA_DATA_PARTITION *ha_part_data; + /* Destructor for ha_part_data */ + void (*ha_part_data_destroy)(HA_DATA_PARTITION *); +#endif + + /** Instrumentation for this table share. */ PSI_table_share *m_psi; @@ -1888,7 +1906,11 @@ typedef struct st_nested_join List<TABLE_LIST> join_list; /* list of elements in the nested join */ table_map used_tables; /* bitmap of tables in the nested join */ table_map not_null_tables; /* tables that rejects nulls */ - struct st_join_table *first_nested;/* the first nested table in the plan */ + /** + Used for pointing out the first table in the plan being covered by this + join nest. It is used exclusively within make_outerjoin_info(). + */ + struct st_join_table *first_nested; /* Used to count tables in the nested join in 2 isolated places: 1. In make_outerjoin_info(). @@ -1898,6 +1920,15 @@ typedef struct st_nested_join */ uint counter; nested_join_map nj_map; /* Bit used to identify this nested join*/ + /** + True if this join nest node is completely covered by the query execution + plan. This means two things. + + 1. All tables on its @c join_list are covered by the plan. + + 2. All child join nest nodes are fully covered. + */ + bool is_fully_covered() const { return join_list.elements == counter; } } NESTED_JOIN; @@ -2001,7 +2032,7 @@ void update_create_info_from_table(HA_CREATE_INFO *info, TABLE *form); bool check_and_convert_db_name(LEX_STRING *db, bool preserve_lettercase); bool check_db_name(LEX_STRING *db); bool check_column_name(const char *name); -bool check_table_name(const char *name, size_t length); +bool check_table_name(const char *name, size_t length, bool check_for_path_chars); int rename_file_ext(const char * from,const char * to,const char * ext); char *get_field(MEM_ROOT *mem, Field *field); bool get_field(MEM_ROOT *mem, Field *field, class String *res); diff --git a/sql/thr_malloc.cc b/sql/thr_malloc.cc index 638f3bbb9f1..7696f28081d 100644 --- a/sql/thr_malloc.cc +++ b/sql/thr_malloc.cc @@ -109,10 +109,6 @@ void* sql_memdup(const void *ptr, size_t len) return pos; } -void sql_element_free(void *ptr __attribute__((unused))) -{} /* purecov: deadcode */ - - char *sql_strmake_with_convert(const char *str, size_t arg_length, CHARSET_INFO *from_cs, diff --git a/sql/thr_malloc.h b/sql/thr_malloc.h index a655884b8b4..6b372a285a2 100644 --- a/sql/thr_malloc.h +++ b/sql/thr_malloc.h @@ -27,7 +27,6 @@ void *sql_calloc(size_t); char *sql_strdup(const char *str); char *sql_strmake(const char *str, size_t len); void *sql_memdup(const void * ptr, size_t size); -void sql_element_free(void *ptr); char *sql_strmake_with_convert(const char *str, size_t arg_length, CHARSET_INFO *from_cs, size_t max_res_length, |