mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-02-02 03:51:50 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge mysql.com:/home/mydev/mysql-5.1

Browse source 
into  mysql.com:/home/mydev/mysql-5.1-bug5390


sql/sql_parse.cc:
  Auto merged
This commit is contained in:
unknown 2005-12-26 14:22:13 +01:00
commit 78ac54aaf0
12 changed files with 216 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
mysql-test/r/create.result
View file

@ -259,21 +259,6 @@ select * from t1;
0 1 2
0 0 1
drop table t1;
create table t1 select 1,2,3;
create table if not exists t1 select 1,2;
Warnings:
Note 1050 Table 't1' already exists
create table if not exists t1 select 1,2,3,4;
ERROR 21S01: Column count doesn't match value count at row 1
create table if not exists t1 select 1;
Warnings:
Note 1050 Table 't1' already exists
select * from t1;
1 2 3
1 2 3
0 1 2
0 0 1
drop table t1;
create table t1 (a int not null, b int, primary key (a));
insert into t1 values (1,1);
create table if not exists t1 select 2;

49
mysql-test/r/merge.result
View file

@ -722,3 +722,52 @@ SELECT b FROM t2;
b
3
DROP TABLE t1, t2;
create table t1(a int);
create table t2(a int);
insert into t1 values (1);
insert into t2 values (2);
create table t3 (a int) engine=merge union=(t1, t2) insert_method=first;
select * from t3;
a
1
2
insert t2 select * from t2;
select * from t2;
a
2
2
insert t3 select * from t1;
select * from t3;
a
1
1
2
2
insert t1 select * from t3;
select * from t1;
a
1
1
1
1
2
2
select * from t2;
a
2
2
select * from t3;
a
1
1
1
1
2
2
2
2
check table t1, t2;
Table Op Msg_type Msg_text
test.t1 check status OK
test.t2 check status OK
drop table t1, t2, t3;

7
mysql-test/t/create.test
View file

@ -211,13 +211,6 @@ drop table t1;
# bug #1434
#
create table t1 select 1,2,3;
create table if not exists t1 select 1,2;
--error 1136
create table if not exists t1 select 1,2,3,4;
create table if not exists t1 select 1;
select * from t1;
drop table t1;
create table t1 select 1,2,3;
create table if not exists t1 select 1,2;
--error 1136

26
mysql-test/t/merge.test
View file

@ -355,4 +355,30 @@ INSERT INTO t2 (b) VALUES (1) ON DUPLICATE KEY UPDATE b=3;
SELECT b FROM t2;
DROP TABLE t1, t2;
#
# BUG#5390 - problems with merge tables
# Problem #1: INSERT...SELECT
#
#drop table if exists t1, t2, t3;
create table t1(a int);
create table t2(a int);
insert into t1 values (1);
insert into t2 values (2);
create table t3 (a int) engine=merge union=(t1, t2) insert_method=first;
select * from t3;
#
insert t2 select * from t2;
select * from t2;
#
insert t3 select * from t1;
select * from t3;
#
insert t1 select * from t3;
select * from t1;
select * from t2;
select * from t3;
check table t1, t2;
drop table t1, t2, t3;
# End of 4.1 tests

123
sql/lock.cc
View file

