Skip to content

M
MariaDB
Commit b11f1d0c authored by unknown's avatar unknown
Browse files
Options

5.1 version of a fix and test cases for bugs: 

Bug#4968 ""Stored procedure crash if cursor opened on altered table"
Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
Bug#19182 "CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work from 
stored procedure."
Bug#19733 "Repeated alter, or repeated create/drop, fails"
Bug#22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
Bug#24879 "Prepared Statements: CREATE TABLE (UTF8 KEY) produces a 
growing key length" (this bug is not fixed in 5.0)

Re-execution of CREATE DATABASE, CREATE TABLE and ALTER TABLE 
statements in stored routines or as prepared statements caused
incorrect results (and crashes in versions prior to 5.0.25).

In 5.1 the problem occured only for CREATE DATABASE, CREATE TABLE
SELECT and CREATE TABLE with INDEX/DATA DIRECTOY options).
  
The problem of bugs 4968, 19733, 19282 and 6895 was that functions
mysql_prepare_table, mysql_create_table and mysql_alter_table are not
re-execution friendly: during their operation they modify contents
of LEX (members create_info, alter_info, key_list, create_list),
thus making the LEX unusable for the next execution.
In particular, these functions removed processed columns and keys from
create_list, key_list and drop_list. Search the code in sql_table.cc 
for drop_it.remove() and similar patterns to find evidence.
  
The fix is to supply to these functions a usable copy of each of the
above structures at every re-execution of an SQL statement. 
  
To simplify memory management, LEX::key_list and LEX::create_list
were added to LEX::alter_info, a fresh copy of which is created for
every execution.
  
The problem of crashing bug 22060 stemmed from the fact that the above 
metnioned functions were not only modifying HA_CREATE_INFO structure 
in LEX, but also were changing it to point to areas in volatile memory
of the execution memory root.
   
The patch solves this problem by creating and using an on-stack
copy of HA_CREATE_INFO in mysql_execute_command.

Additionally, this patch splits the part of mysql_alter_table
that analizes and rewrites information from the parser into
a separate function - mysql_prepare_alter_table, in analogy with
mysql_prepare_table, which is renamed to mysql_prepare_create_table.


