mirror of
https://github.com/MariaDB/server.git
synced 2025-01-22 06:44:16 +01:00
186 commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
unknown
|
164ce4c5cd |
Recursion support made for SP (BUG#10100).
client/mysqltest.c:
An expected error messages hiding from the log if disable_result_log is in force.
mysql-test/r/sp-dynamic.result:
The test expanded for case of allowed/disalowed recursion.
mysql-test/r/sp-error.result:
Error messages changed.
Test of bug11394() made with allowed recursion.
mysql-test/r/sp.result:
Tests for recursion.
mysql-test/r/trigger.result:
Check that triggers are not affected by this patch.
mysql-test/r/variables.result:
Test of max_sp_recursion_depth variable.
mysql-test/t/sp-dynamic.test:
The test expanded for case of allowed/disalowed recursion.
mysql-test/t/sp-error.test:
Error messages changed.
Test of bug11394() made with allowed recursion.
mysql-test/t/sp.test:
Tests for recursion.
mysql-test/t/trigger.test:
Check that triggers are not affected by this patch.
mysql-test/t/variables.test:
Test of max_sp_recursion_depth variable.
sql/item_func.cc:
sp_find_function() and sp_find_procedure() joined to sp_find_routine()
function as it was mentioned in TODO.
sql/mysqld.cc:
max_sp_recursion_depth variable added.
sql/set_var.cc:
max_sp_recursion_depth variable added.
sql/share/errmsg.txt:
An error message changed.
An error message added.
sql/sp.cc:
sp_find_function() and sp_find_procedure() joined to sp_find_routine()
function as it was mentioned in TODO.
Temory LEX is allocated on a stack, not on a heap.
Recursion support added for stored procedures.
sql/sp.h:
sp_find_function() and sp_find_procedure() joined to sp_find_routine()
function as it was mentioned in TODO.
sql/sp_head.cc:
Initialization of new sp_head fields to get correct list of instances
contained one instance only.
Stack requirement for SP instruction is increased.
Stack free space is checked before mem root initialisation to avoid
memory leak.
Pointer to the free instance management added before and after
SP execution.
sql/sp_head.h:
New sp_head variables added to support inst of instances of SP
for recursion and pointer on ths first free to use instance.
sql/sql_base.cc:
open_table() consume a lot of stack space so we check free stack space before it.
sql/sql_class.h:
max_sp_recursion_depth variable added.
sql/sql_parse.cc:
sp_find_function() and sp_find_procedure() joined to sp_find_routine()
function as it was mentioned in TODO.
|
||
|
unknown
|
d213bf0487 |
Merge mysql.com:/usr/local/bk/mysql-5.0
into mysql.com:/usr/home/pem/show-sp-code/mysql-5.0 sql/sp_head.h: Auto merged sql/sql_parse.cc: Auto merged sql/sql_yacc.yy: Auto merged sql/sp_head.cc: Merge fixes (STRING_WITH_LEN in string append calls). |
||
|
unknown
|
91ab707678 |
Background:
Since long, the compiled code of stored routines has been printed in the trace file when starting mysqld with the "--debug" flag. (At creation time only, and only in debug builds of course.) This has been helpful when debugging stored procedure execution, but it's a bit awkward to use. Also, the printing of some of the instructions is a bit terse, in particular for sp_instr_stmt where only the command code was printed. This improves the printout of several of the instructions, and adds the debugging- only commands "show procedure code <name>" and "show function code <name>". (In non-debug builds they are not available.) sql/lex.h: New symbol for debug-only command (e.g. show procedure code). sql/sp_head.cc: Fixed some minor debug-mode bugs in show_create_*(). New method for debugging: sp_head::show_routine_code() - returns the "assembly code" for a stored routine as a result set. Improved the print() methods for many sp_instr* classes, particularly for sp_instr_stmt where the query string is printed as well (up to a max length, just to give a hint of which statement it is). Also print the names of variables and cursors in some instruction. sql/sp_head.h: New debugging-only method in sp_head: show_routine_code(). Added offset member to sp_instr_cpush for improved debug printing. sql/sp_pcontext.cc: Moved find_pvar(uint i) method from sp_pcontext.h, and made it work for all frames, not just the first one. (For debugging purposes) Added a similar find_cursor(uint i, ...) method, for debugging. sql/sp_pcontext.h: Moved find_pvar(uint i) method to sp_pcontext.cc. Added a similar find_cursor(uint i, ...) method, for debugging. sql/sql_lex.h: Added new sql_command codes for debugging. sql/sql_parse.cc: Added new commands for debugging, e.g. "show procedure code". sql/sql_yacc.yy: Added new commands for debugging purposes: "show procedure code ..." and "show function code ...". These are only enabled in debug builds, otherwise they result in a syntax error. (I.e. they don't exist) |
||
|
unknown
|
8a661e77ea |
Issuing error about presence of commit/rollback statements in stored functions and triggers added to SP parsing procedure (BUG#13627)
The crash mentioned in original bug report is already prevented by one of previous patches (fix for bug #13343 "CREATE|etc TRIGGER|VIEW|USER don't commit the transaction (inconsistency)"), this patch only improve error returning. mysql-test/r/sp-error.result: Test that statements which implicitly commit transaction mysql-test/t/sp-error.test: Test that statements which implicitly commit transaction sql/sp_head.cc: We set the new flag about commit/rollback statements presence sql/sp_head.h: The new flag about commit/rollback presence added A comment fixed sql/sql_yacc.yy: Removed commit/rollback-statement-present errors spread by this file, only one check left which check flags of a SP |
||
|
unknown
|
7dbea7df27 |
WL#2818 (Add creator to the trigger definition for privilege
checks on trigger activation)
mysql-test/r/information_schema.result:
Update result file: a new column DEFINER has been added to
INFORMATION_SCHEMA.TRIGGERS.
mysql-test/r/mysqldump.result:
Update result file: a new column DEFINER has been added to
INFORMATION_SCHEMA.TRIGGERS.
mysql-test/r/rpl_ddl.result:
Update result file: a new column DEFINER has been added to
INFORMATION_SCHEMA.TRIGGERS.
mysql-test/r/rpl_sp.result:
Update result file: a new clause DEFINER has been added to
CREATE TRIGGER statement.
mysql-test/r/rpl_trigger.result:
Results for new test cases were added.
mysql-test/r/skip_grants.result:
Error message has been changed.
mysql-test/r/trigger.result:
Added DEFINER column.
mysql-test/r/view.result:
Error messages have been changed.
mysql-test/r/view_grant.result:
Error messages have been changed.
mysql-test/t/mysqldump.test:
Drop created procedure to not affect further tests.
mysql-test/t/rpl_trigger.test:
Add tests for new column in information schema.
mysql-test/t/skip_grants.test:
Error tag has been renamed.
mysql-test/t/view.test:
Error tag has been renamed.
mysql-test/t/view_grant.test:
Error tag has been changed.
sql/item_func.cc:
Fix typo in comments.
sql/mysql_priv.h:
A try to minimize copy&paste:
- introduce operations to be used from sql_yacc.yy;
- introduce an operation to be used from trigger and
view processing code.
sql/share/errmsg.txt:
- Rename ER_NO_VIEW_USER to ER_MALFORMED_DEFINER in order to
be shared for view and trigger implementations;
- Fix a typo;
- Add a new error code for trigger warning.
sql/sp.cc:
set_info() was split into set_info() and set_definer().
sql/sp_head.cc:
set_info() was split into set_info() and set_definer().
sql/sp_head.h:
set_info() was split into set_info() and set_definer().
sql/sql_acl.cc:
Add a new check: exit from the cycle if the table is NULL.
sql/sql_lex.h:
- Rename create_view_definer to definer, since it is used for views
and triggers;
- Change st_lex_user to LEX_USER, since st_lex_user is a structure.
So, formally, it should be "struct st_lex_user", which is longer
than just LEX_USER;
- Add trigger_definition_begin.
sql/sql_parse.cc:
- Add a new check: exit from the cycle if the table is NULL;
- Implement definer-related functions.
sql/sql_show.cc:
Add DEFINER column.
sql/sql_trigger.cc:
Add DEFINER support for triggers.
sql/sql_trigger.h:
Add DEFINER support for triggers.
sql/sql_view.cc:
Rename create_view_definer to definer.
sql/sql_yacc.yy:
Add support for DEFINER-clause in CREATE TRIGGER statement.
Since CREATE TRIGGER and CREATE VIEW can be similar at the start,
yacc is unable to distinguish between them. So, had to modify both
statements in order to make it parsable by yacc.
mysql-test/r/trigger-compat.result:
Result file for triggers backward compatibility test.
mysql-test/r/trigger-grant.result:
Result file of the test for WL#2818.
mysql-test/t/trigger-compat.test:
Triggers backward compatibility test: check that the server
still can load triggers w/o definer attribute and modify
tables with such triggers (add a new trigger, etc).
mysql-test/t/trigger-grant.test:
Test for WL#2818 -- check that DEFINER support in triggers
works properly
|
||
|
unknown
|
898adb8cfc |
Fixed BUG#14498: Stored procedures: hang if undefined variable and exception
The problem was to continue at the right place in the code after the test expression in a flow control statement fails with an exception (internally, the test in sp_instr_jump_if_not), and the exception is caught by a continue handler. Execution must then be resumed after the the entire flow control statement (END IF, END WHILE, etc). mysql-test/r/sp.result: New test case for BUG#14498. mysql-test/t/sp.test: New test case for BUG#14498. (Note that one call is disabled at the moment. Depends on BUG#14643.) sql/sp_head.cc: Added a continuation destination for sp_instr_jump_if_not, for the case when an error in the test expression causes a continue handler to catch. This includes new members in sp_instr_jump_if_not, adjustment of the optmizer (mark and move methods), and separate backpatching code (since we can't use the normal one for this). Also removed the class sp_instr_jump, since it's never used. ...and added some comments to the optimizer. sql/sp_head.h: Added a continuation destination for sp_instr_jump_if_not, for the case when an error in the test expression causes a continue handler to catch. This includes new members in sp_instr_jump_if_not, adjustment of the optmizer (mark and move methods), and separate backpatching code (since we can't use the normal one for this). Also removed the class sp_instr_jump, since it's never used. sql/sql_yacc.yy: Added backpatching of the continue destination for all conditional statements (using sp_instr_jump_if_not). |
||
|
unknown
|
38ebb6c638 |
Merge mysqldev@production.mysql.com:my/mysql-5.0-release
into mysql.com:/opt/local/work/mysql-5.0-root BitKeeper/etc/ignore: auto-union include/my_sys.h: Auto merged mysql-test/r/information_schema.result: Auto merged mysql-test/t/ctype_ujis.test: Auto merged sql/ha_federated.cc: Auto merged sql/handler.cc: Auto merged sql/item_func.h: Auto merged sql/log.cc: Auto merged sql/sp_head.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_acl.cc: Auto merged sql/sql_base.cc: Auto merged sql/sql_class.cc: Auto merged sql/sql_class.h: Auto merged sql/sql_lex.h: Auto merged sql/sql_prepare.cc: Auto merged sql/sql_select.cc: Auto merged sql/sql_view.cc: Auto merged sql/table.cc: Auto merged |
||
|
unknown
|
813fc4104e |
A fix and a test case for Bug#6513 "Test Suite: Values inserted by using
cursor is interpreted latin1 character and Bug#9819 "Cursors: Mysql Server
Crash while fetching from table with 5 million records."
A fix for a possible memory leak when fetching into an SP cursor
in a long loop.
The patch uses a common implementation of cursors in the binary protocol and
in stored procedures and implements materialized cursors.
For implementation details, see comments in sql_cursor.cc
include/my_sys.h:
- declaration for multi_alloc_root
libmysqld/Makefile.am:
- drop protocol_cursor.cc, add sql_cursor.cc (replaces the old
implementation of cursors with a new one)
mysql-test/r/ctype_ujis.result:
- test results fixed (a test case for Bug#6513)
mysql-test/r/sp-big.result:
- test results fixed (a test case for Bug#9819)
mysql-test/t/ctype_ujis.test:
Add a test case for Bug#6513 "Test Suite: Values inserted by using cursor is
interpreted latin1 character"
mysql-test/t/sp-big.test:
Add a restricted test case for Bug#9819 "Cursors: Mysql Server Crash
while fetching from table with 5 million records."
mysys/my_alloc.c:
- an implementation of multi_alloc_root; this is largely a copy-paste
from mulalloc.c, but the function is small and there is no easy way
to reuse the existing C function.
sql/Makefile.am:
- add sql_cursor.h, sql_cursor.cc (a new implementation of stored procedure
cursors) and drop protocol_cursor.cc (the old one)
sql/handler.cc:
- now TABLE object has its mem_root always initialized.
Adjust the implementation handler::ha_open
sql/item_subselect.cc:
- adjust to the changed declaration of st_select_lex_unit::prepare
sql/protocol.h:
- drop Protocol_cursor
sql/sp_head.cc:
- move juggling with Query_arena::free_list and Item::next to
sp_eval_func_item, as this is needed in 3 places already.
sql/sp_head.h:
- declare a no-op implementation for cleanup_stmt in sp_instr_cpush.
This method is needed for non-materializing cursors, which are yet not
used in stored procedures.
- declaration for sp_eval_func_item
sql/sp_rcontext.cc:
- reimplement sp_cursor using the new implementation of server side cursors.
- use sp_eval_func_item to assign values of SP variables from the
row fetched from a cursor. This should fix a possible memory leak in
the old implementation of sp_cursor::fetch
sql/sp_rcontext.h:
- reimplement sp_cursor using the new implementation of server side cursors.
sql/sql_class.cc:
- disable the functionality that closes transient cursors at commit/rollback;
transient cursors are not used in 5.0, instead we use materialized ones.
To be enabled in a later version.
sql/sql_class.h:
- adjust to the rename Cursor -> Server_side_cursor
- additional declarations of select_union used in materialized cursors
sql/sql_derived.cc:
- reuse bits of tmp table code in UNION, derived tables, and materialized
cursors
- cleanup comments
sql/sql_lex.h:
- declarations of auxiliary methods used by materialized cursors
- a cleanup in st_select_lex_unit interface
sql/sql_list.h:
- add an array operator new[] to class Sql_alloc
sql/sql_prepare.cc:
- split the tight coupling of cursors and prepared statements to reuse
the same implementation in stored procedures
- cleanups of error processing in Prepared_statement::{prepare,execute}
sql/sql_select.cc:
- move the implementation of sensitive (non-materializing) cursors to
sql_cursor.cc
- make temporary tables self-contained: the table, its record and fields
are allocated in TABLE::mem_root. This implementation is not clean
and resets thd->mem_root several times because of the way create_tmp_table
works (many additional things are done inside it).
- adjust to the changed declaration of st_select_lex_unit::prepare
sql/sql_select.h:
- move the declaration of sensitive (non-materializing) cursors to
sql_cursor.cc
sql/sql_union.cc:
- move pieces of st_select_unit::prepare to select_union and st_table
methods to be able to reuse code in the implementation of materialized
cursors
sql/sql_view.cc:
- adjust to the changed signature of st_select_lex_unit::prepare
sql/table.cc:
- implement auxiliary st_table methods for use with temporary tables
sql/table.h:
- add declarations for auxiliary methods of st_table used to work with
temporary tables
tests/mysql_client_test.c:
- if cursors are materialized, a parallel update of the table used
in the cursor may go through: update the test.
sql/sql_cursor.cc:
New BitKeeper file ``sql/sql_cursor.cc'' -- implementation of server side
cursors
sql/sql_cursor.h:
New BitKeeper file ``sql/sql_cursor.h'' - declarations for
server side cursors.
|
||
|
unknown
|
3fe752f527 |
WL#2787 (Add view definer/owner to the view definition (.frm) to check privileges on used tables and stored routines when using a VIEW.)
Part 2 postreview fixes. sql/ha_innodb.cc: Renamed structure st_security_context to class Security_context sql/item_func.cc: Renamed structure st_security_context to class Security_context sql/item_strfunc.cc: fixed USER() function sql/log.cc: variable used to optimize access to security context sql/mysql_priv.h: Renamed structure st_security_context to class Security_context sql/mysqld.cc: main security context used direcly sql/sp_head.cc: Renamed structure st_security_context to class Security_context removed unneed variable sql/sp_head.h: Comment inmroved Renamed structure st_security_context to class Security_context sql/sql_acl.cc: Renamed structure st_security_context to class Security_context fixed function comment and return value variable used to optimize access to security context Renamed method of Security_ontext sql/sql_acl.h: fixed return value type sql/sql_class.cc: Renamed structure st_security_context to class Security_context sql/sql_class.h: Renamed structure st_security_context to class Security_context Method renamed sql/sql_db.cc: Renamed structure st_security_context to class Security_context fixed layout sql/sql_parse.cc: registration of wanted access for underlying tables sql/sql_show.cc: Renamed structure st_security_context to class Security_context fixed layout sql/sql_yacc.yy: Renamed structure st_security_context to class Security_context |
||
|
unknown
|
84f029a448 |
WL#2787 (part 2, ver 3 (merged)) changed securety context switching
libmysqld/lib_sql.cc: changed securety context switching mysql-test/r/rpl_sp.result: now it show real information from changed security context of SP (checked) sql/ha_innodb.cc: changed securety context switching sql/item.cc: changed securety context switching sql/item_func.cc: changed securety context switching sql/item_strfunc.cc: changed securety context switching sql/log.cc: changed securety context switching sql/mysql_priv.h: changed securety context switching sql/mysqld.cc: changed securety context switching sql/repl_failsafe.cc: changed securety context switching sql/set_var.cc: changed securety context switching sql/slave.cc: changed securety context switching sql/sp.cc: changed securety context switching sql/sp_head.cc: changed securety context switching in case of inability to switch context we return error now sql/sp_head.h: changed securety context switching sql/sql_acl.cc: changed securety context switching sql/sql_acl.h: changed securety context switching sql/sql_base.cc: changed securety context switching sql/sql_class.cc: changed securety context switching sql/sql_class.h: changed securety context switching sql/sql_db.cc: changed securety context switching sql/sql_insert.cc: changed securety context switching sql/sql_parse.cc: changed securety context switching sql/sql_show.cc: changed securety context switching sql/sql_trigger.cc: changed securety context switching sql/sql_view.cc: changed securety context switching sql/sql_yacc.yy: changed securety context switching |
||
|
unknown
|
8c86f8e4bf |
Post-review fix for BUG#12712: SET AUTOCOMMIT should fail within SP/functions/triggers
mysql-test/r/sp.result: Added missing drop table. mysql-test/t/sp.test: Added missing drop table. sql/sp_head.h: Post-review fix for autocommit check in SPs and triggers. sql/sql_yacc.yy: Post-review fix for autocommit check in SPs and triggers. |
||
|
unknown
|
065a93773e |
Fixed BUG#12712: SET AUTOCOMMIT should fail within SP/functions/triggers
Second version after review. Allow 'set autocommit' in procedures, but not functions or triggers. Can return error in run-time (when a function calls a procedure). mysql-test/r/sp-error.result: New test case for BUG#12712. mysql-test/t/sp-error.test: New test case for BUG#12712. sql/set_var.cc: Made sys_autocommit external, to allow testing in sql_yacc.yy. sql/set_var.h: Made sys_autocommit external, to allow testing in sql_yacc.yy. sql/share/errmsg.txt: New error message for disallowing the setting of autocommit in stored functions and triggers. sql/sp_head.h: New flag: has 'set autocommit', and testing for this in is_not_allowed_in_function(). sql/sql_yacc.yy: Disallow setting AUTOCOMMIT in stored function and triggers. |
||
|
unknown
|
eb769e54b8 |
Fix for BUG#12637: Make SPs+user variables replication work:
* Allocate thd->user_var_events elements on appropriate mem_root
* If several SP statements are binlogged as a single statement, collect all user var
accesses they make (grep for StoredRoutinesBinlogging for details)
mysql-test/r/rpl_sp_effects.result:
Testcase for BUG#12637
mysql-test/r/sp.result:
re-enabled test case for BUG#12297
mysql-test/t/rpl_sp_effects.test:
Testcase for BUG#12637
mysql-test/t/sp.test:
re-enabled test case for BUG#12297
sql/item_func.cc:
Fix for BUG#12637: Make SPs+user variables replication work:
* Allocate thd->user_var_events elements on appropriate mem_root
* If several SP statements are binlogged as a single statement, collect all user var
accesses they make.
sql/log.cc:
Fix for BUG#12637: Make SPs+user variables replication work:
* Allocate thd->user_var_events elements on appropriate mem_root
* If several SP statements are binlogged as a single statement, collect all user var
accesses they make.
sql/sp_head.cc:
Fix for BUG#12637: Make SPs+user variables replication work:
* Allocate thd->user_var_events elements on appropriate mem_root
* If several SP statements are binlogged as a single statement, collect all user var
accesses they make.
sql/sp_head.h:
Remove compiler warning.
sql/sql_class.h:
Fix for BUG#12637: Make SPs+user variables replication work.
sql/sql_parse.cc:
Fix for BUG#12637: Make SPs+user variables replication work.
|
||
|
unknown
|
c910050a76 |
Implement WL#2661 "Prepared Statements: Dynamic SQL in Stored Procedures".
The idea of the patch is to separate statement processing logic,
such as parsing, validation of the parsed tree, execution and cleanup,
from global query processing logic, such as logging, resetting
priorities of a thread, resetting stored procedure cache, resetting
thread count of errors and warnings.
This makes PREPARE and EXECUTE behave similarly to the rest of SQL
statements and allows their use in stored procedures.
This patch contains a change in behaviour:
until recently for each SQL prepared statement command, 2 queries
were written to the general log, e.g.
[Query] prepare stmt from @stmt_text;
[Prepare] select * from t1 <-- contents of @stmt_text
The chagne was necessary to prevent [Prepare] commands from being written
to the general log when executing a stored procedure with Dynamic SQL.
We should consider whether the old behavior is preferrable and probably
restore it.
This patch refixes Bug#7115, Bug#10975 (partially), Bug#10605 (various bugs
in Dynamic SQL reported before it was disabled).
mysql-test/r/not_embedded_server.result:
Since we don't want to log Dynamic SQL in stored procedures,
now the general log gets only one log entry per SQL statement.
mysql-test/r/sp-error.result:
- remove obsolete tests
- a better error message for the case when a stored procedure that
returns a result set is called from a function
mysql-test/r/trigger.result:
- a better error message for the case when a stored procedure that
returns a result set is called from a trigger
mysql-test/t/sp-error.test:
- a better error message for the case when a stored procedure that
returns a result set is called from a function.
- move the comment to its place (end of file).
mysql-test/t/trigger.test:
- a better error message for the case when a stored procedure that
returns a result set is called from a trigger
sql/item_func.cc:
- we need to pass sql_command explicitly to get_var_with_binlog, because
when creating a query for SQL prepared statement thd->lex->sql_command
points at SQLCOM_EXECUTE, which is not listed in the list of update
queries.
sql/log_event.h:
- remove an extra copy of the previous sentence
sql/mysql_priv.h:
- fix declarations of sql_prepare.cc API
sql/share/errmsg.txt:
- a new error message, when one attempts to execute a prepared statement
which is currently being executed (this can happen only in Dynamic SQL
at the moment).
sql/sp_head.cc:
- extend sp_multi_results_command to return different flags for a
command (and rename it)
- add support for SQLCOM_PREPARE,SQLCOM_EXECUTE, SQLCOM_DEALLOCATE
to sp_get_flags_for_command
- replace multiple boolean sp_head members with uint m_flags
- a fix for a crash when user variables are used in a stored procedure
and binlog is on. A temporary fix for Bug#12637 "SP crashes the server
if it has update query with user var & binlog is enabled", which actually
stands for stored functions: now instead of a crash we break
replication if a user variable is used in a stored function which
is executed in prelocked mode.
sql/sp_head.h:
- replace multiple boolean flags of sp_head with uint m_flags;
- add flag CONTAINS_DYNAMIC_SQL
- use this flag to error if a stored procedure with Dynamic SQL is
called from a function or trigger.
sql/sql_class.cc:
- Statement_map::insert should not delete a statement if it exists,
now it's done externally to be able to handle the case when the
statement being deleted is in use.
- remove extra code (free_list is already reset in free_items)
sql/sql_lex.cc:
- add lex->stmt_prepare_mode; we can't rely on thd->command any more,
because we don't reset it any more (Dynamic SQL requirement is that
PS are as little intrusive as possible).
sql/sql_lex.h:
- declare bool LEX::stmt_prepare_mode
sql/sql_parse.cc:
- move prepared statement code to sql_prepare.cc
- change declarations (refactored code)
- better error message when one attempts to use Dynamic SQL or a
stored procedure that returns a result set in a function or trigger.
sql/sql_prepare.cc:
- major refactoring to ensure PREPARE/EXECUTE commands do not reset global THD
state and allow their use in stored procedures.
- add Prepared_statement::flags and use it to ensure no recursive execution
of a prepared statement is possible
- better comments
sql/sql_yacc.yy:
- enable PREPARE/EXECUTE/DEALLOCATE in stored procedures
- produce an error message on attempt to use PREPARE/EXECUTE/DEALLOCATE
in a stored function or trigger
mysql-test/r/sp-dynamic.result:
- sp-dynamic.test results
mysql-test/t/sp-dynamic.test:
- a new test for PREPARE/EXECUTE/DEALLOCATE in stored procedures.
|
||
|
unknown
|
8f3daaf1a0 |
Merge deer.(none):/home/hf/work/mysql-5.0.10499
into deer.(none):/home/hf/work/mysql-5.0.clean sql/sp_head.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_yacc.yy: Auto merged |
||
|
unknown
|
8a5e527453 |
Fix for BUG#12335 (SP replication) : New binlogging strategy for stored PROCEDUREs/FUNCTIONs.
"Interleaved SPs execution is now binlogged properly, "SELECT spfunc()" is binlogged too.
The known remaining issue is binlogging/replication of "a routine is deleted while it is executed" scenario.
mysql-test/r/rpl_sp.result:
Fix for BUG#12335: updated test cases/results
mysql-test/t/rpl_sp.test:
Fix for BUG#12335: updated test cases/results
sql/item.cc:
Fix for BUG#12335 (SP replication):
- Added Item_name_const 'function'
- Addede 'delete reuse' to call dtor on item reuse
sql/item.h:
Fix for BUG#12335 (SP replication) : Added Item_name_const 'function' + code cleanup
sql/item_create.cc:
Fix for BUG#12335 (SP replication) : Added Item_name_const 'function'
sql/item_create.h:
Fix for BUG#12335 (SP replication) : Added Item_name_const 'function'
sql/item_func.cc:
Fix for BUG#12335 (SP replication) : binary log is now constrolled from within execute_function.
sql/lex.h:
Fix for BUG#12335 (SP replication) : Added Item_name_const 'function'
sql/log.cc:
Fix for BUG#12335 (SP replication) : Added MYSQL_LOG::{start|stop}_union_events to allow
one to temporary disable binlogging but collect a 'union' information about binlog write
calls.
sql/mysql_priv.h:
Fix for BUG#12335 (SP replication)
sql/sp_head.cc:
Fix for BUG#12335 (SP replication) : Now we use different SP binlogging strategy, grep for
StoredRoutinesBinlogging for details
sql/sp_head.h:
Comments added
sql/sp_pcontext.h:
Comments added
sql/sp_rcontext.h:
Comments added
sql/sql_class.cc:
Fix for BUG#12335 (SP replication) : Now we use different SP binlogging strategy, grep for
StoredRoutinesBinlogging for details
sql/sql_class.h:
Fix for BUG#12335 (SP replication) : Added MYSQL_LOG::{start|stop}_union_events to allow
one to temporary disable binlogging but collect a 'union' information about binlog write
calls.
sql/sql_delete.cc:
Fix for BUG#12335: check THD::query_str_binlog_unsuitable when writing to binlog.
sql/sql_insert.cc:
Fix for BUG#12335: check THD::query_str_binlog_unsuitable when writing to binlog.
sql/sql_lex.cc:
Fix for BUG#12335 (SP replication): Add ability to extract previous returned token from
the tokenizer.
sql/sql_lex.h:
Fix for BUG#12335 (SP replication): Add ability to extract previous returned token from
the tokenizer.
sql/sql_parse.cc:
Fix for BUG#12335 (SP replication) : Now we use different SP binlogging strategy, grep for
StoredRoutinesBinlogging for details
sql/sql_update.cc:
Fix for BUG#12335: check THD::query_str_binlog_unsuitable when writing to binlog.
sql/sql_yacc.yy:
Fix for BUG#12335 (SP replication) : When creating Item_splocal, remember where it is located
in the query.
|
||
|
unknown
|
276bd123b7 |
A fix and a test case for "Bug #12168 'DECLARE CONTINUE HANDLER FOR
NOT FOUND ...' in conditional handled incorrectly". Whenever we remove an instruction during optimization, we need to adjust instruction numbers (ip - instruction pointer) stored in all instructions. In addition to that, sp_instr_hpush_jump, which corresponds to DECLARE CONTINUE HANDLER needs adjustment for m_handler, which holds the number of instruction with the continue handler. In the bug report, a wrong ip stored in m_handler was pointing at FETCH, which resulted in an error message and abnormal SP termination. The fix is to just remove m_handler member from sp_instr_hpush_jump, as it's always points to the instruction next to the DECLARE statement itself (m_ip+1). mysql-test/r/sp.result: Test results fixed (Bug#12168) mysql-test/t/sp.test: A test case for Bug#12168 "'DECLARE CONTINUE HANDLER FOR NOT FOUND ...' in conditional handled incorrectly" sql/sp_head.cc: Remove m_handler (the number of continue handler instruction) as it always equal to m_ip+1 sql/sp_head.h: Remove m_handler (the number of continue handler instruction) as it always equal to m_ip+1 |
||
|
unknown
|
6cca9a0fd3 |
Fix for bug #10499 (Function creation with GEOMETRY return)
mysql-test/r/gis.result: test result fixed mysql-test/t/gis.test: test case sql/sp_head.cc: m_geom_returns is sent to make_field sql/sp_head.h: m_geom_returns declared sql/sql_yacc.yy: m_geom_returns initializing added |
||
|
unknown
|
e442059c0d |
Manual merge
mysql-test/r/sp.result: Auto merged mysql-test/r/view.result: Auto merged mysql-test/t/view.test: Auto merged sql/item_func.cc: Auto merged sql/sp.cc: Auto merged sql/sp_head.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_base.cc: Auto merged sql/sql_class.cc: Auto merged sql/sql_class.h: Auto merged sql/sql_lex.cc: Auto merged sql/sql_parse.cc: Auto merged sql/sql_trigger.h: Auto merged |
||
|
unknown
|
11abe15eab |
Added Non-prelocked SP execution: Now a PROCEDURE doesn't enter/leave prelocked mode for
its body, but lets each statement to get/release its own locks. This allows a broader set
of statements to be executed inside PROCEDUREs (but breaks replication)
This patch should fix BUG#8072, BUG#8766, BUG#9563, BUG#11126
mysql-test/r/sp-security.result:
Drop tables this test attempts to create
mysql-test/r/sp-threads.result:
Update test results
mysql-test/r/sp.result:
Disabled a test that triggers BUG#11986, cleanup used tables when tests start.
mysql-test/r/view.result:
Enabled a test case that now works with prelocking-free SPs
mysql-test/t/sp-security.test:
Drop tables this test attempts to create
mysql-test/t/sp.test:
Disabled a test that triggers BUG#11986, cleanup used tables when tests start.
mysql-test/t/view.test:
Enabled a test case that now works with prelocking-free SPs
sql/handler.cc:
Rename: thd->transaction.in_sub_stmt -> thd->in_sub_stmt
sql/item_func.cc:
Rename: thd->transaction.in_sub_stmt -> thd->in_sub_stmt
sql/sp.cc:
Non-prelocked SP execution: Added support for skipping prelocking of procedure body for
"CALL proc(...)" statements.
sql/sp.h:
Non-prelocked SP execution: Added support for skipping prelocking of procedure body for
"CALL proc(...)" statements.
sql/sp_cache.h:
Added comments
sql/sp_head.cc:
Non-prelocked SP execution:
* Try to unlock tables after PROCEDURE arguments have been evaluated.
* Make sp_lex_keeper be able to execute in 2 modes: A) when already in prelocked mode
B) when its statement enters/leaves prelocked mode itself.
sql/sp_head.h:
Non-prelocked SP execution: Make sp_lex_keeper to additionally keep list of tables it
needs to prelock when its statement enters/leaves prelocked mode on its own.
sql/sql_base.cc:
Non-prelocked SP execution: Make open_tables() to
* detect 'CALL proc(...)' and not to do prelocking for procedure body statements.
* Make lex->query_tables_last to point precisely to a boundary in lex->query_tables
list where 'own' tables and views' tables end and added-for-prelocking tables begin.
(it was not true before - view's tables could end up after query_tables_own_last)
sql/sql_class.cc:
Rename: thd->transaction.in_sub_stmt -> thd->in_sub_stmt
sql/sql_class.h:
Rename: thd->transaction.in_sub_stmt -> thd->in_sub_stmt
sql/sql_lex.cc:
Non-prelocked SP execution: More rigourous cleanup in st_lex::cleanup_after_one_table_open()
sql/sql_parse.cc:
Rename: thd->transaction.in_sub_stmt -> thd->in_sub_stmt, remove outdated comments
sql/sql_trigger.h:
Rename: thd->transaction.in_sub_stmt -> thd->in_sub_stmt
|
||
|
unknown
|
a66928bb24 |
store/restore sql_mode which was in force during ctrigger creation (BUG#5891)
other sql_mode fixes mysql-test/r/information_schema.result: changes in information schema mysql-test/r/trigger.result: storing and restoring sql modes for triggers mysql-test/t/trigger.test: storing and restoring parsing modes for triggers sql/mysqld.cc: add length of mode names sql/parse_file.cc: new type of list (ulonglong) sql/parse_file.h: new type of list (ulonglong) sql/set_var.cc: mode output made as static method sql/set_var.h: mode output made as static method sql/sp_head.cc: added sql_mode storing/restoring during SP execution optimised sql_mode printing sql/sp_head.h: comment fixed according this changes sql/sql_show.cc: added sql_mode field sql/sql_trigger.cc: store/restore sql_mode which was in force during ctrigger creation sql/sql_trigger.h: store/restore sql_mode which was in force during ctrigger creation sql/sql_view.cc: fixed sql_mode |
||
|
unknown
|
eef5f17bde |
Merge bk-internal.mysql.com:/home/bk/mysql-5.0
into mysql.com:/home/dlenev/src/mysql-5.0-bg8406 mysql-test/r/sp.result: Auto merged mysql-test/r/trigger.result: Auto merged mysql-test/t/sp.test: Auto merged mysql-test/t/trigger.test: Auto merged sql/item_func.cc: Auto merged sql/sp.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_base.cc: Auto merged sql/sql_lex.cc: Auto merged sql/sql_lex.h: Auto merged sql/sql_parse.cc: Auto merged sql/sql_trigger.cc: Auto merged mysql-test/r/sp-error.result: Manual merge. mysql-test/t/sp-error.test: Manual merge. sql/sp_head.cc: Manual merge. sql/sql_yacc.yy: Manual merge. |
||
|
unknown
|
14b1f91ba4 |
Enable support of access to tables from triggers. Thus fix bug #8406 "Triggers
crash if referencing a table" and several other related bugs. Fix for bug #11834 "Re-execution of prepared statement with dropped function crashes server." which was spotted during work on previous bugs. Also couple of nice cleanups: - Replaced two separate hashes for stored routines used by statement with one. - Now instead of doing one pass through all routines used in statement for caching them and then doing another pass for adding their tables to table list, we do only one pass during which do both things. mysql-test/r/sp-error.result: Added test for bug #11834 "Re-execution of prepared statement with dropped function crashes server" also covering handling of prepared statements which use stored functions but does not require prelocking. mysql-test/r/sp.result: Updated test for LOCK TABLES with views in table list. (Old version of statement used in this test will work ok now, since prelocking algorithm was tuned and will lock only one multi-set of tables for each routine even if this routine is used in several different views). mysql-test/r/trigger.result: Added several tests for triggers using tables. mysql-test/t/sp-error.test: Added test for bug #11834 "Re-execution of prepared statement with dropped function crashes server" also covering handling of prepared statements which use stored functions but does not require prelocking. mysql-test/t/sp.test: Updated comment about recursive views to reflect current situation. Updated test for LOCK TABLES with views in table list. (Old version of statement used in this test will work ok now, since prelocking algorithm was tuned and will lock only one multi-set of tables for each routine even if this routine is used in several different views). mysql-test/t/trigger.test: Added several tests for triggers using tables. sql/item_func.cc: Item_func_sp::cleanup(): By next statement execution stored function can be dropped or altered so we can't assume that sp_head object for it will be still valid. sql/sp.cc: - Added Sroutine_hash_entry structure that represents element in the set of stored routines used by statement or routine. We can't as before use LEX_STRING for this purprose because we want link all elements of this set in list. - Replaced sp_add_to_hash() with sp_add_used_routine() which takes into account that now we use one hash for stored routines used by statement instead of two and which mantains list linking all elelemnts in this hash. - Renamed sp_merge_hash() to sp_update_sp_used_routines(). - Introduced sp_update_stmt_used_routines() for adding elements to the set of routines used by statement from another similar set for statement or routine. This function will also mantain list linking elements of destination set. - Now instead of one sp_cache_routines() function we have family of sp_cache_routines_and_add_tables() functions which are also responsible for adding tables used by routines being cached to statement table list. Nice optimization - thanks to list linking all elements in the hash of routines used by statement we don't need to perform several iterations over this hash (as it was before in cases when we have added new elements to it). sql/sp.h: Added declarations of functions used for manipulations with set (hash) of stored routines used by statement. sql/sp_head.cc: sp_name::init_qname(): Now sp_name also holds key identifying routine in the set (hash) of stored routines used by statement. sp_head: Instead of two separate hashes sp_funs/m_spprocs representing sets of stored routines used by this routine we use one hash - m_sroutines. sp_instr_set_trigger_field: Added support for subqueries in assignments to row accessors in triggers. Removed definition of sp_add_sp_tables_to_table_list() and auxilary functions since now we don't have separate stage on which we add tables used by routines used by statement to table list for prelocking. We do it on the same stage as we load those routines in SP cache. So all this functionality moved to sp_cache_routines_and_add_tables() family of functions. sql/sp_head.h: sp_name: Now this class also holds key identifying routine in the set (hash) of stored routines used by statement. sp_head: Instead of two separate hashes sp_funs/m_spprocs representing sets of stored routines used by this routine we use one hash - m_sroutines. sp_instr_set_trigger_field: Added support for subqueries in assignments to row accessors in triggers. Removed declaration of sp_add_sp_tables_to_table_list() since now we don't have separate stage on which we add tables used by routines used by statement to table list for prelocking. We do it on the same stage as we load those routines in SP cache. sql/sql_base.cc: open_tables(): - LEX::spfuns/spprocs hashes were replaced with one LEX::sroutines hash. - Now instead of doing one pass through all routines used in statement for caching them and then doing another pass for adding their tables to table list, we do only one pass during which do both things. It is easy to do since all routines in the set of routines used by statement are linked in the list. This also allows us to calculate table list for prelocking more precisely. - Now triggers properly inform prelocking algorithm about tables they use. sql/sql_lex.cc: lex_start(): Replaced LEX::spfuns/spprocs with with one LEX::sroutines hash. Added LEX::sroutines_list list linking all elements in this hash. st_lex::st_lex(): Moved definition of LEX constructor to sql_lex.cc file to be able use sp_sroutine_key declaration from sp.h in it. sql/sql_lex.h: LEX: Replaced two separate hashes for stored routines used by statement with one. Added list linking all elements in this hash to be able to iterate through all elements and add new elements to this hash at the same time. Moved constructor definition to sql_lex.cc. sql/sql_parse.cc: mysql_execute_command(): Replaced LEX::spfuns/spprocs with one LEX::sroutines hash. sql/sql_trigger.cc: Added missing GNU GPL notice. Table_triggers_list::check_n_load() Added initialization of sroutines_key which stores key representing triggers of this table in the set (hash) of routines used by this statement. sql/sql_trigger.h: Added missing GNU GPL notice. Table_triggers_list: Added sroutines_key member to store key representing triggers of this table in the set (hash) of routines used by this statement. Declared sp_cache_routines_and_add_tables_for_triggers() as friend since it needs access to sroutines_key and trigger bodies. sql/sql_yacc.yy: - Now we use sp_add_used_routine() instead of sp_add_to_hash() for adding elements to the set of stored routines used in statement. - Enabled support of subqueries as right sides in assignments to triggers' row accessors. |
||
|
unknown
|
0f64a49506 |
"Fix" for bug #11394 "Recursion in SP crash server" and bug #11600
"Stored procedures: crash with function calling itself". Disallow recursive stored routines until we either make Item's and LEX reentrant safe or will use spearate sp_head instances (and thus separate LEX objects and Item trees) for each routine invocation. mysql-test/r/sp-error.result: Added tests for bug #11394 "Recursion in SP crash server" and bug #11600 "Stored procedures: crash with function calling itself". (We simply disallow recursion for stored routines). mysql-test/r/sp.result: Disabled test cases containing recursive stored routines until we will support for them. mysql-test/t/sp-error.test: Added tests for bug #11394 "Recursion in SP crash server" and bug #11600 "Stored procedures: crash with function calling itself". (We simply disallow recursion for stored routines). mysql-test/t/sp.test: Disabled test cases containing recursive stored routines until we will support for them. sql/share/errmsg.txt: Added error message saying that recursive stored routines are disallowed. sql/sp_head.cc: sp_head::execute(): Since many Item's and LEX members can't be used in reentrant fashion we have to disable recursion for stored routines. So let us track routine invocations using sp_head::m_is_invoked member and raise error when one attempts to call routine recursively. sql/sp_head.h: sp_head: Added m_is_invoked member for tracking of routine invocations and preventing recursion. |
||
|
unknown
|
91180cb8ab |
- implement inheritance of sp_instr: public Query_arena.
We need every instruction to have its own arena, because we want to
track instruction's state (INITIALIZED_FOR_SP -> EXECUTED). Because of
`if' statements and other conditional instructions used in stored
procedures, not every instruction of a stored procedure gets executed
during the first (or even subsequent) execution of the procedure.
So it's better if we track the execution state of every instruction
independently.
All instructions of a given procedure now also share sp_head's
mem_root, but keep their own free_list.
This simplifies juggling with free Item lists in sp_head::execute.
- free_items() moved to be a member of Query_arena.
- logic of 'backup_arena' debug member of Query_arena has been
changed to support
multi-backups. Until now, TRUE 'backup_arena' meant that there is
exactly one active backup of the THD arena. Now it means simply that
the arena is used for backup, so that we can't accidentally overwrite an
existing backup. This allows doing multiple backups, e.g. in
sp_head::execute and Cursor::fetch, when THD arena is already backed up
but we want to set yet another arena (usually the 'permanent' arena,
to save permanent transformations/optimizations of a parsed tree).
sql/sp_head.cc:
- use Query_arena support in sp_head::execute() as now sp_instr inherites
from it.
sql/sp_head.h:
- inherite sp_instr from Query_arena
sql/sql_class.cc:
- changed the principle of Query_arena::backup_arena; free_items is now
a member of Query_arena.
sql/sql_class.h:
- changed the principle of Query_arena::backup_arena; free_items is now
a member of Query_arena.
sql/sql_prepare.cc:
free_items() is now a member of Query_arena.
sql/sql_select.cc:
free_items() now automatically sets free_list to zero.
|
||
|
unknown
|
40f0738b9c |
Adjust to the changed Query_arena constructor:
main_mem_root is moved out of class Query_arena. sql/sp_head.cc: Adjust to the changed Query_arena constructor. main_mem_root is moved out of class Query_arena. sql/sp_head.h: main_mem_root is moved out of class Query_arena: add it to class sp_head. sql/sql_class.cc: main_mem_root is moved out of class Query_arena: remove constructors no longer relevant, remove dead code. sql/sql_class.h: main_mem_root is moved out of class Query_arena. sql/sql_prepare.cc: It's better to not use main_mem_root anywhere: logically, it's not a public member (can't fix sp_head::make_field and Item_subselect::exec to make it protected) sql/sql_select.cc: New Cursor constructor, which avoids unneeded memory allocation when initializign main_mem_root. sql/sql_select.h: main_mem_root is moved out of class Query_arena. |
||
|
unknown
|
f1f1d39a29 |
Merge bk-internal:/home/bk/mysql-5.0
into serg.mylan:/usr/home/serg/Abk/mysql-5.0 sql/item.h: Auto merged sql/item_func.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_select.cc: Auto merged |
||
|
unknown
|
f1e42a0b35 |
renamed:
Item_buff -> Cached_item
Item_arena -> Query_arena
TEST_ASSERT -> YYERROR_UNLESS
sql/item.h:
renamed:
Item_buff -> Cached_item
sql/item_buff.cc:
renamed:
Item_buff -> Cached_item
sql/item_func.cc:
renamed:
Item_arena -> Query_arena
sql/item_subselect.cc:
renamed:
Item_arena -> Query_arena
sql/sp_head.cc:
renamed:
Item_arena -> Query_arena
sql/sp_head.h:
renamed:
Item_arena -> Query_arena
sql/sql_base.cc:
renamed:
Item_arena -> Query_arena
sql/sql_class.cc:
renamed:
Item_arena -> Query_arena
sql/sql_class.h:
renamed:
Item_arena -> Query_arena
sql/sql_lex.cc:
renamed:
Item_arena -> Query_arena
sql/sql_prepare.cc:
renamed:
Item_arena -> Query_arena
sql/sql_select.cc:
renamed:
Item_arena -> Query_arena
sql/sql_select.h:
renamed:
Item_buff -> Cached_item
Item_arena -> Query_arena
sql/sql_union.cc:
renamed:
Item_arena -> Query_arena
sql/sql_view.cc:
renamed:
Item_arena -> Query_arena
sql/sql_yacc.yy:
renamed:
TEST_ASSERT -> YYERROR_UNLESS
sql/table.cc:
renamed:
Item_arena -> Query_arena
|
||
|
unknown
|
e1c2646a0c |
prohibit opening Query cache for SP cursors (BUG#9715)
mysql-test/r/query_cache.result: testing cursors in SP with QC testing suspicious but working using selects in function with QC mysql-test/t/query_cache.test: testing cursors in SP with QC testing suspicious but working using selects in function with QC sql/sp_head.h: method for prohibiting of QC using SP query sql/sp_rcontext.cc: prohibit opening Query cache for SP cursors sql/sp_rcontext.h: constructor moved to .cc file to be able to use methods from lex_keeper |
||
|
unknown
|
a985031a29 |
Merge bk-internal.mysql.com:/home/bk/mysql-5.0
into mysql.com:/home/dlenev/src/mysql-5.0-ttdf sql/sp_head.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_yacc.yy: Auto merged |
||
|
unknown
|
d51a5baecb |
Fix for trigger.test failure in --debug mode.
We can't have Item_trigger_field as aggregated object inside of
sp_instr_set_trigger_field class since in this case its destructor
will be called twice. So instead let us create this Item separately
and store pointer to it in instruction object.
sql/sp_head.cc:
sp_instr_set_trigger_field:
We can't have Item_trigger_field as aggregated object since in this
case its destructor will be called twice, so let us store pointer
to this Item (Another way to avoid this is to exclude this Item
from free_list but this can't be done in elegant way in 5.0 and
will also cause additional problems with Item::cleanup()).
sql/sp_head.h:
sp_instr_set_trigger_field:
We can't have Item_trigger_field as aggregated object since in this
case its destructor will be called twice, so let us store pointer
to this Item (Another way to avoid this is to exclude this Item
from free_list but this can't be done in elegant way in 5.0 and
will also cause additional problems with Item::cleanup()).
sql/sql_yacc.yy:
We can't have Item_trigger_field as aggregated object inside of
sp_instr_set_trigger_field class since in this case its destructor
will be called twice. So instead let us create this Item separately
and store pointer to it in instruction object.
|
||
|
unknown
|
73b4415ce4 |
Add USE_PRAGMA_INTERFACE and USE_PRAGMA_IMPLEMENTATION to files not existsing in 4.1
sql/hash_filo.h: USE_PRAGMA_INTERFACE sql/sp_cache.cc: USE_PRAGMA_IMPLEMENTATION sql/sp_cache.h: USE_PRAGMA_INTERFACE sql/sp_head.cc: USE_PRAGMA_IMPLEMENTATION sql/sp_head.h: USE_PRAGMA_INTERFACE sql/sp_pcontext.cc: USE_PRAGMA_IMPLEMENTATION sql/sp_pcontext.h: USE_PRAGMA_INTERFACE sql/sp_rcontext.cc: USE_PRAGMA_IMPLEMENTATION sql/sp_rcontext.h: USE_PRAGMA_INTERFACE |
||
|
unknown
|
ce16c895c2 |
Merge in fix Bug#3788
mysql-test/r/information_schema.result: Auto merged mysql-test/t/sp.test: Auto merged sql/item.cc: Auto merged sql/item_func.cc: Auto merged sql/item_func.h: Auto merged sql/mysql_priv.h: Auto merged sql/sp.cc: Auto merged sql/sp_head.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_parse.cc: Auto merged sql/sql_table.cc: Auto merged sql/sql_yacc.yy: Auto merged mysql-test/r/sp.result: Merge BitKeeper/etc/logging_ok: Logging to logging@openlogging.org accepted |
||
|
unknown
|
1220069c53 |
Bug#3788
Crashes with stored procedure return non-string values
Also fixes Bug#2773
mysql-test/r/information_schema.result:
Bug#3788
Fix results for bugfix
mysql-test/r/sp.result:
Bug#3788
Tests for Bug
Fix results for bugfix
mysql-test/t/sp.test:
Bug#3788
New tests for bug
sql/item.cc:
Fix unrelated crash in view test with --ps-protocol.
sql/item_func.cc:
Bug#3788
Alter how SP function result types are handled.
sql/item_func.h:
Bug#3788
Alter how SP function result types are handled.
sql/mysql_priv.h:
Bug#3788
Prototypes for new global functions
sql/sp.cc:
Bug#3788
Alter how function return type is reported
sql/sp_head.cc:
Bug#3788
Change how function return types are stored for SPs
sql/sp_head.h:
Bug#3788
Change how function return types are stored for SPs
sql/sql_parse.cc:
Bug#3788
Split out field construction into its own function
sql/sql_table.cc:
Bug#3788
Split out field preparation code into its own function
sql/sql_yacc.yy:
Bug#3788
Change how function return types are stored for SPs
sql/unireg.cc:
Bug#3788
Add assertion check
|
||
|
unknown
|
ac9f68b9fa |
Better approach for prelocking of tables for stored routines execution
and some SP-related cleanups. - We don't have separate stage for calculation of list of tables to be prelocked and doing implicit LOCK/UNLOCK any more. Instead we calculate this list at open_tables() and do implicit LOCK in lock_tables() (and UNLOCK in close_thread_tables()). Also now we support cases when same table (with same alias) is used several times in the same query in SP. - Cleaned up execution of SP. Moved all common code which handles LEX and does preparations before statement execution or complex expression evaluation to auxilary sp_lex_keeper class. Now all statements in SP (and corresponding instructions) that evaluate expression which can contain subquery have their own LEX. mysql-test/r/lock.result: Replaced wrong error code with the correct one after fixing bug in SP-locking. mysql-test/r/mysqldump.result: Added dropping of view which is used in test to its beginning. mysql-test/r/sp.result: Added tests for improved SP-locking. Temporarily disabled tests for SHOW PROCEDURE STATUS and alike (Until Monty will allow to open mysql.proc under LOCK TABLES without mentioning it in lock list). Replaced wrong results of test for bug #5240 with correct results after fixing bug in handling of cursors. mysql-test/t/lock.test: Replaced wrong error code with the correct one after fixing bug in SP-locking. mysql-test/t/mysqldump.test: Added dropping of view which is used in test to its beginning. mysql-test/t/sp.test: Added tests for improved SP-locking. Temporarily disabled tests for SHOW PROCEDURE STATUS and alike (Until Monty will allow to open mysql.proc under LOCK TABLES without mentioning it in lock list). Removed test for bug #1654 since we already test exactly this function in one of SP-locking tests. Removed comment about cursor's wrong behavior in test for bug #5240 after fixing bug which was its cause. sql/item_func.cc: Removed comment which is no longer true. sql/mysql_priv.h: Changed open_tables() signature. Now its 2nd parameter is in/out since it can add elements to table list. sql/sp.cc: sp_find_procedure(): Added one more parameter which enforces cache only lookup. sp_merge_hash(): Now uses its return value to indicate that first of two hashes changed as result of merge. sp_cache_routines(): This function caches all stored routines used in query now. sql/sp.h: - sp_find_procedure() now has one more parameter which enforces cache only lookup. - sp_merge_hash() now uses its return value to indicate that first of two hashes changed as result of merge. - sp_cache_routines() caches all stored routines now. So it does not need third argument any more. sql/sp_head.cc: sp_head::sp_head(): Added initialization of new m_spfuns and m_spprocs members. sp_head::execute(): Let us save/restore part of thread context which can be damaged by execution of instructions. sp_head::execute_function()/execute_procedure(): Now it is responsibility of caller to close tables used in subqueries which are passed as routine parameters. sp_head::restore_lex(): Let us accumulate information about routines used by this one in new m_spfuns, m_spprocs hashes. sp_lex_keeper::reset_lex_and_exec_core() Main method of new auxilary sp_lex_keeper class to which instructions delegate responsibility for handling LEX and preparations before executing statement or calculating complex expression. Since all instructions which calculate complex expression or execute command now use sp_lex_keeper they have to implement sp_instr::exec_core() method. Most of instruction specific logic has moved from sp_instr::execute() to this new method. Removed sp_instr_set_user_var class which is no longer used, because nowdays we allow execution of statements in stored functions and triggers. sp_merge_table_list() became sp_head::merge_table_list() method. It also treats sp_head::m_sptabs as multi-set of tables now. sp_hash_to_table_list() became sp_head::add_used_tables_to_table_list(). It takes into account that sp_head::m_sptabs is multi-set and allocates object into persistent arena of PS. Removed sp_merge_table_hash(), sp_open_and_lock_tables(), sp_unlock_tables(), sp_merge_routine_tables() methods since they are not used by new prelocking mechanism. Added sp_add_sp_tables_to_table_list() which serves for adding tables needed by routines used in query to the query table list for prelocking. sql/sp_head.h: class sp_head: - Added m_spfuns, m_spprocs members for storing names of routines used by this routine. - Added add_used_tables_to_table_list() method which allows to add tables needed by this routine to query's table list. - Converted sp_merge_table_list() to sp_head::merge_table_list() method. - Changed semantics of THD::m_sptabs. Now it is multi-set which contains only tables which are used by this routine and not routines that are called from this one. Removed sp_merge_routine_tables(), sp_merge_table_hash(), sp_open_and_lock_tables(), sp_unlock_tables() calls since they are not used for our prelocking list calculation. Added auxilary sp_lex_keeper class to which instructions delegate responsibility for handling LEX and preparations before executing statement or calculating complex expression. This class uses new sp_instr::exec_core() method which is responsible for executing instruction's core function after all preparations were made. All instructions which hold and calculate complex expression now have their own LEX (by aggregating sp_lex_keeper instance). sp_instr_stmt now uses sp_lex_keeper too. Removed sp_instr_set_user_var class which is no longer used, because nowdays we allow execution of statements in stored functions and triggers. sql/sp_rcontext.cc: Now sp_cursor holds pointer to sp_lex_keeper instead of LEX. sql/sp_rcontext.h: Now sp_cursor holds pointer to sp_lex_keeper instead of LEX. sql/sql_acl.cc: acl_init(), grant_init(): Now we use simple_open_n_lock_tables() instead of explicit calls to open_tables() and mysql_lock_tables(). sql/sql_base.cc: Implemented support for execution of statements in "prelocked" mode. When we have statement which uses stored routines explicitly or implicitly (via views or triggers) we have to open and lock all tables for these routines at the same time as tables for the main statement. In fact we have to do implicit LOCK TABLES at the begining of such statement and implict UNLOCK TABLES at its end. We call such mode "prelocked". When open_tables() is called for the statement tables which are needed for execution of routines used by it are added to its tables list (this process also caches all routines used). Implicit use of routines is discovered when we open view or table with trigger and apropriate tables are added to the table list at this moment. Statement which has such extra tables in its list (well actually any that uses functions) is marked as requiring prelocked mode for its execution. When lock_tables() sees such statement it will issue implicit LOCK TABLES for this extended table list instead of doing usual locking, it will also set THD::prelocked_mode to indicate that we are in prelocked mode. When open_tables()/lock_tables() are called for statement of stored routine (substatement), they notice that we are running in prelocked mode and use one of prelocked tables from those that are not used by upper levels of execution. close_thread_tables() for substatement won't really close tables used but will mark them as free for reuse instead. Finally when close_thread_tables() is called for the main statement it really unlocks and closes all tables used. Everything will work even if one uses such statement under real LOCK TABLES (we are simply not doing implicit LOCK/UNLOCK in this case). sql/sql_class.cc: Added initialization of THD::prelocked_mode member. sql/sql_class.h: - Added prelocked_mode_type enum and THD::prelocked_mode member which are used for indication whenever "prelocked mode" is on (i.e. that statement uses stored routines and is executed under implicit LOCK TABLES). - Removed THD::shortcut_make_view which is no longer needed. We use TABLE_LIST::prelocking_placeholder for the same purprose now. sql/sql_handler.cc: Changed open_tables() invocation. Now its 2nd parameter is in/out since it can add elements to table list. sql/sql_lex.cc: lex_start(): Added initialization of LEX::query_tables_own_last. Unused LEX::sptabs member was removed. st_lex::unlink_first_table()/link_first_table_back(): We should update LEX::query_tables_last properly if table list contains(ed) only one element. sql/sql_lex.h: LEX: - Removed sptabs member since it is no longer used. - Added query_tables_own_last member, which if non-0 indicates that statement requires prelocking (implicit LOCK TABLES) for its execution and points to last own element in query table list. If it is zero then this query does not need prelocking. - Added requires_prelocking(), mark_as_requiring_prelocking(), first_not_own_table() inline methods to incapsulate and simplify usage of this new member. sql/sql_parse.cc: dispatch_command(): To properly leave prelocked mode when needed we should call close_thread_tables() even if there are no open tables. mysql_execute_command(): - Removed part of function which were responsible for doing implicit LOCK TABLES before statement execution if statement used stored routines (and doing UNLOCK TABLES at the end). Now we do all this in open_tables()/lock_tables()/close_thread_tables() instead. - It is also sensible to reset errors before execution of statement which uses routines. - SQLCOM_DO, SQLCOM_SET_OPTION, SQLCOM_CALL We should always try to open tables because even if statement has empty table list, it can call routines using tables, which should be preopened before statement execution. - SQLCOM_CALL We should not look up routine called in mysql.proc, since it should be already cached by this moment by open_tables() call. - SQLCOM_LOCK_TABLES it is better to use simple_open_n_lock_tables() since we want to avoid materialization of derived tables for this command. sql/sql_prepare.cc: mysql_test_update(): Changed open_tables() invocations. Now its 2nd parameter is in/out since it can add elements to table list. check_prepared_statement(): Since now we cache all routines used by statement in open_tables() we don't need to do it explicitly. mysql_stmt_prepare(): Now we should call close_thread_tables() when THD::lex points to the LEX of statement which opened tables. reset_stmt_for_execute(): Commented why we are resetting all tables in table list. sql/sql_trigger.h: Table_triggers_list::process_triggers(): We should surpress sending of ok packet when we are calling trigger's routine, since now we allow statements in them. sql/sql_update.cc: Changed open_tables() invocations. Now its 2nd parameter is in/out since it can add elements to table list. sql/sql_view.cc: mysql_make_view(): - Removed handling of routines used in view. Instead we add tables which are needed for their execution to statement's table list in open_tables(). - Now we use TABLE_LIST::prelocking_placeholder instead of THD::shortcut_make_view for indicating that view is opened only to discover which tables and routines it uses (this happens when we build extended table list for prelocking). Also now we try to avoid to modify main LEX in this case (except of its table list). - Corrected small error we added tables to the table list of the main LEX without updating its query_tables_last member properly. sql/sql_yacc.yy: Now each expression which is used in SP statements and can contain subquery has its own LEX. This LEX is stored in corresponding sp_instr object and used along with Item tree for expression calculation. We don't need sp_instr_set_user_var() anymore since now we allow execution of statements in stored functions and triggers. sql/table.h: Added TABLE_LIST::prelocking_placeholder member for distinguishing elements of table list which does not belong to the statement itself and added there only for prelocking (as they are to be used by routines called by this statement). sql/tztime.cc: my_tz_init(): Now we use more simplier simple_open_n_lock_tables() call instead of open_tables()/lock_tables() pair. |
||
|
unknown
|
3f24932124 |
WL#2130: Table locking for stored FUNCTIONs
Collect all tables and SPs refered by a statement, and open all tables with an implicit LOCK TABLES. Do find things refered by triggers and views, we open them first (and then repeat this until nothing new is found), before doing the actual lock tables. mysql-test/r/information_schema.result: Updated result for WL#2130. mysql-test/r/lock.result: Updated result for WL#2130. mysql-test/r/sp-error.result: Updated result for WL#2130. mysql-test/r/sp.result: Updated result for WL#2130. mysql-test/r/view.result: Updated result for WL#2130. mysql-test/t/information_schema.test: Disabled one test case due to a bug involving LOCK TABLES, which shows up with WL#2130. mysql-test/t/lock.test: New error message with WL#2130. This change is under debate and might change in the future, but will do for now. mysql-test/t/sp-error.test: Updated for WL#2130. Some tests are voided when table access does work from functions. mysql-test/t/sp.test: Updated for WL#2130. mysql-test/t/view.test: Updated for WL#2130. sql/item_func.cc: We now have to set net.no_send_ok for functions too, with WL#2130. sql/share/errmsg.txt: Reused an error code since the old use was voided by WL#2130, but a new one was needed instead (similar, but more specific restriction). sql/sp.cc: Fixed error handling and collection of used tables for WL#2130. sql/sp.h: Fixed error handling and collection of used tables for WL#2130. sql/sp_head.cc: Added support functions for collecting and merging hash tables and lists of used tables from SPs and substatements, for WL#2130. sql/sp_head.h: Added support functions for collecting and merging hash tables and lists of used tables from SPs and substatements, for WL#2130. sql/sql_base.cc: Changed the way table->query_id is tested and set during with locked tables in effect. This makes some SP test cases work with WL#2130, but has a side effect on some error cases with explicit LOCK TABLES. It's still debated if this is the correct way, so it might change. sql/sql_class.h: Added flags for circumventing some interference between WL#2130 and mysql_make_view(). sql/sql_derived.cc: Added some missing initializations. (Potential bugs.) sql/sql_lex.cc: Clear the new hash tables for WL#2130. sql/sql_lex.h: Added hash tables for procedures and tables too (as for functions), for WL#2130. sql/sql_parse.cc: WL#2130: Make table accesses from stored functions work by adding an implicit LOCK TABLES around (most) executed statements. To do this, we have to go through a loop where we collect all SPs and tables in mysql_execute_statement. sql/sql_prepare.cc: Cache both functions and procedures for WL#2130. sql/sql_show.cc: Added some missing initializations. (Potential bugs.) sql/sql_view.cc: Shortcut mysql_make_view() if thd->shortcut_make_view is true during the pre-open phase for collecting tables in WL#2130. Otherwise, the similar mechanism here causes interference. sql/sql_yacc.yy: For WL#2130, added caching of procedures and disallowed LOCK/UNLOCK TABLES in SPs. |
||
|
unknown
|
c3da2d12f7 |
Fix for bug #5888 "Triggers with nonexistent columns cause packets
out of order". (final version)
Now instead of binding Item_trigger_field to TABLE objects during
trigger definition parsing at table open, we perform pass through
special list of all such objects in trigger. This allows easily check
all references to fields in old/new version of row in trigger during
execution of CREATE TRIGGER statement (this is more courtesy for users
since we can't check everything anyway).
We also report that such reference is bad by returning error from
Item_trigger_field::fix_fields() method (instead of setup_field())
This means that if trigger is broken we will bark during trigger
execution instead of trigger definition parsing at table open.
(i.e. now we allow to open tables with broken triggers).
mysql-test/r/trigger.result:
Added test which attempts to create trigger for table referencing to
field which does not exist in this table.
mysql-test/t/trigger.test:
Added test which attempts to create trigger for table referencing to
field which does not exist in this table.
sql/item.cc:
Item_trigger_field::setup_field() now returns void. If any error
will occur we will report it at fix_fields() stage.
sql/item.h:
Item_trigger_field:
- Added next_trg_field member for linking all such objects in trigger
in one list.
- Also setup_field() now returns void. If any error will occur we will
report it at fix_fields() stage.
sql/mysql_priv.h:
Added SQL_LIST::push_back() method which allows to add another SQL_LIST
to the end of this SQL_LIST.
sql/sp_head.cc:
sp_head::init()/reset_lex()/restore_lex():
In order to fill global LEX::trg_table_fields (list of all
Item_trigger_field objects for trigger) we should init the same list
in LEX of substatement before its parsing and merge it to global list
after parsing.
sql/sp_head.h:
sp_instr_trigger_field:
Made trigger_field member public to be able to add it more easily to
global list of all Item_trigger_field objects in trigger.
sql/sql_lex.cc:
LEX::trg_table was removed.
sql/sql_lex.h:
Now we are binding Item_trigger_field's to TABLE object by passing
through specially constructed list of all such objects in this trigger
instead of doing this during trigger definition parsing at table open.
So we no longer need LEX::trg_table, we use LEX::trg_table_fields list
instead.
sql/sql_parse.cc:
mysql_execute_command():
Since now we use trigger body for some checks in
mysql_create_or_drop_trigger() we should destroy it only
after calling this function.
sql/sql_trigger.cc:
Now instead of binding Item_trigger_field to TABLE objects during
trigger definition parsing at table open, we perform pass through
special list of all such objects in trigger. This allows easily check
all references to fields in old/new version of row in trigger during
execution of CREATE TRIGGER statement (this is more courtesy for users
since we can't check everything anyway).
We also report that such reference is bad by returning error from
Item_trigger_field::fix_fields() method (instead of setup_field())
This means that if trigger is broken we will bark during trigger
execution instead of trigger definition parsing at table open.
(i.e. now we allow to open tables with broken triggers).
Table_triggers_list::prepare_old_row_accessors() method was added to be
able to reuse code creating Field objects referencing TABLE::record[1]
buffer instead of TABLE::record[0].
sql/sql_trigger.h:
Added Table_triggers_list::prepare_old_row_accessors() method to be
able to reuse code creating Field objects referencing to TABLE::record[1]
instead of record[0].
sql/sql_yacc.yy:
Now instead of performing binding of Item_trigger_field objects
to TABLE object during trigger definition parsing at table open,
we perform this binding by passing through specially constructed
list of all such items in trigger.
We also check value returned from memory allocation functions.
|
||
|
unknown
|
db67626196 |
After merge fixes
Added push_back(void *, MEM_ROOT *) to make some list-handling code easier that needs to be allocated in a different mem-root (Before one had to change thd->mem_root ; push_back(); restore mem_root. mysql-test/t/range.test: After merge fixRecR sql/item_func.cc: After merge fix sql/item_sum.cc: After merge fix sql/opt_range.cc: After merge fix sql/parse_file.cc: After merge fix sql/sp.cc: After merge fix sql/sp_head.cc: After merge fix sql/sp_head.h: After merge fix sql/sql_base.cc: After merge fix sql/sql_class.h: After merge fix sql/sql_list.h: Added push_back(void *, MEM_ROOT *) to make some list-handling code easier that needs to be allocated in a different mem-root (Before one had to change thd->mem_root ; push_back(); restore mem_root. sql/sql_prepare.cc: After merge fix sql/sql_select.cc: After merge fix sql/sql_table.cc: After merge fix Fixed problem with OPTIMIZE on INNODB tables sql/sql_trigger.cc: After merge fix sql/sql_union.cc: After merge fix sql/sql_view.cc: After merge fix sql/sql_yacc.yy: After merge fix sql/table.cc: After merge fix |
||
|
unknown
|
e2c4279ce2 |
Fixed BUG#3583: query cache doesn't work for stored procedures.
mysql-test/r/sp.result: New test case for BUG#3583. (And current query is now set correctly.) mysql-test/t/sp.test: New test case for BUG#3583. sql/sp_head.cc: Set the thd->query and try to use cached query, if any, when executing a statement. sql/sp_head.h: Extract the sub-query and store in sp_instr_stmt. sql/sql_cache.cc: Keep the net->pkt_nr up-to-date when using query cache. This makes it work with stored procedures too. sql/sql_cache.h: Keep the net->pkt_nr up-to-date when using query cache. This makes it work with stored procedures too. sql/sql_yacc.yy: Extract the sub-query and store in sp_instr_stmt. (And it's never safe to cache references to local variables.) |
||
|
unknown
|
1912148cec |
Fixed BUG#3294: Stored procedure crash if table dropped before use.
Dropping the table was not the real problem, the problem was with errors occuring within error handlers. mysql-test/r/sp-error.result: New test case for BUG#3294. mysql-test/t/sp-error.test: New test case for BUG#3294. sql/sp_head.cc: Use hreturn instruction both for continue and exit handlers (a special case of a jump). sql/sp_head.h: Use hreturn instruction both for continue and exit handlers (a special case of a jump). sql/sp_rcontext.cc: Keep track on if we're in a handler already, for error handling. sql/sp_rcontext.h: Keep track on if we're in a handler already, for error handling. sql/sql_yacc.yy: Use hreturn instruction both for continue and exit handlers (a special case of a jump). |
||
|
unknown
|
12ce293a7f |
WL#1218 "Triggers"
After review and after merge fixes. mysql-test/t/trigger.test: After merge fix. Updated error codes. sql/sp_head.cc: After merge fix. To give some chances for functions/triggers we have to close tables during sp_instr_* execution only if we have opened them before. sql/sp_head.h: After merge fix. sp_instr constructor now takes one more argument. sql/sql_trigger.cc: After merge and review fixes. Some variable renaming and optimizations. sql/sql_yacc.yy: After merge fixes. sp_instr_* classes now require sp context as constructor parameter. Also we should be careful with adding table for which we are creating trigger to table list. Some elements in trigger body can damage LEX::query_tables and so we should add this table to list only after parsing trigger body. |
||
|
unknown
|
cab6f8df6d |
Merge of changes from the main tree to tree for WL#1218 "Triggers".
sql/item.cc: Auto merged sql/item.h: Auto merged sql/item_func.cc: Auto merged sql/lex.h: Auto merged sql/parse_file.cc: Auto merged sql/sp_head.h: Auto merged sql/sql_base.cc: Auto merged sql/sql_delete.cc: Auto merged sql/sql_insert.cc: Auto merged sql/sql_lex.cc: Auto merged sql/sql_lex.h: Auto merged sql/sql_parse.cc: Auto merged sql/sql_table.cc: Auto merged sql/sql_update.cc: Auto merged sql/sql_yacc.yy: Auto merged sql/table.h: Auto merged include/mysqld_error.h: Manual merge. sql/mysql_priv.h: Manual merge. sql/share/czech/errmsg.txt: Manual merge. sql/share/danish/errmsg.txt: Manual merge. sql/share/dutch/errmsg.txt: Manual merge. sql/share/english/errmsg.txt: Manual merge. sql/share/estonian/errmsg.txt: Manual merge. sql/share/french/errmsg.txt: Manual merge. sql/share/german/errmsg.txt: Manual merge. sql/share/greek/errmsg.txt: Manual merge. sql/share/hungarian/errmsg.txt: Manual merge. sql/share/italian/errmsg.txt: Manual merge. sql/share/japanese/errmsg.txt: Manual merge. sql/share/korean/errmsg.txt: Manual merge. sql/share/norwegian-ny/errmsg.txt: Manual merge. sql/share/norwegian/errmsg.txt: Manual merge. sql/share/polish/errmsg.txt: Manual merge. sql/share/portuguese/errmsg.txt: Manual merge. sql/share/romanian/errmsg.txt: Manual merge. sql/share/russian/errmsg.txt: Manual merge. sql/share/serbian/errmsg.txt: Manual merge. sql/share/slovak/errmsg.txt: Manual merge. sql/share/spanish/errmsg.txt: Manual merge. sql/share/swedish/errmsg.txt: Manual merge. sql/share/ukrainian/errmsg.txt: Manual merge. sql/sp_head.cc: Manual merge. |
||
|
unknown
|
52ac4935e7 |
WL#1218 "Triggers". Some very preliminary version of patch.
Mostly needed for Monty for him getting notion what needed for triggers
from new .FRM format.
Things to be done:
- Right placement of trigger's invocations
- Right handling of errors in triggers (including transaction rollback)
- Support for priviliges
- Right handling of DROP/RENAME table (hope that it will be handled automatically
with merging of .TRG into .FRM file)
- Saving/restoring some information critical for trigger creation and replication
with their definitions (e.g. sql_mode, creator, ...)
- Replication
Already has some known bugs so probably not for general review.
include/mysqld_error.h:
Added trigger related error codes.
sql/Makefile.am:
Added sql_trigger.* files to list of sources from which mysqld is built.
sql/item.cc:
Added Item_trigger_field class representing field of new/old version of row which is
inserted/updated/deleted and for which trigger is invoked.
sql/item.h:
Added enums for describing trigger properties. (Here because of dependencies).
Added Item_trigger_field class representing field of new/old version of row which is
inserted/updated/deleted and for which trigger is invoked.
sql/item_func.cc:
Added Item_func_set_user_var::print_as_stmt() for printing of assignment to ser variable
from stored procedures.
Added comment clarifying why we don't need set no_send_ok when calling stored functions.
sql/item_func.h:
Added Item_func_set_user_var::print_as_stmt() for printing of assignment to ser variable
from stored procedures.
sql/lex.h:
Symbols used in statements defining triggers were added.
sql/mysql_priv.h:
Exported some functions needed for triggers implementation.
sql/parse_file.cc:
Cleaned up FILE_OPTIONS_STRLIST handling (needed for triggers).
sql/parse_file.h:
Cleaned up FILE_OPTIONS_STRLIST handling (needed for triggers).
sql/share/czech/errmsg.txt:
Added trigger related error messages.
sql/share/danish/errmsg.txt:
Added trigger related error messages.
sql/share/dutch/errmsg.txt:
Added trigger related error messages.
sql/share/english/errmsg.txt:
Added trigger related error messages.
sql/share/estonian/errmsg.txt:
Added trigger related error messages.
sql/share/french/errmsg.txt:
Added trigger related error messages.
sql/share/german/errmsg.txt:
Added trigger related error messages.
sql/share/greek/errmsg.txt:
Added trigger related error messages.
sql/share/hungarian/errmsg.txt:
Added trigger related error messages.
sql/share/italian/errmsg.txt:
Added trigger related error messages.
sql/share/japanese/errmsg.txt:
Added trigger related error messages.
sql/share/korean/errmsg.txt:
Added trigger related error messages.
sql/share/norwegian-ny/errmsg.txt:
Added trigger related error messages.
sql/share/norwegian/errmsg.txt:
Added trigger related error messages.
sql/share/polish/errmsg.txt:
Added trigger related error messages.
sql/share/portuguese/errmsg.txt:
Added trigger related error messages.
sql/share/romanian/errmsg.txt:
Added trigger related error messages.
sql/share/russian/errmsg.txt:
Added trigger related error messages.
sql/share/serbian/errmsg.txt:
Added trigger related error messages.
sql/share/slovak/errmsg.txt:
Added trigger related error messages.
sql/share/spanish/errmsg.txt:
Added trigger related error messages.
sql/share/swedish/errmsg.txt:
Added trigger related error messages.
sql/share/ukrainian/errmsg.txt:
Added trigger related error messages.
sql/sp_head.cc:
sp_head::init_strings(): added support for triggers
(we don't have most of strings for them)
sp_head::execute_function(): triggers don't require RETURN
sp_head::reset_lex(): added propagation of trigger properties to LEX used for
parsing of statements composing trigger body.
Added two more SP instructions:
- sp_instr_set_user_var for setting user variables in stored functions and triggers
(we can't use sp_instr_stmt and "SET @a:=..." statement since it will close open
tables and thus break execution of calling statement.
- sp_instr_set_trigger_field for assignment to fields of row being updated/inserted in
triggers
sql/sp_head.h:
Added new type of sp_head object - TYPE_ENUM_TRIGGER
Added two more SP instructions:
- sp_instr_set_user_var for setting user variables in stored functions and triggers
(we can't use sp_instr_stmt and "SET @a:=..." statement since it will close open
tables and thus break execution of calling statement.
- sp_instr_set_trigger_field for assignment to fields of row being updated/inserted in
triggers
sql/sql_base.cc:
Now freeing memory occupied by trigger related structures when closing tables.
open_unireg_entry(): added loading of triggers for table.
find_field_in_real_table() is now public since it required by Item_trigger_field in item.cc
sql/sql_delete.cc:
Added triggers invocation for DELETE (should be fixed for sure :))
sql/sql_insert.cc:
Added triggers invocation for INSERT (should be fixed for sure :))
sql/sql_lex.cc:
Added trg_new_row_fake_var variable pointer to which is used for distinguishing between
assignment to NEW row field (when parsing trigger definition) and structured variable.
Added initialization of LEX->trg_table to lex_start(). (When triggers are parsed during
opening of table it points to table object.)
sql/sql_lex.h:
Added trigger related commands.
Added st_trg_chistics structure describing properties of trigger being created
(as struct and as LEX member).
Added trg_new_row_fake_var variable pointer to which is used for
distinguishing between assignment to NEW row field (when parsing trigger definition)
and structured variable.
Added LEX::trg_table which points to table being opened when we are parsing trigger
definition while opening table.
sql/sql_parse.cc:
Added support for CREATE/DROP TRIGGER commands.
sql/sql_table.cc:
Cleanup. close_cached_table() always returns 0 and its result is not analyzed in most
places so chenged its return type to void.
sql/sql_update.cc:
Added triggers invocation for UPDATE (should be fixed for sure :))
sql/sql_yacc.yy:
Added support for CREATE/DROP TRIGGER statements.
Added support for OLD/NEW row identifiers in trigger.
Made assignment to user variables not to break execution of stored function or trigger.
sql/table.h:
Added TABLE::triggers member representing triggers for this table.
|
||
|
unknown
|
071651efbd |
Major rehacking and cleanup of sp_pcontext.
This finishes (almost) WL#2002: Implement stored procedure GOTO.
Only the syntax issue for free labels remains ("label L;" vs "L:").
include/mysqld_error.h:
New error code for GOTO in SP handler.
mysql-test/r/sp-error.result:
New error test cases for GOTO.
mysql-test/r/sp.result:
New test cases for GOTO.
Also removed some things that made it impossible to run the test in
an external (debugged) mysqld.
mysql-test/t/sp-error.test:
New error test cases for GOTO.
mysql-test/t/sp.test:
New test cases for GOTO.
Also removed some things that made it impossible to run the test in
an external (debugged) mysqld.
sql/share/czech/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/danish/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/dutch/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/english/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/estonian/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/french/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/german/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/greek/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/hungarian/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/italian/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/japanese/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/korean/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/norwegian-ny/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/norwegian/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/polish/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/portuguese/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/romanian/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/russian/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/serbian/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/slovak/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/spanish/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/swedish/errmsg.txt:
New error message for GOTO in SP handler.
sql/share/ukrainian/errmsg.txt:
New error message for GOTO in SP handler.
sql/sp_head.cc:
Code cleanup (renaming of pcontext methods), support goto, and fixed bug
in jump shortcutting in the optimizer (detect infinite loops).
sql/sp_head.h:
Code cleanup (renaming of pcontext methods), support goto, and fixed bug
in jump shortcutting in the optimizer (detect infinite loops).
sql/sp_pcontext.cc:
Major rehack and cleanup:
- We now push and pop a chain of contexts during parsing (instead of having
a single one).
- Makes error detection for GOTO easier and enables some optmizations and
debugger support.
- Makes it a little trickier to keep track on variable and cursor indexes instead.
- Renamed things to get a more consistent naming scheme too.
sql/sp_pcontext.h:
Major rehack and cleanup:
- We now push and pop a chain of contexts during parsing (instead of having
a single one).
- Makes error detection for GOTO easier and enables some optmizations and
debugger support.
- Makes it a little trickier to keep track on variable and cursor indexes instead.
- Renamed things to get a more consistent naming scheme too.
sql/sql_yacc.yy:
Changes to reflect the rework and renamings in sp_pcontext, and fixed
some GOTO error checking.
|
||
|
unknown
|
ac06195caa |
Fixed BUG#3157: Crash if stored procedure contains IF EXISTS,
and BUG#336: Subselects with tables does not work as values for local SP variables (which was closed before with a temp. fix, but not actually fixed). mysql-test/r/sp-error.result: Moved test case for BUG#336 to sp.test, as it's not generating an error any longer. mysql-test/r/sp.result: Move test case for BUG#336 from sp-error.test and added new test case for BUG#3157. mysql-test/t/sp-error.test: Moved test case for BUG#336 to sp.test, as it's not generating an error any longer. mysql-test/t/sp.test: Move test case for BUG#336 from sp-error.test and added new test case for BUG#3157. sql/sp_head.cc: Open and close tables in set, jump-if[-not] and freturn instructions if the value expression is a subselect. sql/sp_head.h: Store tables in set, jump-if[-not] and freturn instructions if the value expression is a subselect. sql/sql_yacc.yy: Store tables in set, jump-if[-not] and freturn instructions if the value expression is a subselect. |
||
|
unknown
|
9b5a6f7228 |
WL#2002: Implement stored procedure GOTO.
Mostly done, it works, but the temporary LABEL syntax still to be fixed. mysql-test/r/sp-error.result: New test case for WL#2002 (GOTO). mysql-test/r/sp.result: New test case for WL#2002 (GOTO). (Also corrected another test) mysql-test/t/sp-error.test: New test case for WL#2002 (GOTO). mysql-test/t/sp.test: New test case for WL#2002 (GOTO). (Also corrected another test) sql/lex.h: New symbol GOTO. Also a temporary symbol LABEL, which hopefully will go away soon. sql/sp_head.cc: Fixed backpatching to cope with free GOTO labels an hpop and cpop instructions. Also optimized away pointless jump instructions. sql/sp_head.h: Fixed backpatching to cope with free GOTO labels an hpop and cpop instructions. We now sometimes generate hpop/cpop 0 instructions but the optimizer removes them. sql/sp_pcontext.cc: Added free GOTO labels, and support for coping with jumps out of blocks with handlers or cursors. sql/sp_pcontext.h: Added free GOTO labels, and support for coping with jumps out of blocks with handlers or cursors. sql/sql_yacc.yy: Added GOTO and LABEL, and adjusted backpatching accordingly. Also fixed LEAVE out of blocks. The LABEL syntax will go away soon, hopefully. |
||
|
unknown
|
177ef90b57 |
Fixed BUG#4902: Stored procedure with SHOW WARNINGS leads to packet error,
and tried to do it properly this time, digging out all show commands that need the multi results flag set. mysql-test/r/sp.result: New test case for BUG#4902, with lots of other show commands as well. mysql-test/t/sp.test: New test case for BUG#4902, with lots of other show commands as well. sql/sp_head.cc: The check for possible multiple result commands was becomming unwieldly, so we moved it to a separate function, and added loads of new command codes to the test. sql/sp_head.h: The check for possible multiple result commands was becomming unwieldly, so we moved it to a separate function. sql/sql_yacc.yy: The check for possible multiple result commands was becomming unwieldly, so we moved it to a separate function. |
||
|
unknown
|
81aad353c5 |
WL#2001: Optimize stored procedure code.
Added a simple optimizer that shortcuts jumps and skip unused instructions. sql/sp.cc: Optimize the code after parsing. sql/sp_head.cc: Added a simple optimizer that shortcuts jumps and skip unused instructions. sql/sp_head.h: Added a simple optimizer that shortcuts jumps and skip unused instructions. |
||
|
unknown
|
6762a65133 |
Fixed BUG#2564: SHOW CREATE inconsistent W.R.T ANSI_QUOTES.
It's not possible to quote the definition according to the current sql_mode setting, so instead we use the setting stored with the SP (that's how it's parsed anyway), and show this setting in the SHOW CREATE output. mysql-test/r/sp.result: Modifed SHOW CREATE FUNCTION|PROCEDURE output. Show the sql_mode used at creation as well. New test case for BUG#2564: SHOW CREATE inconsistent W.R.T ANSI_QUOTES. mysql-test/t/sp.test: New test case for BUG#2564: SHOW CREATE inconsistent W.R.T ANSI_QUOTES. sql/sp.cc: Rewrote create_string to quote things correctly according to the sql_mode used at creation time. sql/sp_head.cc: Store sql_mode in sp_head and use it for SHOW CREATE. sql/sp_head.h: Store sql_mode in sp_head and use it for SHOW CREATE. |
||
|
unknown
|
82fd12f4be |
cleunup items of instruction after every instruction execution
sql/sp_head.h: removed blanks at line end cleunup items of instruction after every instruction execution |