@ -428,6 +428,127 @@ MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b)
}
/*
Find duplicate lock in tables.
SYNOPSIS
mysql_lock_have_duplicate()
thd The current thread.
needle The table to check for duplicate lock.
haystack The list of tables to search for the dup lock.
NOTE
This is mainly meant for MERGE tables in INSERT ... SELECT
situations. The 'real', underlying tables can be found only after
the table is opened. The easier way is to check this after the
tables are locked.
RETURN
1 A table from 'tables' matches a lock on 'table'.
0 No duplicate lock is present.
-1 Error.
*/
TABLE_LIST *mysql_lock_have_duplicate(THD *thd, TABLE_LIST *needle,
TABLE_LIST *haystack)
{
uint count;
uint dup_pos;
TABLE *write_lock_used; /* dummy */
TABLE **tables1;
TABLE **tables2;
TABLE **table_ptr;
TABLE_LIST *tlist_ptr;
MYSQL_LOCK *sql_lock1;
MYSQL_LOCK *sql_lock2;
THR_LOCK_DATA **lock_data1;
THR_LOCK_DATA **end_data1;
THR_LOCK_DATA **lock_data2;
THR_LOCK_DATA **end_data2;
THR_LOCK *lock1;
DBUG_ENTER("mysql_lock_have_duplicate");
/* Table may not be defined for derived or view tables. */
if (! needle->table)
DBUG_RETURN(NULL);
/* Get lock(s) for needle. */
tables1= &needle->table;
if (! (sql_lock1= get_lock_data(thd, tables1, 1, 1, &write_lock_used)))
goto err0;
/* Count real tables in list. */
count=0;
for (tlist_ptr = haystack; tlist_ptr; tlist_ptr= tlist_ptr->next_global)
if (! tlist_ptr->placeholder() && ! tlist_ptr->schema_table)
count++;
/* Allocate a table array. */
if (! (tables2= (TABLE**) sql_alloc(sizeof(TABLE*) * count)))
goto err1;
table_ptr= tables2;
/* Assign table pointers. */
for (tlist_ptr = haystack; tlist_ptr; tlist_ptr= tlist_ptr->next_global)
if (! tlist_ptr->placeholder() && ! tlist_ptr->schema_table)
*(table_ptr++)= tlist_ptr->table;
/* Get lock(s) for haystack. */
if (! (sql_lock2= get_lock_data(thd, tables2, count, 1, &write_lock_used)))
goto err1;
/* Initialize duplicate position to an impossible value. */
dup_pos= UINT_MAX;
/*
Find a duplicate lock.
In case of merge tables, sql_lock1 can have more than 1 lock.
*/
for (lock_data1= sql_lock1->locks,
end_data1= lock_data1 + sql_lock1->lock_count;
lock_data1 < end_data1;
lock_data1++)
{
lock1= (*lock_data1)->lock;
for (lock_data2= sql_lock2->locks,
end_data2= lock_data2 + sql_lock2->lock_count;
lock_data2 < end_data2;
lock_data2++)
{
if ((*lock_data2)->lock == lock1)
{
DBUG_PRINT("ingo", ("duplicate lock found"));
/* Change duplicate position to the real value. */
dup_pos= lock_data2 - sql_lock2->locks;
goto end;
}
}
}
end:
tlist_ptr= NULL; /* In case that no duplicate was found. */
if (dup_pos != UINT_MAX)
{
/* Duplicate found. Search the matching TABLE_LIST object. */
count= 0;
for (tlist_ptr = haystack; tlist_ptr; tlist_ptr= tlist_ptr->next_global)
{
if (! tlist_ptr->placeholder() && ! tlist_ptr->schema_table)
{
count+= tlist_ptr->table->file->lock_count();
if (count > dup_pos)
break;
}
}
}
my_free((gptr) sql_lock2, MYF(0));
my_free((gptr) sql_lock1, MYF(0));
DBUG_RETURN(tlist_ptr);
err1:
my_free((gptr) sql_lock1, MYF(0));
err0:
/* This non-null but special value indicates error, if caller cares. */
DBUG_RETURN(needle);
}
/* unlock a set of external */
static int unlock_external(THD *thd, TABLE **table,uint count)
@ -465,8 +586,8 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count,
MYSQL_LOCK *sql_lock;
THR_LOCK_DATA **locks;
TABLE **to;
DBUG_ENTER("get_lock_data");
DBUG_PRINT("info", ("count %d", count));
*write_lock_used=0;
for (i=tables=lock_count=0 ; i < count ; i++)

4
sql/mysql_priv.h
View file

@ -1016,7 +1016,7 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
uint offset_to_list,
const char *db_name,
const char *table_name);
TABLE_LIST *unique_table(TABLE_LIST *table, TABLE_LIST *table_list);
TABLE_LIST *unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list);
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name);
TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list);
bool close_temporary_table(THD *thd, TABLE_LIST *table_list);
@ -1375,6 +1375,8 @@ void mysql_lock_remove(THD *thd, MYSQL_LOCK *locked,TABLE *table);
void mysql_lock_abort(THD *thd, TABLE *table);
bool mysql_lock_abort_for_thread(THD *thd, TABLE *table);
MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b);
TABLE_LIST *mysql_lock_have_duplicate(THD *thd, TABLE_LIST *needle,
TABLE_LIST *haystack);
bool lock_global_read_lock(THD *thd);
void unlock_global_read_lock(THD *thd);
bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh,

10
sql/sql_base.cc
View file

