An error occurred fetching the project authors.
  1. 05 May, 2009 1 commit
    • Martin Hansson's avatar
      Bug#43580: Issue with Innodb on multi-table update · 391364fa
      Martin Hansson authored
                              
      Certain multi-updates gave different results on InnoDB from
      to MyISAM, due to on-the-fly updates being used on the former and
      the update order matters.
      Fixed by turning off on-the-fly updates when update order 
      dependencies are present.
      
      
      mysql-test/r/innodb_mysql.result:
        Bug#43580: Test result.
      mysql-test/suite/rpl/r/rpl_slave_skip.result:
        Bug#43580: Changed test result. The InnoDB result is now what it would have been on MyISAM.
      mysql-test/t/innodb_mysql.test:
        Bug#43580: Test case.
      sql/sql_base.cc:
        Bug#43580: Added a word of caution about using tmp_set here.
      sql/sql_update.cc:
        Bug#43580: Fix.
        Calls to TABLE::mark_columns_needed_for_update() are moved
        from mysql_multi_update_prepare() and right before the decison
        to do on-the-fly updates to the place where we do (or don't do)
        on-the-fly updates.
      391364fa
  2. 04 May, 2009 1 commit
  3. 27 Mar, 2009 1 commit
    • 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
  4. 05 Mar, 2009 1 commit
  5. 05 Feb, 2009 1 commit
    • Gleb Shchepa's avatar
      Bug #39265: fix for the bug 33699 should be reverted · b9d02d46
      Gleb Shchepa authored
      Documented behaviour was broken by the patch for bug 33699
      that actually is not a bug.
      
      This fix reverts patch for bug 33699 and reverts the
      UPDATE of NOT NULL field with NULL query to old
      behavior.
      
      
      mysql-test/extra/rpl_tests/rpl_extraMaster_Col.test:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/include/ps_modify.inc:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/auto_increment.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/csv_not_null.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/null.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/ps_2myisam.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/ps_3innodb.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/ps_4heap.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/ps_5merge.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/r/warnings.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/suite/ndb/r/ps_7ndb.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/suite/rpl/r/rpl_extraColmaster_innodb.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/suite/rpl/r/rpl_extraColmaster_myisam.result:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/suite/rpl/t/rpl_err_ignoredtable.test:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/t/auto_increment.test:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/t/csv_not_null.test:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/t/null.test:
        Bug #39265: fix for the bug 33699 should be reverted
      mysql-test/t/warnings.test:
        Bug #39265: fix for the bug 33699 should be reverted
      sql/sql_update.cc:
        Bug #39265: fix for the bug 33699 should be reverted
      b9d02d46
  6. 28 Nov, 2008 1 commit
    • Gleb Shchepa's avatar
      Bug #40745: Error during WHERE clause calculation in UPDATE · d15cbc1a
      Gleb Shchepa authored
                  leads to an assertion failure
      
      Any run-time error in stored function (like recursive function
      call or update of table that is already updating by statement
      which invoked this stored function etc.) that was used in some
      expression of the single-table UPDATE statement caused an
      assertion failure.
      Multiple-table UPDATE (as well as INSERT and both single- and
      multiple-table DELETE) are not affected.
      
      
      mysql-test/r/update.result:
        Added test case for bug #40745.
      mysql-test/t/update.test:
        Added test case for bug #40745.
      sql/sql_update.cc:
        Bug #40745: Error during WHERE clause calculation in UPDATE
                    leads to an assertion failure
        
        The mysql_update function has been updated to take into account
        the status of invoked stored functions before setting the status
        of whole UPDATE query to OK.
      d15cbc1a
  7. 27 Nov, 2008 1 commit
    • Sergey Glukhov's avatar
      Bug#37460 Assertion failed: !table->file || table->file->inited == handler::NONE · 89d04406
      Sergey Glukhov authored
      enable uncacheable flag if we update a view with check option
      and check option has a subselect, otherwise, the check option
      can be evaluated after the subselect was freed as independent
      (See full_local in JOIN::join_free())
      
      
      mysql-test/r/subselect.result:
        test result
      mysql-test/t/subselect.test:
        test case
      sql/mysql_priv.h:
        added UNCACHEABLE_CHECKOPTION flag
      sql/sql_update.cc:
        enable uncacheable flag if we update a view with check option
        and check option has a subselect, otherwise, the check option
        can be evaluated after the subselect was freed as independent
        (See full_local in JOIN::join_free())
      89d04406
  8. 10 Nov, 2008 1 commit
  9. 09 Oct, 2008 1 commit
    • Gleb Shchepa's avatar
      Bug#38499: flush tables and multitable table update with · a83f5b18
      Gleb Shchepa authored
                 derived table cause crash
      
      When a multi-UPDATE command fails to lock some table, and
      subsequently succeeds, the tables need to be reopened if
      they were altered. But the reopening procedure failed for
      derived tables.
      
      Extra cleanup has been added.
      
      
      mysql-test/r/lock_multi.result:
        Added test case for bug #38499.
      mysql-test/t/lock_multi.test:
        Added test case for bug #38499.
      sql/sql_union.cc:
        Bug#38499: flush tables and multitable table update with
                   derived table cause crash
        
        Obsolete assertion has been removed.
      sql/sql_update.cc:
        Bug#38499: flush tables and multitable table update with
                   derived table cause crash
        
        Extra cleanup for derived tables has been added:
        1) unit.cleanup(),
        2) unit->reinit_exec_mechanism().
      a83f5b18
  10. 07 Oct, 2008 1 commit
    • Gleb Shchepa's avatar
      Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while · f48b42e7
      Gleb Shchepa authored
                ``FLUSH TABLES WITH READ LOCK''
      
      Concurrent execution of 1) multitable update with a
      NATURAL/USING join and 2) a such query as "FLUSH TABLES
      WITH READ LOCK" or "ALTER TABLE" of updating table led
      to a server crash.
      
      
      The mysql_multi_update_prepare() function call is optimized
      to lock updating tables only, so it postpones locking to
      the last, and if locking fails, it does cleanup of modified
      syntax structures and repeats a query analysis.  However,
      that cleanup procedure was incomplete for NATURAL/USING join
      syntax data: 1) some Field_item items pointed into freed
      table structures, and 2) the TABLE_LIST::join_columns fields
      was not reset.
      
      Major change:
        short-living Field *Natural_join_column::table_field has
        been replaced with long-living Item*.
      
      
      mysql-test/r/lock_multi.result:
        Added test case for bug #38691.
      mysql-test/t/lock_multi.test:
        Added test case for bug #38691.
      sql/item.cc:
        Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while
                  ``FLUSH TABLES WITH READ LOCK''
        
        The Item_field constructor has been modified to allocate
        and copy original database/table/field names always (not
        during PS preparation/1st execution only), because
        an initialization of Item_field items with a pointer to
        short-living Field structures is a common practice.
      sql/sql_base.cc:
        Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while
                  ``FLUSH TABLES WITH READ LOCK''
        
        1) Type adjustment for Natural_join_column::table_field
           (Field to Item_field);
        2) The setup_natural_join_row_types function has been
           updated to take into account new
           first_natural_join_processing flag to skip unnecessary
           reinitialization of Natural_join_column::join_columns
           during table reopening after lock_tables() failure
           (like the 'first_execution' flag for PS).
      sql/sql_lex.cc:
        Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while
                  ``FLUSH TABLES WITH READ LOCK''
        
        Initialization of the new
        st_select_lex::first_natural_join_processing flag has
        been added.
      sql/sql_lex.h:
        Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while
                  ``FLUSH TABLES WITH READ LOCK''
        
        The st_select_lex::first_natural_join_processing flag
        has been added to skip unnecessary rebuilding of
        NATURAL/USING JOIN structures during table reopening
        after lock_tables failure.
      sql/sql_update.cc:
        Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while
                  ``FLUSH TABLES WITH READ LOCK''
        
        Extra cleanup calls have been added to reset
        Natural_join_column::table_field items.
      sql/table.cc:
        Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while
                  ``FLUSH TABLES WITH READ LOCK''
        
        Type adjustment for Natural_join_column::table_field
        (Field to Item_field).
      sql/table.h:
        Bug #38691: segfault/abort in ``UPDATE ...JOIN'' while
                  ``FLUSH TABLES WITH READ LOCK''
        
        Type of the Natural_join_column::table_field field has
        been changed from Field that points into short-living
        TABLE memory to long-living Item_field that can be
        linked to (fixed) reopened table.
      f48b42e7
  11. 29 Sep, 2008 1 commit
    • Davi Arnaut's avatar
      Bug#34306: Can't make copy of log tables when server binary log is enabled · 0406d409
      Davi Arnaut authored
      The problem is that when statement-based replication was enabled,
      statements such as INSERT INTO .. SELECT FROM .. and CREATE TABLE
      .. SELECT FROM need to grab a read lock on the source table that
      does not permit concurrent inserts, which would in turn be denied
      if the source table is a log table because log tables can't be
      locked exclusively.
      
      The solution is to not take such a lock when the source table is
      a log table as it is unsafe to replicate log tables under statement
      based replication. Furthermore, the read lock that does not permits
      concurrent inserts is now only taken if statement-based replication
      is enabled and if the source table is not a log table.
      
      include/thr_lock.h:
        Introduce yet another lock type that my get upgraded depending
        on the binary log format. This is not a optimal solution but
        can be easily improved later.
      mysql-test/r/log_tables.result:
        Add test case result for Bug#34306
      mysql-test/suite/binlog/r/binlog_stm_row.result:
        Add test case result for Bug#34306
      mysql-test/suite/binlog/t/binlog_stm_row.test:
        Add test case for Bug#34306
      mysql-test/t/log_tables.test:
        Add test case for Bug#34306
      sql/lock.cc:
        Assert that TL_READ_DEFAULT is not a real lock type.
      sql/mysql_priv.h:
        Export new function.
      sql/mysqld.cc:
        Remove using_update_log.
      sql/sql_base.cc:
        Introduce function that returns the appropriate read lock type
        depending on how the statement is going to be replicated. It will
        only take a TL_READ_NO_INSERT log if the binary is enabled and the
        binary log format is statement-based and the table is not a log table.
      sql/sql_parse.cc:
        Remove using_update_log.
      sql/sql_update.cc:
        Use new function to choose read lock type.
      sql/sql_yacc.yy:
        The lock type is now decided at open_tables time. This old behavior was
        actually misleading as the binary log format can be dynamically switched
        and this would not change for statements that have already been parsed
        when the binary log format is changed (ie: prepared statements).
      0406d409
  12. 26 Aug, 2008 1 commit
  13. 31 Jul, 2008 1 commit
    • He Zhenxing's avatar
      BUG#37051 Replication rules not evaluated correctly · a018e98c
      He Zhenxing authored
      The problem of this bug is that we need to get the list of tables
      to be updated for a multi-table update statement, which requires to
      open all the tables referenced by the statement and resolve all
      the fields involved in update in order to figure out the list of
      tables for update. However if there are replicate filter rules,
      some tables might not exist on slave and result in a failure
      before we could examine the filter rules.
      
      I think the whole problem can not be solved on slave alone,
      the master must record and send the information of tables
      involved for update to slave, so that the slave do not need to
      open all the tables referenced by the multi-table update statement to
      figure out which tables are involved for update.
      
      So a status variable is added to Query_log event to store the
      value of table map for update on master. And on slave, it will
      try to get the value of this variable and use it to examine
      filter rules without opening any tables on slave, if this values
      is not available, the old approach is used and thus the bug will
      still occur for when replicating from old masters.
      
      
      sql/sql_class.h:
        add member table_map_for_update to THD
      sql/sql_parse.cc:
        check filter rules by using table_map_for_update value
      sql/sql_update.cc:
        save the value of table_map_for_update
      a018e98c
  14. 15 Jul, 2008 1 commit
    • Sergey Petrunia's avatar
      BUG#35478: sort_union() returns bad data when sort_buffer_size is hit · 62513bb1
      Sergey Petrunia authored
      - In QUICK_INDEX_MERGE_SELECT::read_keys_and_merge: when we got table->sort from Unique,
        tell init_read_record() not to use rr_from_cache() because a) rowids are already sorted
        and b) it might be that the the data is used by filesort(), which will need record rowids
        (which rr_from_cache() cannot provide).
      - Fully de-initialize the table->sort read in QUICK_INDEX_MERGE_SELECT::get_next(). This fixes BUG#35477.
      (bk trigger: file as fix for BUG#35478).
      
      sql/filesort.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - make find_all_keys() use quick->get_next() instead of init_read_record(r)/r.read_record() calls
        - added dbug printout
      sql/mysql_priv.h:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/opt_range.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - In QUICK_INDEX_MERGE_SELECT::read_keys_and_merge: when we got table->sort from Unique,
          tell init_read_record() not to use rr_from_cache() because a) rowids are already sorted
          and b) it might be that the the data is used by filesort(), which will need record rowids
          (which rr_from_cache() cannot provide).
        - Fully de-initialize the table->sort read in QUICK_INDEX_MERGE_SELECT::get_next().
      sql/records.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added disable_rr_cache parameter to init_read_record
        - Added comment
      sql/sql_acl.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_delete.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_help.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_select.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_table.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_udf.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      sql/sql_update.cc:
        BUG#35478: sort_union() returns bad data when sort_buffer_size is hit
        - Added parameter to init_read_record
      62513bb1
  15. 18 May, 2008 1 commit
    • unknown's avatar
      Fixed bug#36676: multiupdate using LEFT JOIN updates only · 29e7fa25
      unknown authored
                       first row or fails with an error:
        ERROR 1022 (23000): Can't write; duplicate key in table ''
      
      The server uses intermediate temporary table to store updated
      row data.  The first column of this table contains rowid.
      Current server implementation doesn't reset NULL flag of that
      column even if the server fills a column with rowid.
      To keep each rowid unique, there is an unique index.
      An insertion into an unique index takes into account NULL
      flag of key value and ignores real data if NULL flag is set.
      So, insertion of actually different rowids may lead to two
      kind of problems.  Visible effect of each of these problems
      depends on an initial engine type of temporary table:
      
      1. If multiupdate initially creates temporary table as
      a MyISAM table (a table contains blob columns, and the
      create_tmp_table function assumes, that this table is
      large), it inserts only one single row and updates
      only rows with one corresponding rowid. Other rows are
      silently ignored. 
      
      2. If multiupdate initially creates MEMORY temporary
      table, fills it with data and reaches size limit for
      MEMORY tables (max_heap_table_size), multiupdate
      converts MEMORY table into MyISAM table and fails
      with an error:
        ERROR 1022 (23000): Can't write; duplicate key in table ''
      
      
      Multiupdate has been fixed to update the NULL flag of
      temporary table rowid columns.
      
      
      
      mysql-test/r/multi_update_tiny_hash.result:
        Added test case for bug#36676.
      mysql-test/t/multi_update_tiny_hash-master.opt:
        Added test case for bug#36676.
      mysql-test/t/multi_update_tiny_hash.test:
        Added test case for bug#36676.
      sql/sql_update.cc:
        Fixed bug#36676: multiupdate using LEFT JOIN updates only
                         first row or fails with an error:
          ERROR 1022 (23000): Can't write; duplicate key in table ''
        
        The multi_update::send_data method has been modified to reset null bits of
        fields containing rowids.
      29e7fa25
  16. 07 Apr, 2008 1 commit
  17. 01 Apr, 2008 1 commit
  18. 21 Mar, 2008 1 commit
    • unknown's avatar
      Bug #26461: Intrinsic data type bool (1 byte) redefined to BOOL (4 bytes) · cebb6727
      unknown authored
      The bool data type was redefined to BOOL (4 bytes on windows).
      Removed the #define and fixed some of the warnings that were uncovered
      by this.
      Note that the fix also disables 2 warnings :
      4800 : 'type' : forcing value to bool 'true' or 'false' (performance warning)
      4805: 'operation' : unsafe mix of type 'type' and type 'type' in operation
      
      These warnings will be handled in a separate bug, as they are performance related or bogus.
      
      Fixed to int the return type of functions that return more than 
      2 distinct values.
      
      
      CMakeLists.txt:
        Bug #26461: disable the C4800 and C4805 warnings temporarily
      include/config-win.h:
        Bug #26461: 
         - no need for this define for Windows.
         - windows C++ compilers have a bool type
      include/my_global.h:
        Bug #26461: removed bool_defined (no longer needed)
      sql/handler.h:
        Bug #26461: bool functions must return boolean values
      sql/mysql_priv.h:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/procedure.h:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_acl.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_acl.h:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_analyse.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_analyse.h:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_base.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_db.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_delete.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_load.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_parse.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_prepare.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      sql/sql_update.cc:
        Bug #26461: fixed return type of functions that return more than
        2 distinct values.
      cebb6727
  19. 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
  20. 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
  21. 14 Feb, 2008 1 commit
  22. 12 Feb, 2008 1 commit
    • unknown's avatar
      Bug#23771 AFTER UPDATE trigger not invoked when there are no changes of the data · 8d51c6ad
      unknown authored
      The problem is that AFTER UPDATE triggers will fire only if the
      new data is different from the old data on the row. The trigger
      should fire regardless of whether there are changes to the data.
      
      The solution is to fire the trigger on UPDATE even if there are
      no changes to the value (because the value is the same).
      
      
      mysql-test/r/trigger.result:
        Add test case result for Bug#23771
      mysql-test/t/trigger.test:
        Add test case for Bug#23771
      sql/sql_update.cc:
        Move the invocation of the after update trigger so that
        the trigger will fire even if the records are the same.
      8d51c6ad
  23. 04 Feb, 2008 1 commit
    • unknown's avatar
      Bug#33329 extraneous ROLLBACK in binlog on connection · 62102786
      unknown authored
                  does not use trans tables
      
      There had been two issues.
      Rollback statement was recorded in binlog even though a multi-update
      had not modified any non-transactional table.
      The reason for this artifact was a false initial value of multi_update::transactional_tables.
      Yet another artifact that explained on the bug page is that 
      `ha_autocommit_or_rollback' works differently depending on whether
      a transaction engine has been compiled in. 
      
      Fixed: with setting multi_update::transactional_tables to zero at initialization
      time. Multi-update on non-trans table won't cause ROLLBACK in binlog with
      either compilation option.
      
      The 2nd mentioned artifact comprises a self-standing issue (to be reported
      separately).
      
      
      mysql-test/r/multi_update.result:
        results changed - there is no ROLLBACK in binlog anymore as it should be
      sql/sql_update.cc:
        A wrong assumption on that there were modified transactional table,
        which is nonsense at the very beginning of the query execution.
      62102786
  24. 11 Jan, 2008 1 commit
    • unknown's avatar
      Bug#33699: The UPDATE statement allows NULL as new value on a NOT NULL · a114ede2
      unknown authored
      columns (default datatype value is assigned).
      
      The mysql_update function has been modified to generate
      an error when trying to set a NOT NULL field to NULL rather than a warning
      in the set_field_to_null_with_conversions function.
      
      
      
      mysql-test/extra/rpl_tests/rpl_extraMaster_Col.test:
        Updated test case (for bug#33699).
      mysql-test/include/ps_modify.inc:
        Updated test case (for bug#33699).
      mysql-test/r/auto_increment.result:
        Updated test case (for bug#33699).
      mysql-test/r/null.result:
        Updated test case (for bug#33699).
      mysql-test/r/ps_2myisam.result:
        Updated test case (for bug#33699).
      mysql-test/r/ps_3innodb.result:
        Updated test case (for bug#33699).
      mysql-test/r/ps_4heap.result:
        Updated test case (for bug#33699).
      mysql-test/r/ps_5merge.result:
        Updated test case (for bug#33699).
      mysql-test/r/warnings.result:
        Updated test case (for bug#33699).
      mysql-test/suite/ndb/r/ps_7ndb.result:
        Updated test case (for bug#33699).
      mysql-test/suite/rpl/r/rpl_extraColmaster_innodb.result:
        Updated test case (for bug#33699).
      mysql-test/suite/rpl/r/rpl_extraColmaster_myisam.result:
        Updated test case (for bug#33699).
      mysql-test/suite/rpl/t/rpl_err_ignoredtable.test:
        Updated test case (for bug#33699).
      mysql-test/t/auto_increment.test:
        Updated test case (for bug#33699).
      mysql-test/t/null.test:
        Updated test case (for bug#33699).
      mysql-test/t/warnings.test:
        Updated test case (for bug#33699).
      sql/sql_update.cc:
        Bug#33699: The mysql_update function has been modified to generate
        an error when trying to set a NOT NULL field to NULL rather than
        a warning in the set_field_to_null_with_conversions function.
      tests/mysql_client_test.c:
        Updated test case (for bug#33699).
      a114ede2
  25. 20 Dec, 2007 1 commit
    • unknown's avatar
      A pre-requisite for the fix for Bug#12713 "Error in a stored function · 0fbc29c1
      unknown authored
      called from a SELECT doesn't cause ROLLBACK of state"
      Make private all class handler methods (PSEA API) that may modify
      data. Introduce and deploy public ha_* wrappers for these methods in 
      all sql/.
      This necessary to keep track of all data modifications in sql/,
      which is in turn necessary to be able to optimize two-phase
      commit of those transactions that do not modify data.
      
      
      sql/ha_partition.cc:
        Class ha_partition is no longer a friend of class handler.
        Use the public handler interface (handler::ha_ methods) for partition
        operations.
        Remove unnecessary casts from char[] to const char *.ppзи выафвыаafa
      sql/handler.cc:
        Function ha_create_table() is no longer a friend of class handler.
        Use public handler::change_table_ptr() to access private members.
        This fixes a subtle bug (no test case in the test suite) when a
        deletion error occurs inside one partition of a partitioned engine. 
        The old code would crash in handler::print_error() in this case.
        
        Implement the newly introduced public ha_* wrappers of the private
        virtual handler methods.
      sql/handler.h:
        Introduce ha_* wrappers to all class handler methods that may
        modify data. This is necessary to be able to keep track of
        data modifying operations of class handler and optimize read-only
        transactions.
      sql/item_sum.cc:
        delete_all_rows -> ha_delete_all_rows
      sql/sql_base.cc:
        Use the new public wrappers.
      sql/sql_delete.cc:
        delete_all_rows -> ha_delete_all_rows
      sql/sql_partition.cc:
        Use the new public wrappers.
      sql/sql_select.cc:
        delete_all_rows -> ha_delete_all_rows
        delete_table -> ha_delete_table
        disabe_indexes -> ha_disable_idnexes
      sql/sql_show.cc:
        delete_all_rows -> ha_delete_all_rows
      sql/sql_table.cc:
        Use the public wrappers for class handler DDL methods.
        All methods which may change handler data are now accessed via a public
        wrapper.
      sql/sql_union.cc:
        delete_all_rows -> ha_delete_all_rows
        {enable,disable}_indexes -> ha_{enable,disable}_indexes
      sql/sql_update.cc:
        bulk_update_row -> ha_bulk_update_row
      sql/unireg.cc:
        create_handler_files -> ha_create_handler_files
      0fbc29c1
  26. 13 Dec, 2007 1 commit
  27. 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
  28. 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
  29. 29 Oct, 2007 1 commit
    • unknown's avatar
      Bug #27571 asynchronousity in setting mysql_`query`::error and · 95f3db7b
      unknown authored
                 Query_log_event::error_code
      
      A query can perform completely having the local var error of mysql_$query
      zero, where $query in insert, update, delete, load,
      and be  binlogged with error_code e.g KILLED_QUERY while there is no
      reason do to so.
      That can happen because Query_log_event consults thd->killed flag to
      evaluate error_code.
      
      Fixed with implementing a scheme suggested and partly implemented at
      time of bug@22725 work-on. error_status is cached immediatly after the
      control leaves the main rows-loop and that instance always corresponds
      to `error' the local of mysql_$query functions. The cached value
      is passed to Query_log_event constructor, not the default thd->killed
      which can be changed in between of the caching and the constructing.
      
      
      mysql-test/r/binlog_killed.result:
        results changed
      mysql-test/t/binlog_killed.test:
        Demonstrating that effective killing during rows-loop execution leads to the speficied actions:
        binlogging with the error for a query modified a not-transactional table or
        rolling back effects for transactional table;
        
        fixing possible non-determinism with ID when query_log_enabled;
        
        leave commented out tests for multi-update,delete due to another bug;
        
        removing an obsolete tests template;
        
        changing system rm to --remove_file.
      sql/log_event.cc:
        adding killed status arg
      sql/log_event.h:
        added killed status arg
      sql/sql_delete.cc:
        deploying the update part patch for delete, multi-delete
      sql/sql_insert.cc:
        deploying the update-part patch for insert..select
      sql/sql_load.cc:
        deploying the update-part patch for load data.
        simulation added.
      sql/sql_update.cc:
        Impementing the fix as described in the comments left by bug@22725.
        Also simulation of killing after the loop that would affect binlogging in the old code.
      mysql-test/t/binlog_killed_bug27571-master.opt:
        post rows-loop killing simulation's options
      mysql-test/t/binlog_killed_bug27571.test:
        Checking that if killing happens inbetween of the end of rows loop and
        recording into binlog that will not lead to recording any error incl
        the killed error.
      mysql-test/t/binlog_killed_simulate-master.opt:
        simulation options
      mysql-test/t/binlog_killed_simulate.test:
        tests for 
        a query (update is choosen) being killed after the row-loop;
        load data killed within the loop - effective killed error in the event is gained.
      95f3db7b
  30. 26 Oct, 2007 1 commit
  31. 23 Oct, 2007 1 commit
    • unknown's avatar
      type conversions fixed to avoid warnings on Windows · e1dc86b0
      unknown authored
      myisam/mi_write.c:
        type conversion fixed
      myisam/sort.c:
        type conversion fixed
      sql/ha_federated.cc:
        type conversion fixed
      sql/ha_heap.cc:
        type conversion fixed
      sql/ha_innodb.cc:
        type conversion fixed
      sql/ha_myisam.cc:
        type conversion fixed
      sql/opt_range.cc:
        type conversion fixed
      sql/sql_map.cc:
        type conversion fixed
      sql/sql_select.cc:
        type conversion fixed
      sql/sql_update.cc:
        type conversion fixed
      e1dc86b0
  32. 16 Oct, 2007 1 commit
  33. 13 Oct, 2007 1 commit
    • unknown's avatar
      Bug #29136 erred multi-delete on trans table does not rollback the statement · c8b6d105
      unknown authored
      similar to bug_27716, but it was stressed on in the synopsis on that there is another
      side of the artifact affecting behaviour in transaction.
      
      Fixed with deploying multi_delete::send_error() - otherwise never called - and refining its logic
      to perform binlogging job if needed.
      
      The changeset includes the following side effects:
      - added tests to check bug_23333's scenarios on the mixture of tables for multi_update;
      - fixes bug@30763 with two-liner patch and a test coinciding to one added for bug_23333.
      
      
      mysql-test/r/innodb.result:
        results changed
      mysql-test/r/mix_innodb_myisam_binlog.result:
        results changed
      mysql-test/r/multi_update.result:
        results changed
      mysql-test/t/innodb.test:
        trans table specific test added
      mysql-test/t/mix_innodb_myisam_binlog.test:
        multi-update  and multi-delete of mixure of ta and not-ta tables tests added (relates to bug_23333).
      mysql-test/t/multi_update.test:
        testing another branch of mult-delete: send_eof() (binloggin there), send_error (early return)
      sql/sql_class.h:
        a new flag to designate the fact the statement's error has been handled.
        The flag is checked by ::send_error() methods (multi_update and _delete classes)
      sql/sql_delete.cc:
        expanding multi_delete::send_error to 
        1. early return if error_handled == t
        2. binlogging locally if there was a non-trans table modified side effect
      sql/sql_parse.cc:
        adding multi_update::send_error which can perform binlogging and rollback job in needed
      sql/sql_update.cc:
        issues relating to
         
        1. bug_27716 with zeroing of `updated' to serve as the flag of early return from send_error().
           The flag is changed to be a new member error_handled; also moved outside binlogging branch.
           The reason for this change is that bug_23333 fixes were pushed after the bug_27716's and they
           left this flaw (also no test coverage).
        2. bug_30763 with assertion on trans_safe. I decide to make 2 liner fix for that bug here instead of to remove
           those two assertions. This new bug test case is the same as for multi-update on the mixure of tables.
           The rational for this fix:
           presumption for mutli_update::trans_safe to be set to zero at
           multi_update::multi_update or multi_update::initialize_tables() is incorrect.
        
           trans_safe := false should happen only when a non-transactional table gets modified. 
           Therefore, at initialization the member must be be set to true.
      c8b6d105
  34. 21 Sep, 2007 1 commit
  35. 21 Aug, 2007 1 commit
    • unknown's avatar
      Bug #23333 stored function + non-transac table + transac table = breaks stmt-based binlog · a0849011
      unknown authored
      Binlogging of the statement with a side effect like a modified non-trans table did not happen.
      The artifact involved all binloggable dml queries.
      
      Fixed with changing the binlogging conditions all over the code to exploit thd->transaction.stmt.modified_non_trans_table
      introduced by the patch for bug@27417.
      
      Multi-delete case has own specific addressed by another bug@29136. Multi-update case has been addressed by bug#27716 and
      patch and will need merging.
      
      
      mysql-test/r/mix_innodb_myisam_binlog.result:
        results changed
      mysql-test/r/sp_trans_log.result:
        results changed
      mysql-test/t/mix_innodb_myisam_binlog.test:
        specific to the bug tests added
      mysql-test/t/sp_trans_log.test:
        refining of the proof of that there is an event in binlog
      sql/sql_delete.cc:
        deploying the binlogging check with thd->transaction.stmt.modified_non_trans_table
      sql/sql_insert.cc:
        binlogging when thd->transaction.stmt.modified_non_trans_table is TRUE. Merge with Bug#29571.
      sql/sql_load.cc:
        binlogging when thd->transaction.stmt.modified_non_trans_table is true
      sql/sql_update.cc:
        binlogging when thd->transaction.stmt.modified_non_trans_table is true
      a0849011
  36. 15 Aug, 2007 1 commit
    • unknown's avatar
      Fix doxygen warnings. · c514373c
      unknown authored
      client/mysqldump.c:
        Fix doxygen warnings
      mysys/test_charset.c:
        Fix doxygen warnings
      sql/event_db_repository.cc:
        Fix doxygen warnings
      sql/events.cc:
        Fix doxygen warnings
      sql/events.h:
        Fix doxygen warnings
      sql/item_create.cc:
        Fix doxygen warnings, style.
      sql/item_create.h:
        Fix coding style.
      sql/item_subselect.cc:
        Fix doxygen warnings
      sql/lock.cc:
        Fix doxygen warnings
      sql/sp.cc:
        Fix doxygen warnings
      sql/sp_head.h:
        Fix doxygen warnings
      sql/sql_analyse.cc:
        Fix doxygen warnings
      sql/sql_analyse.h:
        Fix doxygen warnings
      sql/sql_base.cc:
        Fix doxygen warnings
      sql/sql_db.cc:
        Fix doxygen warnings
      sql/sql_lex.cc:
        Fix doxygen warnings
      sql/sql_lex.h:
        Fix doxygen warnings
      sql/sql_parse.cc:
        Fix doxygen warnings
      sql/sql_plugin.cc:
        Fix doxygen warnings
      sql/sql_prepare.cc:
        Fix doxygen warnings
      sql/sql_show.cc:
        Fix doxygen warnings
      sql/sql_trigger.cc:
        Fix doxygen warnings
      sql/sql_update.cc:
        Fix doxygen warnings
      sql/table.h:
        Fix doxygen warnings
      c514373c
  37. 31 Jul, 2007 1 commit
  38. 30 Jul, 2007 1 commit
    • unknown's avatar
      (pushing for Andrei) · 1307d3b8
      unknown authored
      Bug #27417 thd->no_trans_update.stmt lost value inside of SF-exec-stack
        
      Once had been set the flag might later got reset inside of a stored routine 
      execution stack.
      The reason was in that there was no check if a new statement started at time 
      of resetting.
      The artifact affects most of binlogable DML queries. Notice, that multi-update 
      is wrapped up within
        bug@27716 fix, multi-delete bug@29136.
        
      Fixed with saving parent's statement flag of whether the statement modified 
      non-transactional table, and unioning (merging) the value with that was gained 
      in mysql_execute_command.
        
      Resettling thd->no_trans_update members into thd->transaction.`member`;
      Asserting code;
      Effectively the following properties are held.
        
      1. At the end of a substatement thd->transaction.stmt.modified_non_trans_table
         reflects the fact if such a table got modified by the substatement.
         That also respects THD::really_abort_on_warnin() requirements.
      2. Eventually thd->transaction.stmt.modified_non_trans_table will be computed as
         the union of the values of all invoked sub-statements.
         That fixes this bug#27417;
      
      Computing of thd->transaction.all.modified_non_trans_table is refined to base to 
      the stmt's value for all the case including insert .. select statement which 
      before the patch had an extra issue bug@28960.
      Minor issues are covered with mysql_load, mysql_delete, and binloggin of insert in
      to temp_table select. 
        
      The supplied test verifies limitely, mostly asserts. The ultimate testing is defered
      for bug@13270, bug@23333.
      
      
      mysql-test/r/mix_innodb_myisam_binlog.result:
        results changed
      mysql-test/t/mix_innodb_myisam_binlog.test:
        regression test incl the related bug#28960.
      sql/ha_ndbcluster.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/handler.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/handler.h:
        new member added
      sql/log.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/set_var.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sp_head.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
        
        and saving and merging stmt's flag at the end of a substatement.
      sql/sql_class.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_class.h:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_delete.cc:
        correcting basic delete incl truncate branch and multi-delete queries to set
        stmt.modified_non_trans_table;
        optimization to set the flag at the end of per-row loop;
        multi-delete still has an extra issue similar to bug#27716 of multi-update 
        - to be address with bug_29136 fix.
      sql/sql_insert.cc:
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_load.cc:
        eliminating a separate issue where the stmt flag was saved and re-stored after 
        write_record that actually could change it and the change would be lost but 
        should remain permanent;
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      sql/sql_parse.cc:
        initialization to transaction.stmt.modified_non_trans_table at the common part 
        of all types of statements processing - mysql_execute_command().
      sql/sql_table.cc:
        moving the reset up to the mysql_execute_command() caller
      sql/sql_update.cc:
        correcting update query case (multi-update part of the issues covered by other 
        bug#27716 fix)
        thd->transaction.{all,stmt}.modified_non_trans_table
        instead of
        thd->no_trans_update.{all,stmt}
      1307d3b8