An error occurred fetching the project authors.
  1. 11 May, 2007 1 commit
    • unknown's avatar
      Fix for: · d46c8ce6
      unknown authored
        Bug #20662 "Infinite loop in CREATE TABLE IF NOT EXISTS ... SELECT
                    with locked tables"
        Bug #20903 "Crash when using CREATE TABLE .. SELECT and triggers"
        Bug #24738 "CREATE TABLE ... SELECT is not isolated properly"
        Bug #24508 "Inconsistent results of CREATE TABLE ... SELECT when
                    temporary table exists"
      
      Deadlock occured when one tried to execute CREATE TABLE IF NOT
      EXISTS ... SELECT statement under LOCK TABLES which held
      read lock on target table.
      Attempt to execute the same statement for already existing
      target table with triggers caused server crashes.
      Also concurrent execution of CREATE TABLE ... SELECT statement
      and other statements involving target table suffered from
      various races (some of which might've led to deadlocks).
      Finally, attempt to execute CREATE TABLE ... SELECT in case
      when a temporary table with same name was already present
      led to the insertion of data into this temporary table and
      creation of empty non-temporary table.
       
      All above problems stemmed from the old implementation of CREATE
      TABLE ... SELECT in which we created, opened and locked target
      table without any special protection in a separate step and not
      with the rest of tables used by this statement.
      This underminded deadlock-avoidance approach used in server
      and created window for races. It also excluded target table
      from prelocking causing problems with trigger execution.
      
      The patch solves these problems by implementing new approach to
      handling of CREATE TABLE ... SELECT for base tables.
      We try to open and lock table to be created at the same time as
      the rest of tables used by this statement. If such table does not
      exist at this moment we create and place in the table cache special
      placeholder for it which prevents its creation or any other usage
      by other threads.
      We still use old approach for creation of temporary tables.
      
      Note that we have separate fix for 5.0 since there we use slightly
      different less intrusive approach.
      
      
      mysql-test/r/create.result:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/r/trigger.result:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      mysql-test/t/create.test:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/t/trigger.test:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      sql/lock.cc:
        Now for creation of name-lock placeholder lock_table_name() uses
        auxiliary function table_cache_insert_placeholder().
      sql/mysql_priv.h:
        Removed declaration of non-existing build_table_path() routine.
        The former mysql_create_table_internal() was renamed to
        mysql_create_table_no_lock() and now exposed to other modules to
        give them opportunity of creation of tables in cases when name-lock
        is already obtained.
        reopen_name_locked_table() now has 3rd argument which controls linking
        in of table being opened into THD::open_tables (this is useful in
        cases when placeholder used for name-locking is already linked into
        this list).
        Added declaration of auxiliary function table_cache_insert_placeholder()
        which is used for creation of table placeholders for name-locking.
        Added declaration of lock_table_name_if_not_cached() which can be
        used to take an exclusive name-lock on table if there are no records
        for it in table cache.
        Changed signature of unlink_open_table() function to simplify its use
        and make it useful for table placeholders and tables that are only open.
        Added auxiliary drop_open_table() routine.
        Moved declaration of refresh_version to table.h header to make it
        accessible from inline methods of TABLE class.
        MYSQL_OPEN_IGNORE_LOCKED_TABLES flag is no longer used. Instead
        MYSQL_OPEN_TEMPORARY_ONLY option was added.
      sql/sql_base.cc:
        Added support for the new approach to the handling of CREATE TABLE
        ... SELECT for base tables.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads.
        
        Note significant distinctions of this placeholder from the placeholder
        used for normal name-lock: 1) It is treated like open table by other
        name-locks so it does not allow name-lock taking operations like DROP
        TABLE or RENAME TABLE to proceed. 2) it is linked into THD::open_tables
        list and automatically removed during close_thread_tables() call
          
        open_tables():
          Implemented logic described above. To do this added
          auxiliary check_if_table_exists() function.
          Removed support for MYSQL_OPEN_IGNORE_LOCKED_TABLES option
          which is no longer used.
          Added MYSQL_OPEN_TEMPORARY_ONLY which is used to restrict
          search for temporary tables only.
        close_cached_tables()/close_thread_table()/reopen_tables()/
        close_old_data_files()/table_is_used()/remove_table_from_cache():
          Added support for open placeholders (note that we also use them
          when we need to re-open tables during flush).
        unlink_open_table():
          Changed function signature to simplify its use and to make
          useful for open placeholders and tables which are only
          open and not locked.
        Added auxiliary drop_open_table() routine.
        reopen_name_locked_table():
          Now has 3rd argument which controls linking in of table being
          opened into THD::open_tables (this is useful in cases when
          placeholder used for name-locking is already linked into
          this list).
        Added auxiliary table_cache_insert_placeholder() routine which
        simplifies creation of placeholders used for name-locking.
        Added lock_table_name_if_not_cached() which can be used to take
        an exclusive name-lock on table if there are no records for it
        in table cache.
      sql/sql_handler.cc:
        Adjusted mysql_ha_mark_tables_for_reopen() routine to properly
        handle placeholders which now can be linked into open tables
        list.
      sql/sql_insert.cc:
        Introduced new approach to handling of base tables in CREATE TABLE
        ... SELECT statement.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads. By doing this we avoid races which existed with
        previous approach in which we created, opened and locked target in
        separate step without any special protection.
        This also allows properly calculate prelocking set in cases when
        target table already exists and has some on insert triggers.
        
        Note that we don't employ the same approach for temporary tables
        (this is okay as such tables are unaffected by other threads).
        
        Changed create_table_from_items() and methods of select_create
        class to implement this approach.
      sql/sql_parse.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_prepare.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_table.cc:
        Changed mysql_create_table(), mysql_create_like_table() and
        mysql_alter_table() (in rename case) to obtain exclusive name-lock
        on the non-temporary table which is going to be created (to which
        we going to rename). This ensures that not only destination table
        doesn't exist on disk but also that there are no placeholder in 
        table cache for it (i.e. there is no CREATE TABLE ... SELECT operation
        in progress for it). Note that to avoid deadlocks while taking these
        name-locks this code assumes that existence of any record for table in
        table cache (even name-lock) means that table exists. Altough such
        check can lead to false positives these should occur only in case of
        highly concurrent DDL operations on the table and should not break
        binary logging.
        
        Renamed mysql_create_table_internal() to mysql_create_table_no_lock()
        and made it accessible from other files to give them ability to create
        table in situation when name-lock is already obtained or not relevant.
        
        Adjusted calls to reopen_name_locked_table(), which now takes
        extra argument, which controls linking of open table into
        THD::open_tables list.
        
        Removed redundant setting of table's 'version' field before calls
        to close_cached_table(). This function will set it to 0 itself
        anyway.
      sql/sql_trigger.cc:
        reopen_name_locked_tables() now has one more argument which controls
        linking of opened table into the THD::open_tables list.
      sql/sql_yacc.yy:
        The new approach to handling of CREATE TABLE ... SELECT statement
        for base tables assumes that all tables including table to be
        created are open and (or) locked at the same time. Therefore
        we need to set correct lock for target table.
      sql/table.h:
        Moved declaration of refresh_version variable from mysql_priv.h
        to make it accessible from inline methods of TABLE class.
        Renamed TABLE::locked_by_flush member to open_placeholder since
        now it is also used for taking exclusive name-lock and not only
        by flush. 
        Introduced TABLE::is_name_opened() helper method which can be used
        to distinguish TABLE instances corresponding to open tables or
        placeholders for them from closed instances (e.g. due to their old
        version). Also introduced TABLE::needs_reopen_or_name_lock() helper
        which allows to check if TABLE instance corresponds to outdated
        version of table or to name-lock placeholder.
        Introduced TABLE_LIST::create member which marks elements of
        table list corresponds to the table to be created.
        Adjusted TABLE_LIST::placeholder() method to take into account 
        name-lock placeholders for tables to be created (this, for example,
        allows to properly handle such placeholders in lock_tables()).
        Finally, moved currently unused TABLE::open_next/open_prev
        members under ifdef NOT_YET.
      mysql-test/r/create_select-big.result:
        New BitKeeper file ``mysql-test/r/create_select-big.result''
      mysql-test/t/create_select-big.test:
        New BitKeeper file ``mysql-test/t/create_select-big.test''
      d46c8ce6
  2. 19 Mar, 2007 1 commit
    • unknown's avatar
      sql_insert.cc: · 3798a7d5
      unknown authored
        Removed wrong fix for the bug#27006.
        The bug was added by the fix for the bug#19978 and fixed by Monty on 2007/02/21.
      trigger.test, trigger.result:
        Corrected test case for the bug#27006.
      
      
      sql/sql_insert.cc:
        Removed wrong fix for the bug#27006.
        The bug was added by the fix for the bug#19978 and fixed by Monty on 2007/02/21.
      mysql-test/t/trigger.test:
        Corrected test case for the bug#27006.
      mysql-test/r/trigger.result:
        Corrected test case for the bug#27006.
      3798a7d5
  3. 16 Mar, 2007 1 commit
    • unknown's avatar
      Bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY · 6d93f150
      unknown authored
      UPDATE if the row wasn't actually changed.
      
      This bug was caused by fix for bug#19978. It causes AFTER UPDATE triggers
      not firing if a row wasn't actually changed by the update part of the
      INSERT .. ON DUPLICATE KEY UPDATE.
      
      Now triggers are always fired if a row is touched by the INSERT ... ON
      DUPLICATE KEY UPDATE.
      
      
      sql/sql_insert.cc:
        Bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY
        UPDATE if the row wasn't actually changed.
        Now triggers are always fired if a row is touched by the INSERT ... ON
        DUPLICATE KEY UPDATE.
      mysql-test/r/trigger.result:
        Added a test case for the bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY
        UPDATE if the row wasn't actually changed.
      mysql-test/t/trigger.test:
        Added a test case for the bug#27006: AFTER UPDATE triggers not fired with INSERT ... ON DUPLICATE KEY
        UPDATE if the row wasn't actually changed.
      6d93f150
  4. 06 Mar, 2007 3 commits
    • unknown's avatar
      Manual merge · f7414b28
      unknown authored
      f7414b28
    • unknown's avatar
      Manual merge · 71f90b7e
      unknown authored
      71f90b7e
    • unknown's avatar
      Bug#8407 (Stored functions/triggers ignore exception handler) · 266a7fff
      unknown authored
      Bug 18914 (Calling certain SPs from triggers fail)
      Bug 20713 (Functions will not not continue for SQLSTATE VALUE '42S02')
      Bug 21825 (Incorrect message error deleting records in a table with a
        trigger for inserting)
      Bug 22580 (DROP TABLE in nested stored procedure causes strange dependency
        error)
      Bug 25345 (Cursors from Functions)
      
      
      This fix resolves a long standing issue originally reported with bug 8407,
      which affect the behavior of Stored Procedures, Stored Functions and Trigger
      in many different ways, causing symptoms reported by all the bugs listed.
      In all cases, the root cause of the problem traces back to 8407 and how the
      server locks tables involved with sub statements.
      
      Prior to this fix, the implementation of stored routines would:
      - compute the transitive closure of all the tables referenced by a top level
      statement
      - open and lock all the tables involved
      - execute the top level statement
      "transitive closure of tables" means collecting:
      - all the tables,
      - all the stored functions,
      - all the views,
      - all the table triggers
      - all the stored procedures
      involved, and recursively inspect these objects definition to find more
      references to more objects, until the list of every object referenced does
      not grow any more.
      This mechanism is known as "pre-locking" tables before execution.
      The motivation for locking all the tables (possibly) used at once is to
      prevent dead locks.
      
      One problem with this approach is that, if the execution path the code
      really takes during runtime does not use a given table, and if the table is
      missing, the server would not execute the statement.
      This in particular has a major impact on triggers, since a missing table
      referenced by an update/delete trigger would prevent an insert trigger to run.
      
      Another problem is that stored routines might define SQL exception handlers
      to deal with missing tables, but the server implementation would never give
      user code a chance to execute this logic, since the routine is never
      executed when a missing table cause the pre-locking code to fail.
      
      With this fix, the internal implementation of the pre-locking code has been
      relaxed of some constraints, so that failure to open a table does not
      necessarily prevent execution of a stored routine.
      
      In particular, the pre-locking mechanism is now behaving as follows:
      
      1) the first step, to compute the transitive closure of all the tables
      possibly referenced by a statement, is unchanged.
      
      2) the next step, which is to open all the tables involved, only attempts
      to open the tables added by the pre-locking code, but silently fails without
      reporting any error or invoking any exception handler is the table is not
      present. This is achieved by trapping internal errors with
      Prelock_error_handler
      
      3) the locking step only locks tables that were successfully opened.
      
      4) when executing sub statements, the list of tables used by each statements
      is evaluated as before. The tables needed by the sub statement are expected
      to be already opened and locked. Statement referencing tables that were not
      opened in step 2) will fail to find the table in the open list, and only at
      this point will execution of the user code fail.
      
      5) when a runtime exception is raised at 4), the instruction continuation
      destination (the next instruction to execute in case of SQL continue
      handlers) is evaluated.
      This is achieved with sp_instr::exec_open_and_lock_tables()
      
      6) if a user exception handler is present in the stored routine, that
      handler is invoked as usual, so that ER_NO_SUCH_TABLE exceptions can be
      trapped by stored routines. If no handler exists, then the runtime execution
      will fail as expected.
      
      With all these changes, a side effect is that view security is impacted, in
      two different ways.
      
      First, a view defined as "select stored_function()", where the stored
      function references a table that may not exist, is considered valid.
      The rationale is that, because the stored function might trap exceptions
      during execution and still return a valid result, there is no way to decide
      when the view is created if a missing table really cause the view to be invalid.
      
      Secondly, testing for existence of tables is now done later during
      execution. View security, which consist of trapping errors and return a
      generic ER_VIEW_INVALID (to prevent disclosing information) was only
      implemented at very specific phases covering *opening* tables, but not
      covering the runtime execution. Because of this existing limitation,
      errors that were previously trapped and converted into ER_VIEW_INVALID are
      not trapped, causing table names to be reported to the user.
      This change is exposing an existing problem, which is independent and will
      be resolved separately.
      
      
      mysql-test/r/information_schema_db.result:
        Revised the pre-locking code implementation, aligned the tests.
      mysql-test/r/sp-error.result:
        Revised the pre-locking code implementation, aligned the tests.
      mysql-test/r/sp.result:
        Revised the pre-locking code implementation, aligned the tests.
      mysql-test/r/trigger.result:
        Revised the pre-locking code implementation, aligned the tests.
      mysql-test/r/view.result:
        Revised the pre-locking code implementation, aligned the tests.
      mysql-test/t/sp-error.test:
        Revised the pre-locking code implementation, aligned the tests.
      mysql-test/t/sp.test:
        Revised the pre-locking code implementation, aligned the tests.
      mysql-test/t/trigger.test:
        Revised the pre-locking code implementation, aligned the tests.
      sql/lock.cc:
        table->placeholder now checks for schema_table
      sql/mysqld.cc:
        my_message_sql(): invoke internal exception handlers
      sql/sp_head.cc:
        exec_open_and_lock_tables(): open and lock tables, or return the
        continuation destination of this instruction
      sql/sp_head.h:
        exec_open_and_lock_tables(): open and lock tables, or return the
        continuation destination of this instruction
      sql/sql_base.cc:
        Prelock_error_handler: delay open table errors until execution
      sql/sql_class.cc:
        THD: add internal error handler, as an exception mechanism.
      sql/sql_class.h:
        THD: add internal error handler, as an exception mechanism.
      sql/sql_update.cc:
        table->placeholder now checks for schema_table
      sql/table.cc:
        st_table_list::hide_view_error(): masked more errors for view security
      sql/table.h:
        table->placeholder now checks for schema_table, and unopened tables
      266a7fff
  5. 12 Jan, 2007 1 commit
    • unknown's avatar
      Fixed bug #25398: crash in a trigger when using trigger fields · 35e36393
      unknown authored
      in a select list.
      The objects of the Item_trigger_field class inherited the implementations
      of the methods copy_or_same, get_tmp_table_item and get_tmp_table_field
      from the class Item_field while they rather should have used the default
      implementations defined for the base class Item.
      It could cause catastrophic problems for triggers that used SELECTs
      with select list containing trigger fields such as NEW.<table column>
      under DISTINCT.
      
      
      mysql-test/r/trigger.result:
        Added a test case for bug #25398.
      mysql-test/t/trigger.test:
        Added a test case for bug #25398.
      35e36393
  6. 28 Dec, 2006 1 commit
    • unknown's avatar
      WL#3630 (add embedded server to pushbuild) · 333b2684
      unknown authored
      5.1-related fixes
      libmysqld/Makefile.am fixed to recompile and link ha_*.cc files that
      keep dependance on THD structure.
      Minor fixes to make tests working.
      
      
      config/ac-macros/plugins.m4:
        condition_dependent_plugin_objects added
      libmysqld/Makefile.am:
        rules for ha_*.o files added
        condition_dependent_plugin_objects sent to linker
      libmysqld/lib_sql.cc:
        ddl_log initialization added
      mysql-test/r/flush_block_commit_notembedded.result:
        result fixed
      mysql-test/t/crash_commit_before.test:
        doesn't work in embedded server
      mysql-test/t/csv.test:
        replace_result added
      mysql-test/t/ps.test:
        doesn't work in embedded server
        should be fixed by separating ps_notembedded.test
      mysql-test/t/ps_1general.test:
        replace_result fixed
      mysql-test/t/ps_not_windows.test:
        doesn't work in embedded server
      mysql-test/t/trigger.test:
        replace_result fixed
      sql/sql_insert.cc:
        #ifdef HAVE_ROW_BASED_REPLICATION added
      storage/myisam/ha_myisam.cc:
        MY_UNPACK_FILENAME flag added
      333b2684
  7. 21 Dec, 2006 1 commit
    • unknown's avatar
      Bug #23125 [patch] trigger test fails when run as root · b461c41c
      unknown authored
       - Skip tests using chmod when running as root
      
      
      mysql-test/t/information_schema_chmod.test:
        Use mysqltest builtin "chmode"
      mysql-test/t/mysqltest.test:
        Dont run as root - test chmod
      mysql-test/t/rpl_rotate_logs.test:
        Use mysqltest builtin "chmode"
        Use 'write_file' and 'chmod' instead of system
      mysql-test/t/trigger.test:
        Don't run as root
        Use 'write_file' and 'chmod'
      mysql-test/t/varbinary.test:
        Don't run as root
      b461c41c
  8. 21 Nov, 2006 1 commit
    • unknown's avatar
      Bug#23556: TRUNCATE TABLE still maps to DELETE · 1a0e1f13
      unknown authored
       This is the 5.0 part of the fix.
       Currently TRUNCATE command will not call
       delete_all_rows() in the handler (that implements
       the "fast" TRUNCATE for InnoDB) when there are
       triggers on the table.
       As decided by the architecture team TRUNCATE must
       use "fast" TRUNCATE even when there are triggers.
       Thus it must ignore the triggers. 
       Made TRUNCATE to ignore the triggers and call
       delete_all_rows() for all storage engines
       to maintain engine consistency.
      
      
      mysql-test/r/trigger.result:
        Bug#23556: TRUNCATE TABLE still maps to DELETE
         - test case
      mysql-test/t/trigger.test:
        Bug#23556: TRUNCATE TABLE still maps to DELETE
         - test case
      sql/sql_delete.cc:
        Bug#23556: TRUNCATE TABLE still maps to DELETE
         - We implemenent fast TRUNCATE for InnoDB even
           if triggers are present.  
         - TRUNCATE ignores triggers.
      1a0e1f13
  9. 13 Nov, 2006 3 commits
    • unknown's avatar
      Bug#23703 (DROP TRIGGER needs an IF EXISTS) · 541e9c9a
      unknown authored
      This change set implements the DROP TRIGGER IF EXISTS functionality.
      
      This fix is considered a bug and not a feature, because without it,
      there is no known method to write a database creation script that can create
      a trigger without failing, when executed on a database that may or may not
      contain already a trigger of the same name.
      
      Implementing this functionality closes an orthogonality gap between triggers
      and stored procedures / stored functions (which do support the DROP IF
      EXISTS syntax).
      
      In sql_trigger.cc, in mysql_create_or_drop_trigger,
      the code has been reordered to:
      - perform the tests that do not depend on the file system (access()),
      - get the locks (wait_if_global_read_lock, LOCK_open)
      - call access()
      - perform the operation
      - write to the binlog
      - unlock (LOCK_open, start_waiting_global_read_lock)
      
      This is to ensure that all the code that depends on the presence of the
      trigger file is executed in the same critical section,
      and prevents race conditions similar to the case fixed by Bug 14262 :
      
      - thread 1 executes DROP TRIGGER IF EXISTS, access() returns a failure
      - thread 2 executes CREATE TRIGGER
      - thread 2 logs CREATE TRIGGER
      - thread 1 logs DROP TRIGGER IF EXISTS
      
      The patch itself is based on code contributed by the MySQL community,
      under the terms of the Contributor License Agreement (See Bug 18161).
      
      
      mysql-test/r/rpl_trigger.result:
        DROP TRIGGER IF EXISTS
      mysql-test/r/trigger.result:
        DROP TRIGGER IF EXISTS
      mysql-test/t/rpl_trigger.test:
        DROP TRIGGER IF EXISTS
      mysql-test/t/trigger.test:
        DROP TRIGGER IF EXISTS
      sql/sql_trigger.cc:
        DROP TRIGGER IF EXISTS
      sql/sql_yacc.yy:
        DROP TRIGGER IF EXISTS
      541e9c9a
    • unknown's avatar
      several fixes to make tests pass in embedded-server mode · ea1f7e4b
      unknown authored
      libmysqld/lib_sql.cc:
        check for bootstrap added
      mysql-test/include/federated.inc:
        disabled in embedded
      mysql-test/mysql-test-run.pl:
        we disable ssh in embedded server
      mysql-test/r/bdb.result:
        part moved to bdb_notembedded as it uses binlog
      mysql-test/r/flush_block_commit.result:
        part moved to flush_block_commit_notembedded
      mysql-test/r/insert.result:
        part moved to insert_notembedded as delayed works differently in embedded server
      mysql-test/r/insert_select.result:
        part moved to insert_notembedded as GRANTS usually disabled in embedded server
      mysql-test/r/join.result:
        access rights hidden in result
      mysql-test/t/backup.test:
        now available in embedded server
      mysql-test/t/bdb.test:
        part moved to bdb_notembedded as it uses binlog
      mysql-test/t/delayed.test:
        code trimmed
      mysql-test/t/execution_constants.test:
        skipped in embedded-server mode
      mysql-test/t/flush_block_commit.test:
        moved to flush_block_commit_notembedded
      mysql-test/t/information_schema_db.test:
        skipped in embedded-server
      mysql-test/t/innodb.test:
        directories replaced to be embedded-server compliant
      mysql-test/t/insert.test:
        part moved to insert_notembedded
      mysql-test/t/insert_select.test:
        part moved to insert_notembedded
      mysql-test/t/join.test:
        access rights hidden
      mysql-test/t/status.test:
        skipped in embedded server
      mysql-test/t/trigger.test:
        directories replaced to be embedded-server compliant
      sql/item_strfunc.cc:
        extra contexts not needed whan access checks disabled
      sql/share/errmsg.txt:
        bigger paths reserved to prevent test's fails
      mysql-test/r/bdb_notembedded.result:
        ***MISSING WEAVE***
      mysql-test/r/flush_block_commit_notembedded.result:
        added
      mysql-test/r/insert_notembedded.result:
        added
      mysql-test/t/bdb_notembedded.test:
        ***MISSING WEAVE***
      mysql-test/t/flush_block_commit_notembedded.test:
        added
      mysql-test/t/insert_notembedded.test:
        added
      ea1f7e4b
    • unknown's avatar
      Fix for bug bug#23651 "Server crashes when trigger which uses · fc83f787
      unknown authored
      stored function invoked from different connections".
      
      Invocation of trigger which was using stored function from different
      connections caused server crashes (for non-debug server this happened
      in highly concurrent environment, but debug server failed on assertion
      in relatively simple scenario).
      
      Item_func_sp was not safe to use in triggers (in other words for
      re-execution from different threads) as artificial TABLE object
      pointed by Item_func_sp::dummy_table referenced incorrect THD
      object. To fix the problem we force re-initialization of this
      object for each re-execution of statement.
      
      
      mysql-test/r/trigger.result:
        Added test for bug#23651 "Server crashes when trigger which uses
        stored function invoked from different connections".
      mysql-test/t/trigger.test:
        Added test for bug#23651 "Server crashes when trigger which uses
        stored function invoked from different connections".
      sql/item_func.cc:
        To make Item_func_sp safe for usage in triggers (in other words safe
        for re-execution in different threads) we need to ensure that artificial
        TABLE object pointed by Item_func_sp::dummy_table references correct
        THD object. To achieve this we simply force its re-initialization for
        each re-execution of statement.
      fc83f787
  10. 19 Oct, 2006 1 commit
    • unknown's avatar
      Bug#20028 (Function with select return no data) · 5bd58f3e
      unknown authored
      This patch reverts a change introduced by Bug 6951, which incorrectly
      set thd->abort_on_warning for stored procedures.
      
      As per internal discussions about the SQL_MODE=TRADITIONAL,
      the correct behavior is to *not* abort on warnings even inside an INSERT/UPDATE
      trigger.
      
      Tests for Stored Procedures, Stored Functions, Triggers involving SQL_MODE
      have been included or revised, to reflect the intended behavior.
      
      (reposting approved patch, to work around source control issues, no review needed)
      
      
      mysql-test/include/sp-vars.inc:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/r/sp-vars.result:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/r/sp.result:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/r/trigger.result:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/t/sp-vars.test:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/t/sp.test:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/t/trigger.test:
        Tests for SQL_MODE='TRADITIONAL'
      sql/sp_head.cc:
        For SQL_MODE='TRADITIONAL',
        thd->abort_on_warning should be set only when assigning a *column*
      5bd58f3e
  11. 17 Oct, 2006 1 commit
    • unknown's avatar
      Bug#20028 (Function with select return no data) · 81569524
      unknown authored
      This patch reverts a change introduced by Bug 6951, which incorrectly
      set thd->abort_on_warning for stored procedures.
      
      As per internal discussions about the SQL_MODE=TRADITIONAL,
      the correct behavior is to *not* abort on warnings even inside an INSERT/UPDATE
      trigger.
      
      Tests for Stored Procedures, Stored Functions, Triggers involving SQL_MODE
      have been included or revised, to reflect the intended behavior.
      
      
      mysql-test/include/sp-vars.inc:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/r/sp-vars.result:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/r/sp.result:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/r/trigger.result:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/t/sp-vars.test:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/t/sp.test:
        Tests for SQL_MODE='TRADITIONAL'
      mysql-test/t/trigger.test:
        Tests for SQL_MODE='TRADITIONAL'. Revised the expected behavior for triggers
      sql/sp_head.cc:
        For SQL_MODE='TRADITIONAL',
        thd->abort_on_warning should be set only when assigning a *column*
      81569524
  12. 21 Sep, 2006 1 commit
    • unknown's avatar
      Fix for bug#20670 "UPDATE using key and invoking trigger that modifies · 0e4dd85d
      unknown authored
      this key does not stop" (version for 5.0 only).
      
      UPDATE statement which WHERE clause used key and which invoked trigger
      that modified field in this key worked indefinetely.
      
      This problem occured because in cases when UPDATE statement was
      executed in update-on-the-fly mode (in which row is updated right
      during evaluation of select for WHERE clause) the new version of
      the row became visible to select representing WHERE clause and was
      updated again and again.
      We already solve this problem for UPDATE statements which does not
      invoke triggers by detecting the fact that we are going to update
      field in key used for scanning and performing update in two steps,
      during the first step we gather information about the rows to be
      updated and then doing actual updates. We also do this for
      MULTI-UPDATE and in its case we even detect situation when such
      fields are updated in triggers (actually we simply assume that
      we always update fields used in key if we have before update
      trigger).
      
      The fix simply extends this check which is done in check_if_key_used()/
      QUICK_SELECT_I::check_if_keys_used() routine/method in such way that
      it also detects cases when field used in key is updated in trigger.
      As nice side-effect we have more precise and thus more optimal
      perfomance-wise check for the MULTI-UPDATE.
      Also check_if_key_used()/QUICK_SELECT_I::check_if_keys_used() were
      renamed to is_key_used()/QUICK_SELECT_I::is_keys_used() in order to
      better reflect that boolean predicate.
      
      Note that this check is implemented in much more elegant way in 5.1 
      
      
      mysql-test/r/trigger.result:
        Added test case for bug#20670 "UPDATE using key and invoking trigger that
        modifies this key does not stop".
      mysql-test/t/trigger.test:
        Added test case for bug#20670 "UPDATE using key and invoking trigger that
        modifies this key does not stop".
      sql/key.cc:
        Renamed check_if_key_used() to is_key_used(). Also this routine checks if
        key uses field which can be updated by before update trigger defined on the
        table. As result we avoid using update-on-the-fly method in cases when trigger
        updates part of key which is used by select which filters rows to be updated
        and thus avoid infinite updates. By doing such check here we cover both UPDATE
        and MULTI-UPDATE cases.
      sql/mysql_priv.h:
        Renamed check_if_key_used() to is_key_used().
      sql/opt_range.cc:
        Renamed check_if_key_used()/QUICK_SELECT_I::check_if_keys_used() to
        is_key_used()/QUICK_SELECT_I::is_keys_used().
      sql/opt_range.h:
        Renamed QUICK_SELECT_I::check_if_keys_used() method to is_keys_used(),
        also updated comment describing it to reflect its extended semantics
        (this change was caused by change in check_if_key_used()/is_key_used()
         routine semantics).
      sql/sql_trigger.cc:
        Introduced Table_triggers_list::is_updated_in_before_update_triggers()
        method which is needed for checking if field of subject table can be
        changed in before update trigger.
      sql/sql_trigger.h:
        Table_triggers_list:
          Removed has_before_update_triggers() method which is not used any longer.
          Added declaration of is_updated_in_before_update_triggers() which is
          needed for checking if field of subject table can be changed by before
          update trigger.
      sql/sql_update.cc:
        safe_update_on_fly():
          check_if_key_used() routine and check_if_keys_used() method were
          renamed to is_key_used()/is_keys_used(). 
          Now cases when trigger updates fields which are part of key used for
          filtering rows for update are caught directly in is_key_used().
          This also allows to cover both UPDATE and MULTI-UPDATE cases.
      0e4dd85d
  13. 25 Aug, 2006 1 commit
    • unknown's avatar
      Fix for bug#21795: SP: sp_head::is_not_allowed_in_function() contains · 133d2aa5
      unknown authored
      erroneous check
      
      Problem: Actually there were two problems in the server code. The check
      for SQLCOM_FLUSH in SF/Triggers were not according to the existing
      architecture which uses sp_get_flags_for_command() from sp_head.cc .
      This function was also missing a check for SQLCOM_FLUSH which has a
      problem combined with prelocking. This changeset fixes both of these
      deficiencies as well as the erroneous check in
      sp_head::is_not_allowed_in_function() which was a copy&paste error.
      
      
      mysql-test/r/sp-error.result:
        update result
      mysql-test/r/trigger.result:
        update result
      mysql-test/t/sp-error.test:
        FLUSH can create a problem with prelocking, hence it's disabled.
        There is a better way to check this than a check in the parser.
        Now we use sp_get_flags_for_command() and the error returned is
        different.
      mysql-test/t/trigger.test:
        FLUSH can create a problem with prelocking, hence it's disabled.
        There is a better way to check this than a check in the parser.
        Now we use sp_get_flags_for_command() and the error returned is
        different.
      sql/sp_head.cc:
        FLUSH and RESET are not allowed inside a SF/Trigger.
        Because they don't imply a COMMIT sp_head::HAS_COMMIT_OR_ROLLBACK
        cannot be used. Two new flags were introduced for that reason.
      sql/sp_head.h:
        Don't check m_type as this check is erroneous. This is probably
        a copy and paste error when moving code from somewhere else. Another
        fact which supports this was prefixing the enum value with the name
        of class sp_head.
        
        Adding two new flags HAS_SQLCOM_RESET and HAS_SQLCOM_FLUSH. The values
        are 2048 and 4096 because in the 5.1 branch there are already new flags
        which are with values up-to 1024.
      sql/sql_parse.cc:
        FLUSH can cause a problem with prelocking in SF/Trigger and
        therefore is already disabled. RESET is also disabled because
        is handled by the same code as FLUSH. We won't allow RESET inside
        SF/Trigger at that stage without thorough analysis. The check for
        them is already done in the parser by calling
        is_not_allowed_in_function()
      sql/sql_yacc.yy:
        By listing SQLCOM_FLUSH as command which implies COMMIT
        in sp_get_flags_for_command() the check in sql_yacc.yy is
        obsolete.
      133d2aa5
  14. 24 Aug, 2006 1 commit
    • unknown's avatar
      Fix for BUG#16899: Possible buffer overflow in handling of DEFINER-clause · 21e6836b
      unknown authored
          
      User name (host name) has limit on length. The server code relies on these
      limits when storing the names. The problem was that sometimes these limits
      were not checked properly, so that could lead to buffer overflow.
        
      The fix is to check length of user/host name in parser and if string is too
      long, throw an error.
      
      
      mysql-test/r/grant.result:
        Updated result file.
      mysql-test/r/sp.result:
        Updated result file.
      mysql-test/r/trigger.result:
        Updated result file.
      mysql-test/r/view.result:
        Updated result file.
      mysql-test/t/grant.test:
        Added test for BUG#16899.
      mysql-test/t/sp.test:
        Added test for BUG#16899.
      mysql-test/t/trigger.test:
        Added test for BUG#16899.
      mysql-test/t/view.test:
        Added test for BUG#16899.
      sql/mysql_priv.h:
        Added prototype for new function.
      sql/sql_acl.cc:
        Remove outdated checks.
      sql/sql_parse.cc:
        Add a new function for checking string length.
      sql/share/errmsg.txt:
        Added new resources.
      sql/sql_yacc.yy:
        Check length of user/host name.
      21e6836b
  15. 23 Aug, 2006 1 commit
    • unknown's avatar
      Fix for BUG#16899: Possible buffer overflow in handling of DEFINER-clause · f96ee72f
      unknown authored
        
      User name (host name) has limit on length. The server code relies on these
      limits when storing the names. The problem was that sometimes these limits
      were not checked properly, so that could lead to buffer overflow.
      
      The fix is to check length of user/host name in parser and if string is too
      long, throw an error.
      
      
      mysql-test/r/grant.result:
        Updated result file.
      mysql-test/r/sp.result:
        Updated result file.
      mysql-test/r/trigger.result:
        Updated result file.
      mysql-test/r/view.result:
        Updated result file.
      mysql-test/t/grant.test:
        Added test for BUG#16899.
      mysql-test/t/sp.test:
        Added test for BUG#16899.
      mysql-test/t/trigger.test:
        Added test for BUG#16899.
      mysql-test/t/view.test:
        Added test for BUG#16899.
      sql/mysql_priv.h:
        Added prototype for new function.
      sql/share/errmsg.txt:
        Added new resources.
      sql/sql_acl.cc:
        Remove outdated checks.
      sql/sql_parse.cc:
        Add a new function for checking string length.
      sql/sql_yacc.yy:
        Check length of user/host name.
      f96ee72f
  16. 29 Jun, 2006 1 commit
    • unknown's avatar
      Replace all numeric error code with symbolic names in trigger.test. · 8c435bdf
      unknown authored
      mysql-test/t/trigger.test:
        Replace all numeric error code with symbolic names.
        Left are --error 1 for system error, and --error 1100.  The
        symbolic constant for the latter is ER_TABLE_NOT_LOCKED, but using
        it triggers a bug in test driver due to name prefix collision with
        1099 ER_TABLE_NOT_LOCKED_FOR_WRITE.  This bug is fixed in 5.1.
      8c435bdf
  17. 28 Jun, 2006 2 commits
    • unknown's avatar
      Bug#10946: Confusing error messeges in the case of duplicate trigger definition · 837c9719
      unknown authored
      It was hard to distinguish case, when one was unable to create trigger
      on the table because trigger with same action time and event already
      existed for this table, from the case, when one tried to create trigger
      with name which was already occupied by some other trigger, since in
      both these cases we emitted ER_TRG_ALREADY_EXISTS error and message.
      Now we emit ER_NOT_SUPPORTED_YET error with appropriate additional
      message in the first case. There is no sense in introducing separate
      error for this situation since we plan to get rid of this limitation
      eventually.
      
      
      mysql-test/r/trigger.result:
        Update result for new error message.
      mysql-test/t/trigger.test:
        Update test for new error code.
      sql/sql_trigger.cc:
        If there is already a trigger with the same activation time, report an
        "Unsupported yet" error.
      837c9719
    • unknown's avatar
      Bug #18005: Creating a trigger on mysql.event leads to server crash on scheduler startup · 88afd72b
      unknown authored
      Bug #18361: Triggers on mysql.user table cause server crash
      
       Because they do not work, we do not allow creating triggers on tables
       within the 'mysql' schema.
      
       (They may be made to work and re-enabled at some later date, but not
       in 5.0 or 5.1.)
      
      
      mysql-test/r/trigger.result:
        Add new results
      mysql-test/t/trigger.test:
        Add new regression test for creating triggers on system schema
      sql/share/errmsg.txt:
        Add new error message
      sql/sql_trigger.cc:
        Disallow creating triggers on tables in the 'mysql' schema
      88afd72b
  18. 16 Jun, 2006 1 commit
    • unknown's avatar
      Fix for bug#13479 "REPLACE activates UPDATE trigger, not the DELETE and · e08a2b32
      unknown authored
      INSERT triggers".
      
      In cases when REPLACE was internally executed via update and table had
      on update (on delete) triggers defined we exposed the fact that such
      optimization used by callng on update (not calling on delete) triggers.
      Such behavior contradicts our documentation which describes REPLACE as
      INSERT with optional DELETE.
      
      This fix just disables this optimization for tables with on delete triggers.
      The optimization is still applied for tables which have on update but have
      no on delete triggers, we just don't invoke on update triggers in this case
      and thus don't expose information about optimization to user.
      
      Also added test coverage for values returned by ROW_COUNT() function (and
      thus for values returned by mysql_affected_rows()) for various forms of
      INSERT.
      
      
      mysql-test/r/insert.result:
        Added test for values returned by ROW_COUNT() function (and thus for values
        returned by mysql_affected_rows()) for various forms of INSERT. We didn't
        have coverage for this before and since this fix touches related code it is
        better to add it now.
      mysql-test/r/trigger.result:
        Adjusted test after fixing bug#13479 "REPLACE activates UPDATE trigger, not
        the DELETE and INSERT triggers".
      mysql-test/t/insert.test:
        Added test for values returned by ROW_COUNT() function (and thus for values
        returned by mysql_affected_rows()) for various forms of INSERT. We didn't
        have coverage for this before and since this fix touches related code it is
        better to add it now.
      mysql-test/t/trigger.test:
        Adjusted test after fixing bug#13479 "REPLACE activates UPDATE trigger, not
        the DELETE and INSERT triggers".
      sql/sql_insert.cc:
        write_record():
          We should not expose that internally we sometimes execute REPLACE
          via UPDATE instead of documented INSERT + DELETE pair. So we should not
          use this optimization for tables with on delete triggers. OTOH it is ok
          to use it for tables which have on update but have no on delete triggers,
          we just should not invoke on update triggers in this case.
      e08a2b32
  19. 12 May, 2006 1 commit
    • unknown's avatar
      Bug#14635: Accept NEW.x as INOUT parameters to stored procedures · afe2520e
      unknown authored
      from within triggers
      
      Add support for passing NEW.x as INOUT and OUT parameters to stored
      procedures.  Passing NEW.x as INOUT parameter requires SELECT and
      UPDATE privileges on that column, and passing it as OUT parameter
      requires only UPDATE privilege.
      
      
      mysql-test/r/sp-error.result:
        Update the result for new message.
      mysql-test/r/trigger-grant.result:
        Add result for bug#14635.
      mysql-test/r/trigger.result:
        Add result for bug#14635.
      mysql-test/t/trigger-grant.test:
        Add test case for bug#14635.
      mysql-test/t/trigger.test:
        Add test case for bug#14635.
      sql/item.cc:
        Add implementations of set_value() and set_required_privilege() methods
        of Settable_routine_parameter interface.
        
        Use Item_trigger_field::want_privilege instead of
        Item_trigger_field::access_type.
        
        Reset privileges on Item_trigger_field::cleanup().
      sql/item.h:
        Add interface class Settable_routine_parameter and interface query
        method to Item class.  Item_splocal and Item_trigger_field implement
        this interface.
        
        For Item_trigger_field:
         - add read_only attribute and is_read_only() method.
         - remove access_type and add original_privilege and want_privilege
           instead.
         - add set_value() method.
         - add reset_privilege() method.
      sql/item_func.cc:
        Add implementations of set_value() method of Settable_routine_parameter
        interface.
      sql/item_func.h:
        Item_func_get_user_var implements Settable_routine_parameter interface.
      sql/share/errmsg.txt:
        Update english ER_SP_NOT_VAR_ARG message.
      sql/sp_head.cc:
        Use Settable_routine_parameter interface for parameter update.
      sql/sql_yacc.yy:
        Set read_only and want_privilege members in Item_trigger_field
        appropriately.  For NEW.x trigger variable used in left-hand-side
        of SET statement the latter is set to UPDATE_ACL, otherwise it is
        set to SELECT_ACL (but see Item_trigger_field::set_required_privilege(),
        where it may be updated to different value).
      afe2520e
  20. 10 May, 2006 1 commit
  21. 19 Apr, 2006 2 commits
  22. 18 Apr, 2006 1 commit
    • unknown's avatar
      Cleanup test cases that leaves "stuff" behind · f909f996
      unknown authored
      mysql-test/r/ctype_latin2_ch.result:
        Drot table at end of test
      mysql-test/r/grant2.result:
        Drop users
      mysql-test/r/openssl_1.result:
        Drop users
      mysql-test/r/rpl_openssl.result:
        Drop users
      mysql-test/r/sp-security.result:
        Drop users
      mysql-test/r/sp_notembedded.result:
        Drop table
      mysql-test/r/trigger.result:
        Drop table
      mysql-test/t/ctype_latin2_ch.test:
        Drop table
      mysql-test/t/grant2.test:
        Drop users
      mysql-test/t/openssl_1.test:
        Drop users
      mysql-test/t/rpl_openssl.test:
        Drop users
      mysql-test/t/sp-security.test:
        Drop users
      mysql-test/t/sp_notembedded.test:
        Drop table
      mysql-test/t/trigger.test:
        Drop table
      f909f996
  23. 12 Apr, 2006 1 commit
    • unknown's avatar
      Bug#16461: connection_id() does not work properly inside trigger · 886a35bd
      unknown authored
      CONNECTION_ID() was implemented as a constant Item, i.e. an instance of
      Item_static_int_func class holding value computed at creation time.
      Since Items are created on parsing, and trigger statements are parsed
      on table open, the first connection to open a particular table would
      effectively set its own CONNECTION_ID() inside trigger statements for
      that table.
      
      Re-implement CONNECTION_ID() as a class derived from Item_int_func, and
      compute connection_id on every call to fix_fields().
      
      
      mysql-test/r/trigger.result:
        Add result for bug#16461.
      mysql-test/t/trigger.test:
        Add test case for bug#16461.
      sql/item.cc:
        Remove now unused class Item_static_int_func.
      sql/item.h:
        Remove now unused class Item_static_int_func.
      sql/item_create.cc:
        Use new implementation of CONNECTION_ID().
      sql/item_func.cc:
        Re-implement CONNECTION_ID() as Item_func_connection_id
        (was Item_static_int_func).  Set max_length to 10, as it was before.
        Compute connection_id dynamically on every call to fix_fields().
      sql/item_func.h:
        Re-implement CONNECTION_ID() as Item_func_connection_id
        (was Item_static_int_func).
      886a35bd
  24. 29 Mar, 2006 1 commit
    • unknown's avatar
      Proposed fix for bug #17764 "Trigger crashes MyISAM table" · 1d166b17
      unknown authored
      A table with an on insert trigger was reported as crashed when the insert
      was processed with bulk insert mode on (handler::start_bulk_insert).
      The trigger was also selecting from the same table, and that caused
      the "crash".
      The same problem was present when an insert statement, which was processed
      in bulk mode, also used a stored function that was reading the same table.
      
      This fix disables bulk inserts if a statement uses functions or invokes
      triggers. Implementing more granular checks will require much more code and
      therefore can hardly be done in 5.0
      
      
      mysql-test/r/trigger.result:
        Added test bug #17764 "Trigger crashes MyISAM table".
      mysql-test/t/trigger.test:
        Added test bug #17764 "Trigger crashes MyISAM table".
      sql/sql_insert.cc:
        We should not start bulk inserts for INSERT (or similar) statement if it uses
        functions or invokes triggers since they may access to the same table and
        therefore should not see its inconsistent state created by this optimization.
      sql/sql_load.cc:
        We should not start bulk inserts for INSERT (or similar) statement if it uses
        functions or invokes triggers since they may access to the same table and
        therefore should not see its inconsistent state created by this optimization.
      1d166b17
  25. 24 Mar, 2006 1 commit
    • unknown's avatar
      Fix for bug #18153 "ALTER/OPTIMIZE/REPAIR on transactional tables corrupt · a389ec0b
      unknown authored
      triggers".
      
      Applying ALTER/OPTIMIZE/REPAIR TABLE statements to transactional table or to
      table of any type on Windows caused disappearance of its triggers.
      Bug was introduced in 5.0.19 by my fix for bug #13525 "Rename table does not
      keep info of triggers" (see comment for sql_table.cc for more info).
      .
      
      
      mysql-test/r/trigger.result:
        Added test-case covering handling of triggers when one does ALTER TABLE which
        should move table to different database.
      mysql-test/t/trigger.test:
        Added test-case covering handling of triggers when one does ALTER TABLE which
        should move table to different database.
      sql/sql_table.cc:
        mysql_alter_table():
          Removal of strdup() which is no longer necessary allows us to preserve
          nice assumption that "(new_db != db || new_table != table_name) indicates
          that table will be renamed. So now we really can use this condition to
          avoid updating trigger definitions when table is not renamed.
          Note that we can't use (alter_info->flags & ALTER_RENAME) condition instead
          since it can be also true when we do "ALTER TABLE t1 RENAME TO t1".
      sql/sql_trigger.cc:
        Table_triggers_list::change_table_name():
          Mentioned assumption that subject table is not renamed to itself in method
          description. Added DBUG_ASSERT() to catch wrong usage of this method.
      mysql-test/r/trigger-trans.result:
        New BitKeeper file ``mysql-test/r/trigger-trans.result''
      mysql-test/t/trigger-trans.test:
        New BitKeeper file ``mysql-test/t/trigger-trans.test''
      a389ec0b
  26. 04 Mar, 2006 1 commit
    • unknown's avatar
      Fix for bug #17866 "Problem with renaming table with triggers with fully · 350475fa
      unknown authored
      qualified subject table" which was introduced during work on bug #13525
      "Rename table does not keep info of triggers".
      
      The bug was caused by the fact that during reconstruction of CREATE TRIGGER
      statement stored in .TRG file which happened during RENAME TABLE we damaged
      trigger definition in case when it contained fully qualified name of subject
      table (see comment for sql_yacc.yy for more info).
      
      
      mysql-test/r/trigger.result:
        Added test for bug #17866 "Problem with renaming table with triggers with fully
        qualified subject table".
      mysql-test/t/trigger.test:
        Added test for bug #17866 "Problem with renaming table with triggers with fully
        qualified subject table".
      sql/sql_trigger.cc:
        Table_triggers_list::change_table_name_in_triggers():
          Instead of trying to use pointer to the end of subject table identifier
          we use pointer to the beginning of FOR lexeme now, so during reconstruction
          of CREATE TRIGGER statement in this function we need to add extra space
          before part which begins with FOR to get nice trigger definition.
      sql/sql_yacc.yy:
        trigger_tail:
          In this rule we can't rely on using remember_end token after table_ident token,
          since value returned depends on whether table name is fully qualified or not.
          So instead of trying to get pointer to the end of table identifier we use
          pointer to the beginning of FOR lexeme.
      350475fa
  27. 27 Feb, 2006 1 commit
    • unknown's avatar
      Fix for trigger.test failures on pushbuild hosts introduced by fix for · 2efabfd1
      unknown authored
      bug #13525 "Rename table does not keep info of triggers".
      
      Now we use MYSQLTEST_VARDIR in order to be able to run this test in different
      vardir. Also improved cleanup after the test.
      
      
      mysql-test/t/trigger.test:
        Now we use MYSQLTEST_VARDIR in order to be able to run this test in different
        vardir. Also improved cleanup after the test.
      2efabfd1
  28. 24 Feb, 2006 1 commit
    • unknown's avatar
      Fix for bug #13525 "Rename table does not keep info of triggers". · f8386dfa
      unknown authored
      Let us transfer triggers associated with table when we rename it (but only if
      we are not changing database to which table belongs, in the latter case we will
      emit error).
      
      
      mysql-test/r/trigger.result:
        Added test for bug #13525 "Rename table does not keep info of triggers".
      mysql-test/t/trigger.test:
        Added test for bug #13525 "Rename table does not keep info of triggers".
      sql/sql_rename.cc:
        rename_tables():
          Now after renaming table's .FRM file and updating handler data we call
          Table_triggers_list::change_table_name() which is reponsible for
          updating .TRG and .TRN files.
      sql/sql_table.cc:
        mysql_alter_table():
          Now in case when ALTER should rename table we call
          Table_triggers_list::change_table_name() which is responsible
          for updating .TRG and .TRN files after renaming table.
      sql/sql_trigger.cc:
        Added Table_triggers_list::change_table_name() method and
        change_table_name_in_triggers()/trignames() methods responsible for updating
        .TRG and .TRN files for table during its renaming.
        
        Two small cleanups - removed versioning for .TRG files (since it was not working
        before anyway) and emphasized that type of lock specified in tables list is
        unimportant for DROP TABLE (since this statement uses name-locking).
      sql/sql_trigger.h:
        Table_triggers_list:
          Added on_table_names_list member to store pointers and lenghts of
          "ON table_name" parts in triggers' definitions to be able easily
          change them during RENAME TABLE.
          Added change_table_name() method and change_table_name_in_trignames/triggers()
          helper methods responsible for updating .TRG and .TRN files.
      sql/sql_yacc.yy:
        trigger_tail:
          To be able properly update triggers' definitions with new table names
          when renaming tables we need to know where in CREATE TRIGGER statement
          "ON db_name.table_name" part resides.
          Small cleanup - let us emphasize that for CREATE TRIGGER statement 
          lock type which is specified in table list is unimportant since
          name-locking is used.
      f8386dfa
  29. 28 Jan, 2006 1 commit
    • unknown's avatar
      Fix for bug #16829 "Firing trigger with RETURN crashes the server" · a1b67ce2
      unknown authored
      We should disallow usage of RETURN statement in triggers and emit
      error at parsing time (instead of crashing when trigger is fired).
      
      
      mysql-test/r/trigger.result:
        Added test for bug #16829 "Firing trigger with RETURN crashes the server".
      mysql-test/t/trigger.test:
        Added test for bug #16829 "Firing trigger with RETURN crashes the server".
      sql/sql_yacc.yy:
        We should disallow usage of RETURN statement in triggers and emit
        error at parsing time (instead of crashing when trigger is fired).
      a1b67ce2
  30. 24 Jan, 2006 1 commit
    • unknown's avatar
      Make it possible to run mysql-test-run.pl with default test suite in different vardir. · d40f7056
      unknown authored
      mysql-test/include/have_outfile.inc:
        Use MYSQLTEST_VARDIR
      mysql-test/include/test_outfile.inc:
        Use MYSQLTEST_VARDIR
      mysql-test/mysql-test-run.pl:
        Create variable $MYSQLTEST_VARDIR that points to  the vardir
        Don't create a symlink from var/ to the physical vardir if it's somewhere else
        Setup a symlink(or copy dir on windows) for std_data so it is available in the physical vardir
        Use "../tmp" as slave-load-tmpdir, since the server is started in var/master-data and slave in var/slave-data they will both find the dumps in "../tmp"
      mysql-test/mysql-test-run.sh:
        Export MYSQLTEST_VARDIR, always pointing at mysql-test/var
      mysql-test/r/backup.result:
        Use MYSQLTEST_VARDIR
      mysql-test/r/blackhole.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/loaddata.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/mysqlbinlog.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/mysqltest.result:
        Use MYSQLTEST_VARDIR
      mysql-test/r/outfile.result:
        Use MYSQLTEST_VARDIR
      mysql-test/r/query_cache.result:
        Add missing drop function
      mysql-test/r/rpl000001.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl000004.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_innodb.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_loaddata.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_loaddata_rule_m.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_loaddata_rule_s.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_loaddatalocal.result:
        Use MYSQLTEST_VARDIR
      mysql-test/r/rpl_log.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_misc_functions.result:
        Use MYSQLTEST_VARDIR
      mysql-test/r/rpl_replicate_do.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_rewrite_db.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/rpl_timezone.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/symlink.result:
        Use MYSQLTEST_VARDIR
      mysql-test/r/trigger.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/view.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/r/warnings.result:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/backup-master.sh:
        Use MYSQLTEST_VARDIR
      mysql-test/t/backup.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/blackhole.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/ctype_ucs_binlog.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/im_daemon_life_cycle-im.opt:
        Use MYSQLTEST_VARDIR
      mysql-test/t/im_options_set.imtest:
        Use MYSQLTEST_VARDIR
      mysql-test/t/im_options_unset.imtest:
        Use MYSQLTEST_VARDIR
      mysql-test/t/loaddata.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/myisam.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/mysqlbinlog.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/mysqlbinlog2.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/mysqldump.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/mysqltest.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/ndb_autodiscover.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/outfile.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/query_cache.test:
        Add missing drop function
      mysql-test/t/repair.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl000001.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl000004.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl000009.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl000015-slave.sh:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl000017-slave.sh:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_EE_error.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_charset.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_drop_db.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_flush_log_loop-master.opt:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_flush_log_loop-master.sh:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_flush_log_loop-slave.opt:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_flush_log_loop-slave.sh:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_innodb.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl_loaddata.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl_loaddata_rule_m.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl_loaddata_rule_s.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl_loaddatalocal.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_log.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl_misc_functions-slave.sh:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_misc_functions.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_replicate_do.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl_rewrite_db.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/rpl_rotate_logs-slave.sh:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_rotate_logs.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/rpl_timezone.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/show_check.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/sp-destruct.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/symlink.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/temp_table-master.opt:
        Use MYSQLTEST_VARDIR
      mysql-test/t/trigger-compat.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/trigger-grant.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/trigger.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/type_varchar.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/user_var-binlog.test:
        Use MYSQLTEST_VARDIR
      mysql-test/t/view.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/t/warnings.test:
        Use "../std_data_ln" to find std_data files
      mysql-test/include/sourced.inc:
        New BitKeeper file ``mysql-test/include/sourced.inc''
      mysql-test/include/sourced1.inc:
        New BitKeeper file ``mysql-test/include/sourced1.inc''
      d40f7056
  31. 05 Jan, 2006 1 commit
    • unknown's avatar
      Review fixes of new pushed code · 64206b18
      unknown authored
      - Fixed tests
      - Optimized new code
      - Fixed some unlikely core dumps
      - Better bug fixes for:
        - #14397 - OPTIMIZE TABLE with an open HANDLER causes a crash
        - #14850 (ERROR 1062 when a quering a view using a Group By on a column that can be null
      
      
      mysql-test/r/create.result:
        Update results after removing wrong warnings for CREATE ... SELECT
        New tests
      mysql-test/r/handler.result:
        Drop used tables
      mysql-test/r/kill.result:
        Make test portable
      mysql-test/r/mysqlshow.result:
        Drop tables used by previous test
      mysql-test/r/trigger.result:
        Reuse old procedure name
      mysql-test/r/view.result:
        Extra tests
      mysql-test/t/create.test:
        New tests to test fix of removing wrong warnings for CREATE ... SELECT
      mysql-test/t/disabled.def:
        Enable 'kill' test (should now be portable)
      mysql-test/t/handler.test:
        Drop used tables
      mysql-test/t/kill.test:
        Make test portable even if kill doesn't work at once
      mysql-test/t/mysqlshow.test:
        Drop tables used by previous test
      mysql-test/t/trigger.test:
        Reuse old procedure name
      mysql-test/t/view.test:
        Extra tests
      sql/field.cc:
        Removed compiler warning
      sql/ha_federated.cc:
        my_snprintf -> strmake()
        (Simple optimization)
      sql/ha_ndbcluster.cc:
        Indentation cleanups and trival optimization
      sql/item.cc:
        Moved save_org_in_field() to item.cc to make it easier to test
        Remove setting of null_value as this is not needed
      sql/item.h:
        Moved save_org_in_field() to item.cc to make it easier to test
      sql/log_event.cc:
        Remove inline of slave_load_file_stem()
        Added 'extension' parameter to slave_load_file_stem() to get smaller code
        Removed not critical (or needed) DBUG_ASSERT()'s
        Cleaned up usage of slave_load_file_stem() to not depend on constant string lengths
        Indentation fixes
      sql/opt_range.cc:
        Moved code from declaration to function body
        (To make it more readable)
      sql/parse_file.cc:
        Fixed DBUG_PRINT
      sql/sp.cc:
        Simple cleanups
        - Removed not needed {} level
        - Ensure saved variables starts with old_
      sql/sp_head.cc:
        Indentation fixes
        Remove core dump when using --debug when m_next_cached_sp == 0
        Fixed compiler warnings
        Trivial optimizations
      sql/sp_head.h:
        Changed argument to set_definer() to const
        Added THD argument to recursion_level_error() to avoid call to current_thd
      sql/sql_acl.cc:
        Removed not needed test (first_not_own_table is the guard)
      sql/sql_base.cc:
        Removed extra empty line
      sql/sql_handler.cc:
        Don't test table version in mysql_ha_read() as this is already tested in lock_tables()
        Moved call to insert_fields to be after lock_table() to guard aganst reopen of tables
        (Better fix for Bug#14397 - OPTIMIZE TABLE with an open HANDLER causes a crash)
      sql/sql_insert.cc:
        Mark fields that are set in CREATE ... SELECT as used
        (Removed wrong warnings about field not having a default value)
      sql/sql_parse.cc:
        Removed not needed test of 'tables' (first_not_own_table is the guard)
        Simplify code
      sql/sql_select.cc:
        Use group->field to check if value is null instead of item called by 'save_org_in_field'
        This is a better bug fix for #14850 (ERROR 1062 when a quering a view using a Group By on a column that can be null)
      sql/sql_trigger.cc:
        Move sql_modes_parameters outside of function
        Indentation fixes
        Fixed compiler warning
        Ensure that thd->lex->query_tables_own_last is set properly before calling check_table_access()
        (This allows us to remove the extra test in check_grant() and check_table_access())
      64206b18
  32. 11 Dec, 2005 1 commit
    • unknown's avatar
      Fix for bug #14863 "Triggers: crash if create and there is no current database". · 7402f669
      unknown authored
      Now when we create or drop trigger we check that both trigger name and trigger
      table always have database part specified. Thus we give an error if it they
      are not specified explicitly or implicitly via current database.
      
      
      mysql-test/r/trigger.result:
        Added test for bug #14863 "Triggers: crash if create and there is no current
        database".
      mysql-test/t/trigger.test:
        Added test for bug #14863 "Triggers: crash if create and there is no current
        database".
      sql/sql_trigger.cc:
        mysql_create_or_drop_trigger():
          Now we check that both trigger name and trigger table have database
          part specified (explicitly or implicitly via current database. Note
          that in latter case sp_name::m_db is already set by parser).
        Table_triggers_list::create_trigger()/::add_table_for_trigger():
          Simplified method/function's code since now they can assume that
          sp_name::m_db is always filled now.
        trigname_file_parameters:
          Removed comment which is no longer true.
      7402f669
  33. 22 Nov, 2005 2 commits
    • unknown's avatar
      Recursion support made for SP (BUG#10100). · 164ce4c5
      unknown authored
      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.
      164ce4c5
    • unknown's avatar
      Fix for BUG#13549 "Server crash with nested stored procedures · 6574612d
      unknown authored
      if inner routine has more local variables than outer one, and
      one of its last variables was used as argument to NOT operator".
      
      THD::spcont was non-0 when we were parsing stored routine/trigger
      definition during execution of another stored routine. This confused
      methods of Item_splocal and forced them use wrong runtime context.
      Fix ensures that we always have THD::spcont equal to zero during
      routine/trigger body parsing. This also allows to avoid problems
      with errors which occur during parsing and SQL exception handlers.
      
      
      mysql-test/r/sp.result:
        Test suite for bug#13549.
      mysql-test/r/trigger.result:
        Test suite for bug#13549.
      mysql-test/t/sp.test:
        Test suite for bug#13549.
      mysql-test/t/trigger.test:
        Test suite for bug#13549.
      sql/item.cc:
        Protection against using wrong context by SP local variable.
      sql/item.h:
        Protection against using wrong context by SP local variable.
      sql/protocol.cc:
        An incorrect macro name fixed.
      sql/protocol.h:
        An incorrect macro name fixed.
      sql/sp.cc:
        Do not allow SP which we are parsing to use other SP
        context (BUG#13549).
      sql/sp_head.cc:
        Protection against using wrong context by SP local variable.
      sql/sp_rcontext.h:
        Protection against using wrong context by SP local variable.
      sql/sql_cache.h:
        An incorrect macro name fixed.
      sql/sql_class.cc:
        Protection against using wrong context by SP local variable.
      sql/sql_class.h:
        Protection against using wrong context by SP local variable.
      sql/sql_trigger.cc:
        Do not allow Trigger which we are parsing to use
        other SP context (BUG#13549).
      sql/sql_yacc.yy:
        Protection against using wrong context by SP local variable.
      6574612d