@ -1246,6 +1246,7 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
SYNOPSIS
unique_table()
thd thread handle
table table which should be checked
table_list list of tables
@ -1271,7 +1272,7 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
0 if table is unique
*/
TABLE_LIST* unique_table(TABLE_LIST *table, TABLE_LIST *table_list)
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
{
TABLE_LIST *res;
const char *d_name, *t_name;
@ -1306,9 +1307,10 @@ TABLE_LIST* unique_table(TABLE_LIST *table, TABLE_LIST *table_list)
DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name));
for (;;)
{
if (!(res= find_table_in_global_list(table_list, d_name, t_name)) ||
(!res->table || res->table != table->table) &&
(res->select_lex && !res->select_lex->exclude_from_table_unique_test))
if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
(! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
((!res->table || res->table != table->table) &&
res->select_lex && !res->select_lex->exclude_from_table_unique_test))
break;
/*
If we found entry of this table or or table of SELECT which already

4
sql/sql_delete.cc
View file

@ -374,7 +374,7 @@ bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds)
}
{
TABLE_LIST *duplicate;
if ((duplicate= unique_table(table_list, table_list->next_global)))
if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
{
update_non_unique_table_error(table_list, "DELETE", duplicate);
DBUG_RETURN(TRUE);
@ -464,7 +464,7 @@ bool mysql_multi_delete_prepare(THD *thd)
*/
{
TABLE_LIST *duplicate;
if ((duplicate= unique_table(target_tbl->correspondent_table,
if ((duplicate= unique_table(thd, target_tbl->correspondent_table,
lex->query_tables)))
{
update_non_unique_table_error(target_tbl->correspondent_table,

4
sql/sql_insert.cc
View file

@ -890,7 +890,7 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list,
{
Item *fake_conds= 0;
TABLE_LIST *duplicate;
if ((duplicate= unique_table(table_list, table_list->next_global)))
if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
{
update_non_unique_table_error(table_list, "INSERT", duplicate);
DBUG_RETURN(TRUE);
@ -2228,7 +2228,7 @@ select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
query
*/
if (!(lex->current_select->options & OPTION_BUFFER_RESULT) &&
unique_table(table_list, table_list->next_global))
unique_table(thd, table_list, table_list->next_global))
{
/* Using same table for INSERT and SELECT */
lex->current_select->options|= OPTION_BUFFER_RESULT;

2
sql/sql_load.cc
View file

@ -178,7 +178,7 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list,
table is marked to be 'used for insert' in which case we should never
mark this table as 'const table' (ie, one that has only one row).
*/
if (unique_table(table_list, table_list->next_global))
if (unique_table(thd, table_list, table_list->next_global))
{
my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
DBUG_RETURN(TRUE);

4
sql/sql_parse.cc
View file

@ -2824,7 +2824,7 @@ mysql_execute_command(THD *thd)
if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
{
TABLE_LIST *duplicate;
if ((duplicate= unique_table(create_table, select_tables)))
if ((duplicate= unique_table(thd, create_table, select_tables)))
{
update_non_unique_table_error(create_table, "CREATE", duplicate);
res= 1;
@ -2840,7 +2840,7 @@ mysql_execute_command(THD *thd)
tab= tab->next_local)
{
TABLE_LIST *duplicate;
if ((duplicate= unique_table(tab, select_tables)))
if ((duplicate= unique_table(thd, tab, select_tables)))
{
update_non_unique_table_error(tab, "CREATE", duplicate);
res= 1;

7
sql/sql_update.cc
View file

@ -737,7 +737,7 @@ bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
/* Check that we are not using table that we are updating in a sub select */
{
TABLE_LIST *duplicate;
if ((duplicate= unique_table(table_list, table_list->next_global)))
if ((duplicate= unique_table(thd, table_list, table_list->next_global)))
{
update_non_unique_table_error(table_list, "UPDATE", duplicate);
my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name);
@ -960,7 +960,7 @@ reopen_tables:
tl->lock_type != TL_READ_NO_INSERT)
{
TABLE_LIST *duplicate;
if ((duplicate= unique_table(tl, table_list)))
if ((duplicate= unique_table(thd, tl, table_list)))
{
update_non_unique_table_error(table_list, "UPDATE", duplicate);
DBUG_RETURN(TRUE);
@ -1147,8 +1147,7 @@ int multi_update::prepare(List<Item> &not_used_values,
{
TABLE *table=table_ref->table;
if (!(tables_to_update & table->map) &&
find_table_in_local_list(update_tables, table_ref->db,
table_ref->table_name))
unique_table(thd, table_ref, update_tables))
table->no_cache= 1; // Disable row cache
}
DBUG_RETURN(thd->is_fatal_error != 0);