An error occurred fetching the project authors.
  1. 09 Dec, 2009 3 commits
    • Konstantin Osipov's avatar
      Backport of: · 736db89a
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2617.69.37
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-next-bg46748
      timestamp: Fri 2009-08-21 18:17:02 +0400
      message:
        Fix for bug #46748 "Assertion in MDL_context::wait_for_locks()
        on INSERT + CREATE TRIGGER".
      
        Concurrent execution of statements involving stored functions or triggers
        which were using several tables and DDL statements which affected those
        tables on debug build of server might have led to assertion failures in
        MDL_context::wait_for_locks(). Non-debug build was not affected.
      
        The problem was that during back-off which happens when open_tables()
        encounters conflicting metadata lock for one of the tables being open
        we didn't reset MDL_request::ticket value for requests which correspond
        to tables from extended prelocking set. Since these requests are part
        of of list of requests to be waited for in Open_table_context this broke
        assumption that ticket value for them is 0 in MDL_context::wait_for_locks()
        and caused assertion failure.
      
        This fix ensures that close_tables_for_reopen(), which performs this back-off
        resets MDL_request::ticket value not only for tables directly used by the
        statement but also for tables from extended prelocking set, thus satisfying
        assumption described above.
      
      
      
      mysql-test/r/mdl_sync.result:
        Added test case for bug #46748 "Assertion in MDL_context::wait_for_locks()
        on INSERT + CREATE TRIGGER".
      mysql-test/t/mdl_sync.test:
        Added test case for bug #46748 "Assertion in MDL_context::wait_for_locks()
        on INSERT + CREATE TRIGGER".
      sql/sql_base.cc:
        Since metadata lock requests for tables from extended part of prelocking
        set are also part of list of requests to be waited for in Open_table_context
        in close_tables_for_reopen() we have to reset MDL_request::ticket 
        values for them to assumptions in MDL_context::wait_for_locks().
      736db89a
    • Konstantin Osipov's avatar
      Backport of: · 351b912e
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2617.69.25
      committer: Konstantin Osipov <kostja@sun.com>
      branch nick: 5.4-42546
      timestamp: Fri 2009-08-14 23:52:00 +0400
      message:
        A cleanup in open_tables() and lock_tables():
        change return type of these functions to bool from int,
        to follow convention in the rest of the code.
      (Part of WL#4284 review fixes).
      
      sql/mysql_priv.h:
        Change return type of open_talbes() and lock_tables() from
        int to bool.
      sql/sql_base.cc:
        Change return type of open_tables() and lock_tables() from int to bool.
      sql/sql_handler.cc:
        Use bool now that open_tables() returns bool.
      351b912e
    • Jon Olav Hauglid's avatar
      Backport of revno: 2617.69.40 · 546e16eb
      Jon Olav Hauglid authored
      A pre-requisite patch for Bug#30977 "Concurrent statement using 
      stored function and DROP FUNCTION breaks SBR".
      
      This patch changes the MDL API by introducing a namespace for
      lock keys: MDL_TABLE for tables and views and MDL_PROCEDURE
      for stored procedures and functions. The latter is needed for
      the fix for Bug#30977.
      546e16eb
  2. 08 Dec, 2009 4 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
    • Konstantin Osipov's avatar
      Backport of: · 478e0960
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2617.69.2
      committer: Konstantin Osipov <kostja@sun.com>
      branch nick: 5.4-azalea-bugfixing
      timestamp: Mon 2009-08-03 19:26:04 +0400
      message:
        A fix and a test case for Bug#45035 "Altering table under LOCK TABLES
        results in "Error 1213 Deadlock found...".
      
        If a user had a table locked with LOCK TABLES
        for READ and for WRITE in the same connection, ALTER TABLE
        could fail.
      
        Root cause analysis:
      
        If a connection issues
      
        LOCK TABLE t1 write, t1 a read, t1 b read;
      
        the new LOCK TABLES code in 6.0 (part of WL 3726) will create
        the following list of TABLE_LIST objects
        (thd->locked_tables_list->m_locked_tables):
      
        {"t1" "b" tl_read_no_insert}, {"t1" "a" tl_read_no_insert},
        {"t1" "t1" tl_write }
      
        Later on, when we try to ALTER table t1, mysql_alter_table()
        closes all TABLE instances and releases its thr_lock locks,
        keeping only an exclusive metadata lock on t1.
      
        But when ALTER is finished, Locked_table_list::reopen_tables()
        tries to restore the original list of open and locked tables.
      
        Before this patch, it used to do so one by one:
        Open t1 b, get TL_READ_NO_INSERT lock,
        Open t1 a, get TL_READ_NO_INSERT lock
        Open t1, try to get TL_WRITE lock, deadlock.
      
        The cause of the deadlock is that thr_lock.c doesn't
        resolve the situation when the read list only consists
        of locks taken by the same thread, followed by this very
        thread trying to take a WRITE lock. Indeed, since
        thr_lock_multi always gets a sorted list of locks,
        WRITE locks always precede READ locks in the list
        to lock.
      
        Don't try to fix thr_lock.c deficiency, keep this
        code simple.
        Instead, try to take all thr_lock locks at once
        in ::reopen_tables().
      
      
      mysql-test/r/lock.result:
        Update results: test case for Bug#45035.
      mysql-test/t/lock.test:
        Add a test case for Bug#45035.
      sql/sql_base.cc:
        Take all thr_lock locks at once in Locked_tables_list::reopen_tables().
      sql/sql_class.h:
        Add a helper array to store tables for mysql_lock_tables()
        in reopen_tables().
      sql/sql_table.cc:
        Update unlink_all_closed_tables() to the new signature.
      478e0960
    • Konstantin Osipov's avatar
      Backport of: · 226d3e4f
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2617.65.6
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-azalea-bg39674
      timestamp: Sat 2009-07-25 00:28:43 +0400
      message:
        Fix for bug #39674 "On shutdown mdl_destroy() called before
        plugin_shutdown()".
      
        Attempt to shutdown PBXT engine plugin led to assertion failure
        caused by using already destroyed mutex in metadata locking
        subsystem.
      
        This problem stemmed from the fact that we MDL subsystem and
        table definition cache were deinitialized before plugin shutdown
        while PBXT plugin during its shutdown process accessed tables and
        therefore expected them to be in working shape.
      
        This patch solves this problem by moving deinitialization of
        these two subsystems after plugins are shut down.
      
        No test case is provided since such test case would require
        using PBXT or other plugin which accesses tables during its
        shutdown process.
      
      
      sql/mysql_priv.h:
        Introduced table_def_start_shutdown() function which informs
        table definition cache that shutdown process has been started
        so it has to keep number of TABLE and TABLE_SHARE objects minimal
        in order to reduce number of references to pluggable engines.
      sql/mysqld.cc:
        Destroy table definition cache and meta-data locking subsystem
        after shutting down plugins. This allows plugins to work with
        tables during their shutdown.
        Since table definition cache hold references to storage engine
        plugins we have to remove unused tables from it before shutting
        down plugins and keep number of these references minimal during
        the process (by immediately removing tables opened during this
        process from the table definition cache).
      sql/sql_base.cc:
        Introduced table_def_start_shutdown() function which informs
        table definition cache that shutdown process has been started
        so it has to keep number of TABLE and TABLE_SHARE objects
        minimal in order to reduce number of references to pluggable
        engines.
                This allows to smoothly shutdown such plugins without completely
                prohibiting access to tables/table definition cache while
                shutting down other plugins.
      226d3e4f
  3. 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
  4. 03 Dec, 2009 3 commits
    • Konstantin Osipov's avatar
      Backport of: · a9013f8f
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2617.23.20
      committer: Konstantin Osipov <kostja@sun.com>
      branch nick: mysql-6.0-runtime
      timestamp: Wed 2009-03-04 16:31:31 +0300
      message:
        WL#4284 "Transactional DDL locking"
        Review comments: "Objectify" the MDL API.
        MDL_request and MDL_context still need manual construction and
        destruction, since they are used in environment that is averse
        to constructors/destructors.
      
      
      sql/mdl.cc:
        Improve comments.
        Add asserts to backup()/restore_from_backup()/merge() methods.
        Fix an order bug in the error path of mdl_acquire_exclusive_locks():
        we used to first free a ticket object, and only then exclude
        it from the list of tickets.
      a9013f8f
    • Konstantin Osipov's avatar
      Backport of: · f477e66e
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2617.23.18
      committer: Davi Arnaut <Davi.Arnaut@Sun.COM>
      branch nick: 4284-6.0
      timestamp: Mon 2009-03-02 18:18:26 -0300
      message:
      Bug#989: If DROP TABLE while there's an active transaction, wrong binlog order
      WL#4284: Transactional DDL locking
      
      This is a prerequisite patch:
      
      These changes are intended to split lock requests from granted
      locks and to allow the memory and lifetime of granted locks to
      be managed within the MDL subsystem. Furthermore, tickets can
      now be shared and therefore are used to satisfy multiple lock
      requests, but only shared locks can be recursive.
      
      The problem is that the MDL subsystem morphs lock requests into
      granted locks locks but does not manage the memory and lifetime
      of lock requests, and hence, does not manage the memory of
      granted locks either. This can be problematic because it puts the
      burden of tracking references on the users of the subsystem and
      it can't be easily done in transactional contexts where the locks
      have to be kept around for the duration of a transaction.
      
      Another issue is that recursive locks (when the context trying to
      acquire a lock already holds a lock on the same object) requires
      that each time the lock is granted, a unique lock request/granted
      lock structure structure must be kept around until the lock is
      released. This can lead to memory leaks in transactional contexts
      as locks taken during the transaction should only be released at
      the end of the transaction. This also leads to unnecessary wake
      ups (broadcasts) in the MDL subsystem if the context still holds
      a equivalent of the lock being released.
      
      These issues are exacerbated due to the fact that WL#4284 low-level
      design says that the implementation should "2) Store metadata locks
      in transaction memory root, rather than statement memory root" but
      this is not possible because a memory root, as implemented in mysys,
      requires all objects allocated from it to be freed all at once.
      
      This patch combines review input and significant code contributions
      from Konstantin Osipov (kostja) and Dmitri Lenev (dlenev).
      
      
      mysql-test/r/mdl_sync.result:
        Add test case result.
      mysql-test/t/mdl_sync.test:
        Add test case for shared lock upgrade case.
      sql/event_db_repository.cc:
        Rename mdl_alloc_lock to mdl_request_alloc.
      sql/ha_ndbcluster_binlog.cc:
        Use new function names to initialize MDL lock requests.
      sql/lock.cc:
        Rename MDL functions.
      sql/log_event.cc:
        The MDL request now holds the table and database name data (MDL_KEY).
      sql/mdl.cc:
        Move the MDL key to the MDL_LOCK structure in order to make the
        object suitable for allocation from a fixed-size allocator. This
        allows the simplification of the lists in the MDL_LOCK object,
        which now are just two, one for granted tickets and other for
        waiting (upgraders) tickets.
        
        Recursive requests for a shared lock on the same object can now
        be granted using the same lock ticket. This schema is only used
        for shared locks because that the only case that matters. This
        is used to avoid waste of resources in case a context (connection)
        already holds a shared lock on a object.
      sql/mdl.h:
        Introduce a metadata lock object key which is used  to uniquely
        identify lock objects.
        
        Separate the structure used to represent pending lock requests
        from the structure used to represent granted metadata locks.
        
        Rename functions used to manipulate locks requests in order to
        have a more consistent function naming schema.
      sql/sp_head.cc:
        Rename mdl_alloc_lock to mdl_request_alloc.
      sql/sql_acl.cc:
        Rename alloc_mdl_locks to alloc_mdl_requests.
      sql/sql_base.cc:
        Various changes to accommodate that lock requests are separated
        from lock tickets (granted locks).
      sql/sql_class.h:
        Last acquired lock before the savepoint was set.
      sql/sql_delete.cc:
        Various changes to accommodate that lock requests are separated
        from lock tickets (granted locks).
      sql/sql_handler.cc:
        Various changes to accommodate that lock requests are separated
        from lock tickets (granted locks).
      sql/sql_insert.cc:
        Rename alloc_mdl_locks to alloc_mdl_requests.
      sql/sql_parse.cc:
        Rename alloc_mdl_locks to alloc_mdl_requests.
      sql/sql_plist.h:
        Typedef for iterator type.
      sql/sql_plugin.cc:
        Rename alloc_mdl_locks to alloc_mdl_requests.
      sql/sql_servers.cc:
        Rename alloc_mdl_locks to alloc_mdl_requests.
      sql/sql_show.cc:
        Various changes to accommodate that lock requests are separated
        from lock tickets (granted locks).
      sql/sql_table.cc:
        Various changes to accommodate that lock requests are separated
        from lock tickets (granted locks).
      sql/sql_trigger.cc:
        Save reference to the lock ticket so it can be downgraded later.
      sql/sql_udf.cc:
        Rename alloc_mdl_locks to alloc_mdl_requests.
      sql/table.cc:
        Rename mdl_alloc_lock to mdl_request_alloc.
      sql/table.h:
        Separate MDL lock requests from lock tickets (granted locks).
      storage/myisammrg/ha_myisammrg.cc:
        Rename alloc_mdl_locks to alloc_mdl_requests.
      f477e66e
    • Konstantin Osipov's avatar
      Backport of: · c52d4830
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.22.3
      committer: Davi Arnaut <Davi.Arnaut@Sun.COM>
      branch nick: 4284-6.0
      timestamp: Thu 2008-08-07 22:33:43 -0300
      message:
      WL#4284: Transactional DDL locking
      
      Make transaction management more modular through a new interface.
      
      The overall objective of this change is to provide groundwork
      for the design of transactional DDL locking by cleaning up the
      transaction high level API to better distinguish operations implicit
      and explicit, and single statement transaction from operations on
      the normal transaction.
      
      Having a a high-level interface for transaction management provides
      a better base for implementing transactional concepts that are not
      always tied to storage engines and also makes it easier to interect
      with other higher level modules of the server.
      
      client/Makefile.am:
        Add new file to the build.
      libmysqld/CMakeLists.txt:
        Add new file to the build.
      libmysqld/Makefile.am:
        Add new file to the build.
      sql/CMakeLists.txt:
        Add new file to the build.
      sql/Makefile.am:
        Add new file to the build.
      sql/handler.cc:
        Remove multiplexer commit or rollback function. Most callers already
        have enough information to decided whether to rollback or commit.
        Having plain and well named functions makes it easier to read
        and understand code.
      sql/handler.h:
        Remove wrapper function as the low level transaction functions
        shouldn't be called directly anymore.
      sql/log_event.cc:
        Rename transaction management functions to the new names.
      sql/log_event_old.cc:
        Rename transaction management functions to the new names.
      sql/mysql_priv.h:
        Remove obsolete functions for implicit and explicit commit.
      sql/rpl_injector.cc:
        Rename transaction management functions to the new names.
      sql/rpl_rli.cc:
        Rename transaction management functions to the new names.
      sql/set_var.cc:
        Rename transaction management functions to the new names.
      sql/slave.cc:
        Rename transaction management functions to the new names.
      sql/sql_base.cc:
        Rename transaction management functions to the new names.
      sql/sql_class.cc:
        Rename transaction management functions to the new names.
      sql/sql_delete.cc:
        Rename transaction management functions to the new names.
      sql/sql_do.cc:
        Rename transaction management functions to the new names.
      sql/sql_insert.cc:
        Rename transaction management functions to the new names.
      sql/sql_parse.cc:
        Rename transaction management functions to the new names.
      sql/sql_partition.cc:
        Rename transaction management functions to the new names.
      sql/sql_table.cc:
        Rename transaction management functions to the new names.
      sql/transaction.cc:
        Implement wrapper functions to differentiate operations on
        the single statement transaction from the ones operating
        on the normal transaction.
      sql/transaction.h:
        Export new functions for dealing with transaction commands.
      c52d4830
  5. 02 Dec, 2009 7 commits
    • Konstantin Osipov's avatar
      Backport of: · 7f628ac2
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2630.4.38
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-4144
      timestamp: Wed 2008-06-25 22:07:06 +0400
      message:
        WL#4144 - Lock MERGE engine children.
        Committing a version of the patch merged with WL#3726
        on behalf of Ingo.
      
        Step #1: Move locking from parent to children.
      
        MERGE children are now left in the query list of tables
        after inserted there in open_tables(). So they are locked
        by lock_tables() as all other tables are.
      
        The MERGE parent does not store locks any more. It appears
        in a MYSQL_LOCK with zero lock data. This is kind of a "dummy"
        lock.
      
        All other lock handling is also done directly on the children.
        To protect against parent or child modifications during LOCK
        TABLES, the children are detached after every statement and
        attached before every statement, even under LOCK TABLES.
      
        The children table list is removed from the query list of tables
        on every detach and on close of the parent.
      
        Step #2: Move MERGE specific functionality from SQL layer
        into table handler.
      
        Functionality moved from SQL layer (mainly sql_base.cc)
        to the table handler (ha_myisammrg.cc).
      
        Unnecessary code is removed from the SQL layer.
      
        Step #3: Moved all MERGE specific members from TABLE
        to ha_myisammrg.
      
        Moved members from TABLE to ha_myisammrg.
        Renamed some mebers.
        Fixed comments.
      
        Step #4: Valgrind and coverage testing
      
        Valgrind did not uncover new problems.
        Added purecov comments.
      
        Added a new test for DATA/INDEX DIRECTORY options.
        Changed handling of ::reset() for non-attached children.
        Fixed the merge-big test.
      
        Step #5: Fixed crashes detected during review
        Changed detection when to attach/detach.
        Added new tests.
      
      Backport also the fix for Bug#44040 "MySQL allows creating a 
      MERGE table upon VIEWs but crashes when using it"
      
      
      include/my_base.h:
        WL#4144 - Lock MERGE engine children
        Added HA_EXTRA_ADD_CHILDREN_LIST and HA_EXTRA_IS_ATTACHED_CHILDREN
        for MERGE table support
      mysql-test/r/merge.result:
        WL#4144 - Lock MERGE engine children
        Fixed test result.
      mysql-test/t/disabled.def:
        Enable merge.test, which now is working again (WL#4144).
      mysql-test/t/merge-big.test:
        Fix the messages for wait_condition (merge with WL#3726).
      mysql-test/t/merge.test:
        WL#4144 - Lock MERGE engine children
        Fixed one test to meet coding standards for tests
        (upper case keywords, engine names as in SHOW ENGINES).
        Fixed error codes.
        Added a test for DATA/INDEX DIRECTORY.
      mysys/thr_lock.c:
        WL#4144 - Lock MERGE engine children
        Added purecov comments.
      sql/ha_partition.cc:
        WL#4144 - Lock MERGE engine children
        Added MERGE specific extra operations to ha_partition::extra().
        Extended comments.
        Changed function comment to doxygen style.
        Fixed nomenclature: 'parameter' -> 'operation'.
      sql/mysql_priv.h:
        WL#4144 - Lock MERGE engine children
        Removed declarations for removed functions.
      sql/sql_base.cc:
        WL#4144 - Lock MERGE engine children
        Leave the children in the query list of tables after open_tables().
        Set proper back links (prev_global).
        Attach MERGE children before and detach them after every
        statement. Even under LOCK TABLES.
        Remove children from the query list when they are detached.
        Remove lock forwarding from children to parent.
        Moved MERGE specific functions to ha_myisammrg.cc.
        Added purecov comments.
        Backport the fix for Bug#44040 "MySQL allows creating a MERGE table upon VIEWs but crashes when using it"
      sql/sql_table.cc:
        WL#4144 - Lock MERGE engine children
        Changed detection of MERGE tables.
      sql/table.cc:
        WL#4144 - Lock MERGE engine children
        Moved is_children_attached() method from TABLE to ha_myisammrg.
      sql/table.h:
        WL#4144 - Lock MERGE engine children
        Moved all MERGE specific members from TABLE to ha_myisammrg.
      storage/myisammrg/ha_myisammrg.cc:
        WL#4144 - Lock MERGE engine children
        Set proper back links in the child list (prev_global).
        Added a function for removal of the child list from the query list.
        Remove children from the query list when the parent is closed.
        Make parent lock handling a dummy (zero locks).
        Moved MERGE specific functionality from SQL layer to here.
        Moved all MERGE specific members from TABLE to ha_myisammrg.
        Renamed children list pointers.
        Added initialization and free for the children list mem_root.
        Fixed comments.
        Added purecov comments.
      storage/myisammrg/ha_myisammrg.h:
        WL#4144 - Lock MERGE engine children
        Added method add_children_list().
        Moved all MERGE specific members from TABLE to ha_myisammrg.
        Renamed children list pointers.
        Added a mem_root for the children list.
      storage/myisammrg/myrg_extra.c:
        WL#4144 - Lock MERGE engine children
        Changed handling of ::reset() for non-attached children.
      7f628ac2
    • Konstantin Osipov's avatar
      Backport of: · 9148af5c
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2630.4.36
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-3726
      timestamp: Wed 2008-06-25 17:03:37 +0400
      message:
        As per discussion with Serg and Dmitri, remove the code
        that is trying to emulate LOCK TABLES when locking tables for prelocking.
        This code was worked around by the engines, and has no effect.
        We may still have to do something to ensure that statement-based
        replication is consistent in MVCC engines, or other engines
        that downgrade table level locks, but this will have to be done
        somehow differently.
      
      
      sql/sql_base.cc:
        Do not try to emulate LOCK TABLES when locking tables for
        pre-locking.
      9148af5c
    • Konstantin Osipov's avatar
      Backport of: · 124cda8a
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.33
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w2
      timestamp: Fri 2008-06-20 17:11:20 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After-review fixes in progress.
      
        Minimized dependency of mdl.cc on other modules (particularly
        made it independant of mysql_priv.h) in order to be able
        write unit tests for metadata locking subsystem.
      
      
      sql/ha_ndbcluster_binlog.cc:
        Use newly introduced MAX_MDLKEY_LENGTH constant for allocating
        buffer for object key for metadata locking subsystem.
      sql/log_event.cc:
        Use newly introduced MAX_MDLKEY_LENGTH constant for allocating
        buffer for object key for metadata locking subsystem.
      sql/mdl.cc:
        Removed dependency on THD class (and thus on mysql_priv.h)
        by using direct access to members of st_my_thread_var instead
        of accessing THD::killed/enter_cond()/exit_cond().
      sql/mdl.h:
        Added MAX_MDLKEY_LENGTH constant to be used for allocating
        buffers for key for metadata locking subsystem.
        Added declarations of server kernel functions used by metadata
        locking subsystem to mdl.h in order to decrease dependency of
        mdl.cc on other files.
      sql/mysql_priv.h:
        Moved declaration of notify_thread_having_shared_lock() to the
        mdl.h (also renamed it to make clear in metadata locking code
        that it is a callback to SQL-layer).
      sql/sql_base.cc:
        Renamed notify_thread_having_shared_lock() to make it clear
        in metadata locking subsystem code that it is a callback
        to SQL layer.
      sql/sql_handler.cc:
        Use newly introduced MAX_MDLKEY_LENGTH constant for allocating
        buffer for object key for metadata locking subsystem.
      sql/sql_show.cc:
        Use newly introduced MAX_MDLKEY_LENGTH constant for allocating
        buffer for object key for metadata locking subsystem.
      124cda8a
    • Konstantin Osipov's avatar
      Backport of: · e3b3907c
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.32
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w2
      timestamp: Thu 2008-06-19 16:39:58 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After-review fixes in progress.
      
        Ensure that metadata locking subsystem properly handles
        out-of-memory conditions. Clarified MDL interface by
        separating release of locks and removal of lock requests
        from the context.
      
      sql/lock.cc:
        mdl_release_lock(), mdl_acquire_exclusive_locks() and 
        mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        mdl_remove_lock() to do this.
      sql/mdl.cc:
        Ensured that metadata locking subsystem properly handles
        out-of-memory conditions.
        Introduced new MDL_INITIALIZED state for metadata lock
        request which is used in all cases when lock is not acquired 
        and we have not associated request with object respesenting 
        lock.
        
        MDL_PENDING is now only used for requests for exclusive locks
        which are added to the MDL_LOCK::waiting_exclusive queue.
        mdl_release_lock(), mdl_acquire_exclusive_locks() and 
        mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        newly introduced mdl_remove_lock() to do this.
        Also renamed mdl_release_all_locks_for_name() to 
        emphasize that it also actually removes lock requests
        from the context.
        
        Finally mdl_try_acquire_exclusive_lock() is now returs
        information about encountered lock conflict in separate
        out parameter since its return value is used for distinguishing
        between error (e.g. due to OOM) and success.
      sql/mdl.h:
        Introduced new MDL_INITIALIZED state for metadata lock
        request which is used in all cases when lock is not acquired 
        and we have not associated request with object respesenting 
        lock.
        
        MDL_PENDING is now only used for requests for exclusive locks
        which are added to the MDL_LOCK::waiting_exclusive queue.
        mdl_release_lock(), mdl_acquire_exclusive_locks() and 
        mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        newly introduced mdl_remove_lock() to do this.
        Also renamed mdl_release_all_locks_for_name() to 
        emphasize that it also actually removes lock requests
        from the context.
        
        Finally mdl_try_acquire_exclusive_lock() is now returs
        information about encountered lock conflict in separate
        out parameter since its return value is used for distinguishing
        between error (e.g. due to OOM) and success.
      sql/sql_base.cc:
        mdl_release_lock(), mdl_acquire_exclusive_locks() and mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        mdl_remove_lock() to do this.
        Also adjusted open_table() to ensure that it 
        releases/removes metadata locks in case of error 
        after adding/acquiring them (unless keeping these
        lock requests is required for recovering action).
      sql/sql_delete.cc:
        mdl_release_lock(), mdl_acquire_exclusive_locks() and mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        mdl_remove_lock() to do this.
      sql/sql_handler.cc:
        mdl_release_lock(), mdl_acquire_exclusive_locks() and mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        mdl_remove_lock() to do this.
      sql/sql_show.cc:
        mdl_release_lock(), mdl_acquire_exclusive_locks() and mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        mdl_remove_lock() to do this.
      sql/sql_table.cc:
        Renamed mdl_release_all_locks_for_name() to emphasize
        that it also actually removes lock requests from the context.
        mdl_release_lock(), mdl_acquire_exclusive_locks() and mdl_try_acquire_exclusive_lock() are no longer responsible
        for removal of metadata lock requests from the context.
        One should explicitly call mdl_remove_all_locks() and
        mdl_remove_lock() to do this.
        Finally mdl_try_acquire_exclusive_lock() is now returs
        information about encountered lock conflict in separate
        out parameter since its return value is used for distinguishing
        between error (e.g. due to OOM) and success.
      e3b3907c
    • Konstantin Osipov's avatar
      Backport of: · b7e8b016
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2630.4.31
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-3726
      timestamp: Thu 2008-06-12 06:23:08 +0400
      message:
        Extend the signature of TABLE_LIST::init_one_table() to 
        initialize lengths
      
      This is part of WL#3726 post-review fixes.
      b7e8b016
    • Konstantin Osipov's avatar
      Backport of: · 7585067a
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2630.4.30
      Konstantin Osipov   2008-06-11
      Fix a potential cause of test failures.
      
      sql/sql_base.cc:
        0 may not be equal to (char*) 0 on 64 bit pointer/32 bit int machines.
      7585067a
    • Konstantin Osipov's avatar
      Backport of: · 3104af49
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2630.10.1
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-lock-tables-tidyup
      timestamp: Wed 2008-06-11 15:49:58 +0400
      message:
        WL#3726, review fixes.
        Now that we have metadata locks, we don't need to keep a crippled
        TABLE instance in the table cache to indicate that a table is locked.
        Remove all code that used this technique. Instead, rely on metadata
        locks and use the standard open_table() and close_thread_table()
        to manipulate with the table cache tables.
        Removes a list of functions that have become unused (see the comment
        for sql_base.cc for details).
        Under LOCK TABLES, keep a TABLE_LIST instance for each table
        that may be temporarily closed. For that, implement an own class for
        LOCK TABLES mode, Locked_tables_list.
      
      This is a pre-requisite patch for WL#4144.
      This is not exactly a backport: there is no new 
      online ALTER table in Celosia, so the old alter table
      code was changed to work with the new table cache API.
      
      
      mysql-test/r/lock.result:
        Update results (WL#3726 post-review patch).
      mysql-test/r/trigger-compat.result:
        We take the table from the table cache now, thus no warning.
      mysql-test/suite/rpl/r/rpl_trigger.result:
        We take the table from the table cache now, thus no warning.
      mysql-test/t/lock.test:
        Additional tests for LOCK TABLES mode (previously not covered by
        the test suite (WL#3726).
      sql/field.h:
        Remove reopen_table().
      sql/lock.cc:
        Remove an obsolete parameter of mysql_lock_remove().
        It's not used anywhere now either.
      sql/mysql_priv.h:
        Add 4 new open_table() flags.
        Remove declarations of removed functions.
      sql/sp_head.cc:
        Rename thd->mdl_el_root to thd->locked_tables_root.
      sql/sql_acl.cc:
        Use the new implementation of unlock_locked_tables().
      sql/sql_base.cc:
        Implement class Locked_tables_list.
        Implement close_all_tables_for_name().
        Rewrite close_cached_tables() to use the new reopen_tables().
        Remove reopen_table(), reopen_tables(), reopen_table_entry() 
        (ex. open_unireg_entry()), close_data_files_and_leave_as_placeholders(),
        close_handle_and_leave_table_as_placeholder(), close_cached_table(),
        table_def_change_share(), reattach_merge(), reopen_name_locked_table(),
        unlink_open_table().
        
        Move acquisition of a metadata lock into an own function
        - open_table_get_mdl_lock().
      sql/sql_class.cc:
        Deploy class Locked_tables_list.
      sql/sql_class.h:
        Declare class Locked_tables_list.
        Keep one instance of this class in class THD.
        Rename mdl_el_root to locked_tables_root.
      sql/sql_db.cc:
        Update a comment.
      sql/sql_insert.cc:
        Use the plain open_table() to open a just created table in
        CREATE TABLE .. SELECT.
      sql/sql_parse.cc:
        Use thd->locked_tables_list to enter and leave LTM_LOCK_TABLES mode.
      sql/sql_partition.cc:
        Deploy the new method of working with partitioned table locks.
      sql/sql_servers.cc:
        Update to the new signature of unlock_locked_tables().
      sql/sql_table.cc:
        In mysql_rm_table_part2(), the branch that removes a table under
        LOCK TABLES, make sure that the table being dropped
        is also removed from THD::locked_tables_list.
        Update ALTER TABLE and CREATE TABLE LIKE implementation to use
        open_table() and close_all_tables_for_name() instead of 
        reopen_tables().
      sql/sql_trigger.cc:
        Use the new locking way.
      sql/table.h:
        Add TABLE::pos_in_locked_tables, which is used only under
        LOCK TABLES.
      3104af49
  6. 01 Dec, 2009 9 commits
    • Konstantin Osipov's avatar
      Backport of: · e8a9191e
      Konstantin Osipov authored
      ```---------------------------------------------------------
      revno: 2630.9.3
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w3
      timestamp: Wed 2008-06-11 08:33:36 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
        Changed close_cached_tables() not to flush all unused TABLE
        instances when flushing individual table.
        Renamed expel_table_from_cache() to tdc_remove_table() and
        added enum parameter to be able more explicitly specify type
        of removal, rewrote its code to be more efficient.
      
      ******
      Backport of:
      ```
      
      ---------------------------------------------------------
      revno: 2630.9.4
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w3
      timestamp: Wed 2008-06-11 15:53:53 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After-review fixes in progress.
      
        Minor changes in order to improve code readability
        and simplify debugging.
      
      
      mysql-test/r/ps_ddl.result:
        Restore the original (correct) behaviour,
        now that the patch that fixes the regression
        introduced by the original patch for WL#3726 is fixed.
      mysql-test/t/ps_ddl.test:
        Restore the original (correct) behaviour,
        now that the patch that fixes the regression
        introduced by the original patch for WL#3726 is fixed
      sql/mysql_priv.h:
        Renamed expel_table_from_cache() to tdc_remove_table() 
        and added enum parameter to be able more explicitly specify 
        type of removal.
      sql/sql_base.cc:
        Changed close_cached_tables() not to flush all unused TABLE
        instances when flushing individual table.
        Renamed expel_table_from_cache() to tdc_remove_table() and added
        enum parameter to be able more explicitly specify type of
        removal, rewrote its code to be more efficient. As result removed
        relink_unused() function which is no longer used.
        ******
        Improved code in close_cached_tables() according to reviewer's
        comments.
      sql/sql_delete.cc:
        Renamed expel_table_from_cache() to tdc_remove_table() 
        and added enum parameter to be able more explicitly 
        specify type of removal.
      sql/sql_rename.cc:
        Renamed expel_table_from_cache() to tdc_remove_table() 
        and added enum parameter to be able more explicitly 
        specify type of removal.
      sql/sql_show.cc:
        Moved acquisition of high-prio shared metadata lock in which
        happens in fill_schema_table_from_frm() to separate function.
      sql/sql_table.cc:
        Renamed expel_table_from_cache() to tdc_remove_table() 
        and added enum parameter to be able more explicitly 
        specify type of removal.
      sql/sql_trigger.cc:
        Renamed expel_table_from_cache() to tdc_remove_table() 
        and added enum parameter to be able more explicitly 
        specify type of removal.
      e8a9191e
    • Konstantin Osipov's avatar
      Backport of: · f7ba9daf
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.9.2
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w3
      timestamp: Tue 2008-06-10 18:01:56 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
      
      sql/mdl.cc:
        Changed mdl_acquire_shared_lock() signature to accept MDL_CONTEXT
        as one of arguments as described in specification.
      sql/mdl.h:
        Changed mdl_acquire_shared_lock() signature to accept MDL_CONTEXT
         as one of arguments as described in specification.
      sql/sql_base.cc:
        Changed mdl_acquire_shared_lock() signature to accept MDL_CONTEXT
        as one of arguments as described in specification.
        Renamed handle_failed_open_table_attempt() to
        recover_from_failed_open_table_attempt() as suggested by review.
        Added comment clarifying why we need to check TABLE::db_stat
        while looking at TABLE instances open by other threads.
      sql/sql_show.cc:
        Changed mdl_acquire_shared_lock() signature to accept MDL_CONTEXT
        as one of arguments as described in specification.
      f7ba9daf
    • Konstantin Osipov's avatar
      Backport of: · db3f97c3
      Konstantin Osipov authored
      ------------------------------------------------------------ 
      revno: 2630.9.1 
      committer: Dmitry Lenev <dlenev@mysql.com> 
      branch nick: mysql-6.0-3726-w3 
      timestamp: Sun 2008-06-08 22:13:58 +0400 
      message: 
        WL#3726 "DDL locking for all metadata objects" 
         
        After review fixes in progress. 
         
        Some adjustments to the patch that removes thd->locked_tables
      
      sql/sp_head.cc:
        Fix conditions which were wrongly translated by previous patch.
      sql/sql_base.cc:
        close_thread_tables():
          Add comment clarifying control flow in case of LTM_LOCK_TABLES
          mode and statements requiring prelocking.
          Be consistent with other places where we clear
          OPTION_TABLE_LOCK flag.
        lock_tables():
          Always set THD::lock to 0 after freeing memory to which it
          points.
      db3f97c3
    • Konstantin Osipov's avatar
      Backport of: · 466ee7e5
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.27
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w2
      timestamp: Mon 2008-06-09 14:01:19 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
        Changed open_table() to return bool. This allows more easily to
        distinguish cases when this function succeeds but returns no TABLE
        instance (in case of view or in case of special kind of open) from
        cases when we have an error. Pointer to TABLE instance is now
        always returned in TABLE_LIST::table member.
      
        This change allows to get rid of false assumption in open_tables()
        implementation and makes it more clear.
      466ee7e5
    • Konstantin Osipov's avatar
      Backport of: · 5969dcda
      Konstantin Osipov authored
      ----------------------------------------------------------
      revno: 2630.4.26
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-prelocked_mode-to-push
      timestamp: Fri 2008-06-06 23:19:04 +0400
      message:
        WL#3726: work on review comments.
        Remove thd->locked_tables. Always store MYSQL_LOCK instances in
        thd->lock.
        Rename thd->prelocked_mode to thd->locked_tables_mode.
        Use thd->locked_tables_mode to determine if we
        are under LOCK TABLES. Update the code to not assume that
        if thd->lock is set, LOCK TABLES mode is off.
        Review comments.
      
      
      sql/ha_ndbcluster_binlog.cc:
        Don't unlock the lock under LOCK TABLES (safety).
      sql/handler.cc:
        There is no thd->locked_tables any more.
        Update comments.
      sql/lock.cc:
        There is no thd->locked_tables any more.
      sql/log.cc:
        Rename thd->prelocked_mode to thd->locked_tables_mode.
      sql/set_var.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sp_head.cc:
        Rename thd->prelocked_mode to thd->locked_tables_mode.
      sql/sql_base.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
        Remove thd->locked_tables.
      sql/sql_cache.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sql_class.cc:
        Avoid code duplication.
        Do not release the table locks prematurely if we're under LOCK TABLES.
        Use thd->locked_tables_mode instead of thd->locked_tables.
      sql/sql_class.h:
        Remove thd->locked_tables.
        Make prelocked mode a kind of LOCK TABLES mode.
        Update comments.
      sql/sql_cursor.cc:
        Update comments.
      sql/sql_insert.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
        Rename thd->prelocked_mode to thd->locked_tables_mode.
      sql/sql_load.cc:
        Rename thd->prelocked_mode to thd->locked_tables_mode.
      sql/sql_parse.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
        Remove thd->locked_tables.
      sql/sql_partition.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sql_rename.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sql_select.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sql_table.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sql_trigger.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sql_update.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      sql/sql_view.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      storage/myisam/ha_myisam.cc:
        Use thd->locked_tables_mode to determine if we are under LOCK TABLES.
      5969dcda
    • Konstantin Osipov's avatar
      Backport of: · d0a1f640
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.24
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w2
      timestamp: Fri 2008-06-06 14:28:58 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
        Get rid of upgradability and priority attributes of
        metadata lock requests by replacing them with two
        new types of lock requests MDL_SHARED_UPGRADABLE and
        MDL_SHARED_HIGH_PRIO correspondingly.
      d0a1f640
    • Konstantin Osipov's avatar
      Backport of: · 1480dafe
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.8.3
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w4
      timestamp: Thu 2008-06-05 10:48:36 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After-review fixes in progress.
      
        Adjust some comments that were using old terminology
        (name locks instead of exclusive metadata locks), brought
        some of them up-to-date with current situation in code.
      
      
      sql/sql_base.cc:
        Adjusted comments to use proper terminology.
      sql/sql_delete.cc:
        Adjusted comments to use proper terminology.
      sql/sql_handler.cc:
        Adjusted comments to use proper terminology.
      sql/sql_partition.cc:
        Adjusted comments to use proper terminology also fixed
        one comment to correspond to what really happens in code.
      sql/sql_show.cc:
        Adjusted comments to use proper terminology.
      sql/sql_table.cc:
        Adjusted comments to use proper terminology, brought
         one of them up-to-date with current situation.
      sql/sql_trigger.cc:
        Adjusted comments to use proper terminology.
      sql/table.h:
        Removed two unused members of TABLE_SHARE struct.
      1480dafe
    • Konstantin Osipov's avatar
      Backport of: · 93b55a00
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.20
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w2
      timestamp: Wed 2008-06-04 16:27:06 +0400
      message:
        WL#3726 "DDL locking for all metadata objects"
      
        After review fixes in progress.
      
        Got rid of TABLE_LIST::mdl_upgradable member and related functions
        by using special flag which to be passed to open_table() which
        asks it to take upgradable metadata lock on table being opened.
      
      
      sql/mysql_priv.h:
        Added one more argument to open_n_lock_single_table() call to be
        able to pass flags to open_table() and mysql_lock_tables() called
        by it.
        Added new flag for controlling open_table() behavior asks it to
        take upgradable metadata locks on tables open for write.
      sql/sql_base.cc:
        Added new flag for controlling open_table() behavior asks it to
        take upgradable metadata locks on tables open for write.
        This allowed us to get rid of TABLE_LIST::mdl_upgradable member.
        Added one more argument to open_n_lock_single_table() call to be
        able to pass flags to open_table() and mysql_lock_tables() called
        by it.
      sql/sql_insert.cc:
        Added one more argument to open_n_lock_single_table() call to be
        able to pass flags to open_table() and mysql_lock_tables() called
        by it.
      sql/sql_parse.cc:
        Got rid of TABLE_LIST::mdl_upgradable member by using special flag
        which to be passed to open_table() which asks it to take
        upgradable metadata lock on table being opened.  As result also
        got rid of adjust_mdl_locks_upgradability() function.
      sql/sql_table.cc:
        Got rid of TABLE_LIST::mdl_upgradable member and related functions
        by using special flag which to be passed to open_table() which
        asks it to take upgradable metadata lock on table being opened.
      sql/sql_view.cc:
        Got rid of TABLE_LIST::mdl_upgradable member and related functions
        by using special flag which to be passed to open_table() which
        asks it to take upgradable metadata lock on table being opened.
      sql/table.h:
        Got rid of TABLE_LIST::mdl_upgradable member and related functions
        by using special flag which to be passed to open_table() which
        asks it to take upgradable metadata lock on table being opened.
      93b55a00
    • Konstantin Osipov's avatar
      Backport of: · 1ed585ad
      Konstantin Osipov authored
      ---------------------------------------------
      2630.7.3 Konstantin Osipov       2008-06-02
              Various style changes preceding the removal of reopen_table().
      (Post-review fixes for WL#3726).
      
      
      sql/event_db_repository.cc:
        Update to use the new signature of TABLE_LIST::init_one_table().
      sql/mysql_priv.h:
        Move close_cached_table() and wait_while_table_is_used()
        to sql_base.cc.
      sql/sql_base.cc:
        Move close_cached_table() and wait_while_table_is_used()
        from sql_table.cc.
      sql/sql_table.cc:
        Move close_cached_table() and wait_while_table_is_used()
        to sql_base.cc.
      sql/table.h:
        Update the signature of TABLE_LIST::init_one_table().
      1ed585ad
  7. 30 Nov, 2009 9 commits
    • Konstantin Osipov's avatar
      Backport of: · b05303c1
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.18
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w2
      timestamp: Tue 2008-06-03 21:07:58 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
        Now during upgrading/downgrading metadata locks we deal with
        individual metadata lock requests rather than with all requests
        for this object in the context. This makes API a bit more clear
        and makes adjust_mdl_locks_upgradability() much nicer.
      
      
      sql/lock.cc:
        lock_table_names():
          Set TABLE_LIST::mdl_lock_data when allocating new metadata
          lock request object for table list element.
      sql/mdl.cc:
        Now during upgrading/downgrading metadata locks we deal with
        individual metadata lock requests rather than with all
        requests for this object in the context. Adjusted upgrade/
        downgrade functions accordingly.
        We also got rid of mdl_release_exclusive_locks() and
        now release locks individually. To simplify this process
        mdl_release_all_locks_for_name() was introduced.
      sql/mdl.h:
        Now during upgrading/downgrading metadata locks we deal with
        individual metadata lock requests rather than with all
        requests for this object in the context. Adjusted upgrade/
        downgrade functions accordingly.
        We also got rid of mdl_release_exclusive_locks() and
        now release locks individually. To simplify this process
        mdl_release_all_locks_for_name() was introduced.
      sql/sql_base.cc:
        Now during upgrading/downgrading metadata locks we deal with
        individual metadata lock requests rather than with all
        requests for this object in the context.
        We also got rid of mdl_release_exclusive_locks() and
        now release locks individually.
      sql/sql_parse.cc:
        adjust_mdl_locks_upgradability() is much simplier now due to the
        fact that now during upgrading/downgrading metadata locks we
        deal with individual metadata lock requests rather than with
        all requests for this object in the context.
      sql/sql_table.cc:
        Now during upgrading/downgrading metadata locks we deal with
        individual metadata lock requests rather than with all
        requests for this object in the context. Adjusted upgrade/
        downgrade functions accordingly.
        We also got rid of mdl_release_exclusive_locks() and
        now release locks individually. To simplify this process
        mdl_release_all_locks_for_name() was introduced.
      sql/sql_trigger.cc:
        ow during upgrading/downgrading metadata locks we deal with
        individual metadata lock requests rather than with all
        requests for this object in the context.
      b05303c1
    • Konstantin Osipov's avatar
      Backport of: · e23046d1
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.17
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w2
      timestamp: Thu 2008-05-29 16:52:56 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
        "The great correction of names".
      
        Renamed MDL_LOCK and MDL_LOCK_DATA classes to make usage of
        these names in metadata locking subsystem consistent with
        other parts of server (i.e. thr_lock.cc). Now we MDL_LOCK_DATA
        corresponds to request for a lock and MDL_LOCK to the lock
        itself. Adjusted code in MDL subsystem and other places
        using these classes accordingly.
        Did similar thing for GLOBAL_MDL_LOCK_DATA class and also
        changed name of its members to correspond to names of
        MDL_LOCK_DATA members.
        Finally got rid of usage of one letter variables in MDL
        code since it makes code harder to search in (according
        to reviewer).
      e23046d1
    • Konstantin Osipov's avatar
      Backport of: · cf45b61a
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.16
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Thu 2008-05-29 09:45:02 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review changes in progress.
      
        Tweaked some comments and did some renames to
        avoid ambiguites.
      
      
      sql/mysql_priv.h:
        Removed name_lock_locked_table() function.
      sql/sql_base.cc:
        Got rid of name_lock_locked_table() function after replacing
        the only call to it with its body.
        Simplified open_table() code by making "action" argument
        mandatory (i.e. one now should always pass non-0 pointer
        in this argument).
        Renamed TABLE_LIST::open_table_type to open_type to
        avoid confusing it with type of table.
        Adjusted comments according to review.
      sql/sql_handler.cc:
        Added comment clarifying in which cases we can have TABLE::mdl_lock
        set to 0.
      sql/sql_insert.cc:
        Now the 4th argument of open_table() is mandatory (it makes
        no sense to complicate open_table() code when we can simply
        pass dummy variable).
      sql/sql_parse.cc:
        Renamed TABLE_LIST::open_table_type to open_type to
        avoid confusing it with type of table.
      sql/sql_prepare.cc:
        Renamed TABLE_LIST::open_table_type to open_type to
        avoid confusing it with type of table.
      sql/sql_table.cc:
        Now the 4th argument of open_table() is mandatory (it makes
        no sense to complicate open_table() code when we can simply
        pass dummy variable).
      sql/sql_trigger.cc:
        Replaced the only call to name_lock_locked_table() function
        with its body.
      sql/sql_view.cc:
        Renamed TABLE_LIST::open_table_type to open_type to
        avoid confusing it with type of table.
      sql/table.h:
        Renamed TABLE_LIST::open_table_type to open_type (to
        avoid confusing it with type of table) and improved
        comments describing this member.
      cf45b61a
    • Konstantin Osipov's avatar
      Backport of: · 0dcead9f
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.14
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Wed 2008-05-28 12:16:03 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress. Removed unused code and
        adjusted names of functions/methods to better reflect
        their current function.
      
      
      sql/mysql_priv.h:
        Changed names of close_data_files_and_morph_locks() and
        close_handle_and_leave_table_as_lock() to better reflect
        their current function (locking is now responsibility
        of metadata locking subsystem).
      sql/sql_base.cc:
        Changed names of close_data_files_and_morph_locks() and
        close_handle_and_leave_table_as_lock() to better reflect
        their current function (locking is now responsibility
        of metadata locking subsystem). Also adjusted comments
        describing these functions.
        Got rid of TABLE::open_placeholder since it is no longer
        used (its value is never read anywhere).
        TABLE::needs_reopen_or_name_lock() was renamed to needs_reopen()
        since we no longer use name-locks
      sql/sql_handler.cc:
        TABLE::needs_reopen_or_name_lock() was renamed to needs_reopen()
        since we no longer use name-locks.
      sql/sql_insert.cc:
        TABLE::needs_reopen_or_name_lock() was renamed to needs_reopen()
        since we no longer use name-locks
      sql/sql_partition.cc:
        Changed name of close_data_files_and_morph_locks() to
        better reflect its current function (locking is now
        responsibility of metadata locking subsystem).
      sql/sql_table.cc:
        Changed names of close_data_files_and_morph_locks() and
        close_handle_and_leave_table_as_lock() to better reflect
        their current function (locking is now responsibility
        of metadata locking subsystem).
        Got rid of TABLE::open_placeholder since it is no longer
        used.
      sql/sql_trigger.cc:
        Changed name of close_data_files_and_morph_locks() to
        better reflect its current function (locking is now
        responsibility of metadata locking subsystem).
      sql/table.h:
        Got rid of TABLE::open_placeholder which is no longer used
        altough its value was set in several places no code reads it).
        Removed unused TABLE::is_name_opened() method.
        Finally TABLE::needs_reopen_or_name_lock() was renamed to
        needs_reopen() since we no longer use name-locks.
      0dcead9f
    • Konstantin Osipov's avatar
      Backport of: · b58e7956
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.13
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Wed 2008-05-28 12:07:30 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
        Get rid of remove_table_from_cache() function since it was
        doing two things at once -- waiting while no one uses particular
        table (now job of metadata locking) and removing TABLE/TABLE_SHARE
        instances from table definition cache (now job of
        expel_table_from_cache()).
      
      
      
      sql/mysql_priv.h:
        Got rid of remove_table_from_cache() function. Now one
                should use exclusive metadata lock for waiting until all
                other connections will stop using particular table and
                use expel_table_from_cache() for removing table instances
                and table share from table definition cache.
                Removed unused mysql_wait_completed_table() function.
      sql/sql_base.cc:
        Got rid of remove_table_from_cache() function. Now one
        should use exclusive metadata lock for waiting until all
        other connections will stop using particular table and
        use expel_table_from_cache() for removing table instances
        and table share from table definition cache.
                Removed unused mysql_wait_completed_table() function.
      sql/sql_table.cc:
        Get rid of two last places where we use remove_table_from_cache()
        by using wait_while_table_is_used() (which uses metadata locks)
        and close_cached_tables() instead.
      b58e7956
    • Konstantin Osipov's avatar
      Backport of: · cd055f0e
      Konstantin Osipov authored
      -------------------------------------------------------------------
      revno: 2630.6.6
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-3726
      timestamp: Tue 2008-05-27 16:15:44 +0400
      message:
      Implement code review fixes for WL#3726 "DDL locking for all
      metadata objects": cleanup the code from share->mutex
      acquisitions, which are now obsolete.
      
      sql/ha_partition.cc:
        Rename share->mutex to share->LOCK_ha_data. The mutex never
        protected the entire share. The right way to protect a share
        is to acquire an MDL lock.
      sql/ha_partition.h:
        Rename share->mutex to share->LOCK_ha_data.
      sql/sql_base.cc:
        Remove LOCK_table_share. Do not acquire share->mutex when
        deleting a table share or incrementing its ref_count.
        All these operations are and must continue to be protected by LOCK_open
        and respective MDL locks.
      sql/sql_view.cc:
        Remove acquisition of share->mutex when incrementing share->ref_count.
      sql/table.cc:
        Simplify release_table_shar() by removing dead code related
        to share->mutex from it.
      sql/table.h:
        Rename TABLE_SHARE::mutex to TABLE_SHARE::LOCK_ha_data
        to better reflect its purpose.
      storage/myisam/ha_myisam.cc:
        Rename share->mutex to share->LOCK_ha_data.
      cd055f0e
    • Konstantin Osipov's avatar
      Backport of: · 40d98edd
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.6.1
      committer: Konstantin Osipov <konstantin@mysql.com>
      branch nick: mysql-6.0-3726
      timestamp: Tue 2008-05-27 13:45:34 +0400
      message:
        Remove an unused argument from release_table_share().
        Remove unused members from TABLE_SHARE struct.
        Review comments in scope of WL#3726 "DDL locking for all metadata 
        objects"
      
      sql/mysql_priv.h:
        Update declaration.
      sql/sql_base.cc:
        Upate declaration and the comment (release_share()).
      sql/sql_plist.h:
        A cosmetic change, is_empty() is a const method.
      sql/sql_table.cc:
        Update to use the new declaration of release_table_share().
      sql/sql_view.cc:
        Update to use the new declaration of release_table_share().
      sql/table.cc:
        Update to use the new declaration of release_table_share().
        Remove dead code.
      sql/table.h:
        Remove unused members of TABLE.
      40d98edd
    • Konstantin Osipov's avatar
      Backport of: · aeebede1
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 2630.4.11
      committer: Dmitry Lenev <dlenev@mysql.com>
      branch nick: mysql-6.0-3726-w
      timestamp: Tue 2008-05-27 21:31:53 +0400
      message:
        WL#3726 "DDL locking for all metadata objects".
      
        After review fixes in progress.
      
        Changed mysql_lock_tables() to be no longer responsible for
        reopening table if waiting for the lock on it was aborted.
        This allows to get rid of several annoying functions.
      
      
      sql/ha_ndbcluster_binlog.cc:
        lock_tables() now also accepts set of options to be passed to
        mysql_lock_tables().
      sql/lock.cc:
        Changed mysql_lock_tables() always requests caller to reopen
        table instead doing this on its own when waiting for lock was
        aborted. This allows us to get rid of several functions which
        were used in rare cases and significantly complicated our life.
      sql/log_event_old.cc:
        lock_tables() now also accepts set of options to be passed
        to mysql_lock_tables().
      sql/mysql_priv.h:
        Now mysql_lock_tables() always requests caller to reopen
        table instead doing this on its own when waiting for lock was
        aborted. So we no longer need wait_for_tables() and
        table_is_used() functions and MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN
        flag.
        open_and_lock_table_derived() and lock_tables() now accept
        options to be passed to open_tables() and mysql_lock_tables()
        calls.
      sql/sql_base.cc:
        Since now mysql_lock_tables() always requests caller to
        reopen table instead doing this on its own when waiting for
        lock was aborted we no longer need wait_for_tables(),
        table_is_used() and close_old_data_files() functions.
        open_and_lock_table_derived() and lock_tables() now accept
        options to be passed to open_tables() and mysql_lock_tables()
        calls. This was needed in order to get rid of redundant code
        in open_system_tables_for_read() function.
      sql/sql_handler.cc:
        mysql_lock_tables() is now always requests reopen if waiting
        for lock is aborted. MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN flag
        was removed.
      sql/sql_insert.cc:
        handle_delayed_insert():
        Since mysql_lock_tables() is no longer responsible for
        reopening tables when waiting for lock was aborted we have
        to handle such situation outside of this function. To simplify
        this extracted code opening table for delayed insert thread to
        separate method of Delayed_insert class.
      sql/sql_update.cc:
        lock_tables() now also accepts set of options to be passed
        to mysql_lock_tables().
      aeebede1
    • 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
  8. 24 Nov, 2009 2 commits
    • Konstantin Osipov's avatar
      Backport of: · 932a2751
      Konstantin Osipov authored
      ------------------------------------------------------------
      revno: 3559
      committer: Davi Arnaut <Davi.Arnaut@Sun.COM>
      branch nick: mysql-pe
      timestamp: Fri 2009-08-28 15:23:16 -0300
      message:
      Break down a large and obnoxious "if" statement. Multiple "if" statements
      makes it easy to understand and follow the code (specially in a debugger).
      
      sql/sql_base.cc:
        Break down a large and obnoxious "if" statement. Multiple "if" statements
        makes it easy to understand and follow the code (specially in a debugger).
      932a2751
    • Konstantin Osipov's avatar
      Backport of: · 9a9e8d23
      Konstantin Osipov authored
      ----------------------------------------------------------------------
      ChangeSet@1.2571, 2008-04-08 12:30:06+02:00, vvaintroub@wva. +122 -0
        Bug#32082 : definition of VOID in my_global.h conflicts with Windows
        SDK headers
        
        VOID macro is now removed. Its usage is replaced with void cast.
        In some cases, where cast does not make much sense (pthread_*, printf, 
        hash_delete, my_seek), cast is ommited.
      
      
      client/mysqladmin.cc:
        Bug#32082 : remove VOID macro
      client/mysqldump.c:
        Bug#32082 : remove VOID macro
      client/mysqlimport.c:
        Bug#32082 : remove VOID macro
      client/mysqlslap.c:
        Bug#32082 : remove VOID macro
      client/mysqltest.cc:
        Bug#32082 : remove VOID macro
      client/sql_string.cc:
        Bug#32082 : remove VOID macro
      extra/comp_err.c:
        Bug#32082 : remove VOID macro
      extra/replace.c:
        Bug#32082 : remove VOID macro
      include/my_alarm.h:
        Bug#32082 : remove VOID macro
      include/my_global.h:
        Bug#32082 : remove VOID macro
      libmysql/libmysql.c:
        Bug#32082 : remove VOID macro
      mysys/errors.c:
        Bug#32082 : remove VOID macro
      mysys/hash.c:
        Bug#32082 : remove VOID macro
      mysys/mf_iocache2.c:
        Bug#32082 : remove VOID macro
      mysys/mf_loadpath.c:
        Bug#32082 : remove VOID macro
      mysys/mf_path.c:
        Bug#32082 : remove VOID macro
      mysys/my_append.c:
        Bug#32082 : remove VOID macro
      mysys/my_clock.c:
        Bug#32082 : remove VOID macro
      mysys/my_copy.c:
        Bug#32082 : remove VOID macro
      mysys/my_fstream.c:
        Bug#32082 : remove VOID macro
      mysys/my_getwd.c:
        Bug#32082 : remove VOID macro
      mysys/my_lib.c:
        Bug#32082 : remove VOID macro
      mysys/my_lockmem.c:
        Bug#32082 : remove VOID macro
      mysys/my_pthread.c:
        Bug#32082 : remove VOID macro
      mysys/my_redel.c:
        Bug#32082 : remove VOID macro
      mysys/stacktrace.c:
        Bug#32082 : remove VOID macro
      mysys/thr_alarm.c:
        Bug#32082 : remove VOID macro
      mysys/thr_lock.c:
        Bug#32082 : remove VOID macro
      sql/derror.cc:
        Bug#32082 : remove VOID macro
      sql/des_key_file.cc:
        Bug#32082 : remove VOID macro
      sql/discover.cc:
        Bug#32082 : remove VOID macro
      sql/field.cc:
        Bug#32082 : remove VOID macro
      sql/filesort.cc:
        Bug#32082 : remove VOID macro
      sql/ha_ndbcluster.cc:
        Bug#32082 : remove VOID macro
      sql/ha_partition.cc:
        Bug#32082 : remove VOID macro
      sql/handler.cc:
        Bug#32082 : remove VOID macro
      sql/hostname.cc:
        Bug#32082 : remove VOID macro
      sql/init.cc:
        Bug#32082 : remove VOID macro
      sql/item.cc:
        Bug#32082 : remove VOID macro
      sql/item_cmpfunc.cc:
        Bug#32082 : remove VOID macro
      sql/item_strfunc.cc:
        Bug#32082 : remove VOID macro
      sql/lock.cc:
        Bug#32082 : remove VOID macro
      sql/log.cc:
        Bug#32082 : remove VOID macro
      sql/log_event.cc:
        Bug#32082 : remove VOID macro
      sql/mysqld.cc:
        Bug#32082 : remove VOID macro
      sql/opt_range.h:
        Bug#32082 : remove VOID macro
      sql/protocol.cc:
        Bug#32082 : remove VOID macro
      sql/records.cc:
        Bug#32082 : remove VOID macro
      sql/sp_head.cc:
        Bug#32082 : remove VOID macro
      sql/sp_pcontext.cc:
        Bug#32082 : remove VOID macro
      sql/sql_acl.cc:
        Bug#32082 : remove VOID macro
      sql/sql_base.cc:
        Bug#32082 : remove VOID macro
      sql/sql_cache.cc:
        Bug#32082 : remove VOID macro
      sql/sql_connect.cc:
        Bug#32082 : remove VOID macro
      sql/sql_db.cc:
        Bug#32082 : remove VOID macro
      sql/sql_delete.cc:
        Bug#32082 : remove VOID macro
      sql/sql_handler.cc:
        Bug#32082 : remove VOID macro
      sql/sql_insert.cc:
        Bug#32082 : remove VOID macro
      sql/sql_map.cc:
        Bug#32082 : remove VOID macro
      sql/sql_parse.cc:
        Bug#32082 : remove VOID macro
      sql/sql_select.cc:
        Bug#32082 : remove VOID macro
      sql/sql_servers.cc:
        Bug#32082 : remove VOID macro
      sql/sql_show.cc:
        Bug#32082 : remove VOID macro
      sql/sql_string.cc:
        Bug#32082 : remove VOID macro
      sql/sql_table.cc:
        Bug#32082 : remove VOID macro
      sql/sql_test.cc:
        Bug#32082 : remove VOID macro
      sql/sql_trigger.cc:
        Bug#32082 : remove VOID macro
      sql/sql_update.cc:
        Bug#32082 : remove VOID macro
      sql/sql_view.cc:
        Bug#32082 : remove VOID macro
      sql/table.cc:
        Bug#32082 : remove VOID macro
      sql/tztime.cc:
        Bug#32082 : remove VOID macro
      sql/udf_example.c:
        Bug#32082 : remove VOID macro
      sql/uniques.cc:
        Bug#32082 : remove VOID macro
      sql/unireg.cc:
        Bug#32082 : remove VOID macro
      storage/archive/ha_archive.cc:
        Bug#32082 : remove VOID macro
      storage/blackhole/ha_blackhole.cc:
        Bug#32082 : remove VOID macro
      storage/csv/ha_tina.cc:
        Bug#32082 : remove VOID macro
      storage/csv/transparent_file.cc:
        Bug#32082 : remove VOID macro
      storage/example/ha_example.cc:
        Bug#32082 : remove VOID macro
      storage/federated/ha_federated.cc:
        Bug#32082 : remove VOID macro
      storage/heap/hp_clear.c:
        Bug#32082 : remove VOID macro
      storage/heap/hp_create.c:
        Bug#32082 : remove VOID macro
      storage/heap/hp_test1.c:
        Bug#32082 : remove VOID macro
      storage/heap/hp_test2.c:
        Bug#32082 : remove VOID macro
      storage/innobase/handler/ha_innodb.cc:
        Bug#32082 : remove VOID macro
      storage/myisam/ft_eval.c:
        Bug#32082 : remove VOID macro
      storage/myisam/ha_myisam.cc:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_changed.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_check.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_close.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_create.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_dbug.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_delete.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_delete_all.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_dynrec.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_info.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_locking.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_log.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_open.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_packrec.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_panic.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_rsame.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_statrec.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_test1.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_test2.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_test3.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_update.c:
        Bug#32082 : remove VOID macro
      storage/myisam/mi_write.c:
        Bug#32082 : remove VOID macro
      storage/myisam/myisamchk.c:
        Bug#32082 : remove VOID macro
      storage/myisam/myisamlog.c:
        Bug#32082 : remove VOID macro
      storage/myisam/myisampack.c:
        Bug#32082 : remove VOID macro
      storage/myisam/sort.c:
        Bug#32082 : remove VOID macro
      storage/myisammrg/myrg_close.c:
        Bug#32082 : remove VOID macro
      storage/myisammrg/myrg_create.c:
        Bug#32082 : remove VOID macro
      storage/myisammrg/myrg_open.c:
        Bug#32082 : remove VOID macro
      strings/str_test.c:
        Bug#32082 : remove VOID macro
      tests/thread_test.c:
        Bug#32082 : remove VOID macro
      9a9e8d23
  9. 13 Nov, 2009 1 commit
    • unknown's avatar
      Backport Bug #45827 Stmt using two autoinc values does not produce unsafe warning · 0d46e588
      unknown authored
            
      One statement that have more than one different tables to update with 
      autoinc columns just was marked as unsafe in mixed mode, so the unsafe 
      warning can't be produced in statement mode.
            
      To fix the problem, mark the statement as unsafe in statement mode too.
      
      
      mysql-test/extra/rpl_tests/rpl_insert_id.test:
        The test case is updated due to the patch of bug#45827.
      mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result:
        The test result is updated due to the patch of bug#45827.
      mysql-test/suite/binlog/r/binlog_unsafe.result:
        Test result for bug#45827.
      mysql-test/suite/binlog/t/binlog_unsafe.test:
        Added test to verify if stmt that have more than one
        different tables to update with autoinc columns will 
        produce unsafe warning
      mysql-test/suite/rpl/r/rpl_stm_auto_increment_bug33029.result:
        The test result is updated due to the patch of bug#45827.
      mysql-test/suite/rpl/t/rpl_trigger.test:
        The test case is updated due to the patch of bug#45827.
      mysql-test/suite/rpl/t/rpl_variables_stm.test:
        The test case is updated due to the patch of bug#45827.
      sql/sql_base.cc:
        Reomved the 'set_current_stmt_binlog_row_based_if_mixed' function 
        for producing unsafe warnings by executing 'decide_logging_format' 
        function later in statement mode
      0d46e588
  10. 03 Nov, 2009 1 commit
    • unknown's avatar
      BUG#48216 Replication fails on all slaves after upgrade to 5.0.86 on master · 98198851
      unknown authored
      When a sessione is closed, all temporary tables of the session are automatically 
      dropped and are binlogged. But it will be binlogged with wrong database names when
      the length of the temporary tables' database names are greater than the 
      length of the current database name or the current database is not set.
      
      Query_log_event's db_len is forgot to set when Query_log_event's db is set.
      This patch wrote code to set db_len immediately after db has set.
      
      
      98198851