into adventure.(none):/home/thek/Development/cpp/mysql-5.1-runtime
mysql-test/t/sp-vars.test:
Auto merged
sql/item_func.cc:
Auto merged
sql/item_func.h:
Auto merged
mysql-test/r/sp-vars.result:
manual merge
- Adding variable m_cached_result_type to keep the variable type consistent
during the execution of a statement.
- Before each result set is returned to the client the description of each
column is sent as meta data.
Previously the result type for a column could change if the hash variable
entry changed between statements. This caused the result set of the query
to alternate column types in certain cases which is not supported by MySQL
client-server protocol. Example:
Previously this sequence:
SET @a:=1;
SELECT @a:="text", @a;
would return "text", "text";
After the change the SELECT returns "text", 0
The reson for this is that previously the result set from 'SELECT @a;'
would always be of the type STRING, whereas now the type of the variable
is taken from the last SET statement. However, 'SELECT @a:="text"' will
return type of STRING since the right side of the assignment is used.
mysql-test/r/ps_2myisam.result:
Changed test result because SQL type of a user variable now
more accurately represents its Item type: since Item type of a variable
can be either STRING, INT, DECIMAL or DOUBLE, SQL type of the
result set metadata now can be either MYSQL_TYPE_VARCHAR,
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_NEWDECIMAL or MYSQL_TYPE_DOUBLE.
Previously it was always MYSQL_TYPE_VARCHAR.
In particular, integer variables now have changed from
MYSQL_TYPE_VARCHAR to MYSQL_TYPE_LONGLONG.
mysql-test/r/ps_3innodb.result:
Changed test result because SQL type of a user variable now
more accurately represents its Item type: since Item type of a variable
can be either STRING, INT, DECIMAL or DOUBLE, SQL type of the
result set metadata now can be either MYSQL_TYPE_VARCHAR,
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_NEWDECIMAL or MYSQL_TYPE_DOUBLE.
Previously it was always MYSQL_TYPE_VARCHAR.
In particular, integer variables now have changed from
MYSQL_TYPE_VARCHAR to MYSQL_TYPE_LONGLONG.
mysql-test/r/ps_4heap.result:
Changed test result because SQL type of a user variable now
more accurately represents its Item type: since Item type of a variable
can be either STRING, INT, DECIMAL or DOUBLE, SQL type of the
result set metadata now can be either MYSQL_TYPE_VARCHAR,
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_NEWDECIMAL or MYSQL_TYPE_DOUBLE.
Previously it was always MYSQL_TYPE_VARCHAR.
In particular, integer variables now have changed from
MYSQL_TYPE_VARCHAR to MYSQL_TYPE_LONGLONG.
mysql-test/r/ps_5merge.result:
Changed test result because SQL type of a user variable now
more accurately represents its Item type: since Item type of a variable
can be either STRING, INT, DECIMAL or DOUBLE, SQL type of the
result set metadata now can be either MYSQL_TYPE_VARCHAR,
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_NEWDECIMAL or MYSQL_TYPE_DOUBLE.
Previously it was always MYSQL_TYPE_VARCHAR.
In particular, integer variables now have changed from
MYSQL_TYPE_VARCHAR to MYSQL_TYPE_LONGLONG.
mysql-test/r/ps_7ndb.result:
Changed test result because SQL type of a user variable now
more accurately represents its Item type: since Item type of a variable
can be either STRING, INT, DECIMAL or DOUBLE, SQL type of the
result set metadata now can be either MYSQL_TYPE_VARCHAR,
MYSQL_TYPE_LONGLONG, MYSQL_TYPE_NEWDECIMAL or MYSQL_TYPE_DOUBLE.
Previously it was always MYSQL_TYPE_VARCHAR.
In particular, integer variables now have changed from
MYSQL_TYPE_VARCHAR to MYSQL_TYPE_LONGLONG.
mysql-test/r/sp-vars.result:
Added test case. Previously variables could change their variable type during
the execution of a statement.
Which variable type to use in the statement is specified in
any previous statement.
mysql-test/r/type_date.result:
This test case result is changed because it is no longer allowed for user
variables to change their variable type during the execution of a statement.
The determination of which variable type to use in the statement is specified in
any previous statement.
mysql-test/r/user_var.result:
This test case result is changed because it is no longer allowed for user
variables to change their variable type during the execution of a statement.
The determination of which variable type to use in the statement is specified in
any previous statement.
mysql-test/t/sp-vars.test:
Added test case. Previously variables could change their variable type during
the execution of a statement.
Which variable type to use in the statement is specified in
any previous statement.
mysql-test/t/type_date.test:
This test case result is changed because it is no longer allowed for user
variables to change their variable type during the execution of a statement.
The determination of which variable type to use in the statement is specified in
any previous statement.
sql/item_func.cc:
Adding variable m_cached_result_type to keep the variable type consistent
during the execution of a statement.
Previously the result type could change if the hash variable entry changed
between statements. This caused the result set of the query to alternate
column types in certain cases.
sql/item_func.h:
Adding variable m_cached_result_type to keep the variable type consistent
during the execution of a statement.
Previously the result type could change if the hash variable entry changed
between statements. This caused the result set of the query to alternate
column types in certain cases.
into vajra.(none):/opt/local/work/mysql-5.1-runtime
mysql-test/r/sp-error.result:
Auto merged
mysql-test/r/sp-prelocking.result:
Auto merged
mysql-test/r/trigger.result:
Auto merged
mysql-test/t/sp-error.test:
Auto merged
mysql-test/t/sp-prelocking.test:
Auto merged
mysql-test/t/trigger.test:
Auto merged
sql/sql_base.cc:
Auto merged
Adjust the check that defines the error message to be returned.
mysql-test/r/sp-error.result:
Update results (more accurate error code)
mysql-test/r/sp-prelocking.result:
Update results (more accurate error code)
mysql-test/r/trigger.result:
Update results (more accurate error code)
mysql-test/t/sp-error.test:
ER_NOT_LOCKED -> ER_NO_SUCH_TABLE
mysql-test/t/sp-prelocking.test:
Add a test case for Bug#27907
mysql-test/t/trigger.test:
ER_NOT_LOCKED -> ER_NO_SUCH_TABLE
sql/sql_base.cc:
Adjust the check for where-we-are for a better error message.
into adventure.(none):/home/thek/Development/cpp/bug27415/my51-bug27415
mysql-test/r/sp-vars.result:
Auto merged
mysql-test/t/sp-vars.test:
Auto merged
- Problem was reported as a SP variable using itself as
right value inside SUBSTR caused corruption of data.
- This bug could not be verified in either 5.0bk or 5.1bk
- Added test case to prevent future regressions.
mysql-test/r/sp-vars.result:
Added test case for a reported regression which couldn't be
verified.
mysql-test/t/sp-vars.test:
Added test case for a reported regression which couldn't be
verified.
(Bug#26338 "events_bugs.test fail on Debian")
mysql-test/r/events_bugs.result:
Update results.
mysql-test/t/events_bugs.test:
Make a stab at fixing events_bugs.test failure on Debian.
The problem is purely in the race inherent in the test case: an
event that was started doesn't go away fast enough and clutters the
processlist. This patch remove the part of the event that
we can not wait on synchronously (there is no table 'hashed_num'
referenced anywhere).
into vajra.(none):/opt/local/work/mysql-5.1-21483
sql/sp_head.cc:
Auto merged
sql/sql_base.cc:
Auto merged
sql/sql_lex.h:
Auto merged
mysql-test/r/insert.result:
Manual merge.
mysql-test/t/insert.test:
Manual merge.
sql/sql_insert.cc:
Manual merge.
into vajra.(none):/opt/local/work/mysql-5.0-21483
sql/sp_head.cc:
Auto merged
sql/sql_base.cc:
Auto merged
sql/sql_insert.cc:
Auto merged
sql/sql_lex.h:
Auto merged
Bug#21483 "Server abort or deadlock on INSERT DELAYED with another
implicit insert"
Also fixes and adds test cases for bugs:
20497 "Trigger with INSERT DELAYED causes Error 1165"
21714 "Wrong NEW.value and server abort on INSERT DELAYED to a
table with a trigger".
Post-review fixes.
Problem:
In MySQL INSERT DELAYED is a way to pipe all inserts into a
given table through a dedicated thread. This is necessary for
simplistic storage engines like MyISAM, which do not have internal
concurrency control or threading and thus can not
achieve efficient INSERT throughput without support from SQL layer.
DELAYED INSERT works as follows:
For every distinct table, which can accept DELAYED inserts and has
pending data to insert, a dedicated thread is created to write data
to disk. All user connection threads that attempt to
delayed-insert into this table interact with the dedicated thread in
producer/consumer fashion: all records to-be inserted are pushed
into a queue of the dedicated thread, which fetches the records and
writes them.
In this design, client connection threads never open or lock
the delayed insert table.
This functionality was introduced in version 3.23 and does not take
into account existence of triggers, views, or pre-locking.
E.g. if INSERT DELAYED is called from a stored function, which,
in turn, is called from another stored function that uses the delayed
table, a deadlock can occur, because delayed locking by-passes
pre-locking. Besides:
* the delayed thread works directly with the subject table through
the storage engine API and does not invoke triggers
* even if it was patched to invoke triggers, if triggers,
in turn, used other tables, the delayed thread would
have to open and lock involved tables (use pre-locking).
* even if it was patched to use pre-locking, without deadlock
detection the delayed thread could easily lock out user
connection threads in case when the same table is used both
in a trigger and on the right side of the insert query:
the delayed thread would not release locks until all inserts
are complete, and user connection can not complete inserts
without having locks on the tables used on the right side of the
query.
Solution:
These considerations suggest two general alternatives for the
future of INSERT DELAYED:
* it is considered a full-fledged alternative to normal INSERT
* it is regarded as an optimisation that is only relevant
for simplistic engines.
Since we missed our chance to provide complete support of new
features when 5.0 was in development, the first alternative
currently renders infeasible.
However, even the second alternative, which is to detect
new features and convert DELAYED insert into a normal insert,
is not easy to implement.
The catch-22 is that we don't know if the subject table has triggers
or is a view before we open it, and we only open it in the
delayed thread. We don't know if the query involves pre-locking
until we have opened all tables, and we always first create
the delayed thread, and only then open the remaining tables.
This patch detects the problematic scenarios and converts
DELAYED INSERT to a normal INSERT using the following approach:
* if the statement is executed under pre-locking (e.g. from
within a stored function or trigger) or the right
side may require pre-locking, we detect the situation
before creating a delayed insert thread and convert the statement
to a conventional INSERT.
* if the subject table is a view or has triggers, we shutdown
the delayed thread and convert the statement to a conventional
INSERT.
mysql-test/r/insert.result:
Update test results.
mysql-test/t/insert.test:
Add a test case for Bug#21483, Bug#20497, Bug#21714 (INSERT DELAYED
and stored routines, triggers).
sql/sp_head.cc:
Upgrade lock type to TL_WRITE when computing the pre-locking set.
sql/sql_base.cc:
Use a new method.
sql/sql_insert.cc:
INSERT DELAYED and pre-locking:
- if under pre-locking, upgrade the lock type to TL_WRITE
and proceed as a normal write
- if DELAYED table has triggers, also request a lock upgrade.
- make sure errors in the delayed thread are propagated
correctly
sql/sql_lex.h:
Add a method to check if a parsed tree refers to stored
routines.
into vajra.(none):/opt/local/work/mysql-5.1-runtime
mysql-test/include/mix1.inc:
Auto merged
mysql-test/r/innodb_mysql.result:
Auto merged
mysql-test/r/ps_1general.result:
Auto merged
mysql-test/t/disabled.def:
Auto merged
mysql-test/t/ps_1general.test:
Auto merged
sql/ha_ndbcluster.cc:
Auto merged
sql/ha_ndbcluster_binlog.cc:
Auto merged
sql/item.cc:
Auto merged
sql/item_func.cc:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/set_var.cc:
Auto merged
sql/sql_base.cc:
Auto merged
sql/sql_cache.cc:
Auto merged
sql/sql_class.cc:
Auto merged
sql/sql_class.h:
Auto merged
sql/sql_lex.cc:
Auto merged
sql/sql_lex.h:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_partition.cc:
Auto merged
sql/sql_prepare.cc:
Auto merged
sql/sql_table.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
sql/table.h:
Auto merged
sql/sql_insert.cc:
SCCS merged
into vajra.(none):/opt/local/work/mysql-5.0-runtime
sql/item.cc:
Auto merged
sql/item_func.cc:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/set_var.cc:
Auto merged
sql/sql_class.h:
Auto merged
sql/sql_insert.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_prepare.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
TABLES" and failures of alter_table.test on Windows which occured after
pushing fix for bugs #20662, #20903, #24508, #24738 (various problems
with CREATE TABLE SELECT).
ALTER TABLE statements which were handled using "fast" alter table
optimization were not properly working under LOCK TABLES if table
was transactional (for all table types under Windows).
Code implementing "fast" version of ALTER TABLE tried to open and
lock table using open_ltable() after renaming .FRM files (which
corresponds to renaming tables in normal case) in some cases
(for transactional tables or on Windows). This caused problems
under LOCK TABLES and conflicted with name-lock taken by
ALTER TABLE RENAME on target tables.
This patch solves this issue by using reopen_name_locked_table()
instead of open_ltable().
mysql-test/include/mix1.inc:
Added test for bug #28415 "Some ALTER TABLE statements no longer work
under LOCK TABLES" and minimal coverage for fast ALTER TABLE behaviour
for transactional tables.
mysql-test/r/innodb_mysql.result:
Added test for bug #28415 "Some ALTER TABLE statements no longer work
under LOCK TABLES" and minimal coverage for fast ALTER TABLE behaviour
for transactional tables.
sql/sql_table.cc:
mysql_alter_table():
Fixed handling of transactional tables (and all tables on Windows)
by "fast" ALTER TABLE.
Code implementing "fast" version of ALTER TABLE tried to open and
lock table using open_ltable() after renaming .FRM files (which
corresponds to renaming tables in normal case) for such tables.
This caused problems under LOCK TABLES and conflicted with name-lock
taken by ALTER TABLE RENAME on target tables. We solve this issue by
using reopen_name_locked_table() instead of open_ltable().
into olga.mysql.com:/home/igor/mysql-5.1-opt
mysql-test/r/subselect3.result:
Auto merged
sql/item_subselect.cc:
Auto merged
sql/sql_select.h:
Auto merged
a crash when the left operand of the predicate is evaluated to NULL.
It happens when the rows from the inner tables (tables from the subquery)
are accessed by index methods with key values obtained by evaluation of
the left operand of the subquery predicate. When this predicate is
evaluated to NULL an alternative access with full table scan is used
to check whether the result set returned by the subquery is empty or not.
The crash was due to the fact the info about the access methods used for
regular key values was not properly restored after a switch back from the
full scan access method had occurred.
The patch restores this info properly.
The same problem existed for queries with IN subquery predicates if they
were used not at the top level of the queries.
mysql-test/r/subselect3.result:
Added a test case for bug #28375.
mysql-test/t/subselect3.test:
Added a test case for bug #28375.
sql/item_subselect.cc:
Fixed bug #28375: a query with an NOT IN subquery predicate may cause
a crash when the left operand of the predicate is evaluated to NULL.
It happens when the rows from the inner tables (tables from the subquery)
are accessed by index methods with key values obtained by evaluation of
the left operand of the subquery predicate. When this predicate is
evaluated to NULL an alternative access with full table scan is used
to check whether the result set returned by the subquery is empty or not.
The crash was due to the fact the info about the access methods used for
regular key values was not properly restored after a switch back from the
full scan access method had occurred.
The patch restores this info properly.
sql/sql_select.h:
Fixed bug #28375: a query with an NOT IN subquery predicate may cause
a crash when the left operand of the predicate is evaluated to NULL.
In the JOIN_TAB structure two fields have been added to save info about
index methods used to access the subquery rows. The saved info is used
after a switch back from the alternative full scan access method has
occurred. The full scan is used when the left operand of the subquery
predicate is evaluated to NULL.
Corrected test case for the bug#27878.
mysql-test/t/grant.test:
Corrected test case for the bug#27878.
mysql-test/r/grant.result:
Corrected test case for the bug#27878.
into mysql.com:/home/hf/work/27957/my51-27957
mysql-test/t/grant.test:
Auto merged
mysql-test/r/grant.result:
merging
sql/sql_update.cc:
Auto merged
sql/sql_prepare.cc:
Auto merged
database.
If a user has a right to update anything in the current database then the
access was granted and further checks of access rights for underlying tables
wasn't done correctly. The check is done before a view is opened and thus no
check of access rights for underlying tables can be carried out.
This allows a user to update through a view a table from another database for
which he hasn't enough rights.
Now the mysql_update() and the mysql_test_update() functions are forces
re-checking of access rights after a view is opened.
mysql-test/t/grant.test:
Added a test case for the bug#27878: Unchecked privileges on a view referring to a table from another database.
mysql-test/r/grant.result:
Added a test case for the bug#27878: Unchecked privileges on a view referring to a table from another database.
sql/sql_update.cc:
Bug#27878: Unchecked privileges on a view referring to a table from another
database.
Now the mysql_update() function forces re-checking of access rights after
the view is opened.
sql/sql_prepare.cc:
Bug#27878: Unchecked privileges on a view referring to a table from another
database.
Now the mysql_test_update() function forces re-checking of access rights after
the view is opened.
into mockturtle.local:/home/dlenev/src/mysql-5.0-cts-3
sql/mysql_priv.h:
Auto merged
sql/sql_insert.cc:
Auto merged
sql/sql_prepare.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
into mockturtle.local:/home/dlenev/src/mysql-5.1-cts-3
sql/mysql_priv.h:
Auto merged
sql/sql_insert.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_prepare.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
Bug #20662 "Infinite loop in CREATE TABLE IF NOT EXISTS ... SELECT
with locked tables"
Bug #20903 "Crash when using CREATE TABLE .. SELECT and triggers"
Bug #24738 "CREATE TABLE ... SELECT is not isolated properly"
Bug #24508 "Inconsistent results of CREATE TABLE ... SELECT when
temporary table exists"
Deadlock occured when one tried to execute CREATE TABLE IF NOT
EXISTS ... SELECT statement under LOCK TABLES which held
read lock on target table.
Attempt to execute the same statement for already existing
target table with triggers caused server crashes.
Also concurrent execution of CREATE TABLE ... SELECT statement
and other statements involving target table suffered from
various races (some of which might've led to deadlocks).
Finally, attempt to execute CREATE TABLE ... SELECT in case
when a temporary table with same name was already present
led to the insertion of data into this temporary table and
creation of empty non-temporary table.
All above problems stemmed from the old implementation of CREATE
TABLE ... SELECT in which we created, opened and locked target
table without any special protection in a separate step and not
with the rest of tables used by this statement.
This underminded deadlock-avoidance approach used in server
and created window for races. It also excluded target table
from prelocking causing problems with trigger execution.
The patch solves these problems by implementing new approach to
handling of CREATE TABLE ... SELECT for base tables.
We try to open and lock table to be created at the same time as
the rest of tables used by this statement. If such table does not
exist at this moment we create and place in the table cache special
placeholder for it which prevents its creation or any other usage
by other threads.
We still use old approach for creation of temporary tables.
Note that we have separate fix for 5.0 since there we use slightly
different less intrusive approach.
mysql-test/r/create.result:
Extended test coverage for CREATE TABLE ... SELECT. In particular added
tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
when temporary table exists" and bug #20662 "Infinite loop in CREATE
TABLE IF NOT EXISTS ... SELECT with locked tables".
mysql-test/r/trigger.result:
Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
and triggers"
mysql-test/t/create.test:
Extended test coverage for CREATE TABLE ... SELECT. In particular added
tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
when temporary table exists" and bug #20662 "Infinite loop in CREATE
TABLE IF NOT EXISTS ... SELECT with locked tables".
mysql-test/t/trigger.test:
Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
and triggers"
sql/lock.cc:
Now for creation of name-lock placeholder lock_table_name() uses
auxiliary function table_cache_insert_placeholder().
sql/mysql_priv.h:
Removed declaration of non-existing build_table_path() routine.
The former mysql_create_table_internal() was renamed to
mysql_create_table_no_lock() and now exposed to other modules to
give them opportunity of creation of tables in cases when name-lock
is already obtained.
reopen_name_locked_table() now has 3rd argument which controls linking
in of table being opened into THD::open_tables (this is useful in
cases when placeholder used for name-locking is already linked into
this list).
Added declaration of auxiliary function table_cache_insert_placeholder()
which is used for creation of table placeholders for name-locking.
Added declaration of lock_table_name_if_not_cached() which can be
used to take an exclusive name-lock on table if there are no records
for it in table cache.
Changed signature of unlink_open_table() function to simplify its use
and make it useful for table placeholders and tables that are only open.
Added auxiliary drop_open_table() routine.
Moved declaration of refresh_version to table.h header to make it
accessible from inline methods of TABLE class.
MYSQL_OPEN_IGNORE_LOCKED_TABLES flag is no longer used. Instead
MYSQL_OPEN_TEMPORARY_ONLY option was added.
sql/sql_base.cc:
Added support for the new approach to the handling of CREATE TABLE
... SELECT for base tables.
Now we try to open and lock table to be created at the same time as
the rest of tables used by this statement. If such table does not
exist at this moment we create and place in the table cache special
placeholder for it which prevents its creation or any other usage
by other threads.
Note significant distinctions of this placeholder from the placeholder
used for normal name-lock: 1) It is treated like open table by other
name-locks so it does not allow name-lock taking operations like DROP
TABLE or RENAME TABLE to proceed. 2) it is linked into THD::open_tables
list and automatically removed during close_thread_tables() call
open_tables():
Implemented logic described above. To do this added
auxiliary check_if_table_exists() function.
Removed support for MYSQL_OPEN_IGNORE_LOCKED_TABLES option
which is no longer used.
Added MYSQL_OPEN_TEMPORARY_ONLY which is used to restrict
search for temporary tables only.
close_cached_tables()/close_thread_table()/reopen_tables()/
close_old_data_files()/table_is_used()/remove_table_from_cache():
Added support for open placeholders (note that we also use them
when we need to re-open tables during flush).
unlink_open_table():
Changed function signature to simplify its use and to make
useful for open placeholders and tables which are only
open and not locked.
Added auxiliary drop_open_table() routine.
reopen_name_locked_table():
Now has 3rd argument which controls linking in of table being
opened into THD::open_tables (this is useful in cases when
placeholder used for name-locking is already linked into
this list).
Added auxiliary table_cache_insert_placeholder() routine which
simplifies creation of placeholders used for name-locking.
Added lock_table_name_if_not_cached() which can be used to take
an exclusive name-lock on table if there are no records for it
in table cache.
sql/sql_handler.cc:
Adjusted mysql_ha_mark_tables_for_reopen() routine to properly
handle placeholders which now can be linked into open tables
list.
sql/sql_insert.cc:
Introduced new approach to handling of base tables in CREATE TABLE
... SELECT statement.
Now we try to open and lock table to be created at the same time as
the rest of tables used by this statement. If such table does not
exist at this moment we create and place in the table cache special
placeholder for it which prevents its creation or any other usage
by other threads. By doing this we avoid races which existed with
previous approach in which we created, opened and locked target in
separate step without any special protection.
This also allows properly calculate prelocking set in cases when
target table already exists and has some on insert triggers.
Note that we don't employ the same approach for temporary tables
(this is okay as such tables are unaffected by other threads).
Changed create_table_from_items() and methods of select_create
class to implement this approach.
sql/sql_parse.cc:
The new approach to handling of CREATE TABLE ... SELECT for
base tables assumes that all tables (including table to be
created) are opened and (or) locked at the same time.
So in cases when we create base table we have to pass to
open_and_lock_tables() table list which includes target table.
sql/sql_prepare.cc:
The new approach to handling of CREATE TABLE ... SELECT for
base tables assumes that all tables (including table to be
created) are opened and (or) locked at the same time.
So in cases when we create base table we have to pass to
open_and_lock_tables() table list which includes target table.
sql/sql_table.cc:
Changed mysql_create_table(), mysql_create_like_table() and
mysql_alter_table() (in rename case) to obtain exclusive name-lock
on the non-temporary table which is going to be created (to which
we going to rename). This ensures that not only destination table
doesn't exist on disk but also that there are no placeholder in
table cache for it (i.e. there is no CREATE TABLE ... SELECT operation
in progress for it). Note that to avoid deadlocks while taking these
name-locks this code assumes that existence of any record for table in
table cache (even name-lock) means that table exists. Altough such
check can lead to false positives these should occur only in case of
highly concurrent DDL operations on the table and should not break
binary logging.
Renamed mysql_create_table_internal() to mysql_create_table_no_lock()
and made it accessible from other files to give them ability to create
table in situation when name-lock is already obtained or not relevant.
Adjusted calls to reopen_name_locked_table(), which now takes
extra argument, which controls linking of open table into
THD::open_tables list.
Removed redundant setting of table's 'version' field before calls
to close_cached_table(). This function will set it to 0 itself
anyway.
sql/sql_trigger.cc:
reopen_name_locked_tables() now has one more argument which controls
linking of opened table into the THD::open_tables list.
sql/sql_yacc.yy:
The new approach to handling of CREATE TABLE ... SELECT statement
for base tables assumes that all tables including table to be
created are open and (or) locked at the same time. Therefore
we need to set correct lock for target table.
sql/table.h:
Moved declaration of refresh_version variable from mysql_priv.h
to make it accessible from inline methods of TABLE class.
Renamed TABLE::locked_by_flush member to open_placeholder since
now it is also used for taking exclusive name-lock and not only
by flush.
Introduced TABLE::is_name_opened() helper method which can be used
to distinguish TABLE instances corresponding to open tables or
placeholders for them from closed instances (e.g. due to their old
version). Also introduced TABLE::needs_reopen_or_name_lock() helper
which allows to check if TABLE instance corresponds to outdated
version of table or to name-lock placeholder.
Introduced TABLE_LIST::create member which marks elements of
table list corresponds to the table to be created.
Adjusted TABLE_LIST::placeholder() method to take into account
name-lock placeholders for tables to be created (this, for example,
allows to properly handle such placeholders in lock_tables()).
Finally, moved currently unused TABLE::open_next/open_prev
members under ifdef NOT_YET.
mysql-test/r/create_select-big.result:
New BitKeeper file ``mysql-test/r/create_select-big.result''
mysql-test/t/create_select-big.test:
New BitKeeper file ``mysql-test/t/create_select-big.test''
Bug #20662 "Infinite loop in CREATE TABLE IF NOT EXISTS ... SELECT
with locked tables"
Bug #20903 "Crash when using CREATE TABLE .. SELECT and triggers"
Bug #24738 "CREATE TABLE ... SELECT is not isolated properly"
Bug #24508 "Inconsistent results of CREATE TABLE ... SELECT when
temporary table exists"
Deadlock occured when one tried to execute CREATE TABLE IF NOT
EXISTS ... SELECT statement under LOCK TABLES which held
read lock on target table.
Attempt to execute the same statement for already existing
target table with triggers caused server crashes.
Also concurrent execution of CREATE TABLE ... SELECT statement
and other statements involving target table suffered from
various races (some of which might've led to deadlocks).
Finally, attempt to execute CREATE TABLE ... SELECT in case
when a temporary table with same name was already present
led to the insertion of data into this temporary table and
creation of empty non-temporary table.
All above problems stemmed from the old implementation of CREATE
TABLE ... SELECT in which we created, opened and locked target
table without any special protection in a separate step and not
with the rest of tables used by this statement.
This underminded deadlock-avoidance approach used in server
and created window for races. It also excluded target table
from prelocking causing problems with trigger execution.
The patch solves these problems by implementing new approach to
handling of CREATE TABLE ... SELECT for base tables.
We try to open and lock table to be created at the same time as
the rest of tables used by this statement. If such table does not
exist at this moment we create and place in the table cache special
placeholder for it which prevents its creation or any other usage
by other threads.
We still use old approach for creation of temporary tables.
Also note that we decided to postpone introduction of some tests
for concurrent behaviour of CREATE TABLE ... SELECT till 5.1.
The main reason for this is absence in 5.0 ability to set @@debug
variable at runtime, which can be circumvented only by using several
test files with individual .opt files. Since the latter is likely
to slowdown test-suite unnecessary we chose not to push this tests
into 5.0, but run them manually for this version and later push
their optimized version into 5.1
mysql-test/r/create.result:
Extended test coverage for CREATE TABLE ... SELECT. In particular added
tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
when temporary table exists" and bug #20662 "Infinite loop in CREATE
TABLE IF NOT EXISTS ... SELECT with locked tables".
mysql-test/r/trigger.result:
Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
and triggers"
mysql-test/t/create.test:
Extended test coverage for CREATE TABLE ... SELECT. In particular added
tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
when temporary table exists" and bug #20662 "Infinite loop in CREATE
TABLE IF NOT EXISTS ... SELECT with locked tables".
mysql-test/t/trigger.test:
Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
and triggers"
sql/lock.cc:
Now for creation of name-lock placeholder in lock_table_name() we use
auxiliary function table_cache_insert_placeholder().
sql/mysql_priv.h:
Made build_table_path() function available outside of sql_table.cc file.
reopen_name_locked_table() now has 3rd argument which controls linking
in of table being opened into THD::open_tables (this is useful in
cases when placeholder used for name-locking is already linked into
this list).
Added declaration of auxiliary function table_cache_insert_placeholder()
which is used for creation of table placeholders for name-locking.
Added declaration of table_cache_has_open_placeholder() function which
can be used for checking if table cache contains an open placeholder for
the table and if this placeholder was created by another thread.
(This function is needed only in 5.0 where we use it in various versions
of CREATE TABLE in order to protect it from concurrent CREATE TABLE
... SELECT operations for the table. Starting from 5.1 we use different
approach so it is going to be removed there).
Made close_old_data_files() static within sql_base.cc file.
Added auxiliary drop_open_table() routine.
Moved declaration of refresh_version to table.h header to make it
accessible from inline methods of TABLE class.
MYSQL_OPEN_IGNORE_LOCKED_TABLES flag is no longer used. Instead
MYSQL_OPEN_TEMPORARY_ONLY option was added.
sql/sql_base.cc:
Added support for the new approach to the handling of CREATE TABLE
... SELECT for base tables.
Now we try to open and lock table to be created at the same time as
the rest of tables used by this statement. If such table does not
exist at this moment we create and place in the table cache special
placeholder for it which prevents its creation or any other usage
by other threads.
Note significant distinctions of this placeholder from the placeholder
used for normal name-lock: 1) It is treated like open table by other
name-locks so it does not allow name-lock taking operations like DROP
TABLE or RENAME TABLE to proceed. 2) it is linked into THD::open_tables
list and automatically removed during close_thread_tables() call.
open_tables():
Implemented logic described above. To do this added
auxiliary check_if_table_exists() function.
Removed support for MYSQL_OPEN_IGNORE_LOCKED_TABLES option
which is no longer used.
Added MYSQL_OPEN_TEMPORARY_ONLY which is used to restrict
search for temporary tables only.
close_cached_tables()/close_thread_table()/reopen_tables()/
close_old_data_files()/table_is_used()/remove_table_from_cache():
Added support for open placeholders (note that we also use them
when we need to re-open tables during flush).
Added auxiliary drop_open_table() routine.
reopen_name_locked_table():
Now has 3rd argument which controls linking in of table being
opened into THD::open_tables (this is useful in cases when
placeholder used for name-locking is already linked into
this list).
Added auxiliary table_cache_insert_placeholder() routine which
simplifies creation of placeholders used for name-locking.
Added table_cache_has_open_placeholder() function which can be
used for checking if table cache contains an open placeholder for
the table and if this placeholder was created by another thread.
(This function is needed only in 5.0 where we use it in various versions
of CREATE TABLE in order to protect it from concurrent CREATE TABLE
... SELECT operations for the table. Starting from 5.1 we use different
approach so it is going to be removed there).
sql/sql_handler.cc:
Adjusted mysql_ha_mark_tables_for_reopen() routine to properly
handle placeholders which now can be linked into open tables
list.
sql/sql_insert.cc:
Introduced new approach to handling of base tables in CREATE TABLE
... SELECT statement.
Now we try to open and lock table to be created at the same time as
the rest of tables used by this statement. If such table does not
exist at this moment we create and place in the table cache special
placeholder for it which prevents its creation or any other usage
by other threads. By doing this we avoid races which existed with
previous approach in which we created, opened and locked target in
separate step without any special protection.
This also allows properly calculate prelocking set in cases when
target table already exists and has some on insert triggers.
Note that we don't employ the same approach for temporary tables
(this is okay as such tables are unaffected by other threads).
Changed create_table_from_items() and select_create methods to
implement this approach.
sql/sql_parse.cc:
The new approach to handling of CREATE TABLE ... SELECT for
base tables assumes that all tables (including table to be
created) are opened and (or) locked at the same time.
So in cases when we create base table we have to pass to
open_and_lock_tables() table list which includes target table.
sql/sql_prepare.cc:
The new approach to handling of CREATE TABLE ... SELECT for
base tables assumes that all tables (including table to be
created) are opened and (or) locked at the same time.
So in cases when we create base table we have to pass to
open_and_lock_tables() table list which includes target table.
sql/sql_table.cc:
Now mysql_create_table_internal(), mysql_create_like_table() and
mysql_alter_table() not only check that destination table doesn't
exist on disk but also check that there is no create placeholder
in table cache for it (i.e. there is no CREATE TABLE ... SELECT
operation in progress for it). Note that starting from 5.1 we
use different approach in order to to protect CREATE TABLE ... SELECT
from concurrent CREATE TABLE (ALTER TABLE ... RENAME) operations,
the latter simply take name-locks on table before its creation
(on target table name before renaming).
Also made build_table_path() available from other files and
asjusted calls to reopen_name_locked_table(), which now takes
extra argument, which controls linking of open table into
THD::open_tables list.
sql/sql_trigger.cc:
reopen_name_locked_tables() now has one more argument which controls
linking of opened table into the THD::open_tables list.
sql/sql_yacc.yy:
The new approach to handling of CREATE TABLE ... SELECT statement
for base tables assumes that all tables including table to be
created are open and (or) locked at the same time. Therefore
we need to set correct lock for target table.
sql/table.h:
Moved declaration of refresh_version variable from mysql_priv.h
to make it accessible from inline methods of TABLE class.
Renamed TABLE::locked_by_flush member to open_placeholder since
now it is also used for taking exclusive name-lock and not only
by flush.
Introduced TABLE::is_name_opened() helper method which can be used
to distinguish TABLE instances corresponding to open tables or
placeholders for them from closed instances (e.g. due to their old
version). Also introduced TABLE::needs_reopen_or_name_lock() helper
which allows to check if TABLE instance corresponds to outdated
version of table or to name-lock placeholder.
Introduced TABLE_LIST::create member which marks elements of
table list corresponds to the table to be created.
Adjusted TABLE_LIST::placeholder() method to take into account
name-lock placeholders for tables to be created (this, for example,
allows to properly handle such placeholders in lock_tables()).
into vajra.(none):/opt/local/work/mysql-5.1-runtime
mysql-test/r/ps.result:
Auto merged
mysql-test/r/ps_1general.result:
Auto merged
mysql-test/t/ps.test:
Auto merged
mysql-test/t/ps_1general.test:
Auto merged
sql/sql_lex.cc:
Auto merged
sql/sql_lex.h:
Auto merged
sql/sql_yacc.yy:
Auto merged
sql/sql_prepare.cc:
Manual merge.
by moving yet another relevant flag to it from struct LEX.
mysql-test/r/ps.result:
Update result.
mysql-test/r/ps_1general.result:
Update result.
mysql-test/t/ps.test:
New error code.
mysql-test/t/ps_1general.test:
New error code.
sql/sql_lex.cc:
Move stmt_prepare_mode to Lex_input_stream.
sql/sql_lex.h:
Move stmt_prepare_mode to class Lex_input_stream
sql/sql_prepare.cc:
Move stmt_prepare_mode to Lex_input_stream
sql/sql_yacc.yy:
Remove dead code.
into mysql.com:/home/hf/work/27957/my51-27957
mysql-test/r/cast.result:
Auto merged
sql/item_create.cc:
Auto merged
sql/item_func.cc:
Auto merged
sql/item_func.h:
Auto merged
sql/my_decimal.h:
Auto merged
sql/sql_yacc.yy:
Auto merged
into mysql.com:/home/hf/work/27957/my50-27957
mysql-test/r/cast.result:
Auto merged
sql/item_func.cc:
Auto merged
sql/item_func.h:
Auto merged
sql/my_decimal.h:
merging
into mysql.com:/home/hf/work/27957/my51-27957
mysql-test/r/insert_update.result:
Auto merged
mysql-test/t/insert_update.test:
Auto merged
sql/item_func.cc:
Auto merged
sql/sql_insert.cc:
Auto merged
mysql-test/include/mix1.inc:
merging
mysql-test/r/innodb_mysql.result:
SCCS merged
sql/sql_select.cc:
merging
into mysql.com:/home/hf/work/27957/my51-27957
include/decimal.h:
Auto merged
mysql-test/r/type_newdecimal.result:
Auto merged
mysql-test/t/type_newdecimal.test:
Auto merged
sql/item_func.cc:
Auto merged
strings/decimal.c:
Auto merged
mysql-test/r/cast.result:
merging
sql/my_decimal.h:
merging
