1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch '5.5' into 10.0

Browse Source
This commit is contained in:
Sergei Golubchik 2017-07-06 23:47:33 +02:00
commit 89dc445a55
23 changed files with 465 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
mysql-test/r/subselect.result
View File

@ -7147,3 +7147,25 @@ SELECT * FROM t1 WHERE f2 <= SOME ( SELECT f1 FROM t1 );
f1 f2 f1 f2
foo bar foo bar
DROP TABLE t1; DROP TABLE t1;
#
# MDEV-10146: Wrong result (or questionable result and behavior)
# with aggregate function in uncorrelated SELECT subquery
#
CREATE TABLE t1 (f1 INT);
CREATE VIEW v1 AS SELECT * FROM t1;
INSERT INTO t1 VALUES (1),(2);
CREATE TABLE t2 (f2 int);
INSERT INTO t2 VALUES (3);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
( SELECT MAX(f1) FROM t2 )
2
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
( SELECT MAX(f1) FROM t2 )
2
INSERT INTO t2 VALUES (4);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
ERROR 21000: Subquery returns more than 1 row
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
ERROR 21000: Subquery returns more than 1 row
drop view v1;
drop table t1,t2;

22
mysql-test/r/subselect_no_mat.result
View File

@ -7140,6 +7140,28 @@ SELECT * FROM t1 WHERE f2 <= SOME ( SELECT f1 FROM t1 );
f1 f2 f1 f2
foo bar foo bar
DROP TABLE t1; DROP TABLE t1;
#
# MDEV-10146: Wrong result (or questionable result and behavior)
# with aggregate function in uncorrelated SELECT subquery
#
CREATE TABLE t1 (f1 INT);
CREATE VIEW v1 AS SELECT * FROM t1;
INSERT INTO t1 VALUES (1),(2);
CREATE TABLE t2 (f2 int);
INSERT INTO t2 VALUES (3);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
( SELECT MAX(f1) FROM t2 )
2
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
( SELECT MAX(f1) FROM t2 )
2
INSERT INTO t2 VALUES (4);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
ERROR 21000: Subquery returns more than 1 row
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
ERROR 21000: Subquery returns more than 1 row
drop view v1;
drop table t1,t2;
set optimizer_switch=default; set optimizer_switch=default;
select @@optimizer_switch like '%materialization=on%'; select @@optimizer_switch like '%materialization=on%';
@@optimizer_switch like '%materialization=on%' @@optimizer_switch like '%materialization=on%'

22
mysql-test/r/subselect_no_opts.result
View File

@ -7138,4 +7138,26 @@ SELECT * FROM t1 WHERE f2 <= SOME ( SELECT f1 FROM t1 );
f1 f2 f1 f2
foo bar foo bar
DROP TABLE t1; DROP TABLE t1;
#
# MDEV-10146: Wrong result (or questionable result and behavior)
# with aggregate function in uncorrelated SELECT subquery
#
CREATE TABLE t1 (f1 INT);
CREATE VIEW v1 AS SELECT * FROM t1;
INSERT INTO t1 VALUES (1),(2);
CREATE TABLE t2 (f2 int);
INSERT INTO t2 VALUES (3);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
( SELECT MAX(f1) FROM t2 )
2
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
( SELECT MAX(f1) FROM t2 )
2
INSERT INTO t2 VALUES (4);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
ERROR 21000: Subquery returns more than 1 row
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
ERROR 21000: Subquery returns more than 1 row
drop view v1;
drop table t1,t2;
set @optimizer_switch_for_subselect_test=null; set @optimizer_switch_for_subselect_test=null;

22
mysql-test/r/subselect_no_scache.result
View File

@ -7153,6 +7153,28 @@ SELECT * FROM t1 WHERE f2 <= SOME ( SELECT f1 FROM t1 );
f1 f2 f1 f2
foo bar foo bar
DROP TABLE t1; DROP TABLE t1;
#
# MDEV-10146: Wrong result (or questionable result and behavior)
# with aggregate function in uncorrelated SELECT subquery
#
CREATE TABLE t1 (f1 INT);
CREATE VIEW v1 AS SELECT * FROM t1;
INSERT INTO t1 VALUES (1),(2);
CREATE TABLE t2 (f2 int);
INSERT INTO t2 VALUES (3);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
( SELECT MAX(f1) FROM t2 )
2
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
( SELECT MAX(f1) FROM t2 )
2
INSERT INTO t2 VALUES (4);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
ERROR 21000: Subquery returns more than 1 row
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
ERROR 21000: Subquery returns more than 1 row
drop view v1;
drop table t1,t2;
set optimizer_switch=default; set optimizer_switch=default;
select @@optimizer_switch like '%subquery_cache=on%'; select @@optimizer_switch like '%subquery_cache=on%';
@@optimizer_switch like '%subquery_cache=on%' @@optimizer_switch like '%subquery_cache=on%'

22
mysql-test/r/subselect_no_semijoin.result
View File

