+ 0, 0, 0, is_schema_db(dbname.str, dbname.length)))

+ bool save_binlog_row_based;

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ thd->clear_current_stmt_binlog_row_based();

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ DBUG_LEAVE; // Against gcc warnings

+ return 0;

+ bool save_binlog_row_based;

+ is_schema_db(parse_data->dbname.str,

+ parse_data->dbname.length)))

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ thd->clear_current_stmt_binlog_row_based();

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ ret= write_bin_log(thd, TRUE, log_query.c_ptr(), log_query.length());

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ bool save_binlog_row_based;

+ is_schema_db(parse_data->dbname.str,

+ parse_data->dbname.length)))

+ is_schema_db(new_dbname->str, new_dbname->length)))

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ thd->clear_current_stmt_binlog_row_based();

+ ret= write_bin_log(thd, TRUE, thd->query(), thd->query_length());

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ bool save_binlog_row_based;

+ is_schema_db(dbname.str, dbname.length)))

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ thd->clear_current_stmt_binlog_row_based();

+ ret= write_bin_log(thd, TRUE, thd->query(), thd->query_length());

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ is_schema_db(dbname.str, dbname.length)))

+ if (!is_schema_db(thd->lex->select_lex.db) && // There is no events in I_S

+ new_field->pack_length == pack_length());

+ int reset(void) {

+ bzero(ptr, bytes_in_rec);

+ if (bit_ptr && (bit_len > 0)) // reset odd bits among null bits

+ clr_rec_bits(bit_ptr, bit_ofs, bit_len);

+ return 0;

+ }

+ /* filesort cannot handle zero-length records. */

+ DBUG_ASSERT(param.sort_length);

+ goto error_create;

+ {

+ /*

+ Added for safety, InnoDB reports HA_ERR_FOUND_DUPP_KEY

+ if the table/partition already exists.

+ If we return that error code, then print_error would try to

+ get_dup_key on a non-existing partition.

+ So return a more reasonable error code.

+ */

+ if (error == HA_ERR_FOUND_DUPP_KEY)

+ error= HA_ERR_TABLE_EXIST;

+ goto error_create;

+ }

+ DBUG_PRINT("info", ("partition %s created", part_name));

+ goto error_open;

+ DBUG_PRINT("info", ("partition %s opened", part_name));

+ goto error_external_lock;

+ DBUG_PRINT("info", ("partition %s external locked", part_name));

+error_external_lock:

+ VOID(file->close());

+error_open:

+ VOID(file->ha_delete_table(part_name));

+error_create:

+ if (m_added_file)

+ THD *thd= ha_thd();

+ handler **file= m_added_file;

+ while ((part_count > 0) && (*file))

+ {

+ (*file)->ha_external_lock(thd, F_UNLCK);

+ (*file)->close();

+ /* Leave the (*file)->ha_delete_table(part_name) to the ddl-log */

+ file++;

+ part_count--;

+ }

+ m_added_file= NULL;

+ if ((error= copy_partitions(copied, deleted)))

+ {

+ /*

+ Close and unlock the new temporary partitions.

+ They will later be deleted through the ddl-log.

+ */

+ cleanup_new_partition(part_count);

+ }

+ DBUG_RETURN(error);

+ m_reorged_file[reorg_part]->ha_rnd_end();

+#define MAX_PARTS_FOR_OPTIMIZER_CALLS 10

+/*

+ Prepare start variables for estimating optimizer costs.

+

+ @param[out] num_used_parts Number of partitions after pruning.

+ @param[out] check_min_num Number of partitions to call.

+ @param[out] first first used partition.

+*/

+void ha_partition::partitions_optimizer_call_preparations(uint *first,

+ uint *num_used_parts,

+ uint *check_min_num)

+{

+ *first= bitmap_get_first_set(&(m_part_info->used_partitions));

+ *num_used_parts= bitmap_bits_set(&(m_part_info->used_partitions));

+ *check_min_num= min(MAX_PARTS_FOR_OPTIMIZER_CALLS, *num_used_parts);

+}

+

+ double scan_time= 0.0;

+ uint first, part_id, num_used_parts, check_min_num, partitions_called= 0;

+ partitions_optimizer_call_preparations(&first, &num_used_parts, &check_min_num);

+ for (part_id= first; partitions_called < num_used_parts ; part_id++)

+ {

+ if (!bitmap_is_set(&(m_part_info->used_partitions), part_id))

+ continue;

+ scan_time+= m_file[part_id]->scan_time();

+ partitions_called++;

+ if (partitions_called >= check_min_num && scan_time != 0.0)

+ {

+ DBUG_RETURN(scan_time *

+ (double) num_used_parts / (double) partitions_called);

+ }

+ }

+ Estimate rows for records_in_range or estimate_rows_upper_bound.

+ @param is_records_in_range call records_in_range instead of

+ estimate_rows_upper_bound.

+ @param inx (only for records_in_range) index to use.

+ @param min_key (only for records_in_range) start of range.

+ @param max_key (only for records_in_range) end of range.

+ @return Number of rows or HA_POS_ERROR.

+ha_rows ha_partition::estimate_rows(bool is_records_in_range, uint inx,

+ key_range *min_key, key_range *max_key)

+ ha_rows rows, estimated_rows= 0;

+ uint first, part_id, num_used_parts, check_min_num, partitions_called= 0;

+ DBUG_ENTER("ha_partition::records_in_range");

+ partitions_optimizer_call_preparations(&first, &num_used_parts, &check_min_num);

+ for (part_id= first; partitions_called < num_used_parts ; part_id++)

