An error occurred fetching the project authors.
  1. 07 Sep, 2009 1 commit
    • Ingo Struewing's avatar
      Bug#17332 - changing key_buffer_size on a running server · d1a6c778
      Ingo Struewing authored
                  can crash under load
      
      Backport from 5.1.
      Does also include key cache fixes from:
      Bug 44068 (RESTORE can disable the MyISAM Key Cache)
      Bug 40944 (Backup: crash after myisampack)
      
      
      
      include/keycache.h:
        Bug#17332 - changing key_buffer_size on a running server
                    can crash under load
        Added KEY_CACHE components in_resize and waiting_for_resize_cnt.
      myisam/mi_preload.c:
        Bug#17332 - changing key_buffer_size on a running server
                    can crash under load
        Added code to allow LOAD INDEX to load indexes of different block size.
      mysys/mf_keycache.c:
        Bug#17332 - changing key_buffer_size on a running server
                    can crash under load
        .
        Changed resize_key_cache() to not disable the key cache
        after the flush phase. Changed queue handling to use
        standard functions. Wake all threads waiting on resize_queue.
        We can now have read/write threads waiting there (see below).
        .
        Combined add_to_queue() and the wait loops that were always
        following it to the new function wait_on_queue().
        Combined release_queue() and the condition that was always
        preceding it to the new function release_whole_queue().
        .
        Added code to flag and respect the exceptional situation
        BLOCK_IN_EVICTION.
        .
        Rewrote the resize branch of find_key_block().
        .
        Added code to the eviction handling in find_key_block()
        to catch more exceptional cases.
        .
        Changed key_cache_read(), key_cache_insert() and key_cache_write()
        so that they lock keycache->cache_lock whenever the key cache is
        initialized. Checking for a disabled cache and incrementing and
        decrementing the "resize counter" is always done within the lock.
        Locking and unlocking as well as counting the "resize counter" is
        now done once outside the loop. All three functions can now handle
        a NULL return from find_key_block. This happens in the flush phase
        of a resize and demands direct file I/O. Care is taken for
        secondary requests (PAGE_WAIT_TO_BE_READ) to wait in any case.
        Moved block status changes behind the copying of buffer data.
        key_cache_insert() does now read the block if the caller did
        supply less data than a full cache block.
        key_cache_write() does now take care of parallel running flushes
        (BLOCK_FOR_UPDATE, BLOCK_IN_FLUSHWRITE).
        .
        Changed free_block() to un-initialize block variables in the
        correct order and respect an exceptional BLOCK_IN_EVICTION state.
        .
        Changed flushing to take care for parallel running writes.
        Changed flushing to avoid freeing blocks in eviction.
        Changed flushing to consider that parallel writes can move blocks
        from the file_blocks hash to the changed_blocks hash.
        Changed flushing to take care for other parallel flushes.
        Changed flushing to assure that it ends with everything flushed.
        Optimized normal flush at end of statement (FLUSH_KEEP),
        but let other flush types be stringent.
        .
        Added some comments and debugging statements.
      mysys/my_static.c:
        Bug#17332 - changing key_buffer_size on a running server
                    can crash under load
        Removed an unused global variable.
      sql/ha_myisam.cc:
        Bug#17332 - changing key_buffer_size on a running server
                    can crash under load
        Moved an automatic (stack) variable to the scope where it is used.
      sql/sql_table.cc:
        Bug#17332 - changing key_buffer_size on a running server
                    can crash under load
        Changed TL_READ to TL_READ_NO_INSERT in mysql_preload_keys.
      d1a6c778
  2. 03 Sep, 2009 1 commit
    • Satya B's avatar
      Fix for BUG#46591 - .frm file isn't sync'd with sync_frm enabled for · 19e76565
      Satya B authored
                          CREATE TABLE...LIKE...
            
      The mysql server option 'sync_frm' is ignored when table is created with 
      syntax CREATE TABLE .. LIKE.. 
            
      Fixed by adding the MY_SYNC flag and calling my_sync() from my_copy() when
      the flag is set.
      
      In mysql_create_table(), when the 'sync_frm' is set, MY_SYNC flag is passed 
      to my_copy(). 
            
      Note: TestCase is not attached and can be tested manually using debugger.
      
      client/Makefile.am:
        BUG#46591 - .frm file isn't sync'd with sync_frm enabled for 
                    CREATE TABLE...LIKE...
            
        add my_sync to sources as it is used in my_copy() method
      include/my_sys.h:
        BUG#46591 - .frm file isn't sync'd with sync_frm enabled for 
                    CREATE TABLE...LIKE...
            
        MY_SYNC flag is added to call my_sync() method
      mysys/my_copy.c:
        BUG#46591 - .frm file isn't sync'd with sync_frm enabled for 
                    CREATE TABLE...LIKE...
            
        my_sync() is method is called when MY_SYNC is set in my_copy()
      sql/sql_table.cc:
        BUG#46591 - .frm file isn't sync'd with sync_frm enabled for 
                    CREATE TABLE...LIKE...
            
        Fixed mysql_create_like_table() to call my_sync() when opt_sync_frm variable
        is set
      19e76565
  3. 29 Jun, 2009 1 commit
  4. 17 Jun, 2009 1 commit
    • Staale Smedseng's avatar
      Bug #43414 Parenthesis (and other) warnings compiling MySQL · 2be7b06b
      Staale Smedseng authored
      with gcc 4.3.2
            
      Compiling MySQL with gcc 4.3.2 and later produces a number of 
      warnings, many of which are new with the recent compiler
      versions.
                        
      This bug will be resolved in more than one patch to limit the
      size of changesets. This is the second patch, fixing more
      of the warnings.
      2be7b06b
  5. 23 Apr, 2009 1 commit
  6. 27 Mar, 2009 1 commit
    • He Zhenxing's avatar
      BUG#37145 Killing a statement doing DDL may log binlog event with error code 1053 · 11cd6177
      He Zhenxing authored
      When the thread executing a DDL was killed after finished its
      execution but before writing the binlog event, the error code in
      the binlog event could be set wrongly to ER_SERVER_SHUTDOWN or
      ER_QUERY_INTERRUPTED.
      
      This patch fixed the problem by ignoring the kill status when
      constructing the event for DDL statements.
      
      This patch also included the following changes in order to
      provide the test case.
      
       1) modified mysqltest to support variable for connection command
      
       2) modified mysql-test-run.pl, add new variable MYSQL_SLAVE to
          run mysql client against the slave mysqld.
      11cd6177
  7. 27 Feb, 2009 1 commit
  8. 10 Feb, 2009 1 commit
  9. 09 Dec, 2008 1 commit
    • Sergey Glukhov's avatar
      Bug#31291 ALTER TABLE CONVERT TO CHARACTER SET does not change some data types · 3f8a506a
      Sergey Glukhov authored
      added ability for TINY[MEDIUM] text fields 
      to be converted to greater subtype during
      alter if necessary(altered charset)
      
      
      mysql-test/r/alter_table.result:
        test result
      mysql-test/t/alter_table.test:
        test case
      sql/sql_table.cc:
        added ability for TINY[MEDIUM] text fields 
        to be converted to greater subtype during
        alter if necessary(altered charset)
      3f8a506a
  10. 13 Nov, 2008 1 commit
  11. 15 Jul, 2008 1 commit
    • Sergey Petrunia's avatar
      BUG#35478: sort_union() returns bad data when sort_buffer_size is hit · 04037f54
      Sergey Petrunia authored
      - In QUICK_INDEX_MERGE_SELECT::read_keys_and_merge: when we got table->sort from Unique,
        tell init_read_record() not to use rr_from_cache() because a) rowids are already sorted
        and b) it might be that the the data is used by filesort(), which will need record rowids
        (which rr_from_cache() cannot provide).
      - Fully de-initialize the table->sort read in QUICK_INDEX_MERGE_SELECT::get_next(). This fixes BUG#35477.
      (bk trigger: file as fix for BUG#35478).
      
      sql/filesort.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - make find_all_keys() use quick->get_next() instead of init_read_record(r)/r.read_record() calls
        - added dbug printout
      sql/mysql_priv.h:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/opt_range.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - In QUICK_INDEX_MERGE_SELECT::read_keys_and_merge: when we got table->sort from Unique,
          tell init_read_record() not to use rr_from_cache() because a) rowids are already sorted
          and b) it might be that the the data is used by filesort(), which will need record rowids
          (which rr_from_cache() cannot provide).
        - Fully de-initialize the table->sort read in QUICK_INDEX_MERGE_SELECT::get_next().
      sql/records.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added disable_rr_cache parameter to init_read_record
        - Added comment
      sql/sql_acl.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_delete.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_help.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_select.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_table.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_udf.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_update.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      04037f54
  12. 12 May, 2008 1 commit
    • unknown's avatar
      Fixed bug #36055: mysql_upgrade doesn't really 'upgrade' tables · 32425d4c
      unknown authored
      The REPAIR TABLE ... USE_FRM query silently corrupts data of tables
      with old .FRM file version.
      The mysql_upgrade client program or the REPAIR TABLE query (without
      the USE_FRM clause) can't prevent this trouble, because in the
      common case they don't upgrade .FRM file to compatible structure.
      
      1. Evaluation of the REPAIR TABLE ... USE_FRM query has been
         modified to reject such tables with the message:
         "Failed repairing incompatible .FRM file".
      
      2. REPAIR TABLE query (without USE_FRM clause) evaluation has been
         modified to upgrade .FRM files to current version.
      
      3. CHECK TABLE ... FOR UPGRADE query evaluation has been modified
         to return error status when .FRM file has incompatible version.
      
      4. mysql_upgrade and mysqlcheck client programs call CHECK TABLE
         FOR UPGRADE and REPAIR TABLE queries, so their behaviors have
         been changed too to upgrade .FRM files with incompatible
         version numbers.
      
      
      mysql-test/std_data/bug36055.MYD:
        Added test data for bug #36055.
      mysql-test/std_data/bug36055.MYI:
        Added test data for bug #36055.
      mysql-test/std_data/bug36055.frm:
        Added test data for bug #36055.
      mysql-test/r/repair.result:
        Added test case for bug# 36055.
      mysql-test/t/repair.test:
        Added test case for bug# 36055.
      sql/handler.cc:
        Fixed bug #36055: mysql_upgrade doesn't really 'upgrade' tables
        
        The handler::ha_check_for_upgrade method has been modified to
        return error if .FRM file has incompatible version number.
      sql/sql_table.cc:
        Fixed bug #36055: mysql_upgrade doesn't really 'upgrade' tables
        
        The prepare_for_repair function has been modified to reject
        REPAIR TABLE ... USE_FRM queries on incompatible .FRM files
        with the message: "Failed repairing incompatible .FRM file".
      32425d4c
  13. 28 Nov, 2007 1 commit
    • unknown's avatar
      Bug#31479 Bad lock interaction if CREATE TABLE LIKE is killed · 6a6d4b07
      unknown authored
      Kill of a CREATE TABLE source_table LIKE statement waiting for a
      name-lock on the source table causes a bad lock interaction.
      
      The mysql_create_like_table() has a bug that if the connection is
      killed while waiting for the name-lock on the source table, it will
      jump to the wrong error path and try to unlock the source table and
      LOCK_open, but both weren't locked.
      
      The solution is to simple return when the name lock request is killed,
      it's safe to do so because no lock was acquired and no cleanup is needed.
      
      Original bug report also contains description of other problems
      related to this scenario but they either already fixed in 5.1 or
      will be addressed separately (see bug report for details).
      
      
      mysql-test/r/lock_multi.result:
        Add test case result for Bug#31479
      mysql-test/t/lock_multi.test:
        Add test case for Bug#31479
      sql/sql_table.cc:
        Rerturn TRUE when the lock gets killed.
      6a6d4b07
  14. 10 Nov, 2007 1 commit
    • unknown's avatar
      Bug #32063 "create table like" works case-significant only in "embedded" server (libmysqld) · bc05b8c1
      unknown authored
      in mysql_creata_like_table() we 'downcase' the complete path to the
      .frm file. It works fine in standalone case as there usually
      we only have './' as a path to the datahome, but doesn't work in
      the embedded server where we add the real path there, so if a
      directory has uppercase letters in it's name, it won't be found.
      
      Fixed by 'downcasing' only database/table pair.
      
      
      sql/sql_table.cc:
        Bug #32063 "create table like" works case-significant only in "embedded" server (libmysqld)
        
        do not lowercase the database directory
      bc05b8c1
  15. 26 Oct, 2007 1 commit
    • unknown's avatar
      Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, · 51a49b17
      unknown authored
      file .\ha_innodb.
      
      Problem: if a partial unique key followed by a non-partial one we declare
      the second one as a primary key.
      
      Fix: sort non-partial unique keys before partial ones.
      
      
      include/my_base.h:
        Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, 
        file .\ha_innodb.
          - sort unique keys that don't contain partial segments before other keys:
              set HA_KEY_HAS_PART_KEY_SEG flag for such keys in the mysql_prepare_table(),
              use it in the sort_keys();
      mysql-test/r/innodb_mysql.result:
        Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, 
        file .\ha_innodb.
          - test result.
      mysql-test/r/key.result:
        Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, 
        file .\ha_innodb.
          - test result.
      mysql-test/t/innodb_mysql.test:
        Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, 
        file .\ha_innodb.
          - test case.
      mysql-test/t/key.test:
        Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, 
        file .\ha_innodb.
          - test case.
      sql/sql_table.cc:
        Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, 
        file .\ha_innodb.
          - sort unique keys that don't contain partial segments before other keys:
              set HA_KEY_HAS_PART_KEY_SEG flag for such keys in the mysql_prepare_table(),
              use it in the sort_keys();
      sql/structs.h:
        Fix for bug #31137: Assertion failed: primary_key_no == -1 || primary_key_no == 0, 
        file .\ha_innodb.
          - sort unique keys that don't contain partial segments before other keys:
              set HA_KEY_HAS_PART_KEY_SEG flag for such keys in the mysql_prepare_table(),
              use it in the sort_keys();
      51a49b17
  16. 23 Oct, 2007 1 commit
    • unknown's avatar
      Patch for BUG#30736: Row Size Too Large Error Creating a Table and · cfa54d6d
      unknown authored
      Inserting Data.
      
      The problem was that under some circumstances Field class was not
      properly initialized before calling create_length_to_internal_length()
      function, which led to assert failure.
      
      The fix is to do the proper initialization.
      
      The user-visible problem was that under some circumstances
      CREATE TABLE ... SELECT statement crashed the server or led
      to wrong error message (wrong results).
      
      
      mysql-test/r/select.result:
        Update result file.
      mysql-test/t/select.test:
        Add a test case for BUG#30736: Row Size Too Large Error
        Creating a Table and Inserting Data.
      sql/sql_table.cc:
        Move sql_field->decimals initialization before
        sql_field->create_length_to_internal_length() call.
      cfa54d6d
  17. 17 Oct, 2007 1 commit
    • unknown's avatar
      Fix for bug #31207: Test "join_nested" shows different strategy on IA64 · 56aad336
      unknown authored
      CPUs / Intel's ICC compile
      
      The bug is a combination of two problems:
      
      1. IA64/ICC MySQL binaries use glibc's qsort(), not the one in mysys.
      
      2. The order relation implemented by join_tab_cmp() is not transitive,
      i.e. it is possible to choose such a, b and c that (a < b) && (b < c)
      but (c < a). This implies that result of a sort using the relation
      implemented by join_tab_cmp() depends on the order in which
      elements are compared, i.e. the result is implementation-specific. Since
      choose_plan() uses qsort() to pre-sort the
      join tables using join_tab_cmp() as a compare function, the results of
      the sorting may vary depending on qsort() implementation.
      
      It is neither possible nor important to implement a better ordering
      algorithm in join_tab_cmp(). Therefore the only way to fix it is to
      force our own qsort() to be used by renaming it to my_qsort(), so we don't depend
      on linker to decide that.
      
      This patch also "fixes" bug #20530: qsort redefinition violates the
      standard.
      
      
      include/my_sys.h:
        Renamed qsort() and qsort2() to my_qsort() and my_qsort2(). Since
        previously we relied on stdlib.h to provide a declaration for qsort(), a
        separate declaration for my_qsort() is now required.
      libmysql/Makefile.shared:
        Added mf_qsort.c to libmysql, since my_lib.c now uses my_qsort() instead of qsort().
      myisam/ft_boolean_search.c:
        Replaced qsort2() with my_qsort2().
      myisam/ft_nlq_search.c:
        Replaced qsort2() with my_qsort2().
      myisam/myisampack.c:
        Replaced qsort() with my_qsort().
      myisam/sort.c:
        Replaced qsort2() with my_qsort2().
      mysys/mf_keycache.c:
        Replaced qsort() with my_qsort().
      mysys/mf_qsort.c:
        Renamed qsort() to my_qsort() and qsort2() to my_qsort2().
      mysys/mf_sort.c:
        Replaced qsort2() with my_qsort2().
      mysys/my_lib.c:
        Replaced qsort() with my_qsort().
      mysys/queues.c:
        Replaced qsort2() with my_qsort2().
      sql/item_cmpfunc.cc:
        Replaced qsort2() with my_qsort2().
      sql/item_cmpfunc.h:
        Replaced qsort2() with my_qsort2().
      sql/opt_range.cc:
        Replaced qsort() with my_qsort().
      sql/records.cc:
        Replaced qsort() with my_qsort().
      sql/sql_acl.cc:
        Replaced qsort() with my_qsort().
      sql/sql_array.h:
        Replaced qsort() with my_qsort().
      sql/sql_help.cc:
        Replaced qsort() with my_qsort().
      sql/sql_select.cc:
        Replaced qsort() with my_qsort().
      sql/examples/ha_tina.cc:
        Replaced qsort() with my_qsort().
      sql/sql_table.cc:
        Replaced qsort() with my_qsort().
      56aad336
  18. 10 Oct, 2007 1 commit
    • unknown's avatar
      Bug #30825: Problems when putting a non-spatial index on a GIS column · ba373ba5
      unknown authored
       Fixed the usage of spatial data (and Point in specific) with 
       non-spatial indexes.
       Several problems :
         - The length of the Point class was not updated to include the 
           spatial reference system identifier. Fixed by increasing with 4 
           bytes.
         - The storage length of the spatial columns was not accounting for
           the length that is prepended to it. Fixed by treating the 
           spatial data columns as blobs (and thus increasing the storage
           length)
         - When creating the key image for comparison in index read wrong
           key image was created (the one needed for and r-tree search,
           not the one for b-tree/other search). Fixed by treating the
           spatial data columns as blobs (and creating the correct kind of
           image based on the index type). 
      
      
      mysql-test/r/bdb_gis.result:
        Bug #30825: bdb tests
      mysql-test/r/gis-rtree.result:
        Bug #30825: key length changed
      mysql-test/r/gis.result:
        Bug #30825: MyISAM tests
      mysql-test/r/innodb_gis.result:
        Bug #30825: InnoDB tests
      mysql-test/t/bdb_gis.test:
        Bug #30825: bdb tests
      mysql-test/t/gis.test:
        Bug #30825: MyISAM tests
      mysql-test/t/innodb_gis.test:
        Bug #30825: InnoDB tests
      sql/field.cc:
        Bug #30825: Removed Field_geom::get_key_image as Field_blog::get_key_image 
          takes type parameter into consideration and is a superset of 
          Field_geom::get_key_image()
      sql/field.h:
        Bug #30825: Removed Field_geom::get_key_image as Field_blog::get_key_image 
          takes type parameter into consideration and is a superset of 
          Field_geom::get_key_image()
      sql/sql_select.h:
        Bug #30825: Geometry data are a blob derivate
      sql/sql_table.cc:
        Bug #30825: Increased key length to accomodate for
          spatial reference system identifier (srid)
      sql/sql_yacc.yy:
        Bug #30825: Increased key length to accomodate for
          spatial reference system identifier (srid)
      sql/table.cc:
        Bug #30825: It stores a length for spatial data
         as well, so increase the storage length (as it's
         done for blobs).
      mysql-test/include/gis_keys.inc:
        Bug #30825: Test file for spatial data and non-spatial indexes
      ba373ba5
  19. 02 Aug, 2007 1 commit
    • unknown's avatar
      Bug #30193: crash during drop table and kill · 92eb49d5
      unknown authored
      When DROP TABLE detects that it has been killed
      by another thread it must unlock the table names
      it locked.
      
      Fixed by backporting the 5.1 error handling code.
      
      
      sql/sql_table.cc:
        Bug #30193: correct error handling when a thread 
        is killed inside DROP TABLE.
      92eb49d5
  20. 30 Jul, 2007 1 commit
    • unknown's avatar
      (pushing for Andrei) · 817a05a6
      unknown authored
      Bug #27417 thd->no_trans_update.stmt lost value inside of SF-exec-stack
        
      Once had been set the flag might later got reset inside of a stored routine 
      execution stack.
      The reason was in that there was no check if a new statement started at time 
      of resetting.
      The artifact affects most of binlogable DML queries. Notice, that multi-update 
      is wrapped up within
        bug@27716 fix, multi-delete bug@29136.
        
      Fixed with saving parent's statement flag of whether the statement modified 
      non-transactional table, and unioning (merging) the value with that was gained 
      in mysql_execute_command.
        
      Resettling thd->no_trans_update members into thd->transaction.`member`;
      Asserting code;
      Effectively the following properties are held.
        
      1. At the end of a substatement thd->transaction.stmt.modified_non_trans_table
         reflects the fact if such a table got modified by the substatement.
         That also respects THD::really_abort_on_warnin() requirements.
      2. Eventually thd->transaction.stmt.modified_non_trans_table will be computed as
         the union of the values of all invoked sub-statements.
         That fixes this bug#27417;
      
      Computing of thd->transaction.all.modified_non_trans_table is refined to base to 
      the stmt's value for all the case including insert .. select statement which 
      before the patch had an extra issue bug@28960.
      Minor issues are covered with mysql_load, mysql_delete, and binloggin of insert in
      to temp_table select. 
        
      The supplied test verifies limitely, mostly asserts. The ultimate testing is defered
      for bug@13270, bug@23333.
      
      
      mysql-test/r/mix_innodb_myisam_binlog.result:
        results changed
      mysql-test/t/mix_innodb_myisam_binlog.test:
        regression test incl the related bug#28960.
      sql/ha_ndbcluster.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/handler.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/handler.h:
        new member added
      sql/log.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/set_var.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sp_head.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
        
        and saving and merging stmt's flag at the end of a substatement.
      sql/sql_class.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_class.h:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_delete.cc:
        correcting basic delete incl truncate branch and multi-delete queries to set
        stmt.modified_non_trans_table;
        optimization to set the flag at the end of per-row loop;
        multi-delete still has an extra issue similar to bug#27716 of multi-update 
        - to be address with bug_29136 fix.
      sql/sql_insert.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_load.cc:
        eliminating a separate issue where the stmt flag was saved and re-stored after 
        write_record that actually could change it and the change would be lost but 
        should remain permanent;
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_parse.cc:
        initialization to transaction.stmt.modified_non_trans_table at the common part 
        of all types of statements processing - mysql_execute_command().
      sql/sql_table.cc:
        moving the reset up to the mysql_execute_command() caller
      sql/sql_update.cc:
        correcting update query case (multi-update part of the issues covered by other 
        bug#27716 fix)
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      817a05a6
  21. 27 Jul, 2007 1 commit
    • unknown's avatar
      A fix and a test case for Bug#24918 drop table and lock / inconsistent · 0c371edd
      unknown authored
      between perm and temp tables. Review fixes.
      
      The original bug report complains that if we locked a temporary table
      with LOCK TABLES statement, we would not leave LOCK TABLES mode
      when this temporary table is dropped.
      
      Additionally, the bug was escalated when it was discovered than
      when a temporary transactional table that was previously
      locked with LOCK TABLES statement was dropped, futher actions with
      this table, such as UNLOCK TABLES, would lead to a crash.
      
      The problem originates from incomplete support of transactional temporary
      tables. When we added calls to handler::store_lock()/handler::external_lock()
      to operations that work with such tables, we only covered the normal
      server code flow and did not cover LOCK TABLES mode. 
      In LOCK TABLES mode, ::external_lock(LOCK) would sometimes be called without
      matching ::external_lock(UNLOCK), e.g. when a transactional temporary table
      was dropped. Additionally, this table would be left in the list of LOCKed 
      TABLES.
      
      The patch aims to address this inadequacy. Now, whenever an instance
      of 'handler' is destroyed, we assert that it was priorly
      external_lock(UNLOCK)-ed. All the places that violate this assert
      were fixed.
      
      This patch introduces no changes in behavior -- the discrepancy in
      behavior will be fixed when we start calling ::store_lock()/::external_lock()
      for all tables, regardless whether they are transactional or not, 
      temporary or not.
      
      
      mysql-test/r/innodb_mysql.result:
        Update test results (Bug#24918)
      mysql-test/t/innodb_mysql.test:
        Add a test case for Bug#24918
      sql/handler.h:
        Make handler::external_lock() a protected method. Backport from 5.1 its
        public wrapper handler::ha_external_lock().
        Assert that the handler is not closed if it is still locked.
      sql/lock.cc:
        In mysql_lock_tables only call lock_external() for the list of tables that
        we called store_lock() for. 
        E.g. get_lock_data() does not add non-transactional temporary tables to the
        lock list, so lock_external() should not be called for them.
        
        Use handler::ha_external_lock() instead of handler::external_lock().
        
        Add comments for mysql_lock_remove(), parameterize one strange
        side effect that it has. At least in one place where mysql_lock_remove
        is used, this side effect is not desired (DROP TABLE). The parameter
        will be dropped in 5.1, along with the side effect.
      sql/mysql_priv.h:
        Update declaration of mysql_lock_remove().
      sql/opt_range.cc:
        Deploy handler::ha_external_lock() instead of handler::external_lock()
      sql/sql_base.cc:
        When closing a temporary table, remove the table from the list of LOCKed 
        TABLES of this thread, in case it's there. 
        It's there if it is a transactional temporary table.
        Use a new declaration of mysql_lock_remove().
      sql/sql_class.h:
        Extend the comment for THD::temporary_tables.
      sql/sql_table.cc:
        Deploy handler::ha_external_lock() instead of handler::external_lock()
      0c371edd
  22. 18 Jul, 2007 2 commits
    • unknown's avatar
      BUG#28838 - duplicate external_lock in mysql_alter_table · 700e3219
      unknown authored
      Removed duplicate call to handler::external_lock() when
      ALTER TABLE that doesn't need to copy a table (quick
      ALTER TABLE) was executed.
      
      Also quick ALTER TABLE doesn't hold LOCK_open anymore when
      it enables/disables indexes.
      
      
      sql/sql_table.cc:
        Do not call handler::external_lock() as table is already locked
        by open_ltable().
        
        Also do not hold LOCK_open mutex for alter_table_manage_keys() as
        this function doesn't require LOCK_open (LOCK_open is required by
        wait_while_table_is_used() only).
      700e3219
    • unknown's avatar
      Fix for bug #28125: ERROR 2013 when adding index. · 26001a27
      unknown authored
      Problem: we may break a multibyte char sequence using a key 
      reduced to maximum allowed length for a storage engine
      (that leads to failed assertion in the innodb code, 
      see also #17530). 
      
      Fix: align truncated key length to multibyte char boundary.
      
      
      mysql-test/r/innodb_mysql.result:
        Fix for bug #28125: ERROR 2013 when adding index.
          - test result.
      mysql-test/t/innodb_mysql.test:
        Fix for bug #28125: ERROR 2013 when adding index.
          - test case.
      sql/sql_table.cc:
        Fix for bug #28125: ERROR 2013 when adding index.
          - align truncated key length to multibyte char boundary.
          - display real key length in bytes raising warnings.
      26001a27
  23. 11 Jul, 2007 1 commit
    • unknown's avatar
      Bug #29325: · 41bbdb8d
      unknown authored
      By default MyISAM overwrites .MYD and .MYI files no 
      DATA DIRECTORY option is used. This can lead to two tables
      using the same .MYD and .MYI files (that can't be dropped).
      
      To prevent CREATE TABLE from overwriting a file a new option
      is introduced : keep_files_on_create
      When this is on the CREATE TABLE throws an error if either
      the .MYD or .MYI exists for a MyISAM table.
      The option is off by default (resulting in compatible behavior).
      
      
      include/my_base.h:
        Bug #29325: introduce keep_files_on_create
      myisam/mi_create.c:
        Bug #29325: introduce keep_files_on_create
      mysql-test/r/create.result:
        Bug #29325: test case
      mysql-test/t/create.test:
        Bug #29325: test case
      sql/ha_myisam.cc:
        Bug #29325: introduce keep_files_on_create
      sql/set_var.cc:
        Bug #29325: introduce keep_files_on_create
      sql/sql_class.h:
        Bug #29325: introduce keep_files_on_create
      sql/sql_table.cc:
        Bug #29325: introduce keep_files_on_create
      sql/unireg.cc:
        Bug #29325: introduce keep_files_on_create
      41bbdb8d
  24. 08 Jun, 2007 1 commit
    • unknown's avatar
      Bug #28754: RPM builds differ from tar.gz in "ALTER ... RENAME" on views · 0f6f9b8e
      unknown authored
       When constructing the path to the original .frm file ALTER .. RENAME
       was unnecessary (and incorrectly) lowercasing the whole path when not 
       on a case-insensitive filesystem.
       This path should not be modified because of lower_case_table_names
       as it is already in the correct case according to that setting.
       Fixed by removing the lowercasing.
       Unfortunately testing this would require running the tests on a case
       sensitive filesystem in a directory that has uppercase letters.
       This cannot be guaranteed in all setups so no test case added.
      
      
      sql/sql_table.cc:
        Bug #28754: don't downcase the .frm path
      0f6f9b8e
  25. 05 Jun, 2007 1 commit
    • unknown's avatar
      BUG#26976 - Missing table in merge not noted in related error msg + · 2b315dff
      unknown authored
                  SHOW CREATE TABLE fails
      
      Underlying table names, that merge engine fails to open were not
      reported.
      
      With this fix CHECK TABLE issued against merge table reports all
      underlying table names that it fails to open. Other statements
      are unaffected, that is underlying table names are not included
      into error message.
      
      This fix doesn't solve SHOW CREATE TABLE issue.
      
      
      myisammrg/myrg_def.h:
        Added myrg_print_wrong_table declaration.
      myisammrg/myrg_open.c:
        If HA_OPEN_FOR_REPAIR is passed to merge engine open function,
        report names of tables that we fail to open.
      mysql-test/r/backup.result:
        Updated test result.
      mysql-test/r/key_cache.result:
        Updated test result - removed duplicate error.
      mysql-test/r/lock.result:
        Updated test result - added summary row.
      mysql-test/r/merge.result:
        A test case for BUG#26976.
      mysql-test/r/preload.result:
        Updated test result - removed duplicate error, added summary row.
      mysql-test/r/ps.result:
        Updated test result - removed duplicate error, added summary row.
      mysql-test/r/repair.result:
        Updated test result - removed duplicate error, added summary row.
      mysql-test/r/rpl_failed_optimize.result:
        Updated test result - removed duplicate error, added summary row.
      mysql-test/r/sp.result:
        Updated test result - removed duplicate error, added summary row.
      mysql-test/r/view.result:
        Updated test result - removed duplicate error, added summary row.
      mysql-test/t/merge.test:
        A test case for BUG#26976.
      sql/ha_myisam.cc:
        Do not report same error twice.
      sql/ha_myisammrg.cc:
        If HA_OPEN_FOR_REPAIR is passed to merge engine open function,
        report names of tables that we fail to open.
        
        Added dummy ha_myisammrg::check to not confuse users with
        "not implemented" error in case all underlying tables are
        fine.
      sql/ha_myisammrg.h:
         Added ha_myisammrg::check declaration.
      sql/share/errmsg.txt:
        Added ER_ADMIN_WRONG_MRG_TABLE errno. It is used instead
        of ER_WRONG_MRG_TABLE in case HA_OPEN_FOR_REPAIR is
        passed to merge engine handler open function.
      sql/sql_error.cc:
        warning_level_* are now public. It is required by mysql_admin_table to
        report message level.
      sql/sql_error.h:
        warning_level_* are now public. It is required by mysql_admin_table to
        report message level.
      sql/sql_table.cc:
        Reorder mysql_admin_table arguments to meet it's definition.
        
        Report errors that are pending in thd->warn_list as results of
        admin function.
      2b315dff
  26. 01 Jun, 2007 1 commit
    • unknown's avatar
      Fix for bug #28652: MySQL (with-debug=full) asserts when alter table operations · e9cd18c2
      unknown authored
      Problem: we may create a deadlock committing changes in the mysql_alter_table() when 
      LOCK_open is set. Moreover, "in some variants of the ALTER TABLE commit
      happens earlier, outside of LOCK_open, in other later - inside. It's no good, a storage 
      engine code that is called in between could expect a consistency - either there is a 
      transaction or there is not".
      Fix: move the commit to happen earlier and outside of the LOCK_open.
      
      
      mysql-test/r/innodb_mysql.result:
        Fix for bug #28652: MySQL (with-debug=full) asserts when alter table operations
          - test result.
      mysql-test/t/innodb_mysql.test:
        Fix for bug #28652: MySQL (with-debug=full) asserts when alter table operations
          - test case.
      sql/sql_table.cc:
        Fix for bug #28652: MySQL (with-debug=full) asserts when alter table operations
          - commit moved to happen earlier in the mysql_alter_table(), 
            now we commit changes at the same time as in case when a temporary 
            table is used.
      e9cd18c2
  27. 28 May, 2007 1 commit
  28. 23 May, 2007 1 commit
    • unknown's avatar
      5.0 version of fix for: · e8c35f16
      unknown authored
       Bug #23667 "CREATE TABLE LIKE is not isolated from alteration
                   by other connections"
       Bug #18950 "CREATE TABLE LIKE does not obtain LOCK_open"
      As well as:
       Bug #25578 "CREATE TABLE LIKE does not require any privileges
                   on source table".
      
      The first and the second bugs resulted in various errors and wrong
      binary log order when one tried to execute concurrently CREATE TABLE LIKE
      statement and DDL statements on source table or DML/DDL statements on its
      target table.
      
      The problem was caused by incomplete protection/table-locking against
      concurrent statements implemented in mysql_create_like_table() routine.
      We solve it by simply implementing such protection in proper way (see
      comment for sql_table.cc for details).
      
      The third bug allowed user who didn't have any privileges on table create
      its copy and therefore circumvent privilege check for SHOW CREATE TABLE.
      
      This patch solves this problem by adding privilege check, which was missing.
      
      Finally it also removes some duplicated code from mysql_create_like_table().
      
      Note that, altough tests covering concurrency-related aspects of CREATE TABLE
      LIKE behaviour will only be introduced in 5.1, they were run manually for
      this patch as well.
      
      
      mysql-test/r/grant2.result:
        Added test for bug#25578 "CREATE TABLE LIKE does not require any privileges
        on source table".
      mysql-test/t/grant2.test:
        Added test for bug#25578 "CREATE TABLE LIKE does not require any privileges
        on source table".
      sql/handler.h:
        Introduced new flag for HA_CREATE_INFO::options in order to be able to
        distinguish CREATE TABLE ... LIKE from other types of CREATE TABLE.
      sql/mysql_priv.h:
        mysql_create_like_table() now takes source table name not as a
        Table_ident object but as regular table list element.
      sql/sql_parse.cc:
        CREATE TABLE ... LIKE implementation now uses statement's table list
        for storing information about the source table. We also use flag
        in LEX::create_info.options for distinguishing it from other types
        of CREATE TABLE.
        Finally CREATE TABLE ... LIKE now requires the same privileges on
        the source tables as SHOW CREATE TABLE. Moved this privilege check
        to check_show_create_table_access() function.
      sql/sql_table.cc:
        mysql_create_like_table():
         - Provided proper protection from concurrent statements.
           This is achieved by keeping name-lock on the source table and holding
           LOCK_open mutex during whole operation. This gives protection against
           concurrent DDL on source table. Also holding this mutex makes copying
           of .frm file, call to ha_create_table() and binlogging atomic against
           concurrent DML and DDL operations on target table.
         - Get rid of duplicated code related to source database/table name
           handling. All these operations are already done in
           st_select_lex::add_table_to_list(), so we achieve the same effect
           by including source table into the statement's table list.
      sql/sql_yacc.yy:
        Now we use special flag in LEX::create_info::options for distinguishing
        CREATE TABLE ... LIKE from other types of CREATE TABLE and store name
        of source table as regular element in statement's table list.
      e8c35f16
  29. 21 May, 2007 2 commits
    • unknown's avatar
      71a141d6
    • unknown's avatar
      Bug#27507: Wrong DATETIME value was allowed by ALTER TABLE in the NO_ZERO_DATE · a9b0bdab
      unknown authored
      mode.
      
      When a new DATE/DATETIME field without default value is being added by the
      ALTER TABLE the '0000-00-00' value is used as the default one. But it wasn't
      checked whether such value was allowed by the set sql mode. Due to this
      '0000-00-00' values was allowed for DATE/DATETIME fields even in the
      NO_ZERO_DATE mode.
      
      Now the mysql_alter_table() function checks whether the '0000-00-00' value
      is allowed for DATE/DATETIME fields by the set sql mode.
      The new error_if_not_empty flag is used in the mysql_alter_table() function
      to indicate that it should abort if the table being altered isn't empty.
      The new new_datetime_field field is used in the mysql_alter_table() function
      for error throwing purposes. 
      The new error_if_not_empty parameter is added to the copy_data_between_tables()
      function to indicate the it should return error if the source table isn't empty.
      
      
      mysql-test/t/alter_table.test:
        Added a test case for the bug#27507: Wrong DATETIME value was allowed by
        ALTER TABLE in the NO_ZERO_DATE mode.
      mysql-test/r/alter_table.result:
        Added a test case for the bug#27507: Wrong DATETIME value was allowed by
        ALTER TABLE in the NO_ZERO_DATE mode.
      sql/sql_table.cc:
        Bug#27507: Wrong DATETIME value was allowed by ALTER TABLE in the NO_ZERO_DATE
        mode.
        Now the mysql_alter_table() function checks whether the '0000-00-00' value
        is allowed for DATE/DATETIME fields by the set sql mode.
        The new error_if_not_empty flag is used in the mysql_alter_table() function
        to indicate that it should abort if the table being altered isn't empty.
        The new new_datetime_field field is used in the mysql_alter_table() function
        for error throwing purposes. 
        The new error_if_not_empty parameter is added to the copy_data_between_tables()
        function to indicate the it should return error if the source table isn't empty.
      a9b0bdab
  30. 11 May, 2007 1 commit
    • unknown's avatar
      Fix for: · 1f27a7a8
      unknown authored
        Bug #20662 "Infinite loop in CREATE TABLE IF NOT EXISTS ... SELECT
                    with locked tables"
        Bug #20903 "Crash when using CREATE TABLE .. SELECT and triggers"
        Bug #24738 "CREATE TABLE ... SELECT is not isolated properly"
        Bug #24508 "Inconsistent results of CREATE TABLE ... SELECT when
                    temporary table exists"
       
      Deadlock occured when one tried to execute CREATE TABLE IF NOT
      EXISTS ... SELECT statement under LOCK TABLES which held
      read lock on target table.
      Attempt to execute the same statement for already existing
      target table with triggers caused server crashes.
      Also concurrent execution of CREATE TABLE ... SELECT statement
      and other statements involving target table suffered from
      various races (some of which might've led to deadlocks).
      Finally, attempt to execute CREATE TABLE ... SELECT in case
      when a temporary table with same name was already present
      led to the insertion of data into this temporary table and
      creation of empty non-temporary table.
       
      All above problems stemmed from the old implementation of CREATE
      TABLE ... SELECT in which we created, opened and locked target
      table without any special protection in a separate step and not
      with the rest of tables used by this statement.
      This underminded deadlock-avoidance approach used in server
      and created window for races. It also excluded target table
      from prelocking causing problems with trigger execution.
        
      The patch solves these problems by implementing new approach to
      handling of CREATE TABLE ... SELECT for base tables.
      We try to open and lock table to be created at the same time as
      the rest of tables used by this statement. If such table does not
      exist at this moment we create and place in the table cache special
      placeholder for it which prevents its creation or any other usage
      by other threads.
      
      We still use old approach for creation of temporary tables.
      
      Also note that we decided to postpone introduction of some tests
      for concurrent behaviour of CREATE TABLE ... SELECT till 5.1.
      The main reason for this is absence in 5.0 ability to set @@debug
      variable at runtime, which can be circumvented only by using several
      test files with individual .opt files. Since the latter is likely
      to slowdown test-suite unnecessary we chose not to push this tests
      into 5.0, but run them manually for this version and later push
      their optimized version into 5.1
      
      
      mysql-test/r/create.result:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/r/trigger.result:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      mysql-test/t/create.test:
        Extended test coverage for CREATE TABLE ... SELECT. In particular added
        tests for bug #24508 "Inconsistent results of CREATE TABLE ... SELECT
        when temporary table exists" and bug #20662 "Infinite loop in CREATE
        TABLE IF NOT EXISTS ... SELECT with locked tables".
      mysql-test/t/trigger.test:
        Added test case for bug #20903 "Crash when using CREATE TABLE .. SELECT
        and triggers"
      sql/lock.cc:
        Now for creation of name-lock placeholder in lock_table_name() we use
        auxiliary function table_cache_insert_placeholder().
      sql/mysql_priv.h:
        Made build_table_path() function available outside of sql_table.cc file.
        reopen_name_locked_table() now has 3rd argument which controls linking
        in of table being opened into THD::open_tables (this is useful in
        cases when placeholder used for name-locking is already linked into
        this list).
        Added declaration of auxiliary function table_cache_insert_placeholder()
        which is used for creation of table placeholders for name-locking.
        Added declaration of table_cache_has_open_placeholder() function which
        can be used for checking if table cache contains an open placeholder for
        the table and if this placeholder was created by another thread.
        (This function is needed only in 5.0 where we use it in various versions
         of CREATE TABLE in order to protect it from concurrent CREATE TABLE
         ... SELECT operations for the table. Starting from 5.1 we use different
         approach so it is going to be removed there).
        Made close_old_data_files() static within sql_base.cc file. 
        Added auxiliary drop_open_table() routine.
        Moved declaration of refresh_version to table.h header to make it
        accessible from inline methods of TABLE class.
        MYSQL_OPEN_IGNORE_LOCKED_TABLES flag is no longer used. Instead
        MYSQL_OPEN_TEMPORARY_ONLY option was added.
      sql/sql_base.cc:
        Added support for the new approach to the handling of CREATE TABLE
        ... SELECT for base tables.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads.
        
        Note significant distinctions of this placeholder from the placeholder
        used for normal name-lock: 1) It is treated like open table by other
        name-locks so it does not allow name-lock taking operations like DROP
        TABLE or RENAME TABLE to proceed. 2) it is linked into THD::open_tables
        list and automatically removed during close_thread_tables() call.
        
        open_tables():
          Implemented logic described above. To do this added
          auxiliary check_if_table_exists() function.
          Removed support for MYSQL_OPEN_IGNORE_LOCKED_TABLES option
          which is no longer used.
          Added MYSQL_OPEN_TEMPORARY_ONLY which is used to restrict
          search for temporary tables only.
        close_cached_tables()/close_thread_table()/reopen_tables()/
        close_old_data_files()/table_is_used()/remove_table_from_cache():
          Added support for open placeholders (note that we also use them
          when we need to re-open tables during flush).
        Added auxiliary drop_open_table() routine.
        reopen_name_locked_table():
          Now has 3rd argument which controls linking in of table being
          opened into THD::open_tables (this is useful in cases when
          placeholder used for name-locking is already linked into
          this list).
        Added auxiliary table_cache_insert_placeholder() routine which
        simplifies creation of placeholders used for name-locking.
        Added table_cache_has_open_placeholder() function which can be
        used for checking if table cache contains an open placeholder for
        the table and if this placeholder was created by another thread.
        (This function is needed only in 5.0 where we use it in various versions
         of CREATE TABLE in order to protect it from concurrent CREATE TABLE
         ... SELECT operations for the table. Starting from 5.1 we use different
         approach so it is going to be removed there).
      sql/sql_handler.cc:
        Adjusted mysql_ha_mark_tables_for_reopen() routine to properly
        handle placeholders which now can be linked into open tables
        list.
      sql/sql_insert.cc:
        Introduced new approach to handling of base tables in CREATE TABLE
        ... SELECT statement.
        
        Now we try to open and lock table to be created at the same time as
        the rest of tables used by this statement. If such table does not
        exist at this moment we create and place in the table cache special
        placeholder for it which prevents its creation or any other usage
        by other threads. By doing this we avoid races which existed with
        previous approach in which we created, opened and locked target in
        separate step without any special protection.
        This also allows properly calculate prelocking set in cases when
        target table already exists and has some on insert triggers.
          
        Note that we don't employ the same approach for temporary tables
        (this is okay as such tables are unaffected by other threads).
        
        Changed create_table_from_items() and select_create methods to
        implement this approach.
      sql/sql_parse.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_prepare.cc:
        The new approach to handling of CREATE TABLE ... SELECT for
        base tables assumes that all tables (including table to be
        created) are opened and (or) locked at the same time.
        So in cases when we create base table we have to pass to
        open_and_lock_tables() table list which includes target table.
      sql/sql_table.cc:
        Now mysql_create_table_internal(), mysql_create_like_table() and
        mysql_alter_table() not only check that destination table doesn't
        exist on disk but also check that there is no create placeholder
        in table cache for it (i.e. there is no CREATE TABLE ... SELECT
        operation in progress for it). Note that starting from 5.1 we
        use different approach in order to to protect CREATE TABLE ... SELECT
        from concurrent CREATE TABLE (ALTER TABLE ... RENAME) operations,
        the latter simply take name-locks on table before its creation
        (on target table name before renaming).
        
        Also made build_table_path() available from other files and
        asjusted calls to reopen_name_locked_table(), which now takes
        extra argument, which controls linking of open table into
        THD::open_tables list.
      sql/sql_trigger.cc:
        reopen_name_locked_tables() now has one more argument which controls
        linking of opened table into the THD::open_tables list.
      sql/sql_yacc.yy:
        The new approach to handling of CREATE TABLE ... SELECT statement
        for base tables assumes that all tables including table to be
        created are open and (or) locked at the same time. Therefore
        we need to set correct lock for target table.
      sql/table.h:
        Moved declaration of refresh_version variable from mysql_priv.h
        to make it accessible from inline methods of TABLE class. 
        Renamed TABLE::locked_by_flush member to open_placeholder since
        now it is also used for taking exclusive name-lock and not only
        by flush. 
        Introduced TABLE::is_name_opened() helper method which can be used
        to distinguish TABLE instances corresponding to open tables or
        placeholders for them from closed instances (e.g. due to their old
        version). Also introduced TABLE::needs_reopen_or_name_lock() helper
        which allows to check if TABLE instance corresponds to outdated
        version of table or to name-lock placeholder.
        Introduced TABLE_LIST::create member which marks elements of
        table list corresponds to the table to be created.
        Adjusted TABLE_LIST::placeholder() method to take into account 
        name-lock placeholders for tables to be created (this, for example,
        allows to properly handle such placeholders in lock_tables()).
      1f27a7a8
  31. 30 Apr, 2007 1 commit
    • unknown's avatar
      Bug #27653: Temp table can't be created if lower_case_table_names=1 and · 450dad93
      unknown authored
                  tmpdir has uppercase
      
      Fix: don't convert mysql_tmpdir to lower case when building the path to a
      temporary table
      
      
      mysql-test/include/have_lowercase1.inc:
        BitKeeper file /benchmarks/ext3/TOSAVE/tsmith/bk/maint/b27653/50/mysql-test/include/have_lowercase1.inc
      mysql-test/r/lowercase1.require:
        BitKeeper file /benchmarks/ext3/TOSAVE/tsmith/bk/maint/b27653/50/mysql-test/r/lowercase1.require
      mysql-test/r/lowercase_mixed_tmpdir.result:
        BitKeeper file /benchmarks/ext3/TOSAVE/tsmith/bk/maint/b27653/50/mysql-test/r/lowercase_mixed_tmpdir.result
      mysql-test/t/lowercase_mixed_tmpdir-master.opt:
        BitKeeper file /benchmarks/ext3/TOSAVE/tsmith/bk/maint/b27653/50/mysql-test/t/lowercase_mixed_tmpdir-master.opt
      mysql-test/t/lowercase_mixed_tmpdir-master.sh:
        BitKeeper file /benchmarks/ext3/TOSAVE/tsmith/bk/maint/b27653/50/mysql-test/t/lowercase_mixed_tmpdir-master.sh
      mysql-test/t/lowercase_mixed_tmpdir.test:
        BitKeeper file /benchmarks/ext3/TOSAVE/tsmith/bk/maint/b27653/50/mysql-test/t/lowercase_mixed_tmpdir.test
      sql/sql_table.cc:
        When building the path for a temporary table file, do not
        convert mysql_tmpdir to lower case; lower_case_table_names
        should not apply to mysql_tmpdir.
      450dad93
  32. 10 Apr, 2007 1 commit
    • unknown's avatar
      Bug#27069 set with identical elements are created(additional fix) · 32c7e3bf
      unknown authored
      issue an error in strict mode
      if enum|set column has duplicates members in 'create table'
      
      
      mysql-test/r/strict.result:
        test case
      mysql-test/t/strict.test:
        test case
      sql/sql_table.cc:
        issue an error in strict mode
        if enum|set has duplicates members
      32c7e3bf
  33. 03 Apr, 2007 1 commit
    • unknown's avatar
      BUG#18676 when cluster storage engine is down, misleading error message on create table with 4009. · 83f3812e
      unknown authored
      mysql-test/r/ndb_autodiscover.result:
        changes ndbd error code to mysqld error code when no cluster connection
      sql/ha_ndbcluster.cc:
        map 4009 error code to mysql not connected error
      sql/handler.cc:
        define return codes to ha_table_exists_in_engine to something useful
          NOTE: in 5.1 this should call a handlerton method, not horrible ifdef ndb stuff
      sql/sql_table.cc:
        clearly define what happens on create table if exits/not exists/not connected to engine
      83f3812e
  34. 02 Apr, 2007 1 commit
    • unknown's avatar
      Bug#27069 set with identical elements are created · eb502a02
      unknown authored
      added the check for unique elements count in SET
      
      
      mysql-test/r/type_set.result:
        test result
      mysql-test/t/type_set.test:
        test case
      sql/field.cc:
        removed the check for elements count in SET
      sql/sql_table.cc:
        added the check for unique elements count in SET
      eb502a02
  35. 30 Mar, 2007 2 commits
    • unknown's avatar
      Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the · e8da4d1b
      unknown authored
      NO_AUTO_VALUE_ON_ZERO mode.
      
      In the NO_AUTO_VALUE_ON_ZERO mode the table->auto_increment_field_not_null
      variable is used to indicate that a non-NULL value was specified by the user
      for an auto_increment column. When an INSERT .. ON DUPLICATE updates the
      auto_increment field this variable is set to true and stays unchanged for the
      next insert operation. This makes the next inserted row sometimes wrongly have
      0 as the value of the auto_increment field.
      
      Now the fill_record() function resets the table->auto_increment_field_not_null
      variable before filling the record.
      The table->auto_increment_field_not_null variable is also reset by the
      open_table() function for a case if we missed some auto_increment_field_not_null
      handling bug.
      Now the table->auto_increment_field_not_null is reset at the end of the
      mysql_load() function.
      
      Reset the table->auto_increment_field_not_null variable after each
      write_row() call in the copy_data_between_tables() function.
      
      
      
      
      sql/field_conv.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        A comment is corrected.
      sql/handler.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the handler::update_auto_increment() function doesn't reset the
        table->auto_increment_field_not_null variable as it is done in the
        fill_record() function.
      sql/sql_base.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the fill_record() function resets the table->auto_increment_field_not_null
        variable before filling the record.
        The table->auto_increment_field_not_null variable is also reset by the
        open_table() function for a case if we missed some auto_increment_field_not_null
        handling bug.
      sql/sql_insert.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the the table->auto_increment_field_not_null is reset at the end of the
        mysql_insert() an in the select_insert class destructor.
      sql/sql_load.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the 
        NO_AUTO_VALUE_ON_ZERO mode.
        Now the table->auto_increment_field_not_null is reset at the end of the
        mysql_load() function.
      sql/sql_table.cc:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the
        NO_AUTO_VALUE_ON_ZERO mode.
        Reset the table->auto_increment_field_not_null variable after each
        write_row() call in the copy_data_between_tables() function.
      sql/table.h:
        Bug#23233: 0 as LAST_INSERT_ID() after INSERT .. ON DUPLICATE in the
        NO_AUTO_VALUE_ON_ZERO mode.
        A comment added.
      mysql-test/r/insert_update.result:
        Added the test case for the bug#23233: 0 as LAST_INSERT_ID() after
        INSERT .. ON DUPLICATE in the NO_AUTO_VALUE_ON_ZERO mode.
      mysql-test/t/insert_update.test:
        Added the test case for the bug#23233: 0 as LAST_INSERT_ID() after
        INSERT .. ON DUPLICATE in the NO_AUTO_VALUE_ON_ZERO mode.
      e8da4d1b
    • unknown's avatar
      BUG#26138 - REPAIR TABLE with option USE_FRM erases all records in · ddbcb451
      unknown authored
                  ARCHIVE table
      ARCHIVE table was truncated by REPAIR TABLE ... USE_FRM statement.
      The table handler returned its file name extensions in a wrong order.
      REPAIR TABLE believed it has to use the meta file to create a new table
      from it.
      
      With the fixed order, REPAIR TABLE does now use the data file to create
      a new table. So REPAIR TABLE ... USE_FRM works well with ARCHIVE engine
      now.
      
      This issue affects 5.0 only, since in 5.1 ARCHIVE engine stores meta
      information and data in the same file.
      
      
      mysql-test/r/archive.result:
        A test case for bug#26138.
      mysql-test/t/archive.test:
        A test case for bug#26138.
      sql/examples/ha_example.cc:
        Added a comment.
      sql/ha_archive.cc:
        First element of engine file name extentions array should be meta/index
        file extention. Second element - data file extention. This is true
        for engines that have separate meta/index file and data file.
        
        Reoder ha_archive_exts elements to meet described above requirement.
      sql/handler.h:
        Added a comment.
      sql/sql_table.cc:
        Added a comment.
      ddbcb451
  36. 23 Mar, 2007 1 commit
    • unknown's avatar
      Bug #27395 OPTION_STATUS_NO_TRANS_UPDATE is not preserved at the end of SF() · 25dc1f57
      unknown authored
      thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit was not restored at the end of SF() invocation, where
      SF() modified non-ta table.
      As the result of this artifact it was not possible to detect whether there were any side-effects when
      top-level query ends. 
      If the top level query table was not modified and the bit is lost there would be no binlogging.
      
      Fixed with preserving the bit inside of thd->no_trans_update struct. The struct agregates two bool flags
      telling whether the current query and the current transaction modified any non-ta table.
      The flags stmt, all are dropped at the end of the query and the transaction.
      
      
      mysql-test/r/sp_trans.result:
        results will be changed once again after bug#23333 will be fixed.
      mysql-test/t/sp_trans.test:
        regression test added
      sql/ha_ndbcluster.cc:
        replacing thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit and bool thd->no_trans_update
        with thd->no_trans_update as struct
      sql/handler.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/log.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/set_var.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sp_head.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_class.h:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_delete.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_insert.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_load.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_parse.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_table.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      sql/sql_update.cc:
        replacing operations with thd->options' OPTION_STATUS_NO_TRANS_UPDATE bit
        with the member thd->no_trans_update.all;
        converting thd->no_trans_update into struct of bools.
      25dc1f57
  37. 22 Mar, 2007 1 commit
    • unknown's avatar
      Fixed compiler warnings. · e962f35c
      unknown authored
      mysys/default.c:
        Fixed bug.
      ndb/src/mgmclient/CommandInterpreter.cpp:
        Added parenthesis around the expression.
      sql/mysqld.cc:
        Fixed compiler warnings.
        
        Added a missing component in options struct (bug).
      sql-common/my_time.c:
        Removed garbage.
      sql/sql_table.cc:
        A possible use of a variable uninitialized.
      support-files/compiler_warnings.supp:
        BitKeeper file /home/my/bk/mysql-4.1-main/support-files/compiler_warnings.supp
      e962f35c