An error occurred fetching the project authors.
  1. 07 Dec, 2010 1 commit
    • Luis Soares's avatar
      BUG#46166 · 376b2fa5
      Luis Soares authored
      Post merge fix. In write_incident, check if binlog file is
      opened before actually trying to write the incident event.
      376b2fa5
  2. 30 Nov, 2010 2 commits
    • Luis Soares's avatar
      BUG#46166: MYSQL_BIN_LOG::new_file_impl is not propagating error · 1f5dc357
      Luis Soares authored
                 when generating new name.
            
      If find_uniq_filename returns an error, then this error is not
      being propagated upwards, and execution does not report error to
      the user (although a entry in the error log is generated).
                        
      Additionally, some more errors were ignored in new_file_impl:
      - when writing the rotate event
      - when reopening the index and binary log file
                        
      This patch addresses this by propagating the error up in the
      execution stack. Furthermore, when rotation of the binary log
      fails, an incident event is written, because there may be a
      chance that some changes for a given statement, were not properly
      logged. For example, in SBR, LOAD DATA INFILE statement requires
      more than one event to be logged, should rotation fail while
      logging part of the LOAD DATA events, then the logged data would
      become inconsistent with the data in the storage engine.
      
      mysql-test/include/restart_mysqld.inc:
        Refactored restart_mysqld so that it is not hardcoded for
        mysqld.1, but rather for the current server.
      mysql-test/suite/binlog/t/binlog_index.test:
        The error on open of index and binary log on new_file_impl 
        is now caught. Thence the user will get an error message. 
        We need to accomodate this change in the test case for the
        failing FLUSH LOGS.
      mysql-test/suite/rpl/t/rpl_binlog_errors-master.opt:
        Sets max_binlog_size to 4096.
      mysql-test/suite/rpl/t/rpl_binlog_errors.test:
        Added some test cases for asserting that the error is found 
        and reported.
      sql/handler.cc:
        Catching error now returned by unlog (in ha_commit_trans) and 
        returning it.
      sql/log.cc:
        Propagating errors from new_file_impl upwards. The errors that
        new_file_impl catches now are:
        - error on generate_new_name
        - error on writing the rotate event
        - error when opening the index or the binary log file.
      sql/log.h:
        Changing declaration of:
        - rotate_and_purge
        - new_file
        - new_file_without_locking
        - new_file_impl
        - unlog
        They now return int instead of void.
      sql/mysql_priv.h:
        Change signature of reload_acl_and_cache so that write_to_binlog
        is an int instead of bool.
      sql/mysqld.cc:
        Redeclaring not_used var as int instead of bool.
      sql/rpl_injector.cc:
        Changes to catch the return from rotate_and_purge.
      sql/slave.cc:
        Changes to catch the return values for new_file and rotate_relay_log.
      sql/slave.h:
        Changes to rotate_relay_log declaration (now returns int 
        instead of void).
      sql/sql_load.cc:
        In SBR, some logging of LOAD DATA events goes through
        IO_CACHE_CALLBACK invocation at mf_iocache.c:_my_b_get. The
        IO_CACHE implementation is ignoring the return value for from
        these callbacks (pre_read and post_read), so we need to find out
        at the end of the execution if the error is set or not in THD.
      sql/sql_parse.cc:
        Catching the rotate_relay_log and rotate_and_purge return values.
        Semantic change in reload_acl_and_cache so that we report errors
        in binlog interactions through the write_to_binlog output parameter.
        If there was any failure while rotating the binary log, we should
        then report the error to the client when handling SQLCOMM_FLUSH.
      1f5dc357
    • Luis Soares's avatar
      BUG#57288: binlog_tmp_table fails sporadically: "Failed to write · 594787cf
      Luis Soares authored
      the DROP statement ..."
            
      Problem: When using temporary tables and closing a session, an
      implicit DROP TEMPORARY TABLE IF EXISTS is written to the binary
      log (while cleaning up the context of the session THD - see:
      sql_class.cc:THD::cleanup which calls close_temporary_tables).
           
      close_temporary_tables, first checks if the binary log is opened
      and then proceeds to creating the DROP statements. Then, such
      statements, are written to the binary log through
      MYSQL_BIN_LOG::write(Log_event *). Inside, there is another check
      if the binary log is opened and if not an error is returned. This
      is where the faulty behavior is triggered. Given that the test
      case replays a binary log, with temp tables statements, and right
      after it issues RESET MASTER, there is a chance that is_open will
      report false (when the mysql session is closed and the temporary
      tables are written).
            
      is_open may return false, because MYSQL_BIN_LOG::reset_logs is
      not setting the correct flag (LOG_CLOSE_TO_BE_OPENED), on the
      MYSQL_LOG_BIN::log_state (instead it sets just the
      LOG_CLOSE_INDEX flag, leaving the log_state to
      LOG_CLOSED). Thence, when writing the DROP statement as part of
      the THD::cleanup, the thread could get a return value of false
      for is_open - inside MYSQL_BIN_LOG::write, ultimately reporting
      that it can't write the event to the binary log.
            
      Fix: We fix this by adding the correct flag, missing in the
      second close.
      594787cf
  3. 20 Oct, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#45288: pb2 returns a lot of compilation warnings · 031c5d92
      Davi Arnaut authored
      Fix assorted warnings that are generated in optimized builds.
      Most of it is silencing variables that are set but unused.
      
      This patch also introduces the MY_ASSERT_UNREACHABLE macro
      which helps the compiler to deduce that a certain piece of
      code is unreachable.
      
      include/my_compiler.h:
        Use GCC's __builtin_unreachable if available. It allows
        GCC to deduce the unreachability of certain code paths,
        thus avoiding warnings that, for example, accused that a
        variable could be used without being initialized (due to
        unreachable code paths).
      031c5d92
  4. 18 Oct, 2010 1 commit
  5. 22 Sep, 2010 1 commit
  6. 02 Sep, 2010 1 commit
  7. 25 Aug, 2010 1 commit
    • Dmitry Shulga's avatar
      Fixed bug #29751 - do not rename the error log at FLUSH LOGS. · 3be32c12
      Dmitry Shulga authored
      Added open log file with FILE_SHARE_DELETE flag on Windows.
      
      sql/log.cc:
        added reopen_fstreams();
        modified redirect_std_streams(): call to sequence of freopen()
        replaced to reopen_fstreams();
        modified flush_error_log(): removed file rename for flushed
        error log file.
      sql/mysqld.cc:
        modified main() and init_server_components(): do open log error file
        over call to reopen_fstreams().
      3be32c12
  8. 02 Aug, 2010 1 commit
    • Alfranio Correia's avatar
      BUG#55625 RBR breaks on failing 'CREATE TABLE' · a94f5b60
      Alfranio Correia authored
      A CREATE...SELECT that fails is written to the binary log if a non-transactional
      statement is updated. If the logging format is ROW, the CREATE statement and the
      changes are written to the binary log as distinct events and by consequence the
      created table is not rolled back in the slave.
      
      In this patch, we opted to let the slave goes out of sync by not writting to the
      binary log the CREATE statement. We do this by simply reseting the binary log's
      cache.
      
      mysql-test/suite/rpl/r/rpl_drop.result:
        Added a test case.
      mysql-test/suite/rpl/t/rpl_drop.test:
        Added a test case.
      sql/log.cc:
        Introduced a function to clean up the cache.
      sql/log.h:
        Introduced a function to clean up the cache.
      sql/sql_insert.cc:
        Cleaned up the binary log cache if a CREATE...SELECT fails.
      a94f5b60
  9. 20 Jul, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#45288: pb2 returns a lot of compilation warnings on linux · 450d34b7
      Davi Arnaut authored
      Fix warnings flagged by the new warning option -Wunused-but-set-variable
      that was added to GCC 4.6 and that is enabled by -Wunused and -Wall. The
      option causes a warning whenever a local variable is assigned to but is
      later unused. It also warns about meaningless pointer dereferences.
      
      client/mysql.cc:
        Meaningless pointer dereferences.
      client/mysql_upgrade.c:
        Check whether reading from the file succeeded.
      extra/comp_err.c:
        Unused.
      extra/yassl/src/yassl_imp.cpp:
        Skip instead of reading data that is discarded.
      include/my_pthread.h:
        Variable is only used in debug builds.
      include/mysys_err.h:
        Add new error messages.
      mysys/errors.c:
        Add new error message for permission related functions.
      mysys/mf_iocache.c:
        Variable is only checked under THREAD.
      mysys/my_copy.c:
        Raise a error if chmod or chown fails.
      mysys/my_redel.c:
        Raise a error if chmod or chown fails.
      regex/engine.c:
        Use a equivalent variable for the assert.
      server-tools/instance-manager/instance_options.cc:
        Unused.
      sql/field.cc:
        Unused.
      sql/item.cc:
        Unused.
      sql/log.cc:
        Do not ignore the return value of freopen: only set buffer if
        reopening succeeds.
        
        Adjust doxygen comment to the right function.
        
        Pass message lenght to log function.
      sql/mysqld.cc:
        Do not ignore the return value of freopen: only set buffer if
        reopening succeeds.
      sql/partition_info.cc:
        Unused.
      sql/slave.cc:
        No need to set pointer to the address of '\0'.
      sql/spatial.cc:
        Unused. Left for historical purposes.
      sql/sql_acl.cc:
        Unused.
      sql/sql_base.cc:
        Pointers are always set to the same variables.
      sql/sql_parse.cc:
        End statement if reading fails.
        
        Store the buffer after it has actually been updated.
      sql/sql_repl.cc:
        No need to set pointer to the address of '\0'.
      sql/sql_show.cc:
        Put variable under the same ifdef block.
      sql/udf_example.c:
        Set null pointer flag appropriately.
      storage/csv/ha_tina.cc:
        Meaningless dereferences.
      storage/example/ha_example.cc:
        Return the error since it's available.
      storage/myisam/mi_locking.c:
        Remove unused and dead code.
      450d34b7
  10. 02 Jul, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#53445: Build with -Wall and fix warnings that it generates · 1113efea
      Davi Arnaut authored
      Apart strict-aliasing warnings, fix the remaining warnings
      generated by GCC 4.4.4 -Wall and -Wextra flags.
      
      One major source of warnings was the in-house function my_bcmp
      which (unconventionally) took pointers to unsigned characters
      as the byte sequences to be compared. Since my_bcmp and bcmp
      are deprecated functions whose only difference with memcmp is
      the return value, every use of the function is replaced with
      memcmp as the special return value wasn't actually being used
      by any caller.
      
      There were also various other warnings, mostly due to type
      mismatches, missing return values, missing prototypes, dead
      code (unreachable) and ignored return values.
      
      BUILD/SETUP.sh:
        Remove flags that are implied by -Wall and -Wextra.
        Do not warn about unused parameters in C++.
      BUILD/check-cpu:
        Print only the compiler version instead of verbose banner.
        Although the option is gcc specific, the check was only
        being used for GCC specific checks anyway.
      client/mysql.cc:
        bcmp is no longer defined.
      client/mysqltest.cc:
        Pass a string to function expecting a format string.
        Replace use of bcmp with memcmp.
      cmd-line-utils/readline/Makefile.am:
        Always define _GNU_SOURCE when compiling GNU readline.
        Required to make certain prototypes visible.
      cmd-line-utils/readline/input.c:
        Condition for the code to be meaningful.
      configure.in:
        Remove check for bcmp.
      extra/comp_err.c:
        Use appropriate type.
      extra/replace.c:
        Replace use of bcmp with memcmp.
      extra/yassl/src/crypto_wrapper.cpp:
        Do not ignore the return value of fgets. Retrieve the file
        position if fgets succeed -- if it fails, the function will
        bail out and return a error.
      extra/yassl/taocrypt/include/blowfish.hpp:
        Use a single array instead of accessing positions of the sbox_
        through a subscript to pbox_.
      extra/yassl/taocrypt/include/runtime.hpp:
        One definition of such functions is enough.
      extra/yassl/taocrypt/src/aes.cpp:
        Avoid potentially ambiguous conditions.
      extra/yassl/taocrypt/src/algebra.cpp:
        Rename arguments to avoid shadowing related warnings.
      extra/yassl/taocrypt/src/blowfish.cpp:
        Avoid potentially ambiguous conditions.
      extra/yassl/taocrypt/src/integer.cpp:
        Do not define type within a anonymous union.
        Use a variable to return a value instead of
        leaving the result in a register -- compiler
        does not know the logic inside the asm.
      extra/yassl/taocrypt/src/misc.cpp:
        Define handler for pure virtual functions.
        Remove unused code.
      extra/yassl/taocrypt/src/twofish.cpp:
        Avoid potentially ambiguous conditions.
      extra/yassl/testsuite/test.hpp:
        Function must have C language linkage.
      include/m_string.h:
        Remove check which relied on bcmp being defined -- they weren't
        being used as bcmp is only visible when _BSD_SOURCE is defined.
      include/my_bitmap.h:
        Remove bogus helpers which were used only in a few files and
        were causing warnings about dead code.
      include/my_global.h:
        Due to G++ bug, always silence false-positive uninitialized
        variables warnings when compiling C++ code with G++.
        Remove bogus helper.
      libmysql/Makefile.shared:
        Remove built-in implementation of bcmp.
      mysql-test/lib/My/SafeProcess/safe_process.cc:
        Cast pid to largest possible type for a process identifier.
      mysys/mf_loadpath.c:
        Leave space of the ending nul.
      mysys/mf_pack.c:
        Replace bcmp with memcmp.
      mysys/my_bitmap.c:
        Dead code removal.
      mysys/my_gethwaddr.c:
        Remove unused variable.
      mysys/my_getopt.c:
        Silence bogus uninitialized variable warning.
        Do not cast away the constant qualifier.
      mysys/safemalloc.c:
        Cast to expected type.
      mysys/thr_lock.c:
        Silence bogus uninitialized variable warning.
      sql/field.cc:
        Replace bogus helper with a more appropriate logic which is
        used throughout the code.
      sql/item.cc:
        Remove bogus logical condition which always evaluates to TRUE.
      sql/item_create.cc:
        Simplify code to avoid signedness related warnings.
      sql/log_event.cc:
        Replace use of bcmp with memcmp.
        No need to use helpers for simple bit operations.
      sql/log_event_old.cc:
        Replace bmove_align with memcpy.
      sql/mysqld.cc:
        Move use declaration of variable to the ifdef block where it
        is used. Remove now-unnecessary casts and arguments.
      sql/set_var.cc:
        Replace bogus helpers with simple and classic bit operations.
      sql/slave.cc:
        Cast to expected type and silence bogus warning.
      sql/sql_class.h:
        Don't use enum values as bit flags, the supposed type safety is
        bogus as the combined bit flags are not a value in the enumeration.
      sql/udf_example.c:
        Only declare variable when necessary.
      sql/unireg.h:
        Replace use of bmove_align with memcpy.
      storage/innobase/os/os0file.c:
        Silence bogus warning.
      storage/myisam/mi_open.c:
        Remove bogus cast, DBUG_DUMP expects a pointer to unsigned
        char.
      storage/myisam/mi_page.c:
        Remove bogus cast, DBUG_DUMP expects a pointer to unsigned
        char.
      strings/bcmp.c:
        Remove built-in bcmp.
      strings/ctype-ucs2.c:
        Silence bogus warning.
      tests/mysql_client_test.c:
        Use a appropriate type as expected by simple_command().
      1113efea
  11. 19 May, 2010 1 commit
    • Alfranio Correia's avatar
      BUG#53560 CREATE TEMP./DROP TEMP. are not binglogged correctly after a failed statement · c8d6a07d
      Alfranio Correia authored
      This patch fixes two problems described as follows:
      
      1 - If there is an on-going transaction and a temporary table is created or
      dropped, any failed statement that follows the "create" or "drop commands"
      triggers a rollback and by consequence the slave will go out sync because
      the binary log will have a wrong sequence of events.
      
      To fix the problem, we changed the expression that evaluates when the
      cache should be flushed after either the rollback of a statment or
      transaction.
      
      2 - When a "CREATE TEMPORARY TABLE SELECT * FROM" was executed the
      OPTION_KEEP_LOG was not set into the thd->options. For that reason, if
      the transaction had updated only transactional engines and was rolled
      back at the end (.e.g due to a deadlock) the changes were not written
      to the binary log, including the creation of the temporary table.
            
      To fix the problem, we have set the OPTION_KEEP_LOG into the thd->options
      when a "CREATE TEMPORARY TABLE SELECT * FROM" is executed.
      
      sql/log.cc:
        Reorganized the code based on the following functions:
        
        - bool ending_trans(const THD* thd, const bool all);
        - bool trans_has_updated_non_trans_table(const THD* thd);
        - bool trans_has_no_stmt_committed(const THD* thd, const bool all);
        - bool stmt_has_updated_non_trans_table(const THD* thd);
      sql/log.h:
        Added functions to organize the code in log.cc.
      sql/log_event.cc:
        Removed the OPTION_KEEP_LOG since it must be used only when
        creating and dropping temporary tables.
      sql/log_event_old.cc:
        Removed the OPTION_KEEP_LOG since it must be used only when
        creating and dropping temporary tables.
      sql/sql_parse.cc:
        When a "CREATE TEMPORARY TABLE SELECT * FROM" was executed the
        OPTION_KEEP_LOG was not set into the thd->options.
              
        To fix the problem, we have set the OPTION_KEEP_LOG into the
        thd->options when a "CREATE TEMPORARY TABLE SELECT * FROM"
        is executed.
      c8d6a07d
  12. 08 May, 2010 1 commit
    • He Zhenxing's avatar
      Bug#53189 Table map version unused and can be removed · 014367e0
      He Zhenxing authored
      MYSQL_BIN_LOG m_table_map_version member and it's associated 
      functions were not used in the logic of binlogging and replication,
      this patch removed all related code.
      
      sql/log.cc:
        removed unused m_table_map_version variable and functions
      sql/log.h:
        removed unused m_table_map_version variable and functions
      sql/log_event.h:
        Removed unused LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F flag
      sql/sql_class.cc:
        Removed unused LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F flag
      sql/sql_load.cc:
        Removed unused LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F flag
      sql/table.cc:
        removed unused table_map_version variable
      sql/table.h:
        removed unused table_map_version variable
      014367e0
  13. 28 Mar, 2010 1 commit
    • unknown's avatar
      Bug #50407 mysqlbinlog --database=X produces bad output for SAVEPOINTs · 78557dd4
      unknown authored
      When mysqlbinlog was given the --database=X flag, it always printed
      'ROLLBACK TO', but the corresponding 'SAVEPOINT' statement was not
      printed. The replicated filter(replicated-do/ignore-db) and binlog
      filter (binlog-do/ignore-db) has the same problem. They are solved
      in this patch together.
      
      After this patch, We always check whether the query is 'SAVEPOINT'
      statement or not. Because this is a literal check, 'SAVEPOINT' and
      'ROLLBACK TO' statements are also binlogged in uppercase with no
      any comments.
      
      The binlog before this patch can be handled correctly except one case
      that any comments are in front of the keywords. for example:
       /* bla bla */ SAVEPOINT a;
       /* bla bla */ ROLLBACK TO a;
      78557dd4
  14. 17 Mar, 2010 1 commit
    • Mats Kindahl's avatar
      BUG#49618: Field length stored incorrectly in binary log · 028d1256
      Mats Kindahl authored
                 for InnoDB
                  
      The class Field_bit_as_char stores the metadata for the
      field incorrecly because bytes_in_rec and bit_len are set
      to (field_length + 7 ) / 8 and 0 respectively, while
      Field_bit has the correct values field_length / 8 and
      field_length % 8.
                  
      Solved the problem by re-computing the values for the
      metadata based on the field_length instead of using the
      bytes_in_rec and bit_len variables.
                  
      To handle compatibility with old server, a table map
      flag was added to indicate that the bit computation is
      exact. If the flag is clear, the slave computes the
      number of bytes required to store the bit field and
      compares that instead, effectively allowing replication
      *without conversion* from any field length that require
      the same number of bytes to store.
      
      
      mysql-test/suite/rpl/t/rpl_typeconv_innodb.test:
        Adding test to check compatibility for bit field
        replication when using InnoDB
      sql/field.cc:
        Extending compatible_field_size() with flags from
        table map to allow fields to check master info.
      sql/field.h:
        Extending compatible_field_size() with flags from
        table map to allow fields to check master info.
      sql/log.cc:
        Removing table map flags since they are not used
        outside table map class.
      sql/log_event.cc:
        Removing flags parameter from table map constructor
        since it is not used and does not have to be exposed.
      sql/log_event.h:
        Adding flag to denote that bit length for bit field type
        is exact and not potentially rounded to even bytes.
      sql/rpl_utility.cc:
        Adding fields to table_def to store table map flags.
      sql/rpl_utility.h:
        Removing obsolete comment and adding flags to store
        table map flags from master.
      028d1256
  15. 04 Mar, 2010 1 commit
    • Luis Soares's avatar
      BUG#51055: Replication failure on duplicate key + traditional SQL · 010d48f9
      Luis Soares authored
      mode
      
      When the master was executing in sql_mode='traditional' (which
      implies that really_abort_on_warning returns TRUE - because of
      MODE_STRICT_ALL_TABLES), the error code (ER_DUP_ENTRY in the
      reported case) was not being set in the
      Query_log_event. Therefore, even if a failure was to be expected
      when replaying the statement on the slave, a failure would occur,
      because the Query_log_event was not transporting the expected
      error code, but 0 instead.
      
      This was because when the master was getting the error code to
      set it in the Query_log_event, the executing thread would be
      assumed to have been killed:
      THD::killed==THD::KILL_BAD_DATA. This would make the error code
      fetch routine not to check thd->main_da.sql_errno(), but instead
      the thd->killed value. What's more, is that the server would
      thd->killed value if thd->killed == THD::KILL_BAD_DATA and return
      0 instead. So this is a double inconsistency, as the we should
      not even check thd->killed but rather thd->main_da.sql_errno().
      
      We fix this by extending the condition used to choose whether to
      check the thd->main_da.sql_errno() or thd->killed, so that it
      takes into consideration the case when:
      thd->killed==THD::KILL_BAD_DATA.
      010d48f9
  16. 05 Feb, 2010 1 commit
    • Luis Soares's avatar
      BUG#48632: Fix for Bug #23300 Has Not Been Backported · c3f7a25d
      Luis Soares authored
      To 5.x Release
            
      Notes
      =====
            
      This is a backport of BUG#23300 into 5.1 GA.
            
      Original cset revid (in betony):
      luis.soares@sun.com-20090929140901-s4kjtl3iiyy4ls2h
      
      Description
      ===========
            
      When using replication, the slave will not log any slow query
      logs queries replicated from the master, even if the
      option "--log-slow-slave-statements" is set and these take more
      than "log_query_time" to execute.
                          
      In order to log slow queries in replicated thread one needs to
      set the --log-slow-slave-statements, so that the SQL thread is
      initialized with the correct switch. Although setting this flag
      correctly configures the slave thread option to log slow queries,
      there is an issue with the condition that is used to check
      whether to log the slow query or not. When replaying binlog
      events the statement contains the SET TIMESTAMP clause which will
      force the slow logging condition check to fail. Consequently, the
      slow query logging will not take place.
                          
      This patch addresses this issue by removing the second condition
      from the log_slow_statements as it prevents slow queries to be
      binlogged and seems to be deprecated.
      c3f7a25d
  17. 24 Jan, 2010 1 commit
  18. 20 Jan, 2010 1 commit
    • Alfranio Correia's avatar
      BUG#46364 MyISAM transbuffer problems (NTM problem) · a02a4cf4
      Alfranio Correia authored
      It is well-known that due to concurrency issues, a slave can become
      inconsistent when a transaction contains updates to both transaction and
      non-transactional tables in statement and mixed modes.
      
      In a nutshell, the current code-base tries to preserve causality among the
      statements by writing non-transactional statements to the txn-cache which
      is flushed upon commit. However, modifications done to non-transactional
      tables on behalf of a transaction become immediately visible to other
      connections but may not immediately get into the binary log and therefore
      consistency may be broken.
      
      In general, it is impossible to automatically detect causality/dependency
      among statements by just analyzing the statements sent to the server. This
      happen because dependency may be hidden in the application code and it is
      necessary to know a priori all the statements processed in the context of
      a transaction such as in a procedure. Moreover, even for the few cases that
      we could automatically address in the server, the computation effort
      required could make the approach infeasible.
      
      So, in this patch we introduce the option
          - "--binlog-direct-non-transactional-updates" that can be used to bypass
          the current behavior in order to write directly to binary log statements
          that change non-transactional tables.
      
      mysql-test/extra/rpl_tests/rpl_mixing_engines.inc:
        Backported this from Celosia to improve the test cases related to the NTM issue.
      sql/log.cc:
        Checks the --binlog-direct-non-transactional-updates before choosing
        to either use the trxn-cache or not.
      sql/mysqld.cc:
        Introduces the option --binlog-direct-non-transactional-updates.
      sql/set_var.cc:
        Introduces the option --binlog-direct-non-transactional-updates.
      sql/sql_class.h:
        Introduces the option --binlog-direct-non-transactional-updates.
      a02a4cf4
  19. 17 Dec, 2009 1 commit
    • Davi Arnaut's avatar
      Bug#48983: Bad strmake calls (length one too long) · c2fb2a9a
      Davi Arnaut authored
      The problem is a somewhat common misusage of the strmake function.
      The strmake(dst, src, len) function writes at most /len/ bytes to
      the string pointed to by src, not including the trailing null byte.
      Hence, if /len/ is the exact length of the destination buffer, a
      one byte buffer overflow can occur if the length of the source
      string is equal to or greater than /len/.
      
      client/mysqldump.c:
        Make room for the trailing null byte.
      libmysql/libmysql.c:
        Add comment, there is enough room in the buffer.
        Increase buffer length, two strings are concatenated.
      libmysqld/lib_sql.cc:
        Make room for the trailing null byte.
      mysys/default.c:
        Make room for the trailing null bytes.
      mysys/mf_pack.c:
        Make room for the trailing null byte.
      server-tools/instance-manager/commands.cc:
        Copy only if overflow isn't possible in both cases.
      server-tools/instance-manager/listener.cc:
        Make room for the trailing null byte.
      sql/log.cc:
        Make room for the trailing null byte.
      sql/sp_pcontext.h:
        Cosmetic fix.
      sql/sql_acl.cc:
        MAX_HOSTNAME already specifies space for the trailing null byte.
      sql/sql_parse.cc:
        Make room for the trailing null byte.
      sql/sql_table.cc:
        Make room for the trailing null byte.
      c2fb2a9a
  20. 16 Dec, 2009 1 commit
  21. 15 Dec, 2009 1 commit
    • He Zhenxing's avatar
      bug#49536 - deadlock on rotate_and_purge when using expire_logs_days · cbcd6f41
      He Zhenxing authored
      Problem is that purge_logs implementation in ndb (ndbcluster_binlog_index_purge_file)
      calls mysql_parse (with (thd->options & OPTION_BIN_LOG) === 0)) 
      but MYSQL_BIN_LOG first takes LOCK_log and then checks thd->options
      
      Solution in this patch, changes so that rotate_and_purge does not hold
      LOCK_log when calling purge_logs_before_date. I think this is safe
      as other "purge"-function(s) is called wo/ holding LOCK_log, e.g purge_master_logs
      cbcd6f41
  22. 04 Dec, 2009 1 commit
    • Alfranio Correia's avatar
      BUG#45292 orphan binary log created when starting server twice · 0fafee45
      Alfranio Correia authored
      This patch fixes three bugs as follows. First, aborting the server while purging
      binary logs might generate orphan files due to how the purge operation was
      implemented:
      
                (purge routine - sql/log.cc - MYSQL_BIN_LOG::purge_logs)
      
            1 - register the files to be removed in a temporary buffer.
            2 - update the log-bin.index.
            3 - flush the log-bin.index.
            4 - erase the files whose names where register in the temporary buffer
            in step 1.
      
      Thus a failure while  executing step 4 would generate an orphan file. Second,
      a similar issue might happen while creating a new binary as follows:
      
                (create routine - sql/log.cc - MYSQL_BIN_LOG::open)
      
            1 - open the new log-bin.
            2 - update the log-bin.index.
      
      Thus a failure while executing step 1 would generate an orphan file.
      
      To fix these issues, we record the files to be purged or created before really
      removing or adding them. So if a failure happens such records can be used to
      automatically remove dangling files. The new steps might be outlined as follows:
      
                (purge routine - sql/log.cc - MYSQL_BIN_LOG::purge_logs)
      
            1 - register the files to be removed in the log-bin.~rec~ placed in
            the data directory.
            2 - update the log-bin.index.
            3 - flush the log-bin.index.
            4 - delete the log-bin.~rec~.
      
                (create routine - sql/log.cc - MYSQL_BIN_LOG::open)
      
            1 - register the file to be created in the log-bin.~rec~
            placed in the data directory.
            2 - open the new log-bin.
            3 - update the log-bin.index.
            4 - delete the log-bin.~rec~.
      
                (recovery routine - sql/log.cc - MYSQL_BIN_LOG::open_index_file)
      
            1 - open the log-bin.index.
            2 - open the log-bin.~rec~.
            3 - for each file in log-bin.~rec~.
              3.1 Check if the file is in the log-bin.index and if so ignore it.
              3.2 Otherwise, delete it.
      
      The third issue can be described as follows. The purge operation was allowing
      to remove a file in use thus leading to the loss of data and possible
      inconsistencies between the master and slave. Roughly, the routine was only
      taking into account the dump threads and so if a slave was not connect the
      file might be delete even though it was in use.
      0fafee45
  23. 20 Nov, 2009 1 commit
  24. 13 Nov, 2009 1 commit
    • Luis Soares's avatar
      BUG#48738: Backport patch for Bug 34582 to 5.0 codebase. · 0f071feb
      Luis Soares authored
      From BUG 34582 commit message:
      
      Issuing 'FLUSH LOGS' does not close and reopen indexfile.
      Instead a SEEK_SET is performed.
                  
      This patch makes index file to be closed and reopened whenever a
      rotation happens (FLUSH LOGS is issued or binary log exceeds 
      maximum configured size).
      0f071feb
  25. 22 Oct, 2009 1 commit
  26. 20 Oct, 2009 1 commit
    • Luis Soares's avatar
      BUG#34582: FLUSH LOGS does not close and reopen the binlog index · 3996cd98
      Luis Soares authored
      file
            
      Issuing 'FLUSH LOGS' does not close and reopen indexfile.
      Instead a SEEK_SET is performed.
            
      This patch makes index file to be closed and reopened whenever a
      rotation happens (FLUSH LOGS is issued or binary log exceeds 
      maximum configured size).
      
      mysql-test/suite/binlog/r/binlog_delete_and_flush_index.result:
        Result file.
      mysql-test/suite/binlog/t/binlog_delete_and_flush_index.test:
        Test case.
      sql/log.cc:
        Added LOG_CLOSE_INDEX flag when calling MYSQL_BIN_LOG::close
        from within MYSQL_BIN_LOG::new_file_impl (which should just be
        called whenever a rotation is to happen - FLUSH LOGS issued or
        binlog size exceeds the maximum configured).
      3996cd98
  27. 16 Oct, 2009 1 commit
    • Georgi Kodinov's avatar
      Bug #40877: multi statement execution fails in 5.1.30 · 9c6668d6
      Georgi Kodinov authored
            
      Implemented the server infrastructure for the fix:
      
      1. Added a function LEX_STRING *thd_query_string(THD) to return
      a LEX_STRING structure instead of char *.
      This is the function that must be called in innodb instead of 
      thd_query()
      
      2. Did some encapsulation in THD : aggregated thd_query and 
      thd_query_length into a LEX_STRING and made accessor and mutator 
      methods for easy code updating. 
      
      3. Updated the server code to use the new methods where applicable.
      9c6668d6
  28. 06 Oct, 2009 2 commits
    • Alfranio Correia's avatar
      BUG#47678 Changes to n-tables that happen early in a trans. are only flushed upon commit · 216b41ae
      Alfranio Correia authored
        Let
          - T be a transactional table and N non-transactional table.
          - B be begin, C commit and R rollback.
          - N be a statement that accesses and changes only N-tables.
          - T be a statement that accesses and changes only T-tables.
      
      In RBR, changes to N-tables that happen early in a transaction are not immediately flushed
      upon committing a statement. This behavior may, however, break consistency in the presence
      of concurrency since changes done to N-tables become immediately visible to other
      connections. To fix this problem, we do the following:
      
        . B N N T C would log - B N C B N C B T C.
        . B N N T R would log - B N C B N C B T R.
      
      Note that we are not preserving history from the master as we are introducing a commit that
      never happened. However, this seems to be more acceptable than the possibility of breaking
      consistency in the presence of concurrency.
      216b41ae
    • Alfranio Correia's avatar
      BUG#47287 RBR: replication diff on basic case with txn- and non-txn tables in a statement · 11a6647e
      Alfranio Correia authored
      Let
        - T be a transactional table and N non-transactional table.
        - B be begin, C commit and R rollback.
        - M be a mixed statement, i.e. a statement that updates both T and N.
        - M* be a mixed statement that fails while updating either T or N.
      
      This patch restore the behavior presented in 5.1.37 for rows either produced in
      the RBR or MIXED modes, when a M* statement that happened early in a transaction
      had their changes written to the binary log outside the boundaries of the
      transaction and wrapped in a BEGIN/ROLLBACK. This was done to keep the slave
      consistent with with the master as the rollback would keep the changes on N and
      undo them on T. In particular, we do what follows:
      
        . B M* T C would log - B M* R B T C.
      
      Note that, we are not preserving history from the master as we are introducing a
      rollback that never happened. However, this seems to be more acceptable than
      making the slave diverge. We do not fix the following case:
      
        . B T M* C would log B T M* C.
      
      The slave will diverge as the changes on T tables that originated from the M
      statement are rolled back on the master but not on the slave. Unfortunately, we
      cannot simply rollback the transaction as this would undo any uncommitted
      changes on T tables.
      
      SBR is not considered in this patch because a failing statement is written to
      the binary along with the error code and a slave executes and then rolls back
      the statement when it has an associated error code, thus undoing the effects
      on T. In RBR and MBR, a full-fledged fix will be pushed after the WL 2687.
      11a6647e
  29. 11 Sep, 2009 1 commit
    • Ramil Kalimullin's avatar
      Fix for bug#47130: misplaced or redundant check for null pointer? · 8b3ff350
      Ramil Kalimullin authored
      Problem: LOGGER::general_log_write() relied on valid "thd" parameter passed
      but had inconsistent "if (thd)" check.
      
      Fix: as we always pass a valid "thd" parameter to the method, 
      redundant check removed.
      
      
      sql/log.cc:
        Fix for bug#47130: misplaced or redundant check for null pointer?
          - code clean-up, as we rely on the "thd" parameter in the
        LOGGER::general_log_write(), redundant "if (thd)" check removed, 
        added assert(thd) instead.
      8b3ff350
  30. 28 Aug, 2009 1 commit
    • Staale Smedseng's avatar
      Bug #43414 Parenthesis (and other) warnings compiling MySQL · 2708ec4f
      Staale Smedseng authored
      with gcc 4.3.2
            
      This patch fixes a number of GCC warnings about variables used
      before initialized. A new macro UNINIT_VAR() is introduced for
      use in the variable declaration, and LINT_INIT() usage will be
      gradually deprecated. (A workaround is used for g++, pending a
      patch for a g++ bug.)
            
      GCC warnings for unused results (attribute warn_unused_result)
      for a number of system calls (present at least in later
      Ubuntus, where the usual void cast trick doesn't work) are
      also fixed.
      
      
      client/mysqlmanager-pwgen.c:
        A fix for warn_unused_result, adding fallback to use of
        srand()/rand() if /dev/random cannot be used. Also actually
        adds calls to rand() in the second branch so that it actually
        creates a random password.
      2708ec4f
  31. 26 Aug, 2009 1 commit
    • Alfranio Correia's avatar
      BUG#28976 Mixing trans and non-trans tables in one transaction results in incorrect · ca30fe67
      Alfranio Correia authored
      binlog
      
      Mixing transactional (T) and non-transactional (N) tables on behalf of a
      transaction may lead to inconsistencies among masters and slaves in STATEMENT
      mode. The problem stems from the fact that although modifications done to
      non-transactional tables on behalf of a transaction become immediately visible
      to other connections they do not immediately get to the binary log and therefore
      consistency is broken. Although there may be issues in mixing T and M tables in
      STATEMENT mode, there are safe combinations that clients find useful.
      
      In this bug, we fix the following issue. Mixing N and T tables in multi-level
      (e.g. a statement that fires a trigger) or multi-table table statements (e.g.
      update t1, t2...) were not handled correctly. In such cases, it was not possible
      to distinguish when a T table was updated if the sequence of changes was N and T.
      In a nutshell, just the flag "modified_non_trans_table" was not enough to reflect
      that both a N and T tables were changed. To circumvent this issue, we check if an
      engine is registered in the handler's list and changed something which means that
      a T table was modified.
      
      Check WL 2687 for a full-fledged patch that will make the use of either the MIXED or
      ROW modes completely safe.
      
      mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result:
        Truncate statement is wrapped in BEGIN/COMMIT.
      mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result:
        Truncate statement is wrapped in BEGIN/COMMIT.
      ca30fe67
  32. 18 Jul, 2009 1 commit
    • Alfranio Correia's avatar
      BUG#46129 Failing mixed stm (with trans and non-trans tables) causes wrong seq in · b9b08caa
      Alfranio Correia authored
      binlog
            
      The fix for BUG 43929 introduced a regression issue. In a nutshell, when a
      statement that changes a non-transactional table fails, it is written to the
      binary log with the error code appended. Unfortunately, after BUG 43929, this
      failure was flushing the transactional chace causing mismatch between execution
      and logging histories. To fix this issue, we avoid flushing the transactional
      cache when a commit or rollback is not issued.
      b9b08caa
  33. 24 Jun, 2009 1 commit
    • MySQL Build Team's avatar
      Backport into build-200906240007-5.1.34sp1 · 90df7aa9
      MySQL Build Team authored
      > ------------------------------------------------------------
      > revno: 2852.1.15
      > revision-id: davi.arnaut@sun.com-20090409152525-b4vnj9atidmjh0mf
      > parent: luis.soares@sun.com-20090409113044-2072kufy5efeohpp
      > committer: Davi Arnaut <Davi.Arnaut@Sun.COM>
      > branch nick: 43706-5.1
      > timestamp: Thu 2009-04-09 12:25:25 -0300
      > message:
      >   Bug#43706: libmysqld segfaults when re-intialised
      >   Bug#44091: libmysqld gets stuck waiting on mutex on initialization
      >   
      >   The problem was that libmysqld wasn't enforcing a certain
      >   initialization and deinitialization order for the mysys
      >   library. Another problem was that the global object used
      >   for management of log event handlers (aka LOGGER) wasn't
      >   being prepared for a possible reutilization.
      >   
      >   What leads to the hang/crash reported is that a failure
      >   to load the language file triggers a double call of the
      >   cleanup functions, causing an already destroyed mutex to
      >   be used.
      >   
      >   The solution is enforce a order on the initialization and
      >   deinitialization of the mysys library within the libmysqld
      >   library and to ensure that the global LOGGER object reset
      >   it's internal state during cleanup.
      90df7aa9
  34. 19 Jun, 2009 1 commit
    • Sergey Glukhov's avatar
      Bug#44834 strxnmov is expected to behave as you'd expect · 524191be
      Sergey Glukhov authored
      The problem: described in the bug report.
      The fix:
      --increase buffers where it's necessary
        (buffers which are used in stxnmov)
      --decrease buffer lengths which are used
      
      
      client/mysql.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/ha_ndbcluster.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/ha_ndbcluster_binlog.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/handler.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/log.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/mysqld.cc:
        removed unnecessary line
      sql/parse_file.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_acl.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_base.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_db.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_delete.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_partition.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_rename.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_show.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_table.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      sql/sql_view.cc:
        --increase buffers where it's necessary
          (buffers which are used in stxnmov)
        --decrease buffer lengths which are used
          as argument for strxnmov function
      524191be
  35. 18 Jun, 2009 1 commit
    • Alfranio Correia's avatar
      BUG#43929 binlog corruption when max_binlog_cache_size is exceeded · eb708edc
      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.
      eb708edc
  36. 12 Jun, 2009 1 commit
    • Staale Smedseng's avatar
      Bug #45387 Information about statement id for prepared · f6291bab
      Staale Smedseng authored
      statements missed from general log
      
      A refinement of the test in the previous patch to avoid
      using sleep as a means to ensure that timestamps are
      added to the log entries.
      
      mysql-test/t/log_tables_debug.test:
        New test file. A debug feature is used to ensure that
        log entries are prefixed with a timestamp.
      sql/log.cc:
        A debug feature is implemented to ensure that
        log entries are prefixed with a timestamp.
      f6291bab
  37. 31 May, 2009 1 commit
    • He Zhenxing's avatar
      BUG#43263 BEGIN skipped in some replicate-do-db cases · e5788d86
      He Zhenxing authored
      BEGIN/COMMIT/ROLLBACK was subject to replication db rules, and
      caused the boundary of a transaction not recognized correctly 
      when these queries were ignored by the rules.
      
      Fixed the problem by skipping replication db rules for these
      statements.
      
      
      sql/log_event.cc:
        Skip checking replication db rules for BEGIN/COMMIT/ROLLBACK statements
      e5788d86
  38. 30 May, 2009 1 commit
    • He Zhenxing's avatar
      BUG#41948 Query_log_event constructor needlessly contorted · 38e27260
      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
      38e27260