+ {

+ if (!bitmap_is_set(&(m_part_info->used_partitions), part_id))

+ continue;

+ if (is_records_in_range)

+ rows= m_file[part_id]->records_in_range(inx, min_key, max_key);

+ else

+ rows= m_file[part_id]->estimate_rows_upper_bound();

+ if (rows == HA_POS_ERROR)

+ DBUG_RETURN(HA_POS_ERROR);

+ estimated_rows+= rows;

+ partitions_called++;

+ if (partitions_called >= check_min_num && estimated_rows)

+ {

+ DBUG_RETURN(estimated_rows * num_used_parts / partitions_called);

+ }

+ }

+ DBUG_RETURN(estimated_rows);

+

+ DBUG_RETURN(estimate_rows(TRUE, inx, min_key, max_key));

+ DBUG_RETURN(estimate_rows(FALSE, 0, NULL, NULL));

+}

+

+

+/*

+ Get time to read

+

+ SYNOPSIS

+ read_time()

+ index Index number used

+ ranges Number of ranges

+ rows Number of rows

+

+ RETURN VALUE

+ time for read

+

+ DESCRIPTION

+ This will be optimised later to include whether or not the index can

+ be used with partitioning. To achieve we need to add another parameter

+ that specifies how many of the index fields that are bound in the ranges.

+ Possibly added as a new call to handlers.

+*/

+

+double ha_partition::read_time(uint index, uint ranges, ha_rows rows)

+{

+ DBUG_ENTER("ha_partition::read_time");

+

+ DBUG_RETURN(m_file[0]->read_time(index, ranges, rows));

+private:

+ /*

+ Helper function to get the minimum number of partitions to use for

+ the optimizer hints/cost calls.

+ */

+ void partitions_optimizer_call_preparations(uint *num_used_parts,

+ uint *check_min_num,

+ uint *first);

+ ha_rows estimate_rows(bool is_records_in_range, uint inx,

+ key_range *min_key, key_range *max_key);

+public:

+

+ return error ? error : (field->table->in_use->is_error() ? 2 : 0);

+ /**

+ Intrusive list pointer for free list. If not null, points to the next

+ Item on some Query_arena's free list. For instance, stored procedures

+ have their own Query_arena's.

+

+ @see Query_arena::free_list

+ */

+ /*

+ Check if an expression value depends on the current timezone. Used by

+ partitioning code to reject timezone-dependent expressions in a

+ (sub)partitioning function.

+ */

+ virtual bool is_timezone_dependent_processor(uchar *bool_arg)

+ {

+ return FALSE;

+ }

+

+ /**

+ Find a function of a given type

+

+ @param arg the function type to search (enum Item_func::Functype)

+ @return

+ @retval TRUE the function type we're searching for is found

+ @retval FALSE the function type wasn't found

+

+ @description

+ This function can be used (together with Item::walk()) to find functions

+ in an item tree fragment.

+ */

+ virtual bool find_function_processor (uchar *arg)

+ {

+ return FALSE;

+ }

+ current_thd->change_item_tree(li.ref(), new_item);

+ : Item_bool_func(), const_item(0), eval_item(0), cond_false(0),

+ compare_as_dates(FALSE)

+ compare_as_dates= f->is_datetime();

+ compare_as_dates= item_equal->compare_as_dates;

+

+void Item_equal::compare_const(Item *c)

+{

+ if (compare_as_dates)

+ {

+ cmp.set_datetime_cmp_func(this, &c, &const_item);

+ cond_false= cmp.compare();

+ }

+ else

+ {

+ Item_func_eq *func= new Item_func_eq(c, const_item);

+ func->set_cmp_func();

+ func->quick_fix_field();

+ cond_false= !func->val_int();

+ }

+ if (cond_false)

+ const_item_cache= 1;

+}

+

+

+void Item_equal::add(Item *c, Item_field *f)

+{

+ if (cond_false)

+ return;

+ if (!const_item)

+ {

+ DBUG_ASSERT(f);

+ const_item= c;

+ compare_as_dates= f->is_datetime();

+ return;

+ }

+ compare_const(c);

+}

+

+

+ compare_const(c);

+ Arg_comparator cmp;

+ bool compare_as_dates;

+ void compare_const(Item *c);

+ void add(Item *c, Item_field *f);

+ /*

+ When RAND() is binlogged, the seed is binlogged too. So the

+ sequence of random numbers is the same on a replication slave as

+ on the master. However, if several RAND() values are inserted

+ into a table, the order in which the rows are modified may differ

+ between master and slave, because the order is undefined. Hence,

+ the statement is unsafe to log in statement format.

+ */

+ thd->lex->set_stmt_unsafe();

+

+ if (!with_sum_func && !const_item())

+ bool has_timestamp_args()

+ {

+ DBUG_ASSERT(fixed == TRUE);

+ for (uint i= 0; i < arg_count; i++)

+ {

+ if (args[i]->type() == Item::FIELD_ITEM &&

+ args[i]->field_type() == MYSQL_TYPE_TIMESTAMP)

+ return TRUE;

+ }

+ return FALSE;

+ }

+ /*

+ We assume the result of any function that has a TIMESTAMP argument to be

+ timezone-dependent, since a TIMESTAMP value in both numeric and string

+ contexts is interpreted according to the current timezone.

+ The only exception is UNIX_TIMESTAMP() which returns the internal

+ representation of a TIMESTAMP argument verbatim, and thus does not depend on

+ the timezone.

+ */

+ virtual bool is_timezone_dependent_processor(uchar *bool_arg)

+ {

+ return has_timestamp_args();

+ }

+

+ virtual bool find_function_processor (uchar *arg)

+ {

+ return functype() == *(Functype *) arg;

+ }

+/*

+ Convert an array of bytes to a hexadecimal representation.

+

+ Used to generate a hexadecimal representation of a message digest.

+*/

+static void array_to_hex(char *to, const char *str, uint len)

+{

+ const char *str_end= str + len;

+ for (; str != str_end; ++str)

+ {

+ *to++= _dig_vec_lower[((uchar) *str) >> 4];

+ *to++= _dig_vec_lower[((uchar) *str) & 0x0F];

+ }

+}

+ array_to_hex((char *) str->ptr(), (const char*) digest, 16);

+ array_to_hex((char *) str->ptr(), (const char*) digest, SHA1_HASH_SIZE);

+ if (str->ptr() == res2->ptr())

+ { // This is quite uncommon!

+bool Item_func_encode::seed()

+{

+ char buf[80];

+ ulong rand_nr[2];

+ String *key, tmp(buf, sizeof(buf), system_charset_info);

+

+ if (!(key= args[1]->val_str(&tmp)))

+ return TRUE;

+

+ hash_password(rand_nr, key->ptr(), key->length());

+ sql_crypt.init(rand_nr);

+

+ return FALSE;

+}

+

+ /* Precompute the seed state if the item is constant. */

+ seeded= args[1]->const_item() &&

+ (args[1]->result_type() == STRING_RESULT) && !seed();

+ null_value= 1;

+ return NULL;

+ if (!seeded && seed())

+ null_value= 1;

+ return NULL;

+ null_value= 0;

+ res= copy_if_not_alloced(str, res, res->length());

+ crypto_transform(res);

+ sql_crypt.reinit();

+

+void Item_func_encode::crypto_transform(String *res)

+ sql_crypt.encode((char*) res->ptr(),res->length());

+ res->set_charset(&my_charset_bin);

+}

+void Item_func_decode::crypto_transform(String *res)

+{

+private:

+ /** Whether the PRNG has already been seeded. */

+ bool seeded;

+protected:

+ SQL_CRYPT sql_crypt;

+protected:

+ virtual void crypto_transform(String *);

+private:

+ /** Provide a seed for the PRNG sequence. */

+ bool seed();

+protected:

+ void crypto_transform(String *);

+ char_length= (cast_length >= 0) ? cast_length :

+ args[0]->max_length /

+ (cast_cs == &my_charset_bin ? 1 : args[0]->collation.collation->mbmaxlen);

+ bool check_partition_func_processor(uchar *int_arg) {return FALSE;}

+ /*

+ UNIX_TIMESTAMP() depends on the current timezone

+ (and thus may not be used as a partitioning function)

+ when its argument is NOT of the TIMESTAMP type.

+ */

+ bool is_timezone_dependent_processor(uchar *int_arg)

+ {

+ return !has_timestamp_args();

+ }

+ error= mysql_bin_log.write_incident(thd, TRUE);

+bool MYSQL_LOG::init_and_set_log_file_name(const char *log_name,

+ const char *new_name,

+ enum_log_type log_type_arg,

+ enum cache_type io_cache_type_arg)

+{

+ init(log_type_arg, io_cache_type_arg);

+

+ if (new_name && !strmov(log_file_name, new_name))

+ return TRUE;

+ else if (!new_name && generate_new_name(log_file_name, log_name))

+ return TRUE;

+

+ return FALSE;

+}

+

+

+ if (init_and_set_log_file_name(name, new_name,

+ log_type_arg, io_cache_type_arg))

+ strmake(buff, log_name, min(length, FN_REFLEN-1));

+ bzero((char*) &purge_index_file, sizeof(purge_index_file));

+ const char *log_name, bool need_mutex)

+ 0, MYF(MY_WME | MY_WAIT_IF_FULL)) ||

