An error occurred fetching the project authors.
  1. 26 Feb, 2016 2 commits
  2. 04 Mar, 2015 1 commit
  3. 13 Jan, 2015 1 commit
  4. 28 Dec, 2014 1 commit
  5. 05 Dec, 2014 1 commit
  6. 10 Jun, 2014 1 commit
  7. 28 Mar, 2014 1 commit
    • Sergey Vojtovich's avatar
      MDEV-5964 - main.mdev-504 unveils assertion failure in · 71064cbe
      Sergey Vojtovich authored
                  TABLE_SHARE::visit_subgraph
      
      tc_acquire_table() is not ready to update TABLE::in_use without mutex:
      thr1: table= free_tables.pop_front(); // table->in_use is 0
      thr2: tdc_remove_table();
      thr2: find_deadlock(); // assert(table->in_use != 0)
      thr1: table->in_use= thd;
      
      Protect update of TABLE::in_use by LOCK_table_share.
      71064cbe
  8. 20 Mar, 2014 1 commit
  9. 06 Mar, 2014 1 commit
    • Sergey Vojtovich's avatar
      MDEV-5675 - Performance: my_hash_sort_bin is called too often · b95c8ce5
      Sergey Vojtovich authored
      Reduced number of my_hash_sort_bin() calls from 4 to 1 per query.
      Reduced number of memory accesses done by my_hash_sort_bin().
      
      Details:
      - let MDL subsystem use pre-calculated hash value for hash
        inserts and deletes
      - let table cache use pre-calculated MDL hash value
      - MDL namespace is excluded from hash value calculation, so that
        hash value can be used by table cache as is
      - hash value for MDL is calculated as resulting hash value + MDL
        namespace
      - extended hash implementation to accept user defined hash function
      b95c8ce5
  10. 13 Feb, 2014 3 commits
    • Sergey Vojtovich's avatar
      MDEV-5597 - Reduce usage of LOCK_open: LOCK_flush · fd1437df
      Sergey Vojtovich authored
      Replaced LOCK_flush with per-share conditional variable.
      fd1437df
    • Sergey Vojtovich's avatar
      MDEV-5492 - Reduce usage of LOCK_open: TABLE::in_use · 048e9c40
      Sergey Vojtovich authored
      Move TABLE::in_use out of LOCK_open.
      
      This is done with assumtion that foreign threads accessing TABLE::in_use
      will only need consistent value _after_ marking table for flush and purging
      unused table instances. In this case TABLE::in_use will always point to a
      valid thread object.
      
      Previously FLUSH TABLES thread may wait for tables flushed subsequently by
      concurrent threads which breaks the above assumption, e.g.:
      open tables: t1 (version= 1)
      thr1 (FLUSH TABLES): refresh_version++
      thr1 (FLUSH TABLES): purge table cache
      open tables: none
      thr2 (SELECT * FROM t1): open tables: t1
      open tables: t1 (version= 2)
      thr2 (FLUSH TABLES): refresh_version++
      thr2 (FLUSH TABLES): purge table cache
      thr1 (FLUSH TABLES): wait for old tables (including t1 with version 2)
      
      It is fixed so that FLUSH TABLES waits only for tables that were open
      heretofore.
      048e9c40
    • Sergey Vojtovich's avatar
      MDEV-5403 - Reduce usage of LOCK_open: tc_count · a25d87e5
      Sergey Vojtovich authored
      Lock-free tc_count.
      a25d87e5
  11. 29 Jan, 2014 1 commit
    • Michael Widenius's avatar
      Implementation of MDEV-5491: CREATE OR REPLACE TABLE · 7ffc9da0
      Michael Widenius authored
      Using CREATE OR REPLACE TABLE is be identical to
      
      DROP TABLE IF EXISTS table_name;
      CREATE TABLE ...;
      
      Except that:
      
      * CREATE OR REPLACE is be atomic (now one can create the same table between drop and create).
      * Temporary tables will not shadow the table name for the DROP as the CREATE TABLE tells us already if we are using a temporary table or not.
      * If the table was locked with LOCK TABLES, the new table will be locked with the same lock after it's created.
      
      Implementation details:
      - We don't anymore open the to-be-created table during CREATE TABLE, which the original code did.
        - There is no need to open a table we are planning to create. It's enough to check if the table exists or not.
      - Removed some of duplicated code for CREATE IF NOT EXISTS.
      - Give an error when using CREATE OR REPLACE with IF NOT EXISTS (conflicting options).
      - As a side effect of the code changes, we don't anymore have to internally re-prepare prepared statements with CREATE TABLE if the table exists.
      - Made one code path for all testing if log table are in use.
      - Better error message if one tries to create/drop/alter a log table in use
      - Added back disabled rpl_row_create_table test as it now seams to work and includes a lot of interesting tests.
      - Added HA_LEX_CREATE_REPLACE to mark if we are using CREATE OR REPLACE
      - Aligned CREATE OR REPLACE parsing code in sql_yacc.yy for TABLE and VIEW
      - Changed interface for drop_temporary_table() to make it more reusable
      - Changed Locked_tables_list::init_locked_tables() to work on the table object instead of the table list object. Before this it used a mix of both, which was not good.
      - Locked_tables_list::unlock_locked_tables(THD *thd) now requires a valid thd argument. Old usage of calling this with 0 i changed to instead call Locked_tables_list::reset()
      - Added functions Locked_tables_list:restore_lock() and Locked_tables_list::add_back_last_deleted_lock() to be able to easily add back a locked table to the lock list.
      - Added restart_trans_for_tables() to be able to restart a transaction.
      - DROP_ACL is required if one uses CREATE TABLE OR REPLACE.
      - Added drop of normal and temporary tables in create_table_imp() if CREATE OR REPLACE was used.
      - Added reacquiring of table locks in mysql_create_table() and mysql_create_like_table()
      
      
      
      
      mysql-test/include/commit.inc:
        With new code we get fewer status increments
      mysql-test/r/commit_1innodb.result:
        With new code we get fewer status increments
      mysql-test/r/create.result:
        Added testing of create or replace with timeout
      mysql-test/r/create_or_replace.result:
        Basic testing of CREATE OR REPLACE TABLE
      mysql-test/r/partition_exchange.result:
        New error message
      mysql-test/r/ps_ddl.result:
        Fewer reprepares with new code
      mysql-test/suite/archive/discover.result:
        Don't rediscover archive tables if the .frm file exists
        (Sergei will look at this if there is a better way...)
      mysql-test/suite/archive/discover.test:
        Don't rediscover archive tables if the .frm file exists
        (Sergei will look at this if there is a better way...)
      mysql-test/suite/funcs_1/r/innodb_views.result:
        New error message
      mysql-test/suite/funcs_1/r/memory_views.result:
        New error message
      mysql-test/suite/rpl/disabled.def:
        rpl_row_create_table should now be safe to use
      mysql-test/suite/rpl/r/rpl_row_create_table.result:
        Updated results after adding back disabled test
      mysql-test/suite/rpl/t/rpl_create_if_not_exists.test:
        Added comment
      mysql-test/suite/rpl/t/rpl_row_create_table.test:
        Added CREATE OR REPLACE TABLE test
      mysql-test/t/create.test:
        Added CREATE OR REPLACE TABLE test
      mysql-test/t/create_or_replace-master.opt:
        Create logs
      mysql-test/t/create_or_replace.test:
        Basic testing of CREATE OR REPLACE TABLE
      mysql-test/t/partition_exchange.test:
        Error number changed as we are now using same code for all log table change issues
      mysql-test/t/ps_ddl.test:
        Fewer reprepares with new code
      sql/handler.h:
        Moved things around a bit in a structure to get better alignment.
        Added HA_LEX_CREATE_REPLACE to mark if we are using CREATE OR REPLACE
        Added 3 elements to end of HA_CREATE_INFO to be able to store state to add backs locks in case of LOCK TABLES.
      sql/log.cc:
        Reimplemented check_if_log_table():
        - Simpler and faster usage
        - Can give error messages
        
        This gives us one code path for allmost all error messages if log tables are in use
      sql/log.h:
        New interface for check_if_log_table()
      sql/slave.cc:
        More logging
      sql/sql_alter.cc:
        New interface for check_if_log_table()
      sql/sql_base.cc:
        More documentation
        Changed interface for drop_temporary_table() to make it more reusable
        Changed Locked_tables_list::init_locked_tables() to work on the table object instead of the table list object. Before this it used a mix of both, which was not good.
        Locked_tables_list::unlock_locked_tables(THD *thd) now requires a valid thd argument.  Old usage of calling this with 0 i changed to instead call Locked_tables_list::reset()
        Added functions Locked_tables_list:restore_lock() and Locked_tables_list::add_back_last_deleted_lock() to be able to easily add back a locked table to the lock list.
        Check for command number instead of open_strategy of CREATE TABLE was used.
        Added restart_trans_for_tables() to be able to restart a transaction.  This was needed in "create or replace ... select" between the drop table and the select.
      sql/sql_base.h:
        Added and updated function prototypes
      sql/sql_class.h:
        Added new prototypes to Locked_tables_list class
        Added extra argument to select_create to avoid double call to eof() or send_error()
        - I needed this in some edge case where the table was not created against expections.
      sql/sql_db.cc:
        New interface for check_if_log_table()
      sql/sql_insert.cc:
        Remember position to lock information so that we can reaquire table lock for LOCK TABLES + CREATE OR REPLACE TABLE SELECT. Later add back the lock by calling restore_lock().
        Removed one not needed indentation level in create_table_from_items()
        Ensure we don't call send_eof() or abort_result_set() twice.
      sql/sql_lex.h:
        Removed variable that I temporarly added in an earlier changeset
      sql/sql_parse.cc:
        Removed old test code (marked with QQ)
        Ensure that we have open_strategy set as TABLE_LIST::OPEN_STUB in CREATE TABLE
        Removed some IF NOT EXISTS code as this is now handled in create_table_table_impl().
        Set OPTION_KEEP_LOGS later. This code had to be moved as the test for IF EXISTS has changed place.
        DROP_ACL is required if one uses CREATE TABLE OR REPLACE.
      sql/sql_partition_admin.cc:
        New interface for check_if_log_table()
      sql/sql_rename.cc:
        New interface for check_if_log_table()
      sql/sql_table.cc:
        New interface for check_if_log_table()
        Moved some code in mysql_rm_table() under a common test.
        - Safe as temporary tables doesn't have statistics.
        - !is_temporary_table(table) test was moved out from drop_temporary_table() and merged with upper level code.
        - Added drop of normal and temporary tables in create_table_imp() if CREATE OR REPLACE was used.
        - Added reacquiring of table locks in mysql_create_table() and mysql_create_like_table()
        - In mysql_create_like_table(), restore table->open_strategy() if it was changed.
        - Re-test if table was a view after opening it.
      sql/sql_table.h:
        New prototype for mysql_create_table_no_lock()
      sql/sql_yacc.yy:
        Added syntax for CREATE OR REPLACE TABLE
        Reuse new code for CREATE OR REPLACE VIEW
      sql/table.h:
        Added name for enum type
      sql/table_cache.cc:
        More DBUG
      7ffc9da0
  12. 12 Dec, 2013 1 commit
  13. 10 Dec, 2013 1 commit
    • Sergey Vojtovich's avatar
      MDEV-4956 - Reduce usage of LOCK_open: TABLE_SHARE::tdc.used_tables · 98c4f167
      Sergey Vojtovich authored
      - tc_acquire_table and tc_release_table do not access
        TABLE_SHARE::tdc.used_tables anymore
      - in tc_acquire_table(): release LOCK_tdc after we relase LOCK_open
        (saves a few CPU cycles in critical section)
      - in tc_release_table(): if we reached table cache threshold, evict
        to-be-released table without moving it to unused_tables. unused_tables
        must be empty at this point.
      98c4f167
  14. 15 Aug, 2013 1 commit
    • Sergey Vojtovich's avatar
      MDEV-4897 - Assertion `share->tdc.prev == 0 && share->tdc.next == 0' · 954d21de
      Sergey Vojtovich authored
                  failed in TABLE_SHARE* tdc_acquire_share(THD*, const char*,
                  const char*, const char*, uint, uint, TABLE**)
      
      Removed false assertions.
      
      When multiple threads acquire the same previously unused share,
      only one thread shall remove share from unused list (the one that
      has was_unused == true). Other threads will ignore this step and
      may continue even if share is not yet removed from unused list.
      954d21de
  15. 14 Aug, 2013 1 commit
    • Sergey Vojtovich's avatar
      MDEV-4702 - Reduce usage of LOCK_open · b7f9c894
      Sergey Vojtovich authored
      Following variables do not require LOCK_open protection anymore:
      - table_def_cache (renamed to tdc_hash) is protected by rw-lock
        LOCK_tdc_hash;
      - table_def_shutdown_in_progress doesn't need LOCK_open protection;
      - last_table_id use atomics;
      - TABLE_SHARE::ref_count (renamed to TABLE_SHARE::tdc.ref_count)
        is protected by TABLE_SHARE::tdc.LOCK_table_share;
      - TABLE_SHARE::next, ::prev (renamed to tdc.next and tdc.prev),
        oldest_unused_share, end_of_unused_share are protected by
        LOCK_unused_shares;
      - TABLE_SHARE::m_flush_tickets (renamed to tdc.m_flush_tickets)
        is protected by TABLE_SHARE::tdc.LOCK_table_share;
      - refresh_version (renamed to tdc_version) use atomics.
      b7f9c894