in stored procedure.
The problem was that MySQL used unnecessarily large amounts of
memory if user variables were used as an argument to CONCAT or
CONCAT_WS -- 16M per each user variable used.
Technically, it happened because MySQL used the following
allocation strategy for string functions to avoid multiple
realloc() calls: in the virtual operation fix_length_and_dec()
the attribute max_length was calculated as a sum of max_length
values for each argument.
Although this approach worked well for small (or fixed) data types,
there could be a problem if there as a user variable among
the arguments of a string function -- max_length of the function
would be 16M (as the max_length of a user variable is 16M).
Both CONCAT() and CONCAT_WS() functions suffer from this problem.
The fix is to do not use meta-data for allocating memory.
The following strategy is proposed instead: allocate the exact
length of the result string at the first record, double the amount
of memory allocated when it is required.
No test case for this bug because there is no way to test memory
consumption in a robust way with our test suite.
sql/item_strfunc.cc:
Implement memory-wise allocation strategy.
loose index scan enabled for subqueries
mysql-test/r/group_min_max.result:
Bug #31974: test case updates
loose index scan enabled for subqueries
mysql-test/r/index_merge_myisam.result:
Bug #31974: test case updates
loose index scan enabled for subqueries
into lambda.hsd1.co.comcast.net.:/home/malff/TREE/mysql-5.1-rt-merge
sql/handler.cc:
Auto merged
sql/log_event.cc:
Auto merged
sql/sql_update.cc:
Auto merged
The fix for bug 31148 is not correct. It does not
have a relation to the problem described in this bug.
And removing the fix will not make the bug to re-appear.
Fixed the bug #31974 by removing the fix for bug 31148
and adding a test case.
mysql-test/r/key.result:
Bug #31974: test case
mysql-test/t/key.test:
Bug #31974: test case
sql/sql_select.cc:
Bug #31974: revert the fix for bug 31148
error evaluating WHERE"
DELETE with a subquery in WHERE clause would sometimes ignore subquery
evaluation error and proceed with deletion.
The fix is to check for an error after evaluation of the WHERE clause
in DELETE.
Addressed review comments.
mysql-test/r/group_min_max.result:
Update the test results to reflect the fix for Bug#32030.
mysql-test/r/ps.result:
Update test results (Bug#32030)
mysql-test/t/group_min_max.test:
Update the test case to reflect the fix for Bug#32030
mysql-test/t/ps.test:
Add a test case for Bug#32030
sql/sql_delete.cc:
Check for an error before calling send_ok(). Two different places are
covered because the subquery code has slightly different execution
paths depending on ps-protocol/old-protocol
If a stored function that contains a drop temporary table statement
is invoked by a create temporary table of the same name may cause
a server crash. The problem is that when dropping a table no check
is done to ensure that table is not being used by some outer query
(or outer statement), potentially leaving the outer query with a
reference to a stale (freed) table.
The solution is when dropping a temporary table, always check if
the table is being used by some outer statement as a temporary
table can be dropped inside stored procedures.
The check is performed by looking at the TABLE::query_id value for
temporary tables. To simplify this check and to solve a bug related
to handling of temporary tables in prelocked mode, this patch changes
the way in which this member is used to track the fact that table is
used/unused. Now we ensure that TABLE::query_id is zero for unused
temporary tables (which means that all temporary tables which were
used by a statement should be marked as free for reuse after it's
execution has been completed).
mysql-test/include/handler.inc:
Add test case for side effect of Bug#30882
mysql-test/r/handler_innodb.result:
Add test case result for side effect of Bug#30882
mysql-test/r/handler_myisam.result:
Add test case result for side effect of Bug#30882
mysql-test/r/sp-error.result:
Add test case result for Bug#30882
mysql-test/t/sp-error.test:
Add test case for Bug#30882
sql/event_db_repository.cc:
Update close_thread_tables call, no more default values.
sql/mysql_priv.h:
Remove implicit default parameters values of the close_thread_tables
function as no callers are using it.
sql/slave.cc:
Update close_thread_tables call, no more default values
sql/sp_head.cc:
Update close_thread_tables call, no more default values
sql/sql_base.cc:
Changed the approach to distinguishing currently unused temporary tables.
Now we ensure that such tables always have TABLE::query_id set to 0 and
use this fact to perform checks during opening and dropping of temporary
tables. This means that we have to call close_thread_tables() even for
statements which use only temporary tables. To make this call cheaper,
we re-factored close_thread_tables() to not take LOCK_open unless there
are open base tables.
sql/sql_handler.cc:
Properly close temporary tables associated with a handler.
sql/sql_insert.cc:
close_temporary_table is now merged into drop_temporary_table.
sql/sql_parse.cc:
Now the condition doesn't cover all cases because close_thread_tables()
must be called even for statements that use only temporary tables.
sql/sql_table.cc:
Use drop_temporary_table which perform checks to verify if
the table is not being used. Error path problem is due to
a handler tables issue and is going to be addressed in bug
31397.
sql/table.h:
Rename previously unused clear_query_id and document the usage of
query_id and open_by_handler.
The mysql_change_user command fails to properly update the database pointer
when no database is selected, leading to "use after free" errors. The same
happens on the user privilege pointer in the thread security context.
The solution is to properly reset and update the database name. Also update
the user_priv pointer so that it doesn't point to freed memory.
sql/sql_connect.cc:
After a successful call to check_user() without specifying a new
database name, the previous database thd->db) is freed but the
pointer is not updated to NULL.
sql/sql_parse.cc:
Update the security_ctx->priv_user pointer as it is a alias for
the user security_ctx->user pointer. Also remove unneeded cast,
the x_free macro casts the argument.
there is nothing to recover.
Discovered while working on Bug#12713
sql/sql_table.cc:
Use MYF(0) in my_open() in read_ddl_log_header() called from
execute_ddl_log_recovery() called during the server start up to not
generate an error if no ddl log exists. This is not an erroneous situation,
in fact it's the case in any server statrtup. The error was lost
anyway, since it was pushed into the stack of the artificial thd.
error in mysql_create_frm instead of
direct access to my_error() members.
This is a pre-requisite for the patch for Bug#12713.
sql/unireg.cc:
Use Internal_error_handler mechanism to silence ER_TOO_MANY_FIELDS
error in mysql_create_frm instead of
direct access to my_error() members.
in evaluate_join_record().
A minor cleanup required for the fix for Bug#12713.
sql/sql_select.cc:
Use thd->is_error() instead of direct access to thd->net.report_error
in evaluate_join_record()
Fix uninitialized variable causing failures for some interpreted update
operations on gcc 4.2.1.
ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp:
Fix uninitialized variable causing failures for some interpreted update
operations on gcc 4.2.1.
storage/ndb/test/include/dbutil.hpp:
Hearder file for SQL Database Utilities class for adding MySQL SQL abilities to NDB API tests cases.
storage/ndb/test/src/dbutil.cpp:
Implementation file for SQL Database Utilities class for adding MySQL SQL abilities to NDB API tests cases.
storage/ndb/test/src/Makefile.am:
Updated to include dbutil
during udf initialization. The bug is spotted while working on Bug 12713.
If a user-defined function was used in a SELECT statement, and an
error would occur during UDF initialization, this error would not terminate
execution of the SELECT, but rather would be converted to a warning.
The fix is to use a stack buffer to store the message from udf_init instead
of private my_error() buffer.
mysql-test/r/udf.result:
Update the result to reflect the fix for Bug#32007 select udf_function()
doesn't return an error if error during udf initialization
mysql-test/t/udf.test:
Update the test to reflect the fix for Bug #32007 select udf_function()
doesn't return an error if error during udf initialization
sql/item_func.cc:
A fix for Bug#32007.
net.last_error buffer was used to store the temporary message from udf_init.
Then, when my_error() was called, net.last_error was not empty so
my_error() would conclude that there is already an error in the error stack,
and not "overwrite" it.
However, thd->net.report_error was not set, so the the
SELECT was not aborted.
The fix is to use a stack buffer instead of thd->net.last_error
to store the message from udf_init. The message will end up in
thd->net.last_error anyway after a call to my_error.
check_user()/check_connection()/check_for_max_user_connections().
This is a pre-requisite patch for the fix for Bug#12713 "Error in a stored
function called from a SELECT doesn't cause ROLLBACK of statem"
Implement review comments.
sql/mysql_priv.h:
check_for_max_user_connections() is used in one place only, make it static.
sql/mysqld.cc:
Remove net_printf_error(): a consolidation of error reporting facilities
is necessary to simplify maintenance of the query cache, the
client-server protocol, stored procedure continue handlers.
Rewrite the only place where its use is somewhat justified
(my_error() can not be used since we need to report an error for the thread
that does not exist) with my_snprintf()/net_send_error().
sql/protocol.cc:
Remove net_printf_error().
sql/protocol.h:
Remove net_printf_error().
sql/sql_connect.cc:
Remove net_printf_error(). In check_connection()/check_user()/
check_for_max_user_connections() do not write directly to the network,
but use the standard my_error() mechanism to record an error in THD.
It will be sent to the client by the caller. This was the last place
in the server that would attempt to send an error directly, mainly left
untouched by 5.0 refactoring because it is executed only during
thread startup.
sql/sql_parse.cc:
In the old code, when res was greater than 0, it contained an exact
error code, e.g. ER_OUT_OF_RESOURCES or NO SUCH DATABASE,
or ER_HANDSHAKE_ERROR. I don't know the reason why this error code was
ignored, and instead a generic ER_UNKNOWN_COM_ERROR was pushed into the
error stack, but knowing the relaxed attitude towards preserving the error
codes in the old code, I'm inclinded to think that it was a bug.
After this patch, the most specific error message is already pushed,
so calling my_message() again is useless.
If res is < 0, the error used to be already sent. This is not done
by the new code, but will be done later, in the end
of dispatch_command(). When this is done, clear_error() will be called
for us - it is in the first lines of do_command.
To sum up, this change is to remove COM_CHANGE_USER specific error handling
in favor of the standard one employed for all other COM_* commands.
sql-common/client.c:
Move a block of auxiliary functions to the beginning of the file,
to avoid compilation warnings on Windows.
Add comments, albeit trivial, while we're at it.
Add select_send::cleanup.
Fix a compilation warning.
Issues spotted while working on the fix for Bug#12713.
sql-common/client.c:
Fix a warning.
sql/sql_class.cc:
Give a variable a more specific name. Rewrite an incorrect comment.
Add a cleanup for select_send. The only case now this cleanup can be
necessary is when we have a prepared statement inside a stored procedure,
and a continue handler. At first execution, the statement is killed
after having executed select_send::send_fields. At the second execution
it is killed after having executed select_send::send_fields.
sql/sql_class.h:
Rename a member. Add comments.
No functionality added or changed.
This is a pre-requisite for the fix for Bug#12713 Error in a stored
function called from a SELECT doesn't cause ROLLBACK of statem
Address post-review comments.
include/sql_common.h:
Declare auxiliary functions to manipulate mysql.net.last_er* and
mysql_stmt.last_er*
libmysql/libmysql.c:
Use helper functions to set an error in MYSQL or MYSQL_STMT
libmysqld/lib_sql.cc:
Use helper functions to set an error in MYSQL or MYSQL_STMT
sql-common/client.c:
Use helper functions to set an error in MYSQL or MYSQL_STMT
Dropping users causes huge increase in memory usage because field values were
allocated on the server memory root for temporary usage but never deallocated.
This patch changes the target memory root to be that of the thread handler
instead since this root is cleared between each statement.
sql/sql_acl.cc:
Changed memory root from server life time memory to thread life time memory.
