An error occurred fetching the project authors.
  1. 24 May, 2005 1 commit
    • unknown's avatar
      Fix for bugs: · 1fa7c69d
      unknown authored
       #5860 "Multi-table UPDATE does not activate update triggers"
       #6812 "Triggers are not activated for INSERT ... SELECT"
       #8755 "Trigger is not activated by LOAD DATA".
      This patch also implements proper handling of triggers for special forms
      of insert like REPLACE or INSERT ... ON DUPLICATE KEY UPDATE. 
      Also now we don't call after trigger in case when we have failed to
      inserted/update or delete row. Trigger failure should stop statement
      execution.
      
      I have not properly tested handling of errors which happen inside of
      triggers in this patch, since it is simplier to do this once we will be
      able to access tables from triggers.
      
      
      mysql-test/r/trigger.result:
        Added tests for triggers behavior for various non-standard forms of
        INSERT such as REPLACE and INSERT ... ON DUPLICATE KEY UPDATE.
        Also added tests for bugs #5860 "Multi-table UPDATE does not activate
        update triggers", #6812 "Triggers are not activated for INSERT ... SELECT"
        and #8755 "Trigger is not activated by LOAD DATA".
      mysql-test/t/trigger.test:
        Added tests for triggers behavior for various non-standard forms of
        INSERT such as REPLACE and INSERT ... ON DUPLICATE KEY UPDATE.
        Also added tests for bugs #5860 "Multi-table UPDATE does not activate
        update triggers", #6812 "Triggers are not activated for INSERT ... SELECT"
        and #8755 "Trigger is not activated by LOAD DATA".
      sql/item.cc:
        Since it turned out that at trigger loading time we can't say in which
        buffer TABLE::record[0] or record[1] old version of row will be stored
        we have to change our approach to binding of Item_trigger_field to
        Field instances.
        Now after trigger parsing (in Item_trigger_field::setup_table()) we only
        find index of proper Field in the TABLE::field array. Then before trigger
        is invoked we set Table_triggers_list::old_field/new_field so they point
        to arrays holding Field instances bound to buffers with proper row
        versions. And as last step in Item_trigger_field::fix_fields() we get
        pointer to Field from those arrays using saved field index.
        
        Item_trigger_field::setup_field()/fix_fields() were changed to implement
        this approach.
      sql/item.h:
        Since it turned out that at trigger loading time we can't say in which
        buffer TABLE::record[0] or record[1] old version of row will be stored
        we have to change our approach to binding of Item_trigger_field to
        Field instances.
        Now after trigger parsing (in Item_trigger_field::setup_table()) we only
        find index of proper Field in the TABLE::field array. Then before trigger
        is invoked we set Table_triggers_list::old_field/new_field so they point
        to arrays holding Field instances bound to buffers with proper row
        versions. And as last step in Item_trigger_field::fix_fields() we get
        pointer to Field from those arrays using saved field index.
        
        Item_trigger_field:
        - Added field_idx member to store index of Field object corresponding to
          this Item in TABLE::field array.
        - Added triggers member to be able to access to parent Table_trigger_list
          object from fix_fields() method.
        - setup_field() no longer needs to know for which type of event this
          trigger is, since it does not make decision Field for which buffer
          (record[0] or record[1] is appropriate for this Item_trigger_field)
      sql/mysql_priv.h:
        Added fill_record_n_invoke_before_triggers() methods. They are simple
        wrappers around fill_record() which invoke proper before trigger right
        after filling record with values.
      sql/sql_base.cc:
        Added fill_record_n_invoke_before_triggers() methods. They are simple
        wrappers around fill_record() which invoke proper before trigger right
        after filling record with values.
      sql/sql_delete.cc:
        mysql_delete():
          Now we stop statement execution if one of triggers failed, we also
          don't execute after delete trigger if we failed to delete row from
          the table (We also pass information about which buffer contains old
          version of row to process_triggers()).
        multi_delete::send_data()/do_deletes():
          Now we also invoke triggers in case of multi-delete.
      sql/sql_insert.cc:
        mysql_insert():
          Moved invocation of before triggers to fill_record_n_invoke_before_triggers()
          method. After triggers are now executed as part of write_record().
          (as nice side effect now we also stop statement execution if one of
          triggers fail).
        write_record():
          Invoke after insert trigger after performing insert. Also invoke proper
          triggers if insert is converted to update or conflicting row is deleted.
          Cleaned up error handling a bit - no sense to report error via
          handler::print_error if it was not generated by handler method and
          was reported before.
          Also now we will execute after trigger only if we really have written
          row to the table. 
        select_insert::send_data()/store_values():
          We should also execute INSERT triggers for INSERT ... SELECT statement.
      sql/sql_load.cc:
        read_fixed_length()/read_sep_field():
          We should execute INSERT triggers when processing LOAD DATA statement.
          Small cleanup in auto-increment related code. Also moved check for
          thd->killed which is used to abort LOAD DATA in case of problems
          in 'traditional' mode to better place..
      sql/sql_trigger.cc:
        Since it turned out that at trigger loading time we can't say in which
        buffer TABLE::record[0] or record[1] old version of row will be stored
        we have to change our approach to binding of Item_trigger_field to
        Field instances.
        Now after trigger parsing (in Item_trigger_field::setup_table()) we only
        find index of proper Field in the TABLE::field array. Then before trigger
        is invoked we set Table_triggers_list::old_field/new_field so they point
        to arrays holding Field instances bound to buffers with proper row
        versions. And as last step in Item_trigger_field::fix_fields() we get
        pointer to Field from those arrays using saved field index.
        
        Table_triggers_list methods were changed to implement this approach
        (see also comments for sql_trigger.h).
      sql/sql_trigger.h:
        Since it turned out that at trigger loading time we can't say in which
        buffer TABLE::record[0] or record[1] old version of row will be stored
        we have to change our approach to binding of Item_trigger_field to
        Field instances.
        Now after trigger parsing (in Item_trigger_field::setup_table()) we only
        find index of proper Field in the TABLE::field array. Then before trigger
        is invoked we set Table_triggers_list::old_field/new_field so they point
        to arrays holding Field instances bound to buffers with proper row
        versions. And as last step in Item_trigger_field::fix_fields() we get
        pointer to Field from those arrays using saved field index.
        
        Changed Table_triggers_list to implement this new approach:
        - Added record1_field member to store array of Field objects bound
          to TABLE::record[1] buffer (instead of existing old_field member)
        - Added new_field member and changed meaning of old_field member.
          During trigger execution they should point to arrays of Field objects
          bound to buffers holding new and old versions of row respectively.
        - Added 'table' member to be able to get access to TABLE instance
          (for which this trigger list object was created) from process_triggers()
          method.
        - Now process_triggers() method sets old_field and new_field members
          properly before executing triggers body (basing on new 
          old_row_is_record1 parameter value).
        - Renamed prepare_old_row_accessors_method() to prepare_record1_accessors()
        
        Also added has_before_update_triggers() method which allows to check
        whenever any before update triggers exist for table.
      sql/sql_update.cc:
        mysql_update():
          Now we invoke before triggers in fill_record_n_invoke_before_triggers()
          method. Also now we abort statement execution when one of triggers fail.
        safe_update_on_fly():
          When we are trying to understand if we can update first table in multi
          update on the fly we should take into account that BEFORE UPDATE
          trigger can change field values.
        multi_update::send_data()/do_updates()
          We should execute proper triggers when doing multi-update
          (in both cases when we do it on the fly and using temporary tables).
      1fa7c69d
  2. 10 May, 2005 1 commit
  3. 06 May, 2005 1 commit
    • unknown's avatar
      Dmitri please review. Fix for BUG#10417 "CREATE TRIGGER not written to binlog": · 6f83de16
      unknown authored
      writing DROP and CREATE TRIGGER to binlog, disabling binlogging
      of substatements, testing.
      
      
      mysql-test/r/rpl_sp.result:
        result update
      mysql-test/t/rpl_sp.test:
        removing useless lines, plus testing replication of triggers
      sql/sql_trigger.cc:
        trigger can be used to destroy slave, so only SUPER can create it by default.
        If create|drop goes ok, binlog CREATE TRIGGER and DROP TRIGGER.
      sql/sql_trigger.h:
        disable binlogging of substatements of triggers (even if now triggers
        can't do updates)
      6f83de16
  4. 04 Mar, 2005 1 commit
    • unknown's avatar
      Better approach for prelocking of tables for stored routines execution · ac9f68b9
      unknown authored
      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.
      ac9f68b9
  5. 24 Nov, 2004 1 commit
    • unknown's avatar
      Fix for bug #5888 "Triggers with nonexistent columns cause packets · c3da2d12
      unknown authored
      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.
      c3da2d12
  6. 12 Nov, 2004 1 commit
    • unknown's avatar
      Fix for bug #5890 "Triggers fail for DELETE without WHERE". · bb43e831
      unknown authored
      If we have DELETE with always true WHERE clause we should not use 
      optimized delete_all_rows() method for tables with DELETE triggers,
      because in this case we will lose side-effect of deletion.
      
      
      mysql-test/r/trigger.result:
        Added test for bug #5890 "Triggers fail for DELETE without WHERE".
      mysql-test/t/trigger.test:
        Added test for bug #5890 "Triggers fail for DELETE without WHERE".
      sql/sql_delete.cc:
        mysql_delete(): 
          We should not use optimized delete_all_rows() method for tables
          with DELETE triggers, because in this case we will lose side-effect
          of deletion.
      sql/sql_trigger.h:
        Added new Table_triggers_list::has_delete_triggers() method which
        allows to understand quickly if we have some DELETE triggers in
        our list.
      bb43e831
  7. 07 Sep, 2004 1 commit
    • unknown's avatar
      WL#1218 "Triggers". Some very preliminary version of patch. · 52ac4935
      unknown authored
      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.
      52ac4935