An error occurred fetching the project authors.
  1. 18 Jun, 2009 1 commit
    • Alfranio Correia's avatar
      BUG#43929 binlog corruption when max_binlog_cache_size is exceeded · 3cf052b7
      Alfranio Correia authored
      Large transactions and statements may corrupt the binary log if the size of the
      cache, which is set by the max_binlog_cache_size, is not enough to store the
      the changes.
      
      In a nutshell, to fix the bug, we save the position of the next character in the
      cache before starting processing a statement. If there is a problem, we simply
      restore the position thus removing any effect of the statement from the cache.
      Unfortunately, to avoid corrupting the binary log, we may end up loosing changes
      on non-transactional tables if they do not fit in the cache. In such cases, we
      store an Incident_log_event in order to stop the slave and alert users that some
      changes were not logged.
      
      Precisely, for every non-transactional changes that do not fit into the cache,
      we do the following:
        a) the statement is *not* logged
        b) an incident event is logged after committing/rolling back the transaction,
        if any. Note that if a failure happens before writing the incident event to
        the binary log, the slave will not stop and the master will not have reported
        any error.
        c) its respective statement gives an error
      
      For transactional changes that do not fit into the cache, we do the following:
        a) the statement is *not* logged
        b) its respective statement gives an error
      
      To work properly, this patch requires two additional things. Firstly, callers to
      MYSQL_BIN_LOG::write and THD::binlog_query must handle any error returned and
      take the appropriate actions such as undoing the effects of a statement. We
      already changed some calls in the sql_insert.cc, sql_update.cc and sql_insert.cc
      modules but the remaining calls spread all over the code should be handled in
      BUG#37148. Secondly, statements must be either classified as DDL or DML because
      DDLs that do not get into the cache must generate an incident event since they
      cannot be rolled back.
      3cf052b7
  2. 04 Jun, 2009 1 commit
    • Tatiana A. Nurnberg's avatar
      Bug#32149: Long semaphore wait for adaptive hash latch · e34085fe
      Tatiana A. Nurnberg authored
      Holding on to the temporary inno hash index latch is an optimization in
      many cases, but a pessimization in some others.
      
      Release temporary latches for those corner cases we (or rather, or customers,
      thanks!) have identified, that is, when we are about to do something that
      might take a really long time, like REPAIR or filesort.
      
      sql/ha_myisam.cc:
        Let go of (inno, for now) latch when doing MyISAM-repair.
        (optimize passes through repair.) ("Stuck" in "Repair with
        keycache".)
      sql/sql_insert.cc:
        Let go of (inno, for now) latch when doing CREATE...SELECT
        in select_insert::send_data() -- it might take a while.
        ("stuck" in "Sending data")
      sql/sql_select.cc:
        Release temporary (inno, for now) latch on
        - free_tmp_table() (this can take surprisingly long, "removing tmp table")
        - create_myisam_from_heap() (HEAP table overflowing onto disk as MyISAM,
          "converting HEAP to MyISAM")
      e34085fe
  3. 30 May, 2009 1 commit
    • He Zhenxing's avatar
      BUG#41948 Query_log_event constructor needlessly contorted · abf5f8da
      He Zhenxing authored
      Make the caller of Query_log_event, Execute_load_log_event
      constructors and THD::binlog_query to provide the error code
      instead of having the constructors to figure out the error code.
      
      sql/log_event.cc:
        Changed constructors of Query_log_event and Execute_load_log_event to accept the error code argument instead of figuring it out by itself
      sql/log_event.h:
        Changed constructors of Query_log_event and Execute_load_log_event to accept the error code argument
      abf5f8da
  4. 27 Mar, 2009 2 commits
    • Georgi Kodinov's avatar
      fixed a compilation warning · 5f2bda83
      Georgi Kodinov authored
      5f2bda83
    • He Zhenxing's avatar
      BUG#37145 Killing a statement doing DDL may log binlog event with error code 1053 · 51a91166
      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.
      51a91166
  5. 24 Mar, 2009 2 commits
    • Georgi Kodinov's avatar
      Fixed initialization order warining. · f3a08d56
      Georgi Kodinov authored
      f3a08d56
    • Leonard Zhou's avatar
      BUG#41719 delayed INSERT into timestamp col needs set time_zone for concurrent binlogging · 5fdc5510
      Leonard Zhou authored
      When do 'insert delayed' operation, the time_zone info doesn't be keeped in the row info.
      So when we do insert sometime later, time_zone didn't write into binlog.
      This will cause wrong result for timestamp column in slave.
      
      Our solution is that adding time_zone info with the delayed-row and
      restoring time_zone from row-info when execute that row in the furture by another thread.
      So we can write correct time_zone info into binlog and got correct result in slave.
      
      
      mysql-test/r/rpl_timezone.result:
        Test result
      mysql-test/t/rpl_timezone.test:
        Add test for bug#41719
      sql/sql_insert.cc:
        Add time_zone info in the delayed-row and restore time_zone when execute the row in the furture by another thread.
      5fdc5510
  6. 19 Feb, 2009 1 commit
    • Davi Arnaut's avatar
      Bug#41098: Query Cache returns wrong result with concurrent insert · 664bb23a
      Davi Arnaut authored
      The problem is that select queries executed concurrently with
      a concurrent insert on a MyISAM table could be cached if the
      select started after the query cache invalidation but before
      the unlock of tables performed by the concurrent insert. This
      race could happen because the concurrent insert was failing
      to prevent cache of select queries happening at the same time.
      
      The solution is to add a 'uncacheable' status flag to signal
      that a concurrent insert is being performed on the table and
      that queries executing at the same time shouldn't cache the
      results.
      
      mysql-test/r/query_cache_debug.result:
        Add test case result for Bug#41098
      mysql-test/t/disabled.def:
        Re-enable test case.
      mysql-test/t/query_cache_debug.test:
        Add test case for Bug#41098
      sql/sql_cache.cc:
        Debug sync point for regression testing purposes.
      sql/sql_insert.cc:
        Remove meaningless query cache invalidate. There is already
        a preceding invalidate for queries that started before the
        concurrent insert.
      storage/myisam/ha_myisam.cc:
        Check for a active concurrent insert.
      storage/myisam/mi_locking.c:
        Signal the start of a concurrent insert. Flag is zeroed once
        the state is updated back.
      storage/myisam/myisamdef.h:
        Add flag to signal a active concurrent insert.
      664bb23a
  7. 10 Feb, 2009 1 commit
  8. 03 Feb, 2009 1 commit
    • Davi Arnaut's avatar
      Bug#40536: SELECT is blocked by INSERT DELAYED waiting on · c9dc936a
      Davi Arnaut authored
                 upgrading lock, even with low_priority_updates
      
      The problem is that there is no mechanism to control whether a
      delayed insert takes a high or low priority lock on a table.
      
      The solution is to modify the delayed insert thread ("handler")
      to take into account the global value of low_priority_updates
      when taking table locks. The value of low_priority_updates is
      retrieved when the insert delayed thread is created and will
      remain the same for the duration of the thread.
      
      
      include/thr_lock.h:
        Update prototype.
      mysql-test/r/delayed.result:
        Add test case result for Bug#40536
      mysql-test/t/delayed.test:
        Add test case for Bug#40536
      mysys/thr_lock.c:
        Add function parameter which specifies the write lock type.
      sql/sql_insert.cc:
        Take a low priority write lock if global value of low_priority_updates
        was ON when the thread was created.
      c9dc936a
  9. 10 Nov, 2008 1 commit
  10. 15 Oct, 2008 1 commit
    • Georgi Kodinov's avatar
      Bug #38693: leaked memory with blobs! · 74735183
      Georgi Kodinov authored
      If delayed insert fails to upgrade the lock it was not
      freeing the temporary memory storage used to keep
      newly constructed blob values in memory.
      Fixed by iterating over the remaining rows in the delayed
      insert rowset and freeing the blob storage for each row.
      
      No test suite because it involves concurrent delayed inserts 
      on a table and cannot easily be made deterministic. 
      
      Added a correct valgrind suppression for Fedora 9.
      
      mysql-test/valgrind.supp:
        Added a vagrind suppression for Fedora 9
      sql/sql_insert.cc:
        Bug #38693: free the blobs temp storage on error.
      74735183
  11. 08 Oct, 2008 1 commit
    • Mats Kindahl's avatar
      Bug #34707: Row based replication: slave creates table within wrong database · dcd050c5
      Mats Kindahl authored
      The failure was caused by executing a CREATE-SELECT statement that creates a
      table in another database than the current one. In row-based logging, the
      CREATE statement was written to the binary log without the database, hence
      creating the table in the wrong database, causing the following inserts to
      fail since the table didn't exist in the given database.
      
      Fixed the bug by adding a parameter to store_create_info() that will make
      the function print the database name before the table name and used that
      in the calls that write the CREATE statement to the binary log. The database
      name is only printed if it is different than the currently selected database.
      
      The output of SHOW CREATE TABLE has not changed and is still printed without
      the database name.
      
      mysql-test/suite/rpl/t/rpl_row_create_table.test:
        Added test to check that CREATE-SELECT into another database than the
        current one replicates.
      sql/sql_insert.cc:
        Adding parameter to calls to store_create_info().
      sql/sql_show.cc:
        Adding parameter to calls to store_create_info().
        
        Extending store_create_info() with parameter 'show_database' that will cause
        the database to be written before the table name.
      sql/sql_show.h:
        Adding parameter to call to store_create_info() to tell if the database should be shown or not.
      sql/sql_table.cc:
        Adding parameter to calls to store_create_info().
      dcd050c5
  12. 07 Oct, 2008 1 commit
    • Kristofer Pettersson's avatar
      Bug#38692 concurrent inserts cause valgrind errors in Query_cache::invalidate · 85ca9837
      Kristofer Pettersson authored
      Concurrent inserts produce valgrind error messages.
      The reason is that the query cache is invalidated after the target table object
      is closed.
      
      Since the delayed insert thread already takes care of invalidating the query
      cache there is no need to try to synchronize an extra cache invalidation call.
      
      The fix is to remove the query_cache_invalidate3 call altogether.
      
      sql/sql_insert.cc:
        When end_delayed_insert is called, the table_list items will be invalidated
        by the concurrent insert thread. Further more there is no need to call
        query_cache_invalidate here since the delayed insert thread takes care of
        this already.
      85ca9837
  13. 16 Sep, 2008 1 commit
    • Narayanan V's avatar
      Bug#38338: REPLACE causes last_insert_id() to return an incorrect value · d714d290
      Narayanan V authored
                        
      Fix the write_record function to record auto increment
      values in a consistent way.
      
      mysql-test/r/auto_increment.result:
        Updated the test result file with the output of the
        new test case added to verify this bug.
      mysql-test/t/auto_increment.test:
        Added a new test case to verify this bug.
      sql/sql_insert.cc:
        The algorithm for the write_record function
        in sql_insert.cc is (more emphasis given to
        the parts that deal with the autogenerated values)
        
        1) If a write fails
        
           1.1) save the autogenerated value to avoid 
                thd->insert_id_for_cur_row to become 0.
        
           1.2) <logic to handle INSERT ON DUPLICATE KEY
                UPDATE and REPLACE>
        
        2) record the first successful insert id.
        
        explanation of the failure
        --------------------------
        
        As long as 1.1) was executed 2) worked fine.
        
        1.1) was always executed when REPLACE worked 
             with the last row update optimization, but
             in cases where 1.1) was not executed 2)
             would fail and would result in the autogenerated
             value not being saved.
        
        solution
        --------
        
        repeat a check for thd->insert_id_for_cur_row 
        being zero similar to 1.1) before 2) and ensure
        that the correct value is saved.
      d714d290
  14. 10 Sep, 2008 1 commit
    • Kristofer Pettersson's avatar
      Bug#38692 concurrent inserts cause valgrind errors in Query_cache::invalidate · a8b25524
      Kristofer Pettersson authored
            
      If a delayed insert thread was aborted by a concurrent 'truncate table'
      statement, then the diagnostic area would fail with an assert in a debug build
      because no actual error message was pushed on the stack despite a thread
      being killed.
            
      This patch adds an error message to the stack.
      
      
      sql/sql_insert.cc:
        * Changed sql_print_error() to my_error() to avoid assertion in the DA
        * Added assertion in "should never happen" branch.
      a8b25524
  15. 03 Sep, 2008 1 commit
    • Ramil Kalimullin's avatar
      Fix for bug#38821: Assert table->auto_increment_field_not_null failed · f0a50bd9
      Ramil Kalimullin authored
      in open_table()
      
      Problem: repeating "CREATE... ( AUTOINCREMENT) ... SELECT" may lead to
      an assertion failure.
      
      Fix: reset table->auto_increment_field_not_null after each record 
      writing.
      
      
      mysql-test/r/create.result:
        Fix for bug#38821: Assert table->auto_increment_field_not_null failed 
        in open_table()
          - test result.
      mysql-test/t/create.test:
        Fix for bug#38821: Assert table->auto_increment_field_not_null failed 
        in open_table()
          - test case.
      sql/sql_insert.cc:
        Fix for bug#38821: Assert table->auto_increment_field_not_null failed 
        in open_table()
          - reset table->auto_increment_field_not_null after writing a record
        for "{CREATE, INSERT}..SELECT".
      f0a50bd9
  16. 29 Aug, 2008 1 commit
    • Andrei Elkin's avatar
      Bug #38798 Assertion mysql_bin_log.is_open() failed in binlog_trans_log_savepos() · c0de944f
      Andrei Elkin authored
            
      The assert is about binlogging must have been activated, but it was
      not actually according to the reported how-to-repeat instuctions.
      Analysis revealed that binlog_start_trans_and_stmt() was called
      without prior testing if binlogging is ON.
      
      Fixed with avoing entering binlog_start_trans_and_stmt() if binlog is
      not activated.
      
      
      mysql-test/r/skip_log_bin.result:
        new results.
      mysql-test/t/skip_log_bin-master.opt:
        the option to deactivate binlogging.
      mysql-test/t/skip_log_bin.test:
        regression test for the bug.
      sql/sql_insert.cc:
        avoing entering binlog_start_trans_and_stmt() if binlog is not activated.
      c0de944f
  17. 19 Aug, 2008 1 commit
    • Mats Kindahl's avatar
      Bug #34707: Row based replication: slave creates table within wrong database · 5cd9d96a
      Mats Kindahl authored
      The failure was caused by executing a CREATE-SELECT statement that creates a
      table in another database than the current one. In row-based logging, the
      CREATE statement was written to the binary log without the database, hence
      creating the table in the wrong database, causing the following inserts to
      fail since the table didn't exist in the given database.
      
      Fixed the bug by adding a parameter to store_create_info() that will make
      the function print the database name before the table name and used that
      in the calls that write the CREATE statement to the binary log. The database
      name is only printed if it is different than the currently selected database.
      
      The output of SHOW CREATE TABLE has not changed and is still printed without
      the database name.
      
      mysql-test/suite/rpl/r/rpl_row_create_table.result:
        Result file change.
      mysql-test/suite/rpl/t/rpl_row_create_table.test:
        Added test to check that CREATE-SELECT into another database than the
        current one replicates.
      sql/sql_insert.cc:
        Adding parameter to calls to store_create_info().
      sql/sql_show.cc:
        Adding parameter to calls to store_create_info().
        
        Extending store_create_info() with parameter 'show_database' that will cause
        the database to be written before the table name.
      sql/sql_show.h:
        Adding parameter to call to store_create_info() to tell if the database should be shown or not.
      sql/sql_table.cc:
        Adding parameter to calls to store_create_info().
      5cd9d96a
  18. 30 Jun, 2008 1 commit
    • Mats Kindahl's avatar
      BUG#37426: RBR breaks for CHAR() UTF-8 fields > 85 chars · 711305e2
      Mats Kindahl authored
            
      In order to handle CHAR() fields, 8 bits were reserved for
      the size of the CHAR field. However, instead of denoting the
      number of characters in the field, field_length was used which
      denotes the number of bytes in the field.
      
      Since UTF-8 fields can have three bytes per character (and
      has been extended to have four bytes per character in 6.0),
      an extra two bits have been encoded in the field metadata
      work for fields of type Field_string (i.e., CHAR fields).
      
      Since the metadata word is filled, the extra bits have been
      encoded in the upper 4 bits of the real type (the most 
      significant byte of the metadata word) by computing the
      bitwise xor of the extra two bits. Since the upper 4 bits
      of the real type always is 1111 for Field_string, this 
      means that for fields of length <256, the encoding is
      identical to the encoding used in pre-5.1.26 servers, but
      for lengths of 256 or more, an unrecognized type is formed,
      causing an old slave (that does not handle lengths of 256
      or more) to stop.
      
      
      mysql-test/extra/rpl_tests/rpl_row_basic.test:
        Adding test cases for replicating UTF-8 fields of lengths
        of 256 or more (bytes).
      mysql-test/suite/binlog/r/binlog_base64_flag.result:
        Result file change.
      mysql-test/suite/binlog/t/binlog_base64_flag.test:
        Adding tests to trigger check that an error is generated when replicating from a
        5.1.25 server for tables with a CHAR(128) but not when replicating a table with a
        CHAR(63). Although the bug indicates that the limit is 83, we elected to use CHAR(63)
        since 6.0 uses 4-byte UTF-8, and anything exceeding 63 would then cause the test to fail
        when the patch is merged to 6.0.
      mysql-test/suite/bugs/combinations:
        Adding combinations file to run all bug reports in all binlog modes (where
        applicable).
      mysql-test/suite/bugs/r/rpl_bug37426.result:
        Result file change.
      mysql-test/suite/bugs/t/rpl_bug37426.test:
        Added test for reported bug.
      mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result:
        Result file change.
      sql/field.cc:
        Encoding an extra two bits in the most significant nibble (4 bits)
        of the metadata word. Adding assertions to ensure that no attempt
        is made to use lengths longer than supported.
        
        Extending compatible_field_size() function with an extra parameter
        holding a Relay_log_instace for error reporting.
        
        Field_string::compatible_field_size() now reports an error if field
        size for a CHAR is >255.
      sql/field.h:
        Field length is now computed from most significant 4 bits
        of metadata word, or is equal to the row pack length if
        there is no metadata.
        
        Extending compatible_field_size() function with an extra parameter
        holding a Relay_log_instace for error reporting.
      sql/rpl_utility.cc:
        Adding relay log parameter to compatible_field_size().
        
        Minor refactoring to eliminate duplicate code.
      sql/slave.cc:
        Extending rpl_master_has_bug() with a single-argument predicate function and
        a parameter to the predicate function. The predicate function can be used to
        test for extra conditions for the bug before writing an error message.
      sql/slave.h:
        Extending rpl_master_has_bug() with a single-argument predicate function and
        a parameter to the predicate function. The predicate function can be used to
        test for extra conditions for the bug before writing an error message.
        
        Also removing gratuitous default argument.
      sql/sql_insert.cc:
        Changing calls to rpl_master_has_bug() to adapt to changed signature.
      711305e2
  19. 03 Jun, 2008 1 commit
    • Mattias Jonsson's avatar
      Bug#31210: INSERT DELAYED crashes server when used on partitioned tables · a8af693b
      Mattias Jonsson authored
        
      Problem was an unclear error message since it could suggest that
      MyISAM did not support INSERT DELAYED.
      Changed the error message to say that DELAYED is not supported by the
      table, instead of the table's storage engine.
      The confusion is that a partitioned table is in somewhat sense using
      the partitioning storage engine, which in turn uses the ordinary
      storage engine. By saying that the table does not support DELAYED we
      do not give any extra informantion about the storage engine or if it
      is partitioned.
      
      mysql-test/r/innodb-replace.result:
        Bug#31210: INSERT DELAYED crashes server when used on partitioned tables
        
        changed error message
      mysql-test/t/innodb-replace.test:
        Bug#31210: INSERT DELAYED crashes server when used on partitioned tables
        
        changed error message
      mysql-test/t/merge.test:
        Bug#31210: INSERT DELAYED crashes server when used on partitioned tables
        
        changed error message
      mysql-test/t/partition_hash.test:
        Bug#31210: INSERT DELAYED crashes server when used on partitioned tables
        
        changed error message
      sql/share/errmsg.txt:
        Bug#31210: INSERT DELAYED crashes server when used on partitioned tables
        
        added error message for tables not supporting DELAYED
      sql/sql_insert.cc:
        Bug#31210: INSERT DELAYED crashes server when used on partitioned tables
        
        changed error message
      a8af693b
  20. 08 Apr, 2008 1 commit
    • unknown's avatar
      Bug #35762 Failing CREATE-SELECT steels Table map of the following query · 73febb3b
      unknown authored
      Among two claimed artifacts the critical one is in that the Table map of 
      a query following the failing with a duplicate key error CREATE-SELECT is skipped from
      instantionating (and thus binlogging). That leads to sending a "chopped" group of the data
      row-events without the table map head to the slave. 
      The slave can not apply the only data row events.
      It's not easy to force the slave to react with an error in such a case (the second complaint
      on the bug report), because the lack of a table Rows_log_event::do_apply_event the data row event
      handler is a common situation which  normally designates the event has to be filtered out
      basing on the repliation do/ingore rules decision.
      
      Fixed: table map creating and binlogging is restored via deploying the standard cleanup call in
      select_create::abort().
      No error is reported if by chance the table map was not been binlogged.
      Leaving this out to resolve with considering how to combine the do/ingore rules with the situation
      when erronoulsy the Table_map is not written to binlog.
      
      
      mysql-test/suite/rpl/r/rpl_row_create_table.result:
        results changed
      mysql-test/suite/rpl/t/rpl_row_create_table.test:
        regression test for the bug
      sql/sql_insert.cc:
        adding resetting of thd binlogging state that was missed for the particular case of failing CREATE..SELECT
      73febb3b
  21. 28 Mar, 2008 2 commits
    • unknown's avatar
      Bug#21413 - Engine table handler used by multiple threads · fe22ff56
      unknown authored
                  in REPLACE DELAYED
          
      post push patch, removing the optimization for
      copying delayed_insert variables.
      
      
      sql/sql_insert.cc:
        Bug#21413 - Engine table handler used by multiple threads
                    in REPLACE DELAYED
        
        post push patch, removing the optimization for
        copying delayed_insert variables.
        (restored some parts which caused errors)
      fe22ff56
    • unknown's avatar
      BUG#29020 (Event results not correctly replicated to slave in RBR): · f56d77da
      unknown authored
      The bug allow multiple executing transactions working with non-transactional
      to interfere with each others by interleaving the events of different trans-
      actions.
      
      Bug is fixed by writing non-transactional events to the transaction cache and
      flushing the cache to the binary log at statement commit. To mimic the behavior
      of normal statement-based replication, we flush the transaction cache in row-
      based mode when there is no committed statements in the transaction cache,
      which means we are committing the first one. This means that it will be written
      to the binary log as a "mini-transaction" with just the rows for the statement.
      
      Note that the changes here does not take effect when building the server with
      HAVE_TRANSACTIONS set to false, but it is not clear if this was possible before
      this patch either.
      
      For row-based logging, we also have that when AUTOCOMMIT=1, the code now always
      generates a BEGIN/COMMIT pair for single statements, or BEGIN/ROLLBACK pair in the
      case of non-transactional changes in a statement that was rolled back. Note that
      for the case where changes to a non-transactional table causes a rollback due
      to error, the statement will now be logged with a BEGIN/ROLLBACK pair, even
      though some changes has been committed to the non-transactional table.
      
      
      mysql-test/extra/rpl_tests/rpl_row_delayed_ins.test:
        Removing SHOW BINLOG EVENTS causing test to be non-deterministic.
      mysql-test/r/ctype_cp932_binlog_row.result:
        Result change.
      mysql-test/suite/binlog/r/binlog_base64_flag.result:
        Result change.
      mysql-test/suite/binlog/r/binlog_multi_engine.result:
        Result file change.
      mysql-test/suite/binlog/r/binlog_row_binlog.result:
        Result file change.
      mysql-test/suite/binlog/r/binlog_row_ctype_ucs.result:
        Result file change.
      mysql-test/suite/binlog/r/binlog_row_insert_select.result:
        Result file change.
      mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result:
        Result file change.
      mysql-test/suite/binlog/r/binlog_stm_binlog.result:
        Result file change.
      mysql-test/suite/binlog/t/binlog_base64_flag.test:
        Removing table that will be used in test to prevent failing if preceeding
        tests forgot to drop the table.
      mysql-test/suite/rpl/r/rpl_rbr_to_sbr.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_basic_11bugs.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_create_table.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_delayed_ins.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_flsh_tbls.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_inexist_tbl.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_log.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_log_innodb.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_row_until.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_slave_skip.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_switch_stm_row_mixed.result:
        Result file change.
      mysql-test/suite/rpl/r/rpl_truncate_2myisam.result:
        Result file change.
      mysql-test/suite/rpl/t/rpl_row_create_table.test:
        Binlog position change.
      mysql-test/suite/rpl/t/rpl_row_flsh_tbls.test:
        Binlog position change.
      mysql-test/suite/rpl/t/rpl_row_mysqlbinlog.test:
        Binlog position change. Added stop position to mysqlbinlog argments to prevent
        extreneous output.
      mysql-test/suite/rpl/t/rpl_row_until.test:
        Binlog position change.
      mysql-test/suite/rpl/t/rpl_slave_skip.test:
        Binlog position change.
      mysql-test/suite/rpl/t/rpl_switch_stm_row_mixed.test:
        Removing extreneous SHOW BINLOG EVENTS causing test to be non-deterministic.
      mysql-test/suite/rpl_ndb/r/rpl_ndb_log.result:
        Result change.
      sql/log.cc:
        Adding variable at_least_one_stmt to denote that there is at least one
        statement committed to the transaction cache (but there might be more).
        
        Removing duplicate checks from binlog_end_trans(). The transaction cache
        should always be committed or rolled back when this function is called.
        
        Correcting conditions for binlog_rollback() and binlog_commit() and removing
        the previous "invisible commit" in favor of always using explicit commits
        in the binary log.
      sql/log_event.cc:
        Marking table map event to be cached. Removing Muted_query_log_event from code.
      sql/log_event.h:
        Removing unused class Muted_query_log_event.
      sql/sql_insert.cc:
        Adding missing call to ha_autocommit_or_rollback() for delayed thread. Marking
        CREATE-SELECT statements as transactional, since they don't need to be logged.
      f56d77da
  22. 27 Mar, 2008 1 commit
    • unknown's avatar
      Recommit of antonys previous commit. · fb27979e
      unknown authored
      Bug#21413
      "Engine table handler used by multiple threads in REPLACE DELAYED"
      When executing a REPLACE DELAYED statement, the storage engine
      ::extra() method was invoked by a different thread than the thread
      which has acquired the handler instance.
      
      This did not cause problems within the current server and with
      the current storage engines.
      But it has the potential to confuse future storage engines.
      
      Added code to avoid surplus calls to extra() method in case of DELAYED
      which avoids calling storage engine from a different thread than
      expected.
      
      No test case.
      This change does not change behavior in conjunction with current
      storage engines. So it cannot be tested by the regression test suite.
      
      
      sql/sql_insert.cc:
        Bug#21413
        When performing DELAYED operations, we should not call
        the storage engine methods from the 'wrong' context.
        Ensure that the calls to the methods are appropiately guarded
        by either moving calls to sections where the lock_type is checked.
        No need to copy all elements of TABLE_LIST when opening table
        using open_ltable().
      fb27979e
  23. 18 Mar, 2008 1 commit
    • unknown's avatar
      BUG#34768 - nondeterministic INSERT using LIMIT logged in stmt mode if · 1626b42c
      unknown authored
                  binlog_format=mixed
      
      Statement-based replication of DELETE ... LIMIT, UPDATE ... LIMIT,
      INSERT ... SELECT ... LIMIT is not safe as order of rows is not
      defined.
      
      With this fix, we issue a warning that this statement is not safe to
      replicate in statement mode, or go to row-based mode in mixed mode.
      
      Note that we may consider a statement as safe if ORDER BY primary_key
      is present. However it may confuse users to see very similiar statements
      replicated differently.
      
      Note 2: regular UPDATE statement (w/o LIMIT) is unsafe as well, but
      this patch doesn't address this issue. See comment from Kristian
      posted 18 Mar 10:55.
      
      
      mysql-test/suite/binlog/r/binlog_stm_ps.result:
        Updated a test case according to fix for BUG#34768:
        INSERT ... SELECT ... LIMIT is now replicated in row mode.
      mysql-test/suite/binlog/r/binlog_unsafe.result:
        A test case for BUG#34768.
      mysql-test/suite/binlog/t/binlog_unsafe.test:
        A test case for BUG#34768.
      sql/sql_delete.cc:
        Statement-based replication of DELETE ... LIMIT is not safe as order of
        rows is not defined, so in mixed mode we go to row-based.
      sql/sql_insert.cc:
        Statement-based replication of INSERT ... SELECT ... LIMIT is not safe
        as order of rows is not defined, so in mixed mode we go to row-based.
      sql/sql_update.cc:
        Statement-based replication of UPDATE ... LIMIT is not safe as order of
        rows is not defined, so in mixed mode we go to row-based.
      1626b42c
  24. 05 Mar, 2008 1 commit
    • unknown's avatar
      Fix for bug #34889: mysql_client_test::test_mysql_insert_id test fails · 0c1dd98e
      unknown authored
                          sporadically
      
      Under some circumstances, the mysql_insert_id() value after SELECT ...
      INSERT could return a wrong value. This could happen when the last
      SELECT ... INSERT did not involve an AUTO_INCREMENT column, but the
      value of mysql_insert_id() was changed by some previous statements.
      
      Fixed by checking the value of thd->insert_id_used in
      select_insert::send_eof() and returning 0 for mysql_insert_id() if it
      is not set.
      
      
      sql/sql_insert.cc:
        Do not return thd->last_insert_id unconditionally in
        select_insert::send_eof(). First check if thd->insert_id_used is
        non-zero, and return 0 otherwise.
      tests/mysql_client_test.c:
        Added a test case for bug #34889.
      0c1dd98e
  25. 19 Feb, 2008 2 commits
    • unknown's avatar
      Rename send_ok to my_ok. Similarly to my_error, it only records the status, · 14021c96
      unknown authored
      does not send it to the client.
      
      
      14021c96
    • unknown's avatar
      A fix and a test case for Bug#12713 "Error in a stored function called from · 526798db
      unknown authored
      a SELECT doesn't cause ROLLBACK of statem".
      
      The idea of the fix is to ensure that we always commit the current
      statement at the end of dispatch_command(). In order to not issue
      redundant disc syncs, an optimization of the two-phase commit
      protocol is implemented to bypass the two phase commit if
      the transaction is read-only.
      
      
      mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result:
        Update test results.
      mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result:
        Update test results.
      mysql-test/suite/rpl_ndb/t/disabled.def:
        Disable the tests, for which this changeset reveals a bug:
        the injector thread does not always add 'statement commit' to the
        rows injected in circular replication set up.
        To be investigated separately.
      sql/ha_ndbcluster_binlog.cc:
        Add close_thread_tables() to run_query: this ensures
        that all tables are closed and there is no pending statement transaction.
      sql/handler.cc:
        Implement optimisation of read-only transactions.
        If a transaction consists only of DML statements that do not change
        data, we do not perform a two-phase commit for it 
        (run one phase commit only).
      sql/handler.h:
        Implement optimisation of read-only transactions.
        If a transaction consists only of DML statements that do not change
        data, we do not perform a two-phase commit for it 
        (run one phase commit only).
      sql/log.cc:
        Mark the binlog transaction read-write whenever it's started.
        We never read from binlog, so it's safe and least intrusive to add
        this mark up here.
      sql/log_event.cc:
        Update to the new layout of thd->transaction.
      sql/rpl_injector.cc:
        Always commit statement transaction before committing the global one.
      sql/sp.cc:
        Ad comments.
      sql/sp_head.cc:
        Add comments.
      sql/sql_base.cc:
        Commit transaction at the end of the statement. Always.
      sql/sql_class.cc:
        Update thd_ha_data to return the right pointer in the new layout.
        
        Fix select_dumpvar::send_data to properly return operation status.
        A test case from commit.inc would lead to an assertion failure in the 
        diagnostics area (double assignment). Not test otherwise by the test suite.
      sql/sql_class.h:
        Implement a new layout of storage engine transaction info in which 
        it is easy to access all members related to the handlerton only
        based on ht->slot.
      sql/sql_cursor.cc:
        Update to the new layout of thd->transaction.
      sql/sql_delete.cc:
        Remove wrong and now redundant calls to ha_autocommit_or_rollback.
        The transaction is committed in one place, at the end of the statement.
        Remove calls to mysql_unlock_tables, since some engines count locks
        and commit statement transaction in unlock_tables(), which essentially
        equates mysql_unlock_tables to ha_autocommit_or_rollback.
        Previously it was necessary to unlock tables soon because we wanted
        to avoid sending of 'ok' packet to the client under locked tables.
        This is no longer necessary, since OK packet is also sent from one place
        at the end of transaction.
      sql/sql_do.cc:
        Add DO always clears the error, we must rollback the current
        statement before this happens. Otherwise the statement will be committed,
        and not rolled back in the end.
      sql/sql_insert.cc:
        Remove wrong and now redundant calls to ha_autocommit_or_rollback.
        The transaction is committed in one place, at the end of the statement.
        Remove calls to mysql_unlock_tables, since some engines count locks
        and commit statement transaction in unlock_tables(), which essentially
        equates mysql_unlock_tables to ha_autocommit_or_rollback.
        Previously it was necessary to unlock tables soon because we wanted
        to avoid sending of 'ok' packet to the client under locked tables.
        This is no longer necessary, since OK packet is also sent from one place
        at the end of transaction.
      sql/sql_load.cc:
        Remove wrong and now redundant calls to ha_autocommit_or_rollback.
        The transaction is committed in one place, at the end of the statement.
        Remove calls to mysql_unlock_tables, since some engines count locks
        and commit statement transaction in unlock_tables(), which essentially
        equates mysql_unlock_tables to ha_autocommit_or_rollback.
        Previously it was necessary to unlock tables soon because we wanted
        to avoid sending of 'ok' packet to the client under locked tables.
        This is no longer necessary, since OK packet is also sent from one place
        at the end of transaction.
      sql/sql_parse.cc:
        Implement optimisation of read-only transactions: bypass 2-phase
        commit for them.
        Always commit statement transaction before commiting the global one.
        Fix an unrelated crash in check_table_access, when called from 
        information_schema.
      sql/sql_partition.cc:
        Partitions commit at the end of a DDL operation.
        Make sure that send_ok() is done only if the commit has succeeded.
      sql/sql_table.cc:
        Use ha_autocommit_or_rollback and end_active_trans everywhere.
        Add end_trans to mysql_admin_table, so that it leaves no pending
        transaction.
      sql/sql_udf.cc:
        Remvove a redundant call to close_thread_tables()
      sql/sql_update.cc:
        Remove wrong and now redundant calls to ha_autocommit_or_rollback.
        The transaction is committed in one place, at the end of the statement.
        Remove calls to mysql_unlock_tables, since some engines count locks
        and commit statement transaction in unlock_tables(), which essentially
        equates mysql_unlock_tables to ha_autocommit_or_rollback.
        Previously it was necessary to unlock tables soon because we wanted
        to avoid sending of 'ok' packet to the client under locked tables.
        This is no longer necessary, since OK packet is also sent from one place
        at the end of transaction.
      mysql-test/include/commit.inc:
        New BitKeeper file ``mysql-test/include/commit.inc''
      mysql-test/r/commit_1innodb.result:
        New BitKeeper file ``mysql-test/r/commit_1innodb.result''
      mysql-test/t/commit_1innodb.test:
        New BitKeeper file ``mysql-test/t/commit_1innodb.test''
      526798db
  26. 16 Jan, 2008 1 commit
    • unknown's avatar
      A minor cleanup. · bab13c89
      unknown authored
      sql/sql_insert.cc:
        Remove a redundant call to my_error() -- in case of out of memory, the error
        is reported already by operator new (Delayed_inserts inherits from ilink).
      bab13c89
  27. 11 Jan, 2008 1 commit
    • unknown's avatar
      Bug#29477: Not all fields of the target table were checked to have a default · 72ebb0aa
      unknown authored
      value when inserting into a view.
      
      The mysql_prepare_insert function checks all fields of the target table that
      directly or indirectly (through a view) are specified in the INSERT
      statement to have a default value. This check can be skipped if the INSERT
      statement doesn't mention any insert fields. In case of a view this allows
      fields that aren't mentioned in the view to bypass the check.
      
      Now fields of the target table are always checked to have a default value
      when insert goes into a view.
      
      
      mysql-test/t/view.test:
        Added a test case for the bug#29477: Not all fields of the target table were 
        checked to have a default value when inserting into a view.
      mysql-test/r/view.result:
        Added a test case for the bug#29477: Not all fields of the target table were 
        checked to have a default value when inserting into a view.
      sql/sql_insert.cc:
        Bug#29477: Not all fields of the target table were checked to have a default
        value when inserting into a view.
        Now fields of the target table are always checked to have a default value
        when insert goes into a view.
      72ebb0aa
  28. 12 Dec, 2007 1 commit
    • unknown's avatar
      Bug#12713 "Error in a stored function called from a SELECT doesn't · 2a0d2fef
      unknown authored
      cause ROLLBACK of statement", part 1. Review fixes.
      
      Do not send OK/EOF packets to the client until we reached the end of 
      the current statement.
      This is a consolidation, to keep the functionality that is shared by all 
      SQL statements in one place in the server.
      Currently this functionality includes:
      - close_thread_tables()
      - log_slow_statement().
      
      After this patch and the subsequent patch for Bug#12713, it shall also include:
      - ha_autocommit_or_rollback()
      - net_end_statement()
      - query_cache_end_of_result().
      
      In future it may also include:
      - mysql_reset_thd_for_next_command().
      
      
      include/mysql_com.h:
        Rename now unused members of NET: no_send_ok, no_send_error, report_error.
        These were server-specific variables related to the client/server
        protocol. They have been made obsolete by this patch.
        
        Previously the same members of NET were used to store the error message
        both on the client and on the server. 
        The error message was stored in net.last_error (client: mysql->net.last_error,
        server: thd->net.last_error).
        The error code was stored in net.last_errno (client: mysql->net.last_errno,
        server: thd->net.last_errno).
        The server error code and message are now stored elsewhere 
        (in the Diagnostics_area), thus NET members are no longer used by the
        server.
        Rename last_error to client_last_error, last_errno to client_last_errno
        to avoid potential bugs introduced by merges.
      include/mysql_h.ic:
        Update the ABI file to reflect a rename. 
        Renames do not break the binary compatibility.
      libmysql/libmysql.c:
        Rename last_error to client_last_error, last_errno to client_last_errno.
        This is necessary to ensure no unnoticed bugs introduced by merged
        changesets.
        
        Remove net.report_error, net.no_send_ok, net.no_send_error.
      libmysql/manager.c:
        Rename net.last_errno to net.client_last_errno.
      libmysqld/lib_sql.cc:
        Rename net.last_errno to net.client_last_errno.
        
        Update the embedded implementation of the client-server protocol to
        reflect the refactoring of protocol.cc.
      libmysqld/libmysqld.c:
        Rename net.last_errno to net.client_last_errno.
      mysql-test/r/events.result:
        Update to reflect the change in mysql_rm_db(). Now we drop stored
        routines and events for a given database name only if there
        is a directory for this database name. ha_drop_database() and
        query_cache_invalidate() are called likewise. 
        Previously we would attempt to drop routines/events even if database
        directory was not found (it worked, since routines and events are stored
        in tables). This fixes Bug 29958 "Weird message on DROP DATABASE if mysql.proc
        does not exist".
        The change was done because the previous code used to call send_ok()
        twice, which led to an assertion failure when asserts against it were
        added by this patch.
      mysql-test/r/grant.result:
        Fix the patch for Bug 16470, now FLUSH PRIVILEGES produces an error 
        if mysql.procs_priv is missing.
        This fixes the assert that send_ok() must not called after send_error()
        (the original patch for Bug 16470 was prone to this).
      mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result:
        Produce a more detailed error message.
      mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result:
        Produce a more detailed error message.
      mysql-test/t/grant.test:
        Update the test, now FLUSH PRIVILEGES returns an error if mysql.procs_priv
        is missing.
      server-tools/instance-manager/mysql_connection.cc:
        Rename net.last_errno to net.client_last_errno.
      sql/ha_ndbcluster_binlog.cc:
        Add asserts. 
        
        Use getters to access statement status information.
        
        Add a comment why run_query() is broken. Reset the diagnostics area
        in the end of run_query() to fulfill the invariant that the diagnostics_area
        is never assigned twice per statement (see the comment in the code
        when this can happen). We still do not clear thd->is_fatal_error and
        thd->is_slave_error, which may lead to bugs, I consider the whole affair
        as something to be dealt with separately.
      sql/ha_partition.cc:
        fatal_error() doesn't set an error by itself. Perhaps we should
        remove this method altogether and instead add a flag to my_error 
        to set thd->is_fatal_error property.
        
        Meanwhile, this change is a part of inspection made to the entire source
        code with the goal to ensure that fatal_error()
        is always accompanied by my_error().
      sql/item_func.cc:
        There is no net.last_error anymore. Remove the obsolete assignment.
      sql/log_event.cc:
        Use getters to access statement error status information.
      sql/log_event_old.cc:
        Use getters to access statement error status information.
      sql/mysqld.cc:
        Previously, if a continue handler for an error was found, my_message_sql() 
        would not set an error in THD. Since the current statement
        must be aborted in any case, find_handler() had a hack to assign 
        thd->net.report_error to 1.
        
        Remove this hack. Set an error in my_message_sql() even if the continue
        handler is found. The error will be cleared anyway when the handler
        is executed. This is one action among many in this patch to ensure the 
        invariant that whenever thd->is_error() is TRUE, we have a message in 
        thd->main_da.message().
      sql/net_serv.cc:
        Use a full-blown my_error() in net_serv.cc to report an error,
        instead of just setting net->last_errno. This ensures the invariant that
        whenever thd->is_error() returns TRUE, we have a message in 
        thd->main_da.message().
        
        Remove initialization of removed NET members.
      sql/opt_range.cc:
        Use my_error() instead of just raising thd->net.report_error. 
        This ensures the invariant that whenever thd->is_error() returns TRUE, 
        there is a message in thd->main_da.message().
      sql/opt_sum.cc:
        Move invocation of fatal_error() right next to the place where
        we set the error message. That makes it easier to track that whenever
        fatal_error() is called, there is a message in THD.
      sql/protocol.cc:
        Rename send_ok() and send_eof() to net_send_ok() and net_send_eof() 
        respectively. These functions write directly to the network and are not 
        for use anywhere outside the client/server protocol code. 
        
        Remove the code that was responsible for cases when either there is 
        no error code, or no error message, or both.
        Instead the calling code ensures that they are always present. Asserts
        are added to enforce the invariant.
        
        Instead of a direct access to thd->server_status and thd->total_warn_count
        use function parameters, since these from now on don't always come directly
        from THD.
        
        Introduce net_end_statement(), the single-entry-point replacement API for 
        send_ok(), send_eof() and net_send_error().
        
        Implement Protocol::end_partial_result_set to use in select_send::abort()
        when there is a continue handler.
      sql/protocol.h:
        Update declarations.
      sql/repl_failsafe.cc:
        Use getters to access statement status information in THD.
        Rename net.last_error to net.client_last_error.
      sql/rpl_record.cc:
        Set an error message in prepare_record() if there is no default
        value for the field -- later we do print this message to the client.
      sql/rpl_rli.cc:
        Use getters to access statement status information in THD.
      sql/slave.cc:
        In create_table_from_dump() (a common function that is used in 
        LOAD MASTER TABLE SQL statement and COM_LOAD_MASTER_DATA), instead of hacks
        with no_send_ok, clear the diagnostics area when mysql_rm_table() succeeded.
        
        Update has_temporary_error() to work correctly when no error is set.
        This is the case when Incident_log_event is executed: it always returns
        an error but does not set an error message.
        
        Use getters to access error status information.
      sql/sp_head.cc:
        Instead of hacks with no_send_error, work through the diagnostics area 
        interface to suppress sending of OK/ERROR packets to the client.
        
        Move query_cache_end_of_result before log_slow_statement(), similarly
        to how it's done in dispatch_command().
      sql/sp_rcontext.cc:
        Remove hacks with assignment of thd->net.report_error, they are not
        necessary any more (see the changes in mysqld.cc).
      sql/sql_acl.cc:
        Use getters to access error status information in THD.
      sql/sql_base.cc:
        Access thd->main_da.sql_errno() only if there is an error. This fixes
        a bug when auto-discovery, that was effectively disabled under pre-locking.
      sql/sql_binlog.cc:
        Remove hacks with no_send_ok/no_send_error, they are not necessary 
        anymore: the caller is responsible for network communication.
      sql/sql_cache.cc:
        Disable sending of OK/ERROR/EOF packet in the end of dispatch_command
        if the response has been served from the query cache. This raises the 
        question whether we should store EOF packet in the query cache at all,
        or generate it anew for each statement (we should generate it anew), but
        this is to be addressed separately.
      sql/sql_class.cc:
        Implement class Diagnostics_area. Please see comments in sql_class.h
        for details.
        
        Fix a subtle coding mistake in select_send::send_data: when on slave, 
        an error in Item::send() was ignored.
        The problem became visible due to asserts that the diagnostics area is
        never double assigned.
        
        Remove initialization of removed NET members.
        
        In select_send::abort() do not call select_send::send_eof(). This is
        not inheritance-safe. Even if a stored procedure continue handler is
        found, the current statement is aborted, not succeeded.
        Instead introduce a Protocol API to send the required response, 
        Protocol::end_partial_result_set().
        
        This simplifies implementation of select_send::send_eof(). No need
        to add more asserts that there is no error, there is an assert inside
        Diagnostics_area::set_ok_status() already.
        
        Leave no trace of no_send_* in the code.
      sql/sql_class.h:
        Declare class Diagnostics_area. 
        
        Remove the hack with no_send_ok from
        Substatement_state.
        
        Provide inline implementations of send_ok/send_eof.
        
        Add commetns.
      sql/sql_connect.cc:
        Remove hacks with no_send_error. 
        
        Since now an error in THD is always set if net->error, it's not necessary
        to check both net->error and thd->is_error() in the do_command loop.
        
        Use thd->main_da.message() instead of net->last_errno.
        
        Remove the hack with is_slave_error in sys_init_connect. Since now we do not
        reset the diagnostics area in net_send_error (it's reset at the beginning
        of the next statement), we can access it safely even after 
        execute_init_command.
      sql/sql_db.cc:
        Update the code to satisfy the invariant that the diagnostics area is never
        assigned twice.
        Incidentally, this fixes Bug 29958 "Weird message on DROP DATABASE if 
        mysql.proc does not exist".
      sql/sql_delete.cc:
        Change multi-delete to abort in abort(), as per select_send protocol.
        Fixes the merge error with the test for Bug 29136
      sql/sql_derived.cc:
        Use getters to access error information.
      sql/sql_insert.cc:
        Use getters to access error information.
      sql-common/client.c:
        Rename last_error to client_last_error, last_errno to client_last_errno.
      sql/sql_parse.cc:
        Remove hacks with no_send_error. Deploy net_end_statement().
        
        The story of COM_SHUTDOWN is interesting. Long story short, the server 
        would become on its death's door, and only no_send_ok/no_send_error assigned
        by send_ok()/net_send_error() would hide its babbling from the client.
        
        First of all, COM_QUIT does not require a response. So, the comment saying
        "Let's send a response to possible COM_QUIT" is not only groundless 
        (even mysqladmin shutdown/mysql_shutdown() doesn't send COM_QUIT after 
        COM_SHUTDOWN), it's plainly incorrect.
        
        Secondly, besides this additional 'OK' packet to respond to a hypothetical
        COM_QUIT, there was the following code in dispatch_command():
        
        if (thd->killed)
          thd->send_kill_message();
        if (thd->is_error()
          net_send_error(thd);
        
        This worked out really funny for the thread through which COM_SHUTDOWN
        was delivered: we would get COM_SHUTDOWN, say okay, say okay again, 
        kill everybody, get the kill signal ourselves, and then attempt to say 
        "Server shutdown in progress" to the client that is very likely long gone.
        
        This all became visible when asserts were added that the Diagnostics_area
        is not assigned twice.
        
        Move query_cache_end_of_result() to the end of dispatch_command(), since
        net_send_eof() has been moved there. This is safe, query_cache_end_of_result()
        is a no-op if there is no started query in the cache.
        
        Consistently use select_send interface to call abort() or send_eof()
        depending on the operation result.
        
        Remove thd->fatal_error() from reset_master(), it was a no-op. 
        in hacks with no_send_error woudl save us
        from complete breakage of the client/server protocol.
        
        Consistently use select_send::abort() whenever there is an error, 
        and select_send::send_eof() in case of success.
        The issue became visible due to added asserts.
      sql/sql_partition.cc:
        Always set an error in THD whenever there is a call to fatal_error().
      sql/sql_prepare.cc:
        Deploy class Diagnostics_area.
        Remove the unnecessary juggling with the protocol in 
        Select_fetch_protocol_binary::send_eof(). EOF packet format is 
        protocol-independent.
      sql/sql_select.cc:
        Call fatal_error() directly in opt_sum_query.
        Call my_error() whenever we call thd->fatal_error().
      sql/sql_servers.cc:
        Use getters to access error information in THD.
      sql/sql_show.cc:
        Use getters to access error information in THD.
        
        Add comments.
        
        Call my_error() whenever we call fatal_error().
      sql/sql_table.cc:
        Replace hacks with no_send_ok with the interface of the diagnostics area.
        
        Clear the error if ENOENT error in ha_delete_table().
      sql/sql_update.cc:
        Introduce multi_update::abort(), which is the proper way to abort a
        multi-update. This fixes the merge conflict between this patch and
        the patch for Bug 29136.
      sql/table.cc:
        Use a getter to access error information in THD.
      sql/tztime.cc:
        Use a getter to access error information in THD.
      2a0d2fef
  29. 26 Nov, 2007 2 commits
    • unknown's avatar
      5.0 version of the fix for bug #9481: mysql_insert_id() returns 0 after · 1836b736
      unknown authored
      insert ... select.
      
      The 5.0 manual page for mysql_insert_id() does not mention anything
      about INSERT ... SELECT, though its current behavior is incosistent
      with what the manual says about the plain INSERT.
      
      Fixed by changing the AUTO_INCREMENT and mysql_insert_id() handling
      logic in INSERT ... SELECT to be consistent with the INSERT behavior,
      the manual, and the changes in 5.1 introduced by WL3146:
      
      
      - mysql_insert_id() now returns the first automatically generated
      AUTO_INCREMENT value that was successfully inserted by INSERT ... SELECT
      
      -  if an INSERT ... SELECT statement is executed, and no automatically
      generated value is successfully inserted, mysql_insert_id() now returns
      the ID of the last inserted row.
      
      
      sql/sql_class.h:
        Replaced last_insert_id with autoinc_value_of_last_inserted_row to be
        consistent with 5.1 code.
      sql/sql_insert.cc:
        Revised the AUTO_INCREMENT and mysql_insert_id() handling logic in
        INSERT ... SELECT to be consistent with INSERT behavior, the manual, and
        changes in 5.1 introduced by WL3146:
        
        - mysql_insert_id() now returns the first automatically generated
        AUTO_INCREMENT value that was successfully inserted;
        
        -  if an INSERT ... SELECT statement is executed, and no automatically
        generated value is successfully inserted, mysql_insert_id() now returns
        the ID of the last inserted row.
      tests/mysql_client_test.c:
        Backported the test cases related to INSERT ... SELECT and
        mysql_insert_id() from WL3146 patch to 5.0.
      1836b736
    • unknown's avatar
      Fix for bug #32676: insert delayed crash with wrong column and function specified · 50375525
      unknown authored
      Problem: using wrong local lock type value in the mysql_insert() results in a crash. 
      
      Fix: use a proper value.
      
      
      mysql-test/r/delayed.result:
        Fix for bug #32676: insert delayed crash with wrong column and function specified
          - test result.
      mysql-test/t/delayed.test:
        Fix for bug #32676: insert delayed crash with wrong column and function specified
          - test case.
      sql/sql_insert.cc:
        Fix for bug #32676: insert delayed crash with wrong column and function specified
          - the local lock_type var assigment displaced just after the line 
            where the table_list->lock_type is filnally defined in the mysql_insert() 
            to avoid using its old value.
      50375525
  30. 19 Nov, 2007 1 commit
    • unknown's avatar
      Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT · 4addb6b7
      unknown authored
      led to creating corrupted index.
      
      Corrected fix. The new method called prepare2 is added to the select_create
      class. As all preparations are done by the select_create::prepare function
      it doesn't do anything. Slightly changed algorithm of calling the 
      start_bulk_insert function. Now it's called from the select_insert::prepare2
      function when the SQL_BUFFER_RESULT flags is set.
      The is_bulk_insert_mode flag is removed as it is not needed anymore.
      
      
      sql/sql_class.h:
        Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT
        led to creating corrupted index.
        Corrected fix. The new method called prepare2 is added to the select_create
        class. As all preparetions are done by the select_create::prepare function
        it doesn't do anything.
        The is_bulk_insert_mode flag is removed as it is not needed anymore.
      sql/sql_insert.cc:
        Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT
        led to creating corrupted index. Slightly changed algorithm of calling the
        start_bulk_insert function. Now it's called from the select_insert::prepare2
        function when the SQL_BUFFER_RESULT flags is set.
        Corrected fix. The is_bulk_insert_mode flag is removed as it is not needed
        anymore.
      4addb6b7
  31. 15 Nov, 2007 1 commit
    • unknown's avatar
      Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE · c8450b27
      unknown authored
                  corrupts a MERGE table
      Bug 26867 - LOCK TABLES + REPAIR + merge table result in
                  memory/cpu hogging
      Bug 26377 - Deadlock with MERGE and FLUSH TABLE
      Bug 25038 - Waiting TRUNCATE
      Bug 25700 - merge base tables get corrupted by
                  optimize/analyze/repair table
      Bug 30275 - Merge tables: flush tables or unlock tables
                  causes server to crash
      Bug 19627 - temporary merge table locking
      Bug 27660 - Falcon: merge table possible
      Bug 30273 - merge tables: Can't lock file (errno: 155)
      
      The problems were:
      
      Bug 26379 - Combination of FLUSH TABLE and REPAIR TABLE
                      corrupts a MERGE table
      
        1. A thread trying to lock a MERGE table performs busy waiting while
           REPAIR TABLE or a similar table administration task is ongoing on
           one or more of its MyISAM tables.
        
        2. A thread trying to lock a MERGE table performs busy waiting until all
           threads that did REPAIR TABLE or similar table administration tasks
           on one or more of its MyISAM tables in LOCK TABLES segments do UNLOCK
           TABLES. The difference against problem #1 is that the busy waiting
           takes place *after* the administration task. It is terminated by
           UNLOCK TABLES only.
        
        3. Two FLUSH TABLES within a LOCK TABLES segment can invalidate the
           lock. This does *not* require a MERGE table. The first FLUSH TABLES
           can be replaced by any statement that requires other threads to
           reopen the table. In 5.0 and 5.1 a single FLUSH TABLES can provoke
           the problem.
      
      Bug 26867 - LOCK TABLES + REPAIR + merge table result in
                  memory/cpu hogging
      
        Trying DML on a MERGE table, which has a child locked and
        repaired by another thread, made an infinite loop in the server.
      
      Bug 26377 - Deadlock with MERGE and FLUSH TABLE
      
        Locking a MERGE table and its children in parent-child order
        and flushing the child deadlocked the server.
      
      Bug 25038 - Waiting TRUNCATE
      
        Truncating a MERGE child, while the MERGE table was in use,
        let the truncate fail instead of waiting for the table to
        become free.
      
      Bug 25700 - merge base tables get corrupted by
                  optimize/analyze/repair table
      
        Repairing a child of an open MERGE table corrupted the child.
        It was necessary to FLUSH the child first.
      
      Bug 30275 - Merge tables: flush tables or unlock tables
                  causes server to crash
      
        Flushing and optimizing locked MERGE children crashed the server.
      
      Bug 19627 - temporary merge table locking
      
        Use of a temporary MERGE table with non-temporary children
        could corrupt the children.
      
        Temporary tables are never locked. So we do now prohibit
        non-temporary chidlren of a temporary MERGE table.
      
      Bug 27660 - Falcon: merge table possible
      
        It was possible to create a MERGE table with non-MyISAM children.
      
      Bug 30273 - merge tables: Can't lock file (errno: 155)
      
        This was a Windows-only bug. Table administration statements
        sometimes failed with "Can't lock file (errno: 155)".
      
      These bugs are fixed by a new implementation of MERGE table open.
      
      When opening a MERGE table in open_tables() we do now add the
      child tables to the list of tables to be opened by open_tables()
      (the "query_list"). The children are not opened in the handler at
      this stage.
      
      After opening the parent, open_tables() opens each child from the
      now extended query_list. When the last child is opened, we remove
      the children from the query_list again and attach the children to
      the parent. This behaves similar to the old open. However it does
      not open the MyISAM tables directly, but grabs them from the already
      open children.
      
      When closing a MERGE table in close_thread_table() we detach the
      children only. Closing of the children is done implicitly because
      they are in thd->open_tables.
      
      For more detail see the comment at the top of ha_myisammrg.cc.
      
      Changed from open_ltable() to open_and_lock_tables() in all places
      that can be relevant for MERGE tables. The latter can handle tables
      added to the list on the fly. When open_ltable() was used in a loop
      over a list of tables, the list must be temporarily terminated
      after every table for open_and_lock_tables().
      table_list->required_type is set to FRMTYPE_TABLE to avoid open of
      special tables. Handling of derived tables is suppressed.
      These details are handled by the new function
      open_n_lock_single_table(), which has nearly the same signature as
      open_ltable() and can replace it in most cases.
      
      In reopen_tables() some of the tables open by a thread can be
      closed and reopened. When a MERGE child is affected, the parent
      must be closed and reopened too. Closing of the parent is forced
      before the first child is closed. Reopen happens in the order of
      thd->open_tables. MERGE parents do not attach their children
      automatically at open. This is done after all tables are reopened.
      So all children are open when attaching them.
      
      Special lock handling like mysql_lock_abort() or mysql_lock_remove()
      needs to be suppressed for MERGE children or forwarded to the parent.
      This depends on the situation. In loops over all open tables one
      suppresses child lock handling. When a single table is touched,
      forwarding is done.
      
      Behavioral changes:
      ===================
      
      This patch changes the behavior of temporary MERGE tables.
      Temporary MERGE must have temporary children.
      The old behavior was wrong. A temporary table is not locked. Hence
      even non-temporary children were not locked. See
      Bug 19627 - temporary merge table locking.
      
      You cannot change the union list of a non-temporary MERGE table
      when LOCK TABLES is in effect. The following does *not* work:
      CREATE TABLE m1 ... ENGINE=MRG_MYISAM ...;
      LOCK TABLES t1 WRITE, t2 WRITE, m1 WRITE;
      ALTER TABLE m1 ... UNION=(t1,t2) ...;
      However, you can do this with a temporary MERGE table.
      
      You cannot create a MERGE table with CREATE ... SELECT, neither
      as a temporary MERGE table, nor as a non-temporary MERGE table.
      CREATE TABLE m1 ... ENGINE=MRG_MYISAM ... SELECT ...;
      Gives error message: table is not BASE TABLE.
      
      
      include/my_base.h:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added HA_EXTRA_ATTACH_CHILDREN and HA_EXTRA_DETACH_CHILDREN.
      include/myisammrg.h:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added element 'children_attached' to MYRG_INFO.
        Added declarations for myrg_parent_open(),
        myrg_attach_children() and myrg_detach_children()
        for the new MERGE table open approach.
      mysql-test/extra/binlog_tests/blackhole.test:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Preliminarily added new error message with a comment.
      mysql-test/r/create.result:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Fixed test result.
      mysql-test/r/delayed.result:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Moved test result from here to merge.result.
      mysql-test/r/merge.result:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Fixed/added test result.
      mysql-test/r/myisam.result:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Moved test result for bug 8306 from here to merge.result.
      mysql-test/suite/binlog/r/binlog_stm_blackhole.result:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Fixed test result.
      mysql-test/t/create.test:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Fixed error number.
      mysql-test/t/delayed.test:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Moved test from here to merge.test.
      mysql-test/t/merge.test:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Fixed test for new temporary MERGE table behavior.
        Exchanged error numbers by symbolic codes.
        Added tests. Included are tests for bugs
        8306 (moved from myisam.test), 26379, 19627, 25038, 25700, 26377,
        26867, 27660, 30275, and 30273.
        Fixed changes resulting from disabled CREATE...SELECT.
        Integrated tests moved from delayed.test and myisam.test to here.
      mysql-test/t/myisam.test:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Moved test for bug 8306 from here to merge.test.
      mysys/thr_lock.c:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added code to let the owner of a high priority lock (TL_WRITE_ONLY)
        to bypass its own lock.
      sql/ha_ndbcluster_binlog.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added 'thd' argument to init_tmp_table_share().
      sql/handler.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added 'thd' argument to init_tmp_table_share().
      sql/mysql_priv.h:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Removed declaration of check_merge_table_access(). It is now static
        in sql_parse.cc.
        Added declaration for fix_merge_after_open().
        Renamed open_and_lock_tables() to open_and_lock_tables_derived()
        with additional parameter 'derived'.
        Added inline functions simple_open_n_lock_tables() and
        open_and_lock_tables(), which call open_and_lock_tables_derived()
        and add the argument for 'derived'.
        Added new function open_n_lock_single_table(), which can be used
        as an replacement for open_ltable() in most situations. Internally
        it calls simple_open_n_lock_tables() so hat it is appropriate for
        MERGE tables.
        Added 'thd' argument to init_tmp_table_share().
      sql/slave.cc:
        ug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added comment.
      sql/sql_base.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        
        Defined new functions add_merge_table_list(),
        attach_merge_children(), detach_merge_children(), and
        fix_merge_after_open() for the new MERGE table open approach.
        
        Added calls of the new functions to
        close_handle_and_leave_table_as_lock(), close_thread_tables(),
        close_thread_table(), unlink_open_table(), reopen_name_locked_table(),
        reopen_table(), drop_locked_tables(), close_temporary_table(),
        and open_tables() respectively.
        
        Prevented special lock handling of merge children (like
        mysql_lock_remove, mysql_lock_merge or mysql_lock_abort)
        at many places. Some of these calls are forwarded to the
        parent table instead.
        
        Added code to set thd->some_tables_deleted for every thread that has
        a table open that we are flushing.
        Added code for MERGE tables to unlink_open_table().
        Added MERGE children to the list of unusable tables in open_table().
        Added MERGE table handling to reopen_table().
        Added lock handling and closing of a parent before the children
        in close_data_files_and_morph_locks().
        Added code for re-attaching children in reopen_tables().
        Added MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN to the locking flags and
        error reporting after mysql_lock_tables() in reopen_tables().
        Added lock handling and closing of a parent before the children
        in close_old_data_files().
        Added lock handling and detaching in drop_locked_tables().
        Added code for removing the children list from the statement list
        to prepare for a repetition in open_tables().
        Added new function open_n_lock_single_table(), which can be used
        as an replacement for open_ltable() in most situations. Internally
        it calls simple_open_n_lock_tables() so hat it is appropriate for
        MERGE tables.
        Disabled use of open_ltable() for MERGE tables.
        Removed function simple_open_n_lock_tables(). It is now inline
        declared in mysql_priv.h.
        Renamed open_and_lock_tables() to open_and_lock_tables_derived()
        with additional parameter 'derived'. open_and_lock_tables() is now
        inline declared in mysql_priv.h.
        Added a check for end-of-list in two loops in lock_tables().
        Added 'thd' argument to init_tmp_table_share().
      sql/sql_insert.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Changed from open_ltable() to open_n_lock_single_table() in
        handle_delayed_insert().
        Reestablished LEX settings after lex initialization.
        Added 'thd' argument to init_tmp_table_share().
      sql/sql_parse.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Made check_merge_table_access() a static function.
        Disabled use of CREATE...SELECT for MERGE tables.
      sql/sql_partition.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Fixed comment typo.
      sql/sql_select.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added 'thd' argument to init_tmp_table_share().
      sql/sql_table.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Optimized use of mysql_ha_flush() in mysql_rm_table_part2().
        Disabled the use of MERGE tables with prepare_for_restore() and
        prepare_for_repair().
        Changed from open_ltable() to open_n_lock_single_table() in
        mysql_alter_table() and mysql_checksum_table().
        Disabled change of child list under LOCK TABLES.
        Initialized table_list->table in mysql_recreate_table().
      sql/sql_trigger.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added code for allowing CREATE TRIGGER under LOCK TABLE, to be able
        to test it with MERGE tables.
      sql/table.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added 'thd' argument to init_tmp_table_share().
        Setting table_map_id from query_id in init_tmp_table_share().
        Added member function TABLE::is_children_attached().
      sql/table.h:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added access method get_table_def_version() to TABLE_SHARE.
        Added elements for MERGE tables to TABLE and TABLE_LIST.
      storage/myisam/ha_myisam.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added an unrelated comment to the function comment of table2myisam().
      storage/myisam/ha_myisam.h:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added new member function MI_INFO::file_ptr().
      storage/myisammrg/ha_myisammrg.cc:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added callback functions to support parent open and children attach
        of MERGE tables.
        Changed ha_myisammrg::open() to initialize storage engine structures
        and create a list of child tables only. Child tables are not opened.
        Added ha_myisammrg::attach_children(), which does now the main part
        of MERGE open.
        Added ha_myisammrg::detach_children().
        Added calls to ::attach_children() and ::detach_children() to
        ::extra() on HA_EXTRA_ATTACH_CHILDREN and HA_EXTRA_DETACH_CHILDREN
        respectively.
        Added a check for matching TEMPORARY type for children against
        parent.
        Added a check for table def version.
        Added support for thd->open_options to attach_children().
        Changed child path name generation for temporary tables so that
        it does nothing special for temporary tables.
      storage/myisammrg/ha_myisammrg.h:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added elements to class ha_myisammrg to support the new
        open approach.
        Changed empty destructor definition to a declaration.
        Implemented in ha_myisammrg.cc.
        Added declaration for methods attach_children() and
        detach_children().
        Added definition for method table_ptr() for use with
        callback functions.
      storage/myisammrg/myrg_close.c:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Added a check to avoid closing of MyISAM tables when the
        child tables are not attached.
        Added freeing of rec_per_key_part when the child tables
        are not attached.
      storage/myisammrg/myrg_extra.c:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        Some ::extra() functions and ::reset() can be called when
        children are detached.
      storage/myisammrg/myrg_open.c:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE
                    corrupts a MERGE table
        
        Kept old myrg_open() for MERGE use independent from MySQL.
        Removed an always true condition in myrg_open().
        Set children_attached for independent MERGE use in myrg_open().
        
        Added myrg_parent_open(), myrg_attach_children(), and
        myrg_detach_children() for the new MERGE table open approach.
      mysql-test/r/merge-big.result:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE corrupts a MERGE table
        New test result
      mysql-test/t/merge-big.test:
        Bug#26379 - Combination of FLUSH TABLE and REPAIR TABLE corrupts a MERGE table
        New test case
      c8450b27
  32. 05 Nov, 2007 1 commit
    • unknown's avatar
      Bug#31210 - INSERT DELAYED crashes server when used on · e5b2745e
      unknown authored
                  partitioned table
      
      Trying INSERT DELAYED on a partitioned table, that has not been
      used right before, crashes the server. When a table is used for
      select or update, it is kept open for some time. This period I
      mean with "right before".
      
      Information about partitioning of a table is stored in form of
      a string in the .frm file. Parsing of this string requires a
      correctly set up lexical analyzer (lex). The partitioning code
      uses a new temporary instance of a lex. But it does still refer
      to the previously active lex. The delayd insert thread does not
      initialize its lex though...
      
      Added initialization for thd->lex before open table in the delayed
      thread and at all other places where it is necessary to call
      lex_start() if all tables would be partitioned and need to parse
      the .frm file.
      
      
      mysql-test/r/partition_hash.result:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Added test result
      mysql-test/t/partition_hash.test:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Added test
      sql/event_scheduler.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/events.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/ha_ndbcluster_binlog.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/slave.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/sql_acl.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/sql_base.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Asserted that lex is initialized in open_table().
      sql/sql_connect.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/sql_insert.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Added initialization for thd->lex before open table.
      sql/sql_lex.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Added 'is_lex_started' to test if lex is initialized.
      sql/sql_lex.h:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Added 'is_lex_started' to test if lex is initialized.
      sql/sql_plugin.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/sql_servers.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/sql_udf.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      sql/table.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Asserted that lex is initialized in open_table_from_share().
      sql/tztime.cc:
        Bug#31210 - INSERT DELAYED crashes server when used on
                    partitioned table
        Initialized lex for later use in open_table().
      e5b2745e
  33. 01 Nov, 2007 1 commit
    • unknown's avatar
      Bug#30882 Dropping a temporary table inside a stored function may cause a server crash · 611dbd0b
      unknown authored
      If a stored function that contains a drop temporary table statement
      is invoked by a create temporary table of the same name may cause
      a server crash. The problem is that when dropping a table no check
      is done to ensure that table is not being used by some outer query
      (or outer statement), potentially leaving the outer query with a
      reference to a stale (freed) table.
      
      The solution is when dropping a temporary table, always check if
      the table is being used by some outer statement as a temporary
      table can be dropped inside stored procedures.
      
      The check is performed by looking at the TABLE::query_id value for
      temporary tables. To simplify this check and to solve a bug related
      to handling of temporary tables in prelocked mode, this patch changes
      the way in which this member is used to track the fact that table is
      used/unused. Now we ensure that TABLE::query_id is zero for unused
      temporary tables (which means that all temporary tables which were
      used by a statement should be marked as free for reuse after it's
      execution has been completed).
      
      
      mysql-test/include/handler.inc:
        Add test case for side effect of Bug#30882
      mysql-test/r/handler_innodb.result:
        Add test case result for side effect of Bug#30882
      mysql-test/r/handler_myisam.result:
        Add test case result for side effect of Bug#30882
      mysql-test/r/sp-error.result:
        Add test case result for Bug#30882
      mysql-test/t/sp-error.test:
        Add test case for Bug#30882
      sql/event_db_repository.cc:
        Update close_thread_tables call, no more default values.
      sql/mysql_priv.h:
        Remove implicit default parameters values of the close_thread_tables
        function as no callers are using it.
      sql/slave.cc:
        Update close_thread_tables call, no more default values
      sql/sp_head.cc:
        Update close_thread_tables call, no more default values
      sql/sql_base.cc:
        Changed the approach to distinguishing currently unused temporary tables.
        Now we ensure that such tables always have TABLE::query_id set to 0 and
        use this fact to perform checks during opening and dropping of temporary
        tables. This means that we have to call close_thread_tables() even for
        statements which use only temporary tables. To make this call cheaper,
        we re-factored close_thread_tables() to not take LOCK_open unless there
        are open base tables.
      sql/sql_handler.cc:
        Properly close temporary tables associated with a handler.
      sql/sql_insert.cc:
        close_temporary_table is now merged into drop_temporary_table.
      sql/sql_parse.cc:
        Now the condition doesn't cover all cases because close_thread_tables()
        must be called even for statements that use only temporary tables.
      sql/sql_table.cc:
        Use drop_temporary_table which perform checks to verify if
        the table is not being used. Error path problem is due to
        a handler tables issue and is going to be addressed in bug
        31397.
      sql/table.h:
        Rename previously unused clear_query_id and document the usage of
        query_id and open_by_handler.
      611dbd0b
  34. 30 Oct, 2007 2 commits
    • unknown's avatar
      Use an inline getter method (thd->is_error()) to query if there is an error · 24370012
      unknown authored
      in THD.
      In future the error may be stored elsewhere (not in net.report_error) and 
      it's important to start using an opaque getter to simplify merges.
      
      
      sql/filesort.cc:
        net.report_error -> is_error()
      sql/ha_ndbcluster_binlog.cc:
        net.report_error -> is_error()
      sql/item_func.cc:
        net.report_error -> is_error()
      sql/item_subselect.cc:
        net.report_error -> is_error()
      sql/set_var.cc:
        net.report_error -> is_error()
      sql/sp.cc:
        net.report_error -> is_error()
      sql/sp_head.cc:
        net.report_error -> is_error()
      sql/sql_base.cc:
        net.report_error -> is_error()
      sql/sql_class.cc:
        net.report_error -> is_error()
      sql/sql_class.h:
        net.report_error -> is_error()
      sql/sql_connect.cc:
        net.report_error -> is_error()
      sql/sql_delete.cc:
        net.report_error -> is_error()
      sql/sql_insert.cc:
        net.report_error -> is_error()
      sql/sql_parse.cc:
        net.report_error -> is_error()
      sql/sql_prepare.cc:
        net.report_error -> is_error()
      sql/sql_select.cc:
        net.report_error -> is_error()
      sql/sql_union.cc:
        net.report_error -> is_error()
      sql/sql_update.cc:
        net.report_error -> is_error()
      sql/sql_view.cc:
        net.report_error -> is_error()
      sql/sql_yacc.yy:
        net.report_error -> is_error()
      24370012
    • unknown's avatar
      Manual merge 5.0-rpl -> 5.1-rpl. · 356bdcb7
      unknown authored
      involved bug#12691, bug#27571
      
      
      mysql-test/suite/rpl/r/rpl_sp_effects.result:
        results changed
      sql/slave.cc:
        pended manual merge done (mats)
      sql/sql_delete.cc:
        manual merge
      sql/sql_insert.cc:
        manual merge
      sql/sql_load.cc:
        manual merge
      sql/sql_update.cc:
        manual merge.
      356bdcb7