@ -7138,5 +7138,27 @@ SELECT * FROM t1 WHERE f2 <= SOME ( SELECT f1 FROM t1 );
f1 f2 f1 f2
foo bar foo bar
DROP TABLE t1; DROP TABLE t1;
#
# MDEV-10146: Wrong result (or questionable result and behavior)
# with aggregate function in uncorrelated SELECT subquery
#
CREATE TABLE t1 (f1 INT);
CREATE VIEW v1 AS SELECT * FROM t1;
INSERT INTO t1 VALUES (1),(2);
CREATE TABLE t2 (f2 int);
INSERT INTO t2 VALUES (3);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
( SELECT MAX(f1) FROM t2 )
2
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
( SELECT MAX(f1) FROM t2 )
2
INSERT INTO t2 VALUES (4);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
ERROR 21000: Subquery returns more than 1 row
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
ERROR 21000: Subquery returns more than 1 row
drop view v1;
drop table t1,t2;
set @optimizer_switch_for_subselect_test=null; set @optimizer_switch_for_subselect_test=null;
set @join_cache_level_for_subselect_test=NULL; set @join_cache_level_for_subselect_test=NULL;

37
mysql-test/suite/parts/r/longname.result Normal file
View File

@ -0,0 +1,37 @@
set names utf8;
create database mysqltest1;
select database_name, table_name, length(table_name) from mysql.innodb_table_stats where database_name = 'mysqltest1';
database_name table_name length(table_name)
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_format > Antelope.
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
Warning 1478 InnoDB: ROW_FORMAT=DYNAMIC requires innodb_file_format > Antelope.
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
Warning 1478 InnoDB: ROW_FORMAT=DYNAMIC requires innodb_file_format > Antelope.
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
Warning 1478 InnoDB: ROW_FORMAT=DYNAMIC requires innodb_file_format > Antelope.
Warning 1478 InnoDB: assuming ROW_FORMAT=COMPACT.
select database_name, table_name, length(table_name) from mysql.innodb_table_stats where database_name = 'mysqltest1';
database_name table_name length(table_name)
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;

32
mysql-test/suite/parts/t/longname.test Normal file
View File

@ -0,0 +1,32 @@
source include/have_innodb.inc;
source include/have_partition.inc;
set names utf8;
create database mysqltest1;
select database_name, table_name, length(table_name) from mysql.innodb_table_stats where database_name = '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);
select database_name, table_name, length(table_name) from mysql.innodb_table_stats where database_name = 'mysqltest1';
--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;

25
mysql-test/t/subselect.test
View File