+ DBUG_EVALUATE_IF("fault_injection_openning_index", 1, 0))

+

+#ifdef HAVE_REPLICATION

+ /*

+ Sync the index by purging any binary log file that is not registered.

+ In other words, either purge binary log files that were removed from

+ the index but not purged from the file system due to a crash or purge

+ any binary log file that was created but not register in the index

+ due to a crash.

+ */

+

+ if (set_purge_index_file_name(index_file_name_arg) ||

+ open_purge_index_file(FALSE) ||

+ purge_index_entry(NULL, NULL, need_mutex) ||

+ close_purge_index_file() ||

+ DBUG_EVALUATE_IF("fault_injection_recovering_index", 1, 0))

+ {

+ sql_print_error("MYSQL_BIN_LOG::open_index_file failed to sync the index "

+ "file.");

+ return TRUE;

+ }

+#endif

+

+ bool null_created_arg,

+ bool need_mutex)

+

+ if (init_and_set_log_file_name(log_name, new_name, log_type_arg,

+ io_cache_type_arg))

+ {

+ sql_print_error("MSYQL_BIN_LOG::open failed to generate new file name.");

+ DBUG_RETURN(1);

+ }

+

+#ifdef HAVE_REPLICATION

+ if (open_purge_index_file(TRUE) ||

+ register_create_index_entry(log_file_name) ||

+ sync_purge_index_file() ||

+ DBUG_EVALUATE_IF("fault_injection_registering_index", 1, 0))

+ {

+ sql_print_error("MSYQL_BIN_LOG::open failed to sync the index file.");

+ DBUG_RETURN(1);

+ }

+ DBUG_EXECUTE_IF("crash_create_non_critical_before_update_index", abort(););

+#endif

+

+ write_error= 0;

+ if (MYSQL_LOG::open(log_name, log_type_arg, new_name,

+ io_cache_type_arg))

