into bodhi.(none):/opt/local/work/mysql-5.0-runtime
client/mysqldump.c:
Auto merged
mysql-test/r/mysqldump.result:
Auto merged
sql/sql_base.cc:
Auto merged
sql/table.cc:
Auto merged
mysql-test/r/innodb_mysql.result:
Manual merge.
mysql-test/t/innodb_mysql.test:
Manual merge.
sql/sql_table.cc:
Manual merge.
When a table was explicitly locked with LOCK TABLES no associated
tables from any related trigger on the subject table were locked.
As a result of this the user could experience unexpected locking
behavior and statement failures similar to "failed: 1100: Table'xx'
was not locked with LOCK TABLES".
This patch fixes this problem by making sure triggers are
pre-loaded on any statement if the subject table was explicitly
locked with LOCK TABLES.
mysql-test/r/sp-prelocking.result:
Added test case
mysql-test/t/sp-prelocking.test:
Added test case
sql/sql_lex.cc:
- Moved some conditional logic out of the table iteration.
- Added event map values for LOCK TABLE command.
sql/table.cc:
- Refactored set_trg_event_tpye into the two simpler functions set_trg_event_map
and set_trg_event_map as methods for manipulating the table event map.
The original function was only called from st_lex::set_trg_event_type_for_tables
so it was possible to move the event map creation logic to this function as
a loop optimization.
sql/table.h:
- Refactored set_trg_event_tpye into the two simpler functions set_trg_event_map
and set_trg_event_map as methods for manipulating the table event map.
The original function was only called from st_lex::set_trg_event_type_for_tables
so it was possible to move the event map creation logic to this function as
a loop optimization.
between perm and temp tables. Review fixes.
The original bug report complains that if we locked a temporary table
with LOCK TABLES statement, we would not leave LOCK TABLES mode
when this temporary table is dropped.
Additionally, the bug was escalated when it was discovered than
when a temporary transactional table that was previously
locked with LOCK TABLES statement was dropped, futher actions with
this table, such as UNLOCK TABLES, would lead to a crash.
The problem originates from incomplete support of transactional temporary
tables. When we added calls to handler::store_lock()/handler::external_lock()
to operations that work with such tables, we only covered the normal
server code flow and did not cover LOCK TABLES mode.
In LOCK TABLES mode, ::external_lock(LOCK) would sometimes be called without
matching ::external_lock(UNLOCK), e.g. when a transactional temporary table
was dropped. Additionally, this table would be left in the list of LOCKed
TABLES.
The patch aims to address this inadequacy. Now, whenever an instance
of 'handler' is destroyed, we assert that it was priorly
external_lock(UNLOCK)-ed. All the places that violate this assert
were fixed.
This patch introduces no changes in behavior -- the discrepancy in
behavior will be fixed when we start calling ::store_lock()/::external_lock()
for all tables, regardless whether they are transactional or not,
temporary or not.
mysql-test/r/innodb_mysql.result:
Update test results (Bug#24918)
mysql-test/t/innodb_mysql.test:
Add a test case for Bug#24918
sql/handler.h:
Make handler::external_lock() a protected method. Backport from 5.1 its
public wrapper handler::ha_external_lock().
Assert that the handler is not closed if it is still locked.
sql/lock.cc:
In mysql_lock_tables only call lock_external() for the list of tables that
we called store_lock() for.
E.g. get_lock_data() does not add non-transactional temporary tables to the
lock list, so lock_external() should not be called for them.
Use handler::ha_external_lock() instead of handler::external_lock().
Add comments for mysql_lock_remove(), parameterize one strange
side effect that it has. At least in one place where mysql_lock_remove
is used, this side effect is not desired (DROP TABLE). The parameter
will be dropped in 5.1, along with the side effect.
sql/mysql_priv.h:
Update declaration of mysql_lock_remove().
sql/opt_range.cc:
Deploy handler::ha_external_lock() instead of handler::external_lock()
sql/sql_base.cc:
When closing a temporary table, remove the table from the list of LOCKed
TABLES of this thread, in case it's there.
It's there if it is a transactional temporary table.
Use a new declaration of mysql_lock_remove().
sql/sql_class.h:
Extend the comment for THD::temporary_tables.
sql/sql_table.cc:
Deploy handler::ha_external_lock() instead of handler::external_lock()
sql/ha_federated.cc:
remote_error_number is set to -1 when an error was already reported
with my_error(). ER(-1) will also cause a crash on 64bit arch and only
worked on 32bit arch by luck
into gleb.loc:/home/uchum/work/bk/5.0-opt
mysql-test/t/create.test:
Auto merged
sql/field.cc:
Auto merged
sql/sql_base.cc:
Auto merged
sql/table.cc:
Auto merged
mysql-test/r/create.result:
Merge with 5.0 (main).
"Federated Denial of Service"
Federated storage engine used to attempt to open connections within
the ::create() and ::open() methods which are invoked while LOCK_open
mutex is being held by mysqld. As a result, no other client sessions
can open tables while Federated is attempting to open a connection.
Long DNS lookup times would stall mysqld's operation and a rogue
connection string which connects to a remote server which simply
stalls during handshake can stall mysqld for a much longer period of
time.
This patch moves the opening of the connection much later, when the
federated actually issues queries, by which time the LOCK_open mutex is
no longer being held.
mysql-test/r/federated.result:
change of test/results due to patch for bug25679
mysql-test/t/federated.test:
change of test/results due to patch for bug25679
sql/ha_federated.cc:
bug25679
remove function check_foreign_fata_source()
ha_federated::open() no longer opens the federated connection.
ha_federated::create() no longer opens and tests connection.
ha_federated::real_connect() opens connection and tests presence of table.
ha_federated::real_query() sends query, calling real_connect() if neccessary.
sql/ha_federated.h:
bug25679
new methods real_query() and real_connect()
When the SQL_BIG_RESULT flag is specified SELECT should store items from the
select list in the filesort data and use them when sending to a client.
The get_addon_fields function is responsible for creating necessary structures
for that. But this function was allowed to do so only for SELECT and
INSERT .. SELECT queries. This makes the SQL_BIG_RESULT useless for
the CREATE .. SELECT queries.
Now the get_addon_fields allows storing select list items in the filesort
data for the CREATE .. SELECT queries.
mysql-test/t/create.test:
Added a test case for the bug#15130: CREATE .. SELECT was denied to use
advantages of the SQL_BIG_RESULT.
mysql-test/r/create.result:
Added a test case for the bug#15130: CREATE .. SELECT was denied to use
advantages of the SQL_BIG_RESULT.
sql/filesort.cc:
Bug#15130: CREATE .. SELECT was denied to use advantages of the SQL_BIG_RESULT.
Now the get_addon_fields allows storing select list items in the filesort
data for the CREATE .. SELECT queries.
"getGeneratedKeys() does not work with FEDERATED table"
mysql_insert() expected the storage engine to update the row data
during the write_row() operation with the value of the new auto-
increment field. The field must be updated when only one row has
been inserted as mysql_insert() would ignore the thd->last_insert.
This patch implements HA_STATUS_AUTO support in ha_federated::info()
and ensures that ha_federated::write_row() does update the row's
auto-increment value.
The test case was written in C as the protocol's 'id' value is
accessible through libmysqlclient and not via SQL statements.
mysql-test-run.pl was extended to enable running the test binary.
mysql-test/mysql-test-run.pl:
bug25714
implement support to run C test for bug25714
sql/ha_federated.cc:
bug25714
The storage engine instance property auto_increment_value was not
being set.
mysql_insert() requires that the storage engine updates the row with
the auto-increment value, especially when only inserting one row.
Implement support for ha_federated::info(HA_STATUS_AUTO)
tests/Makefile.am:
bug25714
build C test for bug
mysql-test/include/have_bug25714.inc:
New BitKeeper file ``mysql-test/include/have_bug25714.inc''
mysql-test/r/federated_bug_25714.result:
New BitKeeper file ``mysql-test/r/federated_bug_25714.result''
mysql-test/r/have_bug25714.require:
New BitKeeper file ``mysql-test/r/have_bug25714.require''
mysql-test/t/federated_bug_25714.test:
New BitKeeper file ``mysql-test/t/federated_bug_25714.test''
tests/bug25714.c:
New BitKeeper file ``tests/bug25714.c''
In sql/sql_yacc.yy, use the %prec construct at the end of rule join_table
sql/sql_yacc.yy:
In sql/sql_yacc.yy, use the %prec construct at the end of rule join_table
into magare.gmz:/home/kgeorge/mysql/autopush/B29644-5.0-opt
sql/ha_innodb.cc:
Auto merged
sql/sql_base.cc:
Auto merged
mysql-test/r/innodb_mysql.result:
5.0-opt merge
mysql-test/t/innodb_mysql.test:
5.0-opt merge
Limit the fix for bug 28591 to InnoDB only
sql/sql_select.cc:
Limit the fix for bug 28591 to InnoDB only
sql/table.cc:
Limit the fix for bug 28591 to InnoDB only
If a primary key is defined over column c of enum type then
the EXPLAIN command for a look-up query of the form
SELECT * FROM t WHERE c=0
said that the query was with an impossible where condition though the
query correctly returned non-empty result set when the table indeed
contained rows with error empty strings for column c.
This kind of misbehavior was due to a bug in the function
Field_enum::store(longlong,bool) that erroneously returned 1 if
the the value to be stored was equal to 0.
Note that the method
Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
correctly returned 0 if a value of the error empty string
was stored.
mysql-test/r/type_enum.result:
Added a test case for bug #29661.
mysql-test/t/type_enum.test:
Added a test case for bug #29661.
sql/field.cc:
Fixed bug #29611.
If a primary key was defined over column c of enum type then
the EXPLAIN command for a look-up query of the form
SELECT * FROM t WHERE c=0
said that the query was with an impossible where condition though the
query correctly returned non-empty result set when the table indeed
contained rows with error empty strings for column c.
This kind of misbehavior was due to a bug in the function
Field_enum::store(longlong,bool) that erroneously returned 1 if
the the value to be stored was equal to 0.
Note that the method
Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
correctly returned 0 if a value of the error empty string
was stored.
into magare.gmz:/home/kgeorge/mysql/autopush/B28951-5.0-opt
mysql-test/t/innodb_mysql.test:
Auto merged
sql/sql_select.cc:
Auto merged
sql/table.cc:
Auto merged
mysql-test/r/innodb_mysql.result:
merge of 5.0-opt
into olga.mysql.com:/home/igor/dev-opt/mysql-5.0-opt-bug29911
mysql-test/t/having.test:
Auto merged
sql/sql_select.cc:
Auto merged
mysql-test/r/having.result:
SCCS merged
into bodhi.(none):/opt/local/work/mysql-5.0-runtime
mysql-test/r/create.result:
Auto merged
mysql-test/t/create.test:
Auto merged
sql/sql_class.h:
Auto merged
This bug manifested itself for join queries with GROUP BY and HAVING clauses
whose SELECT lists contained DISTINCT. It occurred when the optimizer could
deduce that the result set would have not more than one row.
The bug could lead to wrong result sets for queries of this type because
HAVING conditions were erroneously ignored in some cases in the function
remove_duplicates.
mysql-test/r/having.result:
Added a test case for bug #29911.
mysql-test/t/having.test:
Added a test case for bug #29911.
into mysql.com:/home/kent/bk/tmp3/mysql-5.0-build
libmysql/libmysql.c:
Auto merged
scripts/make_binary_distribution.sh:
Auto merged
sql/field.cc:
Auto merged
ORDER BY primary_key on InnoDB table
Queries that use an InnoDB secondary index to retrieve
data don't need to sort in case of ORDER BY primary key
if the secondary index is compared to constant(s).
They can also skip sorting if ORDER BY contains both the
the secondary key parts and the primary key parts (in
that order).
This is because InnoDB returns the rows in order of the
primary key for rows with the same values of the secondary
key columns.
Fixed by preventing temp table sort for the qualifying
queries.
mysql-test/r/innodb_mysql.result:
Bug #28591: test case
mysql-test/t/innodb_mysql.test:
Bug #28591: test case
sql/sql_select.cc:
Bug #28591: Use the primary key as suffix when testing
if the key can be used for ORDER BY on supporting engines.
sql/table.cc:
Bug #28591: can use the primary key
as a suffix for the secondary keys
by long running transaction
On Windows opened files can't be deleted. There was a special
upgraded lock mode (TL_WRITE instead of TL_WRITE_ALLOW_READ)
in ALTER TABLE to make sure nobody has the table opened
when deleting the old table in ALTER TABLE. This special mode
was causing ALTER TABLE to hang waiting on a lock inside InnoDB.
This special lock is no longer necessary as the server is
closing the tables it needs to delete in ALTER TABLE.
Fixed by removing the special lock.
Note that this also reverses the fix for bug 17264 that deals with
another consequence of this special lock mode being used.
mysql-test/r/innodb_mysql.result:
Bug #29644: test case
mysql-test/t/innodb_mysql.test:
Bug #29644: test case
sql/ha_innodb.cc:
Bug #29644: reverse the (now excessive) fix
for bug 17264 (but leave the test case).
sql/sql_base.cc:
Bug #29644: don't need a special lock mode for Win32 anymore:
the table is closed before the drop.
The Item_date_typecast::val_int function doesn't reset null_value flag.
This makes all values that follows the first null value to be treated as nulls
and led to a wrong result.
Now the Item_date_typecast::val_int function correctly sets the null_value flag
for both null and non-null values.
mysql-test/t/cast.test:
Added a test case for the bug#29898: Item_date_typecast::val_int doesn't reset
the null_value flag.
mysql-test/r/cast.result:
Added a test case for the bug#29898: Item_date_typecast::val_int doesn't reset
the null_value flag.
sql/item_timefunc.cc:
Bug#29898: Item_date_typecast::val_int doesn't reset the null_value flag.
Now the Item_date_typecast::val_int function correctly sets the null_value flag
for both null and non-null values.
a temporary table.
The result string of the Item_func_group_concat wasn't initialized in the
copying constructor of the Item_func_group_concat class. This led to a
wrong charset of GROUP_CONCAT result when the select employs a temporary
table.
The copying constructor of the Item_func_group_concat class now correctly
initializes the charset of the result string.
mysql-test/t/func_gconcat.test:
Added a test case for the bug#29850: Wrong charset of the GROUP_CONCAT result
when the select employs a temporary table.
mysql-test/r/func_gconcat.result:
Added a test case for the bug#29850: Wrong charset of the GROUP_CONCAT result
when the select employs a temporary table.
sql/item_sum.cc:
Bug#29850: Wrong charset of GROUP_CONCAT result when the select employs
a temporary table.
The copying constructor of the Item_func_group_concat class now correctly
initializes the charset of the result string.
No test case, since the bug requires a stress case with 30 INSERT DELAYED
threads and 1 killer thread to repeat. The patch is verified
manually.
Review fixes.
The server that is running DELAYED inserts would deadlock itself
or crash under high load if some of the delayed threads were KILLed
in the meanwhile.
The fix is to change internal lock acquisition order of delayed inserts
subsystem and to ensure that
Delayed_insert::table_list::db does not point to volatile memory in some
cases.
For details, please see a comment for sql_insert.cc.
sql/sql_insert.cc:
A fix for Bug#29431 killing an insert delayed thread causes crash
1) The deadlock was caused by different lock acquisition order
between delayed_get_table and handle_delayed_insert.
delayed_get_table would:
- acquire LOCK_delayed_create
- create a new Delayed_insert instance
- acquire instance mutex (di->mutex)
- "lock the instance in memory" by
increasing di->locked_in_memory variable
- start the delayed thread
- release di->mutex
- let the delayed thread open the delayed table
- discover that the delayed thread was killed
- try to unlock() the delayed insert instance in memory
- in Delayed_insert::unlock() do
* lock LOCK_delayed_insert
* decrease locks_in_memory and discover it's 0
* attempt to lock di->mutex to broadcast di->cond condition <-- deadlock
here
Meanwhile, the delayed thread would
* lock di->mutex
* open the table
* get killed
* not notice that and attempt to lock LOCK_delayed_insert
to register itself in the delayed insert list <-- deadlock here.
Simply put, delayed_get_table used to lock LOCK_delayed_insert and then
di->mutex, and handle_delayed_insert would lock di->mutex and then
LOCK_delayed_insert.
Fixed by moving registration in the list of delayed insert threads from
handle_delayed_insert to delayed_get_table - so that now
handle_delayed_insert doesn't need to acquire LOCK_delayed_insert mutex.
2) di->table_list.db was copied by-pointer from table_list.db of the first
producer -- the one who initiated creation of the delayed insert thread.
This producer might be long gone when the member is needed
(handle_delayed_insert:open_ltable),
e.g. by having been killed with KILL CONNECTION statement.
Fixed by using a pointer to the consumer's deep copy of THD::db.
3) In find_handler, we shouldn't assume that Delayed_insert object
already (or still) has a table opened all the time it is
present in the delayed insert list. E.g. it's not the case
when Delayed_insert decided to terminate, closed the table, but haven't
yet unregistered from the list (see the end of handle_delayed_insert).
Optimization of queries with DETERMINISTIC functions in the
WHERE clause was not effective: sequential scan was always
used.
Now a SF with the DETERMINISTIC flags is treated as constant
when it's arguments are constants (or a SF doesn't has arguments).
sql/item_func.h:
Fixed bug #29338.
The Item_func_sp::used_tables has been removed
(virtual Item_func::used_tables function is enough).
The virtual Item_func_sp::update_used_tables function
has been added.
sql/item_func.cc:
Fixed bug #29338.
The Item_func_sp::update_used_tables and the
Item_func_sp::fix_field functions have been modified
to take into account the DETERMINISTIC flag of SF definition.
mysql-test/r/sp.result:
Updated test case for bug #29338.
mysql-test/t/sp.test:
Updated test case for bug #29338.
to CHECK TABLE
CHECK/REPAIR TABLE reports "File not found" error when issued
against temporary table.
Fixed by disabling a brunch of code (in case it gets temporary table)
that is responsible for updating frm version as it is not needed
for temporary tables.
mysql-test/r/check.result:
A test case for BUG#26325.
mysql-test/t/check.test:
A test case for BUG#26325.
sql/handler.cc:
No need to update frm version in case table was created or checked
by server with the same version. This also ensures that we do not
update frm version for temporary tables as this code doesn't support
temporary tables.
Fix the typo in the constructor. Cover a semantic check that previously
never worked with a test.
mysql-test/r/create.result:
Update results (Bug#26104)
mysql-test/r/innodb.result:
Update results.
mysql-test/t/create.test:
Add a test case for Bug#26104 Bug on foreign key class constructor
mysql-test/t/innodb.test:
Return a new error number (MySQL error instead of internal InnoDB error).
sql/sql_class.h:
A fix for Bug#26104 Bug on foreign key class constructor -- fix
the typo in the constructor
