bugfix: long partition names
This commit is contained in:
parent
a7ed4644a6
commit
f305a7ce4b
33
mysql-test/suite/parts/r/longname.result
Normal file
33
mysql-test/suite/parts/r/longname.result
Normal file
@ -0,0 +1,33 @@
|
||||
set names utf8;
|
||||
create database mysqltest1;
|
||||
CREATE TABLE mysqltest1.test_jfg_table_name_with_64_chars_123456789012345678901234567890 (
|
||||
id int(10) unsigned NOT NULL,
|
||||
id2 int(10) unsigned NOT NULL,
|
||||
PRIMARY KEY ( id, id2 )
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC
|
||||
PARTITION BY RANGE ( id )
|
||||
SUBPARTITION BY HASH ( id2 )
|
||||
SUBPARTITIONS 2 (
|
||||
PARTITION test_jfg_partition_name_with_60_chars_1234567890123456789012 VALUES LESS THAN (1000) ENGINE = InnoDB,
|
||||
PARTITION pmax VALUES LESS THAN MAXVALUE ENGINE = InnoDB);
|
||||
Warnings:
|
||||
Warning 1478 InnoDB: ROW_FORMAT=DYNAMIC requires innodb_file_per_table.
|
||||
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
|
||||
Warning 1478 InnoDB: ROW_FORMAT=DYNAMIC requires innodb_file_per_table.
|
||||
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
|
||||
Warning 1478 InnoDB: ROW_FORMAT=DYNAMIC requires innodb_file_per_table.
|
||||
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
|
||||
Warning 1478 InnoDB: ROW_FORMAT=DYNAMIC requires innodb_file_per_table.
|
||||
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
|
||||
CREATE TABLE mysqltest1.éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé (
|
||||
id int(10) unsigned NOT NULL,
|
||||
id2 int(10) unsigned NOT NULL,
|
||||
PRIMARY KEY ( id, id2 )
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC
|
||||
PARTITION BY RANGE ( id )
|
||||
SUBPARTITION BY HASH ( id2 )
|
||||
SUBPARTITIONS 2 (
|
||||
PARTITION çççççççççççççççççççççççççççççççççççççççççççççççççççççççççççç VALUES LESS THAN (1000) ENGINE = InnoDB,
|
||||
PARTITION pmax VALUES LESS THAN MAXVALUE ENGINE = InnoDB);
|
||||
ERROR HY000: The path specified for @0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@0n@ is too long.
|
||||
drop database mysqltest1;
|
29
mysql-test/suite/parts/t/longname.test
Normal file
29
mysql-test/suite/parts/t/longname.test
Normal file
@ -0,0 +1,29 @@
|
||||
source include/have_innodb.inc;
|
||||
source include/have_partition.inc;
|
||||
set names utf8;
|
||||
|
||||
create database mysqltest1;
|
||||
CREATE TABLE mysqltest1.test_jfg_table_name_with_64_chars_123456789012345678901234567890 (
|
||||
id int(10) unsigned NOT NULL,
|
||||
id2 int(10) unsigned NOT NULL,
|
||||
PRIMARY KEY ( id, id2 )
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC
|
||||
PARTITION BY RANGE ( id )
|
||||
SUBPARTITION BY HASH ( id2 )
|
||||
SUBPARTITIONS 2 (
|
||||
PARTITION test_jfg_partition_name_with_60_chars_1234567890123456789012 VALUES LESS THAN (1000) ENGINE = InnoDB,
|
||||
PARTITION pmax VALUES LESS THAN MAXVALUE ENGINE = InnoDB);
|
||||
|
||||
--error ER_PATH_LENGTH
|
||||
CREATE TABLE mysqltest1.éééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééééé (
|
||||
id int(10) unsigned NOT NULL,
|
||||
id2 int(10) unsigned NOT NULL,
|
||||
PRIMARY KEY ( id, id2 )
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC
|
||||
PARTITION BY RANGE ( id )
|
||||
SUBPARTITION BY HASH ( id2 )
|
||||
SUBPARTITIONS 2 (
|
||||
PARTITION çççççççççççççççççççççççççççççççççççççççççççççççççççççççççççç VALUES LESS THAN (1000) ENGINE = InnoDB,
|
||||
PARTITION pmax VALUES LESS THAN MAXVALUE ENGINE = InnoDB);
|
||||
|
||||
drop database mysqltest1;
|
@ -634,7 +634,7 @@ int ha_partition::create(const char *name, TABLE *table_arg,
|
||||
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;
|
||||
@ -667,9 +667,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)))
|
||||
@ -680,15 +682,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;
|
||||
@ -724,8 +730,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;
|
||||
@ -767,10 +773,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;
|
||||
@ -783,16 +790,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();
|
||||
@ -835,10 +846,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++];
|
||||
@ -850,10 +862,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,
|
||||
@ -867,32 +880,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);
|
||||
@ -1488,7 +1505,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;
|
||||
@ -1698,10 +1715,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,
|
||||
@ -1719,9 +1740,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],
|
||||
@ -1980,8 +2006,8 @@ int ha_partition::del_ren_cre_table(const char *from,
|
||||
{
|
||||
int save_error= 0;
|
||||
int error= HA_ERR_INTERNAL_ERROR;
|
||||
char from_buff[FN_REFLEN], to_buff[FN_REFLEN], from_lc_buff[FN_REFLEN],
|
||||
to_lc_buff[FN_REFLEN], buff[FN_REFLEN];
|
||||
char from_buff[FN_REFLEN + 1], to_buff[FN_REFLEN + 1],
|
||||
from_lc_buff[FN_REFLEN], to_lc_buff[FN_REFLEN], buff[FN_REFLEN];
|
||||
char *name_buffer_ptr;
|
||||
const char *from_path;
|
||||
const char *to_path= NULL;
|
||||
@ -2028,13 +2054,15 @@ int ha_partition::del_ren_cre_table(const char *from,
|
||||
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;
|
||||
@ -2081,9 +2109,9 @@ create_error:
|
||||
name_buffer_ptr= m_name_buffer_ptr;
|
||||
for (abort_file= file, file= m_file; file < abort_file; file++)
|
||||
{
|
||||
create_partition_name(from_buff, from_path, name_buffer_ptr, NORMAL_PART_NAME,
|
||||
FALSE);
|
||||
(void) (*file)->ha_delete_table((const char*) from_buff);
|
||||
if (!create_partition_name(from_buff, sizeof(from_buff), from_path,
|
||||
name_buffer_ptr, NORMAL_PART_NAME, FALSE))
|
||||
(void) (*file)->ha_delete_table(from_buff);
|
||||
name_buffer_ptr= strend(name_buffer_ptr) + 1;
|
||||
}
|
||||
DBUG_RETURN(error);
|
||||
@ -2092,12 +2120,11 @@ 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))
|
||||
(void) (*file)->ha_rename_table(to_buff, from_buff);
|
||||
name_buffer_ptr= strend(name_buffer_ptr) + 1;
|
||||
}
|
||||
DBUG_RETURN(error);
|
||||
@ -2895,7 +2922,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];
|
||||
bool is_not_tmp_table= (table_share->tmp_table == NO_TMP_TABLE);
|
||||
ulonglong check_table_flags;
|
||||
DBUG_ENTER("ha_partition::open");
|
||||
@ -2965,8 +2992,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;
|
||||
if (!(m_file[i]= file[i]->clone(name_buff, m_clone_mem_root)))
|
||||
{
|
||||
error= HA_ERR_INITIALIZATION;
|
||||
@ -2981,8 +3009,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)))
|
||||
goto err_handler;
|
||||
|
@ -5882,8 +5882,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;
|
||||
@ -5907,14 +5907,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)
|
||||
@ -5935,12 +5936,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)
|
||||
@ -5979,7 +5981,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;
|
||||
@ -6018,10 +6020,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))
|
||||
{
|
||||
@ -6037,9 +6039,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))
|
||||
{
|
||||
@ -8117,31 +8120,41 @@ static uint32 get_next_subpartition_via_walking(PARTITION_ITERATOR *part_iter)
|
||||
|
||||
}
|
||||
|
||||
/* 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)
|
||||
{
|
||||
@ -8151,11 +8164,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;
|
||||
}
|
||||
|
||||
|
||||
@ -8164,37 +8183,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)
|
||||
|
@ -274,12 +274,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,
|
||||
|
Loading…
x
Reference in New Issue
Block a user