+ {

+#ifdef HAVE_REPLICATION

+ close_purge_index_file();

+#endif

+ }

+#ifdef HAVE_REPLICATION

+ DBUG_EXECUTE_IF("crash_create_critical_before_update_index", abort(););

+#endif

+

+ DBUG_ASSERT(my_b_inited(&index_file) != 0);

+ reinit_io_cache(&index_file, WRITE_CACHE,

+ my_b_filelength(&index_file), 0, 0);

+ if (DBUG_EVALUATE_IF("fault_injection_updating_index", 1, 0) ||

+ my_b_write(&index_file, (uchar*) log_file_name,

+ strlen(log_file_name)) ||

+ my_b_write(&index_file, (uchar*) "\n", 1) ||

+ flush_io_cache(&index_file) ||

+ goto err;

+

+#ifdef HAVE_REPLICATION

+ DBUG_EXECUTE_IF("crash_create_after_update_index", abort(););

+#endif

+#ifdef HAVE_REPLICATION

+ close_purge_index_file();

+#endif

+

+#ifdef HAVE_REPLICATION

+ if (is_inited_purge_index_file())

+ purge_index_entry(NULL, NULL, need_mutex);

+ close_purge_index_file();

+#endif

+ /*

+ First delete all old log files and then update the index file.

+ As we first delete the log files and do not use sort of logging,

+ a crash may lead to an inconsistent state where the index has

+ references to non-existent files.

+ We need to invert the steps and use the purge_index_file methods

+ in order to make the operation safe.

+ */

+ push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,

+ push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,

+ if (!open_index_file(index_file_name, 0, FALSE))

+ open(save_name, log_type, 0, io_cache_type, no_auto_events, max_size, 0, FALSE);

+ int error= 0;

+ sql_print_error("MYSQL_BIN_LOG::purge_logs was called with file %s not "

+ if ((error= open_purge_index_file(TRUE)))

+ sql_print_error("MYSQL_BIN_LOG::purge_logs failed to sync the index file.");

+ goto err;

+ !is_active(log_info.log_file_name) &&

+ if ((error= register_purge_index_entry(log_info.log_file_name)))

+ sql_print_error("MYSQL_BIN_LOG::purge_logs failed to copy %s to register file.",

+ }

+

+ DBUG_EXECUTE_IF("crash_purge_before_update_index", abort(););

+

+ if ((error= sync_purge_index_file()))

+ {

+ sql_print_error("MSYQL_BIN_LOG::purge_logs failed to flush register file.");

+ goto err;

+ }

+ sql_print_error("MSYQL_BIN_LOG::purge_logs failed to update the index file");

+ DBUG_EXECUTE_IF("crash_purge_critical_after_update_index", abort(););

+err:

+ /* Read each entry from purge_index_file and delete the file. */

+ if (is_inited_purge_index_file() &&

+ (error= purge_index_entry(thd, decrease_log_space, FALSE)))

+ sql_print_error("MSYQL_BIN_LOG::purge_logs failed to process registered files"

+ " that would be purged.");

+ close_purge_index_file();

+

+ DBUG_EXECUTE_IF("crash_purge_non_critical_after_update_index", abort(););

+

+ if (need_mutex)

+ pthread_mutex_unlock(&LOCK_index);

+ DBUG_RETURN(error);

+}

+

+int MYSQL_BIN_LOG::set_purge_index_file_name(const char *base_file_name)

+{

+ int error= 0;

+ DBUG_ENTER("MYSQL_BIN_LOG::set_purge_index_file_name");

+ if (fn_format(purge_index_file_name, base_file_name, mysql_data_home,

+ ".~rec~", MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH |

+ MY_REPLACE_EXT)) == NULL)

+ {

+ error= 1;

+ sql_print_error("MYSQL_BIN_LOG::set_purge_index_file_name failed to set "

+ "file name.");

+ }

+ DBUG_RETURN(error);

+}

+

+int MYSQL_BIN_LOG::open_purge_index_file(bool destroy)

+{

+ int error= 0;

+ File file= -1;

+

+ DBUG_ENTER("MYSQL_BIN_LOG::open_purge_index_file");

+

+ if (destroy)

+ close_purge_index_file();

+

+ if (!my_b_inited(&purge_index_file))

+ if ((file= my_open(purge_index_file_name, O_RDWR | O_CREAT | O_BINARY,

+ MYF(MY_WME | ME_WAITTANG))) < 0 ||

+ init_io_cache(&purge_index_file, file, IO_SIZE,

+ (destroy ? WRITE_CACHE : READ_CACHE),

+ 0, 0, MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)))

+ {

+ error= 1;

+ sql_print_error("MYSQL_BIN_LOG::open_purge_index_file failed to open register "

+ " file.");

+ }

+ }

+ DBUG_RETURN(error);

+}

+

+int MYSQL_BIN_LOG::close_purge_index_file()

+{

+ int error= 0;

+

+ DBUG_ENTER("MYSQL_BIN_LOG::close_purge_index_file");

+

+ if (my_b_inited(&purge_index_file))

+ {

+ end_io_cache(&purge_index_file);

+ error= my_close(purge_index_file.file, MYF(0));

+ }

+ my_delete(purge_index_file_name, MYF(0));

+ bzero((char*) &purge_index_file, sizeof(purge_index_file));

+

+ DBUG_RETURN(error);

+}

+

+bool MYSQL_BIN_LOG::is_inited_purge_index_file()

+{

+ DBUG_ENTER("MYSQL_BIN_LOG::is_inited_purge_index_file");

+ DBUG_RETURN (my_b_inited(&purge_index_file));

+}

+

+int MYSQL_BIN_LOG::sync_purge_index_file()

