database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-10-23 18:49:29 +03:00
Code Activity

Merge branch '10.0' into 10.1

Browse Source
This commit is contained in:
Sergei Golubchik
2017-07-07 11:30:03 +02:00
parent 2b5c9bc2c8 6b99859fff
commit 9e11e055ce
33 changed files with 778 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
sql/ha_partition.cc
View File

@@ -674,7 +674,7 @@ int ha_partition::create(const char *name, TABLE *table_arg,
HA_CREATE_INFO *create_info)
{
int error;
char name_buff[FN_REFLEN], name_lc_buff[FN_REFLEN];
char name_buff[FN_REFLEN + 1], name_lc_buff[FN_REFLEN];
char *name_buffer_ptr;
const char *path;
uint i;
@@ -716,8 +716,9 @@ int ha_partition::create(const char *name, TABLE *table_arg,
for (j= 0; j < m_part_info->num_subparts; j++)
{
part_elem= sub_it++;
create_partition_name(name_buff, path, name_buffer_ptr,
NORMAL_PART_NAME, FALSE);
if ((error= create_partition_name(name_buff, sizeof(name_buff), path,
name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto create_error;
if ((error= set_up_table_before_create(table_arg, name_buff,
create_info, part_elem)) ||
((error= (*file)->ha_create(name_buff, table_arg, create_info))))
@@ -729,8 +730,9 @@ int ha_partition::create(const char *name, TABLE *table_arg,
}
else
{
create_partition_name(name_buff, path, name_buffer_ptr,
NORMAL_PART_NAME, FALSE);
if ((error= create_partition_name(name_buff, sizeof(name_buff), path,
name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto create_error;
if ((error= set_up_table_before_create(table_arg, name_buff,
create_info, part_elem)) ||
((error= (*file)->ha_create(name_buff, table_arg, create_info))))
@@ -746,9 +748,9 @@ create_error:
name_buffer_ptr= m_name_buffer_ptr;
for (abort_file= file, file= m_file; file < abort_file; file++)
{
create_partition_name(name_buff, path, name_buffer_ptr, NORMAL_PART_NAME,
FALSE);
(void) (*file)->ha_delete_table((const char*) name_buff);
if (!create_partition_name(name_buff, sizeof(name_buff), path,
name_buffer_ptr, NORMAL_PART_NAME, FALSE))
(void) (*file)->ha_delete_table((const char*) name_buff);
name_buffer_ptr= strend(name_buffer_ptr) + 1;
}
handler::delete_table(name);
@@ -775,7 +777,7 @@ create_error:
int ha_partition::drop_partitions(const char *path)
{
List_iterator<partition_element> part_it(m_part_info->partitions);
char part_name_buff[FN_REFLEN];
char part_name_buff[FN_REFLEN + 1];
uint num_parts= m_part_info->partitions.elements;
uint num_subparts= m_part_info->num_subparts;
uint i= 0;
@@ -808,9 +810,11 @@ int ha_partition::drop_partitions(const char *path)
{
partition_element *sub_elem= sub_it++;
part= i * num_subparts + j;
create_subpartition_name(part_name_buff, path,
part_elem->partition_name,
sub_elem->partition_name, name_variant);
if ((ret_error= create_subpartition_name(part_name_buff,
sizeof(part_name_buff), path,
part_elem->partition_name,
sub_elem->partition_name, name_variant)))
error= ret_error;
file= m_file[part];
DBUG_PRINT("info", ("Drop subpartition %s", part_name_buff));
if ((ret_error= file->ha_delete_table(part_name_buff)))
@@ -821,15 +825,19 @@ int ha_partition::drop_partitions(const char *path)
}
else
{
create_partition_name(part_name_buff, path,
part_elem->partition_name, name_variant,
TRUE);
file= m_file[i];
DBUG_PRINT("info", ("Drop partition %s", part_name_buff));
if ((ret_error= file->ha_delete_table(part_name_buff)))
if ((ret_error= create_partition_name(part_name_buff,
sizeof(part_name_buff), path,
part_elem->partition_name, name_variant, TRUE)))
error= ret_error;
if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
else
{
file= m_file[i];
DBUG_PRINT("info", ("Drop partition %s", part_name_buff));
if ((ret_error= file->ha_delete_table(part_name_buff)))
error= ret_error;
if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
}
}
if (part_elem->part_state == PART_IS_CHANGED)
part_elem->part_state= PART_NORMAL;
@@ -865,8 +873,8 @@ int ha_partition::rename_partitions(const char *path)
{
List_iterator<partition_element> part_it(m_part_info->partitions);
List_iterator<partition_element> temp_it(m_part_info->temp_partitions);
char part_name_buff[FN_REFLEN];
char norm_name_buff[FN_REFLEN];
char part_name_buff[FN_REFLEN + 1];
char norm_name_buff[FN_REFLEN + 1];
uint num_parts= m_part_info->partitions.elements;
uint part_count= 0;
uint num_subparts= m_part_info->num_subparts;
@@ -908,10 +916,11 @@ int ha_partition::rename_partitions(const char *path)
{
sub_elem= sub_it++;
file= m_reorged_file[part_count++];
create_subpartition_name(norm_name_buff, path,
part_elem->partition_name,
sub_elem->partition_name,
NORMAL_PART_NAME);
if ((ret_error= create_subpartition_name(norm_name_buff,
sizeof(norm_name_buff), path,
part_elem->partition_name,
sub_elem->partition_name, NORMAL_PART_NAME)))
error= ret_error;
DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff));
if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error;
@@ -924,16 +933,20 @@ int ha_partition::rename_partitions(const char *path)
else
{
file= m_reorged_file[part_count++];
create_partition_name(norm_name_buff, path,
part_elem->partition_name, NORMAL_PART_NAME,
TRUE);
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
if ((ret_error= file->ha_delete_table(norm_name_buff)))
if ((ret_error= create_partition_name(norm_name_buff,
sizeof(norm_name_buff), path,
part_elem->partition_name, NORMAL_PART_NAME, TRUE)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
else
part_elem->log_entry= NULL; /* Indicate success */
{
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
else
part_elem->log_entry= NULL; /* Indicate success */
}
}
} while (++i < temp_partitions);
(void) sync_ddl_log();
@@ -976,10 +989,11 @@ int ha_partition::rename_partitions(const char *path)
{
sub_elem= sub_it++;
part= i * num_subparts + j;
create_subpartition_name(norm_name_buff, path,
part_elem->partition_name,
sub_elem->partition_name,
NORMAL_PART_NAME);
if ((ret_error= create_subpartition_name(norm_name_buff,
sizeof(norm_name_buff), path,
part_elem->partition_name,
sub_elem->partition_name, NORMAL_PART_NAME)))
error= ret_error;
if (part_elem->part_state == PART_IS_CHANGED)
{
file= m_reorged_file[part_count++];
@@ -991,10 +1005,11 @@ int ha_partition::rename_partitions(const char *path)
(void) sync_ddl_log();
}
file= m_new_file[part];
create_subpartition_name(part_name_buff, path,
part_elem->partition_name,
sub_elem->partition_name,
TEMP_PART_NAME);
if ((ret_error= create_subpartition_name(part_name_buff,
sizeof(part_name_buff), path,
part_elem->partition_name,
sub_elem->partition_name, TEMP_PART_NAME)))
error= ret_error;
DBUG_PRINT("info", ("Rename subpartition from %s to %s",
part_name_buff, norm_name_buff));
if ((ret_error= file->ha_rename_table(part_name_buff,
@@ -1008,32 +1023,36 @@ int ha_partition::rename_partitions(const char *path)
}
else
{
create_partition_name(norm_name_buff, path,
part_elem->partition_name, NORMAL_PART_NAME,
TRUE);
if (part_elem->part_state == PART_IS_CHANGED)
if ((ret_error= create_partition_name(norm_name_buff,
sizeof(norm_name_buff), path,
part_elem->partition_name, NORMAL_PART_NAME, TRUE)) ||
(ret_error= create_partition_name(part_name_buff,
sizeof(part_name_buff), path,
part_elem->partition_name, TEMP_PART_NAME, TRUE)))
error= ret_error;
else
{
file= m_reorged_file[part_count++];
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
if ((ret_error= file->ha_delete_table(norm_name_buff)))
if (part_elem->part_state == PART_IS_CHANGED)
{
file= m_reorged_file[part_count++];
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
(void) sync_ddl_log();
}
file= m_new_file[i];
DBUG_PRINT("info", ("Rename partition from %s to %s",
part_name_buff, norm_name_buff));
if ((ret_error= file->ha_rename_table(part_name_buff,
norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
(void) sync_ddl_log();
else
part_elem->log_entry= NULL;
}
file= m_new_file[i];
create_partition_name(part_name_buff, path,
part_elem->partition_name, TEMP_PART_NAME,
TRUE);
DBUG_PRINT("info", ("Rename partition from %s to %s",
part_name_buff, norm_name_buff));
if ((ret_error= file->ha_rename_table(part_name_buff,
norm_name_buff)))
error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
else
part_elem->log_entry= NULL;
}
}
} while (++i < num_parts);
@@ -1649,7 +1668,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
{
List_iterator<partition_element> part_it(m_part_info->partitions);
List_iterator <partition_element> t_it(m_part_info->temp_partitions);
char part_name_buff[FN_REFLEN];
char part_name_buff[FN_REFLEN + 1];
uint num_parts= m_part_info->partitions.elements;
uint num_subparts= m_part_info->num_subparts;
uint i= 0;
@@ -1878,10 +1897,14 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
do
{
partition_element *sub_elem= sub_it++;
create_subpartition_name(part_name_buff, path,
part_elem->partition_name,
sub_elem->partition_name,
name_variant);
if ((error= create_subpartition_name(part_name_buff,
sizeof(part_name_buff), path,
part_elem->partition_name, sub_elem->partition_name,
name_variant)))
{
cleanup_new_partition(part_count);
DBUG_RETURN(error);
}
part= i * num_subparts + j;
DBUG_PRINT("info", ("Add subpartition %s", part_name_buff));
if ((error= prepare_new_partition(table, create_info,
@@ -1899,9 +1922,14 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
}
else
{
create_partition_name(part_name_buff, path,
part_elem->partition_name, name_variant,
TRUE);
if ((error= create_partition_name(part_name_buff,
sizeof(part_name_buff), path, part_elem->partition_name,
name_variant, TRUE)))
{
cleanup_new_partition(part_count);
DBUG_RETURN(error);
}
DBUG_PRINT("info", ("Add partition %s", part_name_buff));
if ((error= prepare_new_partition(table, create_info,
new_file_array[i],
@@ -2272,8 +2300,8 @@ uint ha_partition::del_ren_table(const char *from, const char *to)
{
int save_error= 0;
int error;
char from_buff[FN_REFLEN], to_buff[FN_REFLEN], from_lc_buff[FN_REFLEN],
to_lc_buff[FN_REFLEN];
char from_buff[FN_REFLEN + 1], to_buff[FN_REFLEN + 1],
from_lc_buff[FN_REFLEN], to_lc_buff[FN_REFLEN];
char *name_buffer_ptr;
const char *from_path;
const char *to_path= NULL;
@@ -2309,13 +2337,15 @@ uint ha_partition::del_ren_table(const char *from, const char *to)
i= 0;
do
{
create_partition_name(from_buff, from_path, name_buffer_ptr,
NORMAL_PART_NAME, FALSE);
if ((error= create_partition_name(from_buff, sizeof(from_buff), from_path,
name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto rename_error;
if (to != NULL)
{ // Rename branch
create_partition_name(to_buff, to_path, name_buffer_ptr,
NORMAL_PART_NAME, FALSE);
if ((error= create_partition_name(to_buff, sizeof(to_buff), to_path,
name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto rename_error;
error= (*file)->ha_rename_table(from_buff, to_buff);
if (error)
goto rename_error;
@@ -2344,12 +2374,14 @@ rename_error:
for (abort_file= file, file= m_file; file < abort_file; file++)
{
/* Revert the rename, back from 'to' to the original 'from' */
create_partition_name(from_buff, from_path, name_buffer_ptr,
NORMAL_PART_NAME, FALSE);
create_partition_name(to_buff, to_path, name_buffer_ptr,
NORMAL_PART_NAME, FALSE);
/* Ignore error here */
(void) (*file)->ha_rename_table(to_buff, from_buff);
if (!create_partition_name(from_buff, sizeof(from_buff), from_path,
name_buffer_ptr, NORMAL_PART_NAME, FALSE) &&
!create_partition_name(to_buff, sizeof(to_buff), to_path,
name_buffer_ptr, NORMAL_PART_NAME, FALSE))
{
/* Ignore error here */
(void) (*file)->ha_rename_table(to_buff, from_buff);
}
name_buffer_ptr= strend(name_buffer_ptr) + 1;
}
DBUG_RETURN(error);
@@ -3416,7 +3448,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
char *name_buffer_ptr;
int error= HA_ERR_INITIALIZATION;
handler **file;
char name_buff[FN_REFLEN];
char name_buff[FN_REFLEN + 1];
ulonglong check_table_flags;
DBUG_ENTER("ha_partition::open");
@@ -3470,8 +3502,9 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
file= m_is_clone_of->m_file;
for (i= 0; i < m_tot_parts; i++)
{
create_partition_name(name_buff, name, name_buffer_ptr, NORMAL_PART_NAME,
FALSE);
if ((error= create_partition_name(name_buff, sizeof(name_buff), name,
name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto err_handler;
/* ::clone() will also set ha_share from the original. */
if (!(m_file[i]= file[i]->clone(name_buff, m_clone_mem_root)))
{
@@ -3487,8 +3520,9 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
file= m_file;
do
{
create_partition_name(name_buff, name, name_buffer_ptr, NORMAL_PART_NAME,
FALSE);
if ((error= create_partition_name(name_buff, sizeof(name_buff), name,
name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto err_handler;
table->s->connect_string = m_connect_string[(uint)(file-m_file)];
if ((error= (*file)->ha_open(table, name_buff, mode,
test_if_locked | HA_OPEN_NO_PSI_CALL)))

6
sql/item.cc
View File

@@ -4875,6 +4875,12 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
(Item_ident*) (*reference) :
0));
if (thd->lex->in_sum_func &&
thd->lex->in_sum_func->nest_level >= select->nest_level)
{
set_if_bigger(thd->lex->in_sum_func->max_arg_level,
select->nest_level);
}
/*
A reference to a view field had been found and we
substituted it instead of this Item (find_field_in_tables

2
sql/item_timefunc.cc
View File

@@ -3100,7 +3100,7 @@ get_date_time_result_type(const char *format, uint length)
const char *val= format;
const char *end= format + length;
for (; val != end && val != end; val++)
for (; val != end; val++)
{
if (*val == '%' && val+1 != end)
{

14
sql/partition_info.cc
View File

@@ -889,6 +889,7 @@ char* partition_info::find_duplicate_field()
*/
partition_element *partition_info::get_part_elem(const char *partition_name,
char *file_name,
size_t file_name_size,
uint32 *part_id)
{
List_iterator<partition_element> part_it(partitions);
@@ -910,10 +911,10 @@ partition_element *partition_info::get_part_elem(const char *partition_name,
sub_part_elem->partition_name, partition_name))
{
if (file_name)
create_subpartition_name(file_name, "",
part_elem->partition_name,
partition_name,
NORMAL_PART_NAME);
if (create_subpartition_name(file_name, file_name_size, "",
part_elem->partition_name,
partition_name, NORMAL_PART_NAME))
DBUG_RETURN(NULL);
*part_id= j + (i * num_subparts);
DBUG_RETURN(sub_part_elem);
}
@@ -928,8 +929,9 @@ partition_element *partition_info::get_part_elem(const char *partition_name,
part_elem->partition_name, partition_name))
{
if (file_name)
create_partition_name(file_name, "", partition_name,
NORMAL_PART_NAME, TRUE);
if (create_partition_name(file_name, file_name_size, "",
partition_name, NORMAL_PART_NAME, TRUE))
DBUG_RETURN(NULL);
*part_id= i;
DBUG_RETURN(part_elem);
}

5
sql/partition_info.h
View File

@@ -340,9 +340,8 @@ public:
bool init_column_part(THD *thd);
bool add_column_list_value(THD *thd, Item *item);
void set_show_version_string(String *packet);
partition_element *get_part_elem(const char *partition_name,
char *file_name,
uint32 *part_id);
partition_element *get_part_elem(const char *partition_name, char *file_name,
size_t file_name_size, uint32 *part_id);
void report_part_expr_error(bool use_subpart_expr);
bool set_used_partition(List<Item> &fields,
List<Item> &values,

32
sql/slave.cc
View File

@@ -2466,6 +2466,7 @@ static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi)
}
if (rli->ign_gtids.count())
{
DBUG_ASSERT(!rli->is_in_group()); // Ensure no active transaction
glev= new Gtid_list_log_event(&rli->ign_gtids,
Gtid_list_log_event::FLAG_IGN_GTIDS);
rli->ign_gtids.reset();
@@ -5582,7 +5583,9 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
bool gtid_skip_enqueue= false;
bool got_gtid_event= false;
rpl_gtid event_gtid;
#ifndef DBUG_OFF
static uint dbug_rows_event_count= 0;
#endif
/*
FD_q must have been prepared for the first R_a event
inside get_master_version_and_clock()
@@ -5649,6 +5652,26 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
(uchar)buf[EVENT_TYPE_OFFSET] != FORMAT_DESCRIPTION_EVENT /* a way to escape */)
DBUG_RETURN(queue_old_event(mi,buf,event_len));
#ifdef ENABLED_DEBUG_SYNC
/*
A (+d,dbug.rows_events_to_delay_relay_logging)-test is supposed to
create a few Write_log_events and after receiving the 1st of them
the IO thread signals to launch the SQL thread, and sets itself to
wait for a release signal.
*/
DBUG_EXECUTE_IF("dbug.rows_events_to_delay_relay_logging",
if ((buf[EVENT_TYPE_OFFSET] == WRITE_ROWS_EVENT_V1 ||
buf[EVENT_TYPE_OFFSET] == WRITE_ROWS_EVENT) &&
++dbug_rows_event_count == 2)
{
const char act[]=
"now SIGNAL start_sql_thread "
"WAIT_FOR go_on_relay_logging";
DBUG_ASSERT(debug_sync_service);
DBUG_ASSERT(!debug_sync_set_action(current_thd,
STRING_WITH_LEN(act)));
};);
#endif
mysql_mutex_lock(&mi->data_lock);
switch ((uchar)buf[EVENT_TYPE_OFFSET]) {
@@ -6897,9 +6920,12 @@ static Log_event* next_event(rpl_group_info *rgi, ulonglong *event_size)
DBUG_RETURN(ev);
}
if (rli->ign_gtids.count())
if (rli->ign_gtids.count() && !rli->is_in_group())
{
/* We generate and return a Gtid_list, to update gtid_slave_pos. */
/*
We generate and return a Gtid_list, to update gtid_slave_pos,
unless being in the middle of a group.
*/
DBUG_PRINT("info",("seeing ignored end gtids"));
ev= new Gtid_list_log_event(&rli->ign_gtids,
Gtid_list_log_event::FLAG_IGN_GTIDS);

12
sql/sql_class.cc
View File

@@ -4113,7 +4113,7 @@ void Security_context::destroy()
if (external_user)
{
my_free(external_user);
user= NULL;
external_user= NULL;
}
my_free(ip);
@@ -4330,6 +4330,10 @@ extern "C" enum thd_kill_levels thd_kill_level(const MYSQL_THD thd)
however not more often than global.progress_report_time.
If global.progress_report_time is 0, then don't send progress reports, but
check every second if the value has changed
We clear any errors that we get from sending the progress packet to
the client as we don't want to set an error without the caller knowing
about it.
*/
static void thd_send_progress(THD *thd)
@@ -4346,8 +4350,12 @@ static void thd_send_progress(THD *thd)
thd->progress.next_report_time= (report_time +
seconds_to_next * 1000000000ULL);
if (global_system_variables.progress_report_time &&
thd->variables.progress_report_time)
thd->variables.progress_report_time && !thd->is_error())
{
net_send_progress_packet(thd);
if (thd->is_error())
thd->clear_error();
}
}
}

118
sql/sql_partition.cc
View File

@@ -5989,8 +5989,8 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
DDL_LOG_ENTRY ddl_log_entry;
partition_info *part_info= lpt->part_info;
DDL_LOG_MEMORY_ENTRY *log_entry;
char tmp_path[FN_REFLEN];
char normal_path[FN_REFLEN];
char tmp_path[FN_REFLEN + 1];
char normal_path[FN_REFLEN + 1];
List_iterator<partition_element> part_it(part_info->partitions);
uint temp_partitions= part_info->temp_partitions.elements;
uint num_elements= part_info->partitions.elements;
@@ -6014,14 +6014,15 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(sub_elem->engine_type);
create_subpartition_name(tmp_path, path,
part_elem->partition_name,
sub_elem->partition_name,
TEMP_PART_NAME);
create_subpartition_name(normal_path, path,
part_elem->partition_name,
sub_elem->partition_name,
NORMAL_PART_NAME);
if (create_subpartition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name,
sub_elem->partition_name,
TEMP_PART_NAME) ||
create_subpartition_name(normal_path, sizeof(normal_path), path,
part_elem->partition_name,
sub_elem->partition_name,
NORMAL_PART_NAME))
DBUG_RETURN(TRUE);
ddl_log_entry.name= normal_path;
ddl_log_entry.from_name= tmp_path;
if (part_elem->part_state == PART_IS_CHANGED)
@@ -6042,12 +6043,13 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(part_elem->engine_type);
create_partition_name(tmp_path, path,
part_elem->partition_name,
TEMP_PART_NAME, TRUE);
create_partition_name(normal_path, path,
part_elem->partition_name,
NORMAL_PART_NAME, TRUE);
if (create_partition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name, TEMP_PART_NAME,
TRUE) ||
create_partition_name(normal_path, sizeof(normal_path), path,
part_elem->partition_name, NORMAL_PART_NAME,
TRUE))
DBUG_RETURN(TRUE);
ddl_log_entry.name= normal_path;
ddl_log_entry.from_name= tmp_path;
if (part_elem->part_state == PART_IS_CHANGED)
@@ -6086,7 +6088,7 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
DDL_LOG_ENTRY ddl_log_entry;
partition_info *part_info= lpt->part_info;
DDL_LOG_MEMORY_ENTRY *log_entry;
char tmp_path[FN_LEN];
char tmp_path[FN_REFLEN + 1];
List_iterator<partition_element> part_it(part_info->partitions);
List_iterator<partition_element> temp_it(part_info->temp_partitions);
uint num_temp_partitions= part_info->temp_partitions.elements;
@@ -6125,10 +6127,10 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(sub_elem->engine_type);
create_subpartition_name(tmp_path, path,
part_elem->partition_name,
sub_elem->partition_name,
name_variant);
if (create_subpartition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name,
sub_elem->partition_name, name_variant))
DBUG_RETURN(TRUE);
ddl_log_entry.name= tmp_path;
if (write_ddl_log_entry(&ddl_log_entry, &log_entry))
{
@@ -6144,9 +6146,10 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(part_elem->engine_type);
create_partition_name(tmp_path, path,
part_elem->partition_name,
name_variant, TRUE);
if (create_partition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name, name_variant,
TRUE))
DBUG_RETURN(TRUE);
ddl_log_entry.name= tmp_path;
if (write_ddl_log_entry(&ddl_log_entry, &log_entry))
{
@@ -8266,31 +8269,41 @@ static uint32 get_next_subpartition_via_walking(PARTITION_ITERATOR *part_iter)
return res;
}
/* used in error messages below */
static const char *longest_str(const char *s1, const char *s2,
const char *s3=0)
{
if (strlen(s2) > strlen(s1)) s1= s2;
if (s3 && strlen(s3) > strlen(s1)) s1= s3;
return s1;
}
/*
Create partition names
SYNOPSIS
create_partition_name()
out:out Created partition name string
out:out The buffer for the created partition name string
must be *at least* of FN_REFLEN+1 bytes
in1 First part
in2 Second part
name_variant Normal, temporary or renamed partition name
RETURN VALUE
NONE
0 if ok, error if name too long
DESCRIPTION
This method is used to calculate the partition name, service routine to
the del_ren_cre_table method.
*/
void create_partition_name(char *out, const char *in1,
const char *in2, uint name_variant,
bool translate)
int create_partition_name(char *out, size_t outlen, const char *in1,
const char *in2, uint name_variant, bool translate)
{
char transl_part_name[FN_REFLEN];
const char *transl_part;
const char *transl_part, *end;
DBUG_ASSERT(outlen >= FN_REFLEN + 1); // consistency! same limit everywhere
if (translate)
{
@@ -8300,11 +8313,17 @@ void create_partition_name(char *out, const char *in1,
else
transl_part= in2;
if (name_variant == NORMAL_PART_NAME)
strxmov(out, in1, "#P#", transl_part, NullS);
end= strxnmov(out, outlen-1, in1, "#P#", transl_part, NullS);
else if (name_variant == TEMP_PART_NAME)
strxmov(out, in1, "#P#", transl_part, "#TMP#", NullS);
end= strxnmov(out, outlen-1, in1, "#P#", transl_part, "#TMP#", NullS);
else if (name_variant == RENAMED_PART_NAME)
strxmov(out, in1, "#P#", transl_part, "#REN#", NullS);
end= strxnmov(out, outlen-1, in1, "#P#", transl_part, "#REN#", NullS);
if (end - out == static_cast<ptrdiff_t>(outlen-1))
{
my_error(ER_PATH_LENGTH, MYF(0), longest_str(in1, transl_part));
return HA_WRONG_CREATE_OPTION;
}
return 0;
}
@@ -8313,37 +8332,46 @@ void create_partition_name(char *out, const char *in1,
SYNOPSIS
create_subpartition_name()
out:out Created partition name string
out:out The buffer for the created partition name string
must be *at least* of FN_REFLEN+1 bytes
in1 First part
in2 Second part
in3 Third part
name_variant Normal, temporary or renamed partition name
RETURN VALUE
NONE
0 if ok, error if name too long
DESCRIPTION
This method is used to calculate the subpartition name, service routine to
the del_ren_cre_table method.
*/
void create_subpartition_name(char *out, const char *in1,
const char *in2, const char *in3,
uint name_variant)
int create_subpartition_name(char *out, size_t outlen,
const char *in1, const char *in2,
const char *in3, uint name_variant)
{
char transl_part_name[FN_REFLEN], transl_subpart_name[FN_REFLEN];
char transl_part_name[FN_REFLEN], transl_subpart_name[FN_REFLEN], *end;
DBUG_ASSERT(outlen >= FN_REFLEN + 1); // consistency! same limit everywhere
tablename_to_filename(in2, transl_part_name, FN_REFLEN);
tablename_to_filename(in3, transl_subpart_name, FN_REFLEN);
if (name_variant == NORMAL_PART_NAME)
strxmov(out, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, NullS);
end= strxnmov(out, outlen-1, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, NullS);
else if (name_variant == TEMP_PART_NAME)
strxmov(out, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, "#TMP#", NullS);
end= strxnmov(out, outlen-1, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, "#TMP#", NullS);
else if (name_variant == RENAMED_PART_NAME)
strxmov(out, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, "#REN#", NullS);
end= strxnmov(out, outlen-1, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, "#REN#", NullS);
if (end - out == static_cast<ptrdiff_t>(outlen-1))
{
my_error(ER_PATH_LENGTH, MYF(0),
longest_str(in1, transl_part_name, transl_subpart_name));
return HA_WRONG_CREATE_OPTION;
}
return 0;
}
uint get_partition_field_store_length(Field *field)

12
sql/sql_partition.h
View File

@@ -277,12 +277,12 @@ bool partition_key_modified(TABLE *table, const MY_BITMAP *fields);
#define partition_key_modified(X,Y) 0
#endif
void create_partition_name(char *out, const char *in1,
const char *in2, uint name_variant,
bool translate);
void create_subpartition_name(char *out, const char *in1,
const char *in2, const char *in3,
uint name_variant);
int __attribute__((warn_unused_result))
create_partition_name(char *out, size_t outlen, const char *in1, const char
*in2, uint name_variant, bool translate);
int __attribute__((warn_unused_result))
create_subpartition_name(char *out, size_t outlen, const char *in1, const
char *in2, const char *in3, uint name_variant);
void set_field_ptr(Field **ptr, const uchar *new_buf, const uchar *old_buf);
void set_key_field_ptr(KEY *key_info, const uchar *new_buf,

8
sql/sql_partition_admin.cc
View File

@@ -492,7 +492,7 @@ bool Sql_cmd_alter_table_exchange_partition::
partition_element *part_elem;
char *partition_name;
char temp_name[FN_REFLEN+1];
char part_file_name[FN_REFLEN+1];
char part_file_name[2*FN_REFLEN+1];
char swap_file_name[FN_REFLEN+1];
char temp_file_name[FN_REFLEN+1];
uint swap_part_id;
@@ -590,9 +590,9 @@ bool Sql_cmd_alter_table_exchange_partition::
temp_name, "", FN_IS_TMP);
if (!(part_elem= part_table->part_info->get_part_elem(partition_name,
part_file_name +
part_file_name_len,
&swap_part_id)))
part_file_name + part_file_name_len,
sizeof(part_file_name) - part_file_name_len,
&swap_part_id)))
{
// my_error(ER_UNKNOWN_PARTITION, MYF(0), partition_name,
// part_table->alias);

14
sql/threadpool_unix.cc
View File

@@ -982,24 +982,26 @@ static void thread_group_close(thread_group_t *thread_group)
if (pipe(thread_group->shutdown_pipe))
{
DBUG_VOID_RETURN;
goto end;
}
/* Wake listener */
if (io_poll_associate_fd(thread_group->pollfd,
thread_group->shutdown_pipe[0], NULL))
{
DBUG_VOID_RETURN;
goto end;
}
{
char c= 0;
if (write(thread_group->shutdown_pipe[1], &c, 1) < 0)
goto end;
}
char c= 0;
if (write(thread_group->shutdown_pipe[1], &c, 1) < 0)
DBUG_VOID_RETURN;
/* Wake all workers. */
while(wake_thread(thread_group) == 0)
{
}
end:
mysql_mutex_unlock(&thread_group->mutex);
DBUG_VOID_RETURN;