@ -6021,3 +6021,28 @@ INSERT INTO t1 VALUES ('foo','bar');
SELECT * FROM t1 WHERE f2 >= SOME ( SELECT f1 FROM t1 ); SELECT * FROM t1 WHERE f2 >= SOME ( SELECT f1 FROM t1 );
SELECT * FROM t1 WHERE f2 <= SOME ( SELECT f1 FROM t1 ); SELECT * FROM t1 WHERE f2 <= SOME ( SELECT f1 FROM t1 );
DROP TABLE t1; DROP TABLE t1;
--echo #
--echo # MDEV-10146: Wrong result (or questionable result and behavior)
--echo # with aggregate function in uncorrelated SELECT subquery
--echo #
CREATE TABLE t1 (f1 INT);
CREATE VIEW v1 AS SELECT * FROM t1;
INSERT INTO t1 VALUES (1),(2);
CREATE TABLE t2 (f2 int);
INSERT INTO t2 VALUES (3);
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
INSERT INTO t2 VALUES (4);
--error ER_SUBQUERY_NO_1_ROW
SELECT ( SELECT MAX(f1) FROM t2 ) FROM v1;
--error ER_SUBQUERY_NO_1_ROW
SELECT ( SELECT MAX(f1) FROM t2 ) FROM t1;
drop view v1;
drop table t1,t2;

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) HA_CREATE_INFO *create_info)
{ {
int error; 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; char *name_buffer_ptr;
const char *path; const char *path;
uint i; 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++) for (j= 0; j < m_part_info->num_subparts; j++)
{ {
part_elem= sub_it++; part_elem= sub_it++;
create_partition_name(name_buff, path, name_buffer_ptr, if ((error= create_partition_name(name_buff, sizeof(name_buff), path,
NORMAL_PART_NAME, FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto create_error;
if ((error= set_up_table_before_create(table_arg, name_buff, if ((error= set_up_table_before_create(table_arg, name_buff,
create_info, part_elem)) || create_info, part_elem)) ||
((error= (*file)->ha_create(name_buff, table_arg, create_info)))) ((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 else
{ {
create_partition_name(name_buff, path, name_buffer_ptr, if ((error= create_partition_name(name_buff, sizeof(name_buff), path,
NORMAL_PART_NAME, FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto create_error;
if ((error= set_up_table_before_create(table_arg, name_buff, if ((error= set_up_table_before_create(table_arg, name_buff,
create_info, part_elem)) || create_info, part_elem)) ||
((error= (*file)->ha_create(name_buff, table_arg, create_info)))) ((error= (*file)->ha_create(name_buff, table_arg, create_info))))
@ -746,9 +748,9 @@ create_error:
name_buffer_ptr= m_name_buffer_ptr; name_buffer_ptr= m_name_buffer_ptr;
for (abort_file= file, file= m_file; file < abort_file; file++) for (abort_file= file, file= m_file; file < abort_file; file++)
{ {
create_partition_name(name_buff, path, name_buffer_ptr, NORMAL_PART_NAME, if (!create_partition_name(name_buff, sizeof(name_buff), path,
FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE))
(void) (*file)->ha_delete_table((const char*) name_buff); (void) (*file)->ha_delete_table((const char*) name_buff);
name_buffer_ptr= strend(name_buffer_ptr) + 1; name_buffer_ptr= strend(name_buffer_ptr) + 1;
} }
handler::delete_table(name); handler::delete_table(name);
@ -775,7 +777,7 @@ create_error:
int ha_partition::drop_partitions(const char *path) int ha_partition::drop_partitions(const char *path)
{ {
List_iterator<partition_element> part_it(m_part_info->partitions); 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_parts= m_part_info->partitions.elements;
uint num_subparts= m_part_info->num_subparts; uint num_subparts= m_part_info->num_subparts;
uint i= 0; uint i= 0;
@ -808,9 +810,11 @@ int ha_partition::drop_partitions(const char *path)
{ {
partition_element *sub_elem= sub_it++; partition_element *sub_elem= sub_it++;
part= i * num_subparts + j; part= i * num_subparts + j;
create_subpartition_name(part_name_buff, path, if ((ret_error= create_subpartition_name(part_name_buff,
part_elem->partition_name, sizeof(part_name_buff), path,
sub_elem->partition_name, name_variant); part_elem->partition_name,
sub_elem->partition_name, name_variant)))
error= ret_error;
file= m_file[part]; file= m_file[part];
DBUG_PRINT("info", ("Drop subpartition %s", part_name_buff)); DBUG_PRINT("info", ("Drop subpartition %s", part_name_buff));
if ((ret_error= file->ha_delete_table(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 else
{ {
create_partition_name(part_name_buff, path, if ((ret_error= create_partition_name(part_name_buff,
part_elem->partition_name, name_variant, sizeof(part_name_buff), path,
TRUE); 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)))
error= ret_error; error= ret_error;
if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos)) else
error= 1; {
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) if (part_elem->part_state == PART_IS_CHANGED)
part_elem->part_state= PART_NORMAL; 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> part_it(m_part_info->partitions);
List_iterator<partition_element> temp_it(m_part_info->temp_partitions); List_iterator<partition_element> temp_it(m_part_info->temp_partitions);
char part_name_buff[FN_REFLEN]; char part_name_buff[FN_REFLEN + 1];
char norm_name_buff[FN_REFLEN]; char norm_name_buff[FN_REFLEN + 1];
uint num_parts= m_part_info->partitions.elements; uint num_parts= m_part_info->partitions.elements;
uint part_count= 0; uint part_count= 0;
uint num_subparts= m_part_info->num_subparts; uint num_subparts= m_part_info->num_subparts;
@ -908,10 +916,11 @@ int ha_partition::rename_partitions(const char *path)
{ {
sub_elem= sub_it++; sub_elem= sub_it++;
file= m_reorged_file[part_count++]; file= m_reorged_file[part_count++];
create_subpartition_name(norm_name_buff, path, if ((ret_error= create_subpartition_name(norm_name_buff,
part_elem->partition_name, sizeof(norm_name_buff), path,
sub_elem->partition_name, part_elem->partition_name,
NORMAL_PART_NAME); sub_elem->partition_name, NORMAL_PART_NAME)))
error= ret_error;
DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff)); DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff));
if ((ret_error= file->ha_delete_table(norm_name_buff))) if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error; error= ret_error;
@ -924,16 +933,20 @@ int ha_partition::rename_partitions(const char *path)
else else
{ {
file= m_reorged_file[part_count++]; file= m_reorged_file[part_count++];
create_partition_name(norm_name_buff, path, if ((ret_error= create_partition_name(norm_name_buff,
part_elem->partition_name, NORMAL_PART_NAME, sizeof(norm_name_buff), path,
TRUE); 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)))
error= ret_error; error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1;
else 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); } while (++i < temp_partitions);
(void) sync_ddl_log(); (void) sync_ddl_log();
@ -976,10 +989,11 @@ int ha_partition::rename_partitions(const char *path)
{ {
sub_elem= sub_it++; sub_elem= sub_it++;
part= i * num_subparts + j; part= i * num_subparts + j;
create_subpartition_name(norm_name_buff, path, if ((ret_error= create_subpartition_name(norm_name_buff,
part_elem->partition_name, sizeof(norm_name_buff), path,
sub_elem->partition_name, part_elem->partition_name,
NORMAL_PART_NAME); sub_elem->partition_name, NORMAL_PART_NAME)))
error= ret_error;
if (part_elem->part_state == PART_IS_CHANGED) if (part_elem->part_state == PART_IS_CHANGED)
{ {
file= m_reorged_file[part_count++]; file= m_reorged_file[part_count++];
@ -991,10 +1005,11 @@ int ha_partition::rename_partitions(const char *path)
(void) sync_ddl_log(); (void) sync_ddl_log();
} }
file= m_new_file[part]; file= m_new_file[part];
create_subpartition_name(part_name_buff, path, if ((ret_error= create_subpartition_name(part_name_buff,
part_elem->partition_name, sizeof(part_name_buff), path,
sub_elem->partition_name, part_elem->partition_name,
TEMP_PART_NAME); sub_elem->partition_name, TEMP_PART_NAME)))
error= ret_error;
DBUG_PRINT("info", ("Rename subpartition from %s to %s", DBUG_PRINT("info", ("Rename subpartition from %s to %s",
part_name_buff, norm_name_buff)); part_name_buff, norm_name_buff));
if ((ret_error= file->ha_rename_table(part_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 else
{ {
create_partition_name(norm_name_buff, path, if ((ret_error= create_partition_name(norm_name_buff,
part_elem->partition_name, NORMAL_PART_NAME, sizeof(norm_name_buff), path,
TRUE); part_elem->partition_name, NORMAL_PART_NAME, TRUE)) ||
if (part_elem->part_state == PART_IS_CHANGED) (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++]; if (part_elem->part_state == PART_IS_CHANGED)
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff)); {
if ((ret_error= file->ha_delete_table(norm_name_buff))) 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; error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos)) else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1; 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); } 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> part_it(m_part_info->partitions);
List_iterator <partition_element> t_it(m_part_info->temp_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_parts= m_part_info->partitions.elements;
uint num_subparts= m_part_info->num_subparts; uint num_subparts= m_part_info->num_subparts;
uint i= 0; uint i= 0;
@ -1877,10 +1896,14 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
do do
{ {
partition_element *sub_elem= sub_it++; partition_element *sub_elem= sub_it++;
create_subpartition_name(part_name_buff, path, if ((error= create_subpartition_name(part_name_buff,
part_elem->partition_name, sizeof(part_name_buff), path,
sub_elem->partition_name, part_elem->partition_name, sub_elem->partition_name,
name_variant); name_variant)))
{
cleanup_new_partition(part_count);
DBUG_RETURN(error);
}
part= i * num_subparts + j; part= i * num_subparts + j;
DBUG_PRINT("info", ("Add subpartition %s", part_name_buff)); DBUG_PRINT("info", ("Add subpartition %s", part_name_buff));
if ((error= prepare_new_partition(table, create_info, if ((error= prepare_new_partition(table, create_info,
@ -1898,9 +1921,14 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
} }
else else
{ {
create_partition_name(part_name_buff, path, if ((error= create_partition_name(part_name_buff,
part_elem->partition_name, name_variant, sizeof(part_name_buff), path, part_elem->partition_name,
TRUE); name_variant, TRUE)))
{
cleanup_new_partition(part_count);
DBUG_RETURN(error);
}
DBUG_PRINT("info", ("Add partition %s", part_name_buff)); DBUG_PRINT("info", ("Add partition %s", part_name_buff));
if ((error= prepare_new_partition(table, create_info, if ((error= prepare_new_partition(table, create_info,
new_file_array[i], new_file_array[i],
@ -2271,8 +2299,8 @@ uint ha_partition::del_ren_table(const char *from, const char *to)
{ {
int save_error= 0; int save_error= 0;
int error; int error;
char from_buff[FN_REFLEN], to_buff[FN_REFLEN], from_lc_buff[FN_REFLEN], char from_buff[FN_REFLEN + 1], to_buff[FN_REFLEN + 1],
to_lc_buff[FN_REFLEN]; from_lc_buff[FN_REFLEN], to_lc_buff[FN_REFLEN];
char *name_buffer_ptr; char *name_buffer_ptr;
const char *from_path; const char *from_path;
const char *to_path= NULL; const char *to_path= NULL;
@ -2308,13 +2336,15 @@ uint ha_partition::del_ren_table(const char *from, const char *to)
i= 0; i= 0;
do do
{ {
create_partition_name(from_buff, from_path, name_buffer_ptr, if ((error= create_partition_name(from_buff, sizeof(from_buff), from_path,
NORMAL_PART_NAME, FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto rename_error;
if (to != NULL) if (to != NULL)
{ // Rename branch { // Rename branch
create_partition_name(to_buff, to_path, name_buffer_ptr, if ((error= create_partition_name(to_buff, sizeof(to_buff), to_path,
NORMAL_PART_NAME, FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto rename_error;
error= (*file)->ha_rename_table(from_buff, to_buff); error= (*file)->ha_rename_table(from_buff, to_buff);
if (error) if (error)
goto rename_error; goto rename_error;
@ -2343,12 +2373,14 @@ rename_error:
for (abort_file= file, file= m_file; file < abort_file; file++) for (abort_file= file, file= m_file; file < abort_file; file++)
{ {
/* Revert the rename, back from 'to' to the original 'from' */ /* Revert the rename, back from 'to' to the original 'from' */
create_partition_name(from_buff, from_path, name_buffer_ptr, if (!create_partition_name(from_buff, sizeof(from_buff), from_path,
NORMAL_PART_NAME, FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE) &&
create_partition_name(to_buff, to_path, name_buffer_ptr, !create_partition_name(to_buff, sizeof(to_buff), to_path,
NORMAL_PART_NAME, FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE))
/* Ignore error here */ {
(void) (*file)->ha_rename_table(to_buff, from_buff); /* Ignore error here */
(void) (*file)->ha_rename_table(to_buff, from_buff);
}
name_buffer_ptr= strend(name_buffer_ptr) + 1; name_buffer_ptr= strend(name_buffer_ptr) + 1;
} }
DBUG_RETURN(error); DBUG_RETURN(error);
@ -3415,7 +3447,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
char *name_buffer_ptr; char *name_buffer_ptr;
int error= HA_ERR_INITIALIZATION; int error= HA_ERR_INITIALIZATION;
handler **file; handler **file;
char name_buff[FN_REFLEN]; char name_buff[FN_REFLEN + 1];
ulonglong check_table_flags; ulonglong check_table_flags;
DBUG_ENTER("ha_partition::open"); DBUG_ENTER("ha_partition::open");
@ -3469,8 +3501,9 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
file= m_is_clone_of->m_file; file= m_is_clone_of->m_file;
for (i= 0; i < m_tot_parts; i++) for (i= 0; i < m_tot_parts; i++)
{ {
create_partition_name(name_buff, name, name_buffer_ptr, NORMAL_PART_NAME, if ((error= create_partition_name(name_buff, sizeof(name_buff), name,
FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto err_handler;
/* ::clone() will also set ha_share from the original. */ /* ::clone() will also set ha_share from the original. */
if (!(m_file[i]= file[i]->clone(name_buff, m_clone_mem_root))) if (!(m_file[i]= file[i]->clone(name_buff, m_clone_mem_root)))
{ {
@ -3486,8 +3519,9 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
file= m_file; file= m_file;
do do
{ {
create_partition_name(name_buff, name, name_buffer_ptr, NORMAL_PART_NAME, if ((error= create_partition_name(name_buff, sizeof(name_buff), name,
FALSE); name_buffer_ptr, NORMAL_PART_NAME, FALSE)))
goto err_handler;
table->s->connect_string = m_connect_string[(uint)(file-m_file)]; table->s->connect_string = m_connect_string[(uint)(file-m_file)];
if ((error= (*file)->ha_open(table, name_buff, mode, if ((error= (*file)->ha_open(table, name_buff, mode,
test_if_locked | HA_OPEN_NO_PSI_CALL))) test_if_locked | HA_OPEN_NO_PSI_CALL)))

7
sql/item.cc
View File

@ -4988,6 +4988,13 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ? ((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
(Item_ident*) (*reference) : (Item_ident*) (*reference) :
0)); 0));
if (thd->lex->in_sum_func &&
thd->lex->in_sum_func->nest_level >= select->nest_level)
{
Item::Type ref_type= (*reference)->type();
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 A reference to a view field had been found and we
substituted it instead of this Item (find_field_in_tables substituted it instead of this Item (find_field_in_tables

2
sql/item_timefunc.cc
View File

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

14
sql/partition_info.cc
View File

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

5
sql/partition_info.h
View File

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

2
sql/sql_class.cc
View File

@ -3874,7 +3874,7 @@ void Security_context::destroy()
if (external_user) if (external_user)
{ {
my_free(external_user); my_free(external_user);
user= NULL; external_user= NULL;
} }
my_free(ip); my_free(ip);

118
sql/sql_partition.cc
View File

@ -5988,8 +5988,8 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
DDL_LOG_ENTRY ddl_log_entry; DDL_LOG_ENTRY ddl_log_entry;
partition_info *part_info= lpt->part_info; partition_info *part_info= lpt->part_info;
DDL_LOG_MEMORY_ENTRY *log_entry; DDL_LOG_MEMORY_ENTRY *log_entry;
char tmp_path[FN_REFLEN]; char tmp_path[FN_REFLEN + 1];
char normal_path[FN_REFLEN]; char normal_path[FN_REFLEN + 1];
List_iterator<partition_element> part_it(part_info->partitions); List_iterator<partition_element> part_it(part_info->partitions);
uint temp_partitions= part_info->temp_partitions.elements; uint temp_partitions= part_info->temp_partitions.elements;
uint num_elements= part_info->partitions.elements; uint num_elements= part_info->partitions.elements;
@ -6013,14 +6013,15 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry; ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name= ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(sub_elem->engine_type); ha_resolve_storage_engine_name(sub_elem->engine_type);
create_subpartition_name(tmp_path, path, if (create_subpartition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name, part_elem->partition_name,
sub_elem->partition_name, sub_elem->partition_name,
TEMP_PART_NAME); TEMP_PART_NAME) ||
create_subpartition_name(normal_path, path, create_subpartition_name(normal_path, sizeof(normal_path), path,
part_elem->partition_name, part_elem->partition_name,
sub_elem->partition_name, sub_elem->partition_name,
NORMAL_PART_NAME); NORMAL_PART_NAME))
DBUG_RETURN(TRUE);
ddl_log_entry.name= normal_path; ddl_log_entry.name= normal_path;
ddl_log_entry.from_name= tmp_path; ddl_log_entry.from_name= tmp_path;
if (part_elem->part_state == PART_IS_CHANGED) if (part_elem->part_state == PART_IS_CHANGED)
@ -6041,12 +6042,13 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry; ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name= ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(part_elem->engine_type); ha_resolve_storage_engine_name(part_elem->engine_type);
create_partition_name(tmp_path, path, if (create_partition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name, part_elem->partition_name, TEMP_PART_NAME,
TEMP_PART_NAME, TRUE); TRUE) ||
create_partition_name(normal_path, path, create_partition_name(normal_path, sizeof(normal_path), path,
part_elem->partition_name, part_elem->partition_name, NORMAL_PART_NAME,
NORMAL_PART_NAME, TRUE); TRUE))
DBUG_RETURN(TRUE);
ddl_log_entry.name= normal_path; ddl_log_entry.name= normal_path;
ddl_log_entry.from_name= tmp_path; ddl_log_entry.from_name= tmp_path;
if (part_elem->part_state == PART_IS_CHANGED) if (part_elem->part_state == PART_IS_CHANGED)
@ -6085,7 +6087,7 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
DDL_LOG_ENTRY ddl_log_entry; DDL_LOG_ENTRY ddl_log_entry;
partition_info *part_info= lpt->part_info; partition_info *part_info= lpt->part_info;
DDL_LOG_MEMORY_ENTRY *log_entry; 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> part_it(part_info->partitions);
List_iterator<partition_element> temp_it(part_info->temp_partitions); List_iterator<partition_element> temp_it(part_info->temp_partitions);
uint num_temp_partitions= part_info->temp_partitions.elements; uint num_temp_partitions= part_info->temp_partitions.elements;
@ -6124,10 +6126,10 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry; ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name= ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(sub_elem->engine_type); ha_resolve_storage_engine_name(sub_elem->engine_type);
create_subpartition_name(tmp_path, path, if (create_subpartition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name, part_elem->partition_name,
sub_elem->partition_name, sub_elem->partition_name, name_variant))
name_variant); DBUG_RETURN(TRUE);
ddl_log_entry.name= tmp_path; ddl_log_entry.name= tmp_path;
if (write_ddl_log_entry(&ddl_log_entry, &log_entry)) if (write_ddl_log_entry(&ddl_log_entry, &log_entry))
{ {
@ -6143,9 +6145,10 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
ddl_log_entry.next_entry= *next_entry; ddl_log_entry.next_entry= *next_entry;
ddl_log_entry.handler_name= ddl_log_entry.handler_name=
ha_resolve_storage_engine_name(part_elem->engine_type); ha_resolve_storage_engine_name(part_elem->engine_type);
create_partition_name(tmp_path, path, if (create_partition_name(tmp_path, sizeof(tmp_path), path,
part_elem->partition_name, part_elem->partition_name, name_variant,
name_variant, TRUE); TRUE))
DBUG_RETURN(TRUE);
ddl_log_entry.name= tmp_path; ddl_log_entry.name= tmp_path;
if (write_ddl_log_entry(&ddl_log_entry, &log_entry)) if (write_ddl_log_entry(&ddl_log_entry, &log_entry))
{ {
@ -8257,31 +8260,41 @@ static uint32 get_next_subpartition_via_walking(PARTITION_ITERATOR *part_iter)
return res; 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 Create partition names
SYNOPSIS SYNOPSIS
create_partition_name() 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 in1 First part
in2 Second part in2 Second part
name_variant Normal, temporary or renamed partition name name_variant Normal, temporary or renamed partition name
RETURN VALUE RETURN VALUE
NONE 0 if ok, error if name too long
DESCRIPTION DESCRIPTION
This method is used to calculate the partition name, service routine to This method is used to calculate the partition name, service routine to
the del_ren_cre_table method. the del_ren_cre_table method.
*/ */
void create_partition_name(char *out, const char *in1, int create_partition_name(char *out, size_t outlen, const char *in1,
const char *in2, uint name_variant, const char *in2, uint name_variant, bool translate)
bool translate)
{ {
char transl_part_name[FN_REFLEN]; 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) if (translate)
{ {
@ -8291,11 +8304,17 @@ void create_partition_name(char *out, const char *in1,
else else
transl_part= in2; transl_part= in2;
if (name_variant == NORMAL_PART_NAME) 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) 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) 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;
} }
@ -8304,37 +8323,46 @@ void create_partition_name(char *out, const char *in1,
SYNOPSIS SYNOPSIS
create_subpartition_name() 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 in1 First part
in2 Second part in2 Second part
in3 Third part in3 Third part
name_variant Normal, temporary or renamed partition name name_variant Normal, temporary or renamed partition name
RETURN VALUE RETURN VALUE
NONE 0 if ok, error if name too long
DESCRIPTION DESCRIPTION
This method is used to calculate the subpartition name, service routine to This method is used to calculate the subpartition name, service routine to
the del_ren_cre_table method. the del_ren_cre_table method.
*/ */
void create_subpartition_name(char *out, const char *in1, int create_subpartition_name(char *out, size_t outlen,
const char *in2, const char *in3, const char *in1, const char *in2,
uint name_variant) 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(in2, transl_part_name, FN_REFLEN);
tablename_to_filename(in3, transl_subpart_name, FN_REFLEN); tablename_to_filename(in3, transl_subpart_name, FN_REFLEN);
if (name_variant == NORMAL_PART_NAME) if (name_variant == NORMAL_PART_NAME)
strxmov(out, in1, "#P#", transl_part_name, end= strxnmov(out, outlen-1, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, NullS); "#SP#", transl_subpart_name, NullS);
else if (name_variant == TEMP_PART_NAME) else if (name_variant == TEMP_PART_NAME)
strxmov(out, in1, "#P#", transl_part_name, end= strxnmov(out, outlen-1, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, "#TMP#", NullS); "#SP#", transl_subpart_name, "#TMP#", NullS);
else if (name_variant == RENAMED_PART_NAME) else if (name_variant == RENAMED_PART_NAME)
strxmov(out, in1, "#P#", transl_part_name, end= strxnmov(out, outlen-1, in1, "#P#", transl_part_name,
"#SP#", transl_subpart_name, "#REN#", NullS); "#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) uint get_partition_field_store_length(Field *field)

12
sql/sql_partition.h
View File

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

8
sql/sql_partition_admin.cc
View File

@ -491,7 +491,7 @@ bool Sql_cmd_alter_table_exchange_partition::
partition_element *part_elem; partition_element *part_elem;
char *partition_name; char *partition_name;
char temp_name[FN_REFLEN+1]; 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 swap_file_name[FN_REFLEN+1];
char temp_file_name[FN_REFLEN+1]; char temp_file_name[FN_REFLEN+1];
uint swap_part_id; uint swap_part_id;
@ -571,9 +571,9 @@ bool Sql_cmd_alter_table_exchange_partition::
temp_name, "", FN_IS_TMP); temp_name, "", FN_IS_TMP);
if (!(part_elem= part_table->part_info->get_part_elem(partition_name, if (!(part_elem= part_table->part_info->get_part_elem(partition_name,
part_file_name + part_file_name + part_file_name_len,
part_file_name_len, sizeof(part_file_name) - part_file_name_len,
&swap_part_id))) &swap_part_id)))
{ {
// my_error(ER_UNKNOWN_PARTITION, MYF(0), partition_name, // my_error(ER_UNKNOWN_PARTITION, MYF(0), partition_name,
// part_table->alias); // 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)) if (pipe(thread_group->shutdown_pipe))
{ {
DBUG_VOID_RETURN; goto end;
} }
/* Wake listener */ /* Wake listener */
if (io_poll_associate_fd(thread_group->pollfd, if (io_poll_associate_fd(thread_group->pollfd,
thread_group->shutdown_pipe[0], NULL)) 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. */ /* Wake all workers. */
while(wake_thread(thread_group) == 0) while(wake_thread(thread_group) == 0)
{ {
} }
end:
mysql_mutex_unlock(&thread_group->mutex); mysql_mutex_unlock(&thread_group->mutex);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;

1
storage/archive/ha_archive.cc
View File

@ -1690,7 +1690,6 @@ int ha_archive::info(uint flag)
stats.update_time= (ulong) file_stat.st_mtime; stats.update_time= (ulong) file_stat.st_mtime;
if (flag & HA_STATUS_CONST) if (flag & HA_STATUS_CONST)
{ {
stats.max_data_file_length= share->rows_recorded * stats.mean_rec_length;
stats.max_data_file_length= MAX_FILE_SIZE; stats.max_data_file_length= MAX_FILE_SIZE;
stats.create_time= (ulong) file_stat.st_ctime; stats.create_time= (ulong) file_stat.st_ctime;
} }

4
storage/maria/ma_loghandler.c
View File

@ -1270,6 +1270,7 @@ static my_bool translog_set_lsn_for_files(uint32 from_file, uint32 to_file,
mysql_file_close(fd, MYF(MY_WME)))) mysql_file_close(fd, MYF(MY_WME))))
{ {
translog_stop_writing(); translog_stop_writing();
mysql_mutex_unlock(&log_descriptor.file_header_lock);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
} }
@ -2294,10 +2295,11 @@ static void translog_set_only_in_buffers(TRANSLOG_ADDRESS in_buffers)
if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0) if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0)
{ {
if (translog_status != TRANSLOG_OK) if (translog_status != TRANSLOG_OK)
DBUG_VOID_RETURN; goto end;
log_descriptor.in_buffers_only= in_buffers; log_descriptor.in_buffers_only= in_buffers;
DBUG_PRINT("info", ("set new in_buffers_only")); DBUG_PRINT("info", ("set new in_buffers_only"));
} }
end:
mysql_mutex_unlock(&log_descriptor.sent_to_disk_lock); mysql_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }

1
storage/maria/ma_pagecache.c
View File

@ -3482,6 +3482,7 @@ restart:
lock_to_read[lock].unlock_lock, lock_to_read[lock].unlock_lock,
unlock_pin, FALSE)) unlock_pin, FALSE))
{ {
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_ASSERT(0); DBUG_ASSERT(0);
return (uchar*) 0; return (uchar*) 0;
} }

14
storage/mroonga/mrn_table.cpp
View File

@ -196,7 +196,7 @@ void mrn_get_partition_info(const char *table_name, uint table_name_length,
const TABLE *table, partition_element **part_elem, const TABLE *table, partition_element **part_elem,
partition_element **sub_elem) partition_element **sub_elem)
{ {
char tmp_name[FN_LEN]; char tmp_name[FN_REFLEN + 1];
partition_info *part_info = table->part_info; partition_info *part_info = table->part_info;
partition_element *tmp_part_elem = NULL, *tmp_sub_elem = NULL; partition_element *tmp_part_elem = NULL, *tmp_sub_elem = NULL;
bool tmp_flg = FALSE, tmp_find_flg = FALSE; bool tmp_flg = FALSE, tmp_find_flg = FALSE;
@ -218,9 +218,10 @@ void mrn_get_partition_info(const char *table_name, uint table_name_length,
List_iterator<partition_element> sub_it((*part_elem)->subpartitions); List_iterator<partition_element> sub_it((*part_elem)->subpartitions);
while ((*sub_elem = sub_it++)) while ((*sub_elem = sub_it++))
{ {
create_subpartition_name(tmp_name, table->s->path.str, if (create_subpartition_name(tmp_name, sizeof(tmp_name), table->s->path.str,
(*part_elem)->partition_name, (*sub_elem)->partition_name, (*part_elem)->partition_name, (*sub_elem)->partition_name,
NORMAL_PART_NAME); NORMAL_PART_NAME))
DBUG_VOID_RETURN;
DBUG_PRINT("info", ("mroonga tmp_name=%s", tmp_name)); DBUG_PRINT("info", ("mroonga tmp_name=%s", tmp_name));
if (table_name && !memcmp(table_name, tmp_name, table_name_length + 1)) if (table_name && !memcmp(table_name, tmp_name, table_name_length + 1))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -237,8 +238,9 @@ void mrn_get_partition_info(const char *table_name, uint table_name_length,
} }
} }
} else { } else {
create_partition_name(tmp_name, table->s->path.str, if (create_partition_name(tmp_name, sizeof(tmp_name), table->s->path.str,
(*part_elem)->partition_name, NORMAL_PART_NAME, TRUE); (*part_elem)->partition_name, NORMAL_PART_NAME, TRUE))
DBUG_VOID_RETURN;
DBUG_PRINT("info", ("mroonga tmp_name=%s", tmp_name)); DBUG_PRINT("info", ("mroonga tmp_name=%s", tmp_name));
if (table_name && !memcmp(table_name, tmp_name, table_name_length + 1)) if (table_name && !memcmp(table_name, tmp_name, table_name_length + 1))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;

29
storage/spider/spd_table.cc
View File

@ -6941,7 +6941,7 @@ void spider_get_partition_info(
partition_element **part_elem, partition_element **part_elem,
partition_element **sub_elem partition_element **sub_elem
) { ) {
char tmp_name[FN_LEN]; char tmp_name[FN_REFLEN + 1];
partition_element *tmp_part_elem = NULL, *tmp_sub_elem = NULL; partition_element *tmp_part_elem = NULL, *tmp_sub_elem = NULL;
bool tmp_flg = FALSE, tmp_find_flg = FALSE; bool tmp_flg = FALSE, tmp_find_flg = FALSE;
DBUG_ENTER("spider_get_partition_info"); DBUG_ENTER("spider_get_partition_info");
@ -6962,9 +6962,10 @@ void spider_get_partition_info(
List_iterator<partition_element> sub_it((*part_elem)->subpartitions); List_iterator<partition_element> sub_it((*part_elem)->subpartitions);
while ((*sub_elem = sub_it++)) while ((*sub_elem = sub_it++))
{ {
create_subpartition_name(tmp_name, table_share->path.str, if (create_subpartition_name(tmp_name, sizeof(tmp_name),
(*part_elem)->partition_name, (*sub_elem)->partition_name, table_share->path.str, (*part_elem)->partition_name,
NORMAL_PART_NAME); (*sub_elem)->partition_name, NORMAL_PART_NAME))
DBUG_VOID_RETURN;
DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); DBUG_PRINT("info",("spider tmp_name=%s", tmp_name));
if (!memcmp(table_name, tmp_name, table_name_length + 1)) if (!memcmp(table_name, tmp_name, table_name_length + 1))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -6980,8 +6981,10 @@ void spider_get_partition_info(
} }
} }
} else { } else {
create_partition_name(tmp_name, table_share->path.str, if (create_partition_name(tmp_name, sizeof(tmp_name),
(*part_elem)->partition_name, NORMAL_PART_NAME, TRUE); table_share->path.str, (*part_elem)->partition_name,
NORMAL_PART_NAME, TRUE))
DBUG_VOID_RETURN;
DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); DBUG_PRINT("info",("spider tmp_name=%s", tmp_name));
if (!memcmp(table_name, tmp_name, table_name_length + 1)) if (!memcmp(table_name, tmp_name, table_name_length + 1))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -8447,7 +8450,7 @@ int spider_discover_table_structure(
spider_free_share_resource_only(spider_share); spider_free_share_resource_only(spider_share);
#ifdef WITH_PARTITION_STORAGE_ENGINE #ifdef WITH_PARTITION_STORAGE_ENGINE
} else { } else {
char tmp_name[FN_LEN]; char tmp_name[FN_REFLEN + 1];
List_iterator<partition_element> part_it(part_info->partitions); List_iterator<partition_element> part_it(part_info->partitions);
partition_element *part_elem, *sub_elem; partition_element *part_elem, *sub_elem;
while ((part_elem = part_it++)) while ((part_elem = part_it++))
@ -8458,9 +8461,10 @@ int spider_discover_table_structure(
while ((sub_elem = sub_it++)) while ((sub_elem = sub_it++))
{ {
str.length(str_len); str.length(str_len);
create_subpartition_name(tmp_name, table_name, if (create_subpartition_name(tmp_name, sizeof(tmp_name), table_name,
(part_elem)->partition_name, (sub_elem)->partition_name, (part_elem)->partition_name, (sub_elem)->partition_name,
NORMAL_PART_NAME); NORMAL_PART_NAME))
DBUG_RETURN(1);
DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); DBUG_PRINT("info",("spider tmp_name=%s", tmp_name));
if (!(spider_share = spider_create_share(table_name, share, if (!(spider_share = spider_create_share(table_name, share,
part_info, part_info,
@ -8483,8 +8487,9 @@ int spider_discover_table_structure(
break; break;
} else { } else {
str.length(str_len); str.length(str_len);
create_partition_name(tmp_name, table_name, if (create_partition_name(tmp_name, sizeof(tmp_name), table_name,
(part_elem)->partition_name, NORMAL_PART_NAME, TRUE); (part_elem)->partition_name, NORMAL_PART_NAME, TRUE))
DBUG_RETURN(1);
DBUG_PRINT("info",("spider tmp_name=%s", tmp_name)); DBUG_PRINT("info",("spider tmp_name=%s", tmp_name));
if (!(spider_share = spider_create_share(table_name, share, if (!(spider_share = spider_create_share(table_name, share,
part_info, part_info,