+{

+ int error= 0;

+ DBUG_ENTER("MYSQL_BIN_LOG::sync_purge_index_file");

+

+ if ((error= flush_io_cache(&purge_index_file)) ||

+ (error= my_sync(purge_index_file.file, MYF(MY_WME))))

+ DBUG_RETURN(error);

+

+ DBUG_RETURN(error);

+}

+

+int MYSQL_BIN_LOG::register_purge_index_entry(const char *entry)

+{

+ int error= 0;

+ DBUG_ENTER("MYSQL_BIN_LOG::register_purge_index_entry");

+

+ if ((error=my_b_write(&purge_index_file, (const uchar*)entry, strlen(entry))) ||

+ (error=my_b_write(&purge_index_file, (const uchar*)"\n", 1)))

+ DBUG_RETURN (error);

+

+ DBUG_RETURN(error);

+}

+

+int MYSQL_BIN_LOG::register_create_index_entry(const char *entry)

+{

+ DBUG_ENTER("MYSQL_BIN_LOG::register_create_index_entry");

+ DBUG_RETURN(register_purge_index_entry(entry));

+}

+

+int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *decrease_log_space,

+ bool need_mutex)

+{

+ MY_STAT s;

+ int error= 0;

+ LOG_INFO log_info;

+ LOG_INFO check_log_info;

+

+ DBUG_ENTER("MYSQL_BIN_LOG:purge_index_entry");

+

+ DBUG_ASSERT(my_b_inited(&purge_index_file));

+

+ if ((error=reinit_io_cache(&purge_index_file, READ_CACHE, 0, 0, 0)))

+ {

+ sql_print_error("MSYQL_BIN_LOG::purge_index_entry failed to reinit register file "

+ if ((length=my_b_gets(&purge_index_file, log_info.log_file_name,

+ if (purge_index_file.error)

+ error= purge_index_file.error;

+ sql_print_error("MSYQL_BIN_LOG::purge_index_entry error %d reading from "

+ "register file.", error);

+ push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,

+ if ((error= find_log_pos(&check_log_info, log_info.log_file_name, need_mutex)))

+ if (error != LOG_INFO_EOF)

+ ER_BINLOG_PURGE_FATAL_ERR,

+ "a problem with deleting %s and "

+ "reading the binlog index file",

+ else

+ {

+ sql_print_information("Failed to delete file '%s' and "

+ "read the binlog index file",

+ log_info.log_file_name);

+ }

+ goto err;

+ }

+

+ error= 0;

+ if (!need_mutex)

+ {

+ /*

+ This is to avoid triggering an error in NDB.

+ */

+ ha_binlog_index_purge_file(current_thd, log_info.log_file_name);

+ }

+

+ DBUG_PRINT("info",("purging %s",log_info.log_file_name));

+ if (!my_delete(log_info.log_file_name, MYF(0)))

+ {

+ if (decrease_log_space)

+ *decrease_log_space-= s.st_size;

+ if (my_errno == ENOENT)

+ if (thd)

+ {

+ push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,

+ ER_LOG_PURGE_NO_FILE, ER(ER_LOG_PURGE_NO_FILE),

+ log_info.log_file_name);

+ }

+ sql_print_information("Failed to delete file '%s'",

+ log_info.log_file_name);

+ my_errno= 0;

+ if (thd)

+ {

+ push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,

+ ER_BINLOG_PURGE_FATAL_ERR,

+ "a problem with deleting %s; "

+ }

+ else

+ {

+ sql_print_information("Failed to delete file '%s'; "

+ "consider examining correspondence "

+ "of your binlog index file "

+ "to the actual binlog files",

+ log_info.log_file_name);

+ }

+ if (my_errno == EMFILE)

+ {

+ DBUG_PRINT("info",

+ ("my_errno: %d, set ret = LOG_INFO_EMFILE", my_errno));

+ error= LOG_INFO_EMFILE;

+ goto err;

+ }

+ error= LOG_INFO_FATAL;

+ !is_active(log_info.log_file_name) &&

+ !log_in_use(log_info.log_file_name))

+ push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,

+ sizeof(log_info.log_file_name) - 1);

+ if (!open_index_file(index_file_name, 0, FALSE))

+ open(old_name, log_type, new_name_ptr,

+ io_cache_type, no_auto_events, max_size, 1, FALSE);

+

+ 1 - a transactional engine/table is updated (stmt_has_updated_trans_table == TRUE);

+ 2 - or the event asks for it (cache_stmt == TRUE);

+ 3 - or the cache is already not empty (meaning we're in a transaction;

+ note that the present event could be about a non-transactional table, but

+ still we need to write to the binlog cache in that case to handle updates

+ to mixed trans/non-trans table types).

+

+ Write to the binlog on disk if only a non-transactional engine is

+ updated and:

+ 1 - the binlog cache is empty or;

+ 2 - --binlog-direct-non-transactional-updates is set and we are about to

+ use the statement format. When using the row format (cache_stmt == TRUE).

+ if (event_info->get_cache_stmt() || stmt_has_updated_trans_table(thd) ||

+ (!thd->variables.binlog_direct_non_trans_update &&

+ trans_log_pos != 0))

+#ifdef HAVE_REPLICATION

+ bool check_purge= false;

+#endif

+ check_purge= true;

+

+#ifdef HAVE_REPLICATION

+ /*

+ NOTE: Run purge_logs wo/ holding LOCK_log

+ as it otherwise will deadlock in ndbcluster_binlog_index_purge_file

+ */

+ if (check_purge && expire_logs_days)

+ {

+ time_t purge_time= my_time(0) - expire_logs_days*24*60*60;

+ if (purge_time >= 0)

+ purge_logs_before_date(purge_time);

+ }

+#endif

+ error= ev.write(&log_file);

+ end= strmake(err_renamed,log_error_file,FN_REFLEN-5);

+ char err_temp[FN_REFLEN+5];

+ open(opt_name, LOG_BIN, 0, WRITE_CACHE, 0, max_binlog_size, 0, TRUE);

+ bool init_and_set_log_file_name(const char *log_name,

+ const char *new_name,

+ enum_log_type log_type_arg,

+ enum cache_type io_cache_type_arg);

+ char index_file_name[FN_REFLEN];

+ purge_file is a temp file used in purge_logs so that the index file

+ IO_CACHE purge_index_file;

+ char purge_index_file_name[FN_REFLEN];

+ bool null_created,

+ bool need_mutex);

+ const char *log_name, bool need_mutex);

+ int set_purge_index_file_name(const char *base_file_name);

+ int open_purge_index_file(bool destroy);

+ bool is_inited_purge_index_file();

+ int close_purge_index_file();

+ int clean_purge_index_file();

+ int sync_purge_index_file();

+ int register_purge_index_entry(const char* entry);

+ int register_create_index_entry(const char* entry);

+ int purge_index_entry(THD *thd, ulonglong *decrease_log_space,

+ bool need_mutex);

+ if (master_data_written != 0)

+ {

+ /*

+ Q_MASTER_DATA_WRITTEN_CODE only exists in relay logs where the master

+ has binlog_version<4 and the slave has binlog_version=4. See comment

+ for master_data_written in log_event.h for details.

+ */

+ *start++= Q_MASTER_DATA_WRITTEN_CODE;

+ int4store(start, master_data_written);

+ start+= 4;

+ }

+

+ the MAX_SIZE_LOG_EVENT_STATUS in log_event.h and update the function

+ code_name() in this file.

+ table_map_for_update((ulonglong)thd_arg->table_map_for_update),

+ master_data_written(0)

+ case Q_MASTER_DATA_WRITTEN_CODE: return "Q_MASTER_DATA_WRITTEN_CODE";

+ table_map_for_update(0), master_data_written(0)

+ }

