An error occurred fetching the project authors.
  1. 17 Nov, 2010 1 commit
    • Jon Olav Hauglid's avatar
      Bug #57663 Concurrent statement using stored function and DROP DATABASE · 1e9f239e
      Jon Olav Hauglid authored
                 breaks SBR
      
      The problem was that DROP DATABASE ignored any metadata locks on stored
      functions and procedures held by other connections. This made it
      possible for DROP DATABASE to drop functions/procedures that were in use
      by other connections and therefore break statement based replication.
      (DROP DATABASE could appear in the binlog before a statement using a
      dropped function/procedure.)
      
      This problem was an issue left unresolved by the patch for Bug#30977
      where metadata locks for stored functions/procedures were introduced.
      
      This patch fixes the problem by making sure DROP DATABASE takes
      exclusive metadata locks on all stored functions/procedures to be
      dropped.
      
      Test case added to sp-lock.test.
      1e9f239e
  2. 11 Nov, 2010 1 commit
    • Dmitry Lenev's avatar
      Patch that refactors global read lock implementation and fixes · 6bf6272f
      Dmitry Lenev authored
      bug #57006 "Deadlock between HANDLER and FLUSH TABLES WITH READ
      LOCK" and bug #54673 "It takes too long to get readlock for
      'FLUSH TABLES WITH READ LOCK'".
      
      The first bug manifested itself as a deadlock which occurred
      when a connection, which had some table open through HANDLER
      statement, tried to update some data through DML statement
      while another connection tried to execute FLUSH TABLES WITH
      READ LOCK concurrently.
      
      What happened was that FTWRL in the second connection managed
      to perform first step of GRL acquisition and thus blocked all
      upcoming DML. After that it started to wait for table open
      through HANDLER statement to be flushed. When the first connection
      tried to execute DML it has started to wait for GRL/the second
      connection creating deadlock.
      
      The second bug manifested itself as starvation of FLUSH TABLES
      WITH READ LOCK statements in cases when there was a constant
      stream of concurrent DML statements (in two or more
      connections).
      
      This has happened because requests for protection against GRL
      which were acquired by DML statements were ignoring presence of
      pending GRL and thus the latter was starved.
      
      This patch solves both these problems by re-implementing GRL
      using metadata locks.
      
      Similar to the old implementation acquisition of GRL in new
      implementation is two-step. During the first step we block
      all concurrent DML and DDL statements by acquiring global S
      metadata lock (each DML and DDL statement acquires global IX
      lock for its duration). During the second step we block commits
      by acquiring global S lock in COMMIT namespace (commit code
      acquires global IX lock in this namespace).
      
      Note that unlike in old implementation acquisition of
      protection against GRL in DML and DDL is semi-automatic.
      We assume that any statement which should be blocked by GRL
      will either open and acquires write-lock on tables or acquires
      metadata locks on objects it is going to modify. For any such
      statement global IX metadata lock is automatically acquired
      for its duration.
      
      The first problem is solved because waits for GRL become
      visible to deadlock detector in metadata locking subsystem
      and thus deadlocks like one in the first bug become impossible.
      
      The second problem is solved because global S locks which
      are used for GRL implementation are given preference over
      IX locks which are acquired by concurrent DML (and we can
      switch to fair scheduling in future if needed).
      
      Important change:
      FTWRL/GRL no longer blocks DML and DDL on temporary tables.
      Before this patch behavior was not consistent in this respect:
      in some cases DML/DDL statements on temporary tables were
      blocked while in others they were not. Since the main use cases
      for FTWRL are various forms of backups and temporary tables are
      not preserved during backups we have opted for consistently
      allowing DML/DDL on temporary tables during FTWRL/GRL.
      
      Important change:
      This patch changes thread state names which are used when
      DML/DDL of FTWRL is waiting for global read lock. It is now
      either "Waiting for global read lock" or "Waiting for commit
      lock" depending on the stage on which FTWRL is.
      
      Incompatible change:
      To solve deadlock in events code which was exposed by this
      patch we have to replace LOCK_event_metadata mutex with
      metadata locks on events. As result we have to prohibit
      DDL on events under LOCK TABLES.
      
      This patch also adds extensive test coverage for interaction
      of DML/DDL and FTWRL.
      
      Performance of new and old global read lock implementations
      in sysbench tests were compared. There were no significant
      difference between new and old implementations.
      
      mysql-test/include/check_ftwrl_compatible.inc:
        Added helper script which allows to check that a statement is
        compatible with FLUSH TABLES WITH READ LOCK.
      mysql-test/include/check_ftwrl_incompatible.inc:
        Added helper script which allows to check that a statement is
        incompatible with FLUSH TABLES WITH READ LOCK.
      mysql-test/include/handler.inc:
        Adjusted test case to the fact that now DROP TABLE closes
        open HANDLERs for the table to be dropped before checking
        if there active FTWRL in this connection.
      mysql-test/include/wait_show_condition.inc:
        Fixed small error in the timeout message. The correct name
        of variable used as parameter for this script is "$condition"
        and not "$wait_condition".
      mysql-test/r/delayed.result:
        Added test coverage for scenario which triggered assert in
        metadata locking subsystem.
      mysql-test/r/events_2.result:
        Updated test results after prohibiting event DDL operations
        under LOCK TABLES.
      mysql-test/r/flush.result:
        Added test coverage for bug #57006 "Deadlock between HANDLER
        and FLUSH TABLES WITH READ LOCK".
      mysql-test/r/flush_read_lock.result:
        Added test coverage for various aspects of FLUSH TABLES WITH
        READ LOCK functionality.
      mysql-test/r/flush_read_lock_kill.result:
        Adjusted test case after replacing custom global read lock
        implementation with one based on metadata locks. Use new
        debug_sync point. Do not disable concurrent inserts as now
        InnoDB we always use InnoDB table.
      mysql-test/r/handler_innodb.result:
        Adjusted test case to the fact that now DROP TABLE closes
        open HANDLERs for the table to be dropped before checking
        if there active FTWRL in this connection.
      mysql-test/r/handler_myisam.result:
        Adjusted test case to the fact that now DROP TABLE closes
        open HANDLERs for the table to be dropped before checking
        if there active FTWRL in this connection.
      mysql-test/r/mdl_sync.result:
        Adjusted test case after replacing custom global read lock
        implementation with one based on metadata locks. Replaced
        usage of GRL-specific debug_sync's with appropriate sync
        points in MDL subsystem.
      mysql-test/suite/perfschema/r/dml_setup_instruments.result:
        Updated test results after removing global
        COND_global_read_lock condition variable.
      mysql-test/suite/perfschema/r/func_file_io.result:
        Ensure that this test doesn't affect subsequent tests.
        At the end of its execution enable back P_S instrumentation
        which this test disables at some point.
      mysql-test/suite/perfschema/r/func_mutex.result:
        Ensure that this test doesn't affect subsequent tests.
        At the end of its execution enable back P_S instrumentation
        which this test disables at some point.
      mysql-test/suite/perfschema/r/global_read_lock.result:
        Adjusted test case to take into account that new GRL
        implementation is based on MDL.
      mysql-test/suite/perfschema/r/server_init.result:
        Adjusted test case after replacing custom global read
        lock implementation with one based on MDL and replacing
        LOCK_event_metadata mutex with metadata lock.
      mysql-test/suite/perfschema/t/func_file_io.test:
        Ensure that this test doesn't affect subsequent tests.
        At the end of its execution enable back P_S instrumentation
        which this test disables at some point.
      mysql-test/suite/perfschema/t/func_mutex.test:
        Ensure that this test doesn't affect subsequent tests.
        At the end of its execution enable back P_S instrumentation
        which this test disables at some point.
      mysql-test/suite/perfschema/t/global_read_lock.test:
        Adjusted test case to take into account that new GRL
        implementation is based on MDL.
      mysql-test/suite/perfschema/t/server_init.test:
        Adjusted test case after replacing custom global read
        lock implementation with one based on MDL and replacing
        LOCK_event_metadata mutex with metadata lock.
      mysql-test/suite/rpl/r/rpl_tmp_table_and_DDL.result:
        Updated test results after prohibiting event DDL under
        LOCK TABLES.
      mysql-test/t/delayed.test:
        Added test coverage for scenario which triggered assert in
        metadata locking subsystem.
      mysql-test/t/events_2.test:
        Updated test case after prohibiting event DDL operations
        under LOCK TABLES.
      mysql-test/t/flush.test:
        Added test coverage for bug #57006 "Deadlock between HANDLER
        and FLUSH TABLES WITH READ LOCK".
      mysql-test/t/flush_block_commit.test:
        Adjusted test case after changing thread state name which
        is used when COMMIT waits for FLUSH TABLES WITH READ LOCK
        from "Waiting for release of readlock" to "Waiting for commit
        lock".
      mysql-test/t/flush_block_commit_notembedded.test:
        Adjusted test case after changing thread state name which is
        used when DML waits for FLUSH TABLES WITH READ LOCK. Now we
        use "Waiting for global read lock" in this case.
      mysql-test/t/flush_read_lock.test:
        Added test coverage for various aspects of FLUSH TABLES WITH
        READ LOCK functionality.
      mysql-test/t/flush_read_lock_kill-master.opt:
        We no longer need to use make_global_read_lock_block_commit_loop
        debug tag in this test. Instead we rely on an appropriate
        debug_sync point in MDL code.
      mysql-test/t/flush_read_lock_kill.test:
        Adjusted test case after replacing custom global read lock
        implementation with one based on metadata locks. Use new
        debug_sync point. Do not disable concurrent inserts as now
        InnoDB we always use InnoDB table.
      mysql-test/t/lock_multi.test:
        Adjusted test case after changing thread state names which
        are used when DML or DDL waits for FLUSH TABLES WITH READ
        LOCK to "Waiting for global read lock".
      mysql-test/t/mdl_sync.test:
        Adjusted test case after replacing custom global read lock
        implementation with one based on metadata locks. Replaced
        usage of GRL-specific debug_sync's with appropriate sync
        points in MDL subsystem. Updated thread state names which
        are used when DDL waits for FTWRL.
      mysql-test/t/trigger_notembedded.test:
        Adjusted test case after changing thread state names which
        are used when DML or DDL waits for FLUSH TABLES WITH READ
        LOCK to "Waiting for global read lock".
      sql/event_data_objects.cc:
        Removed Event_queue_element::status/last_executed_changed
        members and Event_queue_element::update_timing_fields()
        method. We no longer use this class for updating mysql.events
        once event is chosen for execution. Accesses to instances of
        this class in scheduler thread require protection by
        Event_queue::LOCK_event_queue mutex and we try to avoid
        updating table while holding this lock.
      sql/event_data_objects.h:
        Removed Event_queue_element::status/last_executed_changed
        members and Event_queue_element::update_timing_fields()
        method. We no longer use this class for updating mysql.events
        once event is chosen for execution. Accesses to instances of
        this class in scheduler thread require protection by
        Event_queue::LOCK_event_queue mutex and we try to avoid
        updating table while holding this lock.
      sql/event_db_repository.cc:
        - Changed Event_db_repository methods to not release all
          metadata locks once they are done updating mysql.events
          table. This allows to keep metadata lock protecting
          against GRL and lock protecting particular event around
          until corresponding DDL statement is written to the binary
          log.
        - Removed logic for conditional update of "status" and
          "last_executed" fields from update_timing_fields_for_event()
          method. In the only case when this method is called now
          "last_executed" is always modified and tracking change
          of "status" is too much hassle.
      sql/event_db_repository.h:
        Removed logic for conditional update of "status" and
        "last_executed" fields from Event_db_repository::
        update_timing_fields_for_event() method.
        In the only case when this method is called now "last_executed"
        is always modified and tracking change of "status" field is
        too much hassle.
      sql/event_queue.cc:
        Changed event scheduler code not to update mysql.events
        table while holding Event_queue::LOCK_event_queue mutex.
        Doing so led to a deadlock with a new GRL implementation.
        This deadlock didn't occur with old implementation due to
        fact that code acquiring protection against GRL ignored
        pending GRL requests (which lead to GRL starvation).
        One of goals of new implementation is to disallow GRL
        starvation and so we have to solve problem with this
        deadlock in a different way.
      sql/events.cc:
        Changed methods of Events class to acquire protection
        against GRL while perfoming DDL statement and keep it
        until statement is written to the binary log.
        Unfortunately this step together with new GRL implementation
        exposed deadlock involving Events::LOCK_event_metadata
        and GRL. To solve it Events::LOCK_event_metadata mutex was
        replaced with a metadata lock on event. As a side-effect
        events DDL has to be prohibited under LOCK TABLES even in
        cases when mysql.events table was explicitly locked for
        write.
      sql/events.h:
        Replaced Events::LOCK_event_metadata mutex with a metadata
        lock on event.
      sql/ha_ndbcluster.cc:
        Updated code after replacing custom global read lock
        implementation with one based on MDL. Since MDL subsystem
        should now be able to detect deadlocks involving metadata
        locks and GRL there is no need for special handling of
        active GRL.
      sql/handler.cc:
        Replaced custom implementation of global read lock with
        one based on metadata locks. Consequently when doing
        commit instead of calling method of Global_read_lock
        class to acquire protection against GRL we simply acquire
        IX in COMMIT namespace.
      sql/lock.cc:
        Replaced custom implementation of global read lock with
        one based on metadata locks. This step allows to expose
        wait for GRL to deadlock detector of MDL subsystem and
        thus succesfully resolve deadlocks similar to one behind
        bug #57006 "Deadlock between HANDLER and FLUSH TABLES
        WITH READ LOCK". It also solves problem with GRL starvation
        described in bug #54673 "It takes too long to get readlock
        for 'FLUSH TABLES WITH READ LOCK'" since metadata locks used
        by GRL give preference to FTWRL statement instead of DML
        statements (if needed in future this can be changed to
        fair scheduling).
        
        Similar to old implementation of acquisition of GRL is
        two-step. During the first step we block all concurrent
        DML and DDL statements by acquiring global S metadata lock
        (each DML and DDL statement acquires global IX lock for
        its duration). During the second step we block commits by
        acquiring global S lock in COMMIT namespace (commit code
        acquires global IX lock in this namespace).
        
        Note that unlike in old implementation acquisition of
        protection against GRL in DML and DDL is semi-automatic.
        We assume that any statement which should be blocked by GRL
        will either open and acquires write-lock on tables or acquires
        metadata locks on objects it is going to modify. For any such
        statement global IX metadata lock is automatically acquired
        for its duration.
        
        To support this change:
        - Global_read_lock::lock/unlock_global_read_lock and
          make_global_read_lock_block_commit methods were changed
          accordingly.
        - Global_read_lock::wait_if_global_read_lock() and
          start_waiting_global_read_lock() methods were dropped.
          It is now responsibility of code acquiring metadata locks
          opening tables to acquire protection against GRL by
          explicitly taking global IX lock with statement duration.
        - Global variables, mutex and condition variable used by
          old implementation was removed.
        - lock_routine_name() was changed to use statement duration for
          its global IX lock. It was also renamed to lock_object_name()
          as it now also used to take metadata locks on events.
        - Global_read_lock::set_explicit_lock_duration() was added which
          allows not to release locks used for GRL when leaving prelocked
          mode.
      sql/lock.h:
        - Renamed lock_routine_name() to lock_object_name() and changed
          its signature to allow its usage for events.
        - Removed broadcast_refresh() function. It is no longer needed
          with new GRL implementation.
      sql/log_event.cc:
        Release metadata locks with statement duration at the end
        of processing legacy event for LOAD DATA. This ensures that
        replication thread processing such event properly releases
        its protection against global read lock.
      sql/mdl.cc:
        Changed MDL subsystem to support new MDL-based implementation
        of global read lock.
        
        Added COMMIT and EVENTS namespaces for metadata locks. Changed
        thread state name for GLOBAL namespace to "Waiting for global
        read lock".
        
        Optimized MDL_map::find_or_insert() method to avoid taking
        m_mutex mutex when looking up MDL_lock objects for GLOBAL
        or COMMIT namespaces. We keep pre-created MDL_lock objects
        for these namespaces around and simply return pointers to
        these global objects when needed.
        
        Changed MDL_lock/MDL_scoped_lock to properly handle
        notification of insert delayed handler threads when FTWRL
        takes global S lock.
        
        Introduced concept of lock duration. In addition to locks with
        transaction duration which work in the way which is similar to
        how locks worked before (i.e. they are released at the end of
        transaction), locks with statement and explicit duration were
        introduced.
        Locks with statement duration are automatically released at the
        end of statement. Locks with explicit duration require explicit
        release and obsolete concept of transactional sentinel.
        
        * Changed MDL_request and MDL_ticket classes to support notion
          of duration.
        * Changed MDL_context to keep locks with different duration in
          different lists. Changed code handling ticket list to take
          this into account.
        * Changed methods responsible for releasing locks to take into
          account duration of tickets. Particularly public
          MDL_context::release_lock() method now only can release
          tickets with explicit duration (there is still internal
          method which allows to specify duration). To release locks
          with statement or transaction duration one have to use
          release_statement/transactional_locks() methods.
        * Concept of savepoint for MDL subsystem now has to take into
          account locks with statement duration. Consequently
          MDL_savepoint class was introduced and methods working with
          savepoints were updated accordingly.
        * Added methods which allow to set duration for one or all
          locks in the context.
      sql/mdl.h:
        Changed MDL subsystem to support new MDL-based implementation
        of global read lock.
        
        Added COMMIT and EVENTS namespaces for metadata locks.
        
        Introduced concept of lock duration. In addition to locks with
        transaction duration which work in the way which is similar to
        how locks worked before (i.e. they are released at the end of
        transaction), locks with statement and explicit duration were
        introduced.
        Locks with statement duration are automatically released at the
        end of statement. Locks with explicit duration require explicit
        release and obsolete concept of transactional sentinel.
        
        * Changed MDL_request and MDL_ticket classes to support notion
          of duration.
        * Changed MDL_context to keep locks with different duration in
          different lists. Changed code handling ticket list to take
          this into account.
        * Changed methods responsible for releasing locks to take into
          account duration of tickets. Particularly public
          MDL_context::release_lock() method now only can release
          tickets with explicit duration (there is still internal
          method which allows to specify duration). To release locks
          with statement or transaction duration one have to use
          release_statement/transactional_locks() methods.
        * Concept of savepoint for MDL subsystem now has to take into
          account locks with statement duration. Consequently
          MDL_savepoint class was introduced and methods working with
          savepoints were updated accordingly.
        * Added methods which allow to set duration for one or all
          locks in the context.
      sql/mysqld.cc:
        Removed global mutex and condition variables which were used
        by old implementation of GRL.
        Also we no longer need to initialize Events::LOCK_event_metadata
        mutex as it was replaced with metadata locks on events.
      sql/mysqld.h:
        Removed global variable, mutex and condition variables which
        were used by old implementation of GRL.
      sql/rpl_rli.cc:
        When slave thread closes tables which were open for handling
        of RBR events ensure that it releases global IX lock which
        was acquired as protection against GRL.
      sql/sp.cc:
        Adjusted code to the new signature of lock_object/routine_name(),
        to the fact that one now needs specify duration of lock when
        initializing MDL_request and to the fact that savepoints for MDL
        subsystem are now represented by MDL_savepoint class.
      sql/sp_head.cc:
        Ensure that statements in stored procedures release statement
        metadata locks and thus release their protectiong against GRL
        in proper moment in time.
        Adjusted code to the fact that one now needs specify duration
        of lock when initializing MDL_request.
      sql/sql_admin.cc:
        Adjusted code to the fact that one now needs specify duration
        of lock when initializing MDL_request.
      sql/sql_base.cc:
        - Implemented support for new approach to acquiring protection
          against global read lock. We no longer acquire such protection
          explicitly on the basis of statement flags. Instead we always
          rely on code which is responsible for acquiring metadata locks
          on object to be changed acquiring this protection. This is
          achieved by acquiring global IX metadata lock with statement
          duration. Code doing this also responsible for checking that
          current connection has no active GRL by calling an
          Global_read_lock::can_acquire_protection() method.
          Changed code in open_table() and lock_table_names()
          accordingly.
          Note that as result of this change DDL and DML on temporary
          tables is always compatible with GRL (before it was
          incompatible in some cases and compatible in other cases).
        - To speed-up code acquiring protection against GRL introduced
          m_has_protection_against_grl member in Open_table_context
          class. It indicates that protection was already acquired
          sometime during open_tables() execution and new attempts
          can be skipped.
        - Thanks to new GRL implementation calls to broadcast_refresh()
          became unnecessary and were removed.
        - Adjusted code to the fact that one now needs specify duration
          of lock when initializing MDL_request and to the fact that
          savepoints for MDL subsystem are now represented by
          MDL_savepoint class.
      sql/sql_base.h:
        Adjusted code to the fact that savepoints for MDL subsystem are
        now represented by MDL_savepoint class.
        Also introduced Open_table_context::m_has_protection_against_grl
        member which allows to avoid acquiring protection against GRL
        while opening tables if such protection was already acquired.
      sql/sql_class.cc:
        Changed THD::leave_locked_tables_mode() after transactional
        sentinel for metadata locks was obsoleted by introduction of
        locks with explicit duration.
      sql/sql_class.h:
        - Adjusted code to the fact that savepoints for MDL subsystem
          are now represented by MDL_savepoint class.
        - Changed Global_read_lock class according to changes in
          global read lock implementation:
          * wait_if_global_read_lock and start_waiting_global_read_lock
            are now gone. Instead code needing protection against GRL
            has to acquire global IX metadata lock with statement
            duration itself. To help it new can_acquire_protection()
            was introduced. Also as result of the above change
            m_protection_count member is gone too.
          * Added m_mdl_blocks_commits_lock member to store metadata
            lock blocking commits.
          * Adjusted code to the fact that concept of transactional
            sentinel was obsoleted by concept of lock duration.
        - Removed CF_PROTECT_AGAINST_GRL flag as it is no longer
          necessary. New GRL implementation acquires protection
          against global read lock automagically when statement
          acquires metadata locks on tables or other objects it
          is going to change.
      sql/sql_db.cc:
        Adjusted code to the fact that one now needs specify duration
        of lock when initializing MDL_request.
      sql/sql_handler.cc:
        Removed call to broadcast_refresh() function. It is no longer
        needed with new GRL implementation.
        Adjusted code after introducing duration concept for metadata
        locks. Particularly to the fact transactional sentinel was
        replaced with explicit duration.
      sql/sql_handler.h:
        Renamed mysql_ha_move_tickets_after_trans_sentinel() to
        mysql_ha_set_explicit_lock_duration() after transactional
        sentinel was obsoleted by locks with explicit duration.
      sql/sql_insert.cc:
        Adjusted code handling delaying inserts after switching to
        new GRL implementation. Now connection thread initiating
        delayed insert has to acquire global IX lock in addition
        to metadata lock on table being inserted into. This IX lock
        protects against GRL and similarly to SW lock on table being
        inserted into has to be passed to handler thread in order to
        avoid deadlocks.
      sql/sql_lex.cc:
        LEX::protect_against_global_read_lock member is no longer
        necessary since protection against GRL is automatically
        taken by code acquiring metadata locks/opening tables.
      sql/sql_lex.h:
        LEX::protect_against_global_read_lock member is no longer
        necessary since protection against GRL is automatically
        taken by code acquiring metadata locks/opening tables.
      sql/sql_parse.cc:
        - Implemented support for new approach to acquiring protection
          against global read lock. We no longer acquire such protection
          explicitly on the basis of statement flags. Instead we always
          rely on code which is responsible for acquiring metadata locks
          on object to be changed acquiring this protection. This is
          achieved by acquiring global IX metadata lock with statement
          duration. This lock is automatically released at the end of
          statement execution.
        - Changed implementation of CREATE/DROP PROCEDURE/FUNCTION not
          to release metadata locks and thus protection against of GRL
          in the middle of statement execution.
        - Adjusted code to the fact that one now needs specify duration
          of lock when initializing MDL_request and to the fact that
          savepoints for MDL subsystem are now represented by
          MDL_savepoint class.
      sql/sql_prepare.cc:
        Adjusted code to the to the fact that savepoints for MDL
        subsystem are now represented by MDL_savepoint class.
      sql/sql_rename.cc:
        With new GRL implementation there is no need to explicitly
        acquire protection against GRL before renaming tables.
        This happens automatically in code which acquires metadata
        locks on tables being renamed.
      sql/sql_show.cc:
        Adjusted code to the fact that one now needs specify duration
        of lock when initializing MDL_request and to the fact that
        savepoints for MDL subsystem are now represented by
        MDL_savepoint class.
      sql/sql_table.cc:
        - With new GRL implementation there is no need to explicitly
          acquire protection against GRL before dropping tables.
          This happens automatically in code which acquires metadata
          locks on tables being dropped.
        - Changed mysql_alter_table() not to release lock on new table
          name explicitly and to rely on automatic release of locks
          at the end of statement instead. This was necessary since
          now MDL_context::release_lock() is supported only for locks
          for explicit duration.
      sql/sql_trigger.cc:
        With new GRL implementation there is no need to explicitly
        acquire protection against GRL before changing table triggers.
        This happens automatically in code which acquires metadata
        locks on tables which triggers are to be changed.
      sql/sql_update.cc:
        Fix bug exposed by GRL testing. During prepare phase acquire
        only S metadata locks instead of SW locks to keep prepare of
        multi-UPDATE compatible with concurrent LOCK TABLES WRITE
        and global read lock.
      sql/sql_view.cc:
        With new GRL implementation there is no need to explicitly
        acquire protection against GRL before creating view.
        This happens automatically in code which acquires metadata
        lock on view to be created.
      sql/sql_yacc.yy:
        LEX::protect_against_global_read_lock member is no longer
        necessary since protection against GRL is automatically
        taken by code acquiring metadata locks/opening tables.
      sql/table.cc:
        Adjusted code to the fact that one now needs specify duration
        of lock when initializing MDL_request.
      sql/table.h:
        Adjusted code to the fact that one now needs specify duration
        of lock when initializing MDL_request.
      sql/transaction.cc:
        Replaced custom implementation of global read lock with
        one based on metadata locks. Consequently when doing
        commit instead of calling method of Global_read_lock
        class to acquire protection against GRL we simply acquire
        IX in COMMIT namespace.
        Also adjusted code to the fact that MDL savepoint is now
        represented by MDL_savepoint class.
      6bf6272f
  3. 21 Oct, 2010 1 commit
    • Dmitry Shulga's avatar
      Fixed bug#45445 - cannot execute procedures with thread_stack · 89e43c84
      Dmitry Shulga authored
      set to 128k.
      
      sql/sp.cc:
        Added checking for stack overrun at functions
        db_load_routine/sp_find_routine.
      sql/sp_head.cc:
        sp_head::execute() modified: pass constant value STACK_MIN_SIZE
        instead of 8 * STACK_MIN_SIZE  as second argument value
        in call to check_stack_overrun. Added checking for stack overrun
        at functions sp_lex_keeper::reset_lex_and_exec_core/sp_instr_stmt::execute.
      sql/sql_parse.cc:
        check_stack_overrun modified: allocate buffer for error message
        at heap instead of stack.
        parse_sql modified: added call to check_stack_overrun() before
        parsing of sql statement.
      89e43c84
  4. 07 Oct, 2010 1 commit
    • Dmitry Lenev's avatar
      Fix for bug#57061 "User without privilege on routine can · eaae6752
      Dmitry Lenev authored
      discover its existence".
      
      The problem was that user without any privileges on 
      routine was able to find out whether it existed or not.
      DROP FUNCTION and DROP PROCEDURE statements were 
      checking if routine being dropped existed and reported 
      ER_SP_DOES_NOT_EXIST error/warning before checking 
      if user had enough privileges to drop it.
      
      This patch solves this problem by changing code not to 
      check if routine exists before checking if user has enough 
      privileges to drop it. Moreover we no longer perform this 
      check using a separate call instead we rely on 
      sp_drop_routine() returning SP_KEY_NOT_FOUND if routine 
      doesn't exist.
      
      This change also simplifies one of upcoming patches
      refactoring global read lock implementation.
      
      mysql-test/r/grant.result:
        Updated test case after fixing bug#57061 "User without
        privilege on routine can discover its existence". Removed
        DROP PROCEDURE/FUNCTION statements which have started to
        fail after this fix (correctly). There is no need in
        dropping routines in freshly created database anyway.
      mysql-test/r/sp-security.result:
        Added new test case for bug#57061 "User without privilege
        on routine can discover its existence". Updated existing
        tests according to new behaviour.
      mysql-test/suite/funcs_1/r/innodb_storedproc_06.result:
        Updated test case after fixing bug#57061 "User without
        privilege on routine can discover its existence".
        Now we drop routines under user which has enough
        privileges to do so.
      mysql-test/suite/funcs_1/r/memory_storedproc_06.result:
        Updated test case after fixing bug#57061 "User without
        privilege on routine can discover its existence".
        Now we drop routines under user which has enough
        privileges to do so.
      mysql-test/suite/funcs_1/r/myisam_storedproc_06.result:
        Updated test case after fixing bug#57061 "User without
        privilege on routine can discover its existence".
        Now we drop routines under user which has enough
        privileges to do so.
      mysql-test/suite/funcs_1/storedproc/storedproc_06.inc:
        Updated test case after fixing bug#57061 "User without
        privilege on routine can discover its existence".
        Now we drop routines under user which has enough
        privileges to do so.
      mysql-test/t/grant.test:
        Updated test case after fixing bug#57061 "User without
        privilege on routine can discover its existence". Removed
        DROP PROCEDURE/FUNCTION statements which have started to
        fail after this fix (correctly). There is no need in
        dropping routines in freshly created database anyway.
      mysql-test/t/sp-security.test:
        Added new test case for bug#57061 "User without privilege
        on routine can discover its existence". Updated existing
        tests according to new behaviour.
      sql/sp.cc:
        Removed sp_routine_exists_in_table() which is no longer
        used.
      sql/sp.h:
        Removed sp_routine_exists_in_table() which is no longer
        used.
      sql/sql_parse.cc:
        When dropping routine we no longer check if routine exists 
        before checking if user has enough privileges to do so. 
        Moreover we no longer perform this check using a separate 
        call instead we rely on sp_drop_routine() returning 
        SP_KEY_NOT_FOUND if routine doesn't exist.
      eaae6752
  5. 31 Aug, 2010 2 commits
    • Alexander Nozdrin's avatar
      Cherry-picking patch for Bug#56137 from mysql-5.5-runtime. · 4283a704
      Alexander Nozdrin authored
      ```---------------------------------------------------------
      revno: 3124
      revision-id: dlenev@mysql.com-20100831090419-rzr5ktekby2gspm1
      parent: alik@sun.com-20100827083901-x4wvtc10u9p7gcs9
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-5.5-rt-56137
      timestamp: Tue 2010-08-31 13:04:19 +0400
      message:
        Bug #56137 "Assertion `thd->lock == 0' failed on upgrading 
        from 5.1.50 to 5.5.6".
        
        Debug builds of the server aborted due to an assertion
        failure when DROP DATABASE statement was run on an
        installation which had outdated or corrupt mysql.proc table.
        Particularly this affected the mysql_upgrade tool which is
        run as part of 5.1 to 5.5 upgrade.
        
        The problem was that sp_drop_db_routines(), which was invoked
        during dropping of the database, could have returned without
        closing and unlocking mysql.proc table in cases when this
        table was not up-to-date with the current server. As a result
        further attempt to open and lock the mysql.event table, which
        was necessary to complete dropping of the database, ended up
        with an assert.
        
        This patch solves this problem by ensuring that
        sp_drop_db_routines() always closes mysql.proc table and
        releases metadata locks on it. This is achieved by changing
        open_proc_table_for_update() function to close tables and
        release metadata locks acquired by it in case of failure.
        This step also makes behavior of the latter function
        consistent with behavior of open_proc_table_for_read()/
        open_and_lock_tables().
        
        
        Test case for this bug was added to sp-destruct.test.
      ```
      
      ---------------------------------------------------------
      4283a704
    • Dmitry Lenev's avatar
      Bug #56137 "Assertion `thd->lock == 0' failed on upgrading · cddb976f
      Dmitry Lenev authored
      from 5.1.50 to 5.5.6".
      
      Debug builds of the server aborted due to an assertion
      failure when DROP DATABASE statement was run on an
      installation which had outdated or corrupt mysql.proc table.
      Particularly this affected the mysql_upgrade tool which is
      run as part of 5.1 to 5.5 upgrade.
      
      The problem was that sp_drop_db_routines(), which was invoked
      during dropping of the database, could have returned without
      closing and unlocking mysql.proc table in cases when this
      table was not up-to-date with the current server. As a result
      further attempt to open and lock the mysql.event table, which
      was necessary to complete dropping of the database, ended up
      with an assert.
      
      This patch solves this problem by ensuring that
      sp_drop_db_routines() always closes mysql.proc table and
      releases metadata locks on it. This is achieved by changing
      open_proc_table_for_update() function to close tables and
      release metadata locks acquired by it in case of failure.
      This step also makes behavior of the latter function
      consistent with behavior of open_proc_table_for_read()/
      open_and_lock_tables().
      
      
      Test case for this bug was added to sp-destruct.test.
      cddb976f
  6. 27 Jul, 2010 1 commit
    • Konstantin Osipov's avatar
      A pre-requisite patch for the fix for Bug#52044. · 36290c09
      Konstantin Osipov authored
      This patch also fixes Bug#55452 "SET PASSWORD is
      replicated twice in RBR mode".
      
      The goal of this patch is to remove the release of 
      metadata locks from close_thread_tables().
      This is necessary to not mistakenly release
      the locks in the course of a multi-step
      operation that involves multiple close_thread_tables()
      or close_tables_for_reopen().
      
      On the same token, move statement commit outside 
      close_thread_tables().
      
      Other cleanups:
      Cleanup COM_FIELD_LIST.
      Don't call close_thread_tables() in COM_SHUTDOWN -- there
      are no open tables there that can be closed (we leave
      the locked tables mode in THD destructor, and this
      close_thread_tables() won't leave it anyway).
      
      Make open_and_lock_tables() and open_and_lock_tables_derived()
      call close_thread_tables() upon failure.
      Remove the calls to close_thread_tables() that are now
      unnecessary.
      
      Simplify the back off condition in Open_table_context.
      
      Streamline metadata lock handling in LOCK TABLES 
      implementation.
      
      Add asserts to ensure correct life cycle of 
      statement transaction in a session.
      
      Remove a piece of dead code that has also become redundant
      after the fix for Bug 37521.
      
      mysql-test/r/variables.result:
        Update results: set @@autocommit and statement transaction/
        prelocked mode.
      mysql-test/r/view.result:
        A harmless change in CHECK TABLE <view> status for a broken view.
        If previously a failure to prelock all functions used in a view 
        would leave the connection in LTM_PRELOCKED mode, now we call
        close_thread_tables() from open_and_lock_tables()
        and leave prelocked mode, thus some check in mysql_admin_table() that
        works only in prelocked/locked tables mode is no longer activated.
      mysql-test/suite/rpl/r/rpl_row_implicit_commit_binlog.result:
        Fixed Bug#55452 "SET PASSWORD is replicated twice in
        RBR mode": extra binlog events are gone from the
        binary log.
      mysql-test/t/variables.test:
        Add a test case: set autocommit and statement transaction/prelocked
        mode.
      sql/event_data_objects.cc:
        Simplify code in Event_job_data::execute().
        Move sp_head memory management to lex_end().
      sql/event_db_repository.cc:
        Move the release of metadata locks outside
        close_thread_tables().
        Make sure we call close_thread_tables() when
        open_and_lock_tables() fails and remove extra
        code from the events data dictionary.
        Use close_mysql_tables(), a new internal
        function to properly close mysql.* tables
        in the data dictionary.
        Contract Event_db_repository::drop_events_by_field,
        drop_schema_events into one function.
        When dropping all events in a schema,
        make sure we don't mistakenly release all
        locks acquired by DROP DATABASE. These
        include locks on the database name
        and the global intention exclusive
        metadata lock.
      sql/event_db_repository.h:
        Function open_event_table() does not require an instance 
        of Event_db_repository.
      sql/events.cc:
        Use close_mysql_tables() instead of close_thread_tables()
        to bootstrap events, since the latter no longer
        releases metadata locks.
      sql/ha_ndbcluster.cc:
        - mysql_rm_table_part2 no longer releases
        acquired metadata locks. Do it in the caller.
      sql/ha_ndbcluster_binlog.cc:
        Deploy the new protocol for closing thread
        tables in run_query() and ndb_binlog_index
        code.
      sql/handler.cc:
        Assert that we never call ha_commit_trans/
        ha_rollback_trans in sub-statement, which
        is now the case.
      sql/handler.h:
        Add an accessor to check whether THD_TRANS object
        is empty (has no transaction started).
      sql/log.cc:
        Update a comment.
      sql/log_event.cc:
        Since now we commit/rollback statement transaction in 
        mysql_execute_command(), we need a mechanism to communicate
        from Query_log_event::do_apply_event() to mysql_execute_command()
        that the statement transaction should be rolled back, not committed.
        Ideally it would be a virtual method of THD. I hesitate
        to make THD a virtual base class in this already large patch.
        Use a thd->variables.option_bits for now.
        
        Remove a call to close_thread_tables() from the slave IO
        thread. It doesn't open any tables, and the protocol
        for closing thread tables is more complicated now.
        
        Make sure we properly close thread tables, however, 
        in Load_data_log_event, which doesn't
        follow the standard server execution procedure
        with mysql_execute_command().
        @todo: this piece should use Server_runnable
        framework instead.
        Remove an unnecessary call to mysql_unlock_tables().
      sql/rpl_rli.cc:
        Update Relay_log_info::slave_close_thread_tables()
        to follow the new close protocol.
      sql/set_var.cc:
        Remove an unused header.
      sql/slave.cc:
        Remove an unnecessary call to
        close_thread_tables().
      sql/sp.cc:
        Remove unnecessary calls to close_thread_tables()
        from SP DDL implementation. The tables will
        be closed by the caller, in mysql_execute_command().
        When dropping all routines in a database, make sure
        to not mistakenly drop all metadata locks acquired
        so far, they include the scoped lock on the schema.
      sql/sp_head.cc:
        Correct the protocol that closes thread tables
        in an SP instruction.
        Clear lex->sphead before cleaning up lex
        with lex_end to make sure that we don't
        delete the sphead twice. It's considered
        to be "cleaner" and more in line with
        future changes than calling delete lex->sphead
        in other places that cleanup the lex.
      sql/sp_head.h:
        When destroying m_lex_keeper of an instruction,
        don't delete the sphead that all lex objects
        share. 
        @todo: don't store a reference to routine's sp_head
        instance in instruction's lex.
      sql/sql_acl.cc:
        Don't call close_thread_tables() where the caller will
        do that for us.
        Fix Bug#55452 "SET PASSWORD is replicated twice in RBR 
        mode" by disabling RBR replication in change_password()
        function.
        Use close_mysql_tables() in bootstrap and ACL reload
        code to make sure we release all metadata locks.
      sql/sql_base.cc:
        This is the main part of the patch:
        - remove manipulation with thd->transaction
        and thd->mdl_context from close_thread_tables().
        Now this function is only responsible for closing
        tables, nothing else.
        This is necessary to be able to easily use
        close_thread_tables() in procedures, that
        involve multiple open/close tables, which all
        need to be protected continuously by metadata
        locks.
        Add asserts ensuring that TABLE object
        is only used when is protected by a metadata lock.
        Simplify the back off condition of Open_table_context,
        we no longer need to look at the autocommit mode.
        Make open_and_lock_tables() and open_normal_and_derived_tables()
        close thread tables and release metadata locks acquired so-far 
        upon failure. This simplifies their usage.
        Implement close_mysql_tables().
      sql/sql_base.h:
        Add declaration for close_mysql_tables().
      sql/sql_class.cc:
        Remove a piece of dead code that has also become redundant
        after the fix for Bug 37521.
        The code became dead when my_eof() was made a non-protocol method,
        but a method that merely modifies the diagnostics area.
        The code became redundant with the fix for Bug#37521, when 
        we started to cal close_thread_tables() before
        Protocol::end_statement().
      sql/sql_do.cc:
        Do nothing in DO if inside a substatement
        (the assert moved out of trans_rollback_stmt).
      sql/sql_handler.cc:
        Add comments.
      sql/sql_insert.cc:
        Remove dead code. 
        Release metadata locks explicitly at the
        end of the delayed insert thread.
      sql/sql_lex.cc:
        Add destruction of lex->sphead to lex_end(),
        lex "reset" method called at the end of each statement.
      sql/sql_parse.cc:
        Move close_thread_tables() and other related
        cleanups to mysql_execute_command()
        from dispatch_command(). This has become
        possible after the fix for Bug#37521.
        Mark federated SERVER statements as DDL.
        
        Next step: make sure that we don't store
        eof packet in the query cache, and move
        the query cache code outside mysql_parse.
        
        Brush up the code of COM_FIELD_LIST.
        Remove unnecessary calls to close_thread_tables().
        
        When killing a query, don't report "OK"
        if it was a suicide.
      sql/sql_parse.h:
        Remove declaration of a function that is now static.
      sql/sql_partition.cc:
        Remove an unnecessary call to close_thread_tables().
      sql/sql_plugin.cc:
        open_and_lock_tables() will clean up
        after itself after a failure.
        Move close_thread_tables() above
        end: label, and replace with close_mysql_tables(),
        which will also release the metadata lock
        on mysql.plugin.
      sql/sql_prepare.cc:
        Now that we no longer release locks in close_thread_tables()
        statement prepare code has become more straightforward.
        Remove the now redundant check for thd->killed() (used
        only by the backup project) from Execute_server_runnable.
        Reorder code to take into account that now mysql_execute_command()
        performs lex->unit.cleanup() and close_thread_tables().
      sql/sql_priv.h:
        Add a new option to server options to interact
        between the slave SQL thread and execution
        framework (hack). @todo: use a virtual
        method of class THD instead.
      sql/sql_servers.cc:
        Due to Bug 25705 replication of 
        DROP/CREATE/ALTER SERVER is broken.
        Make sure at least we do not attempt to 
        replicate these statements using RBR,
        as this violates the assert in close_mysql_tables().
      sql/sql_table.cc:
        Do not release metadata locks in mysql_rm_table_part2,
        this is done by the caller.
        Do not call close_thread_tables() in mysql_create_table(),
        this is done by the caller. 
        Fix a bug in DROP TABLE under LOCK TABLES when,
        upon error in wait_while_table_is_used() we would mistakenly
        release the metadata lock on a non-dropped table.
        Explicitly release metadata locks when doing an implicit
        commit.
      sql/sql_trigger.cc:
        Now that we delete lex->sphead in lex_end(),
        zero the trigger's sphead in lex after loading
        the trigger, to avoid double deletion.
      sql/sql_udf.cc:
        Use close_mysql_tables() instead of close_thread_tables().
      sql/sys_vars.cc:
        Remove code added in scope of WL#4284 which would
        break when we perform set @@session.autocommit along
        with setting other variables and using tables or functions.
        A test case added to variables.test.
      sql/transaction.cc:
        Add asserts.
      sql/tztime.cc:
        Use close_mysql_tables() rather than close_thread_tables().
      36290c09
  7. 10 Jun, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#42733: Type-punning warnings when compiling MySQL -- · 0f9ddfa9
      Davi Arnaut authored
                  strict aliasing violations.
      
      One somewhat major source of strict-aliasing violations and
      related warnings is the SQL_LIST structure. For example,
      consider its member function `link_in_list` which takes
      a pointer to pointer of type T (any type) as a pointer to
      pointer to unsigned char. Dereferencing this pointer, which
      is done to reset the next field, violates strict-aliasing
      rules and might cause problems for surrounding code that
      uses the next field of the object being added to the list.
      
      The solution is to use templates to parametrize the SQL_LIST
      structure in order to deference the pointers with compatible
      types. As a side bonus, it becomes possible to remove quite
      a few casts related to acessing data members of SQL_LIST.
      
      sql/handler.h:
        Use the appropriate template type argument.
      sql/item.cc:
        Remove now-unnecessary cast.
      sql/item_subselect.cc:
        Remove now-unnecessary casts.
      sql/item_sum.cc:
        Use the appropriate template type argument.
        Remove now-unnecessary cast.
      sql/mysql_priv.h:
        Move SQL_LIST structure to sql_list.h
        Use the appropriate template type argument.
      sql/sp.cc:
        Remove now-unnecessary casts.
      sql/sql_delete.cc:
        Use the appropriate template type argument.
        Remove now-unnecessary casts.
      sql/sql_derived.cc:
        Remove now-unnecessary casts.
      sql/sql_lex.cc:
        Remove now-unnecessary casts.
      sql/sql_lex.h:
        SQL_LIST now takes a template type argument which must
        match the type of the elements of the list. Use forward
        declaration when the type is not available, it is used
        in pointers anyway.
      sql/sql_list.h:
        Rename SQL_LIST to SQL_I_List. The template parameter is
        the type of object that is stored in the list.
      sql/sql_olap.cc:
        Remove now-unnecessary casts.
      sql/sql_parse.cc:
        Remove now-unnecessary casts.
      sql/sql_prepare.cc:
        Remove now-unnecessary casts.
      sql/sql_select.cc:
        Remove now-unnecessary casts.
      sql/sql_show.cc:
        Remove now-unnecessary casts.
      sql/sql_table.cc:
        Remove now-unnecessary casts.
      sql/sql_trigger.cc:
        Remove now-unnecessary casts.
      sql/sql_union.cc:
        Remove now-unnecessary casts.
      sql/sql_update.cc:
        Remove now-unnecessary casts.
      sql/sql_view.cc:
        Remove now-unnecessary casts.
      sql/sql_yacc.yy:
        Remove now-unnecessary casts.
      storage/myisammrg/ha_myisammrg.cc:
        Remove now-unnecessary casts.
      0f9ddfa9
  8. 21 May, 2010 1 commit
    • Alexey Kopytov's avatar
      Bug #42064: low memory crash when importing hex strings, in · c2ebb0ac
      Alexey Kopytov authored
                  Item_hex_string::Item_hex_string
      
      The status of memory allocation in the Lex_input_stream (called
      from the Parser_state constructor) was not checked which led to
      a parser crash in case of the out-of-memory error.
      
      The solution is to introduce new init() member function in
      Parser_state and Lex_input_stream so that status of memory
      allocation can be returned to the caller.
      
      mysql-test/r/error_simulation.result:
        Added a test case for bug #42064.
      mysql-test/t/error_simulation.test:
        Added a test case for bug #42064.
      mysys/my_alloc.c:
        Added error injection code for the regression test.
      mysys/my_malloc.c:
        Added error injection code for the regression test.
      mysys/safemalloc.c:
        Added error injection code for the regression test.
      sql/event_data_objects.cc:
        Use the new init() member function of Parser_state and check
        its return value to handle memory allocation failures.
      sql/mysqld.cc:
        Added error injection code for the regression test.
      sql/sp.cc:
        Use the new init() member function of Parser_state and check
        its return value to handle memory allocation failures.
      sql/sql_lex.cc:
        Moved memory allocation from constructor to the separate init()
        member function.
        Added error injection code for the regression test.
      sql/sql_lex.h:
        Moved memory allocation from constructor to the separate init()
        member function.
      sql/sql_parse.cc:
        Use the new init() member function of Parser_state and check
        its return value to handle memory allocation failures.
      sql/sql_partition.cc:
        Use the new init() member function of Parser_state and check
        its return value to handle memory allocation failures.
      sql/sql_prepare.cc:
        Use the new init() member function of Parser_state and check
        its return value to handle memory allocation failures.
      sql/sql_trigger.cc:
        Use the new init() member function of Parser_state and check
        its return value to handle memory allocation failures.
      sql/sql_view.cc:
        Use the new init() member function of Parser_state and check
        its return value to handle memory allocation failures..
      sql/thr_malloc.cc:
        Added error injection code for the regression test.
      c2ebb0ac
  9. 28 Apr, 2010 1 commit
    • unknown's avatar
      Bug #51839 mixup of DDL causes slave to stop · 164ff447
      unknown authored
      Stored routine DDL statements use statement-based replication
      regardless of the current binlog format. The problem here was
      that if a DDL statement failed during metadata lock acquisition
      or opening of mysql.proc, the binlog format would not be reset
      before returning. So the following DDL or DML statements are 
      binlogged with a wrong binlog format, which causes the slave 
      to stop.
      
      The problem can be resolved by grabbing an exclusive MDL lock firstly
      instead of clearing the current binlog format. So that the binlog
      format will not be affected when the lock grab returns directly with
      an error. The same way is taken to open a proc table for update.
      
      
      mysql-test/suite/rpl/r/rpl_tmp_table_and_DDL.result:
        Test Result for bug#51839
      mysql-test/suite/rpl/t/rpl_tmp_table_and_DDL.test:
        Added test to make sure the binlog format is not changed
        after a execution of DDL with a table locked.
      sql/sp.cc:
        Grab an exclusive MDL lock and open a proc table for update firstly
        instead of clearing the current binlog format.
      164ff447
  10. 31 Mar, 2010 1 commit
    • Mats Kindahl's avatar
      WL#5030: Split and remove mysql_priv.h · 23d8586d
      Mats Kindahl authored
      This patch:
      
      - Moves all definitions from the mysql_priv.h file into
        header files for the component where the variable is
        defined
      - Creates header files if the component lacks one
      - Eliminates all include directives from mysql_priv.h
      - Eliminates all circular include cycles
      - Rename time.cc to sql_time.cc
      - Rename mysql_priv.h to sql_priv.h
      23d8586d
  11. 10 Feb, 2010 1 commit
  12. 09 Feb, 2010 1 commit
    • Luis Soares's avatar
      BUG#51021: current_stmt_binlog_row_based not removed in next-mr · 06df9b07
      Luis Soares authored
      As part of BUG@39934 fix, the public:
       - THD::current_stmt_binlog_row_based 
      variable had been removed and replaced by a private variable:
       - THD::current_stmt_binlog_format. 
      
      THD was refactored and some modifiers and accessors were
      implemented for the new variable.
      
      However, due to a bad merge, the
      THD::current_stmt_binlog_row_based variable is back as a public
      member of THD. This in itself is already potentially
      harmful. What's even worse is that while merging some more
      patches and resolving conflicts, the variable started being used
      again, which is obviously wrong.
      
      To fix this we:
        1. remove the extraneous variable from sql_class.h
        2. revert a bad merge for BUG#49132
        3. merge BUG#49132 properly again (actually, making use of the
           cset used to merge the original patch to mysql-pe).
      06df9b07
  13. 04 Feb, 2010 1 commit
    • Konstantin Osipov's avatar
      Merge next-mr -> next-4284. · 00dc9a6e
      Konstantin Osipov authored
      Cherry-pick a fix Bug#37148 from next-mr, to preserve
      file ids of the added files, and ensure that all the necessary
      changes have been pulled.
      
      Since initially Bug#37148 was null-merged into 6.0,
      the changeset that is now being cherry-picked was likewise
      null merged into next-4284.
      
      Now that Bug#37148 has been reapplied to 6.0, try to make
      it work with next-4284. This is also necessary to be able
      to pull other changes from 5.1-rep into next-4284.
      
      To resolve the merge issues use this changeset applied
      to 6.0:
      revid:jperkin@sun.com-20091216103628-ylhqf7s6yegui2t9
      revno: 3776.1.1
      committer: He Zhenxing <zhenxing.he@sun.com>
      branch nick: 6.0-codebase-bugfixing
      timestamp: Thu 2009-12-17 17:02:50 +0800
      message:
        Fix merge problem with Bug#37148
      
      
      
      00dc9a6e
  14. 24 Jan, 2010 1 commit
  15. 22 Jan, 2010 1 commit
    • unknown's avatar
      Bug #49132 Replication failure on temporary table + DDL · 3cae7d11
      unknown authored
      In RBR, DDL statement will change binlog format to non row-based
      format before it is binlogged, but the binlog format was not be
      restored, and then manipulating a temporary table can not reset binlog
      format to row-based format rightly. So that the manipulated statement
      is binlogged with statement-based format.
      
      To fix the problem, restore the state of binlog format after the DDL
      statement is binlogged.
      
      mysql-test/extra/rpl_tests/rpl_tmp_table_and_DDL.test:
        Added the test file to verify if executing DDL statement before
        trying to manipulate a temporary table causes row-based replication
        to break with error 'table does not exist'.
      mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result:
        Correct the test result, all the above binlog event
        should be row-based after the bug49132 is fixed IN RBR.
      mysql-test/suite/ndb/r/ndb_tmp_table_and_DDL.result:
        Test result for bug#49132 base on ndb engine.
      mysql-test/suite/ndb/t/ndb_tmp_table_and_DDL.test:
        Added the test file to verify if executing DDL statement before
        trying to manipulate a temporary table causes row-based replication
        to break with error 'table does not exist' base on ndb engine.
      mysql-test/suite/rpl/r/rpl_tmp_table_and_DDL.result:
        Test result for bug#49132 base on myisam engine.
      mysql-test/suite/rpl/t/rpl_tmp_table_and_DDL.test:
        Added the test file to verify if executing DDL statement before
        trying to manipulate a temporary table causes row-based replication
        to break with error 'table does not exist' base on myisam engine.
      sql/event_db_repository.cc:
        Added code to restore the state of binlog format after the DDL
        statement is binlogged.
      sql/events.cc:
        Added code to restore the state of binlog format after the DDL
        statement is binlogged.
      sql/sp.cc:
        Added code to restore the state of binlog format after the DDL
        statement is binlogged.
      sql/sql_acl.cc:
        Added code to restore the state of binlog format after the DDL
        statement is binlogged.
      sql/sql_udf.cc:
        Added code to restore the state of binlog format after the DDL
        statement is binlogged.
      3cae7d11
  16. 21 Jan, 2010 1 commit
    • Dmitry Lenev's avatar
      Patch that changes metadata locking subsystem to use mutex per lock and · 6ddd01c2
      Dmitry Lenev authored
      condition variable per context instead of one mutex and one conditional
      variable for the whole subsystem.
      
      This should increase concurrency in this subsystem.
      
      It also opens the way for further changes which are necessary to solve
      such bugs as bug #46272 "MySQL 5.4.4, new MDL: unnecessary deadlock"
      and bug #37346 "innodb does not detect deadlock between update and alter
      table".
      
      Two other notable changes done by this patch:
      
      - MDL subsystem no longer implicitly acquires global intention exclusive
        metadata lock when per-object metadata lock is acquired. Now this has
        to be done by explicit calls outside of MDL subsystem.
      - Instead of using separate MDL_context for opening system tables/tables
        for purposes of I_S we now create MDL savepoint in the main context
        before opening tables and rollback to this savepoint after closing
        them. This means that it is now possible to get ER_LOCK_DEADLOCK error
        even not inside a transaction. This might happen in unlikely case when
        one runs DDL on one of system tables while also running DDL on some
        other tables. Cases when this ER_LOCK_DEADLOCK error is not justified
        will be addressed by advanced deadlock detector for MDL subsystem which
        we plan to implement.
      
      mysql-test/include/handler.inc:
        Adjusted handler_myisam.test and handler_innodb.test to the fact that
        exclusive metadata locks on tables are now acquired according to
        alphabetical order of fully qualified table names instead of order
        in which tables are mentioned in statement.
      mysql-test/r/handler_innodb.result:
        Adjusted handler_myisam.test and handler_innodb.test to the fact that
        exclusive metadata locks on tables are now acquired according to
        alphabetical order of fully qualified table names instead of order
        in which tables are mentioned in statement.
      mysql-test/r/handler_myisam.result:
        Adjusted handler_myisam.test and handler_innodb.test to the fact that
        exclusive metadata locks on tables are now acquired according to
        alphabetical order of fully qualified table names instead of order
        in which tables are mentioned in statement.
      mysql-test/r/mdl_sync.result:
        Adjusted mdl_sync.test to the fact that exclusive metadata locks on
        tables are now acquired according to alphabetical order of fully
        qualified table names instead of order in which tables are mentioned
        in statement.
      mysql-test/t/mdl_sync.test:
        Adjusted mdl_sync.test to the fact that exclusive metadata locks on
        tables are now acquired according to alphabetical order of fully
        qualified table names instead of order in which tables are mentioned
        in statement.
      sql/events.cc:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. As result code
        opening/closing system tables was changed to use Open_tables_backup
        instead of Open_table_state class as well.
      sql/ha_ndbcluster.cc:
        Since manipulations with open table state no longer install proxy
        MDL_context it does not make sense to perform them in order to
        satisfy assert in mysql_rm_tables_part2(). Removed them per agreement
        with Cluster team. This has not broken test suite since scenario in
        which deadlock can occur and assertion fails is not covered by tests.
      sql/lock.cc:
        MDL subsystem no longer implicitly acquires global intention exclusive
        metadata lock when per-object exclusive metadata lock is acquired.
        Now this has to be done by explicit calls outside of MDL subsystem.
      sql/log.cc:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. As result code
        opening/closing system tables was changed to use Open_tables_backup
        instead of Open_table_state class as well.
      sql/mdl.cc:
        Changed metadata locking subsystem to use mutex per lock and condition
        variable per context instead of one mutex and one conditional variable
        for the whole subsystem.
        Changed approach to handling of global metadata locks. Instead of
        implicitly acquiring intention exclusive locks when user requests
        per-object upgradeable or exclusive locks now we require them to be
        acquired explicitly in the same way as ordinary metadata locks.
        In fact global lock are now ordinary metadata locks in new GLOBAL
        namespace.
        
        To implement these changes:
        - Removed LOCK_mdl mutex and COND_mdl condition variable.
        - Introduced MDL_lock::m_mutex mutexes which protect individual lock
          objects.
        - Replaced mdl_locks hash with MDL_map class, which has hash for
          MDL_lock objects as a member and separate mutex which protects this
          hash. Methods of this class allow to find(), find_or_create() or
          remove() MDL_lock objects in concurrency-friendly fashion (i.e.
          for most common operation, find_or_create(), we don't acquire
          MDL_lock::m_mutex while holding MDL_map::m_mutex. Thanks to MikaelR
          for this idea and benchmarks!). Added three auxiliary members to
          MDL_lock class (m_is_destroyed, m_ref_usage, m_ref_release) to
          support this concurrency-friendly behavior.
        - Introduced MDL_context::m_ctx_wakeup_cond condition variable to be
          used for waiting until this context's pending request can be
          satisfied or its thread has to perform actions to resolve potential
          deadlock. Context which want to wait add ticket corresponding to the
          request to an appropriate queue of waiters in MDL_lock object so
          they can be noticed when other contexts change state of lock and be
          awaken by them by signalling on MDL_context::m_ctx_wakeup_cond.
          As consequence MDL_ticket objects has to be used for any waiting
          in metadata locking subsystem including one which happens in
          MDL_context::wait_for_locks() method.
          Another consequence is that MDL_context is no longer copyable and
          can't be saved/restored when working with system tables.
        - Made MDL_lock an abstract class, which delegates specifying exact
          compatibility matrix to its descendants. Added MDL_global_lock child
          class for global lock (The old is_lock_type_compatible() method
          became can_grant_lock() method of this class). Added MDL_object_lock
          class to represent per-object lock (The old MDL_lock::can_grant_lock()
          became its method). Choice between two classes happens based on MDL
          namespace in MDL_lock::create() method.
        - Got rid of MDL_lock::type member as its meaning became ambigous for
          global locks.
        - To simplify waking up of contexts waiting for lock split waiting queue
          in MDL_lock class in two queues. One for pending requests for exclusive
          (including intention exclusive) locks and another for requests for
          shared locks.
        - Added virtual wake_up_waiters() method to MDL_lock, MDL_global_lock and
          MDL_object_lock classes which allows to wake up waiting contexts after
          state of lock changes. Replaced old duplicated code with calls to this
          method.
        - Adjusted MDL_context::try_acquire_shared_lock()/exclusive_lock()/
          global_shared_lock(), MDL_ticket::upgrade_shared_lock_to_exclusive_lock()
          and MDL_context::release_ticket() methods to use MDL_map and
          MDL_lock::m_mutex instead of single LOCK_mdl mutex and wake up
          waiters according to the approach described above. The latter method
          also was renamed to MDL_context::release_lock().
        - Changed MDL_context::try_acquire_shared_lock()/exclusive_lock() and
          release_lock() not to handle global locks. They are now supposed to
          be taken explicitly like ordinary metadata locks.
        - Added helper MDL_context::try_acquire_global_intention_exclusive_lock()
          and acquire_global_intention_exclusive_lock() methods.
        - Moved common code from MDL_context::acquire_global_shared_lock() and
          acquire_global_intention_exclusive_lock() to new method -
          MDL_context::acquire_lock_impl().
        - Moved common code from MDL_context::try_acquire_shared_lock(),
          try_acquire_global_intention_exclusive_lock()/exclusive_lock()
          to MDL_context::try_acquire_lock_impl().
        - Since acquiring of several exclusive locks can no longer happen under
          single LOCK_mdl mutex the approach to it had to be changed. Now we do
          it in one by one fashion. This is done in alphabetical order to avoid
          deadlocks. Changed MDL_context::acquire_exclusive_locks() accordingly
          (as part of this change moved code responsible for acquiring single
          exclusive lock to new MDL_context::acquire_exclusive_lock_impl()
          method).
        - Since we no longer have single LOCK_mdl mutex which protects all
          MDL_context::m_is_waiting_in_mdl members using these members to
          determine if we have really awaken context holding conflicting
          shared lock became inconvinient. Got rid of this member and changed
          notify_shared_lock() helper function and process of acquiring
          of/upgrading to exclusive lock not to rely on such information.
          Now in MDL_context::acquire_exclusive_lock_impl() and
          MDL_ticket::upgrade_shared_lock_to_exclusive_lock() we simply
          re-try to wake up threads holding conflicting shared locks after
          small time out.
        - Adjusted MDL_context::can_wait_lead_to_deadlock() and
          MDL_ticket::has_pending_conflicting_lock() to use per-lock
          mutexes instead of LOCK_mdl. To do this introduced
          MDL_lock::has_pending_exclusive_lock() method.
      sql/mdl.h:
        Changed metadata locking subsystem to use mutex per lock and condition
        variable per context instead of one mutex and one conditional variable
        for the whole subsystem. In order to implement this change:
        
        - Added MDL_key::cmp() method to be able to sort MDL_key objects
          alphabetically. Changed length fields in MDL_key class to uint16
          as 16-bit is enough for length of any key.
        - Changed MDL_ticket::get_ctx() to return pointer to non-const
          object in order to be able to use MDL_context::awake() method
          for such contexts.
        - Got rid of unlocked versions of can_wait_lead_to_deadlock()/
          has_pending_conflicting_lock() methods in MDL_context and
          MDL_ticket. We no longer has single mutex which protects all
          locks. Thus one always has to use versions of these methods
          which acquire per-lock mutexes.
        - MDL_request_list type of list now counts its elements.
        - Added MDL_context::m_ctx_wakeup_cond condition variable to be used
          for waiting until this context's pending request can be satisfied
          or its thread has to perform actions to resolve potential deadlock.
          Added awake() method to wake up context from such wait.
          Addition of condition variable made MDL_context uncopyable.
          As result we no longer can save/restore MDL_context when working
          with system tables. Instead we create MDL savepoint before opening
          those tables and rollback to it once they are closed.
        - MDL_context::release_ticket() became release_lock() method.
        - Added auxiliary MDL_context::acquire_exclusive_lock_impl() method
          which does all necessary work to acquire exclusive lock on one object
          but should not be used directly as it does not enforce any asserts
          ensuring that no deadlocks are possible.
        - Since we no longer need to know if thread trying to acquire exclusive
          lock managed to wake up any threads having conflicting shared locks
          (as, anyway, we will try to wake up such threads again shortly)
        - MDL_context::m_is_waiting_in_mdl member became unnecessary and
          notify_shared_lock() no longer needs to be friend of MDL_context.
        
        Changed approach to handling of global metadata locks. Instead of
        implicitly acquiring intention exclusive locks when user requests
        per-object upgradeable or exclusive locks now we require them to be
        acquired explicitly in the same way as ordinary metadata locks.
        
        - Added new GLOBAL namespace for such locks.
        - Added new type of lock to be requested MDL_INTENTION_EXCLISIVE.
        - Added MDL_context::try_acquire_global_intention_exclusive_lock()
          and acquire_global_intention_exclusive_lock() methods.
        - Moved common code from MDL_context::acquire_global_shared_lock()
          and acquire_global_intention_exclusive_lock() to new method -
          MDL_context::acquire_lock_impl().
        - Moved common code from MDL_context::try_acquire_shared_lock(),
          try_acquire_global_intention_exclusive_lock()/exclusive_lock()
          to MDL_context::try_acquire_lock_impl().
        - Added helper MDL_context::is_global_lock_owner() method to be
          able easily to find what kind of global lock this context holds.
        - MDL_context::m_has_global_shared_lock became unnecessary as
          global read lock is now represented by ordinary ticket.
        - Removed assert in MDL_context::set_lt_or_ha_sentinel() which became
          false for cases when we execute LOCK TABLES under global read lock
          mode.
      sql/mysql_priv.h:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. As result calls
        opening/closing system tables were changed to use Open_tables_backup
        instead of Open_table_state class as well.
      sql/sp.cc:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. As result code
        opening/closing system tables was changed to use Open_tables_backup
        instead of Open_table_state class as well.
      sql/sp.h:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. As result code
        opening/closing system tables was changed to use Open_tables_backup
        instead of Open_table_state class as well.
      sql/sql_base.cc:
        close_thread_tables():
          Since we no longer use separate MDL_context for opening system
          tables we need to avoid releasing all transaction locks when
          closing system table. Releasing metadata lock on system table
          is now responsibility of THD::restore_backup_open_tables_state().
        open_table_get_mdl_lock(),
        Open_table_context::recover_from_failed_open():
          MDL subsystem no longer implicitly acquires global intention exclusive
          metadata lock when per-object upgradable or exclusive metadata lock is
          acquired. So this have to be done explicitly from these calls.
          Changed Open_table_context class to store MDL_request object for
          global intention exclusive lock acquired when opening tables.
        open_table():
          Do not release metadata lock if we have failed to open table as
          this lock might have been acquired by one of previous statements
          in transaction, and therefore should not be released.
        open_system_tables_for_read()/close_system_tables()/
        open_performance_schema_table():
          Instead of using separate MDL_context for opening system tables we now
          create MDL savepoint in the main context before opening such tables
          and rollback to this savepoint after closing them. To support this
          change methods of THD responsible for saving/restoring open table
          state were changed to use Open_tables_backup class which in addition
          to Open_table_state has a member for this savepoint. As result code
          opening/closing system tables was changed to use Open_tables_backup
          instead of Open_table_state class as well.
        close_performance_schema_table():
          Got rid of duplicated code.
      sql/sql_class.cc:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. Also releasing
        metadata lock on system table is now responsibility of
        THD::restore_backup_open_tables_state().
        Adjusted assert in THD::cleanup() to take into account fact that now
        we also use MDL sentinel for global read lock.
      sql/sql_class.h:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. As result:
        - 'mdl_context' member was moved out of Open_tables_state to THD class.
          enter_locked_tables_mode()/leave_locked_tables_mode() had to follow.
        - Methods of THD responsible for saving/restoring open table state were
          changed to use Open_tables_backup class which in addition to
          Open_table_state has a member for this savepoint.
        Changed Open_table_context class to store MDL_request object for
        global intention exclusive lock acquired when opening tables.
      sql/sql_delete.cc:
        MDL subsystem no longer implicitly acquires global intention exclusive
        metadata lock when per-object exclusive metadata lock is acquired.
        Now this has to be done by explicit calls outside of MDL subsystem.
      sql/sql_help.cc:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. As result code
        opening/closing system tables was changed to use Open_tables_backup
        instead of Open_table_state class as well.
      sql/sql_parse.cc:
        Adjusted assert reload_acl_and_cache() to the fact that global read
        lock now takes full-blown metadata lock.
      sql/sql_plist.h:
        Added support for element counting to I_P_List list template.
        One can use policy classes to specify if such counting is needed
        or not needed for particular list.
      sql/sql_show.cc:
        Instead of using separate MDL_context for opening tables for I_S
        purposes we now create MDL savepoint in the main context before
        opening tables and rollback to this savepoint after closing them.
        To support this and similar change for system tables methods of
        THD responsible for saving/restoring open table state were changed
        to use Open_tables_backup class which in addition to Open_table_state
        has a member for this savepoint. As result code opening/closing tables
        for I_S purposes was changed to use Open_tables_backup instead of
        Open_table_state class as well.
      sql/sql_table.cc:
        mysql_rm_tables_part2():
          Since now global intention exclusive metadata lock is ordinary
          metadata lock we no longer can rely that by releasing MDL locks
          on all tables we will release all locks acquired by this routine.
          So in non-LOCK-TABLES mode we have to release all locks acquired
          explicitly.
        prepare_for_repair(), mysql_alter_table():
          MDL subsystem no longer implicitly acquires global intention
          exclusive metadata lock when per-object exclusive metadata lock
          is acquired. Now this has to be done by explicit calls outside of
          MDL subsystem.
      sql/tztime.cc:
        Instead of using separate MDL_context for opening system tables we now
        create MDL savepoint in the main context before opening such tables
        and rollback to this savepoint after closing them. To support this
        change methods of THD responsible for saving/restoring open table
        state were changed to use Open_tables_backup class which in addition
        to Open_table_state has a member for this savepoint. As result code
        opening/closing system tables was changed to use Open_tables_backup
        instead of Open_table_state class as well.
        Also changed code not to use special mechanism for open system tables
        when it is not really necessary.
      6ddd01c2
  17. 15 Jan, 2010 1 commit
    • Sergey Glukhov's avatar
      backported: · 5a4a98af
      Sergey Glukhov authored
      -WL#2822 INFORMATION_SCHEMA.ROUTINES: Add missing columns
      -WL#2003 INFORMATION_SCHEMA: PARAMETERS view
      -addon for 'I_S optimization' WL
      
      5a4a98af
  18. 29 Dec, 2009 1 commit
    • Konstantin Osipov's avatar
      Apply and review: · bf9c1b73
      Konstantin Osipov authored
      3655 Jon Olav Hauglid   2009-10-19
      Bug #30977 Concurrent statement using stored function and DROP FUNCTION 
                 breaks SBR
      Bug #48246 assert in close_thread_table
      
      Implement a fix for:
      Bug #41804 purge stored procedure cache causes mysterious hang for many
                 minutes
      Bug #49972 Crash in prepared statements
      
      The problem was that concurrent execution of DML statements that
      use stored functions and DDL statements that drop/modify the same
      function might result in incorrect binary log in statement (and
      mixed) mode and therefore break replication.
      
      This patch fixes the problem by introducing metadata locking for
      stored procedures and functions. This is similar to what is done
      in Bug#25144 for views. Procedures and functions now are
      locked using metadata locks until the transaction is either
      committed or rolled back. This prevents other statements from
      modifying the procedure/function while it is being executed. This
      provides commit ordering - guaranteeing serializability across
      multiple transactions and thus fixes the reported binlog problem.
      
      Note that we do not take locks for top-level CALLs. This means
      that procedures called directly are not protected from changes by
      simultaneous DDL operations so they are executed at the state they
      had at the time of the CALL. By not taking locks for top-level
      CALLs, we still allow transactions to be started inside
      procedures.
      
      This patch also changes stored procedure cache invalidation.
      Upon a change of cache version, we no longer invalidate the entire
      cache, but only those routines which we use, only when a statement
      is executed that uses them.
      
      This patch also changes the logic of prepared statement validation.
      A stored procedure used by a prepared statement is now validated
      only once a metadata lock has been acquired. A version mismatch
      causes a flush of the obsolete routine from the cache and
      statement reprepare.
      Incompatible changes:
      1) ER_LOCK_DEADLOCK is reported for a transaction trying to access
         a procedure/function that is locked by a DDL operation in
         another connection.
      
      2) Procedure/function DDL operations are now prohibited in LOCK
         TABLES mode as exclusive locks must be taken all at once and
         LOCK TABLES provides no way to specifiy procedures/functions to
         be locked.
      
      Test cases have been added to sp-lock.test and rpl_sp.test.
      
      Work on this bug has very much been a team effort and this patch
      includes and is based on contributions from Davi Arnaut, Dmitry
      Lenev, Magne Mæhre and Konstantin Osipov.
      
      
      mysql-test/r/ps_ddl.result:
        Update results (Bug#30977).
      mysql-test/r/ps_ddl1.result:
        Update results (Bug#30977).
      mysql-test/r/sp-error.result:
        Update results (Bug#30977).
      mysql-test/r/sp-lock.result:
        Update results (Bug#30977).
      mysql-test/suite/rpl/r/rpl_sp.result:
        Update results (Bug#30977).
      mysql-test/suite/rpl/t/rpl_sp.test:
        Add a test case for Bug#30977.
      mysql-test/t/ps_ddl.test:
        Update comments. We no longer re-prepare a prepared statement
        when a stored procedure used in top-level CALL is changed.
      mysql-test/t/ps_ddl1.test:
        Modifying stored procedure p1 no longer invalidates prepared
        statement "call p1" -- we can re-use the prepared statement
        without invalidation.
      mysql-test/t/sp-error.test:
        Use a constant for an error value.
      mysql-test/t/sp-lock.test:
        Add test coverage for Bug#30977.
      sql/lock.cc:
        Implement lock_routine_name() - a way to acquire an 
        exclusive metadata lock (ex- name-lock) on 
        stored procedure/function.
      sql/sp.cc:
        Change semantics of sp_cache_routine() -- now it has an option
        to make sure that the routine that is cached is up to date (has
        the latest sp cache version).
        
        Add sp_cache_invalidate() to sp_drop_routine(), where it was
        missing (a bug!).
        
        Acquire metadata locks for SP DDL (ALTER/CREATE/DROP). This is
        the core of the fix for Bug#30977.
        
        Since caching and cache invalidation scheme was changed, make 
        sure we don't invalidate the SP cache in the middle of a stored
        routine execution. At the same time, make sure we don't access
        stale data due to lack of invalidation. 
        For that, change ALTER FUNCTION/PROCEDURE to not use the cache,
        and SHOW PROCEDURE CODE/SHOW CREATE PROCEDURE/FUNCTION to always
        read an up to date version of the routine from the cache.
      sql/sp.h:
        Add a helper wrapper around sp_cache_routine().
      sql/sp_cache.cc:
        Implement new sp_cache_version() and sp_cache_flush_obsolete().
        Now we flush stale routines individually, rather than all at once.
      sql/sp_cache.h:
        Update signatures of sp_cache_version() and sp_cache_flush_obsolete().
      sql/sp_head.cc:
        Add a default initialization of sp_head::m_sp_cache_version.
        Remove a redundant sp_head::create().
      sql/sp_head.h:
        Add m_sp_cache_version to sp_head class - we now 
        keep track of every routine in the stored procedure cache, rather than
        of the entire cache.
      sql/sql_base.cc:
        Implement prelocking for stored routines. Validate stored
        routines after they were locked.
        Flush obsolete routines upon next access, one by one, not all at once
        (Bug#41804).
        Style fixes.
      sql/sql_class.h:
        Rename a Open_table_context method.
      sql/sql_parse.cc:
        Make sure stored procedures DDL commits the active transaction 
        (issues an implicit commit before and after).
        Remove sp_head::create(), a pure redundancy.
        Move the semantical check during alter routine inside sp_update_routine() code in order to:
        - avoid using SP cache during update, it may be obsolete.
        - speed up and simplify the update procedure.
        
        Remove sp_cache_flush_obsolete() calls, we no longer flush the entire
        cache, ever, stale routines are flushed before next use, one at a time.
      sql/sql_prepare.cc:
        Move routine metadata validation to open_and_process_routine().
        Fix Bug#49972 (don't swap flags at reprepare).
        Reset Sroutine_hash_entries in reinit_stmt_before_use().
        Remove SP cache invalidation, it's now done by open_tables().
      sql/sql_show.cc:
        Fix a warning: remove an unused label.
      sql/sql_table.cc:
        Reset mdl_request.ticket for tickets acquired for routines inlined
        through a view, in CHECK TABLE statement, to satisfy an MDL assert.
      sql/sql_update.cc:
        Move the cleanup of "translation items" to close_tables_for_reopen(),
        since it's needed in all cases when we back off, not just
        the back-off in multi-update. This fixes a bug when the server
        would crash on attempt to back off when opening tables
        for a statement that uses information_schema tables.
      bf9c1b73
  19. 05 Feb, 2010 1 commit
  20. 10 Dec, 2009 1 commit
    • Konstantin Osipov's avatar
      Backport of: · f26f632b
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2617.68.25
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-next-bg-pre2-2
      timestamp: Wed 2009-09-16 18:26:50 +0400
      message:
        Follow-up for one of pre-requisite patches for fixing bug #30977
        "Concurrent statement using stored function and DROP FUNCTION
        breaks SBR".
      
        Made enum_mdl_namespace enum part of MDL_key class and removed MDL_
        prefix from the names of enum members. In order to do the latter
        changed name of PROCEDURE symbol to PROCEDURE_SYM (otherwise macro
        which was automatically generated for this symbol conflicted with
        MDL_key::PROCEDURE enum member).
      f26f632b
  21. 09 Dec, 2009 1 commit
    • Konstantin Osipov's avatar
      Backport of: · 634a8109
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2617.68.24
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-next-bg-pre2-2
      timestamp: Wed 2009-09-16 17:25:29 +0400
      message:
        Pre-requisite patch for fixing bug #30977 "Concurrent statement
        using stored function and DROP FUNCTION breaks SBR".
      
        Added MDL_request for stored routine as member to Sroutine_hash_entry
        in order to be able perform metadata locking for stored routines in
        future (Sroutine_hash_entry is an equivalent of TABLE_LIST class for
        stored routines).
      (WL#4284, follow up fixes).
      
      sql/mdl.cc:
        Introduced version of MDL_request::init() method which initializes
        lock request using pre-built MDL key.
        MDL_key::table_name/table_name_length() getters were
        renamed to reflect the fact that MDL_key objects are
        now created not only for tables.
      sql/mdl.h:
        Extended enum_mdl_namespace enum with values which correspond
        to namespaces for stored functions and triggers.
        Renamed MDL_key::table_name/table_name_length() getters
        to MDL_key::name() and name_length() correspondingly to
        reflect the fact that MDL_key objects are now created
        not only for tables.
        Added MDL_key::mdl_namespace() getter.
        Also added version of MDL_request::init() method which
        initializes lock request using pre-built MDL key.
      sql/sp.cc:
        Added MDL_request for stored routine as member to Sroutine_hash_entry.
        Changed code to use MDL_key from this request as a key for LEX::sroutines
        set. Removed separate "key" member from Sroutine_hash_entry as it became
        unnecessary.
      sql/sp.h:
        Added MDL_request for stored routine as member to Sroutine_hash_entry
        in order to be able perform metadata locking for stored routines in
        future (Sroutine_hash_entry is an equivalent of TABLE_LIST class for
        stored routines).
        Removed Sroutine_hash_entry::key member as now we can use MDL_key from
        this request as a key for LEX::sroutines set.
      sql/sp_head.cc:
        Removed sp_name::m_sroutines_key member and set_routine_type() method.
        Since key for routine in LEX::sroutines set has no longer sp_name::m_qname
        as suffix we won't save anything by creating it at sp_name construction
        time.
        Adjusted sp_name constructor used for creating temporary objects for
        lookups in SP-cache to accept MDL_key as parameter and to avoid any
        memory allocation.
        Finally, removed sp_head::m_soutines_key member for reasons similar
        to why sp_name::m_sroutines_key was removed
      sql/sp_head.h:
        Removed sp_name::m_sroutines_key member and set_routine_type() method.
        Since key for routine in LEX::sroutines set has no longer sp_name::m_qname
        as suffix we won't save anything by creating it at sp_name construction
        time.
        Adjusted sp_name constructor used for creating temporary objects for
        lookups in SP-cache to accept MDL_key as parameter and to avoid any
        memory allocation.
        Finally, removed sp_head::m_soutines_key member for reasons similar
        to why sp_name::m_sroutines_key was removed.
      sql/sql_base.cc:
        Adjusted code to the fact that we now use MDL_key from
        Sroutine_hash_entry::mdl_request as a key for LEX::sroutines set.
        MDL_key::table_name/table_name_length() getters were
        renamed to reflect the fact that MDL_key objects are
        now created not only for tables.
      sql/sql_trigger.cc:
        sp_add_used_routine() now takes MDL_key as parameter as now we use
        instance of this class as a key for LEX::sroutines set.
      634a8109
  22. 08 Dec, 2009 2 commits
    • Konstantin Osipov's avatar
      Backport of: · 30235272
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2617.69.24
      committer: Konstantin Osipov <kostja@sun.com>
      branch nick: 5.4-42546
      timestamp: Fri 2009-08-14 19:22:05 +0400
      message:
        A pre-requisite for a fix for Bug#42546 "Backup: RESTORE fails, thinking it
        finds an existing table"
        Back-port from WL 148 "Foreign keys" feature tree a patch
        that introduced Prelocking_strategy class -- a way to parameterize
        open_tables() behaviour, implemented by Dmitry Lenev.
      
      (Part of WL#4284).
      
      sql/sql_base.cc:
        Implement different prelocking strategies. Use an instance of
        prelocking_strategy in open_tables().
      sql/sql_class.h:
        Add declarations for class Prelocking_strategy.
      sql/sql_lex.h:
        Add a helper method to access last table of the global table list
        (lex->query_tables).
      sql/sql_parse.cc:
        Use a special prelocking strategy when locking tables for LOCK TABLES.
      sql/sql_table.cc:
        Use normal open_and_lock_tables_derived() in ALTER TABLE.
      sql/sql_yacc.yy:
        Modify the grammar to not pollute the global table list with tables
        that should not be opened.
      30235272
    • Konstantin Osipov's avatar
      Backport of: · ce5c87a3
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2617.69.20
      committer: Konstantin Osipov <kostja@sun.com>
      branch nick: 5.4-4284-1-assert
      timestamp: Thu 2009-08-13 18:29:55 +0400
      message:
        WL#4284 "Transactional DDL locking"
        A review fix.
        Since WL#4284 implementation separated MDL_request and MDL_ticket,
        MDL_request becamse a utility object necessary only to get a ticket.
        Store it by-value in TABLE_LIST with the intent to merge
        MDL_request::key with table_list->table_name and table_list->db
        in future.
        Change the MDL subsystem to not require MDL_requests to
        stay around till close_thread_tables().
        Remove the list of requests from the MDL context.
        Requests for shared metadata locks acquired in open_tables()
        are only used as a list in recover_from_failed_open_table_attempt(),
        which calls mdl_context.wait_for_locks() for this list.
        To keep such list for recover_from_failed_open_table_attempt(),
        introduce a context class (Open_table_context), that collects
        all requests.
        A lot of minor cleanups and simplications that became possible
        with this change.
      
      
      sql/event_db_repository.cc:
        Remove alloc_mdl_requests(). Now MDL_request instance is a member
        of TABLE_LIST, and init_one_table() initializes it.
      sql/ha_ndbcluster_binlog.cc:
        Remove now unnecessary declaration and initialization
        of binlog_mdl_request.
      sql/lock.cc:
        No need to allocate MDL requests in lock_table_names() now.
      sql/log.cc:
        Use init_one_table() method, remove alloc_mdl_requests(),
        which is now unnecessary.
      sql/log_event.cc:
        No need to allocate mdl_request separately now.
        Use init_one_table() method.
      sql/log_event_old.cc:
        Update to the new signature of close_tables_for_reopen().
      sql/mdl.cc:
        Update try_acquire_exclusive_lock() to be more easy to use.
        Function lock_table_name_if_not_cached() has been removed.
        Make acquire_shared_lock() signature consistent with
        try_acquire_exclusive_lock() signature.
        Remove methods that are no longer used.
        Update comments.
      sql/mdl.h:
        Implement an assignment operator that doesn't
        copy MDL_key (MDL_key::operator= is private and
        should remain private).
        This is a hack to work-around assignment of TABLE_LIST
        by value in several places. Such assignments violate
        encapsulation, since only perform a shallow copy.
        In most cases these assignments are a hack on their own.
      sql/mysql_priv.h:
        Update signatures of close_thread_tables() and close_tables_for_reopen().
      sql/sp.cc:
        Allocate TABLE_LIST in thd->mem_root.
        Use init_one_table().
      sql/sp_head.cc:
        Use init_one_table().
        Remove thd->locked_tables_root, it's no longer needed.
      sql/sql_acl.cc:
        Use init_mdl_requests() and init_one_table().
      sql/sql_base.cc:
        Update to new signatures of try_acquire_shared_lock() and
        try_acquire_exclusive_lock().
        Remove lock_table_name_if_not_cached().
        Fix a bug in open_ltable() that would not return ER_LOCK_DEADLOCK
        in case of a failed lock_tables() and a multi-statement
        transaction.
        Fix a bug in open_and_lock_tables_derived() that would
        not return ER_LOCK_DEADLOCK in case of a multi-statement
        transaction and a failure of lock_tables().
        Move assignment of enum_open_table_action to a method of Open_table_context, a new class that maintains information
        for backoff actions.
        Minor rearrangements of the code.
        Remove alloc_mdl_requests() in functions that work with system
        tables: instead the patch ensures that callers always initialize
        TABLE_LIST argument.
      sql/sql_class.cc:
        THD::locked_tables_root is no more.
      sql/sql_class.h:
        THD::locked_tables_root is no more.
        Add a declaration for Open_table_context class.
      sql/sql_delete.cc:
        Update to use the simplified MDL API.
      sql/sql_handler.cc:
        TABLE_LIST::mdl_request is stored by-value now.
        Ensure that mdl_request.ticket is NULL for every request
        that is passed into MDL, to satisfy MDL asserts.
        @ sql/sql_help.cc
        Function open_system_tables_for_read() no longer initializes
        mdl_requests.
        Move TABLE_LIST::mdl_request initialization closer to
        TABLE_LIST initialization.
      sql/sql_help.cc:
        Function open_system_tables_for_read() no longer initializes
        mdl_requests.
        Move TABLE_LIST::mdl_request initialization closer to
        TABLE_LIST initialization.
      sql/sql_insert.cc:
        Remove assignment by-value of TABLE_LIST in
        TABLEOP_HOOKS. We can't carry over a granted
        MDL ticket from one table list to another.
      sql/sql_parse.cc:
        Change alloc_mdl_requests() -> init_mdl_requests().
        @todo We can remove init_mdl_requests() altogether
        in some places: all places that call add_table_to_list()
        already have mdl requests initialized.
      sql/sql_plugin.cc:
        Use init_one_table().
        THD::locked_tables_root is no more.
      sql/sql_servers.cc:
        Use init_one_table().
      sql/sql_show.cc:
        Update acquire_high_priority_shared_lock() to use
        TABLE_LIST::mdl_request rather than allocate an own.
        Fix get_trigger_table_impl() to use init_one_table(),
        check for out of memory, follow the coding style.
      sql/sql_table.cc:
        Update to work with TABLE_LIST::mdl_request by-value.
        Remove lock_table_name_if_not_cached().
        The code that used to delegate to it is quite simple and
        concise without it now.
      sql/sql_udf.cc:
        Use init_one_table().
      sql/sql_update.cc:
        Update to use the new signature of close_tables_for_reopen().
      sql/table.cc:
        Move re-setting of mdl_requests for prepared statements
        and stored procedures from close_thread_tables() to
        reinit_stmt_before_use().
        Change alloc_mdl_requests() to init_mdl_requests().
        init_mdl_requests() is a hack that can't be deleted
        until we don't have a list-aware TABLE_LIST constructor.
        Hopefully its use will be minimal
      sql/table.h:
        Change alloc_mdl_requests() to init_mdl_requests()
        TABLE_LIST::mdl_request is stored by value.
      sql/tztime.cc:
        We no longer initialize mdl requests in open_system_tables_for*()
        functions. Move this initialization closer to initialization
        of the rest of TABLE_LIST members.
      storage/myisammrg/ha_myisammrg.cc:
        Simplify mdl_request initialization.
      ce5c87a3
  23. 03 Dec, 2009 1 commit
    • Konstantin Osipov's avatar
      Backport of: · ec14bfc7
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2630.2.7
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-runtime
      timestamp: Wed 2008-06-04 15:18:52 +0400
      message:
        Fix a code regression (not observable externally) that I introduced
        in the fix for Bug#26141
      
      (backporting as part of all patches related to WL#3726)
      ec14bfc7
  24. 02 Dec, 2009 1 commit
    • Alexander Barkov's avatar
      Bug#48766 SHOW CREATE FUNCTION returns extra data in return clause · d7abca9a
      Alexander Barkov authored
      Problem: SHOW CREATE FUNCTION and SELECT DTD_IDENTIFIER FROM I_S.ROUTINES
      returned wrong values in case of ENUM return data type and UCS2
      character set.
      
      Fix: the string to collect returned data type was incorrectly set to
      "binary" character set, therefore UCS2 values where returned with
      extra '\0' characters.
      Setting string character set to creation_ctx->get_client_cs()
      in sp_find_routine(), and to system_charset_info in sp_create_routine
      fixes the problem.
      
      Adding tests:
      - the original test with Latin letters
      - an extra test with non-Latin letters
      d7abca9a
  25. 21 Nov, 2009 2 commits
    • Davi Arnaut's avatar
      Bug#41726: upgrade from 5.0 to 5.1.30 crashes if you didn't run mysql_upgrade · c70a9fa1
      Davi Arnaut authored
      The problem is that the server could crash when attempting
      to access a non-conformant proc system table. One such case
      was a crash when invoking stored procedure related statements
      on a 5.1 server with a proc system table in the 5.0 format.
      
      The solution is to validate the proc system table format
      before attempts to access it are made. If the table is not
      in the format that the server expects, a message is written
      to the error log and the statement that caused the table to
      be accessed fails.
      
      mysql-test/r/sp-destruct.result:
        Add test case result for Bug#41726
      mysql-test/t/sp-destruct.test:
        Add test case for Bug#41726
      sql/event_db_repository.cc:
        Update code to use new structures.
      sql/sp.cc:
        Describe the proc table format and use it to validate when
        opening a instance of the table.
        Add a check to insure that a error message is written to
        the error log only once.
      sql/sql_acl.cc:
        Remove unused variable and use new structure.
      sql/sql_acl.h:
        Export field definition.
      sql/table.cc:
        Accept the field count and definition in a single structure.
      sql/table.h:
        Combine the field count and definition in a single structure.
        Transform function into a class in order to support different
        ways of reporting a error.
        Add a pointer cache to TABLE_SHARE.
      c70a9fa1
    • He Zhenxing's avatar
      BUG#37148 Most callers of mysql_bin_log.write ignore the return result · dd383cad
      He Zhenxing authored
      This is the non-ndb part of the patch.
      
      The return value of mysql_bin_log.write was ignored by most callers,
      which may lead to inconsistent on master and slave if the transaction
      was committed while the binlog was not correctly written. If
      my_error() is call in mysql_bin_log.write, this could also lead to
      assertion issue if my_ok() or my_error() is called after.
      
      This fixed the problem by let the caller to check and handle the
      return value of mysql_bin_log.write. This patch only adresses the
      simple cases.
      
      
      mysql-test/include/binlog_inject_error.inc:
        inject binlog write error when doing a query
      mysql-test/suite/binlog/t/binlog_write_error.test:
        Simple test case to check if proper error is reported when injecting binlog write errors.
      sql/events.cc:
        check return value of mysql_bin_log.write
      sql/log.cc:
        check return value of mysql_bin_log.write
      sql/log_event.cc:
        check return value of mysql_bin_log.write
      sql/log_event_old.cc:
        check return value of mysql_bin_log.write
      sql/mysql_priv.h:
        Change write_bin_log to return int instead of void
      sql/rpl_injector.cc:
        check return value of writing binlog
      sql/sp.cc:
        check return value of writing binlog
      sql/sp_head.cc:
        return 1 if writing binlog failed
      sql/sql_acl.cc:
        check return value of writing binlog
      sql/sql_base.cc:
        check return value of writing binlog
      sql/sql_class.h:
        Change binlog_show_create_table to return int
      sql/sql_db.cc:
        Change write_to_binlog to return int
        check return value of writing binlog
      sql/sql_delete.cc:
        check return value of writing binlog
      sql/sql_insert.cc:
        check return value of writing binlog
      sql/sql_load.cc:
        check return value of writing binlog
      sql/sql_parse.cc:
        check return value of writing binlog
      sql/sql_partition.cc:
        check return value of writing binlog
      sql/sql_rename.cc:
        check return value of writing binlog
      sql/sql_repl.cc:
        check return value of writing binlog
      sql/sql_table.cc:
        Change write_bin_log to return int, and return 1 if there was error writing binlog
      sql/sql_tablespace.cc:
        check return value of writing binlog
      sql/sql_trigger.cc:
        check return value of writing binlog
      sql/sql_udf.cc:
        check return value of writing binlog
      sql/sql_update.cc:
        check return value of writing binlog
      sql/sql_view.cc:
        check return value of writing binlog
      dd383cad
  26. 20 Nov, 2009 1 commit
  27. 10 Nov, 2009 1 commit
    • Davi Arnaut's avatar
      Backport of Bug#32140 to mysql-next-mr · c34c6665
      Davi Arnaut authored
      ------------------------------------------------------------
      revno: 2618
      revision-id: sp1r-davi@mysql.com/endora.local-20080418131946-26951
      parent: sp1r-davi@mysql.com/endora.local-20080417190810-26185
      committer: davi@mysql.com/endora.local
      timestamp: Fri 2008-04-18 10:19:46 -0300
      message:
        Bug#32140: wrong error code caught when an SF() call is interruped with KILL query
      
        The problem is that killing a query which calls a stored function
        could return a wrong error (table corrupt) instead of the query
        interrupted error message.
      
        The solution is to not set the table corrupt error if the query
        is killed, the query interrupted error message will be set  later
        when the query is finished.
      
      sql/sp.cc:
        Don't set a error if the thread was killed, the query
        interrupted error will be set later.
      c34c6665
  28. 09 Nov, 2009 1 commit
    • Alexander Barkov's avatar
      # · f3d89b2a
      Alexander Barkov authored
      # Bug#24690 Stored functions: RETURNing UTF8 strings
      # do not return UTF8_UNICODE_CI collation
      #
      # Bug#17903: cast to char results in binary
      # Regression. The character set was not being properly initialized
      # for CAST() with a type like CHAR(2) BINARY, which resulted in
      # incorrect results or even a server crash.
      #
      
      Backporting from mysql-6.0-codebase.
      
      mysql-test/r/sp-ucs2.result:
      mysql-test/t/sp-ucs2.test:
      
        Adding tests
      
      sql/mysql_priv.h:
        Adding prototype
      
      sql/sp.cc
        Remember COLLATE clause for non-default collations
      
      sql/sql_parse.cc
        Adding a new helper function
      
      sql/sql_yacc.yy
        - Allow "CHARACTER SET cs COLLATE cl" in
          SP parameters, RETURNS, DECLARE
        - Minor reorganization for "ASCII" and "UNICODE"
          related rules, to make the code more readable,
          also to allow these aliases:
          * "VARCHAR(10) ASCII BINARY"   -> CHARACTER SET latin1 COLLATE latin1_bin
          * "VARCHAR(10) BINARY ASCII"   -> CHARACTER SET latin1 COLLATE latin1_bin
          * "VARCHAR(10) UNICODE BINARY" -> CHARACTER SET ucs2 COLLATE ucs2_bin
          * "VARCHAR(10) BINARY UNICODE" -> CHARACTER SET ucs2 COLLATE ucs2_bin
          Previously these four aliases returned the error
          "This version of MySQL does not yet support return value collation".
      
      Note:
      
         This patch allows  "VARCHAR(10) CHARACTER SET cs COLLATE cl"
         and the above four aliases.
      
         "VARCHAR(10) COLLATE cl" is still not allowed
         i.e. when COLLATE is given without CHARACTER SET.
         If we want to support this, we need an architecture decision
         which character set to use by default.
      f3d89b2a
  29. 03 Nov, 2009 1 commit
    • Alfranio Correia's avatar
      WL#2687 WL#5072 BUG#40278 BUG#47175 · 19c380aa
      Alfranio Correia authored
      Non-transactional updates that take place inside a transaction present problems
      for logging because they are visible to other clients before the transaction
      is committed, and they are not rolled back even if the transaction is rolled
      back. It is not always possible to log correctly in statement format when both
      transactional and non-transactional tables are used in the same transaction.
      
      In the current patch, we ensure that such scenario is completely safe under the
      ROW and MIXED modes.
      19c380aa
  30. 16 Oct, 2009 1 commit
    • Georgi Kodinov's avatar
      Bug #40877: multi statement execution fails in 5.1.30 · 7b4ef910
      Georgi Kodinov authored
            
      Implemented the server infrastructure for the fix:
      
      1. Added a function LEX_STRING *thd_query_string(THD) to return
      a LEX_STRING structure instead of char *.
      This is the function that must be called in innodb instead of 
      thd_query()
      
      2. Did some encapsulation in THD : aggregated thd_query and 
      thd_query_length into a LEX_STRING and made accessor and mutator 
      methods for easy code updating. 
      
      3. Updated the server code to use the new methods where applicable.
      7b4ef910
  31. 14 Oct, 2009 1 commit
    • Konstantin Osipov's avatar
      Backport of: · 9b41c753
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2617.22.5
      committer: Konstantin Osipov <kostja@sun.com>
      branch nick: mysql-6.0-runtime
      timestamp: Tue 2009-01-27 05:08:48 +0300
      message:
        Remove non-prefixed use of HASH.
        Always use my_hash_init(), my_hash_inited(), my_hash_search(),
        my_hash_element(), my_hash_delete(), my_hash_free() rather
        than non-prefixed counterparts (hash_init(), etc).
        Remove the backward-compatible defines.
      9b41c753
  32. 10 Sep, 2009 1 commit
    • Marc Alff's avatar
      WL#2110 (SIGNAL) · 63e56390
      Marc Alff authored
      WL#2265 (RESIGNAL)
      
      Manual merge of SIGNAL and RESIGNAL to mysql-trunk-signal,
      plus required dependencies.
      63e56390
  33. 28 Jul, 2009 1 commit
    • Alfranio Correia's avatar
      BUG#41166 stored function requires "deterministic" if binlog_format is "statement" · 043e09b5
      Alfranio Correia authored
      If the log_bin_trust_function_creators option is not defined, creating a stored
      function requires either one of the modifiers DETERMINISTIC, NO SQL, or READS
      SQL DATA. Executing a stored function should also follows the same rules if in
      STATEMENT mode. However, this was not happening and a wrong error was being
      printed out: ER_BINLOG_ROW_RBR_TO_SBR.
      
      The patch makes the creation and execution compatible and prints out the correct
      error ER_BINLOG_UNSAFE_ROUTINE when a stored function without one of the modifiers
      above is executed in STATEMENT mode.
      043e09b5
  34. 16 Jul, 2009 1 commit
  35. 14 Jul, 2009 1 commit
    • Sven Sandberg's avatar
      BUG#39934: Slave stops for engine that only support row-based logging · 41783de5
      Sven Sandberg authored
      General overview:
      The logic for switching to row format when binlog_format=MIXED had
      numerous flaws. The underlying problem was the lack of a consistent
      architecture.
      General purpose of this changeset:
      This changeset introduces an architecture for switching to row format
      when binlog_format=MIXED. It enforces the architecture where it has
      to. It leaves some bugs to be fixed later. It adds extensive tests to
      verify that unsafe statements work as expected and that appropriate
      errors are produced by problems with the selection of binlog format.
      It was not practical to split this into smaller pieces of work.
      
      Problem 1:
      To determine the logging mode, the code has to take several parameters
      into account (namely: (1) the value of binlog_format; (2) the
      capabilities of the engines; (3) the type of the current statement:
      normal, unsafe, or row injection). These parameters may conflict in
      several ways, namely:
       - binlog_format=STATEMENT for a row injection
       - binlog_format=STATEMENT for an unsafe statement
       - binlog_format=STATEMENT for an engine only supporting row logging
       - binlog_format=ROW for an engine only supporting statement logging
       - statement is unsafe and engine does not support row logging
       - row injection in a table that does not support statement logging
       - statement modifies one table that does not support row logging and
         one that does not support statement logging
      Several of these conflicts were not detected, or were detected with
      an inappropriate error message. The problem of BUG#39934 was that no
      appropriate error message was written for the case when an engine
      only supporting row logging executed a row injection with
      binlog_format=ROW. However, all above cases must be handled.
      Fix 1:
      Introduce new error codes (sql/share/errmsg.txt). Ensure that all
      conditions are detected and handled in decide_logging_format()
      
      Problem 2:
      The binlog format shall be determined once per statement, in
      decide_logging_format(). It shall not be changed before or after that.
      Before decide_logging_format() is called, all information necessary to
      determine the logging format must be available. This principle ensures
      that all unsafe statements are handled in a consistent way.
      However, this principle is not followed:
      thd->set_current_stmt_binlog_row_based_if_mixed() is called in several
      places, including from code executing UPDATE..LIMIT,
      INSERT..SELECT..LIMIT, DELETE..LIMIT, INSERT DELAYED, and
      SET @@binlog_format. After Problem 1 was fixed, that caused
      inconsistencies where these unsafe statements would not print the
      appropriate warnings or errors for some of the conflicts.
      Fix 2:
      Remove calls to THD::set_current_stmt_binlog_row_based_if_mixed() from
      code executed after decide_logging_format(). Compensate by calling the
      set_current_stmt_unsafe() at parse time. This way, all unsafe statements
      are detected by decide_logging_format().
      
      Problem 3:
      INSERT DELAYED is not unsafe: it is logged in statement format even if
      binlog_format=MIXED, and no warning is printed even if
      binlog_format=STATEMENT. This is BUG#45825.
      Fix 3:
      Made INSERT DELAYED set itself to unsafe at parse time. This allows
      decide_logging_format() to detect that a warning should be printed or
      the binlog_format changed.
      
      Problem 4:
      LIMIT clause were not marked as unsafe when executed inside stored
      functions/triggers/views/prepared statements. This is
      BUG#45785.
      Fix 4:
      Make statements containing the LIMIT clause marked as unsafe at
      parse time, instead of at execution time. This allows propagating
      unsafe-ness to the view.
      
      
      mysql-test/extra/rpl_tests/create_recursive_construct.inc:
        Added auxiliary file used by binlog_unsafe.test to create and
        execute recursive constructs
        (functions/procedures/triggers/views/prepared statements).
      mysql-test/extra/rpl_tests/rpl_foreign_key.test:
        removed unnecessary set @@session.binlog_format
      mysql-test/extra/rpl_tests/rpl_insert_delayed.test:
        Filter out table id from table map events in binlog listing.
        Got rid of $binlog_format_statement.
      mysql-test/extra/rpl_tests/rpl_ndb_apply_status.test:
        disable warnings around call to unsafe procedure
      mysql-test/include/rpl_udf.inc:
        Disabled warnings for code that generates warnings
        for some binlog formats. That would otherwise cause
        inconsistencies in the result file.
      mysql-test/r/mysqldump.result:
        Views are now unsafe if they contain a LIMIT clause.
        That fixed BUG#45831. Due to BUG#45832, a warning is
        printed for the CREATE VIEW statement.
      mysql-test/r/sp_trans.result:
        Unsafe statements in stored procedures did not give a warning if
        binlog_format=statement. This is BUG#45824. Now they do, so this
        result file gets a new warning.
      mysql-test/suite/binlog/r/binlog_multi_engine.result:
        Error message changed.
      mysql-test/suite/binlog/r/binlog_statement_insert_delayed.result:
        INSERT DELAYED didn't generate a warning when binlog_format=STATEMENT.
        That was BUG#45825. Now there is a warning, so result file needs to be
        updated.
      mysql-test/suite/binlog/r/binlog_stm_ps.result:
        Changed error message.
      mysql-test/suite/binlog/r/binlog_unsafe.result:
        updated result file:
         - error message changed
         - added test for most combinations of unsafe constructs invoked
           from recursive constructs
         - INSERT DELAYED now gives a warning (because BUG#45826 is fixed)
         - INSERT..SELECT..LIMIT now gives a warning from inside recursive
           constructs (because BUG#45785 was fixed)
         - When a recursive construct (e.g., stored proc or function)
           contains more than one statement, at least one of which is
           unsafe, then all statements in the recursive construct give
           warnings. This is a new bug introduced by this changeset.
           It will be addressed in a post-push fix.
      mysql-test/suite/binlog/t/binlog_innodb.test:
        Changed error code for innodb updates with READ COMMITTED or 
        READ UNCOMMITTED transaction isolation level and
        binlog_format=statement.
      mysql-test/suite/binlog/t/binlog_multi_engine.test:
        The error code has changed for statements where more than one
        engine is involved and one of them is self-logging.
      mysql-test/suite/binlog/t/binlog_unsafe-master.opt:
        Since binlog_unsafe now tests unsafe-ness of UDF's, we need an extra
        flag in the .opt file.
      mysql-test/suite/binlog/t/binlog_unsafe.test:
         - Clarified comment.
         - Rewrote first part of test. Now it tests not only unsafe variables
           and functions, but also unsafe-ness due to INSERT..SELECT..LIMIT,
           INSERT DELAYED, insert into two autoinc columns, use of UDF's, and
           access to log tables in the mysql database.
           Also, in addition to functions, procedures, triggers, and prepared
           statements, it now also tests views; and it constructs recursive
           calls in two levels by combining these recursive constructs.
           Part of the logic is in extra/rpl_tests/create_recursive_construct.inc.
         - added tests for all special system variables that should not be unsafe.
         - added specific tests for BUG#45785 and BUG#45825
      mysql-test/suite/rpl/r/rpl_events.result:
        updated result file
      mysql-test/suite/rpl/r/rpl_extraColmaster_innodb.result:
        updated result file
      mysql-test/suite/rpl/r/rpl_extraColmaster_myisam.result:
        updated result file
      mysql-test/suite/rpl/r/rpl_foreign_key_innodb.result:
        updated result file
      mysql-test/suite/rpl/r/rpl_idempotency.result:
        updated result file
      mysql-test/suite/rpl/r/rpl_mix_found_rows.result:
        Split rpl_found_rows.test into rpl_mix_found_rows.test (a new file) and
        rpl_stm_found_rows.test (renamed rpl_found_rows.test). This file equals
        the second half of the old rpl_found_rows.result, with the following
        modifications:
         - minor formatting changes
         - additional initialization
      mysql-test/suite/rpl/r/rpl_mix_insert_delayed.result:
        Moved out code operating in mixed mode from rpl_stm_insert_delayed
        (into rpl_mix_insert_delayed) and got rid of explicit setting of
        binlog format.
      mysql-test/suite/rpl/r/rpl_rbr_to_sbr.result:
        updated result file
      mysql-test/suite/rpl/r/rpl_row_idempotency.result:
        Moved the second half of rpl_idempotency.test, which only
        executed in row mode, to rpl_row_idempotency.test. This is
        the new result file.
      mysql-test/suite/rpl/r/rpl_row_insert_delayed.result:
        Got rid of unnecessary explicit setting of binlog format.
      mysql-test/suite/rpl/r/rpl_stm_found_rows.result:
        Split rpl_found_rows.test into rpl_mix_found_rows.test (a new file) and
        rpl_stm_found_rows.test (renamed rpl_found_rows.test). Changes in
        this file:
         - minor formatting changes
         - warning is now issued for unsafe statements inside procedures
           (since BUG#45824 is fixed)
         - second half of file is moved to rpl_mix_found_rows.result
      mysql-test/suite/rpl/r/rpl_stm_insert_delayed.result:
        Moved out code operating in mixed mode from rpl_stm_insert_delayed
        (into rpl_mix_insert_delayed) and got rid of explicit setting of
        binlog format.
      mysql-test/suite/rpl/r/rpl_stm_loadfile.result:
        error message changed
      mysql-test/suite/rpl/r/rpl_temporary_errors.result:
        updated result file
      mysql-test/suite/rpl/r/rpl_udf.result:
        Remove explicit set of binlog format (and triplicate test execution)
        and rely on test system executing the test in all binlog formats.
      mysql-test/suite/rpl/t/rpl_bug31076.test:
        Test is only valid in mixed or row mode since it generates row events.
      mysql-test/suite/rpl/t/rpl_events.test:
        Removed explicit set of binlog_format and removed duplicate testing.
        Instead, we rely on the test system to try all binlog formats.
      mysql-test/suite/rpl/t/rpl_extraColmaster_innodb.test:
        Removed triplicate testing and instead relying on test system.
        Test is only relevant for row format since statement-based replication
        cannot handle extra columns on master.
      mysql-test/suite/rpl/t/rpl_extraColmaster_myisam.test:
        Removed triplicate testing and instead relying on test system.
        Test is only relevant for row format since statement-based replication
        cannot handle extra columns on master.
      mysql-test/suite/rpl/t/rpl_idempotency-slave.opt:
        Removed .opt file to avoid server restarts.
      mysql-test/suite/rpl/t/rpl_idempotency.test:
        - Moved out row-only tests to a new test file, rpl_row_idempotency.test.
          rpl_idempotency now only contains tests that execute in all
          binlog_formats.
        - While I was here, also removed .opt file to avoid server restarts.
          The slave_exec_mode is now set inside the test instead.
      mysql-test/suite/rpl/t/rpl_mix_found_rows.test:
        Split rpl_found_rows.test into rpl_mix_found_rows.test (a new file) and
        rpl_stm_found_rows.test (renamed rpl_found_rows.test). This file
        contains the second half of the original rpl_found_rows.test with the
        follwing changes:
         - initialization
         - removed SET_BINLOG_FORMAT and added have_binlog_format_mixed.inc
         - minor formatting changes
      mysql-test/suite/rpl/t/rpl_mix_insert_delayed.test:
        Moved out code operating in mixed mode from rpl_stm_insert_delayed
        (into rpl_mix_insert_delayed) and got rid of explicit setting of
        binlog format.
      mysql-test/suite/rpl/t/rpl_rbr_to_sbr.test:
        Test cannot execute in statement mode, since we no longer
        switch to row format when binlog_format=statement.
        Enforced mixed mode throughout the test.
      mysql-test/suite/rpl/t/rpl_row_idempotency.test:
        Moved the second half of rpl_idempotency.test, which only
        executed in row mode, to this new file. We now rely on the
        test system to set binlog format.
      mysql-test/suite/rpl/t/rpl_row_insert_delayed.test:
         - Got rid of unnecessary explicit setting of binlog format.
         - extra/rpl_tests/rpl_insert_delayed.test does not need the
           $binlog_format_statement variable any more, so that was
           removed.
      mysql-test/suite/rpl/t/rpl_slave_skip.test:
        The test switches binlog_format internally and master generates both
        row and statement events. Hence, the slave must be able to log in both
        statement and row format. Hence test was changed to only execute in
        mixed mode.
      mysql-test/suite/rpl/t/rpl_stm_found_rows.test:
        Split rpl_found_rows.test into rpl_mix_found_rows.test (a new file) and
        rpl_stm_found_rows.test (renamed rpl_found_rows.test). Changes in
        this file:
         - minor formatting changes
         - added have_binlog_format_statement and removed SET BINLOG_FORMAT.
         - second half of file is moved to rpl_mix_found_rows.test
         - added cleanup code
      mysql-test/suite/rpl/t/rpl_stm_insert_delayed.test:
        Moved out code operating in mixed mode from rpl_stm_insert_delayed
        (into rpl_mix_insert_delayed) and got rid of explicit setting of
        binlog format.
      mysql-test/suite/rpl/t/rpl_switch_stm_row_mixed.test:
        The test switches binlog_format internally and master generates both
        row and statement events. Hence, the slave must be able to log in both
        statement and row format. Hence test was changed to only execute in
        mixed mode on slave.
      mysql-test/suite/rpl/t/rpl_temporary_errors.test:
        Removed explicit set of binlog format. Instead, the test now only
        executes in row mode.
      mysql-test/suite/rpl/t/rpl_udf.test:
        Remove explicit set of binlog format (and triplicate test execution)
        and rely on test system executing the test in all binlog formats.
      mysql-test/suite/rpl_ndb/combinations:
        Added combinations file for rpl_ndb.
      mysql-test/suite/rpl_ndb/r/rpl_ndb_binlog_format_errors.result:
        new result file
      mysql-test/suite/rpl_ndb/r/rpl_ndb_circular_simplex.result:
        updated result file
      mysql-test/suite/rpl_ndb/t/rpl_ndb_2innodb.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_2myisam.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_basic.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_binlog_format_errors-master.opt:
        new option file
      mysql-test/suite/rpl_ndb/t/rpl_ndb_binlog_format_errors-slave.opt:
        new option file
      mysql-test/suite/rpl_ndb/t/rpl_ndb_binlog_format_errors.test:
        New test case to verify all errors and warnings generated by
        decide_logging_format.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_blob.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_blob2.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_circular.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_circular_simplex.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
        While I was here, also made the test clean up after itself.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_commit_afterflush.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_ctype_ucs2_def.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_delete_nowhere.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_do_db.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_do_table.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_func003.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_innodb_trans.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_insert_ignore.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_mixed_engines_transactions.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_multi_update3.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_rep_ignore.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_row_001.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_sp003.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_sp006.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/suite/rpl_ndb/t/rpl_ndb_trig004.test:
        The test needs slave to be able to switch to row mode, so the
        test was changed to only execute in mixed and row mode.
      mysql-test/t/partition_innodb_stmt.test:
        Changed error code for innodb updates with READ COMMITTED or 
        READ UNCOMMITTED transaction isolation level and
        binlog_format=statement.
      sql/event_db_repository.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/events.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/ha_ndbcluster_binlog.cc:
        reset_current_stmt_binlog_row_based() is not a no-op for the ndb_binlog
        thread any more. Instead, the ndb_binlog thread now forces row mode both
        initially and just after calling mysql_parse.  (mysql_parse() is the only
        place where reset_current_stmt_binlog_row_based() may be called from
        the ndb_binlog thread, so these are the only two places that need to
        change.)
      sql/ha_partition.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/handler.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/item_create.cc:
        Added DBUG_ENTER to some functions, to be able to trace when
        set_stmt_unsafe is called.
      sql/log.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/log_event.cc:
         - Moved logic for changing to row format out of do_apply_event (and into
           decide_logging_format).
         - Added @todo comment for post-push cleanup.
      sql/log_event_old.cc:
        Move logic for changing to row format out of do_apply_event (and into
        decide_logging_format).
      sql/mysql_priv.h:
        Make decide_logging_format() a member of the THD class, for two reasons:
         - It is natural from an object-oriented perspective.
         - decide_logging_format() needs to access private members of THD
           (specifically, the new binlog_warning_flags field).
      sql/rpl_injector.cc:
        Removed call to set_current_stmt_binlog_row_based().
        From now on, only decide_logging_fromat is allowed to modify
        current_stmt_binlog_row_based. This call is from the ndb_binlog
        thread, mostly executing code in ha_ndbcluster_binlog.cc.
        This call can be safely removed, because:
         - current_stmt_binlog_row_based is initialized for the ndb_binlog
           thread's THD object when the THD object is created. So we're
           not going to read uninitialized memory.
         - The behavior of ndb_binlog thread does not use the state of the
           current_stmt_binlog_row_based. It is conceivable that the
           ndb_binlog thread would rely on the current_stmt_binlog_format
           in two situations:
            (1) when it calls mysql_parse;
            (2) when it calls THD::binlog_query.
           In case (1), it always clears THD::options&OPTION_BIN_LOG (because
           run_query() in ha_ndbcluster_binlog.cc is only called with
           disable_binlogging = TRUE).
           In case (2), it always uses qtype=STMT_QUERY_TYPE.
      sql/set_var.cc:
        Added @todo comment for post-push cleanup.
      sql/share/errmsg.txt:
        Added new error messages and clarified ER_BINLOG_UNSAFE_STATEMENT.
      sql/sp.cc:
        Added DBUG_ENTER, to be able to trace when set_stmt_unsafe is called.
        Got rid of MYSQL_QUERY_TYPE: it was equivalent to STMT_QUERY_TYPE.
      sql/sp_head.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/sp_head.h:
        Added DBUG_ENTER, to be able to trace when set_stmt_unsafe is called.
      sql/sql_acl.cc:
        Got rid of MYSQL_QUERY_TYPE: it was equivalent to STMT_QUERY_TYPE.
      sql/sql_base.cc:
         - Made decide_logging_format take care of all logic for deciding the
           logging format, and for determining the related warnings and errors.
           See comment above decide_logging_format for details.
         - Made decide_logging_format a member function of THD, since it needs
           to access private members of THD and since its purpose is to update
           the state of a THD object.
         - Added DBUG_ENTER, to be able to trace when set_stmt_unsafe is called.
      sql/sql_class.cc:
        - Moved logic for determining unsafe warnings away from THD::binlog_query
          (and into decide_logging_format()). Now, it works like this:
          1. decide_logging_format detects that the current statement shall
             produce a warning, if it ever makes it to the binlog
          2. decide_logging_format sets a flag of THD::binlog_warning_flags.
          3. THD::binlog_query reads the flag. If the flag is set, it generates
             a warning.
        - Use member function to read current_stmt_binlog_row_based.
      sql/sql_class.h:
        - Added THD::binlog_warning_flags (see sql_class.cc for explanation).
        - Made decide_logging_format() and reset_for_next_command() member
          functions of THD (instead of standalone functions). This was needed
          for two reasons: (1) the functions need to access the private member
          THD::binlog_warning_flags; (2) the purpose of these functions is to
          update the staet of a THD object, so from an object-oriented point
          of view they should be member functions.
        - Encapsulated current_stmt_binlog_row_based, so it is now private and
          can only be accessed from a member function. Also changed the
          data type to an enumeration instead of a bool.
        - Removed MYSQL_QUERY_TYPE, because it was equivalent to
          STMT_QUERY_TYPE anyways.
        - When reset_current_stmt_binlog_row_based was called from the
          ndb_binlog thread, it would behave as a no-op. This special
          case has been removed, and the behavior of
          reset_current_stmt_binlog_row_based does not depend on which thread
          calls it any more. The special case did not serve any purpose,
          since the ndb binlog thread did not take the
          current_stmt_binlog_row_based flag into account anyways.
      sql/sql_delete.cc:
        - Moved logic for setting row format for DELETE..LIMIT away from
          mysql_prepare_delete.
          (Instead, we mark the statement as unsafe at parse time (sql_yacc.yy)
          and rely on decide_logging_format() (sql_class.cc) to set row format.)
          This is part of the fix for BUG#45831.
        - Use member function to read current_stmt_binlog_row_based.
      sql/sql_insert.cc:
         - Removed unnecessary calls to thd->lex->set_stmt_unsafe() and
           thd->set_current_stmt_binlog_row_based_if_mixed() from
           handle_delayed_insert(). The calls are unnecessary because they
           have already been made; they were made in the constructor of
           the `di' object.
         - Since decide_logging_format() is now a member function of THD, code
           that calls decide_logging_format() had to be updated.
         - Added DBUG_ENTER call, to be able to trace when set_stmt_unsafe is
           called.
         - Moved call to set_stmt_unsafe() for INSERT..SELECT..LIMIT away from
           mysql_insert_select_prepare() (and into decide_logging_format).
           This is part of the fix for BUG#45831.
         - Use member function to read current_stmt_binlog_row_based.
      sql/sql_lex.h:
         - Added the flag BINLOG_STMT_FLAG_ROW_INJECTION to enum_binlog_stmt_flag.
           This was necessary so that a statement can identify itself as a row
           injection.
         - Added appropriate setter and getter functions for the new flag.
         - Added or clarified some comments.
         - Added DBUG_ENTER()
      sql/sql_load.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/sql_parse.cc:
         - Made mysql_reset_thd_for_next_command() clear thd->binlog_warning_flags.
         - Since thd->binlog_warning_flags is private, it must be set in a
           member function of THD. Hence, moved the body of
           mysql_reset_thd_for_next_command() to the new member function
           THD::reset_thd_for_next_command(), and made
           mysql_reset_thd_for_next_command() call
           THD::reset_thd_for_next_command().
         - Removed confusing comment.
         - Use member function to read current_stmt_binlog_row_based.
      sql/sql_repl.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/sql_table.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/sql_udf.cc:
        Use member function to read current_stmt_binlog_row_based.
      sql/sql_update.cc:
        Moved logic for setting row format for UPDATE..LIMIT away from
        mysql_prepare_update.
        (Instead, we mark the statement as unsafe at parse time (sql_yacc.yy)
        and rely on decide_logging_format() (sql_class.cc) to set row format.)
        This is part of the fix for BUG#45831.
      sql/sql_yacc.yy:
        Made INSERT DELAYED, INSERT..SELECT..LIMIT, UPDATE..LIMIT, and
        DELETE..LIMIT mark themselves as unsafe at parse time (instead
        of at execution time).
        This is part of the fixes BUG#45831 and BUG#45825.
      storage/example/ha_example.cc:
        Made exampledb accept inserts. This was needed by the new test case
        rpl_ndb_binlog_format_errors, because it needs an engine that
        is statement-only (and accepts inserts).
      storage/example/ha_example.h:
        Made exampledb a statement-only engine instead of a row-only engine.
        No existing test relied exampledb's row-only capabilities. The new
        test case rpl_ndb_binlog_format_errors needs an engine that is
        statement-only.
      storage/innobase/handler/ha_innodb.cc:
        - Changed error error code and message given by innodb when 
          binlog_format=STATEMENT and transaction isolation level is
          READ COMMITTED or READ UNCOMMITTED.
        - While I was here, also simplified the condition for
          checking when to give the error.
      41783de5
  36. 30 May, 2009 1 commit
    • He Zhenxing's avatar
      BUG#41948 Query_log_event constructor needlessly contorted · abf5f8da
      He Zhenxing authored
      Make the caller of Query_log_event, Execute_load_log_event
      constructors and THD::binlog_query to provide the error code
      instead of having the constructors to figure out the error code.
      
      sql/log_event.cc:
        Changed constructors of Query_log_event and Execute_load_log_event to accept the error code argument instead of figuring it out by itself
      sql/log_event.h:
        Changed constructors of Query_log_event and Execute_load_log_event to accept the error code argument
      abf5f8da
  37. 29 May, 2009 1 commit
    • Kristofer Pettersson's avatar
      Bug#44658 Create procedure makes server crash when user does not have ALL privilege · 66e0ee66
      Kristofer Pettersson authored
      MySQL crashes if a user without proper privileges attempts to create a procedure.
      
      The crash happens because more than one error state is pushed onto the Diagnostic
      area. In this particular case the user is denied to implicitly create a new user
      account with the implicitly granted privileges ALTER- and EXECUTE ROUTINE.
      
      The new account is needed if the original user account contained a host mask.
      A user account with a host mask is a distinct user account in this context.
      An alternative would be to first get the most permissive user account which
      include the current user connection and then assign privileges to that
      account. This behavior change is considered out of scope for this bug patch.
      
      The implicit assignment of privileges when a user creates a stored routine is a
      considered to be a feature for user convenience and as such it is not
      a critical operation. Any failure to complete this operation is thus considered
      non-fatal (an error becomes a warning).
      
      The patch back ports a stack implementation of the internal error handler interface.
      This enables the use of multiple error handlers so that it is possible to intercept
      and cancel errors thrown by lower layers. This is needed as a error handler already
      is used in the call stack emitting the errors which needs to be converted.
      
      
      mysql-test/r/grant.result:
        * Added test case for bug44658
      mysql-test/t/grant.test:
        * Added test case for bug44658
      sql/sp.cc:
        * Removed non functional parameter no_error and my_error calls as all errors
          from this function will be converted to a warning anyway.
        * Change function return type from int to bool.
      sql/sp.h:
        * Removed non functional parameter no_error and my_error calls as all errors
          from this function will be converted to a warning anyway.
        * Changed function return value from int to bool
      sql/sql_acl.cc:
        * Removed the non functional no_error parameter from the function prototype.
          The function is called from two places and in one of the places we now 
          ignore errors through error handlers.
        * Introduced the parameter write_to_binlog
        * Introduced an error handler to cancel any error state from mysql_routine_grant.
        * Moved my_ok() signal from mysql_routine_grant to make it easier to avoid
          setting the wrong state in the Diagnostic area.
        * Changed the broken error state in sp_grant_privileges() to a warning
          so that if "CREATE PROCEDURE" fails because "Password hash isn't a hexidecimal
          number" it is still clear what happened.
      sql/sql_acl.h:
        * Removed the non functional no_error parameter from the function prototype.
          The function is called from two places and in one of the places we now 
          ignore errors through error handlers.
        * Introduced the parameter write_to_binlog
        * Changed return type for sp_grant_privileges() from int to bool
      sql/sql_class.cc:
        * Back ported implementation of internal error handler from 6.0 branch
      sql/sql_class.h:
        * Back ported implementation of internal error handler from 6.0 branch
      sql/sql_parse.cc:
        * Moved my_ok() signal from mysql_routine_grant() to make it easier to avoid
          setting the wrong state in the Diagnostic area.
      66e0ee66