An error occurred fetching the project authors.
  1. 12 Feb, 2010 1 commit
    • unknown's avatar
      Bug #43913 rpl_cross_version can't pass on conflicts complainig clash with · 97afccae
      unknown authored
      --slave-load-tm
            
      The MDL_SHARED lock was introduced for an object in 5.4, but the 'TABLE_LIST' 
      object was not initialized with the MDL_SHARED lock when applying event with 
      LOAD DATA INFILE into table. So the failure is caused when checking the 
      MDL_SHARED lock for the object.
      To fix the problem, the 'TABLE_LIST' object was initialized with the MDL_SHARED 
      lock when applying event with LOAD DATA INFILE into table.
      
      
      mysql-test/suite/rpl/t/disabled.def:
        Got rid of the line for enabling 'rpl_cross_version' test.
      97afccae
  2. 01 Feb, 2010 1 commit
  3. 24 Dec, 2009 1 commit
  4. 04 Dec, 2009 1 commit
    • Konstantin Osipov's avatar
      Backport of revno ## 2617.31.1, 2617.31.3, 2617.31.4, 2617.31.5, · a14bbee5
      Konstantin Osipov authored
      2617.31.12, 2617.31.15, 2617.31.15, 2617.31.16, 2617.43.1
      - initial changeset that introduced the fix for 
      Bug#989 and follow up fixes for all test suite failures
      introduced in the initial changeset. 
      ------------------------------------------------------------
      revno: 2617.31.1
      committer: Davi Arnaut <Davi.Arnaut@Sun.COM>
      branch nick: 4284-6.0
      timestamp: Fri 2009-03-06 19:17:00 -0300
      message:
      Bug#989: If DROP TABLE while there's an active transaction, wrong binlog order
      WL#4284: Transactional DDL locking
      
      Currently the MySQL server does not keep metadata locks on
      schema objects for the duration of a transaction, thus failing
      to guarantee the integrity of the schema objects being used
      during the transaction and to protect then from concurrent
      DDL operations. This also poses a problem for replication as
      a DDL operation might be replicated even thought there are
      active transactions using the object being modified.
      
      The solution is to defer the release of metadata locks until
      a active transaction is either committed or rolled back. This
      prevents other statements from modifying the table for the
      entire duration of the transaction. This provides commitment
      ordering for guaranteeing serializability across multiple
      transactions.
      
      - Incompatible change:
      
      If MySQL's metadata locking system encounters a lock conflict,
      the usual schema is to use the try and back-off technique to
      avoid deadlocks -- this schema consists in releasing all locks
      and trying to acquire them all in one go.
      
      But in a transactional context this algorithm can't be utilized
      as its not possible to release locks acquired during the course
      of the transaction without breaking the transaction commitments.
      To avoid deadlocks in this case, the ER_LOCK_DEADLOCK will be
      returned if a lock conflict is encountered during a transaction.
      
      Let's consider an example:
      
      A transaction has two statements that modify table t1, then table
      t2, and then commits. The first statement of the transaction will
      acquire a shared metadata lock on table t1, and it will be kept
      utill COMMIT to ensure serializability.
      
      At the moment when the second statement attempts to acquire a
      shared metadata lock on t2, a concurrent ALTER or DROP statement
      might have locked t2 exclusively. The prescription of the current
      locking protocol is that the acquirer of the shared lock backs off
      -- gives up all his current locks and retries. This implies that
      the entire multi-statement transaction has to be rolled back.
      
      - Incompatible change:
      
      FLUSH commands such as FLUSH PRIVILEGES and FLUSH TABLES WITH READ
      LOCK won't cause locked tables to be implicitly unlocked anymore.
      
      
      mysql-test/extra/binlog_tests/drop_table.test:
        Add test case for Bug#989.
      mysql-test/extra/binlog_tests/mix_innodb_myisam_binlog.test:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction.
      mysql-test/include/mix1.inc:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction.
      mysql-test/include/mix2.inc:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction.
      mysql-test/r/flush_block_commit.result:
        Update test case result (WL#4284).
      mysql-test/r/flush_block_commit_notembedded.result:
        Update test case result (WL#4284).
      mysql-test/r/innodb.result:
        Update test case result (WL#4284).
      mysql-test/r/innodb_mysql.result:
        Update test case result (WL#4284).
      mysql-test/r/lock.result:
        Add test case result for an effect of WL#4284/Bug#989
        (all locks should be released when a connection terminates).
      mysql-test/r/mix2_myisam.result:
        Update test case result (effects of WL#4284/Bug#989).
      mysql-test/r/not_embedded_server.result:
        Update test case result (effects of WL#4284/Bug#989).
        Add a test case for interaction of WL#4284 and FLUSH PRIVILEGES.
      mysql-test/r/partition_innodb_semi_consistent.result:
        Update test case result (effects of WL#4284/Bug#989).
      mysql-test/r/partition_sync.result:
        Temporarily disable the test case for Bug#43867,
        which will be fixed by a subsequent backport.
      mysql-test/r/ps.result:
        Add a test case for effect of PREPARE on transactional
        locks: we take a savepoint at beginning of PREAPRE
        and release it at the end. Thus PREPARE does not 
        accumulate metadata locks (Bug#989/WL#4284).
      mysql-test/r/read_only_innodb.result:
        Update test case result (effects of WL#4284/Bug#989).
      mysql-test/suite/binlog/r/binlog_row_drop_tbl.result:
        Add a test case result (WL#4284/Bug#989).
      mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result:
        Update test case result (effects of WL#4284/Bug#989).
      mysql-test/suite/binlog/r/binlog_stm_drop_tbl.result:
        Add a test case result (WL#4284/Bug#989).
      mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result:
        Update test case result (effects of WL#4284/Bug#989).
      mysql-test/suite/binlog/r/binlog_unsafe.result:
        A side effect of Bug#989 -- slightly different table map ids.
      mysql-test/suite/binlog/t/binlog_row_drop_tbl.test:
        Add a test case for WL#4284/Bug#989.
      mysql-test/suite/binlog/t/binlog_stm_drop_tbl.test:
        Add a test case for WL#4284/Bug#989.
      mysql-test/suite/binlog/t/binlog_stm_row.test:
        Update to the new state name. This
        is actually a follow up to another patch for WL#4284, 
        that changes Locked thread state to Table lock.
      mysql-test/suite/ndb/r/ndb_index_ordered.result:
        Remove result for disabled part of the test case.
      mysql-test/suite/ndb/t/disabled.def:
        Temporarily disable a test case (Bug#45621).
      mysql-test/suite/ndb/t/ndb_index_ordered.test:
        Disable a part of a test case (needs update to
        reflect semantics of Bug#989).
      mysql-test/suite/rpl/t/disabled.def:
        Disable tests made meaningless by transactional metadata
        locking.
      mysql-test/suite/sys_vars/r/autocommit_func.result:
        Add a commit (Bug#989).
      mysql-test/suite/sys_vars/t/autocommit_func.test:
        Add a commit (Bug#989).
      mysql-test/t/flush_block_commit.test:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction.
      mysql-test/t/flush_block_commit_notembedded.test:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction.
        Add a test case for transaction-scope locks and the global
        read lock (Bug#989/WL#4284).
      mysql-test/t/innodb.test:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction
        (effects of Bug#989/WL#4284).
      mysql-test/t/lock.test:
        Add a test case for Bug#989/WL#4284.
      mysql-test/t/not_embedded_server.test:
        Add a test case for Bug#989/WL#4284.
      mysql-test/t/partition_innodb_semi_consistent.test:
        Replace TRUNCATE with DELETE, to not issue
        an implicit commit of a transaction, and not depend
        on metadata locks.
      mysql-test/t/partition_sync.test:
        Temporarily disable the test case for Bug#43867,
        which needs a fix to be backported from 6.0.
      mysql-test/t/ps.test:
        Add a test case for semantics of PREPARE and transaction-scope
        locks: metadata locks on tables used in PREPARE are enclosed into a
        temporary savepoint, taken at the beginning of PREPARE,
        and released at the end. Thus PREPARE does not effect
        what locks a transaction owns.
      mysql-test/t/read_only_innodb.test:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction 
        (Bug#989/WL#4284).
        
        Wait for the read_only statement to actually flush tables before
        sending other concurrent statements that depend on its state.
      mysql-test/t/xa.test:
        Fix test case to reflect the fact that transactions now hold
        metadata locks for the duration of a transaction 
        (Bug#989/WL#4284).
      sql/ha_ndbcluster_binlog.cc:
        Backport bits of changes of ha_ndbcluster_binlog.cc
        from 6.0, to fix the failing binlog test suite with
        WL#4284. WL#4284 implementation does not work
        with 5.1 implementation of ndbcluster binlog index.
      sql/log_event.cc:
        Release metadata locks after issuing a commit.
      sql/mdl.cc:
        Style changes (WL#4284).
      sql/mysql_priv.h:
        Rename parameter to match the name used in the definition (WL#4284).
      sql/rpl_injector.cc:
        Release metadata locks on commit (WL#4284).
      sql/rpl_rli.cc:
        Remove assert made meaningless, metadata locks are released
        at the end of the transaction.
      sql/set_var.cc:
        Close tables and release locks if autocommit mode is set.
      sql/slave.cc:
        Release metadata locks after a rollback.
      sql/sql_acl.cc:
        Don't implicitly unlock locked tables. Issue a implicit commit
        at the end and unlock tables.
      sql/sql_base.cc:
        Defer the release of metadata locks when closing tables
        if not required to.
        Issue a deadlock error if the locking protocol requires
        that a transaction re-acquire its locks.
        
        Release metadata locks when closing tables for reopen.
      sql/sql_class.cc:
        Release metadata locks if the thread is killed.
      sql/sql_parse.cc:
        Release metadata locks after implicitly committing a active
        transaction, or after explicit commits or rollbacks.
      sql/sql_plugin.cc:
        
        Allocate MDL request on the stack as the use of the table
        is contained within the function. It will be removed from
        the context once close_thread_tables is called at the end
        of the function.
      sql/sql_prepare.cc:
        The problem is that the prepare phase of the CREATE TABLE
        statement takes a exclusive metadata lock lock and this can
        cause a self-deadlock the thread already holds a shared lock
        on the table being that should be created.
        
        The solution is to make the prepare phase take a shared
        metadata lock when preparing a CREATE TABLE statement. The
        execution of the statement will still acquire a exclusive
        lock, but won't cause any problem as it issues a implicit
        commit.
        
        After some discussions with stakeholders it has been decided that
        metadata locks acquired during a PREPARE statement must be released
        once the statement is prepared even if it is prepared within a multi
        statement transaction.
      sql/sql_servers.cc:
        Don't implicitly unlock locked tables. Issue a implicit commit
        at the end and unlock tables.
      sql/sql_table.cc:
        Close table and release metadata locks after a admin operation.
      sql/table.h:
        The problem is that the prepare phase of the CREATE TABLE
        statement takes a exclusive metadata lock lock and this can
        cause a self-deadlock the thread already holds a shared lock
        on the table being that should be created.
        
        The solution is to make the prepare phase take a shared
        metadata lock when preparing a CREATE TABLE statement. The
        execution of the statement will still acquire a exclusive
        lock, but won't cause any problem as it issues a implicit
        commit.
      sql/transaction.cc:
        Release metadata locks after the implicitly committed due
        to a new transaction being started. Also, release metadata
        locks acquired after a savepoint if the transaction is rolled
        back to the save point.
        
        The problem is that in some cases transaction-long metadata locks
        could be released before the transaction was committed. This could
        happen when a active transaction was ended by a "START TRANSACTION"
        or "BEGIN" statement, in which case the metadata locks would be
        released before the actual commit of the active transaction.
        
        The solution is to defer the release of metadata locks to after the
        transaction has been implicitly committed. No test case is provided
        as the effort to provide one is too disproportional to the size of
        the fix.
      a14bbee5
  5. 01 Dec, 2009 1 commit
  6. 30 Nov, 2009 1 commit
    • Konstantin Osipov's avatar
      Initial import of WL#3726 "DDL locking for all metadata objects". · eff3780d
      Konstantin Osipov authored
      Backport of:
      ------------------------------------------------------------
      revno: 2630.4.1
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Fri 2008-05-23 17:54:03 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      ------------------------------------------------------------
      
      This is the first patch in series. It transforms the metadata 
      locking subsystem to use a dedicated module (mdl.h,cc). No 
      significant changes in the locking protocol. 
      The import passes the test suite with the exception of 
      deprecated/removed 6.0 features, and MERGE tables. The latter
      are subject to a fix by WL#4144.
      Unfortunately, the original changeset comments got lost in a merge,
      thus this import has its own (largely insufficient) comments.
      
      This patch fixes Bug#25144 "replication / binlog with view breaks".
      Warning: this patch introduces an incompatible change:
      Under LOCK TABLES, it's no longer possible to FLUSH a table that 
      was not locked for WRITE.
      Under LOCK TABLES, it's no longer possible to DROP a table or
      VIEW that was not locked for WRITE.
      
      ******
      Backport of:
      ------------------------------------------------------------
      revno: 2630.4.2
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Sat 2008-05-24 14:03:45 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
      ******
      Backport of:
      ------------------------------------------------------------
      revno: 2630.4.3
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Sat 2008-05-24 14:08:51 +0400
      message:
        WL#3726 "DDL locking for all metadata objects"
      
        Fixed failing Windows builds by adding mdl.cc to the lists
        of files needed to build server/libmysqld on Windows.
      
      ******
      Backport of:
      ------------------------------------------------------------
      revno: 2630.4.4
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Sat 2008-05-24 21:57:58 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        Fix for assert failures in kill.test which occured when one
        tried to kill ALTER TABLE statement on merge table while it
        was waiting in wait_while_table_is_used() for other connections
        to close this table.
      
        These assert failures stemmed from the fact that cleanup code
        in this case assumed that temporary table representing new
        version of table was open with adding to THD::temporary_tables
        list while code which were opening this temporary table wasn't
        always fulfilling this.
      
        This patch changes code that opens new version of table to
        always do this linking in. It also streamlines cleanup process
        for cases when error occurs while we have new version of table
        open.
      
      ******
      WL#3726 "DDL locking for all metadata objects"
      Add libmysqld/mdl.cc to .bzrignore.
      ******
      Backport of:
      ------------------------------------------------------------
      revno: 2630.4.6
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Sun 2008-05-25 00:33:22 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        Addition to the fix of assert failures in kill.test caused by
        changes for this worklog.
      
      
      Make sure we close the new table only once.
      
      .bzrignore:
        Add libmysqld/mdl.cc
      libmysqld/CMakeLists.txt:
        Added mdl.cc to the list of files needed for building of libmysqld.
      libmysqld/Makefile.am:
        Added files implementing new meta-data locking subsystem to the server.
      mysql-test/include/handler.inc:
        Use separate connection for waiting while threads performing DDL
        operations conflicting with open HANDLER tables reach blocked
        state. This is required because now we check and close tables open
        by HANDLER statements in this connection conflicting with DDL in
        another each time open_tables() is called and thus select from I_S
        which is used for waiting will unblock DDL operations if issued
        from connection with open HANDLERs.
      mysql-test/r/create.result:
        Adjusted test case after change in implementation of CREATE TABLE
        ... SELECT.  We no longer have special check in open_table() which
        catches the case when we select from the table created. Instead we
        rely on unique_table() call which happens after opening and
        locking all tables.
      mysql-test/r/flush.result:
        FLUSH TABLES WITH READ LOCK can no longer happen under LOCK
        TABLES.  Updated test accordingly.
      mysql-test/r/flush_table.result:
        Under LOCK TABLES we no longer allow to do FLUSH TABLES for tables
        locked for read. Updated test accordingly.
      mysql-test/r/handler_innodb.result:
        Use separate connection for waiting while threads performing DDL
        operations conflicting with open HANDLER tables reach blocked
        state. This is required because now we check and close tables open
        by HANDLER statements in this connection conflicting with DDL in
        another each time open_tables() is called and thus select from I_S
        which is used for waiting will unblock DDL operations if issued
        from connection with open HANDLERs.
      mysql-test/r/handler_myisam.result:
        Use separate connection for waiting while threads performing DDL
        operations conflicting with open HANDLER tables reach blocked
        state. This is required because now we check and close tables open
        by HANDLER statements in this connection conflicting with DDL in
        another each time open_tables() is called and thus select from I_S
        which is used for waiting will unblock DDL operations if issued
        from connection with open HANDLERs.
      mysql-test/r/information_schema.result:
        Additional test for WL#3726 "DDL locking for all metadata
        objects".  Check that we use high-priority metadata lock requests
        when filling I_S tables.
        
        Rearrange tests to match 6.0 better (fewer merge conflicts).
      mysql-test/r/kill.result:
        Added tests checking that DDL and DML statements waiting for
        metadata locks can be interrupted by KILL command.
      mysql-test/r/lock.result:
        One no longer is allowed to do DROP VIEW under LOCK TABLES even if
        this view is locked by LOCK TABLES. The problem is that in such
        situation write locks on view are not mutually exclusive so
        upgrading metadata lock which is required for dropping of view
        will lead to deadlock.
      mysql-test/r/partition_column_prune.result:
        Update results (same results in 6.0), WL#3726
      mysql-test/r/partition_pruning.result:
        Update results (same results in 6.0), WL#3726
      mysql-test/r/ps_ddl.result:
        We no longer invalidate prepared CREATE TABLE ... SELECT statement
        if target table changes. This is OK since it is not strictly
        necessary.
        
        
        The first change is wrong, is caused by FLUSH TABLE
        now flushing all unused tables. This is a regression that
        Dmitri fixed in 6.0 in a follow up patch.
      mysql-test/r/sp.result:
        Under LOCK TABLES we no longer allow accessing views which were
        not explicitly locked. To access view we need to obtain metadata
        lock on it and doing this under LOCK TABLES may lead to deadlocks.
      mysql-test/r/view.result:
        One no longer is allowed to do DROP VIEW under LOCK TABLES even if
        this view is locked by LOCK TABLES. The problem is that in such
        situation even "write locks" on view are not mutually exclusive so
        upgrading metadata lock which is required for dropping of view
        will lead to deadlock
      mysql-test/r/view_grant.result:
        ALTER VIEW implementation was changed to open a view only after
        checking that user which does alter has appropriate privileges on
        it. This means that in case when user's privileges are
        insufficient for this we won't check that new view definer is the
        same as original one or user performing alter has SUPER privilege.
        Adjusted test case accordingly.
      mysql-test/r/view_multi.result:
        Added test case for bug#25144 "replication / binlog with view
        breaks".
      mysql-test/suite/rpl/t/disabled.def:
        Disable test for deprecated features (they don't work with new MDL).
      mysql-test/t/create.test:
        Adjusted test case after change in implementation of CREATE TABLE
        ... SELECT.  We no longer have special check in open_table() which
        catches the case when we select from the table created. Instead we
        rely on unique_table() call which happens after opening and
        locking all tables.
      mysql-test/t/disabled.def:
        Disable merge.test, subject of WL#4144
      mysql-test/t/flush.test:
        
        FLUSH TABLES WITH READ LOCK can no longer happen under LOCK
        TABLES.  Updated test accordingly.
      mysql-test/t/flush_table.test:
        Under LOCK TABLES we no longer allow to do FLUSH TABLES for tables
        locked for read. Updated test accordingly.
      mysql-test/t/information_schema.test:
        Additional test for WL#3726 "DDL locking for all metadata
        objects".  Check that we use high-priority metadata lock requests
        when filling I_S tables.
        
        Rearrange the results for easier merges with 6.0.
      mysql-test/t/kill.test:
        Added tests checking that DDL and DML statements waiting for
        metadata locks can be interrupted by KILL command.
      mysql-test/t/lock.test:
        One no longer is allowed to do DROP VIEW under LOCK TABLES even if
        this view is locked by LOCK TABLES. The problem is that in such
        situation write locks on view are not mutually exclusive so
        upgrading metadata lock which is required for dropping of view
        will lead to deadlock.
      mysql-test/t/lock_multi.test:
        Adjusted test case to the changes of status in various places
        caused by change in implementation FLUSH TABLES WITH READ LOCK,
        which is now takes global metadata lock before flushing tables and
        therefore waits on at these places.
      mysql-test/t/ps_ddl.test:
        We no longer invalidate prepared CREATE TABLE ... SELECT statement
        if target table changes. This is OK since it is not strictly
        necessary.
        
        
        The first change is wrong, is caused by FLUSH TABLE
        now flushing all unused tables. This is a regression that
        Dmitri fixed in 6.0 in a follow up patch.
      mysql-test/t/sp.test:
        Under LOCK TABLES we no longer allow accessing views which were
        not explicitly locked. To access view we need to obtain metadata
        lock on it and doing this under LOCK TABLES may lead to deadlocks.
      mysql-test/t/trigger_notembedded.test:
        Adjusted test case to the changes of status in various places
        caused by change in implementation FLUSH TABLES WITH READ LOCK,
        which is now takes global metadata lock before flushing tables and
        therefore waits on at these places.
      mysql-test/t/view.test:
        One no longer is allowed to do DROP VIEW under LOCK TABLES even if
        this view is locked by LOCK TABLES. The problem is that in such
        situation even "write locks" on view are not mutually exclusive so
        upgrading metadata lock which is required for dropping of view
        will lead to deadlock.
      mysql-test/t/view_grant.test:
        ALTER VIEW implementation was changed to open a view only after
        checking that user which does alter has appropriate privileges on
        it. This means that in case when user's privileges are
        insufficient for this we won't check that new view definer is the
        same as original one or user performing alter has SUPER privilege.
        Adjusted test case accordingly.
      mysql-test/t/view_multi.test:
        Added test case for bug#25144 "replication / binlog with view
        breaks".
      sql/CMakeLists.txt:
        Added mdl.cc to the list of files needed for building of server.
      sql/Makefile.am:
        Added files implementing new meta-data locking subsystem to the
        server.
      sql/event_db_repository.cc:
        
        Allocate metadata lock requests objects (MDL_LOCK) on execution
        memory root in cases when TABLE_LIST objects is also allocated
        there or on stack.
      sql/ha_ndbcluster.cc:
        Adjusted code to work nicely with new metadata locking subsystem.
        close_cached_tables() no longer has wait_for_placeholder argument.
        Instead of relying on this parameter and related behavior FLUSH
        TABLES WITH READ LOCK now takes global shared metadata lock.
      sql/ha_ndbcluster_binlog.cc:
        Adjusted code to work with new metadata locking subsystem.
        close_cached_tables() no longer has wait_for_placeholder argument.
        Instead of relying on this parameter and related behavior FLUSH
        TABLES WITH READ LOCK now takes global shared metadata lock.
      sql/handler.cc:
        update_frm_version():
          Directly update TABLE_SHARE::mysql_version member instead of
          going through all TABLE instances for this table (old code was a
          legacy from pre-table-definition-cache days).
      sql/lock.cc:
        Use new metadata locking subsystem. Threw away most of functions
        related to name locking as now one is supposed to use metadata
        locking API instead.  In lock_global_read_lock() and
        unlock_global_read_lock() in order to avoid problems with global
        read lock sneaking in at the moment when we perform FLUSH TABLES
        or ALTER TABLE under LOCK TABLES and when tables being reopened
        are protected only by metadata locks we also have to take global
        shared meta data lock.
      sql/log_event.cc:
        Adjusted code to work with new metadata locking subsystem.  For
        tables open by slave thread for applying RBR events allocate
        memory for lock request object in the same chunk of memory as
        TABLE_LIST objects for them. In order to ensure that we keep these
        objects around until tables are open always close tables before
        calling Relay_log_info::clear_tables_to_lock(). Use new auxiliary
        Relay_log_info::slave_close_thread_tables() method to enforce
        this.
      sql/log_event_old.cc:
        Adjusted code to work with new metadata locking subsystem.  Since
        for tables open by slave thread for applying RBR events memory for
        lock request object is allocated in the same chunk of memory as
        TABLE_LIST objects for them we have to ensure that we keep these
        objects around until tables are open. To ensure this we always
        close tables before calling
        Relay_log_info::clear_tables_to_lock(). To enfore this we use
        new auxiliary Relay_log_info::slave_close_thread_tables()
        method.
      sql/mdl.cc:
        Implemented new metadata locking subsystem and API described in
        WL3726 "DDL locking for all metadata objects".
      sql/mdl.h:
        Implemented new metadata locking subsystem and API described in
        WL3726 "DDL locking for all metadata objects".
      sql/mysql_priv.h:
        - close_thread_tables()/close_tables_for_reopen() now has one more
          argument which indicates that metadata locks should be released
          but not removed from the context in order to be used later in
          mdl_wait_for_locks() and tdc_wait_for_old_version().
        - close_cached_table() routine is no longer public.
        - Thread waiting in wait_while_table_is_used() can be now killed
          so this function returns boolean to make caller aware of such
          situation.
        - We no longer have  table cache as separate entity instead used
          and unused TABLE instances are linked to TABLE_SHARE objects in
          table definition cache.
        - Now third argument of open_table() is also used for requesting
          table repair or auto-discovery of table's new definition. So its
          type was changed from bool to enum.
        - Added tdc_open_view() function for opening view by getting its
          definition from disk (and table cache in future).
        - reopen_name_locked_table() no longer needs "link_in" argument as
          now we have exclusive metadata locks instead of dummy TABLE
          instances when this function is called.
        - find_locked_table() now takes head of list of TABLE instances
          instead of always scanning through THD::open_tables list. Also
          added find_write_locked_table() auxiliary.
        - reopen_tables(), close_cached_tables() no longer have
          mark_share_as_old and wait_for_placeholder arguments. Instead of
          relying on this parameters and related behavior FLUSH TABLES
          WITH READ LOCK now takes global shared metadata lock.
        - We no longer need drop_locked_tables() and
          abort_locked_tables().
        - mysql_ha_rm_tables() now always assume that LOCK_open is not
          acquired by caller.
        - Added notify_thread_having_shared_lock() callback invoked by
          metadata locking subsystem when acquiring an exclusive lock, for
          each thread that has a conflicting shared metadata lock.
        - Introduced expel_table_from_cache() as replacement for
          remove_table_from_cache() (the main difference is that this new
          function assumes that caller follows metadata locking protocol
          and never waits).
        - Threw away most of functions related to name locking. One should
          use new metadata locking subsystem and API instead.
      sql/mysqld.cc:
        Got rid of call initializing/deinitializing table cache since now
        it is embedded into table definition cache. Added calls for
        initializing/ deinitializing metadata locking subsystem.
      sql/rpl_rli.cc:
        Introduced auxiliary Relay_log_info::slave_close_thread_tables()
        method which is used for enforcing that we always close tables
        open for RBR before deallocating TABLE_LIST elements and MDL_LOCK
        objects for them.
      sql/rpl_rli.h:
        Introduced auxiliary Relay_log_info::slave_close_thread_tables()
        method which is used for enforcing that we always close tables
        open for RBR before deallocating TABLE_LIST elements and MDL_LOCK
        objects for them.
      sql/set_var.cc:
        close_cached_tables() no longer has wait_for_placeholder argument.
        Instead of relying on this parameter and related behavior FLUSH
        TABLES WITH READ LOCK now takes global shared metadata lock.
      sql/sp_head.cc:
        For tables added to the statement's table list by prelocking
        algorithm we allocate these objects either on the same memory as
        corresponding table list elements or on THD::locked_tables_root
        (if we are building table list for LOCK TABLES).
      sql/sql_acl.cc:
        Allocate metadata lock requests objects (MDL_LOCK) on execution
        memory root in cases when we use stack TABLE_LIST objects to open
        tables.  Got rid of redundant code by using unlock_locked_tables()
        function.
      sql/sql_base.cc:
        Changed code to use new MDL subsystem. Got rid of separate table
        cache.  Now used and unused TABLE instances are linked to the
        TABLE_SHAREs in table definition cache.
        
        check_unused():
          Adjusted code to the fact that we no longer have separate table
          cache.  Removed dead code.
        table_def_free():
          Free TABLE instances referenced from TABLE_SHARE objects before
          destroying table definition cache.
        get_table_share():
          Added assert which ensures that noone will be able to access
          table (and its share) without acquiring some kind of metadata
          lock first.
        close_handle_and_leave_table_as_lock():
          Adjusted code to the fact that TABLE instances now are linked to
          list in TABLE_SHARE.
        list_open_tables():
          Changed this function to use table definition cache instead of
          table cache.
        free_cache_entry():
          Unlink freed TABLE elements from the list of all TABLE instances
          for the table in TABLE_SHARE.
        kill_delayed_thread_for_table():
          Added auxiliary for killing delayed insert threads for
          particular table.
        close_cached_tables():
          Got rid of wait_for_refresh argument as we now rely on global
          shared metadata lock to prevent FLUSH WITH READ LOCK sneaking in
          when we are reopening tables. Heavily reworked this function to
          use new MDL code and not to rely on separate table cache entity.
        close_open_tables():
          We no longer have separate table cache.
        close_thread_tables():
          Release metadata locks after closing all tables. Added skip_mdl
          argument which allows us not to remove metadata lock requests
          from the context in case when we are going to use this requests
          later in mdl_wait_for_locks() and tdc_wait_for_old_versions().
        close_thread_table()/close_table_for_reopen():
          Since we no longer have separate table cache and all TABLE
          instances are linked to TABLE_SHARE objects in table definition
          cache we have to link/unlink TABLE object to/from appropriate
          lists in the share.
        name_lock_locked_table():
         Moved redundant code to find_write_locked_table() function and
          adjusted code to the fact that wait_while_table_is_used() can
          now return with an error if our thread is killed.
        reopen_table_entry():
          We no longer need "link_in" argument as with MDL we no longer
          call this function with dummy TABLE object pre-allocated and
          added to the THD::open_tables. Also now we add newly-open TABLE
          instance to the list of share's used TABLE instances.
        table_cache_insert_placeholder():
          Got rid of name-locking legacy.
        lock_table_name_if_not_cached():
          Moved to sql_table.cc the only place where it is used. It was
          also reimplemented using new MDL API.
        open_table():
          - Reworked this function to use new MDL subsystem.
          - Changed code to deal with table definition cache directly
            instead of going through separate table cache.
          - Now third argument is also used for requesting table repair
            or auto-discovery of table's new definition. So its type was
            changed from bool to enum.
        find_locked_table()/find_write_locked_table():
          Accept head of list of TABLE objects as first argument and use
          this list instead of always searching in THD::open_tables list.
          Also added auxiliary for finding write-locked locked tables.
        reopen_table():
          Adjusted function to work with new MDL subsystem and to properly
          manuipulate with lists of used/unused TABLE instaces in
          TABLE_SHARE.
        reopen_tables():
          Removed mark_share_as_old parameter. Instead of relying on it
          and related behavior FLUSH TABLES WITH READ LOCK now takes
          global shared metadata lock. Changed code after removing
          separate table cache.
        drop_locked_tables()/abort_locked_tables():
          Got rid of functions which are no longer needed.
          unlock_locked_tables():
          Moved this function from sql_parse.cc and changed it to release
          memory which was used for allocating metadata lock requests for
          tables open and locked by LOCK TABLES.
        tdc_open_view():
          Intoduced function for opening a view by getting its definition
          from disk (and table cache in future).
        reopen_table_entry():
          Introduced function for opening table definitions while holding
          exclusive metatadata lock on it.
        open_unireg_entry():
         Got rid of this function. Most of its functionality is relocated
          to open_table() and open_table_fini() functions, and some of it
          to reopen_table_entry() and tdc_open_view(). Also code
          resposible for auto-repair and auto-discovery of tables was
          moved to separate function.
        open_table_entry_fini():
          Introduced function which contains common actions which finalize
          process of TABLE object creation.
        auto_repair_table():
          Moved code responsible for auto-repair of table being opened
          here.
        handle_failed_open_table_attempt()
          Moved code responsible for handling failing attempt to open
          table to one place (retry due to lock conflict/old version,
          auto-discovery and repair).
        open_tables():
          - Flush open HANDLER tables if they have old version of if there
            is conflicting metadata lock against them (before this moment
            we had this code in open_table()).
          - When we open view which should be processed via derived table
            on the second execution of prepared statement or stored
            routine we still should call open_table() for it in order to
            obtain metadata lock on it and prepare its security context.
          - In cases when we discover that some special handling of
            failure to open table is needed call
            handle_failed_open_table_attempt() which handles all such
            scenarios.
        open_ltable():
          Handling of various special scenarios of failure to open a table
          was moved to separate handle_failed_open_table_attempt()
          function.
        remove_db_from_cache():
          Removed this function as it is no longer used.
        notify_thread_having_shared_lock():
          Added callback which is invoked by MDL subsystem when acquiring
          an exclusive lock, for each thread that has a conflicting shared
          metadata lock.
        expel_table_from_cache():
          Introduced function for removing unused TABLE instances. Unlike
          remove_table_from_cache() it relies on caller following MDL
          protocol and having appropriate locks when calling it and thus
          does not do any waiting if table is still in use.
        tdc_wait_for_old_version():
          Added function which allows open_tables() to wait in cases when
          we discover that we should back-off due to presence of old
          version of table.
        abort_and_upgrade_lock():
          Use new MDL calls.
        mysql_wait_completed_table():
          Got rid of unused function.
        open_system_tables_for_read/for_update()/performance_schema_table():
          Allocate MDL_LOCK objects on execution memory root in cases when
          TABLE_LIST objects for corresponding tables is allocated on
          stack.
        close_performance_schema_table():
          Release metadata locks after closing tables.
        ******
        Use I_P_List for free/used tables list in the table share.
      sql/sql_binlog.cc:
        Use Relay_log_info::slave_close_thread_tables() method to enforce
        that we always close tables open for RBR before deallocating
        TABLE_LIST elements and MDL_LOCK objects for them.
      sql/sql_class.cc:
        Added meta-data locking contexts as part of Open_tables_state
        context.  Also introduced THD::locked_tables_root memory root
        which is to be used for allocating MDL_LOCK objects for tables in
        LOCK TABLES statement (end of lifetime for such objects is UNLOCK
        TABLES so we can't use statement or execution root for them).
      sql/sql_class.h:
        Added meta-data locking contexts as part of Open_tables_state
        context.  Also introduced THD::locked_tables_root memory root
        which is to be used for allocating MDL_LOCK objects for tables in
        LOCK TABLES statement (end of lifetime for such objects is UNLOCK
        TABLES so we can't use statement or execution root for them).
        
        Note: handler_mdl_context and locked_tables_root and
        mdl_el_root will be removed by subsequent patches.
      sql/sql_db.cc:
        mysql_rm_db() does not really need to call remove_db_from_cache()
        as it drops each table in the database using
        mysql_rm_table_part2(), which performs all necessary operations on
        table (definition) cache.
      sql/sql_delete.cc:
        Use the new metadata locking API for TRUNCATE.
      sql/sql_handler.cc:
        Changed HANDLER implementation to use new metadata locking
        subsystem.  Note that MDL_LOCK objects for HANDLER tables are
        allocated in the same chunk of heap memory as TABLE_LIST object
        for those tables.
      sql/sql_insert.cc:
        mysql_insert():
          find_locked_table() now takes head of list of TABLE object as
          its argument instead of always scanning through THD::open_tables
          list.
        handle_delayed_insert():
          Allocate metadata lock request object for table open by delayed
          insert thread on execution memroot.  create_table_from_items():
          We no longer allocate dummy TABLE objects for tables being
          created if they don't exist. As consequence
          reopen_name_locked_table() no longer has link_in argument.
          open_table() now has one more argument which is not relevant for
          temporary tables.
      sql/sql_parse.cc:
        - Moved unlock_locked_tables() routine to sql_base.cc and made
          available it in other files. Got rid of some redundant code by
          using this function.
        - Replaced boolean TABLE_LIST::create member with enum
          open_table_type member.
        - Use special memory root for allocating MDL_LOCK objects for
          tables open and locked by LOCK TABLES (these object should live
          till UNLOCK TABLES so we can't allocate them on statement nor
          execution memory root). Also properly set metadata lock
          upgradability attribure for those tables.
        - Under LOCK TABLES it is no longer allowed to flush tables which
          are not write-locked as this breaks metadata locking protocol
          and thus potentially might lead to deadlock.
        - Added auxiliary adjust_mdl_locks_upgradability() function.
      sql/sql_partition.cc:
        Adjusted code to the fact that reopen_tables() no longer has
        "mark_share_as_old" argument. Got rid of comments which are no
        longer true.
      sql/sql_plist.h:
        Added I_P_List template class for parametrized intrusive doubly
        linked lists and I_P_List_iterator for corresponding iterator.
        Unlike for I_List<> list elements of such list can participate in
        several lists. Unlike List<> such lists are doubly-linked and
        intrusive.
      sql/sql_plugin.cc:
        Allocate metadata lock requests objects (MDL_LOCK) on execution
        memory root in cases when we use stack TABLE_LIST objects to open
        tables.
      sql/sql_prepare.cc:
        Replaced boolean TABLE_LIST::create member with enum
        open_table_type member.  This allows easily handle situation in
        which instead of opening the table we want only to take exclusive
        metadata lock on it.
      sql/sql_rename.cc:
        Use new metadata locking subsystem in implementation of RENAME
        TABLE.
      sql/sql_servers.cc:
        Allocate metadata lock requests objects (MDL_LOCK) on execution
        memory root in cases when we use stack TABLE_LIST objects to open
        tables. Got rid of redundant code by using unlock_locked_tables()
        function.
      sql/sql_show.cc:
        Acquire shared metadata lock when we are getting information for
        I_S table directly from TABLE_SHARE without doing full-blown table
        open.  We use high priority lock request in this situation in
        order to avoid deadlocks.
        Also allocate metadata lock requests objects (MDL_LOCK) on
        execution memory root in cases when TABLE_LIST objects are also
        allocated there
      sql/sql_table.cc:
        mysql_rm_table():
          Removed comment which is no longer relevant.
        mysql_rm_table_part2():
          Now caller of mysql_ha_rm_tables() should not own LOCK_open.
          Adjusted code to use new metadata locking subsystem instead of
          name-locks.
        lock_table_name_if_not_cached():
          Moved this function from sql_base.cc to this file and
          reimplemented it using metadata locking API.
        mysql_create_table():
          Adjusted code to use new MDL API.
        wait_while_table_is_used():
          Changed function to use new MDL subsystem. Made thread waiting
          in it killable (this also led to introduction of return value so
          caller can distinguish successful executions from situations
          when waiting was aborted).
        close_cached_tables():
          Thread waiting in this function is killable now. As result it
          has return value for distinguishing between succes and failure.
          Got rid of redundant boradcast_refresh() call.
        prepare_for_repair():
          Use MDL subsystem instead of name-locks.
        mysql_admin_table():
          mysql_ha_rm_tables() now always assumes that caller doesn't own
          LOCK_open.
        mysql_repair_table():
          We should mark all elements of table list as requiring
          upgradable metadata locks.
        mysql_create_table_like():
          Use new MDL subsystem instead of name-locks.
        create_temporary_tables():
          We don't need to obtain metadata locks when creating temporary
          table.
        mysql_fast_or_online_alter_table():
          Thread waiting in wait_while_table_is_used() is now killable.
        mysql_alter_table():
          Adjusted code to work with new MDL subsystem and to the fact
          that threads waiting in what_while_table_is_used() and
          close_cached_table() are now killable.
      sql/sql_test.cc:
        We no longer have separate table cache. TABLE instances are now
        associated with/linked to TABLE_SHARE objects in table definition
        cache.
      sql/sql_trigger.cc:
        Adjusted code to work with new metadata locking subsystem.  Also
        reopen_tables() no longer has mark_share_as_old argument (Instead
        of relying on this parameter and related behavior FLUSH TABLES
        WITH READ LOCK now takes global shared metadata lock).
      sql/sql_udf.cc:
        Allocate metadata lock requests objects (MDL_LOCK) on execution
        memory root in cases when we use stack TABLE_LIST objects to open
        tables.
      sql/sql_update.cc:
        Adjusted code to work with new meta-data locking subsystem.
      sql/sql_view.cc:
        Added proper meta-data locking to implementations of
        CREATE/ALTER/DROP VIEW statements. Now we obtain exclusive
        meta-data lock on a view before creating/ changing/dropping it.
        This ensures that all concurrent statements that use this view
        will finish before our statement will proceed and therefore we
        will get correct order of statements in the binary log.
        Also ensure that TABLE_LIST::mdl_upgradable attribute is properly
        propagated for underlying tables of view.
      sql/table.cc:
        Added auxiliary alloc_mdl_locks() function for allocating metadata
        lock request objects for all elements of table list.
      sql/table.h:
        TABLE_SHARE:
          Got rid of unused members. Introduced members for storing lists
          of used and unused TABLE objects for this share.
        TABLE:
          Added members for linking TABLE objects into per-share lists of
          used and unused TABLE instances. Added member for holding
          pointer to metadata lock for this table.
        TABLE_LIST:
          Replaced boolean TABLE_LIST::create member with enum
          open_table_type member.  This allows easily handle situation in
          which instead of opening the table we want only to take
          exclusive meta-data lock on it (we need this in order to handle
          ALTER VIEW and CREATE VIEW statements).
          Introduced new mdl_upgradable member for marking elements of
          table list for which we need to take upgradable shared metadata
          lock instead of plain shared metadata lock.  Added pointer for
          holding pointer to MDL_LOCK for the table.
        Added auxiliary alloc_mdl_locks() function for allocating metadata
        lock requests objects for all elements of table list.  Added
        auxiliary set_all_mdl_upgradable() function for marking all
        elements in table list as requiring upgradable metadata locks.
      storage/myisammrg/ha_myisammrg.cc:
        Allocate MDL_LOCK objects for underlying tables of MERGE table.
        To be reworked once Ingo pushes his patch for WL4144.
      eff3780d
  7. 27 Oct, 2009 1 commit
  8. 23 Oct, 2009 1 commit
    • Luis Soares's avatar
      post-push fixes · ba0afceb
      Luis Soares authored
      Disabled rpl_cross_version (instead of setting it experimental).
      Fixed outstanding warning fix in main.debug_sync.
      ba0afceb
  9. 22 Oct, 2009 1 commit
  10. 27 Sep, 2009 1 commit
  11. 23 Sep, 2009 1 commit
  12. 01 Sep, 2009 1 commit
  13. 31 Aug, 2009 1 commit
  14. 30 Aug, 2009 1 commit
  15. 15 Jul, 2009 1 commit
  16. 06 Jul, 2009 1 commit
    • Patrick Crews's avatar
      Bug#44920: MTR2 is not processing master.opt input properly on Windows. · 869e6bd1
      Patrick Crews authored
      Had attempted to disable this test on Windows only, but the nature of this bug
      does not allow for this.  The master.opt file is processed before anything in 
      in the actual test.  As a result, we must use disabled.def files to ensure
      these tests are skipped on the problematic platforms.
      
      Removed Windows-only code and updated the proper disabled.def files accordingly.
      869e6bd1
  17. 12 Jun, 2009 1 commit
  18. 18 May, 2009 1 commit
  19. 15 Apr, 2009 1 commit
  20. 27 Mar, 2009 1 commit
  21. 24 Mar, 2009 1 commit
    • Leonard Zhou's avatar
      Bug#43440 rpl.rpl_temp_table_mix_row fails sporadicly · da30dedd
      Leonard Zhou authored
            
      The problem is that after disconnect, the DOPR TEMPORARY TABLE event didn't been
      written into binlog. So after syncing with slave, the TEMPORARY table on slave 
      is not removed.
            
      Waiting DROP TEMPORARY TABLE event to be written into binlog before sync slave with
      master.
      
      mysql-test/suite/rpl/t/disabled.def:
        Remove disable item.
      mysql-test/suite/rpl/t/rpl_temp_table_mix_row.test:
        Waiting DROP TEMPORARY TABLE event to be written into binlog
      da30dedd
  22. 23 Mar, 2009 1 commit
  23. 30 Dec, 2008 1 commit
    • Sven Sandberg's avatar
      BUG#41793: rpl_binlog_corruption disabled in main (needs new mtr) · 28e672db
      Sven Sandberg authored
      Disabled rpl_binlog_corruption since it requires the new mtr,
      which only exists in 5.1-rpl / 6.0-rpl.
      Please re-enable the test in 5.1-rpl / 6.0-rpl.
      
      
      mysql-test/suite/rpl/t/disabled.def:
        Disabled rpl_binlog_corruption since it requires the new mtr,
        which only exists in 5.1-rpl / 6.0-rpl.
      28e672db
  24. 19 Dec, 2008 1 commit
    • Andrei Elkin's avatar
      Bug#38934 slave slave until does not work with --replicate-same-server-id · 126c0b44
      Andrei Elkin authored
      Bug#38540 rpl_server_id2 uses show slave status unnecessarily
                  
      Slave did not perform any event recorded into the relay log from some
      different master when it was started with --replicate-same-server-id.
      The reason appeared to be a consequence of BUG#38734 which stopped the
      sql thread at its startup time.
            
      The real fixes for the current bug are in the patch for BUG#38734.
      This changeset carries only a regression test for the bugs.  Bug#38540
      gets fixed too by means of eliminating an extra show slave status.
      
      
      mysql-test/suite/rpl/r/rpl_server_id2.result:
        Bug#38934 Bug#38540 changed results.
      mysql-test/suite/rpl/t/disabled.def:
        rpl_server_id2 is re-enabled.
      mysql-test/suite/rpl/t/rpl_server_id2.test:
        regression test for BUG#38734 is added.
        Bug#38540 requirement to get rid of show slave status is implemented.
      126c0b44
  25. 18 Dec, 2008 1 commit
  26. 06 Nov, 2008 1 commit
    • Sven Sandberg's avatar
      BUG#36625: Please remove the rpl_probe and rpl_parse features from the server · f40fc60c
      Sven Sandberg authored
      Problem 1: BUG#36625: rpl_redirect doesn't do anything useful. It tests an
      obsolete feature that was never fully implemented.
      Fix 1: Remove rpl_redirect.
      Problem 2: rpl_innodb_bug28430 and rpl_flushlog_loop are disabled despite the
      bugs for which they were disabled have been fixed.
      Fix 2: Re-enable rpl_innodb_bug28430 and rpl_flushlog_loop.
      
      
      mysql-test/suite/rpl/r/rpl_redirect.result:
        Removed result file for obsolete test.\
      mysql-test/suite/rpl/t/disabled.def:
        Re-enabled tests.
      mysql-test/suite/rpl/t/rpl_redirect.test:
        Removed obsolete test.
      f40fc60c
  27. 07 Oct, 2008 1 commit
    • Ramil Kalimullin's avatar
      Fix for bug#38269: pushbuild gives valgrind error in · b4c5cafe
      Ramil Kalimullin authored
      ha_statistic_increment for rpl_temporary
      
      Problem: in some cases master send a special event to reconnecting
      slave to keep slave's temporary tables (see #17284) and they still 
      have references to the "old" SQL slave thread and use them to access
      thread's data.
      
      Fix: set temporary tables thread references to the actual SQL slave
      thread in such cases.
      
      
      mysql-test/suite/rpl/t/disabled.def:
        Fix for bug#38269: pushbuild gives valgrind error in 
        ha_statistic_increment for rpl_temporary
          - rpl_temporary test enabled.
      sql/log_event.cc:
        Fix for bug#38269: pushbuild gives valgrind error in 
        ha_statistic_increment for rpl_temporary
          - if we keep slave's temporary tables after reconnect,
        set their thread pointers (->in_use) to the current SQL thread.
      b4c5cafe
  28. 01 Oct, 2008 1 commit
  29. 05 Sep, 2008 1 commit
  30. 23 Jul, 2008 1 commit
    • Sven Sandberg's avatar
      BUG#37733: rpl.rpl_flushlog_loop 'row' fails sporadically on pushbuild · d8c838c2
      Sven Sandberg authored
      BUG#37884: rpl_row_basic_2myisam and rpl_row_basic_3innodb fail sporadically in pushbuild
      These have been fixed in 5.1-rpl. Re-applying fix for BUG#37884
      in 5.1-bugteam, and disabling rpl_flushlog_loop for BUG#37733 in
      5.1-bugteam.
      
      
      mysql-test/extra/rpl_tests/rpl_row_basic.test:
        Missing sync_slave_with_master added.
      mysql-test/suite/rpl/t/disabled.def:
        Disabling rpl_flushlog_loop until the fixed version gets
        merged from 5.1-rpl
      d8c838c2
  31. 21 Jul, 2008 1 commit
  32. 18 Jul, 2008 1 commit
    • Andrei Elkin's avatar
      Bug #36818 rpl_server_id1 fails expecting slave has stopped · 7d1bc0a4
      Andrei Elkin authored
            
      the reason for the failure is that io thread passes through a sequence of state
      changes before it eventually got stuck at the expect running state as NO.
      It's unreasonble to wait for the running status while the whole idea of the test is
      to get to the IO thread error.
      
      Fixed with changing the waiting condition.
      
      mysql-test/suite/rpl/r/rpl_server_id1.result:
        results changed
      mysql-test/suite/rpl/t/disabled.def:
        re-enabling rpl_server_id1
      mysql-test/suite/rpl/t/rpl_server_id1.test:
        deploying the exact waiting condition i.e to wait for the slave io error.
      7d1bc0a4
  33. 19 Jun, 2008 1 commit
    • Tatiana A. Nurnberg's avatar
      re 36818: rpl_server_id1 fails expecting slave has stopped · b4a45a71
      Tatiana A. Nurnberg authored
      On a slow environment like valgrind the test is vulnerable
      because it does not check if slave has stopped at time
      of the new session is requested `start slave;' -- disabling
      test till it is fixed.
      
      mysql-test/suite/rpl/t/disabled.def:
        disable rpl_server_id1 until test is fixed.
      b4a45a71
  34. 19 May, 2008 1 commit
    • unknown's avatar
      disabled.def: · ee4e10c7
      unknown authored
        rpl_innodb_bug28430 disabled
      
      
      mysql-test/suite/rpl/t/disabled.def:
        rpl_innodb_bug28430 disabled
      ee4e10c7
  35. 07 May, 2008 2 commits
    • unknown's avatar
      BUG#36398: 'DROP TEMPORARY TABLE' in ROLLBACK transaction causes transaction to be logged · e1a2bb92
      unknown authored
      Temporarily checking in an incorrect test case. Rationale: the impact of
      this bug is negligible (it's almost a feature request). We need 5.1 to be
      stable, and making a real fix is a bit risky. So the fix is postponed
      to 6.0.
      
      
      mysql-test/suite/rpl/r/rpl_ddl.result:
        Updated result file.
      mysql-test/suite/rpl/t/disabled.def:
        Enabling test case rpl_ddl.test
      e1a2bb92
    • unknown's avatar
      BUG#36379: please re-enable rpl_innodb_bug28430 · fcec0b01
      unknown authored
      The test suite/rpl/t/rpl_innodb_bug28430.test was disabled because of
      BUG#32247, but not re-enabled when BUG#32247 was fixed. I've re-enabled
      it. The test and result file needed to be updated too.
      
      
      mysql-test/suite/rpl/r/rpl_innodb_bug28430.result:
        Updated result file.
      mysql-test/suite/rpl/t/disabled.def:
        Enabled the rpl_innodb_bug28430 test case.
      mysql-test/suite/rpl/t/rpl_innodb_bug28430.test:
        show slave status is not needed since we have select count(*)
      fcec0b01
  36. 26 Apr, 2008 1 commit
  37. 25 Apr, 2008 2 commits
  38. 24 Apr, 2008 1 commit
    • unknown's avatar
      Enabled rpl: rpl_view, rpl_ndb_multi, rpl_log_pos · 9cb63bfb
      unknown authored
      and main: user_limits, concurrent_innodb, lowercase_table3, ctype_create 
      tests.
      
      
      mysql-test/suite/ndb/t/disabled.def:
        Removed test commented.
      mysql-test/suite/rpl/t/disabled.def:
        Enabled rpl_view, rpl_ndb_multi, rpl_log_pos tests.
      mysql-test/t/disabled.def:
        Enabled user_limits, concurrent_innodb, lowercase_table3, ctype_create tests.
      9cb63bfb