+ else

+ {

+ /*

+ server version < 5.0 / binlog_version < 4 master's event is

+ relay-logged with storing the original size of the event in

+ Q_MASTER_DATA_WRITTEN_CODE status variable.

+ The size is to be restored at reading Q_MASTER_DATA_WRITTEN_CODE-marked

+ event from the relay log.

+ */

+ DBUG_ASSERT(description_event->binlog_version < 4);

+ master_data_written= data_written;

+ case Q_MASTER_DATA_WRITTEN_CODE:

+ CHECK_SPACE(pos, end, 4);

+ data_written= master_data_written= uint4korr(pos);

+ pos+= 4;

+ break;

+ /*

+ In the slave thread, we may sometimes execute some DROP / * 40005

+ TEMPORARY * / TABLE that come from parts of binlogs (likely if we

+ use RESET SLAVE or CHANGE MASTER TO), while the temporary table

+ has already been dropped. To ignore such irrelevant "table does

+ not exist errors", we silently clear the error if TEMPORARY was used.

+ */

+ if (thd->lex->sql_command == SQLCOM_DROP_TABLE && thd->lex->drop_temporary &&

+ thd->is_error() && thd->main_da.sql_errno() == ER_BAD_TABLE_ERROR &&

+ !expected_error)

+ thd->main_da.reset_diagnostics_area();

+ /*

+ 11 + // "CONCURRENT "

+ if (thd->lex->lock_option == TL_WRITE_CONCURRENT_INSERT)

+ pos= strmov(pos, "CONCURRENT ");

+

+ return mysql_bin_log.write(this);

+ error= thd->binlog_flush_pending_rows_event(true);

+ error|= ha_autocommit_or_rollback(thd, error);

+ if (m_field_metadata_size < 251)

+ else

+ m_data_size+= m_field_metadata_size + 3;

+ 1 + 8 /* type, table_map_for_update */ + \

+ 1 + 4 /* type, master_data_written */)

+#define Q_MASTER_DATA_WRITTEN_CODE 10

+

+/* Intvar event post-header */

+

+ /*

+ Holds the original length of a Query_log_event that comes from a

+ master of version < 5.0 (i.e., binlog_version < 4). When the IO

+ thread writes the relay log, it augments the Query_log_event with a

+ Q_MASTER_DATA_WRITTEN_CODE status_var that holds the original event

+ length. This field is initialized to non-zero in the SQL thread when

+ it reads this augmented event. SQL thread does not write

+ Q_MASTER_DATA_WRITTEN_CODE to the slave's server binlog.

+ */

+ uint32 master_data_written;

+ (2) LOAD DATA [CONCURRENT] [LOCAL] INFILE 'file_name'

+ error= thd->binlog_flush_pending_rows_event(false);

+ if (error)

+ {

+ rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,

+ ER(ER_SLAVE_FATAL_ERROR),

+ "call to binlog_flush_pending_rows_event() failed");

+ thd->is_slave_error= 1;

+ DBUG_RETURN(error);

+ }

+ int binlog_error= thd->binlog_flush_pending_rows_event(true);

+ if ((error= ha_autocommit_or_rollback(thd, binlog_error)))

+ error|= binlog_error;

+/* Version numbers for deprecation messages */

+#define VER_BETONY "5.5"

+#define VER_CELOSIA "5.6"

+

+ "in a future release. Please use %s instead.", (Old), (New)); \

+int write_bin_log(THD *thd, bool clear_error,

+ char const *query, ulong query_length);

