into bodhi.(none):/opt/local/work/mysql-5.0-runtime
mysql-test/t/sp.test:
Auto merged
sql/item.h:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_show.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
mysql-test/r/innodb_mysql.result:
Manual merge.
mysql-test/t/innodb_mysql.test:
Manual merge.
selected prior: ensure the fix also works for information_schema
tables.
sql/sql_parse.cc:
Ensure the fix for Bug#29050 works for information_schema tables.
causes full table lock on innodb table.
Also fixes Bug#28502 Triggers that update another innodb table
will block on X lock unnecessarily (duplciate).
Code review fixes.
Both bugs' synopses are misleading: InnoDB table is
not X locked. The statements, however, cannot proceed concurrently,
but this happens due to lock conflicts for tables used in triggers,
not for the InnoDB table.
If a user had an InnoDB table, and two triggers, AFTER UPDATE and
AFTER INSERT, competing for different resources (e.g. two distinct
MyISAM tables), then these two triggers would not be able to execute
concurrently. Moreover, INSERTS/UPDATES of the InnoDB table would
not be able to run concurrently.
The problem had other side-effects (see respective bug reports).
This behavior was a consequence of a shortcoming of the pre-locking
algorithm, which would not distinguish between different DML operations
(e.g. INSERT and DELETE) and pre-lock all the tables
that are used by any trigger defined on the subject table.
The idea of the fix is to extend the pre-locking algorithm to keep track,
for each table, what DML operation it is used for and not
load triggers that are known to never be fired.
mysql-test/r/trigger-trans.result:
Update results (Bug#26141)
mysql-test/r/trigger.result:
Update results (Bug#28502)
mysql-test/t/trigger-trans.test:
Add a test case for Bug#26141 mixing table types in trigger causes
full table lock on innodb table.
mysql-test/t/trigger.test:
Add a test case for Bug#28502 Triggers that update another innodb
table will block echo on X lock unnecessarily. Add more test
coverage for triggers.
sql/item.h:
enum trg_event_type is needed in table.h
sql/sp.cc:
Take into account table_list->trg_event_map when determining
what tables to pre-lock.
After this change, if we attempt to fire a
trigger for which we had not pre-locked any tables, error
'Table was not locked with LOCK TABLES' will be printed.
This, however, should never happen, provided the pre-locking
algorithm has no programming bugs.
Previously a trigger key in the sroutines hash was based on the name
of the table the trigger belongs to. This was possible because we would
always add to the pre-locking list all the triggers defined for a table when
handling this table.
Now the key is based on the name of the trigger, owing
to the fact that a trigger name must be unique in the database it
belongs to.
sql/sp_head.cc:
Generate sroutines hash key in init_spname(). This is a convenient
place since there we have all the necessary information and can
avoid an extra alloc.
Maintain and merge trg_event_map when adding and merging elements
of the pre-locking list.
sql/sp_head.h:
Add ,m_sroutines_key member, used when inserting the sphead for a
trigger into the cache of routines used by a statement.
Previously the key was based on the table name the trigger belonged
to, since for a given table we would add to the sroutines list
all the triggers defined on it.
sql/sql_lex.cc:
Introduce a new lex step: set_trg_event_type_for_tables().
It is called when we have finished parsing but before opening
and locking tables. Now this step is used to evaluate for each
TABLE_LIST instance which INSERT/UPDATE/DELETE operation, if any,
it is used in.
In future this method could be extended to aggregate other information
that is hard to aggregate during parsing.
sql/sql_lex.h:
Add declaration for set_trg_event_type_for_tables().
sql/sql_parse.cc:
Call set_trg_event_type_for_tables() after MYSQLparse(). Remove tabs.
sql/sql_prepare.cc:
Call set_trg_event_type_for_tables() after MYSQLparse().
sql/sql_trigger.cc:
Call set_trg_event_type_for_tables() after MYSQLparse().
sql/sql_trigger.h:
Remove an obsolete member.
sql/sql_view.cc:
Call set_trg_event_type_for_tables() after MYSQLparse().
sql/sql_yacc.yy:
Move assignment of sp_head::m_type before calling sp_head::init_spname(),
one is now used inside another.
sql/table.cc:
Implement TABLE_LIST::set_trg_event_map() - a method that calculates
wh triggers may be fired on this table when executing a statement.
sql/table.h:
Add missing declarations.
Move declaration of trg_event_type from item.h (it will be needed for
trg_event_map bitmap when we start using Bitmap template instead
of uint8).
Problem: logging queries not using indexes we check a special flag which
is set only at the server startup and is not changing with a corresponding
server variable together.
Fix: check the variable value instead of the flag.
mysql-test/r/show_check.result:
Fix for bug #28808: log_queries_not_using_indexes variable dynamic change is ignored
- test result.
mysql-test/t/show_check.test:
Fix for bug #28808: log_queries_not_using_indexes variable dynamic change is ignored
- test case.
sql/mysqld.cc:
Fix for bug #28808: log_queries_not_using_indexes variable dynamic change is ignored
- SPECIAL_LOG_QUERIES_NOT_USING_INDEXES is not used anymore.
sql/sql_parse.cc:
Fix for bug #28808: log_queries_not_using_indexes variable dynamic change is ignored
- check opt_log_queries_not_using_indexes instead of
SPECIAL_LOG_QUERIES_NOT_USING_INDEXES flag.
sql/unireg.h:
Fix for bug #28808: log_queries_not_using_indexes variable dynamic change is ignored
- SPECIAL_LOG_QUERIES_NOT_USING_INDEXES is not used anymore.
fails if a database is not selected prior.
The problem manifested itself when a user tried to
create a routine that had non-fully-qualified identifiers in its bodies
and there was no current database selected.
This is a regression introduced by the fix for Bug 19022:
The patch for Bug 19022 changes the code to always produce a warning
if we can't resolve the current database in the parser.
In this case this was not necessary, since even though the produced
parsed tree was incorrect, we never re-use sphead
that was obtained at first parsing of CREATE PROCEDURE.
The sphead that is anyhow used is always obtained through db_load_routine,
and there we change the current database to sphead->m_db before
calling yyparse.
The idea of the fix is to resolve the current database directly using
lex->sphead->m_db member when parsing a stored routine body, when
such is present.
This patch removes the need to reset the current database
when loading a trigger or routine definition into SP cache.
The redundant code will be removed in 5.1.
mysql-test/r/sp.result:
Update test results (Bug#29050)
mysql-test/r/trigger.result:
Update results.
mysql-test/t/sp.test:
Add a test case for Bug#29050
mysql-test/t/trigger.test:
Fix wrong behavior covered with tests.
sql/sql_lex.cc:
Implement st_lex::copy_db_to().
sql/sql_lex.h:
Declare st_lex::copy_db_to().
sql/sql_parse.cc:
Use st_lex::copy_db_to() in add_table_to_list, rather than
THD::copy_db_to(). The former will use the database of the sphead,
if we're parsing a stored routine, not the default database in
THD. The default database is needed to initialize tables->db
when the database part was not explicitly specified in the identifier.
sql/sql_yacc.yy:
Use st_lex::copy_db_to() in the parser, rather than
THD::copy_db_to(). The former will use the database of the sphead,
if we're parsing a stored routine, not the default database in
THD.
LOCK TABLES takes a list of tables to lock. It may lock several
tables successfully and then encounter a tables that it can't lock,
e.g. because it's locked. In such case it needs to undo the locks on
the already locked tables. And it does that. But it has also notified
the relevant table storage engine handlers that they should lock.
The only reliable way to ensure that the table handlers will give up
their locks is to end the transaction. This is what UNLOCK TABLE
does : it ends the transaction if there were locked tables by LOCK
tables.
It is possible to end the transaction when the lock fails in
LOCK TABLES because LOCK TABLES ends the transaction at its start
already.
Fixed by ending (again) the transaction when LOCK TABLES fails to
lock a table.
mysql-test/r/innodb_mysql.result:
Bug #29154: test case
mysql-test/t/innodb_mysql.test:
Bug #29154: test case
sql/sql_parse.cc:
Bug #29154: end the trasaction at a failing
LOCK TABLES so the handler can free its locks.
into adventure.(none):/home/thek/Development/cpp/mysql-5.0-runtime
sql/sql_class.h:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_prepare.cc:
Auto merged
sql/sql_view.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
ALTER VIEW is currently not supported as a prepared statement
and should be disabled as such as they otherwise could cause server crashes.
ALTER VIEW is currently not supported when called from stored
procedures or functions for related reasons and should also be disabled.
This patch disables these DDL statements and adjusts the appropriate test
cases accordingly.
Additional tests has been added to reflect on the fact that we do support
CREATE/ALTER/DROP TABLE for Prepared Statements (PS), Stored Procedures (SP)
and PS within SP.
mysql-test/r/ps_1general.result:
- Updated test to reflect on the new policy to disallow ALTER VIEW within SP.
mysql-test/r/sp-dynamic.result:
- Added PS ALTER TABLE test from within SP-context to demonstrate that CREATE/ALTER/DROP
TABLE statements is working.
- Added PS CREATE/ALTER/DROP VIEW tests from within SP-context to show that
ALTER VIEW is not supported, CREATE VIEW/DROP VIEW are supported.
mysql-test/r/sp-error.result:
- Updated test to reflect on the new policy to disallow VIEW DDL within SP.
mysql-test/t/ps_1general.test:
- Updated test to reflect on the new policy to disallow VIEW DDL within SP.
mysql-test/t/sp-dynamic.test:
- Add PS ALTER TABLE test from within SP to demonstrate that CREATE/ALTER/DROP
TABLE statements are supported.
mysql-test/t/sp-error.test:
- Updated test to reflect on the new policy to disallow ALTER VIEW
within SP-context.
- Changed error code 1314 to the more abstract ER_SP_BADSTATEMENT.
sql/sql_class.h:
- Added comment for clarity
sql/sql_parse.cc:
- Added comment for clarity
sql/sql_prepare.cc:
- Disallow ALTER VIEW as prepared statements until they are
properly supported. Note that SQLCOM_CREATE_VIEW also handles ALTER VIEW
statements.
sql/sql_view.cc:
- converted to doxygen comments
- Added comment for clarity
sql/sql_yacc.yy:
- Disallow ALTER VIEW statements within a SP.
If the parser is operating within the SP context, this is shown
on the sp->sphead pointer. If this flag is set for view DDL operations
we stop parsing with the error 'ER_SP_BAD_STATEMENT'.
into quadxeon.mysql.com:/benchmarks/ext3/TOSAVE/tsmith/bk/maint/jun14/50
configure.in:
Auto merged
mysql-test/mysql-test-run.pl:
Auto merged
mysql-test/r/binlog.result:
Auto merged
mysql-test/r/have_log_bin.require:
Auto merged
BitKeeper/deleted/.del-ctype_cp932_notembedded.test:
Auto merged
mysql-test/t/binlog.test:
Auto merged
mysql-test/t/ctype_cp932_binlog.test:
Auto merged
mysql-test/t/ctype_ucs_binlog.test:
Auto merged
mysql-test/t/flush_block_commit_notembedded.test:
Auto merged
mysql-test/t/insert_select-binlog.test:
Auto merged
mysql-test/t/mysqlbinlog-cp932.test:
Auto merged
mysql-test/t/mysqldump.test:
Auto merged
mysql-test/t/sp_trans.test:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_select.cc:
Auto merged
mysql-test/r/mix_innodb_myisam_binlog.result:
Use local
mysql-test/t/blackhole.test:
manual merge
mysql-test/t/drop_temp_table.test:
manual merge
mysql-test/t/mix_innodb_myisam_binlog.test:
Use local
mysql-test/t/mysqlbinlog.test:
Use local
into mysql.com:/d2/hf/mrg/mysql-5.0-opt
client/mysqltest.c:
Auto merged
sql/field.cc:
Auto merged
sql/field.h:
Auto merged
sql/item.cc:
Auto merged
sql/item.h:
Auto merged
sql/item_cmpfunc.cc:
Auto merged
sql/mysqld.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_prepare.cc:
Auto merged
sql/sql_table.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
mysql-test/r/innodb_mysql.result:
merging
mysql-test/t/innodb_mysql.test:
merging
sql/sql_select.cc:
merging
protocol
Fixed duplicated code, same as last commit.
One could send a malformed packet that caused the server to SEGV. In
recent versions of the password protocol, the client tells the server
what length the ciphertext is (almost always 20). If that length was
large enough to overflow a signed char, then the number would jump to
very large after being casted to unsigned int.
Instead, cast the *passwd char to uchar.
sql/sql_parse.cc:
Additional location of signed-char casted to uint.
protocol
One could send a malformed packet that caused the server to SEGV. In
recent versions of the password protocol, the client tells the server
what length the ciphertext is (almost always 20). If that length was
large enough to overflow a signed char, then the number would jump to
very large after being casted to unsigned int.
Instead, cast the *passwd char to uchar.
sql/sql_parse.cc:
Cast *passwd to get rid of the sign, so that sign extension doesn't
cause the sequence 125, 126, 127, 4294967169, 4294967170.
In case of database level grant the database name may be a pattern,
in case of table|column level grant the database name can not be a pattern.
We use 'dont_check_global_grants' as a flag to determine
if it's database level grant command
(see SQLCOM_GRANT case, mysql_execute_command() function) and
set db_is_pattern according to 'dont_check_global_grants' value.
mysql-test/r/grant2.result:
test result
mysql-test/t/grant2.test:
test case
sql/sql_parse.cc:
In case of database level grant the database name may be a pattern,
in case of table|column level grant the database name can not be a pattern.
We use 'dont_check_global_grants' as a flag to determine
if it's database level grant command
(see SQLCOM_GRANT case, mysql_execute_command() function) and
set db_is_pattern according to 'dont_check_global_grants' value.
into quadxeon.mysql.com:/benchmarks/ext3/TOSAVE/tsmith/bk/maint/jun05/50
mysql-test/mysql-test-run.pl:
Auto merged
mysql-test/t/mysqltest.test:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/mysqld.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_table.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
into pilot.blaudden:/home/msvensson/mysql/mysql-5.0-maint
libmysql/libmysql.c:
Auto merged
sql-common/client.c:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/net_serv.cc:
Auto merged
sql/set_var.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_repl.cc:
Auto merged
- The "mysql client in mysqld"(which is used by
replication and federated) should use alarms instead of setting
socket timeout value if the rest of the server uses alarm. By
always calling 'my_net_set_write_timeout'
or 'my_net_set_read_timeout' when changing the timeout value(s), the
selection whether to use alarms or timeouts will be handled by
ifdef's in those two functions.
- Move declaration of 'vio_timeout' into "vio_priv.h"
include/mysql_com.h:
Move the net_set_*_timeout function declarations to mysql_com.h and
rename to my_net_set_*_timeout to avoid name clashes
include/violite.h:
Move declaration of 'vio_timeout' to vio_priv.h (to make
the function as private as possible)
libmysql/libmysql.c:
Use my_net_read_timeout or my_net_write_timeout when setting
the timeouts. Move the global variables for my_net_read/my_write_timeout
into the only place where they are used. Thus removing them...
server-tools/instance-manager/mysql_connection.cc:
Use my_net_read_timeout or my_net_write_timeout when setting the timeouts
sql-common/client.c:
Use my_net_read_timeout or my_net_write_timeout when setting the timeouts
sql/mysql_priv.h:
Move the net_set_*_timeout function declarations to mysql_com.h
sql/net_serv.cc:
No need to cast the net->write_timeout value from "uint" to "uint"
sql/set_var.cc:
Rename net_set_*_timeout to my_net_set_*_timeout
sql/sql_client.cc:
Use my_net_read_timeout or my_net_write_timeout when setting the timeouts
sql/sql_parse.cc:
Rename net_set_*_timeout to my_net_set_*_timeout
sql/sql_repl.cc:
Rename net_set_*_timeout to my_net_set_*_timeout
vio/vio_priv.h:
Move declaration of 'vio_timeout' to vio_priv.h
vio/viosocket.c:
Cleanup 'vio_timeout'
- Use "const void*" on POSIX and "const char*" on windows for
setsockopt
- Add DBUG_PRINT's
- Add comment about why we don't have an implementation of
vio_timeout for platforms not supporting SO_SNDTIMEO or SO_RCVTIMEO
Bug #23667 "CREATE TABLE LIKE is not isolated from alteration
by other connections"
Bug #18950 "CREATE TABLE LIKE does not obtain LOCK_open"
As well as:
Bug #25578 "CREATE TABLE LIKE does not require any privileges
on source table".
The first and the second bugs resulted in various errors and wrong
binary log order when one tried to execute concurrently CREATE TABLE LIKE
statement and DDL statements on source table or DML/DDL statements on its
target table.
The problem was caused by incomplete protection/table-locking against
concurrent statements implemented in mysql_create_like_table() routine.
We solve it by simply implementing such protection in proper way (see
comment for sql_table.cc for details).
The third bug allowed user who didn't have any privileges on table create
its copy and therefore circumvent privilege check for SHOW CREATE TABLE.
This patch solves this problem by adding privilege check, which was missing.
Finally it also removes some duplicated code from mysql_create_like_table().
Note that, altough tests covering concurrency-related aspects of CREATE TABLE
LIKE behaviour will only be introduced in 5.1, they were run manually for
this patch as well.
mysql-test/r/grant2.result:
Added test for bug#25578 "CREATE TABLE LIKE does not require any privileges
on source table".
mysql-test/t/grant2.test:
Added test for bug#25578 "CREATE TABLE LIKE does not require any privileges
on source table".
sql/handler.h:
Introduced new flag for HA_CREATE_INFO::options in order to be able to
distinguish CREATE TABLE ... LIKE from other types of CREATE TABLE.
sql/mysql_priv.h:
mysql_create_like_table() now takes source table name not as a
Table_ident object but as regular table list element.
sql/sql_parse.cc:
CREATE TABLE ... LIKE implementation now uses statement's table list
for storing information about the source table. We also use flag
in LEX::create_info.options for distinguishing it from other types
of CREATE TABLE.
Finally CREATE TABLE ... LIKE now requires the same privileges on
the source tables as SHOW CREATE TABLE. Moved this privilege check
to check_show_create_table_access() function.
sql/sql_table.cc:
mysql_create_like_table():
- Provided proper protection from concurrent statements.
This is achieved by keeping name-lock on the source table and holding
LOCK_open mutex during whole operation. This gives protection against
concurrent DDL on source table. Also holding this mutex makes copying
of .frm file, call to ha_create_table() and binlogging atomic against
concurrent DML and DDL operations on target table.
- Get rid of duplicated code related to source database/table name
handling. All these operations are already done in
st_select_lex::add_table_to_list(), so we achieve the same effect
by including source table into the statement's table list.
sql/sql_yacc.yy:
Now we use special flag in LEX::create_info::options for distinguishing
CREATE TABLE ... LIKE from other types of CREATE TABLE and store name
of source table as regular element in statement's table list.
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
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()).
allow select into out file from I_S if user has FILE privilege
otherwise issue an error
mysql-test/r/outfile.result:
test result
mysql-test/t/outfile.test:
test case
sql/sql_parse.cc:
allow select into out file from I_S if user has FILE privilege
otherwise issue an error
into weblab.(none):/home/marcsql/TREE/mysql-5.0-rt-merge
mysql-test/t/sp.test:
Auto merged
sql/item.cc:
Auto merged
sql/item_func.cc:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/sql_lex.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
into weblab.(none):/home/marcsql/TREE/mysql-5.0-25411_d
sql/item_func.cc:
Auto merged
sql/log_event.cc:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/slave.cc:
Auto merged
sql/sp.cc:
Auto merged
sql/sp_head.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_prepare.cc:
Auto merged
sql/sql_view.cc:
Auto merged
The issue found with bug 25411 is due to the function skip_rear_comments()
which damages the source code while implementing a work around.
The root cause of the problem is in the lexical analyser, which does not
process special comments properly.
For special comments like :
[1] aaa /*!50000 bbb */ ccc
since 5.0 is a version older that the current code, the parser is in lining
the content of the special comment, so that the query to process is
[2] aaa bbb ccc
However, the text of the query captured when processing a stored procedure,
stored function or trigger (or event in 5.1), can be after rebuilding it:
[3] aaa bbb */ ccc
which is wrong.
To fix bug 25411 properly, the lexical analyser needs to return [2] when
in lining special comments.
In order to implement this, some preliminary cleanup is required in the code,
which is implemented by this patch.
Before this change, the structure named LEX (or st_lex) contains attributes
that belong to lexical analysis, as well as attributes that represents the
abstract syntax tree (AST) of a statement.
Creating a new LEX structure for each statements (which makes sense for the
AST part) also re-initialized the lexical analysis phase each time, which
is conceptually wrong.
With this patch, the previous st_lex structure has been split in two:
- st_lex represents the Abstract Syntax Tree for a statement. The name "lex"
has not been changed to avoid a bigger impact in the code base.
- class lex_input_stream represents the internal state of the lexical
analyser, which by definition should *not* be reinitialized when parsing
multiple statements from the same input stream.
This change is a pre-requisite for bug 25411, since the implementation of
lex_input_stream will later improve to deal properly with special comments,
and this processing can not be done with the current implementation of
sp_head::reset_lex and sp_head::restore_lex, which interfere with the lexer.
This change set alone does not fix bug 25411.
sql/item_func.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/log_event.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/mysql_priv.h:
Refactoring, separate lex_input_stream from st_lex.
sql/slave.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sp.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sp_head.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sp_head.h:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_class.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_class.h:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_lex.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_lex.h:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_parse.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_prepare.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_trigger.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_view.cc:
Refactoring, separate lex_input_stream from st_lex.
sql/sql_yacc.yy:
Refactoring, separate lex_input_stream from st_lex.
into mysql.com:/home/ram/work/b27515/b27515.5.0
mysql-test/r/grant.result:
Auto merged
mysql-test/t/grant.test:
Auto merged
sql/sql_parse.cc:
Auto merged
into mysql.com:/home/ram/work/b27515/b27515.5.0
mysql-test/r/grant.result:
will be merged in a post-merge CS
mysql-test/t/grant.test:
manual merge
sql/sql_parse.cc:
manual merge
Added missed DROP privilege check on the original table for RENAME TABLE command.
mysql-test/r/grant.result:
Fix for bug #27515: DROP previlege is not required anymore for RENAME TABLE
- test result.
mysql-test/t/grant.test:
Fix for bug #27515: DROP previlege is not required anymore for RENAME TABLE
- test case.
sql/sql_parse.cc:
Fix for bug #27515: DROP previlege is not required anymore for RENAME TABLE
- added DROP privilege check on the original table for RENAME TABLE command.
The problem was that THD::db_access variable was not restored after
database switch in stored-routine-execution code.
The fix is to restore THD::db_access in this case.
Unfortunately, this fix requires additional changes,
because in prepare_schema_table(), called on the parsing stage, we checked
privileges. That was wrong according to our design, but this flaw haven't
struck so far, because it was masked. All privilege checkings must be
done on the execution stage in order to be compatible with prepared statements
and stored routines. So, this patch also contains patch for
prepare_schema_table(), which moves the checkings to the execution phase.
mysql-test/r/grant.result:
Updated result file.
mysql-test/t/grant.test:
Added test case for BUG#27337.
sql/mysql_priv.h:
Added function declaration.
sql/sql_db.cc:
Fix for BUG#27337 -- set THD::db_access even if we're called
from stored-routine-execution code.
sql/sql_parse.cc:
Split prepare_schema_table() into two functions:
- prepare_schema_table(), which is called from the parser (parsing stage);
- check_show_access(), which is called on the execution stage.
sql/sql_show.cc:
Ignore schema_select_lex member if its table is NULL.
execution breaks replication.
When a stored routine is executed, we switch current
database to the database, in which the routine
has been created. When the stored routine finishes,
we switch back to the original database.
The problem was that if the original database does not
exist (anymore) after routine execution, we raised an error.
The fix is to report a warning, and switch to the NULL database.
mysql-test/r/sp.result:
Updated result file.
mysql-test/t/sp.test:
Added test case for BUG#25082.
sql/mysql_priv.h:
1. Change mysql_change_db() prototype;
2. Polishing.
sql/sp.cc:
Polishing.
sql/sp_head.cc:
Polishing.
sql/sql_db.cc:
1. Polishing.
2. Fix mysql_change_db().
sql/sql_parse.cc:
Polishing.
sql/sql_show.cc:
Polishing.
give some leeway on required permissions for SHOW FIELDS on views so
an unknonwn DEFINER will no longer break mysqldump
client/client_priv.h:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
New option for mysqldump: redirect stderr to file ("2> for Windows")
client/mysqldump.c:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
New option for mysqldump: redirect stderr to file ("2> for Windows")
mysql-test/r/information_schema_db.result:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
New option for mysqldump: redirect stderr to file ("2> for Windows")
mysql-test/t/information_schema_db.test:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
New option for mysqldump: redirect stderr to file ("2> for Windows")
sql/sql_base.cc:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
be a little more lenient for SHOW FIELDS FROM
sql/sql_parse.cc:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
be a little more lenient for SHOW FIELDS FROM on views on views
sql/sql_view.cc:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
give SHOW FIELDS the same perks as SHOW CREATE
sql/table.cc:
Bug #26817: mysqldump fails to backup database containing view with invalid definer
give SHOW FIELDS the same perks as SHOW CREATE
thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit was not restored at the end of SF() invocation, where
SF() modified non-ta table.
As the result of this artifact it was not possible to detect whether there were any side-effects when
top-level query ends.
If the top level query table was not modified and the bit is lost there would be no binlogging.
Fixed with preserving the bit inside of thd->no_trans_update struct. The struct agregates two bool flags
telling whether the current query and the current transaction modified any non-ta table.
The flags stmt, all are dropped at the end of the query and the transaction.
mysql-test/r/sp_trans.result:
results will be changed once again after bug#23333 will be fixed.
mysql-test/t/sp_trans.test:
regression test added
sql/ha_ndbcluster.cc:
replacing thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit and bool thd->no_trans_update
with thd->no_trans_update as struct
sql/handler.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/log.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/set_var.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sp_head.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sql_class.h:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sql_delete.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sql_insert.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sql_load.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sql_parse.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sql_table.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
sql/sql_update.cc:
replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
with the member thd->no_trans_update.all;
converting thd->no_trans_update into struct of bools.
TABLE ... WRITE".
Memory and CPU hogging occured when connection which had to wait for table
lock was serviced by thread which previously serviced connection that was
killed (note that connections can reuse threads if thread cache is enabled).
One possible scenario which exposed this problem was when thread which
provided binlog dump to replication slave was implicitly/automatically
killed when the same slave reconnected and started pulling data through
different thread/connection.
The problem also occured when one killed particular query in connection
(using KILL QUERY) and later this connection had to wait for some table
lock.
This problem was caused by the fact that thread-specific mysys_var::abort
variable, which indicates that waiting operations on mysys layer should
be aborted (this includes waiting for table locks), was set by kill
operation but was never reset back. So this value was "inherited" by the
following statements or even other connections (which reused the same
physical thread). Such discrepancy between this variable and THD::killed
flag broke logic on SQL-layer and caused CPU and memory hogging.
This patch tries to fix this problem by properly resetting this member.
There is no test-case associated with this patch since it is hard to test
for memory/CPU hogging conditions in our test-suite.
sql/mysqld.cc:
We should not forget to reset THD::mysys_var::abort after kill operation
if we are going to use thread to which this operation was applied for
handling of other connections.
sql/sp_head.cc:
We should not forget to reset THD::mysys_var::abort after kill operation
if we are going to use thread to which this operation was applied for
handling of further statements.
sql/sql_parse.cc:
We should not forget to reset THD::mysys_var::abort after kill operation
if we are going to use thread to which this operation was applied for
handling of further statements.
differences in tables
Certain merge tables were wrongly reported as having incorrect definition:
- Some fields that are 1 byte long (e.g. TINYINT, CHAR(1)), might
be internally casted (in certain cases) to a different type on a
storage engine layer. (affects 4.1 and up)
- If tables in a merge (and a MERGE table itself) had short VARCHAR column (less
than 4 bytes) and at least one (but not all) tables were ALTER'ed (even to an
identical table: ALTER TABLE xxx ENGINE=yyy), table definitions went ouf of
sync. (affects 4.1 only)
This is fixed by relaxing a check for underlying conformance and setting
field type to FIELD_TYPE_STRING in case varchar is shorter than 4
when a table is created.
myisam/mi_create.c:
Added a comment.
mysql-test/r/merge.result:
A test case for bug#26881.
mysql-test/t/merge.test:
A test case for bug#26881.
sql/ha_myisam.cc:
Relaxed some checks performed by check_definition():
As comparing of fulltext keys (and key segments) is not yet implemented,
only return an error in case one of keys is fulltext and other is not.
Otherwise, if both keys are fulltext, accept them as is.
As comparing of spatial keys (and key segments) is not yet implemented,
only return an error in case one of keys is spatial and other is not.
Otherwise, if both keys are spatial, accept them as is.
A workaround to handle situation when field is casted from FIELD_SKIP_ZERO
to FIELD_NORMAL. This could happen only in case field length is 1 and row
format is fixed.
sql/sql_parse.cc:
When a table that has varchar field shorter than 4 is created, field type is
set to FIELD_TYPE_VAR_STRING. Later, when a table is modified using alter
table, field type is changed to FIELD_TYPE_STRING (see Field_string::type).
That means HA_OPTION_PACK_RECORD flag might be lost and thus null_bit might
be shifted by alter table, in other words alter table doesn't create 100%
equal table definition.
This is usually not a problem, since when a table is created/altered,
definition on a storage engine layer is based on one that is passed from
sql layer. But it is a problem for merge engine - null_bit is shifted when
a table (merge or underlying) is altered.
Set field type to FIELD_TYPE_STRING in case FIELD_TYPE_VAR_STRING is shorter
than 4 when a table is created as it is done in Field::type.
into mysql.com:/home/hf/work/mrg/mysql-5.0-opt
mysql-test/r/order_by.result:
Auto merged
mysql-test/r/subselect.result:
Auto merged
mysql-test/t/order_by.test:
Auto merged
mysql-test/t/sp.test:
Auto merged
sql/item.cc:
Auto merged
sql/item_cmpfunc.cc:
Auto merged
sql/item_cmpfunc.h:
Auto merged
sql/item_func.cc:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/sql_base.cc:
Auto merged
sql/sql_insert.cc:
Auto merged
sql/sql_lex.cc:
Auto merged
sql/sql_lex.h:
Auto merged
sql/sql_load.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_select.cc:
Auto merged
sql/sql_update.cc:
Auto merged
mysql-test/r/func_str.result:
merging
mysql-test/r/sp.result:
merging
mysql-test/r/view.result:
merging
mysql-test/t/func_str.test:
merging
mysql-test/t/view.test:
merging
into quadxeon.mysql.com:/benchmarks/ext3/TOSAVE/tsmith/bk/maint/mrg0306/50
sql/mysqld.cc:
Auto merged
sql/sql_class.cc:
Auto merged
sql/sql_class.h:
Auto merged
sql/sql_parse.cc:
Auto merged
fixes).
The legend: on a replication slave, in case a trigger creation
was filtered out because of application of replicate-do-table/
replicate-ignore-table rule, the parsed definition of a trigger was not
cleaned up properly. LEX::sphead member was left around and leaked
memory. Until the actual implementation of support of
replicate-ignore-table rules for triggers by the patch for Bug 24478 it
was never the case that "case SQLCOM_CREATE_TRIGGER"
was not executed once a trigger was parsed,
so the deletion of lex->sphead there worked and the memory did not leak.
The fix:
The real cause of the bug is that there is no 1 or 2 places where
we can clean up the main LEX after parse. And the reason we
can not have just one or two places where we clean up the LEX is
asymmetric behaviour of MYSQLparse in case of success or error.
One of the root causes of this behaviour is the code in Item::Item()
constructor. There, a newly created item adds itself to THD::free_list
- a single-linked list of Items used in a statement. Yuck. This code
is unaware that we may have more than one statement active at a time,
and always assumes that the free_list of the current statement is
located in THD::free_list. One day we need to be able to explicitly
allocate an item in a given Query_arena.
Thus, when parsing a definition of a stored procedure, like
CREATE PROCEDURE p1() BEGIN SELECT a FROM t1; SELECT b FROM t1; END;
we actually need to reset THD::mem_root, THD::free_list and THD::lex
to parse the nested procedure statement (SELECT *).
The actual reset and restore is implemented in semantic actions
attached to sp_proc_stmt grammar rule.
The problem is that in case of a parsing error inside a nested statement
Bison generated parser would abort immediately, without executing the
restore part of the semantic action. This would leave THD in an
in-the-middle-of-parsing state.
This is why we couldn't have had a single place where we clean up the LEX
after MYSQLparse - in case of an error we needed to do a clean up
immediately, in case of success a clean up could have been delayed.
This left the door open for a memory leak.
One of the following possibilities were considered when working on a fix:
- patch the replication logic to do the clean up. Rejected
as breaks module borders, replication code should not need to know the
gory details of clean up procedure after CREATE TRIGGER.
- wrap MYSQLparse with a function that would do a clean up.
Rejected as ideally we should fix the problem when it happens, not
adjust for it outside of the problematic code.
- make sure MYSQLparse cleans up after itself by invoking the clean up
functionality in the appropriate places before return. Implemented in
this patch.
- use %destructor rule for sp_proc_stmt to restore THD - cleaner
than the prevoius approach, but rejected
because needs a careful analysis of the side effects, and this patch is
for 5.0, and long term we need to use the next alternative anyway
- make sure that sp_proc_stmt doesn't juggle with THD - this is a
large work that will affect many modules.
Cleanup: move main_lex and main_mem_root from Statement to its
only two descendants Prepared_statement and THD. This ensures that
when a Statement instance was created for purposes of statement backup,
we do not involve LEX constructor/destructor, which is fairly expensive.
In order to track that the transformation produces equivalent
functionality please check the respective constructors and destructors
of Statement, Prepared_statement and THD - these members were
used only there.
This cleanup is unrelated to the patch.
sql/log_event.cc:
THD::main_lex is private and should not be used.
sql/mysqld.cc:
Move MYSQLerror to sql_yacc.yy as it depends on LEX headers now.
sql/sql_class.cc:
Cleanup: move main_lex and main_mem_root to THD and Prepared_statement
sql/sql_class.h:
Cleanup: move main_lex and main_mem_root to THD and Prepared_statement
sql/sql_lex.cc:
Implement st_lex::restore_lex()
sql/sql_lex.h:
Declare st_lex::restore_lex().
sql/sql_parse.cc:
Consolidate the calls to unit.cleanup() and deletion of lex->sphead
in mysql_parse (COM_QUERY handler)
sql/sql_prepare.cc:
No need to delete lex->sphead to restore memory roots now in case of a
parse error - this is done automatically inside MYSQLparse
sql/sql_trigger.cc:
This code could lead to double deletion apparently, as in case
of an error lex.sphead was never reset.
sql/sql_yacc.yy:
Trap all returns from the parser to ensure that MySQL-specific cleanup
is invoked: we need to restore the global state of THD and LEX in
case of a parsing error. In case of a parsing success this happens as
part of normal grammar reduction process.
into quadxeon.mysql.com:/benchmarks/ext3/TOSAVE/tsmith/bk/maint/mrg0306/50
mysql-test/mysql-test-run.pl:
Auto merged
mysql-test/r/sp.result:
Auto merged
mysql-test/t/sp.test:
Auto merged
sql/item_cmpfunc.cc:
Auto merged
sql/item_cmpfunc.h:
Auto merged
sql/mysqld.cc:
Auto merged
sql/sql_class.cc:
Auto merged
sql/sql_class.h:
Auto merged
sql/sql_parse.cc:
Auto merged
into moonbone.local:/mnt/gentoo64/work/25122-bug-5.0-opt-mysql
sql/mysql_priv.h:
Auto merged
sql/sql_base.cc:
Auto merged
sql/sql_delete.cc:
Auto merged
sql/sql_insert.cc:
Auto merged
sql/sql_load.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_update.cc:
Auto merged
When INSERT is done over a view the table being inserted into is
checked to be unique among all views tables. But if the view contains
self-joined table an error will be thrown even if all tables are used under
different aliases.
The unique_table() function now also checks tables' aliases when needed.
sql/mysql_priv.h:
Bug#25122: Views based on a self-joined table aren't insertable.
Updated prototype of the unique_table() function.
sql/sql_base.cc:
Bug#25122: Views based on a self-joined table aren't insertable.
Now the unique_table() function checks tables' aliases when needed.
sql/sql_delete.cc:
Bug#25122: Views based on a self-joined table aren't insertable.
Updated calls to the unique_table() function.
sql/sql_insert.cc:
Bug#25122: Views based on a self-joined table aren't insertable.
Updated calls to the unique_table() function.
sql/sql_load.cc:
Bug#25122: Views based on a self-joined table aren't insertable.
Updated calls to the unique_table() function.
sql/sql_parse.cc:
Bug#25122: Views based on a self-joined table aren't insertable.
Updated calls to the unique_table() function.
sql/sql_update.cc:
Bug#25122: Views based on a self-joined table aren't insertable.
Updated calls to the unique_table() function.
into weblab.(none):/home/marcsql/TREE/mysql-5.0-rt-merge
mysql-test/mysql-test-run.pl:
Auto merged
mysql-test/t/disabled.def:
Auto merged
server-tools/instance-manager/instance_options.cc:
Auto merged
server-tools/instance-manager/mysqlmanager.cc:
Auto merged
sql/item_cmpfunc.cc:
Auto merged
sql/item_cmpfunc.h:
Auto merged
sql/item_subselect.cc:
Auto merged
sql/item_subselect.h:
Auto merged
sql/sp_head.cc:
Auto merged
sql/sql_base.cc:
Auto merged
sql/sql_class.cc:
Auto merged
sql/sql_lex.cc:
Auto merged
sql/sql_lex.h:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_yacc.yy:
Auto merged
into pilot.blaudden:/home/msvensson/mysql/mysql-5.0-maint
BitKeeper/etc/ignore:
auto-union
client/mysqltest.c:
Auto merged
extra/comp_err.c:
Auto merged
include/my_time.h:
Auto merged
mysql-test/r/innodb.result:
Auto merged
mysql-test/r/mysqltest.result:
Auto merged
mysql-test/r/type_blob.result:
Auto merged
mysql-test/t/mysqltest.test:
Auto merged
sql/item.cc:
Auto merged
sql/item_cmpfunc.cc:
Auto merged
sql/item_cmpfunc.h:
Auto merged
sql/item_strfunc.cc:
Auto merged
sql/log.cc:
Auto merged
sql/mysql_priv.h:
Auto merged
sql/mysqld.cc:
Auto merged
sql/set_var.cc:
Auto merged
sql/sql_class.cc:
Auto merged
sql/sql_class.h:
Auto merged
sql/sql_load.cc:
Auto merged
sql/sql_parse.cc:
Auto merged
sql/sql_select.cc:
Auto merged
sql/tztime.cc:
Auto merged
client/mysql_upgrade.c:
Manual merge
mysql-test/mysql-test-run.pl:
Manual merge
mysql-test/r/ctype_cp932.result:
Manual merge
mysql-test/r/mysqlbinlog.result:
Manual merge
mysql-test/t/ctype_cp932.test:
Manual merge
mysql-test/t/mysql.test:
Manual merge
mysql-test/t/mysqlbinlog.test:
Manual merge
Problem: DROP TRIGGER was not properly handled in combination
with slave filters, which made replication stop
Fix: loading table name before checking slave filters when
dropping a trigger.
mysql-test/r/rpl_replicate_do.result:
Adding test case
mysql-test/t/rpl_replicate_do.test:
Adding test case
sql/sql_parse.cc:
Loading table name when dropping a trigger
before checking slave filtering rules.
sql/sql_trigger.cc:
Making add_table_for_trigger() public
sql/sql_trigger.h:
Making add_table_for_trigger() public