mysql-test/r/ps.result:
  Update test results (Bug#19182, Bug#22060, Bug#4968, Bug#6895)
mysql-test/r/sp.result:
  Update results (Bug#19733)
mysql-test/t/ps.test:
  Add test cases for Bug#19182, Bug#22060, Bug#4968, Bug#6895
mysql-test/t/sp.test:
  Add a test case for Bug#19733
sql/field.h:
  Implement a deep copy constructor for create_field
sql/mysql_priv.h:
  LEX::key_list and LEX::create_list were moved to LEX::alter_info.
  Update declarations to use LEX::alter_info instead of these two
  members.
  Remove declarations of mysql_add_index, mysql_drop_index.
sql/sql_class.cc:
  Implement deep copy constructors.
sql/sql_class.h:
  Implement (almost) deep copy constructors for key_part_spec, 
  Alter_drop, Alter_column, Key, foreign_key.
  Replace pair<columns, keys> with an instance of Alter_info in
  select_create constructor. We create a new copy of Alter_info
  each time we re-execute SELECT .. CREATE prepared statement.
sql/sql_insert.cc:
  Adjust to a new signature of create_table_from_items.
sql/sql_lex.cc:
  Implement Alter_info::Alter_info that would make a "deep" copy
  of all definition lists (keys, columns).
  Move is_partition_management() from sql_partition.cc (feature-based
  file division is evil).
sql/sql_lex.h:
  Move key_list and create_list to class Alter_info. Implement
  Alter_info::Alter_info that can be used with PS and SP.
  Get rid of Alter_info::clear() which was an attempt to save on
  matches and always use Alter_info::reset().
  Implement an auxiliary Alter_info::init_for_create_from_alter()
  which is used in mysql_alter_table.
sql/sql_list.cc:
    Implement a copy constructor of class List that makes a deep copy
    of all list nodes.
sql/sql_list.h:
  Implement a way to make a deep copy of all list nodes.
sql/sql_parse.cc:
  Adjust to new signatures of mysql_create_table, mysql_alter_table,
  select_create. Functions mysql_create_index and mysql_drop_index has
  become identical after initialization of alter_info was moved to the 
  parser, and were merged. Flag enable_slow_log was not updated for 
  SQLCOM_DROP_INDEX, which was a bug.
  Just like CREATE INDEX, DROP INDEX is currently done via complete 
  table rebuild and is rightfully a slow administrative statement.
sql/sql_partition.cc:
  Move is_partition_management() to sql_lex.cc
  Adjust code to the new Alter_info.
sql/sql_table.cc:
  Adjust mysql_alter_table, mysql_recreate_table, mysql_create_table,
  mysql_prepare_table to new signatures.
  Rename mysql_prepare_table to mysql_prepare_create_table. Make
  sure it follows the convention and returns FALSE for success and
  TRUE for error.
  Move parts of mysql_alter_table to mysql_prepare_alter_table.
  Move the first invokation of mysql_prepare_table from mysql_alter_table
  to compare_tables, as it was needed only for the purpose
  of correct comparison.
  Since now Alter_info itself is created in the runtime mem root,
  adjust mysql_prepare_table to always allocate memory in the
  runtime memory root.
  Remove dead code.
sql/sql_yacc.yy:
  LEX::key_list and LEX::create_list moved to class Alter_info
parent 850eadad
Hide whitespace changes
Inline Side-by-side
Showing with 1826 additions and 1288 deletions
mysql-test/r/ps.result
View file @ b11f1d0c
...@@ -1062,6 +1062,87 @@ EXECUTE stmt USING @a; ...@@ -1062,6 +1062,87 @@ EXECUTE stmt USING @a;
0 0 0 0
DEALLOCATE PREPARE stmt; DEALLOCATE PREPARE stmt;
DROP TABLE t1; DROP TABLE t1;
DROP TABLE IF EXISTS t1, t2;
CREATE TABLE t1 (i INT);
PREPARE st_19182
FROM "CREATE TABLE t2 (i INT, j INT, KEY (i), KEY(j)) SELECT i FROM t1";
EXECUTE st_19182;
DESC t2;
Field Type Null Key Default Extra
j int(11) YES MUL NULL
i int(11) YES MUL NULL
DROP TABLE t2;
EXECUTE st_19182;
DESC t2;
Field Type Null Key Default Extra
j int(11) YES MUL NULL
i int(11) YES MUL NULL
DEALLOCATE PREPARE st_19182;
DROP TABLE t2, t1;
drop database if exists mysqltest;
drop table if exists t1, t2;
create database mysqltest character set utf8;
prepare stmt1 from "create table mysqltest.t1 (c char(10))";
prepare stmt2 from "create table mysqltest.t2 select 'test'";
execute stmt1;
execute stmt2;
show create table mysqltest.t1;
Table Create Table
t1 CREATE TABLE `t1` (
`c` char(10) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8
show create table mysqltest.t2;
Table Create Table
t2 CREATE TABLE `t2` (
`test` varchar(4) CHARACTER SET latin1 NOT NULL DEFAULT ''
) ENGINE=MyISAM DEFAULT CHARSET=utf8
drop table mysqltest.t1;
drop table mysqltest.t2;
alter database mysqltest character set latin1;
execute stmt1;
execute stmt2;
show create table mysqltest.t1;
Table Create Table
t1 CREATE TABLE `t1` (
`c` char(10) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
show create table mysqltest.t2;
Table Create Table
t2 CREATE TABLE `t2` (
`test` varchar(4) NOT NULL DEFAULT ''
) ENGINE=MyISAM DEFAULT CHARSET=latin1
drop database mysqltest;
deallocate prepare stmt1;
deallocate prepare stmt2;
execute stmt;
show create table t1;
drop table t1;
execute stmt;
show create table t1;
drop table t1;
deallocate prepare stmt;
CREATE TABLE t1(a int);
INSERT INTO t1 VALUES (2), (3), (1);
PREPARE st1 FROM
'(SELECT a FROM t1) UNION (SELECT a+10 FROM t1) ORDER BY RAND()*0+a';
EXECUTE st1;
a
1
2
3
11
12
13
EXECUTE st1;
a
1
2
3
11
12
13
DEALLOCATE PREPARE st1;
DROP TABLE t1;
End of 4.1 tests. End of 4.1 tests.
create table t1 (a varchar(20)); create table t1 (a varchar(20));
insert into t1 values ('foo'); insert into t1 values ('foo');
...@@ -1544,6 +1625,72 @@ a ...@@ -1544,6 +1625,72 @@ a
2 2
DEALLOCATE PREPARE stmt; DEALLOCATE PREPARE stmt;
DROP TABLE t1,t2; DROP TABLE t1,t2;
drop table if exists t1;
create table t1 (s1 char(20));
prepare stmt from "alter table t1 modify s1 int";
execute stmt;
execute stmt;
drop table t1;
deallocate prepare stmt;
drop table if exists t1;
create table t1 (a int, b int);
prepare s_6895 from "alter table t1 drop column b";
execute s_6895;
show columns from t1;
Field Type Null Key Default Extra
a int(11) YES NULL
drop table t1;
create table t1 (a int, b int);
execute s_6895;
show columns from t1;
Field Type Null Key Default Extra
a int(11) YES NULL
drop table t1;
create table t1 (a int, b int);
execute s_6895;
show columns from t1;
Field Type Null Key Default Extra
a int(11) YES NULL
deallocate prepare s_6895;
drop table t1;
create table t1 (i int primary key auto_increment) comment='comment for table t1';
create table t2 (i int, j int, k int);
prepare stmt from "alter table t1 auto_increment=100";
execute stmt;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`i` int(11) NOT NULL AUTO_INCREMENT,
PRIMARY KEY (`i`)
) ENGINE=MyISAM AUTO_INCREMENT=100 DEFAULT CHARSET=latin1 COMMENT='comment for table t1'
flush tables;
select * from t2;
i j k
execute stmt;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`i` int(11) NOT NULL AUTO_INCREMENT,
PRIMARY KEY (`i`)
) ENGINE=MyISAM AUTO_INCREMENT=100 DEFAULT CHARSET=latin1 COMMENT='comment for table t1'
deallocate prepare stmt;
drop table t1, t2;
set @old_character_set_server= @@character_set_server;
set @@character_set_server= latin1;
prepare stmt from "create database mysqltest_1";
execute stmt;
show create database mysqltest_1;
Database Create Database
mysqltest_1 CREATE DATABASE `mysqltest_1` /*!40100 DEFAULT CHARACTER SET latin1 */
drop database mysqltest_1;
set @@character_set_server= utf8;
execute stmt;
show create database mysqltest_1;
Database Create Database
mysqltest_1 CREATE DATABASE `mysqltest_1` /*!40100 DEFAULT CHARACTER SET utf8 */
drop database mysqltest_1;
deallocate prepare stmt;
set @@character_set_server= @old_character_set_server;
drop tables if exists t1; drop tables if exists t1;
create table t1 (id int primary key auto_increment, value varchar(10)); create table t1 (id int primary key auto_increment, value varchar(10));
insert into t1 (id, value) values (1, 'FIRST'), (2, 'SECOND'), (3, 'THIRD'); insert into t1 (id, value) values (1, 'FIRST'), (2, 'SECOND'), (3, 'THIRD');
...@@ -2524,4 +2671,25 @@ i j ...@@ -2524,4 +2671,25 @@ i j
4 5 4 5
3 NULL 3 NULL
DROP TABLE t1, t2; DROP TABLE t1, t2;
drop table if exists t1;
Warnings:
Note 1051 Unknown table 't1'
prepare stmt
from "create table t1 (c char(100) character set utf8, key (c(10)))";
execute stmt;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`c` char(100) CHARACTER SET utf8 DEFAULT NULL,
KEY `c` (`c`(10))
) ENGINE=MyISAM DEFAULT CHARSET=latin1
drop table t1;
execute stmt;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`c` char(100) CHARACTER SET utf8 DEFAULT NULL,
KEY `c` (`c`(10))
) ENGINE=MyISAM DEFAULT CHARSET=latin1
drop table t1;
End of 5.1 tests. End of 5.1 tests.
mysql-test/r/sp.result
View file @ b11f1d0c
...@@ -5617,6 +5617,23 @@ Called B ...@@ -5617,6 +5617,23 @@ Called B
Called B Called B
drop procedure proc_21462_a| drop procedure proc_21462_a|
drop procedure proc_21462_b| drop procedure proc_21462_b|
drop table if exists t3|
drop procedure if exists proc_bug19733|
create table t3 (s1 int)|
create procedure proc_bug19733()
begin
declare v int default 0;
while v < 100 do
create index i on t3 (s1);
drop index i on t3;
set v = v + 1;
end while;
end|
call proc_bug19733()|
call proc_bug19733()|
call proc_bug19733()|
drop procedure proc_bug19733|
drop table t3|
DROP PROCEDURE IF EXISTS p1| DROP PROCEDURE IF EXISTS p1|
DROP VIEW IF EXISTS v1, v2| DROP VIEW IF EXISTS v1, v2|
DROP TABLE IF EXISTS t3, t4| DROP TABLE IF EXISTS t3, t4|
......
mysql-test/t/ps.test
View file @ b11f1d0c
...@@ -1118,6 +1118,113 @@ EXECUTE stmt USING @a; ...@@ -1118,6 +1118,113 @@ EXECUTE stmt USING @a;
DEALLOCATE PREPARE stmt; DEALLOCATE PREPARE stmt;
DROP TABLE t1; DROP TABLE t1;
#
# Bug#19182: CREATE TABLE bar (m INT) SELECT n FROM foo; doesn't work
# from stored procedure.
#
# The cause of a bug was that cached LEX::create_list was modified,
# and then together with LEX::key_list was reset.
#
--disable_warnings
DROP TABLE IF EXISTS t1, t2;
--enable_warnings
CREATE TABLE t1 (i INT);
PREPARE st_19182
FROM "CREATE TABLE t2 (i INT, j INT, KEY (i), KEY(j)) SELECT i FROM t1";
EXECUTE st_19182;
DESC t2;
DROP TABLE t2;
# Check that on second execution we don't loose 'j' column and the keys
# on 'i' and 'j' columns.
EXECUTE st_19182;
DESC t2;
DEALLOCATE PREPARE st_19182;
DROP TABLE t2, t1;
#
# Bug #22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
#
# Code which implemented CREATE/ALTER TABLE and CREATE DATABASE
# statement modified HA_CREATE_INFO structure in LEX, making these
# statements PS/SP-unsafe (their re-execution might have resulted
# in incorrect results).
#
--disable_warnings
drop database if exists mysqltest;
drop table if exists t1, t2;
--enable_warnings
# CREATE TABLE and CREATE TABLE ... SELECT
create database mysqltest character set utf8;
prepare stmt1 from "create table mysqltest.t1 (c char(10))";
prepare stmt2 from "create table mysqltest.t2 select 'test'";
execute stmt1;
execute stmt2;
show create table mysqltest.t1;
show create table mysqltest.t2;
drop table mysqltest.t1;
drop table mysqltest.t2;
alter database mysqltest character set latin1;
execute stmt1;
execute stmt2;
show create table mysqltest.t1;
show create table mysqltest.t2;
drop database mysqltest;
deallocate prepare stmt1;
deallocate prepare stmt2;
#
# CREATE TABLE with DATA DIRECTORY option
#
# Protect ourselves from data left in tmp/ by a previos possibly failed
# test
--system rm -f $MYSQLTEST_VARDIR/tmp/t1.*
--disable_warnings
--disable_query_log
eval prepare stmt from "create table t1 (c char(10)) data directory='$MYSQLTEST_VARDIR/tmp'";
--enable_query_log
execute stmt;
#
# DATA DIRECTORY option does not always work: if the operating
# system does not support symlinks, have_symlinks option is automatically
# disabled.
# In this case DATA DIRECTORY is silently ignored when
# creating a table, and is not output by SHOW CREATE TABLE.
#
--disable_result_log
show create table t1;
--enable_result_log
drop table t1;
execute stmt;
--disable_result_log
show create table t1;
--enable_result_log
--enable_warnings
drop table t1;
deallocate prepare stmt;
#
#
# Bug #27937: crash on the second execution for prepared statement
# from UNION with ORDER BY an expression containing RAND()
#
CREATE TABLE t1(a int);
INSERT INTO t1 VALUES (2), (3), (1);
PREPARE st1 FROM
'(SELECT a FROM t1) UNION (SELECT a+10 FROM t1) ORDER BY RAND()*0+a';
EXECUTE st1;
EXECUTE st1;
DEALLOCATE PREPARE st1;
DROP TABLE t1;
--echo End of 4.1 tests. --echo End of 4.1 tests.
############################# 5.0 tests start ################################ ############################# 5.0 tests start ################################
...@@ -1596,6 +1703,77 @@ EXECUTE stmt USING @arg; ...@@ -1596,6 +1703,77 @@ EXECUTE stmt USING @arg;
DEALLOCATE PREPARE stmt; DEALLOCATE PREPARE stmt;
DROP TABLE t1,t2; DROP TABLE t1,t2;
#
# Bug#4968 "Stored procedure crash if cursor opened on altered table"
# The bug is not repeatable any more after the fix for
# Bug#15217 "Bug #15217 Using a SP cursor on a table created with PREPARE
# fails with weird error", however ALTER TABLE is not re-execution friendly
# and that caused a valgrind warning. Check that the warning is gone.
#
--disable_warnings
drop table if exists t1;
--enable_warnings
create table t1 (s1 char(20));
prepare stmt from "alter table t1 modify s1 int";
execute stmt;
execute stmt;
drop table t1;
deallocate prepare stmt;
#
# Bug#6895 "Prepared Statements: ALTER TABLE DROP COLUMN does nothing"
#
--disable_warnings
drop table if exists t1;
--enable_warnings
create table t1 (a int, b int);
prepare s_6895 from "alter table t1 drop column b";
execute s_6895;
show columns from t1;
drop table t1;
create table t1 (a int, b int);
execute s_6895;
show columns from t1;
drop table t1;
create table t1 (a int, b int);
execute s_6895;
show columns from t1;
deallocate prepare s_6895;
drop table t1;
#
# Bug #22060 "ALTER TABLE x AUTO_INCREMENT=y in SP crashes server"
#
# 5.0 part of the test.
#
# ALTER TABLE
create table t1 (i int primary key auto_increment) comment='comment for table t1';
create table t2 (i int, j int, k int);
prepare stmt from "alter table t1 auto_increment=100";
execute stmt;
show create table t1;
# Let us trash table-cache's memory
flush tables;
select * from t2;
execute stmt;
show create table t1;
deallocate prepare stmt;
drop table t1, t2;
# 5.1 part of the test.
# CREATE DATABASE
set @old_character_set_server= @@character_set_server;
set @@character_set_server= latin1;
prepare stmt from "create database mysqltest_1";
execute stmt;
show create database mysqltest_1;
drop database mysqltest_1;
set @@character_set_server= utf8;
execute stmt;
show create database mysqltest_1;
drop database mysqltest_1;
deallocate prepare stmt;
set @@character_set_server= @old_character_set_server;
# #
...@@ -2570,5 +2748,21 @@ connection default; ...@@ -2570,5 +2748,21 @@ connection default;
DROP TABLE t1, t2; DROP TABLE t1, t2;
#
# Bug #24879 Prepared Statements: CREATE TABLE (UTF8 KEY) produces a growing
# key length
#
# Test that parse information is not altered by subsequent executions of a
# prepared statement
#
drop table if exists t1;
prepare stmt
from "create table t1 (c char(100) character set utf8, key (c(10)))";
execute stmt;
show create table t1;
drop table t1;
execute stmt;
show create table t1;
drop table t1;
--echo End of 5.1 tests. --echo End of 5.1 tests.
mysql-test/t/sp.test
View file @ b11f1d0c
...@@ -6569,6 +6569,34 @@ drop procedure proc_21462_a| ...@@ -6569,6 +6569,34 @@ drop procedure proc_21462_a|
drop procedure proc_21462_b| drop procedure proc_21462_b|
#
# Bug#19733 "Repeated alter, or repeated create/drop, fails"
# Check that CREATE/DROP INDEX is re-execution friendly.
#
--disable_warnings
drop table if exists t3|
drop procedure if exists proc_bug19733|
--enable_warnings
create table t3 (s1 int)|
create procedure proc_bug19733()
begin
declare v int default 0;
while v < 100 do
create index i on t3 (s1);
drop index i on t3;
set v = v + 1;
end while;
end|
call proc_bug19733()|
call proc_bug19733()|
call proc_bug19733()|
drop procedure proc_bug19733|
drop table t3|
# #
# BUG#20492: Subsequent calls to stored procedure yeild incorrect # BUG#20492: Subsequent calls to stored procedure yeild incorrect
# result if join is used # result if join is used
......
sql/field.h
View file @ b11f1d0c
...@@ -1622,6 +1622,9 @@ class create_field :public Sql_alloc ...@@ -1622,6 +1622,9 @@ class create_field :public Sql_alloc
uint offset,pack_flag; uint offset,pack_flag;
create_field() :after(0) {} create_field() :after(0) {}
create_field(Field *field, Field *orig_field); create_field(Field *field, Field *orig_field);
/* Used to make a clone of this object for ALTER/CREATE TABLE */
create_field *clone(MEM_ROOT *mem_root) const
{ return new (mem_root) create_field(*this); }
void create_length_to_internal_length(void); void create_length_to_internal_length(void);
/* Init for a tmp table field. To be extended if need be. */ /* Init for a tmp table field. To be extended if need be. */
......
sql/mysql_priv.h
View file @ b11f1d0c
...@@ -960,32 +960,26 @@ int prepare_create_field(create_field *sql_field, ...@@ -960,32 +960,26 @@ int prepare_create_field(create_field *sql_field,
longlong table_flags); longlong table_flags);
bool mysql_create_table(THD *thd,const char *db, const char *table_name, bool mysql_create_table(THD *thd,const char *db, const char *table_name,
HA_CREATE_INFO *create_info, HA_CREATE_INFO *create_info,
List<create_field> &fields, List<Key> &keys, Alter_info *alter_info,
bool tmp_table, uint select_field_count, bool tmp_table, uint select_field_count);
bool use_copy_create_info);
bool mysql_create_table_no_lock(THD *thd, const char *db, bool mysql_create_table_no_lock(THD *thd, const char *db,
const char *table_name, const char *table_name,
HA_CREATE_INFO *create_info, HA_CREATE_INFO *create_info,
List<create_field> &fields, List<Key> &keys, Alter_info *alter_info,
bool tmp_table, uint select_field_count, bool tmp_table, uint select_field_count);
bool use_copy_create_info);
bool mysql_alter_table(THD *thd, char *new_db, char *new_name, bool mysql_alter_table(THD *thd, char *new_db, char *new_name,
HA_CREATE_INFO *create_info, HA_CREATE_INFO *create_info,
TABLE_LIST *table_list, TABLE_LIST *table_list,
List<create_field> &fields, Alter_info *alter_info,
List<Key> &keys, uint order_num, ORDER *order, bool ignore);
uint order_num, ORDER *order, bool ignore, bool mysql_recreate_table(THD *thd, TABLE_LIST *table_list);
ALTER_INFO *alter_info, bool do_send_ok); bool mysql_create_like_table(THD *thd, TABLE_LIST *table,
bool mysql_recreate_table(THD *thd, TABLE_LIST *table_list, bool do_send_ok); TABLE_LIST *src_table,
bool mysql_create_like_table(THD *thd, TABLE_LIST *table, TABLE_LIST *src_table,
HA_CREATE_INFO *create_info); HA_CREATE_INFO *create_info);
bool mysql_rename_table(handlerton *base, const char *old_db, bool mysql_rename_table(handlerton *base, const char *old_db,
const char * old_name, const char *new_db, const char * old_name, const char *new_db,
const char * new_name, uint flags); const char * new_name, uint flags);
bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys);
bool mysql_drop_index(THD *thd, TABLE_LIST *table_list,
ALTER_INFO *alter_info);
bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list, bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
Item **conds, uint order_num, ORDER *order); Item **conds, uint order_num, ORDER *order);
int mysql_update(THD *thd,TABLE_LIST *tables,List<Item> &fields, int mysql_update(THD *thd,TABLE_LIST *tables,List<Item> &fields,
...@@ -1309,14 +1303,13 @@ char *make_default_log_name(char *buff,const char* log_ext); ...@@ -1309,14 +1303,13 @@ char *make_default_log_name(char *buff,const char* log_ext);
#ifdef WITH_PARTITION_STORAGE_ENGINE #ifdef WITH_PARTITION_STORAGE_ENGINE
uint fast_alter_partition_table(THD *thd, TABLE *table, uint fast_alter_partition_table(THD *thd, TABLE *table,
ALTER_INFO *alter_info, Alter_info *alter_info,
HA_CREATE_INFO *create_info, HA_CREATE_INFO *create_info,
TABLE_LIST *table_list, TABLE_LIST *table_list,
List<create_field> *create_list, char *db,
List<Key> *key_list, char *db,
const char *table_name, const char *table_name,
uint fast_alter_partition); uint fast_alter_partition);
uint prep_alter_part_table(THD *thd, TABLE *table, ALTER_INFO *alter_info, uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
HA_CREATE_INFO *create_info, HA_CREATE_INFO *create_info,
handlerton *old_db_type, handlerton *old_db_type,
bool *partition_changed, bool *partition_changed,
...@@ -1348,11 +1341,7 @@ typedef struct st_lock_param_type ...@@ -1348,11 +1341,7 @@ typedef struct st_lock_param_type
ulonglong deleted; ulonglong deleted;
THD *thd; THD *thd;
HA_CREATE_INFO *create_info; HA_CREATE_INFO *create_info;
ALTER_INFO *alter_info; Alter_info *alter_info;
List<create_field> *create_list;
List<create_field> new_create_list;
List<Key> *key_list;
List<Key> new_key_list;
TABLE *table; TABLE *table;
KEY *key_info_buffer; KEY *key_info_buffer;
const char *db; const char *db;
......
sql/sql_class.cc
View file @ b11f1d0c
...@@ -91,6 +91,40 @@ bool key_part_spec::operator==(const key_part_spec& other) const ...@@ -91,6 +91,40 @@ bool key_part_spec::operator==(const key_part_spec& other) const
return length == other.length && !strcmp(field_name, other.field_name); return length == other.length && !strcmp(field_name, other.field_name);
} }
/**
Construct an (almost) deep copy of this key. Only those
elements that are known to never change are not copied.
If out of memory, a partial copy is returned and an error is set
in THD.
*/
Key::Key(const Key &rhs, MEM_ROOT *mem_root)
:type(rhs.type),
key_create_info(rhs.key_create_info),
columns(rhs.columns, mem_root),
name(rhs.name),
generated(rhs.generated)
{
list_copy_and_replace_each_value(columns, mem_root);
}
/**
Construct an (almost) deep copy of this foreign key. Only those
elements that are known to never change are not copied.
If out of memory, a partial copy is returned and an error is set
in THD.
*/
foreign_key::foreign_key(const foreign_key &rhs, MEM_ROOT *mem_root)
:Key(rhs),
ref_table(rhs.ref_table),
ref_columns(rhs.ref_columns),
delete_opt(rhs.delete_opt),
update_opt(rhs.update_opt),
match_opt(rhs.match_opt)
{
list_copy_and_replace_each_value(ref_columns, mem_root);
}
/* /*
Test if a foreign key (= generated key) is a prefix of the given key Test if a foreign key (= generated key) is a prefix of the given key
......
sql/sql_class.h
View file @ b11f1d0c
...@@ -90,6 +90,17 @@ class key_part_spec :public Sql_alloc { ...@@ -90,6 +90,17 @@ class key_part_spec :public Sql_alloc {
uint length; uint length;
key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {} key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {}
bool operator==(const key_part_spec& other) const; bool operator==(const key_part_spec& other) const;
/**
Construct a copy of this key_part_spec. field_name is copied
by-pointer as it is known to never change. At the same time
'length' may be reset in mysql_prepare_create_table, and this
is why we supply it with a copy.
@return If out of memory, 0 is returned and an error is set in
THD.
*/
key_part_spec *clone(MEM_ROOT *mem_root) const
{ return new (mem_root) key_part_spec(*this); }
}; };
...@@ -100,6 +111,12 @@ class Alter_drop :public Sql_alloc { ...@@ -100,6 +111,12 @@ class Alter_drop :public Sql_alloc {
enum drop_type type; enum drop_type type;
Alter_drop(enum drop_type par_type,const char *par_name) Alter_drop(enum drop_type par_type,const char *par_name)
:name(par_name), type(par_type) {} :name(par_name), type(par_type) {}
/**
Used to make a clone of this object for ALTER/CREATE TABLE
@sa comment for key_part_spec::clone
*/
Alter_drop *clone(MEM_ROOT *mem_root) const
{ return new (mem_root) Alter_drop(*this); }
}; };
...@@ -109,6 +126,12 @@ class Alter_column :public Sql_alloc { ...@@ -109,6 +126,12 @@ class Alter_column :public Sql_alloc {
Item *def; Item *def;
Alter_column(const char *par_name,Item *literal) Alter_column(const char *par_name,Item *literal)
:name(par_name), def(literal) {} :name(par_name), def(literal) {}
/**
Used to make a clone of this object for ALTER/CREATE TABLE
@sa comment for key_part_spec::clone
*/
Alter_column *clone(MEM_ROOT *mem_root) const
{ return new (mem_root) Alter_column(*this); }
}; };
...@@ -127,9 +150,16 @@ class Key :public Sql_alloc { ...@@ -127,9 +150,16 @@ class Key :public Sql_alloc {
:type(type_par), key_create_info(*key_info_arg), columns(cols), :type(type_par), key_create_info(*key_info_arg), columns(cols),
name(name_arg), generated(generated_arg) name(name_arg), generated(generated_arg)
{} {}
~Key() {} Key(const Key &rhs, MEM_ROOT *mem_root);
virtual ~Key() {}
/* Equality comparison of keys (ignoring name) */ /* Equality comparison of keys (ignoring name) */
friend bool foreign_key_prefix(Key *a, Key *b); friend bool foreign_key_prefix(Key *a, Key *b);
/**
Used to make a clone of this object for ALTER/CREATE TABLE
@sa comment for key_part_spec::clone
*/
virtual Key *clone(MEM_ROOT *mem_root) const
{ return new (mem_root) Key(*this, mem_root); }
}; };
class Table_ident; class Table_ident;
...@@ -152,6 +182,13 @@ class foreign_key: public Key { ...@@ -152,6 +182,13 @@ class foreign_key: public Key {
delete_opt(delete_opt_arg), update_opt(update_opt_arg), delete_opt(delete_opt_arg), update_opt(update_opt_arg),
match_opt(match_opt_arg) match_opt(match_opt_arg)
{} {}
foreign_key(const foreign_key &rhs, MEM_ROOT *mem_root);
/**
Used to make a clone of this object for ALTER/CREATE TABLE
@sa comment for key_part_spec::clone
*/
virtual Key *clone(MEM_ROOT *mem_root) const
{ return new (mem_root) foreign_key(*this, mem_root); }
}; };
typedef struct st_mysql_lock typedef struct st_mysql_lock
...@@ -1944,20 +1981,20 @@ class select_insert :public select_result_interceptor { ...@@ -1944,20 +1981,20 @@ class select_insert :public select_result_interceptor {
class select_create: public select_insert { class select_create: public select_insert {
ORDER *group; ORDER *group;
TABLE_LIST *create_table; TABLE_LIST *create_table;
List<create_field> *extra_fields;
List<Key> *keys;
HA_CREATE_INFO *create_info; HA_CREATE_INFO *create_info;
Alter_info *alter_info;
Field **field; Field **field;
public: public:
select_create (TABLE_LIST *table_arg, select_create(TABLE_LIST *table_arg,
HA_CREATE_INFO *create_info_par, HA_CREATE_INFO *create_info_arg,
List<create_field> &fields_par, Alter_info *alter_info_arg,
List<Key> &keys_par, List<Item> &select_fields,
List<Item> &select_fields,enum_duplicates duplic, bool ignore) enum_duplicates duplic, bool ignore)
:select_insert (NULL, NULL, &select_fields, 0, 0, duplic, ignore), :select_insert(NULL, NULL, &select_fields, 0, 0, duplic, ignore),
create_table(table_arg), extra_fields(&fields_par),keys(&keys_par), create_table(table_arg),
create_info(create_info_par) create_info(create_info_arg),
{} alter_info(alter_info_arg)
{}
int prepare(List<Item> &list, SELECT_LEX_UNIT *u); int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
void binlog_show_create_table(TABLE **tables, uint count); void binlog_show_create_table(TABLE **tables, uint count);
......
sql/sql_insert.cc
View file @ b11f1d0c
...@@ -3138,11 +3138,11 @@ bool select_insert::send_eof() ...@@ -3138,11 +3138,11 @@ bool select_insert::send_eof()
temporary table flag) temporary table flag)
create_table in Pointer to TABLE_LIST object providing database create_table in Pointer to TABLE_LIST object providing database
and name for table to be created or to be open and name for table to be created or to be open
extra_fields in/out Initial list of fields for table to be created alter_info in/out Initial list of columns and indexes for the table
keys in List of keys for table to be created to be created
items in List of items which should be used to produce rest items in List of items which should be used to produce rest
of fields for the table (corresponding fields will of fields for the table (corresponding fields will
be added to the end of 'extra_fields' list) be added to the end of alter_info->create_list)
lock out Pointer to the MYSQL_LOCK object for table created lock out Pointer to the MYSQL_LOCK object for table created
(or open temporary table) will be returned in this (or open temporary table) will be returned in this
parameter. Since this table is not included in parameter. Since this table is not included in
...@@ -3171,8 +3171,7 @@ bool select_insert::send_eof() ...@@ -3171,8 +3171,7 @@ bool select_insert::send_eof()
static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
TABLE_LIST *create_table, TABLE_LIST *create_table,
List<create_field> *extra_fields, Alter_info *alter_info,
List<Key> *keys,
List<Item> *items, List<Item> *items,
MYSQL_LOCK **lock, MYSQL_LOCK **lock,
TABLEOP_HOOKS *hooks) TABLEOP_HOOKS *hooks)
...@@ -3236,7 +3235,7 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, ...@@ -3236,7 +3235,7 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
DBUG_RETURN(0); DBUG_RETURN(0);
if (item->maybe_null) if (item->maybe_null)
cr_field->flags &= ~NOT_NULL_FLAG; cr_field->flags &= ~NOT_NULL_FLAG;
extra_fields->push_back(cr_field); alter_info->create_list.push_back(cr_field);
} }
DBUG_EXECUTE_IF("sleep_create_select_before_create", my_sleep(6000000);); DBUG_EXECUTE_IF("sleep_create_select_before_create", my_sleep(6000000););
...@@ -3261,8 +3260,8 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, ...@@ -3261,8 +3260,8 @@ static TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
tmp_disable_binlog(thd); tmp_disable_binlog(thd);
if (!mysql_create_table_no_lock(thd, create_table->db, if (!mysql_create_table_no_lock(thd, create_table->db,
create_table->table_name, create_table->table_name,
create_info, *extra_fields, *keys, 0, create_info, alter_info, 0,
select_field_count, 0)) select_field_count))
{ {
if (create_info->table_existed && if (create_info->table_existed &&
...@@ -3388,7 +3387,7 @@ select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u) ...@@ -3388,7 +3387,7 @@ select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
} }
if (!(table= create_table_from_items(thd, create_info, create_table, if (!(table= create_table_from_items(thd, create_info, create_table,
extra_fields, keys, &values, alter_info, &values,
&thd->extra_lock, hook_ptr))) &thd->extra_lock, hook_ptr)))
DBUG_RETURN(-1); // abort() deletes table DBUG_RETURN(-1); // abort() deletes table
......
sql/sql_lex.cc
View file @ b11f1d0c
...@@ -1118,6 +1118,34 @@ int MYSQLlex(void *arg, void *yythd) ...@@ -1118,6 +1118,34 @@ int MYSQLlex(void *arg, void *yythd)
} }
Alter_info::Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root)
:drop_list(rhs.drop_list, mem_root),
alter_list(rhs.alter_list, mem_root),
key_list(rhs.key_list, mem_root),
create_list(rhs.create_list, mem_root),
flags(rhs.flags),
keys_onoff(rhs.keys_onoff),
tablespace_op(rhs.tablespace_op),
partition_names(rhs.partition_names, mem_root),
no_parts(rhs.no_parts)
{
/*
Make deep copies of used objects.
This is not a fully deep copy - clone() implementations
of Alter_drop, Alter_column, Key, foreign_key, key_part_spec
do not copy string constants. At the same length the only
reason we make a copy currently is that ALTER/CREATE TABLE
code changes input Alter_info definitions, but string
constants never change.
*/
list_copy_and_replace_each_value(drop_list, mem_root);
list_copy_and_replace_each_value(alter_list, mem_root);
list_copy_and_replace_each_value(key_list, mem_root);
list_copy_and_replace_each_value(create_list, mem_root);
/* partition_names are not deeply copied currently */
}
/* /*
Skip comment in the end of statement. Skip comment in the end of statement.
...@@ -2379,3 +2407,22 @@ bool st_select_lex::add_index_hint (THD *thd, char *str, uint length) ...@@ -2379,3 +2407,22 @@ bool st_select_lex::add_index_hint (THD *thd, char *str, uint length)
current_index_hint_clause, current_index_hint_clause,
str, length)); str, length));
} }
/**
A routine used by the parser to decide whether we are specifying a full
partitioning or if only partitions to add or to split.
@note This needs to be outside of WITH_PARTITION_STORAGE_ENGINE since it
is used from the sql parser that doesn't have any #ifdef's
@retval TRUE Yes, it is part of a management partition command
@retval FALSE No, not a management partition command
*/
bool st_lex::is_partition_management() const
{
return (sql_command == SQLCOM_ALTER_TABLE &&
(alter_info.flags == ALTER_ADD_PARTITION ||
alter_info.flags == ALTER_REORGANIZE_PARTITION));
}
sql/sql_lex.h
View file @ b11f1d0c
...@@ -830,26 +830,60 @@ inline bool st_select_lex_unit::is_union () ...@@ -830,26 +830,60 @@ inline bool st_select_lex_unit::is_union ()
#define ALTER_REMOVE_PARTITIONING (1L << 25) #define ALTER_REMOVE_PARTITIONING (1L << 25)
#define ALTER_FOREIGN_KEY (1L << 26) #define ALTER_FOREIGN_KEY (1L << 26)
typedef struct st_alter_info /**
@brief Parsing data for CREATE or ALTER TABLE.
This structure contains a list of columns or indexes to be created,
altered or dropped.
*/
class Alter_info
{ {
public:
List<Alter_drop> drop_list; List<Alter_drop> drop_list;
List<Alter_column> alter_list; List<Alter_column> alter_list;
List<Key> key_list;
List<create_field> create_list;
uint flags; uint flags;
enum enum_enable_or_disable keys_onoff; enum enum_enable_or_disable keys_onoff;
enum tablespace_op_type tablespace_op; enum tablespace_op_type tablespace_op;
List<char> partition_names; List<char> partition_names;
uint no_parts; uint no_parts;
st_alter_info(){clear();} Alter_info() :
void clear() flags(0),
keys_onoff(LEAVE_AS_IS),
tablespace_op(NO_TABLESPACE_OP),
no_parts(0)
{}
void reset()
{ {
drop_list.empty();
alter_list.empty();
key_list.empty();
create_list.empty();
flags= 0;
keys_onoff= LEAVE_AS_IS; keys_onoff= LEAVE_AS_IS;
tablespace_op= NO_TABLESPACE_OP; tablespace_op= NO_TABLESPACE_OP;
no_parts= 0; no_parts= 0;
partition_names.empty(); partition_names.empty();
} }
void reset(){drop_list.empty();alter_list.empty();clear();} /**
} ALTER_INFO; Construct a copy of this object to be used for mysql_alter_table
and mysql_create_table. Historically, these two functions modify
their Alter_info arguments. This behaviour breaks re-execution of
prepared statements and stored procedures and is compensated by
always supplying a copy of Alter_info to these functions.
@return You need to use check the error in THD for out
of memory condition after calling this function.
*/
Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root);
private:
Alter_info &operator=(const Alter_info &rhs); // not implemented
Alter_info(const Alter_info &rhs); // not implemented
};
struct st_sp_chistics struct st_sp_chistics
{ {
...@@ -1103,8 +1137,6 @@ typedef struct st_lex : public Query_tables_list ...@@ -1103,8 +1137,6 @@ typedef struct st_lex : public Query_tables_list
List<String> interval_list; List<String> interval_list;
List<LEX_USER> users_list; List<LEX_USER> users_list;
List<LEX_COLUMN> columns; List<LEX_COLUMN> columns;
List<Key> key_list;
List<create_field> create_list;
List<Item> *insert_list,field_list,value_list,update_list; List<Item> *insert_list,field_list,value_list,update_list;
List<List_item> many_values; List<List_item> many_values;
List<set_var_base> var_list; List<set_var_base> var_list;
...@@ -1202,7 +1234,7 @@ typedef struct st_lex : public Query_tables_list ...@@ -1202,7 +1234,7 @@ typedef struct st_lex : public Query_tables_list
bool safe_to_cache_query; bool safe_to_cache_query;
bool subqueries, ignore; bool subqueries, ignore;
st_parsing_options parsing_options; st_parsing_options parsing_options;
ALTER_INFO alter_info; Alter_info alter_info;
/* Prepared statements SQL syntax:*/ /* Prepared statements SQL syntax:*/
LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */ LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
/* /*
...@@ -1361,6 +1393,7 @@ typedef struct st_lex : public Query_tables_list ...@@ -1361,6 +1393,7 @@ typedef struct st_lex : public Query_tables_list
void restore_backup_query_tables_list(Query_tables_list *backup); void restore_backup_query_tables_list(Query_tables_list *backup);
bool table_or_sp_used(); bool table_or_sp_used();
bool is_partition_management() const;
} LEX; } LEX;
struct st_lex_local: public st_lex struct st_lex_local: public st_lex
......
sql/sql_list.cc
View file @ b11f1d0c
...@@ -36,3 +36,37 @@ void free_list(I_List <i_string> *list) ...@@ -36,3 +36,37 @@ void free_list(I_List <i_string> *list)
while ((tmp= list->get())) while ((tmp= list->get()))
delete tmp; delete tmp;
} }
base_list::base_list(const base_list &rhs, MEM_ROOT *mem_root)
{
if (rhs.elements)
{
/*
It's okay to allocate an array of nodes at once: we never
call a destructor for list_node objects anyway.
*/
first= (list_node*) alloc_root(mem_root,
sizeof(list_node) * rhs.elements);
if (first)
{
elements= rhs.elements;
list_node *dst= first;
list_node *src= rhs.first;
for (; dst < first + elements - 1; dst++, src= src->next)
{
dst->info= src->info;
dst->next= dst + 1;
}
/* Copy the last node */
dst->info= src->info;
dst->next= &end_of_list;
/* Setup 'last' member */
last= &dst->next;
return;
}
}
elements= 0;
first= &end_of_list;
last= &first;
}
sql/sql_list.h
View file @ b11f1d0c
#ifndef INCLUDES_MYSQL_SQL_LIST_H
#define INCLUDES_MYSQL_SQL_LIST_H
/* Copyright (C) 2000-2003 MySQL AB /* Copyright (C) 2000-2003 MySQL AB
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
...@@ -63,21 +65,24 @@ class Sql_alloc ...@@ -63,21 +65,24 @@ class Sql_alloc
pointer. pointer.
*/ */
class list_node :public Sql_alloc
/**
list_node - a node of a single-linked list.
@note We never call a destructor for instances of this class.
*/
struct list_node :public Sql_alloc
{ {
public:
list_node *next; list_node *next;
void *info; void *info;
list_node(void *info_par,list_node *next_par) list_node(void *info_par,list_node *next_par)
:next(next_par),info(info_par) :next(next_par),info(info_par)
{} {}
list_node() /* For end_of_list */ list_node() /* For end_of_list */
{ {
info=0; info= 0;
next= this; next= this;
} }
friend class base_list;
friend class base_list_iterator;
}; };
...@@ -93,12 +98,28 @@ class base_list :public Sql_alloc ...@@ -93,12 +98,28 @@ class base_list :public Sql_alloc
inline void empty() { elements=0; first= &end_of_list; last=&first;} inline void empty() { elements=0; first= &end_of_list; last=&first;}
inline base_list() { empty(); } inline base_list() { empty(); }
/**
This is a shallow copy constructor that implicitly passes the ownership
from the source list to the new instance. The old instance is not
updated, so both objects end up sharing the same nodes. If one of
the instances then adds or removes a node, the other becomes out of
sync ('last' pointer), while still operational. Some old code uses and
relies on this behaviour. This logic is quite tricky: please do not use
it in any new code.
*/
inline base_list(const base_list &tmp) :Sql_alloc() inline base_list(const base_list &tmp) :Sql_alloc()
{ {
elements= tmp.elements; elements= tmp.elements;
first= tmp.first; first= tmp.first;
last= elements ? tmp.last : &first; last= elements ? tmp.last : &first;
} }
/**
Construct a deep copy of the argument in memory root mem_root.
The elements themselves are copied by pointer. If you also
need to copy elements by value, you should employ
list_copy_and_replace_each_value after creating a copy.
*/
base_list(const base_list &rhs, MEM_ROOT *mem_root);
inline base_list(bool error) { } inline base_list(bool error) { }
inline bool push_back(void *info) inline bool push_back(void *info)
{ {
...@@ -185,6 +206,15 @@ class base_list :public Sql_alloc ...@@ -185,6 +206,15 @@ class base_list :public Sql_alloc
elements+= list->elements; elements+= list->elements;
} }
} }
/**
Swap two lists.
*/
inline void swap(base_list &rhs)
{
swap_variables(list_node *, first, rhs.first);
swap_variables(list_node **, last, rhs.last);
swap_variables(uint, elements, rhs.elements);
}
inline list_node* last_node() { return *last; } inline list_node* last_node() { return *last; }
inline list_node* first_node() { return first;} inline list_node* first_node() { return first;}
inline void *head() { return first->info; } inline void *head() { return first->info; }
...@@ -349,6 +379,8 @@ template <class T> class List :public base_list ...@@ -349,6 +379,8 @@ template <class T> class List :public base_list
public: public:
inline List() :base_list() {} inline List() :base_list() {}
inline List(const List<T> &tmp) :base_list(tmp) {} inline List(const List<T> &tmp) :base_list(tmp) {}
inline List(const List<T> &tmp, MEM_ROOT *mem_root) :
base_list(tmp, mem_root) {}
inline bool push_back(T *a) { return base_list::push_back(a); } inline bool push_back(T *a) { return base_list::push_back(a); }
inline bool push_back(T *a, MEM_ROOT *mem_root) inline bool push_back(T *a, MEM_ROOT *mem_root)
{ return base_list::push_back(a, mem_root); } { return base_list::push_back(a, mem_root); }
...@@ -547,3 +579,32 @@ template <class T> class I_List_iterator :public base_ilist_iterator ...@@ -547,3 +579,32 @@ template <class T> class I_List_iterator :public base_ilist_iterator
I_List_iterator(I_List<T> &a) : base_ilist_iterator(a) {} I_List_iterator(I_List<T> &a) : base_ilist_iterator(a) {}
inline T* operator++(int) { return (T*) base_ilist_iterator::next(); } inline T* operator++(int) { return (T*) base_ilist_iterator::next(); }
}; };
/**
Make a deep copy of each list element.
@note A template function and not a template method of class List
is employed because of explicit template instantiation:
in server code there are explicit instantiations of List<T> and
an explicit instantiation of a template requires that any method
of the instantiated class used in the template can be resolved.
Evidently not all template arguments have clone() method with
the right signature.
@return You must query the error state in THD for out-of-memory
situation after calling this function.
*/
template <typename T>
inline
void
list_copy_and_replace_each_value(List<T> &list, MEM_ROOT *mem_root)
{
/* Make a deep copy of each element */
List_iterator<T> it(list);
T *el;
while ((el= it++))
it.replace(el->clone(mem_root));
}
#endif // INCLUDES_MYSQL_SQL_LIST_H
sql/sql_parse.cc
View file @ b11f1d0c
...@@ -2086,23 +2086,47 @@ mysql_execute_command(THD *thd) ...@@ -2086,23 +2086,47 @@ mysql_execute_command(THD *thd)
// Skip first table, which is the table we are creating // Skip first table, which is the table we are creating
TABLE_LIST *create_table= lex->unlink_first_table(&link_to_local); TABLE_LIST *create_table= lex->unlink_first_table(&link_to_local);
TABLE_LIST *select_tables= lex->query_tables; TABLE_LIST *select_tables= lex->query_tables;
/*
Code below (especially in mysql_create_table() and select_create
methods) may modify HA_CREATE_INFO structure in LEX, so we have to
use a copy of this structure to make execution prepared statement-
safe. A shallow copy is enough as this code won't modify any memory
referenced from this structure.
*/
HA_CREATE_INFO create_info(lex->create_info);
/*
We need to copy alter_info for the same reasons of re-execution
safety, only in case of Alter_info we have to do (almost) a deep
copy.
*/
Alter_info alter_info(lex->alter_info, thd->mem_root);
if (thd->is_fatal_error)
{
/* If out of memory when creating a copy of alter_info. */
res= 1;
goto end_with_restore_list;
}
if ((res= create_table_precheck(thd, select_tables, create_table))) if ((res= create_table_precheck(thd, select_tables, create_table)))
goto end_with_restore_list; goto end_with_restore_list;
/* Might have been updated in create_table_precheck */
create_info.alias= create_table->alias;
#ifndef HAVE_READLINK #ifndef HAVE_READLINK
if (lex->create_info.data_file_name) if (create_info.data_file_name)
push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0, push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
"DATA DIRECTORY option ignored"); "DATA DIRECTORY option ignored");
if (lex->create_info.index_file_name) if (create_info.index_file_name)
push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0, push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
"INDEX DIRECTORY option ignored"); "INDEX DIRECTORY option ignored");
lex->create_info.data_file_name=lex->create_info.index_file_name=0; create_info.data_file_name= create_info.index_file_name= NULL;
#else #else
/* Fix names if symlinked tables */ /* Fix names if symlinked tables */
if (append_file_to_dir(thd, &lex->create_info.data_file_name, if (append_file_to_dir(thd, &create_info.data_file_name,
create_table->table_name) || create_table->table_name) ||
append_file_to_dir(thd, &lex->create_info.index_file_name, append_file_to_dir(thd, &create_info.index_file_name,
create_table->table_name)) create_table->table_name))
goto end_with_restore_list; goto end_with_restore_list;
#endif #endif
...@@ -2110,14 +2134,14 @@ mysql_execute_command(THD *thd) ...@@ -2110,14 +2134,14 @@ mysql_execute_command(THD *thd)
If we are using SET CHARSET without DEFAULT, add an implicit If we are using SET CHARSET without DEFAULT, add an implicit
DEFAULT to not confuse old users. (This may change). DEFAULT to not confuse old users. (This may change).
*/ */
if ((lex->create_info.used_fields & if ((create_info.used_fields &
(HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) == (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
HA_CREATE_USED_CHARSET) HA_CREATE_USED_CHARSET)
{ {
lex->create_info.used_fields&= ~HA_CREATE_USED_CHARSET; create_info.used_fields&= ~HA_CREATE_USED_CHARSET;
lex->create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET; create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET;
lex->create_info.default_table_charset= lex->create_info.table_charset; create_info.default_table_charset= create_info.table_charset;
lex->create_info.table_charset= 0; create_info.table_charset= 0;
} }
/* /*
The create-select command will open and read-lock the select table The create-select command will open and read-lock the select table
...@@ -2156,7 +2180,7 @@ mysql_execute_command(THD *thd) ...@@ -2156,7 +2180,7 @@ mysql_execute_command(THD *thd)
select_lex->options|= SELECT_NO_UNLOCK; select_lex->options|= SELECT_NO_UNLOCK;
unit->set_limit(select_lex); unit->set_limit(select_lex);
if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE)) if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
{ {
lex->link_first_table_back(create_table, link_to_local); lex->link_first_table_back(create_table, link_to_local);
create_table->create= TRUE; create_table->create= TRUE;
...@@ -2168,7 +2192,7 @@ mysql_execute_command(THD *thd) ...@@ -2168,7 +2192,7 @@ mysql_execute_command(THD *thd)
Is table which we are changing used somewhere in other parts Is table which we are changing used somewhere in other parts
of query of query
*/ */
if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE)) if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
{ {
TABLE_LIST *duplicate; TABLE_LIST *duplicate;
create_table= lex->unlink_first_table(&link_to_local); create_table= lex->unlink_first_table(&link_to_local);
...@@ -2180,10 +2204,10 @@ mysql_execute_command(THD *thd) ...@@ -2180,10 +2204,10 @@ mysql_execute_command(THD *thd)
} }
} }
/* If we create merge table, we have to test tables in merge, too */ /* If we create merge table, we have to test tables in merge, too */
if (lex->create_info.used_fields & HA_CREATE_USED_UNION) if (create_info.used_fields & HA_CREATE_USED_UNION)
{ {
TABLE_LIST *tab; TABLE_LIST *tab;
for (tab= (TABLE_LIST*) lex->create_info.merge_list.first; for (tab= (TABLE_LIST*) create_info.merge_list.first;
tab; tab;
tab= tab->next_local) tab= tab->next_local)
{ {
...@@ -2198,18 +2222,15 @@ mysql_execute_command(THD *thd) ...@@ -2198,18 +2222,15 @@ mysql_execute_command(THD *thd)
} }
/* /*
FIXME Temporary hack which will go away once Kostja pushes select_create is currently not re-execution friendly and
his uber-fix for ALTER/CREATE TABLE. needs to be created for every execution of a PS/SP.
*/ */
lex->create_info.table_existed= 0;
if ((result= new select_create(create_table, if ((result= new select_create(create_table,
&lex->create_info, &create_info,
lex->create_list, &alter_info,
lex->key_list, select_lex->item_list,
select_lex->item_list, lex->duplicates,
lex->duplicates, lex->ignore)))
lex->ignore)))
{ {
/* /*
CREATE from SELECT give its SELECT_LEX for SELECT, CREATE from SELECT give its SELECT_LEX for SELECT,
...@@ -2218,29 +2239,25 @@ mysql_execute_command(THD *thd) ...@@ -2218,29 +2239,25 @@ mysql_execute_command(THD *thd)
res= handle_select(thd, lex, result, 0); res= handle_select(thd, lex, result, 0);
delete result; delete result;
} }
/* reset for PS */
lex->create_list.empty();
lex->key_list.empty();
} }
else if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE)) else if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
create_table= lex->unlink_first_table(&link_to_local); create_table= lex->unlink_first_table(&link_to_local);
} }
else else
{ {
/* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */ /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
if (lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) if (create_info.options & HA_LEX_CREATE_TMP_TABLE)
thd->options|= OPTION_KEEP_LOG; thd->options|= OPTION_KEEP_LOG;
/* regular create */ /* regular create */
if (lex->create_info.options & HA_LEX_CREATE_TABLE_LIKE) if (create_info.options & HA_LEX_CREATE_TABLE_LIKE)
res= mysql_create_like_table(thd, create_table, select_tables, res= mysql_create_like_table(thd, create_table, select_tables,
&lex->create_info); &create_info);
else else
{ {
res= mysql_create_table(thd, create_table->db, res= mysql_create_table(thd, create_table->db,
create_table->table_name, &lex->create_info, create_table->table_name, &create_info,
lex->create_list, &alter_info, 0, 0);
lex->key_list, 0, 0, 1);
} }
if (!res) if (!res)
send_ok(thd); send_ok(thd);
...@@ -2252,15 +2269,46 @@ mysql_execute_command(THD *thd) ...@@ -2252,15 +2269,46 @@ mysql_execute_command(THD *thd)
break; break;
} }
case SQLCOM_CREATE_INDEX: case SQLCOM_CREATE_INDEX:
/* Fall through */
case SQLCOM_DROP_INDEX:
/*
CREATE INDEX and DROP INDEX are implemented by calling ALTER
TABLE with proper arguments.
In the future ALTER TABLE will notice that the request is to
only add indexes and create these one by one for the existing
table without having to do a full rebuild.
*/
{
/* Prepare stack copies to be re-execution safe */
HA_CREATE_INFO create_info;
Alter_info alter_info(lex->alter_info, thd->mem_root);
if (thd->is_fatal_error) /* out of memory creating a copy of alter_info */
goto error;
DBUG_ASSERT(first_table == all_tables && first_table != 0); DBUG_ASSERT(first_table == all_tables && first_table != 0);
if (check_one_table_access(thd, INDEX_ACL, all_tables)) if (check_one_table_access(thd, INDEX_ACL, all_tables))
goto error; /* purecov: inspected */ goto error; /* purecov: inspected */
thd->enable_slow_log= opt_log_slow_admin_statements;
if (end_active_trans(thd)) if (end_active_trans(thd))
goto error; goto error;
res= mysql_create_index(thd, first_table, lex->key_list); /*
break; Currently CREATE INDEX or DROP INDEX cause a full table rebuild
and thus classify as slow administrative statements just like
ALTER TABLE.
*/
thd->enable_slow_log= opt_log_slow_admin_statements;
bzero((char*) &create_info, sizeof(create_info));
create_info.db_type= 0;
create_info.row_type= ROW_TYPE_NOT_USED;
create_info.default_table_charset= thd->variables.collation_database;
res= mysql_alter_table(thd, first_table->db, first_table->table_name,
&create_info, first_table, &alter_info,
0, (ORDER*) 0, 0);
break;
}
#ifdef HAVE_REPLICATION #ifdef HAVE_REPLICATION
case SQLCOM_SLAVE_START: case SQLCOM_SLAVE_START:
{ {
...@@ -2302,11 +2350,22 @@ mysql_execute_command(THD *thd) ...@@ -2302,11 +2350,22 @@ mysql_execute_command(THD *thd)
{ {
ulong priv=0; ulong priv=0;
ulong priv_needed= ALTER_ACL; ulong priv_needed= ALTER_ACL;
/*
Code in mysql_alter_table() may modify its HA_CREATE_INFO argument,
so we have to use a copy of this structure to make execution
prepared statement- safe. A shallow copy is enough as no memory
referenced from this structure will be modified.
*/
HA_CREATE_INFO create_info(lex->create_info);
Alter_info alter_info(lex->alter_info, thd->mem_root);
if (thd->is_fatal_error) /* out of memory creating a copy of alter_info */
goto error;
/* /*
We also require DROP priv for ALTER TABLE ... DROP PARTITION, as well We also require DROP priv for ALTER TABLE ... DROP PARTITION, as well
as for RENAME TO, as being done by SQLCOM_RENAME_TABLE as for RENAME TO, as being done by SQLCOM_RENAME_TABLE
*/ */
if (lex->alter_info.flags & (ALTER_DROP_PARTITION | ALTER_RENAME)) if (alter_info.flags & (ALTER_DROP_PARTITION | ALTER_RENAME))
priv_needed|= DROP_ACL; priv_needed|= DROP_ACL;
/* Must be set in the parser */ /* Must be set in the parser */
...@@ -2318,7 +2377,7 @@ mysql_execute_command(THD *thd) ...@@ -2318,7 +2377,7 @@ mysql_execute_command(THD *thd)
is_schema_db(select_lex->db))|| is_schema_db(select_lex->db))||
check_merge_table_access(thd, first_table->db, check_merge_table_access(thd, first_table->db,
(TABLE_LIST *) (TABLE_LIST *)
lex->create_info.merge_list.first)) create_info.merge_list.first))
goto error; /* purecov: inspected */ goto error; /* purecov: inspected */
if (grant_option) if (grant_option)
{ {
...@@ -2337,13 +2396,13 @@ mysql_execute_command(THD *thd) ...@@ -2337,13 +2396,13 @@ mysql_execute_command(THD *thd)
} }
} }
/* Don't yet allow changing of symlinks with ALTER TABLE */ /* Don't yet allow changing of symlinks with ALTER TABLE */
if (lex->create_info.data_file_name) if (create_info.data_file_name)
push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0, push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
"DATA DIRECTORY option ignored"); "DATA DIRECTORY option ignored");
if (lex->create_info.index_file_name) if (create_info.index_file_name)
push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0, push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 0,
"INDEX DIRECTORY option ignored"); "INDEX DIRECTORY option ignored");
lex->create_info.data_file_name=lex->create_info.index_file_name=0; create_info.data_file_name= create_info.index_file_name= NULL;
/* ALTER TABLE ends previous transaction */ /* ALTER TABLE ends previous transaction */
if (end_active_trans(thd)) if (end_active_trans(thd))
goto error; goto error;
...@@ -2357,12 +2416,12 @@ mysql_execute_command(THD *thd) ...@@ -2357,12 +2416,12 @@ mysql_execute_command(THD *thd)
thd->enable_slow_log= opt_log_slow_admin_statements; thd->enable_slow_log= opt_log_slow_admin_statements;
res= mysql_alter_table(thd, select_lex->db, lex->name.str, res= mysql_alter_table(thd, select_lex->db, lex->name.str,
&lex->create_info, &create_info,
first_table, lex->create_list, first_table,
lex->key_list, &alter_info,
select_lex->order_list.elements, select_lex->order_list.elements,
(ORDER *) select_lex->order_list.first, (ORDER *) select_lex->order_list.first,
lex->ignore, &lex->alter_info, 1); lex->ignore);
break; break;
} }
case SQLCOM_RENAME_TABLE: case SQLCOM_RENAME_TABLE:
...@@ -2505,7 +2564,7 @@ mysql_execute_command(THD *thd) ...@@ -2505,7 +2564,7 @@ mysql_execute_command(THD *thd)
goto error; /* purecov: inspected */ goto error; /* purecov: inspected */
thd->enable_slow_log= opt_log_slow_admin_statements; thd->enable_slow_log= opt_log_slow_admin_statements;
res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ? res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
mysql_recreate_table(thd, first_table, 1) : mysql_recreate_table(thd, first_table) :
mysql_optimize_table(thd, first_table, &lex->check_opt); mysql_optimize_table(thd, first_table, &lex->check_opt);
/* ! we write after unlocking the table */ /* ! we write after unlocking the table */
if (!res && !lex->no_write_to_binlog) if (!res && !lex->no_write_to_binlog)
...@@ -2858,14 +2917,6 @@ mysql_execute_command(THD *thd) ...@@ -2858,14 +2917,6 @@ mysql_execute_command(THD *thd)
lex->drop_temporary); lex->drop_temporary);
} }
break; break;
case SQLCOM_DROP_INDEX:
DBUG_ASSERT(first_table == all_tables && first_table != 0);
if (check_one_table_access(thd, INDEX_ACL, all_tables))
goto error; /* purecov: inspected */
if (end_active_trans(thd))
goto error;
res= mysql_drop_index(thd, first_table, &lex->alter_info);
break;
case SQLCOM_SHOW_PROCESSLIST: case SQLCOM_SHOW_PROCESSLIST:
if (!thd->security_ctx->priv_user[0] && if (!thd->security_ctx->priv_user[0] &&
check_global_access(thd,PROCESS_ACL)) check_global_access(thd,PROCESS_ACL))
...@@ -3005,6 +3056,12 @@ mysql_execute_command(THD *thd) ...@@ -3005,6 +3056,12 @@ mysql_execute_command(THD *thd)
break; break;
case SQLCOM_CREATE_DB: case SQLCOM_CREATE_DB:
{ {
/*
As mysql_create_db() may modify HA_CREATE_INFO structure passed to
it, we need to use a copy of LEX::create_info to make execution
prepared statement- safe.
*/
HA_CREATE_INFO create_info(lex->create_info);
if (end_active_trans(thd)) if (end_active_trans(thd))
{ {
res= -1; res= -1;
...@@ -3037,7 +3094,7 @@ mysql_execute_command(THD *thd) ...@@ -3037,7 +3094,7 @@ mysql_execute_command(THD *thd)
is_schema_db(lex->name.str))) is_schema_db(lex->name.str)))
break; break;
res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias :
lex->name.str), &lex->create_info, 0); lex->name.str), &create_info, 0);
break; break;
} }
case SQLCOM_DROP_DB: case SQLCOM_DROP_DB:
...@@ -3130,6 +3187,7 @@ mysql_execute_command(THD *thd) ...@@ -3130,6 +3187,7 @@ mysql_execute_command(THD *thd)
case SQLCOM_ALTER_DB: case SQLCOM_ALTER_DB:
{ {
LEX_STRING *db= &lex->name; LEX_STRING *db= &lex->name;
HA_CREATE_INFO create_info(lex->create_info);
if (check_db_name(db)) if (check_db_name(db))
{ {
my_error(ER_WRONG_DB_NAME, MYF(0), db->str); my_error(ER_WRONG_DB_NAME, MYF(0), db->str);
...@@ -3159,7 +3217,7 @@ mysql_execute_command(THD *thd) ...@@ -3159,7 +3217,7 @@ mysql_execute_command(THD *thd)
ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0)); ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
goto error; goto error;
} }
res= mysql_alter_db(thd, db->str, &lex->create_info); res= mysql_alter_db(thd, db->str, &create_info);
break; break;
} }
case SQLCOM_SHOW_CREATE_DB: case SQLCOM_SHOW_CREATE_DB:
...@@ -3750,7 +3808,7 @@ mysql_execute_command(THD *thd) ...@@ -3750,7 +3808,7 @@ mysql_execute_command(THD *thd)
goto error; goto error;
} }
my_bool nsok= thd->net.no_send_ok; my_bool save_no_send_ok= thd->net.no_send_ok;
thd->net.no_send_ok= TRUE; thd->net.no_send_ok= TRUE;
if (sp->m_flags & sp_head::MULTI_RESULTS) if (sp->m_flags & sp_head::MULTI_RESULTS)
{ {
...@@ -3761,7 +3819,7 @@ mysql_execute_command(THD *thd) ...@@ -3761,7 +3819,7 @@ mysql_execute_command(THD *thd)
back back
*/ */
my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str); my_error(ER_SP_BADSELECT, MYF(0), sp->m_qname.str);
thd->net.no_send_ok= nsok; thd->net.no_send_ok= save_no_send_ok;
goto error; goto error;
} }
/* /*
...@@ -3777,7 +3835,7 @@ mysql_execute_command(THD *thd) ...@@ -3777,7 +3835,7 @@ mysql_execute_command(THD *thd)
if (check_routine_access(thd, EXECUTE_ACL, if (check_routine_access(thd, EXECUTE_ACL,
sp->m_db.str, sp->m_name.str, TRUE, FALSE)) sp->m_db.str, sp->m_name.str, TRUE, FALSE))
{ {
thd->net.no_send_ok= nsok; thd->net.no_send_ok= save_no_send_ok;
goto error; goto error;
} }
#endif #endif
...@@ -3802,7 +3860,7 @@ mysql_execute_command(THD *thd) ...@@ -3802,7 +3860,7 @@ mysql_execute_command(THD *thd)
thd->variables.select_limit= select_limit; thd->variables.select_limit= select_limit;
thd->net.no_send_ok= nsok; thd->net.no_send_ok= save_no_send_ok;
thd->server_status&= ~bits_to_be_cleared; thd->server_status&= ~bits_to_be_cleared;
if (!res) if (!res)
...@@ -5432,18 +5490,22 @@ bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type, ...@@ -5432,18 +5490,22 @@ bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type,
} }
if (type_modifier & PRI_KEY_FLAG) if (type_modifier & PRI_KEY_FLAG)
{ {
Key *key;
lex->col_list.push_back(new key_part_spec(field_name->str, 0)); lex->col_list.push_back(new key_part_spec(field_name->str, 0));
lex->key_list.push_back(new Key(Key::PRIMARY, NullS, key= new Key(Key::PRIMARY, NullS,
&default_key_create_info, &default_key_create_info,
0, lex->col_list)); 0, lex->col_list);
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); lex->col_list.empty();
} }
if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG)) if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
{ {
Key *key;
lex->col_list.push_back(new key_part_spec(field_name->str, 0)); lex->col_list.push_back(new key_part_spec(field_name->str, 0));
lex->key_list.push_back(new Key(Key::UNIQUE, NullS, key= new Key(Key::UNIQUE, NullS,
&default_key_create_info, 0, &default_key_create_info, 0,
lex->col_list)); lex->col_list);
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); lex->col_list.empty();
} }
...@@ -5503,7 +5565,7 @@ bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type, ...@@ -5503,7 +5565,7 @@ bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type,
interval_list, cs, uint_geom_type)) interval_list, cs, uint_geom_type))
DBUG_RETURN(1); DBUG_RETURN(1);
lex->create_list.push_back(new_field); lex->alter_info.create_list.push_back(new_field);
lex->last_field=new_field; lex->last_field=new_field;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
...@@ -6525,55 +6587,6 @@ Item * all_any_subquery_creator(Item *left_expr, ...@@ -6525,55 +6587,6 @@ Item * all_any_subquery_creator(Item *left_expr,
} }
/*
CREATE INDEX and DROP INDEX are implemented by calling ALTER TABLE with
the proper arguments. This isn't very fast but it should work for most
cases.
In the future ALTER TABLE will notice that only added indexes
and create these one by one for the existing table without having to do
a full rebuild.
One should normally create all indexes with CREATE TABLE or ALTER TABLE.
*/
bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
{
List<create_field> fields;
ALTER_INFO alter_info;
alter_info.flags= ALTER_ADD_INDEX;
HA_CREATE_INFO create_info;
DBUG_ENTER("mysql_create_index");
bzero((char*) &create_info,sizeof(create_info));
create_info.db_type= 0;
create_info.default_table_charset= thd->variables.collation_database;
create_info.row_type= ROW_TYPE_NOT_USED;
DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
&create_info, table_list,
fields, keys, 0, (ORDER*)0,
0, &alter_info, 1));
}
bool mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
{
List<create_field> fields;
List<Key> keys;
HA_CREATE_INFO create_info;
DBUG_ENTER("mysql_drop_index");
bzero((char*) &create_info,sizeof(create_info));
create_info.db_type= 0;
create_info.default_table_charset= thd->variables.collation_database;
create_info.row_type= ROW_TYPE_NOT_USED;
alter_info->clear();
alter_info->flags= ALTER_DROP_INDEX;
DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
&create_info, table_list,
fields, keys, 0, (ORDER*)0,
0, alter_info, 1));
}
/* /*
Multi update query pre-check Multi update query pre-check
...@@ -6885,7 +6898,6 @@ bool create_table_precheck(THD *thd, TABLE_LIST *tables, ...@@ -6885,7 +6898,6 @@ bool create_table_precheck(THD *thd, TABLE_LIST *tables,
want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ? want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
CREATE_TMP_ACL : CREATE_ACL); CREATE_TMP_ACL : CREATE_ACL);
lex->create_info.alias= create_table->alias;
if (check_access(thd, want_priv, create_table->db, if (check_access(thd, want_priv, create_table->db,
&create_table->grant.privilege, 0, 0, &create_table->grant.privilege, 0, 0,
test(create_table->schema_table)) || test(create_table->schema_table)) ||
......
sql/sql_partition.cc
View file @ b11f1d0c
...@@ -141,30 +141,6 @@ int get_part_iter_for_interval_via_walking(partition_info *part_info, ...@@ -141,30 +141,6 @@ int get_part_iter_for_interval_via_walking(partition_info *part_info,
PARTITION_ITERATOR *part_iter); PARTITION_ITERATOR *part_iter);
static void set_up_range_analysis_info(partition_info *part_info); static void set_up_range_analysis_info(partition_info *part_info);
/*
A routine used by the parser to decide whether we are specifying a full
partitioning or if only partitions to add or to split.
SYNOPSIS
is_partition_management()
lex Reference to the lex object
RETURN VALUE
TRUE Yes, it is part of a management partition command
FALSE No, not a management partition command
DESCRIPTION
This needs to be outside of WITH_PARTITION_STORAGE_ENGINE since it is
used from the sql parser that doesn't have any #ifdef's
*/
my_bool is_partition_management(LEX *lex)
{
return (lex->sql_command == SQLCOM_ALTER_TABLE &&
(lex->alter_info.flags == ALTER_ADD_PARTITION ||
lex->alter_info.flags == ALTER_REORGANIZE_PARTITION));
}
#ifdef WITH_PARTITION_STORAGE_ENGINE #ifdef WITH_PARTITION_STORAGE_ENGINE
/* /*
A support function to check if a name is in a list of strings A support function to check if a name is in a list of strings
...@@ -4125,7 +4101,7 @@ static bool check_native_partitioned(HA_CREATE_INFO *create_info,bool *ret_val, ...@@ -4125,7 +4101,7 @@ static bool check_native_partitioned(HA_CREATE_INFO *create_info,bool *ret_val,
change patterns. change patterns.
*/ */
uint prep_alter_part_table(THD *thd, TABLE *table, ALTER_INFO *alter_info, uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
HA_CREATE_INFO *create_info, HA_CREATE_INFO *create_info,
handlerton *old_db_type, handlerton *old_db_type,
bool *partition_changed, bool *partition_changed,
...@@ -5991,8 +5967,6 @@ void handle_alter_part_error(ALTER_PARTITION_PARAM_TYPE *lpt, ...@@ -5991,8 +5967,6 @@ void handle_alter_part_error(ALTER_PARTITION_PARAM_TYPE *lpt,
alter_info ALTER TABLE info alter_info ALTER TABLE info
create_info Create info for CREATE TABLE create_info Create info for CREATE TABLE
table_list List of the table involved table_list List of the table involved
create_list The fields in the resulting table
key_list The keys in the resulting table
db Database name of new table db Database name of new table
table_name Table name of new table table_name Table name of new table
...@@ -6006,11 +5980,10 @@ void handle_alter_part_error(ALTER_PARTITION_PARAM_TYPE *lpt, ...@@ -6006,11 +5980,10 @@ void handle_alter_part_error(ALTER_PARTITION_PARAM_TYPE *lpt,
*/ */
uint fast_alter_partition_table(THD *thd, TABLE *table, uint fast_alter_partition_table(THD *thd, TABLE *table,
ALTER_INFO *alter_info, Alter_info *alter_info,
HA_CREATE_INFO *create_info, HA_CREATE_INFO *create_info,
TABLE_LIST *table_list, TABLE_LIST *table_list,
List<create_field> *create_list, char *db,
List<Key> *key_list, char *db,
const char *table_name, const char *table_name,
uint fast_alter_partition) uint fast_alter_partition)
{ {
...@@ -6027,8 +6000,6 @@ uint fast_alter_partition_table(THD *thd, TABLE *table, ...@@ -6027,8 +6000,6 @@ uint fast_alter_partition_table(THD *thd, TABLE *table,
lpt->part_info= part_info; lpt->part_info= part_info;
lpt->alter_info= alter_info; lpt->alter_info= alter_info;
lpt->create_info= create_info; lpt->create_info= create_info;
lpt->create_list= create_list;
lpt->key_list= key_list;
lpt->db_options= create_info->table_options; lpt->db_options= create_info->table_options;
if (create_info->row_type == ROW_TYPE_DYNAMIC) if (create_info->row_type == ROW_TYPE_DYNAMIC)
lpt->db_options|= HA_OPTION_PACK_RECORD; lpt->db_options|= HA_OPTION_PACK_RECORD;
...@@ -6106,7 +6077,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table, ...@@ -6106,7 +6077,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table,
The first approach here was to downgrade locks. Now a different approach The first approach here was to downgrade locks. Now a different approach
is decided upon. The idea is that the handler will have access to the is decided upon. The idea is that the handler will have access to the
ALTER_INFO when store_lock arrives with TL_WRITE_ALLOW_READ. So if the Alter_info when store_lock arrives with TL_WRITE_ALLOW_READ. So if the
handler knows that this functionality can be handled with a lower lock handler knows that this functionality can be handled with a lower lock
level it will set the lock level to TL_WRITE_ALLOW_WRITE immediately. level it will set the lock level to TL_WRITE_ALLOW_WRITE immediately.
Thus the need to downgrade the lock disappears. Thus the need to downgrade the lock disappears.
...@@ -6379,7 +6350,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table, ...@@ -6379,7 +6350,7 @@ uint fast_alter_partition_table(THD *thd, TABLE *table,
user user
*/ */
DBUG_RETURN(fast_end_partition(thd, lpt->copied, lpt->deleted, DBUG_RETURN(fast_end_partition(thd, lpt->copied, lpt->deleted,
table, table_list, FALSE, lpt, table, table_list, FALSE, NULL,
written_bin_log)); written_bin_log));
} }
#endif #endif
......
sql/sql_table.cc
View file @ b11f1d0c
This source diff could not be displayed because it is too large. You can view the blob instead.
sql/sql_yacc.yy
View file @ b11f1d0c
...@@ -491,7 +491,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); ...@@ -491,7 +491,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%pure_parser /* We have threads */ %pure_parser /* We have threads */
/* /*
Currently there is 287 shift/reduce conflict. We should not introduce Currently there is 286 shift/reduce conflict. We should not introduce
new conflicts any more. new conflicts any more.
*/ */
%expect 286 %expect 286
...@@ -1569,8 +1569,7 @@ create: ...@@ -1569,8 +1569,7 @@ create:
TL_OPTION_UPDATING, TL_OPTION_UPDATING,
TL_WRITE)) TL_WRITE))
MYSQL_YYABORT; MYSQL_YYABORT;
lex->create_list.empty(); lex->alter_info.reset();
lex->key_list.empty();
lex->col_list.empty(); lex->col_list.empty();
lex->change=NullS; lex->change=NullS;
bzero((char*) &lex->create_info,sizeof(lex->create_info)); bzero((char*) &lex->create_info,sizeof(lex->create_info));
...@@ -1603,21 +1602,23 @@ create: ...@@ -1603,21 +1602,23 @@ create:
NULL, NULL,
TL_OPTION_UPDATING)) TL_OPTION_UPDATING))
MYSQL_YYABORT; MYSQL_YYABORT;
lex->create_list.empty(); lex->alter_info.reset();
lex->key_list.empty(); lex->alter_info.flags= ALTER_ADD_INDEX;
lex->col_list.empty(); lex->col_list.empty();
lex->change=NullS; lex->change=NullS;
} }
'(' key_list ')' key_options '(' key_list ')' key_options
{ {
LEX *lex=Lex; LEX *lex=Lex;
Key *key;
if ($2 != Key::FULLTEXT && lex->key_create_info.parser_name.str) if ($2 != Key::FULLTEXT && lex->key_create_info.parser_name.str)
{ {
my_parse_error(ER(ER_SYNTAX_ERROR)); my_parse_error(ER(ER_SYNTAX_ERROR));
MYSQL_YYABORT; MYSQL_YYABORT;
} }
lex->key_list.push_back(new Key($2, $4.str, &lex->key_create_info, 0, key= new Key($2, $4.str, &lex->key_create_info, 0,
lex->col_list)); lex->col_list);
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); lex->col_list.empty();
} }
| CREATE DATABASE opt_if_not_exists ident | CREATE DATABASE opt_if_not_exists ident
...@@ -3931,7 +3932,7 @@ opt_part_values: ...@@ -3931,7 +3932,7 @@ opt_part_values:
/* empty */ /* empty */
{ {
LEX *lex= Lex; LEX *lex= Lex;
if (!is_partition_management(lex)) if (! lex->is_partition_management())
{ {
if (lex->part_info->part_type == RANGE_PARTITION) if (lex->part_info->part_type == RANGE_PARTITION)
{ {
...@@ -3952,7 +3953,7 @@ opt_part_values: ...@@ -3952,7 +3953,7 @@ opt_part_values:
| VALUES LESS_SYM THAN_SYM part_func_max | VALUES LESS_SYM THAN_SYM part_func_max
{ {
LEX *lex= Lex; LEX *lex= Lex;
if (!is_partition_management(lex)) if (! lex->is_partition_management())
{ {
if (Lex->part_info->part_type != RANGE_PARTITION) if (Lex->part_info->part_type != RANGE_PARTITION)
{ {
...@@ -3967,7 +3968,7 @@ opt_part_values: ...@@ -3967,7 +3968,7 @@ opt_part_values:
| VALUES IN_SYM '(' part_list_func ')' | VALUES IN_SYM '(' part_list_func ')'
{ {
LEX *lex= Lex; LEX *lex= Lex;
if (!is_partition_management(lex)) if (! lex->is_partition_management())
{ {
if (Lex->part_info->part_type != LIST_PARTITION) if (Lex->part_info->part_type != LIST_PARTITION)
{ {
...@@ -4478,8 +4479,9 @@ key_def: ...@@ -4478,8 +4479,9 @@ key_def:
my_parse_error(ER(ER_SYNTAX_ERROR)); my_parse_error(ER(ER_SYNTAX_ERROR));
MYSQL_YYABORT; MYSQL_YYABORT;
} }
lex->key_list.push_back(new Key($1,$2, &lex->key_create_info, 0, Key *key= new Key($1, $2, &lex->key_create_info, 0,
lex->col_list)); lex->col_list);
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); /* Alloced by sql_alloc */ lex->col_list.empty(); /* Alloced by sql_alloc */
} }
| opt_constraint constraint_key_type opt_ident key_alg | opt_constraint constraint_key_type opt_ident key_alg
...@@ -4487,24 +4489,27 @@ key_def: ...@@ -4487,24 +4489,27 @@ key_def:
{ {
LEX *lex=Lex; LEX *lex=Lex;
const char *key_name= $3 ? $3 : $1; const char *key_name= $3 ? $3 : $1;
lex->key_list.push_back(new Key($2, key_name, &lex->key_create_info, 0, Key *key= new Key($2, key_name, &lex->key_create_info, 0,
lex->col_list)); lex->col_list);
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); /* Alloced by sql_alloc */ lex->col_list.empty(); /* Alloced by sql_alloc */
} }
| opt_constraint FOREIGN KEY_SYM opt_ident '(' key_list ')' references | opt_constraint FOREIGN KEY_SYM opt_ident '(' key_list ')' references
{ {
LEX *lex=Lex; LEX *lex=Lex;
lex->key_list.push_back(new foreign_key($4 ? $4:$1, lex->col_list, const char *key_name= $4 ? $4 : $1;
$8, Key *key= new foreign_key(key_name, lex->col_list,
lex->ref_list, $8,
lex->fk_delete_opt, lex->ref_list,
lex->fk_update_opt, lex->fk_delete_opt,
lex->fk_match_option)); lex->fk_update_opt,
lex->key_list.push_back(new Key(Key::MULTIPLE, $4 ? $4 : $1, lex->fk_match_option);
&default_key_create_info, 1, lex->alter_info.key_list.push_back(key);
lex->col_list)); key= new Key(Key::MULTIPLE, key_name,
&default_key_create_info, 1,
lex->col_list);
lex->alter_info.key_list.push_back(key);
lex->col_list.empty(); /* Alloced by sql_alloc */ lex->col_list.empty(); /* Alloced by sql_alloc */
/* Only used for ALTER TABLE. Ignored otherwise. */ /* Only used for ALTER TABLE. Ignored otherwise. */
lex->alter_info.flags|= ALTER_FOREIGN_KEY; lex->alter_info.flags|= ALTER_FOREIGN_KEY;
} }
...@@ -5095,8 +5100,7 @@ alter: ...@@ -5095,8 +5100,7 @@ alter:
if (!lex->select_lex.add_table_to_list(thd, $4, NULL, if (!lex->select_lex.add_table_to_list(thd, $4, NULL,
TL_OPTION_UPDATING)) TL_OPTION_UPDATING))
MYSQL_YYABORT; MYSQL_YYABORT;
lex->create_list.empty(); lex->alter_info.reset();
lex->key_list.empty();
lex->col_list.empty(); lex->col_list.empty();
lex->select_lex.init_order(); lex->select_lex.init_order();
lex->select_lex.db= lex->select_lex.db=
...@@ -5105,8 +5109,7 @@ alter: ...@@ -5105,8 +5109,7 @@ alter:
lex->create_info.db_type= 0; lex->create_info.db_type= 0;
lex->create_info.default_table_charset= NULL; lex->create_info.default_table_charset= NULL;
lex->create_info.row_type= ROW_TYPE_NOT_USED; lex->create_info.row_type= ROW_TYPE_NOT_USED;
lex->alter_info.reset(); lex->alter_info.reset();
lex->alter_info.flags= 0;
lex->no_write_to_binlog= 0; lex->no_write_to_binlog= 0;
lex->create_info.storage_media= HA_SM_DEFAULT; lex->create_info.storage_media= HA_SM_DEFAULT;
} }
...@@ -8141,7 +8144,8 @@ drop: ...@@ -8141,7 +8144,8 @@ drop:
{ {
LEX *lex=Lex; LEX *lex=Lex;
lex->sql_command= SQLCOM_DROP_INDEX; lex->sql_command= SQLCOM_DROP_INDEX;
lex->alter_info.drop_list.empty(); lex->alter_info.reset();
lex->alter_info.flags= ALTER_DROP_INDEX;
lex->alter_info.drop_list.push_back(new Alter_drop(Alter_drop::KEY, lex->alter_info.drop_list.push_back(new Alter_drop(Alter_drop::KEY,
$3.str)); $3.str));
if (!lex->current_select->add_table_to_list(lex->thd, $5, NULL, if (!lex->current_select->add_table_to_list(lex->thd, $5, NULL,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7