+inline bool is_schema_db(const char *name, size_t len)

+{

+ return (INFORMATION_SCHEMA_NAME.length == len &&

+ !my_strcasecmp(system_charset_info,

+ INFORMATION_SCHEMA_NAME.str, name));

+}

+

+inline bool is_schema_db(const char *name)

+{

+ return !my_strcasecmp(system_charset_info,

+ INFORMATION_SCHEMA_NAME.str, name);

+}

+ DBUG_LEAVE; // Must match DBUG_ENTER()

+ if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln, TRUE))

+ WRITE_CACHE, 0, max_binlog_size, 0, TRUE))

+ OPT_LOG_BIN_TRUST_FUNCTION_CREATORS_OLD,

+ OPT_MYISAM_MMAP_SIZE,

+ OPT_DEFAULT_COLLATION_OLD,

+ OPT_SYMBOLIC_LINKS,

+ OPT_WARNINGS,

+ OPT_RECORD_BUFFER_OLD,

+ OPT_IGNORE_BUILTIN_INNODB,

+ OPT_BINLOG_DIRECT_NON_TRANS_UPDATE,

+ OPT_DEFAULT_CHARACTER_SET_OLD

+ {"default-character-set", OPT_DEFAULT_CHARACTER_SET_OLD,

+ "Set the default character set (deprecated option, use --character-set-server instead).",

+ {"default-collation", OPT_DEFAULT_COLLATION_OLD, "Set the default collation (deprecated option, use --collation-server instead).",

+ {"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed by a slave server \

+each time the SQL thread starts.",

+ {"log-bin-trust-routine-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS_OLD,

+ {"use-symbolic-links", OPT_SYMBOLIC_LINKS, "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",

+ {"warnings", OPT_WARNINGS, "Deprecated; use --log-warnings instead.",

+ {"myisam_mmap_size", OPT_MYISAM_MMAP_SIZE,

+ "Can be used to restrict the total memory used for memory mmaping of myisam files",

+ (uchar**) &myisam_mmap_size, (uchar**) &myisam_mmap_size, 0,

+ GET_ULL, REQUIRED_ARG, SIZE_T_MAX, MEMMAP_EXTRA_MARGIN, SIZE_T_MAX, 0, 1, 0},

+ {"record_buffer", OPT_RECORD_BUFFER_OLD,

+ "Alias for read_buffer_size. This variable is deprecated and will be removed in a future release.",

+ {"binlog-direct-non-transactional-updates", OPT_BINLOG_DIRECT_NON_TRANS_UPDATE,

+ "Causes updates to non-transactional engines using statement format to be written directly to binary log. Before using this option make sure that there are no dependencies between transactional and non-transactional tables such as in the statement INSERT INTO t_myisam SELECT * FROM t_innodb; otherwise, slaves may diverge from the master.",

+ (uchar**) &global_system_variables.binlog_direct_non_trans_update, (uchar**) &max_system_variables.binlog_direct_non_trans_update, 0, GET_BOOL, NO_ARG, 0,

+ 0, 0, 0, 0, 0},

+ case '0':

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--log-long-format", "--log-short-format");

+ break;

+ case OPT_DEFAULT_CHARACTER_SET_OLD: // --default-character-set

+ WARN_DEPRECATED(NULL, VER_CELOSIA,

+ "--default-character-set",

+ "--character-set-server");

+ /* Fall through */

+ case 'O':

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--set-variable", "--variable-name=value");

+ break;

+ case OPT_WARNINGS:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--warnings", "--log-warnings");

+ /* Note: fall-through to 'W' */

+ case (int) OPT_DEFAULT_COLLATION_OLD:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--default-collation", "--collation-server");

+ break;

+ case (int) OPT_SAFE_SHOW_DB:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--safe-show-database", "GRANT SHOW DATABASES");

+ break;

+ case (int) OPT_LOG_BIN_TRUST_FUNCTION_CREATORS_OLD:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--log-bin-trust-routine-creators", "--log-bin-trust-function-creators");

+ break;

+ case (int) OPT_ENABLE_LOCK:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--enable-locking", "--external-locking");

+ break;

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--log-update", "--log-bin");

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--skip-locking", "--skip-external-locking");

+ case (int) OPT_SQL_BIN_UPDATE_SAME:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--sql-bin-update-same", "the binary log");

+ break;

+ case (int) OPT_RECORD_BUFFER_OLD:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "record_buffer", "read_buffer_size");

+ break;

+ case (int) OPT_SYMBOLIC_LINKS:

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--use-symbolic-links", "--symbolic-links");

+ break;

+ WARN_DEPRECATED(NULL, VER_CELOSIA, "--skip-symlink", "--skip-symbolic-links");

+ WARN_DEPRECATED(NULL, VER_CELOSIA,

+ "--delay-key-write-for-all-tables",

+ "--delay-key-write=ALL");

+/**

+ @retval 0 transaction committed

+ @retval 1 transaction rolled back

+ */

+ int error= m_thd->binlog_flush_pending_rows_event(true);

+ error |= ha_autocommit_or_rollback(m_thd, error);

+ end_trans(m_thd, error ? ROLLBACK : COMMIT);

+ DBUG_RETURN(error);

+

+ int error= check_state(ROW_STATE);

+ if (error)

+ error= m_thd->binlog_write_row(tbl.get_table(), tbl.is_transactional(),

+ cols, colcnt, record);

+ DBUG_RETURN(error);

+ int error= check_state(ROW_STATE);

+ if (error)

+ error= m_thd->binlog_delete_row(tbl.get_table(), tbl.is_transactional(),

+ cols, colcnt, record);

+ DBUG_RETURN(error);

+ int error= check_state(ROW_STATE);

+ if (error)

+ error= m_thd->binlog_update_row(tbl.get_table(), tbl.is_transactional(),

+ cols, colcnt, before, after);

+ DBUG_RETURN(error);

+ /**

+ Calling reset just in case one is unpacking on top a

+ record with data.

+

+ This could probably go into set_null() but doing so,

+ (i) triggers assertion in other parts of the code at

+ the moment; (ii) it would make us reset the field,

+ always when setting null, which right now doesn't seem

+ needed anywhere else except here.

+

+ TODO: maybe in the future we should consider moving

+ the reset to make it part of set_null. But then

+ the assertions triggered need to be

+ addressed/revisited.

+ */

+ f->reset();

+ if (rli->relay_log.open_index_file(opt_relaylog_index_name, ln, TRUE) ||

+ max_binlog_size), 1, TRUE))

+bool Relay_log_info::is_until_satisfied(THD *thd, Log_event *ev)

+ if (ev && ev->server_id == (uint32) ::server_id && !replicate_same_server_id)

+ DBUG_RETURN(FALSE);

+ log_pos= (!ev)? group_master_log_pos :

+ ((thd->options & OPTION_BEGIN || !ev->log_pos) ?

+ group_master_log_pos : ev->log_pos - ev->data_written);

+ bool is_until_satisfied(THD *thd, Log_event *ev);

+ case MYSQL_TYPE_GEOMETRY:

+static uchar *get_myisam_mmap_size(THD *thd);

+static sys_var_thd_bool sys_binlog_direct_non_trans_update(&vars, "binlog_direct_non_transactional_updates",

+ &SV::binlog_direct_non_trans_update);

+static sys_var_readonly sys_myisam_mmap_size(&vars, "myisam_mmap_size",

+ OPT_GLOBAL,

+ SHOW_LONGLONG,

+ get_myisam_mmap_size);

+static uchar *get_myisam_mmap_size(THD *thd)

+{

+ return (uchar *)&myisam_mmap_size;

+}

+

+

+ WARN_DEPRECATED(thd, VER_CELOSIA, "@@log_bin_trust_routine_creators",

+ eng "The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been ignored. This option will be removed in MySQL 5.6."

+ ger "Das Update-Log ist veraltet und wurde durch das Bin�r-Log ersetzt. SET SQL_LOG_UPDATE wird ignoriert. Diese Option wird in MySQL 5.6 entfernt."

+ eng "The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been translated to SET SQL_LOG_BIN. This option will be removed in MySQL 5.6."

+ ger "Das Update-Log ist veraltet und wurde durch das Bin�r-Log ersetzt. SET SQL_LOG_UPDATE wurde in SET SQL_LOG_BIN �bersetzt. Diese Option wird in MySQL 5.6 entfernt."

+ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR

+ eng "Constant, random or timezone-dependent expressions in (sub)partitioning function are not allowed"

+ rli->is_until_satisfied(thd, ev))

+ rli->is_until_satisfied(thd, NULL))

+ bool save_binlog_row_based;

+

+ retstr.set_charset(system_charset_info);

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ if (thd->binlog_query(THD::MYSQL_QUERY_TYPE,

+ log_query.c_ptr(), log_query.length(),

+ FALSE, FALSE, 0))

+ ret= SP_INTERNAL_ERROR;

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ bool save_binlog_row_based;

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ if (write_bin_log(thd, TRUE, thd->query(), thd->query_length()))

+ ret= SP_INTERNAL_ERROR;

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ bool save_binlog_row_based;

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ if (write_bin_log(thd, TRUE, thd->query(), thd->query_length()))

+ ret= SP_INTERNAL_ERROR;

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ retstr.set_charset(sp->get_creation_ctx()->get_client_cs());

+ err_status= TRUE;

+ /*

+ Update the state of the active arena if no errors on

+ open_tables stage.

+ */

+ if (!res || !thd->is_error() ||

+ (thd->main_da.sql_errno() != ER_CANT_REOPEN_TABLE &&

+ thd->main_da.sql_errno() != ER_NO_SUCH_TABLE &&

+ thd->main_da.sql_errno() != ER_UPDATE_TABLE_USED))

+ thd->stmt_arena->state= Query_arena::EXECUTED;

+ char sqlstate[SQLSTATE_LENGTH+1];

+ my_bool return_val= TRUE;

+ return_val= FALSE;

+ my_bool return_val= TRUE;

+ /*

+ Execution might have been interrupted; only print the error message

+ if an error condition has been raised.

+ */

+ if (thd->main_da.is_error())

+ sql_print_error("Fatal error: Can't open and lock privilege tables: %s",

+ thd->main_da.message());

+ strmake(sctx->priv_host, acl_user->host.hostname, MAX_HOSTNAME - 1);

+ strmake(sctx->priv_host, acl_user->host.hostname, MAX_HOSTNAME - 1);

+ result= thd->binlog_query(THD::MYSQL_QUERY_TYPE, buff, query_length,

+ FALSE, FALSE, 0);

+ bool save_binlog_row_based;

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ {

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ }

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ result= write_bin_log(thd, TRUE, thd->query(), thd->query_length());

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ bool save_binlog_row_based;

+ save_binlog_row_based= thd->current_stmt_binlog_row_based;

+ {

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ }

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ if (write_bin_log(thd, FALSE, thd->query(), thd->query_length()))

+ result= TRUE;

+ /* Restore the state of binlog format */

+ thd->current_stmt_binlog_row_based= save_binlog_row_based;

+ bool save_binlog_row_based;