An error occurred fetching the project authors.
  1. 28 Feb, 2008 1 commit
    • unknown's avatar
      Bug#33851 Passing UNSIGNED param to EXECUTE returns ERROR 1210 · 1164e2bc
      unknown authored
      The problem is that passing anything other than a integer to a limit
      clause in a prepared statement would fail. This limitation was introduced
      to avoid replication problems (e.g: replicating the statement with a
      string argument would cause a parse failure in the slave).
      
      The solution is to convert arguments to the limit clause to a integer
      value and use this converted value when persisting the query to the log.
      
      
      mysql-test/r/limit.result:
        Update test case result.
      mysql-test/r/ps.result:
        Add test case result for Bug#33851
      mysql-test/r/rpl_user_variables.result:
        Test case result for replication of prepared statement with
        limit clause.
      mysql-test/t/limit.test:
        Test parameters to limit clause.
      mysql-test/t/ps.test:
        Add test case for Bug#33851
      mysql-test/t/rpl_user_variables.test:
        Test replication of a parameter which value is converted.
      sql/item.cc:
        Convert value to integer if it's a parameter to a limit clause.
      sql/item.h:
        Flag signal that item is a parameter to a limit clause.
      sql/item_func.cc:
        Const member functions, object is not mutated.
      sql/sql_class.h:
        Const member functions, object is not mutated.
      sql/sql_yacc.yy:
        Flag that item is a parameter to a limit clause.
      1164e2bc
  2. 19 Feb, 2008 3 commits
    • unknown's avatar
    • 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
  3. 13 Dec, 2007 3 commits
    • unknown's avatar
      Remove an unused argument of sql_update::do_updates(). · a6eec72e
      unknown authored
      sql/sql_class.h:
        Remove an unused argument.
      sql/sql_update.cc:
        Remove an unused argument.
      a6eec72e
    • unknown's avatar
      Bug #32858: Erro: "Incorrect usage of UNION and INTO" does not take · 93e3057b
      unknown authored
      subselects into account
      
      It is forbidden to use the SELECT INTO construction inside UNION statements
      unless on the last SELECT of the union. The parser records whether it 
      has seen INTO or not when parsing a UNION statement. But if the INTO was
      legally used in an outer query, an error is thrown if UNION is seen in a
      subquery. Fixed in 5.0 by remembering the nesting level of INTO tokens and 
      mitigate the error unless it collides with the UNION.
      
      
      mysql-test/r/union.result:
        Bug#32858: Test result
      mysql-test/t/union.test:
        Bug#32858: Test case
      sql/sql_class.cc:
        Bug#32858: Initializing new member
      sql/sql_class.h:
        Bug#32858: Added property nest_level to select_result class.
      sql/sql_yacc.yy:
        Bug#32858: The fix.
      93e3057b
    • unknown's avatar
      Fix a compilation warning and a subtle bug with truncation of the · a3a0d435
      unknown authored
      last_insert_id introduced by the patch for Bug#12713 (part 1)
      
      
      a3a0d435
  4. 12 Dec, 2007 2 commits
    • 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
    • unknown's avatar
      Bug#31552 Replication breaks when deleting rows from out-of-sync table · 96a51b7f
      unknown authored
          without PK
      Bug#31609 Not all RBR slave errors reported as errors
      bug#32468 delete rows event on a table with foreign key constraint fails
      
      The first two bugs comprise idempotency issues.
      First, there was no error code reported under conditions of the bug
      description although the slave sql thread halted.
      Second, executions were different with and without presence of prim key in
      the table.
      Third, there was no way to instruct the slave whether to ignore an error
      and skip to the following event or to halt.
      Fourth, there are handler errors which might happen due to idempotent
      applying of binlog but those were not listed among the "idempotent" error
      list.
      
      All the named issues are addressed.
      Wrt to the 3rd, there is the new global system variable, changeble at run
      time, which controls the slave sql thread behaviour.
      The new variable allows further extensions to mimic the sql_mode
      session/global variable.
      To address the 4th, the new bug#32468 had to be fixed as it was staying
      in the way.
      
      
      include/my_bitmap.h:
        basic operations with bits of an integer type are added.
      mysql-test/extra/rpl_tests/rpl_foreign_key.test:
        regression test for bug#32468
      mysql-test/extra/rpl_tests/rpl_row_basic.test:
        changes due to bug#31552/31609 idempotency is not default any longer
      mysql-test/extra/rpl_tests/rpl_row_tabledefs.test:
        changes due to bug#31552/31609 idempotency is not default any longer
      mysql-test/suite/rpl/r/rpl_foreign_key_innodb.result:
        results changed
      mysql-test/suite/rpl/r/rpl_idempotency.result:
        results changed
      mysql-test/suite/rpl/r/rpl_row_basic_11bugs.result:
        results changed
      mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result:
        results changed
      mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result:
        results changed
      mysql-test/suite/rpl/r/rpl_row_mystery22.result:
        results changed
      mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result:
        results changed
      mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result:
        results changed
      mysql-test/suite/rpl/r/rpl_temporary_errors.result:
        results changed
      mysql-test/suite/rpl/t/rpl_idempotency.test:
        extenstions to the test providing testing of complements to the
        idempotent error set and checking how slave halts when it faces an error
        from the list when the mode is STRICT.
      mysql-test/suite/rpl/t/rpl_row_basic_11bugs.test:
        changes due to bug#31552/31609 idempotency is not default any longer.
      mysql-test/suite/rpl/t/rpl_row_mystery22.test:
        changes due to bug#31552/31609 idempotency is not default any longer
      mysql-test/suite/rpl/t/rpl_temporary_errors.test:
        changes due to bug#31552/31609 idempotency is not default any longer
      mysql-test/suite/rpl_ndb/r/rpl_ndb_dd_advance.result:
        results changed
      mysql-test/suite/rpl_ndb/r/rpl_row_basic_7ndb.result:
        results changed
      sql/log_event.cc:
        the fix for bug#32468 delete rows event on a table with foreign key constraint fails
        ensures the flags are set at proper time so that their values will be caught
        by innodb.
        reseting the flags is done along the common error and errorless execution
        path.
        The list of idempotent error is extended with foreign keys related items.
        NDB engine write events are designed with the replace sematics in mind.
        Therefore the corrsponding ndb handler's flag are (re)set regardless of
        the slave's execution mode.
        Rows_log_event::write_row() starts using the bool replace argument as its
        caller sets it depending on the event's execution mode.
      sql/log_event.h:
        adding a new member to hold the slave's mode during execution of the event.
      sql/mysql_priv.h:
        changes to link the command line option with the new global sys var.
      sql/mysqld.cc:
        introduction of the new command line option.
        providing its initialization to a default.
        changes to link the command line option with the new global sys var.
      sql/rpl_rli.cc:
        rli post-event-execution cleanup restores the default bits.
      sql/set_var.cc:
        The new "standard" sys_var_set class' and the new global system var related
        declarations and definitions.
        fix_slave_exec_mode() is used as with the update method of a new class so
        as at time of the command line arguments parsing.
      sql/set_var.h:
        new declarations. The class for the new global sys var is based on
        yet another new "standard" one.
      sql/share/errmsg.txt:
        slave_exec_mode setting error;
        slave inconsistency error which may be not an error when the intention
        is "idempotent". I.e consisting of row-based events binlog is being
        applied for the 2nd (more) time.
      sql/sql_class.h:
        The names for the bits of the new sever slave_exec_mode_options.
      mysql-test/suite/rpl/t/rpl_idempotency-master.opt:
        innodb is necessary
      mysql-test/suite/rpl/t/rpl_idempotency-slave.opt:
        innodb is necessary, as well as the tests start with non-default
        IDEMPOTENT slave execution mode.
      96a51b7f
  5. 26 Nov, 2007 1 commit
    • unknown's avatar
      5.0 version of the fix for bug #9481: mysql_insert_id() returns 0 after · 1836b736
      unknown authored
      insert ... select.
      
      The 5.0 manual page for mysql_insert_id() does not mention anything
      about INSERT ... SELECT, though its current behavior is incosistent
      with what the manual says about the plain INSERT.
      
      Fixed by changing the AUTO_INCREMENT and mysql_insert_id() handling
      logic in INSERT ... SELECT to be consistent with the INSERT behavior,
      the manual, and the changes in 5.1 introduced by WL3146:
      
      
      - mysql_insert_id() now returns the first automatically generated
      AUTO_INCREMENT value that was successfully inserted by INSERT ... SELECT
      
      -  if an INSERT ... SELECT statement is executed, and no automatically
      generated value is successfully inserted, mysql_insert_id() now returns
      the ID of the last inserted row.
      
      
      sql/sql_class.h:
        Replaced last_insert_id with autoinc_value_of_last_inserted_row to be
        consistent with 5.1 code.
      sql/sql_insert.cc:
        Revised the AUTO_INCREMENT and mysql_insert_id() handling logic in
        INSERT ... SELECT to be consistent with INSERT behavior, the manual, and
        changes in 5.1 introduced by WL3146:
        
        - mysql_insert_id() now returns the first automatically generated
        AUTO_INCREMENT value that was successfully inserted;
        
        -  if an INSERT ... SELECT statement is executed, and no automatically
        generated value is successfully inserted, mysql_insert_id() now returns
        the ID of the last inserted row.
      tests/mysql_client_test.c:
        Backported the test cases related to INSERT ... SELECT and
        mysql_insert_id() from WL3146 patch to 5.0.
      1836b736
  6. 19 Nov, 2007 1 commit
    • unknown's avatar
      Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT · 4addb6b7
      unknown authored
      led to creating corrupted index.
      
      Corrected fix. The new method called prepare2 is added to the select_create
      class. As all preparations are done by the select_create::prepare function
      it doesn't do anything. Slightly changed algorithm of calling the 
      start_bulk_insert function. Now it's called from the select_insert::prepare2
      function when the SQL_BUFFER_RESULT flags is set.
      The is_bulk_insert_mode flag is removed as it is not needed anymore.
      
      
      sql/sql_class.h:
        Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT
        led to creating corrupted index.
        Corrected fix. The new method called prepare2 is added to the select_create
        class. As all preparetions are done by the select_create::prepare function
        it doesn't do anything.
        The is_bulk_insert_mode flag is removed as it is not needed anymore.
      sql/sql_insert.cc:
        Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT
        led to creating corrupted index. Slightly changed algorithm of calling the
        start_bulk_insert function. Now it's called from the select_insert::prepare2
        function when the SQL_BUFFER_RESULT flags is set.
        Corrected fix. The is_bulk_insert_mode flag is removed as it is not needed
        anymore.
      4addb6b7
  7. 10 Nov, 2007 2 commits
    • unknown's avatar
      bad merge fixed · 38591bca
      unknown authored
      38591bca
    • unknown's avatar
      Bug#31700: thd->examined_row_count not incremented for 'const' type queries · a41b4763
      unknown authored
      UNIQUE (eq-ref) lookups result in table being considered as a "constant" table.
      Queries that consist of only constant tables are processed in do_select() in a
      special way that doesn't invoke evaluate_join_record(), and therefore doesn't
      increase the counters join->examined_rows and join->thd->row_count.
      
      The patch increases these counters in this special case.
      
      NOTICE:
      This behavior seems to contradict what the documentation says in Sect. 5.11.4:
      "Queries handled by the query cache are not added to the slow query log, nor
      are queries that would not benefit from the presence of an index because the
      table has zero rows or one row."
      
      No test case in 5.0 as issue shows only in slow query log, and other counters
      can give subtly different values (with regard to counting in create_sort_index(),
      synthetic rows in ROLLUP, etc.).
      
      
      sql/sql_class.h:
        add documentation for some variables
      sql/sql_select.cc:
        Don't forget const tables when counting read records!
      a41b4763
  8. 31 Oct, 2007 1 commit
    • unknown's avatar
      Cleanup: rename select_send::status to select_send::is_result_set_started. · 9ad4366b
      unknown authored
      Add select_send::cleanup.
      Fix a compilation warning.
      Issues spotted while working on the fix for Bug#12713.
      
      
      sql-common/client.c:
        Fix a warning.
      sql/sql_class.cc:
        Give a variable a more specific name. Rewrite an incorrect comment.
        Add a cleanup for select_send. The only case now this cleanup can be
        necessary is when we have a prepared statement inside a stored procedure, 
        and a continue handler. At first execution, the statement is killed
        after having executed select_send::send_fields. At the second execution
        it is killed after having executed select_send::send_fields.
      sql/sql_class.h:
        Rename a member. Add comments.
      9ad4366b
  9. 30 Oct, 2007 2 commits
    • unknown's avatar
      In ha_delete_table, use a standard mechanism to intercept the error message · 8365a74e
      unknown authored
      and convert it to a warning instead of direct manipulation with the
      thread error stack.
      Fix a bug in handler::print_erorr when a garbled message was
      printed for HA_ERR_NO_SUCH_TABLE.
      This is a pre-requisite patch for the fix for Bug#12713 Error in a stored
      function called from a SELECT doesn't cause ROLLBACK of statem
      
      
      sql/handler.cc:
        Use a standard mechanism to intercept the error message, instead
        of direct manipulation with thread error stack. 
        Fix a bug when for HA_ERR_NO_SUCH_TABLE handler::print_error() would
        print a garbled message.
      sql/log.cc:
        Extend internal error handler interface to carry the message text.
      sql/mysqld.cc:
        Extend internal error handler interface to carry the message text.
      sql/sql_base.cc:
        Extend internal error handler interface to carry the message text.
      sql/sql_class.cc:
        Extend internal error handler interface to carry the message text.
      sql/sql_class.h:
        Extend internal error handler interface to carry the message text.
      sql/sql_error.cc:
        Extend internal error handler interface to carry the message text.
      8365a74e
    • 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
  10. 25 Oct, 2007 1 commit
    • unknown's avatar
      WL#4078: Document binary format of binlog entries · f8f8c028
      unknown authored
      Documented some binlog events using doxygen. More will be done later.
      Also fixed typos in other comments and added remarks about dubious code.
      Only comments are affected, there is no change to the actual code.
      
      
      sql/log_event.cc:
        Fixed typos in some comments.
        Added remarks (as comments) about questionable code.
      sql/log_event.h:
        Documented the binary format of following binlog events:
        Log_event
        Query_log_event
        Muted_query_log_event
        Slave_log_event (partial)
        Load_log_event
        Intvar_log_event
        Rand_log_event
        Rotate_log_event (partial)
      sql/sql_class.h:
        Fixed typo in comment.
      f8f8c028
  11. 23 Oct, 2007 1 commit
    • unknown's avatar
      Fixed bug #31663: if the FIELDS TERMINATED BY string · bcc62784
      unknown authored
      in the SELECT INTO OUTFILE clause starts with a special
      character (one of n, t, r, b, 0, Z or N) and ENCLOSED BY
      is empty, every occurrence of this character within a
      field value is duplicated.
      
      Duplication has been avoided.
      New warning message has been added: "First character of
      the FIELDS TERMINATED string is ambiguous; please use
      non-optional and non-empty FIELDS ENCLOSED BY".
      
      
      mysql-test/r/outfile_loaddata.result:
        BitKeeper file /home/uchum/work/bk/5.0-opt-31663/mysql-test/r/outfile_loaddata.result
        Added test case for bug #31663.
      mysql-test/t/outfile_loaddata.test:
        BitKeeper file /home/uchum/work/bk/5.0-opt-31663/mysql-test/t/outfile_loaddata.test
        Added test case for bug #31663.
      sql/sql_class.h:
        Fixed bug #31663.
        The select_export::is_ambiguous_field_term field has been added.
        This field is true if select_export::field_sep_char contains
        the first char of the FIELDS TERMINATED BY (ENCLOSED BY is empty),
        and items can contain this character.
        The select_export::field_term_char field has been added (first
        char of the FIELDS TERMINATED BY string or INT_MAX).
      sql/sql_class.cc:
        Fixed bug #31663.
        The select_export::prepare method has been modified to calculate
        a value of the select_export::is_ambiguous_field_term field and
        to warn if this value is true.
        The select_export::send_data method has been modified to
        avoid escaping or duplication of the field_set_char if
        is_ambiguous_field_term is true.
      sql/share/errmsg.txt:
        Fixed bug #31663.
        The ER_AMBIGUOUS_FIELD_TERM warning has been added.
      bcc62784
  12. 19 Oct, 2007 1 commit
    • unknown's avatar
      Rename: query_error -> is_slave_error. · 079ae230
      unknown authored
      Add comments.
      
      
      sql/ha_ndbcluster_binlog.cc:
        query_error -> slave_error
      sql/handler.cc:
        query_error -> slave_error
      sql/log.cc:
        query_error -> slave_error
      sql/log_event.cc:
        query_error -> slave_error
      sql/log_event_old.cc:
        query_error -> slave_error
      sql/mysqld.cc:
        query_error -> slave_error
      sql/protocol.cc:
        query_error -> slave_error
      sql/slave.cc:
        query_error -> slave_error
      sql/sp_head.cc:
        query_error -> slave_error
      sql/sql_class.cc:
        query_error -> slave_error
      sql/sql_class.h:
        Rename: query_error -> is_slave_error, to avoid confusion.
        Add commenta.
      sql/sql_connect.cc:
        Rename: query_error -> is_slave_error, to avoid confusion.
        Originally it was the same code to handle init-connect and init-slave 
        mysqld options. Then init-connect implementation forked off,
        but the one who copy-pasted the code didn't change it to not
        use a replication-specific variable.
      079ae230
  13. 16 Oct, 2007 1 commit
  14. 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
  15. 03 Oct, 2007 1 commit
    • unknown's avatar
      BUG#30752 rpl_dual_pos_advance valgrind (jump depends on uninitialized LOG_INFO) · 42cea00e
      unknown authored
      Problem: one thread could read uninitialized memory from (the stack of) another
      thread.
      Fix: swapped order of initializing the memory and making it available to the
      other thread.
      Fix: put lock around the statement that makes the memory available to the other
      thread.
      Fix: all fields of the struct are now initialized in the constructor, to avoid
      future problems.
      
      
      sql/sql_class.h:
        Initialize all members in constructor for more safe future code.
      sql/sql_repl.cc:
        Swap order so that linfo is first initialized, then assigned, instead of the
        other way around.
        Put a lock around the assignment. We use LOCK_thread_count since log_in_use
        uses it: log_in_use may be running concurrently, called from
        MYSQL_LOG::purge_logs.
      42cea00e
  16. 28 Sep, 2007 1 commit
  17. 21 Sep, 2007 1 commit
    • unknown's avatar
      Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT · f7f10959
      unknown authored
      led to creating corrupted index.
      
      While execution of the  CREATE .. SELECT SQL_BUFFER_RESULT statement the 
      engine->start_bulk_insert function was called twice. On the first call
      On the first call MyISAM disabled all non-unique indexes and on the second
      call it decides to not re-enable them because all indexes was disabled.
      Due to this no indexes was actually created during CREATE TABLE thus
      producing crashed table.
      
      Now the select_inset class has is_bulk_insert_mode flag which prevents
      calling the start_bulk_insert function twice.
      The flag is set in the select_create::prepare, select_insert::prepare2
      functions and the select_insert class constructor.
      The flag is reset in the select_insert::send_eof function.
      
      
      mysql-test/t/insert_select.test:
        A test case is added for the bug#30384: Having SQL_BUFFER_RESULT option in the
        CREATE .. KEY(..) .. SELECT led to creating corrupted index.
      mysql-test/r/insert_select.result:
        A test case is added for the bug#30384: Having SQL_BUFFER_RESULT option in the 
        CREATE .. KEY(..) .. SELECT led to creating corrupted index.
      sql/sql_class.h:
        Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT
        led to creating corrupted index.
        The is_bulk_insert_mode flag is added to the select_insert class.
      sql/sql_insert.cc:
        Bug#30384: Having SQL_BUFFER_RESULT option in the CREATE .. KEY(..) .. SELECT
        led to creating corrupted index.
        The is_bulk_insert_mode is set in the select_create::prepare, select_insert::prepare2
        functions and the select_insert class constructor.
        The flag is reset in the select_insert::send_eof function.
      f7f10959
  18. 31 Aug, 2007 1 commit
    • unknown's avatar
      Fix for BUG#25843: changing default database between PREPARE and EXECUTE · 7e0ad09e
      unknown authored
      of statement breaks binlog.
      
      There were two problems discovered by this bug:
      
        1. Default (current) database is not fixed at the creation time.
           That leads to wrong output of DATABASE() function.
      
        2. Database attributes (@@collation_database) are not fixed at
           the creation time. That leads to wrong resultset.
      
      Binlog breakage and Query Cache wrong output happened because of
      the first problem.
      
      The fix is to remember the current database at the PREPARE-time and
      set it each time at EXECUTE.
      
      
      mysql-test/include/query_cache_sql_prepare.inc:
        The first part of the test case for BUG#25843.
      mysql-test/r/query_cache_ps_no_prot.result:
        Update result file.
      mysql-test/r/query_cache_ps_ps_prot.result:
        Update result file.
      mysql-test/suite/rpl/r/rpl_ps.result:
        Update result file.
      mysql-test/suite/rpl/t/rpl_ps.test:
        The second part of the test case for BUG#25843.
      sql/mysql_priv.h:
        Added mysql_opt_change_db() prototype.
      sql/sp.cc:
        1. Polishing;
        2. sp_use_new_db() has been removed;
        3. Use mysql_opt_change_db() instead of sp_use_new_db().
      sql/sp.h:
        sp_use_new_db() has been removed.
        This function has nothing to do with a) sp and b) *new* database.
        It was merely "switch the current database if needed".
      sql/sp_head.cc:
        1. Polishing.
        2. Use mysql_opt_change_db() instead of sp_use_new_db().
      sql/sql_class.cc:
        Move THD::{db, db_length} into Statement.
      sql/sql_class.h:
        Move THD::{db, db_length} into Statement.
      sql/sql_db.cc:
        Introduce mysql_opt_change_db() as a replacement (and inspired by)
        sp_use_new_db().
      sql/sql_prepare.cc:
        1. Remember the current database in Prepared_statement::prepare().
        2. Switch/restore the current database in Prepared_statement::execute().
      7e0ad09e
  19. 30 Aug, 2007 1 commit
    • unknown's avatar
      Cleanup-patch for BUG#25843: changing default database between · 3edb6301
      unknown authored
      PREPARE and EXECUTE of statement breaks binlog.
      
      
      sql/sp.cc:
        - Polishing sp_use_new_db():
          - renamed no_access_check to force_switch to be more adequate;
          - fixed comment;
      sql/sql_class.h:
        Polishing: fixed comment.
      sql/sql_db.cc:
        1. Use mysql_change_db_impl() to reset current database instead of
        THD::set_db() in mysql_rm_db(). THD::set_db() does not take care of
        THD::db_access and database attributes (@@collation_database).
        2. Polishing: add, fix comments.
      3edb6301
  20. 16 Aug, 2007 1 commit
    • unknown's avatar
      Renaming RELAY_LOG_INFO and st_relay_log_info to follow coding standards · 044a4a3e
      unknown authored
      (and be more friendly to Doxygen by removing unnecessary typedefs).
      
      
      sql/log.cc:
        Renaming struct st_relay_log_info to class Relay_log_info.
      sql/log.h:
        Renaming struct st_relay_log_info to class Relay_log_info.
      sql/log_event.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/log_event.h:
        Renaming struct st_relay_log_info to class Relay_log_info.
        Renaming RELAY_LOG_INFO to Relay_log_info.
        Removing typedef RELAY_LOG_INFO.
      sql/log_event_old.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/log_event_old.h:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_mi.h:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_record.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_record.h:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_record_old.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_record_old.h:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_rli.cc:
        Renaming struct st_relay_log_info to class Relay_log_info.
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_rli.h:
        Renaming struct st_relay_log_info to class Relay_log_info.
        Renaming RELAY_LOG_INFO to Relay_log_info.
        Removing typedef RELAY_LOG_INFO.
      sql/rpl_utility.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/rpl_utility.h:
        Renaming struct st_relay_log_info to class Relay_log_info.
        Renaming RELAY_LOG_INFO to Relay_log_info.
        Removing typedef RELAY_LOG_INFO.
      sql/slave.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/slave.h:
        Renaming struct st_relay_log_info to class Relay_log_info.
        Renaming RELAY_LOG_INFO to Relay_log_info.
        Removing typedef RELAY_LOG_INFO.
      sql/sql_binlog.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      sql/sql_class.h:
        Renaming struct st_relay_log_info to class Relay_log_info.
        Renaming RELAY_LOG_INFO to Relay_log_info.
        Removing typedef RELAY_LOG_INFO.
      sql/sql_repl.cc:
        Renaming RELAY_LOG_INFO to Relay_log_info.
      044a4a3e
  21. 13 Aug, 2007 1 commit
    • unknown's avatar
      Fixed a lot of compiler warnings and errors detected by Forte C++ on Solaris · 09a53f28
      unknown authored
      Faster thr_alarm()
      Added 'Opened_files' status variable to track calls to my_open()
      Don't give warnings when running mysql_install_db
      Added option --source-install to mysql_install_db
      
      I had to do the following renames() as used polymorphism didn't work with Forte compiler on 64 bit systems
      index_read()      -> index_read_map()
      index_read_idx()  -> index_read_idx_map()
      index_read_last() -> index_read_last_map()
      
      
      BUILD/compile-solaris-sparc-forte:
        Updated script to current Solaris installations
        Now we compile by default for 64 bits
      client/mysql.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      client/mysql_upgrade.c:
        Fixed compiler warning (on Forte)
      client/mysqladmin.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      client/mysqlcheck.c:
        Fixed compiler warning (on Forte)
      client/mysqldump.c:
        Fixed compiler warning (on Forte)
      client/mysqlslap.c:
        Fixed compiler warning (on Forte)
      client/mysqltest.c:
        Fixed compiler warning (on Forte)
      client/sql_string.cc:
        Avoid compiler warnings when using C function pointers in C++
      configure.in:
        Added detection of mtmalloc and ieeefp.h
      extra/replace.c:
        Fixed compiler warning (on Forte)
      include/m_ctype.h:
        Added some typedef's to make it easy to use C function pointers in C++
      include/my_sys.h:
        Added my_file_total_opened (counter for calls to my_open())
      include/myisam.h:
        Fixed compiler warning (on Forte)
      libmysql/libmysql.c:
        Fixed compiler warning (on Forte) by adding casts and change types
      libmysql/manager.c:
        Fixed compiler warning (on Forte) by adding casts and change types
      mysql-test/r/ctype_cp932_binlog_stm.result:
        Updated positions
        (Needed because we didn't before correctly restore collation_database after running stored procedure
      mysys/my_fopen.c:
        Count number of opened files
      mysys/my_open.c:
        Count number of opened files
      mysys/my_static.c:
        Count number of opened files
      mysys/thr_alarm.c:
        Optimization to do less alarm() and pthread_sigmask() calls.
        Idea is to remember time for next pending alarm and not reschedule a new alarm if it's after the current one.
        Before we only did this if there was other pending alarms.
        We don't have to use pthread_sigmask() in case of 'USE_ONE_SIGNAL_HAND' as the alarm()
        signal will be blocked for the calling thread anyway and no other thread will have the alarm() signal enabled to call process_alarm()
      regex/regcomp.c:
        Fixed compiler warning (on Forte) by adding casts and change types
      scripts/mysql_install_db.sh:
        Added option --source-install to allow one to create a mysql database from the source tree without installing MySQL
        Don't give (unnecessary) warnings
      server-tools/instance-manager/angel.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      server-tools/instance-manager/thread_registry.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/event_db_repository.cc:
        index_read() -> index_read_map()
      sql/event_queue.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/field.cc:
        Fixed compiler warnings about hidden fields
      sql/ha_partition.cc:
        Fixed compiler warnings about hidden fields
        index_read() -> index_read_map()
      sql/ha_partition.h:
        index_read() -> index_read_map()
      sql/handler.cc:
        Added PAGE option to row types (to prepare for future)
        index_read() -> index_read_map()
      sql/handler.h:
        Added ROW_TYPE_PAGE (for future)
        Added flag to signal if table was to be created transactionally
        I had to do the following renames() as used polymorphism didn't work with Forte compiler on 64 bit systems
        index_read()      -> index_read_map()
        index_read_idx()  -> index_read_idx_map()
        index_read_last() -> index_read_last_map()
      sql/item.cc:
        Fixed indentation
        Renamed local variable to avoid hiding class variable
      sql/item_cmpfunc.cc:
        Renamed local variable to avoid hiding class variable
      sql/item_cmpfunc.h:
        Removed not used variable
      sql/item_func.cc:
        Renamed local variable to avoid hiding class variable
      sql/item_strfunc.cc:
        Moved functions from Item_strfunc.cc
      sql/item_strfunc.h:
        Move functions to item_strfunc.cc
        Use C function pointer type to avoid compiler warnings (with Forte)
      sql/item_subselect.cc:
        index_read() -> index_read_map()
      sql/item_xmlfunc.cc:
        Renamed local variable to avoid hiding class variable
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/key.cc:
        Fixed indentation
      sql/log.cc:
        Renamed local variable to avoid hiding class variable
      sql/log_event.cc:
        Removed call to my_time() when creating class instance of Log_event() as this may have static instances.
        (One can't call my_time() before my_init())
        index_read() -> index_read_map()
        Renamed local variable to avoid hiding class variable
      sql/log_event_old.cc:
        Renamed local variable to avoid hiding class variable
      sql/mysql_priv.h:
        Made all create_backup_ctx() declarations identical.
        This lifted up a bug where wrong create_backup_ctx() was called in some cases.
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/mysqld.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
        Fixed indentation
        Don't call end_thr_alarm() when calling unireg_abort() as unireg_abort() already calls end_thr_alarm()
        Added variable 'Opened_files' (number of calls to my_open() or my_fopen())
        Don't print 'loose' warnings when using --bootstrap (to avoid warnings when running mysql_install_db)
        Fixed compiler warnings
      sql/opt_range.cc:
        index_read() -> index_read_map()
      sql/opt_sum.cc:
        index_read() -> index_read_map()
      sql/partition_info.cc:
        Renamed local variable to avoid hiding class variable
      sql/rpl_filter.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/set_var.cc:
        Renamed local variable to avoid hiding class variable
        Added 'process_key_cache_t' type to avoid compiler warning (on Forte)
      sql/set_var.h:
        Added 'process_key_cache_t' type to avoid compiler warning (on Forte)
      sql/sp.cc:
        More debugging
        index_read() -> index_read_map()
      sql/sp_cache.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/sp_head.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
        Moved 'saved_creation_ctx' higher up to be able to free objects allocated by create_backup_ctx()
      sql/sql_acl.cc:
        index_read() -> index_read_map()
      sql/sql_class.cc:
        Renamed local variable to avoid hiding class variable
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/sql_class.h:
        Renamed local variable to avoid hiding class variable
      sql/sql_db.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      sql/sql_delete.cc:
        Renamed local variable to avoid hiding class variable
      sql/sql_handler.cc:
        index_read() -> index_read_map()
      sql/sql_help.cc:
        index_read() -> index_read_map()
      sql/sql_insert.cc:
        index_read() -> index_read_map()
        Renamed local variable to avoid hiding class variable
      sql/sql_lex.cc:
        Renamed local variable to avoid hiding class variable
      sql/sql_plugin.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
        index_read() -> index_read_map()
        Don't give warnings about not used plugins if we are using --warnings=0
      sql/sql_select.cc:
        index_read() -> index_read_map()
      sql-common/client.c:
        Fixed compiler warning (on Forte)
      sql-common/my_time.c:
        Removed never accessed code
        Fixed compiler warning (on Forte)
      sql/sql_servers.cc:
        index_read() -> index_read_map()
      sql/sql_show.cc:
        Added TRANSACTIONAL to SHOW CREATE
        Fixed ROW_TYPE_PAGE
      sql/sql_string.cc:
        Avoid compiler warnings when using C function pointers in C++
      sql/sql_table.cc:
        Set create_info->transactional if we used TRANSACTIONAL=1
      sql/sql_udf.cc:
        index_read() -> index_read_map()
      sql/sql_yacc.yy:
        Added TRANSACTIONAL=0|1 to CREATE (for future)
        Added row type PAGE (was only partionally handled before)
      sql/strfunc.cc:
        Avoid compiler warnings when using C function pointers in C++
      sql/table.cc:
        More DBUG statements
        Declare all create_backup_ctx() functions identically
        Remember if table was created with TRANSACTIONAL flag or not (future safe)
        Renamed local variable to avoid hiding class variable
      sql/table.h:
        Remember if table was created with TRANSACTIONAL=1
      sql/tztime.cc:
        index_read() -> index_read_map()
      sql-common/pack.c:
        Fixed compiler warning (on Forte)
      storage/archive/archive_reader.c:
        Fixed compiler warning (on Forte)
      storage/archive/azio.c:
        Fixed compiler warning (on Forte)
      storage/blackhole/ha_blackhole.cc:
        index_read() -> index_read_map()
      storage/blackhole/ha_blackhole.h:
        index_read() -> index_read_map()
      storage/csv/ha_tina.cc:
        Declare functions sent to C code with extern "C" to avoid compiler warnings (on Forte)
      storage/example/ha_example.cc:
        index_read() -> index_read_map()
      storage/example/ha_example.h:
        index_read() -> index_read_map()
      storage/heap/ha_heap.cc:
        index_read() -> index_read_map()
      storage/heap/ha_heap.h:
        index_read() -> index_read_map()
      storage/heap/hp_test1.c:
        Fixed compiler warning (on Forte)
      storage/heap/hp_test2.c:
        Fixed compiler warning (on Forte)
      storage/myisam/ft_boolean_search.c:
        Fixed compiler warning (on Forte)
      storage/myisam/ft_nlq_search.c:
        Fixed compiler warning (on Forte)
      storage/myisam/ft_parser.c:
        Fixed compiler warning (on Forte)
      storage/myisam/ft_stopwords.c:
        Fixed compiler warning (on Forte)
      storage/myisam/ha_myisam.cc:
        index_read() -> index_read_map()
      storage/myisam/ha_myisam.h:
        index_read() -> index_read_map()
      storage/myisam/mi_check.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_delete.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_dynrec.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_extra.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_key.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_keycache.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_locking.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_log.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_open.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_packrec.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_page.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_rkey.c:
        Added comment
      storage/myisam/mi_search.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_statrec.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_test1.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_test2.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_test3.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_update.c:
        Fixed compiler warning (on Forte)
      storage/myisam/mi_write.c:
        Fixed compiler warning (on Forte)
      storage/myisam/myisamdef.h:
        Fixed that file_read/file_write returns type size_t
        Changed some functions to use uchar * as argument/return value instead of char*
        This fixed some compiler warnings on Forte
      storage/myisam/myisamlog.c:
        Fixed compiler warning (on Forte)
      storage/myisam/myisampack.c:
        Fixed compiler warning (on Forte)
      storage/myisam/rt_test.c:
        Fixed compiler warning (on Forte)
      storage/myisam/sort.c:
        Fixed compiler warning (on Forte) by adding casts or changing variables to uchar*
      storage/myisam/sp_test.c:
        Fixed compiler warning (on Forte) by adding casts or changing variables to uchar*
      storage/myisammrg/ha_myisammrg.cc:
        index_read() -> index_read_map()
      storage/myisammrg/ha_myisammrg.h:
        index_read() -> index_read_map()
      storage/myisammrg/myrg_create.c:
        Fixed compiler warning (on Forte) by adding casts or changing variable types
      storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp:
        Tdummy -> align  (as in other part of cluster code)
      storage/ndb/src/kernel/vm/DynArr256.cpp:
        Removed not used variable
      storage/ndb/src/ndbapi/Ndb.cpp:
        Removed not used variable
      strings/strtod.c:
        Include ieeefp.h to avoid compiler warning
      tests/bug25714.c:
        Fixed compiler warning
      tests/mysql_client_test.c:
        Remove not used variable
        Fixed indentation
        Removed never reached code
        Fixed compiler warning (on Forte) by adding casts or changing variable types
      vio/viosocket.c:
        Fixed compiler warning (on Forte) by adding casts or changing variable types
      09a53f28
  22. 02 Aug, 2007 1 commit
    • unknown's avatar
      sql_class.h: · d24df2c6
      unknown authored
        After merge changes.
      
      
      sql/sql_class.h:
        After merge changes.
      d24df2c6
  23. 01 Aug, 2007 2 commits
    • unknown's avatar
      After-merge fixup. · be4cfe50
      unknown authored
        - THD::tmp_table_used removed, THD::thread_specific_used used instead.
      
      
      be4cfe50
    • unknown's avatar
      Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect · f87acb59
      unknown authored
      restores from mysqlbinlog out
      
      Problem: using "mysqlbinlog | mysql" for recoveries the connection_id() 
      result may differ from what was used when issuing the statement.
      
      Fix: if there is a connection_id() in a statement, write to binlog
      SET pseudo_thread_id= XXX; before it and use the value later on.
      
      
      mysql-test/r/mysqlbinlog.result:
        Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect 
        restores from mysqlbinlog out
          - test result.
      mysql-test/t/mysqlbinlog.test:
        Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect 
        restores from mysqlbinlog out
          - test case.
      sql/item_create.cc:
        Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect 
        restores from mysqlbinlog out
          - set thread_specific_used flag for the connection_id() function.
      sql/item_func.cc:
        Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect 
        restores from mysqlbinlog out
          - always return thd->variables.pseudo_thread_id as a connection_id() 
        result, as it contains a proper value for both master and slave.
      sql/log_event.cc:
        Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect 
        restores from mysqlbinlog out
          - set LOG_EVENT_THREAD_SPECIFIC_F event flag if thread_specific_used
        is set.
      sql/sql_class.cc:
        Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect 
        restores from mysqlbinlog out
          - thd->thread_specific_used introduced, which is set if thread specific 
        value(s) used in a statement.
      sql/sql_class.h:
        Fix for bug #29928: INSERT ... VALUES(connection_id(), ...) incorrect 
        restores from mysqlbinlog out
          - thd->thread_specific_used introduced, which is set if thread specific 
        value(s) used in a statement.
      f87acb59
  24. 30 Jul, 2007 3 commits
    • 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
    • unknown's avatar
      Bug#24989: The DEADLOCK error is improperly handled by InnoDB. · 9246c372
      unknown authored
      When innodb detects a deadlock it calls ha_rollback_trans() to rollback the 
      main transaction. But such action isn't allowed from inside of triggers and
      functions. When it happen the 'Explicit or implicit commit' error is thrown
      even if there is no commit/rollback statements in the trigger/function. This
      leads to the user confusion.
      
      Now the convert_error_code_to_mysql() function doesn't call the 
      ha_rollback_trans() function directly but rather calls the
      mark_transaction_to_rollback function and returns an error.
      The sp_rcontext::find_handler() now doesn't allow errors to be caught by the
      trigger/function error handlers when the thd->is_fatal_sub_stmt_error flag
      is set. Procedures are still allowed to catch such errors.
      The sp_rcontext::find_handler function now accepts a THD handle as a parameter.
      The transaction_rollback_request and the is_fatal_sub_stmt_error flags are 
      added to the THD class. The are initialized by the THD class constructor.
      Now the ha_autocommit_or_rollback function rolls back main transaction
      when not in a sub statement and the thd->transaction_rollback_request
      is set.
      The THD::restore_sub_statement_state function now resets the 
      thd->is_fatal_sub_stmt_error flag on exit from a sub-statement.
      
      
      sql/ha_innodb.cc:
        Bug#24989: The DEADLOCK error is improperly handled by InnoDB.
        Now the convert_error_code_to_mysql() function doesn't call the
        ha_rollback_trans() function directly but rather calls the
        mark_transaction_to_rollback function and returns an error.
      sql/handler.cc:
        Bug#24989: The DEADLOCK error is improperly handled by InnoDB.
        Now the ha_autocommit_or_rollback function rolls back main transaction
        when not in a sub statement and the thd->transaction_rollback_request
        is set.
      mysql-test/r/innodb-big.result:
        Added a test case for the bug#24989: The DEADLOCK error is improperly handled by
        InnoDB.
      mysql-test/t/innodb-big.test:
        Added a test case for the bug#24989: The DEADLOCK error is improperly handled by
        InnoDB.
      sql/sql_class.h:
        Bug#24989: The DEADLOCK error is improperly handled by InnoDB.
        The transaction_rollback_request and the is_fatal_sub_stmt_error flags are 
        added to the THD class.
      sql/sql_class.cc:
        Bug#24989: The DEADLOCK error is improperly handled by InnoDB.
        Initialization of the transaction_rollback_request and the
        is_fatal_sub_stmt_error flags are added to the THD class constructor.
        The mark_transaction_to_rollback function is added.
        The THD::restore_sub_statement_state function now resets the
        thd->is_fatal_sub_stmt_error flag on exit from a sub-statement.
      sql/sp_rcontext.h:
        Bug#24989: The DEADLOCK error is improperly handled by InnoDB.
        The sp_rcontext::find_handler function now accepts a THD handle as a parameter.
        The in_sub_stmt flag is added to the sp_rcontext class.
      sql/sp_rcontext.cc:
        Bug#24989: The DEADLOCK error is improperly handled by InnoDB.
        The sp_rcontext::find_handler() now doesn't allow errors to be caught by the
        trigger/function error handlers when the thd->is_fatal_sub_stmt_error flag
        is set. Instead it tries to find a most inner procedure that isn't called
        directly or indirectly from any function/trigger.
        Procedures are still allowed to catch such errors.
        The sp_rcontext::find_handler function now accepts a THD handle as a parameter.
      9246c372
    • unknown's avatar
      Slow query log to file now displays queries with microsecond precission · b59217eb
      unknown authored
      --long-query-time is now given in seconds with microseconds as decimals
      --min_examined_row_limit added for slow query log
      long_query_time user variable is now double with 6 decimals
      Added functions to get time in microseconds
      Added faster time() functions for system that has gethrtime()  (Solaris)
      We now do less time() calls.
      Added field->in_read_set() and field->in_write_set() for easier field manipulation by handlers
      set_var.cc and my_getopt() can now handle DOUBLE variables.
      All time() calls changed to my_time()
      my_time() now does retry's if time() call fails.
      Added debug function for stopping in mysql_admin_table() when tables are locked
      Some trivial function and struct variable renames to avoid merge errors.
      Fixed compiler warnings
      Initialization of some time variables on windows moved to my_init() 
      
      
      include/my_getopt.h:
        Added support for double arguments
      include/my_sys.h:
        Fixed wrong type to packfrm()
        Added new my_time functions
      include/mysql/plugin.h:
        Added support for DOUBLE
      libmysql/CMakeLists.txt:
        Added new time functions
      libmysql/Makefile.shared:
        Added new time functions
      mysql-test/r/variables.result:
        Testing of long_query_time
      mysql-test/t/variables.test:
        Testing of long_query_time
      mysys/charset.c:
        Fixed compiler warnings
      mysys/default_modify.c:
        Fixed compiler warnings
      mysys/hash.c:
        Fixed compiler warnings
      mysys/mf_getdate.c:
        Use my_time()
      mysys/mf_iocache2.c:
        Fixed compiler warnings
      mysys/mf_pack.c:
        Fixed compiler warnings
      mysys/mf_path.c:
        Fixed compiler warnings
      mysys/my_append.c:
        Fixed compiler warnings
      mysys/my_compress.c:
        Fixed compiler warnings
      mysys/my_copy.c:
        Fixed compiler warnings
      mysys/my_gethwaddr.c:
        Fixed compiler warnings
      mysys/my_getopt.c:
        Added support for double arguments
      mysys/my_getsystime.c:
        Added functions to get time in microseconds.
        Added faster time() functions for system that has gethrtime()  (Solaris)
        Moved windows initialization code to my_init()
      mysys/my_init.c:
        Added initializing of variables needed for windows time functions
      mysys/my_static.c:
        Added variables needed for windows time functions
      mysys/my_static.h:
        Added variables needed for windows time functions
      mysys/my_thr_init.c:
        Added THR_LOCK_time, used for faster my_time()
      mysys/mysys_priv.h:
        Added THR_LOCK_time, used for faster my_time()
      mysys/thr_alarm.c:
        time() -> my_time()
      sql/event_data_objects.cc:
        end_time() -> set_current_time()
      sql/event_queue.cc:
        end_time() -> set_current_time()
      sql/event_scheduler.cc:
        Fixed compiler warnings
      sql/field.h:
        Added field->in_read_set() and field->in_write_set() for easier field manipulation by handlers
      sql/item.h:
        Added decimal to Item_float(double)
      sql/item_cmpfunc.h:
        Added decimal to Item_float(double)
      sql/item_timefunc.cc:
        time() -> my_time()
      sql/item_xmlfunc.cc:
        Fixed compiler warning
      sql/lock.cc:
        lock_time() -> set_time_after_lock()
      sql/log.cc:
        Timing in slow query log to file is now done in microseconds
        Changed some while() loops to for() loops.
        Fixed indentation
        time() -> my_time()
      sql/log.h:
        Slow query logging is now done based on microseconds
      sql/log_event.cc:
        time() -> my_time()
        Fixed arguments to new Item_float()
      sql/mysql_priv.h:
        Fixed compiler warnings
        Added opt_log_slow_slave_statements
      sql/mysqld.cc:
        Added --log_slow_slave_statements and --min_examined_row_limit
        --long-query-time now takes a double argument with microsecond resolution
        Don't write shutdown message when using --help
        Removed not needed \n
        Thread create time and connect time is now done in microseconds
        time() -> my_time()
        Avoid some time() calls
      sql/net_serv.cc:
        Fixed compiler warnings
      sql/parse_file.cc:
        time() -> my_time()
      sql/set_var.cc:
        Added support for DOUBLE variables
        Added support for variables that are given in seconds with microsecond resolution
      sql/set_var.h:
        Added support for variables that are given in seconds with microsecond resolution
      sql/slave.cc:
        Allow logging of slave queries to slow query log if 'opt_log_slow_slave_statements' is given
        time() -> my_time()
      sql/sql_cache.h:
        Fixed compiler warning()
      sql/sql_class.cc:
        Initialize new THD variables
      sql/sql_class.h:
        long_query_time is now in microseconds
        Added min_examined_row_limit
        Reordered some THD elements for higher efficency
        Added timers in microseconds (connect_utime, thr_create_utime, start_utime and utime_after_lock)
        Start of query is now recorded both in seconds and in microseconds.
        Following renames was made for more clarity and avoid merge problems from earlier versions:
        connect_time -> connect_utime
        thr_create_time -> thr_create_utime
        end_time()  -> set_current_time()
        lock_time() -> set_time_after_lock()
        
        Added THD::start_utime, which is start of query in microseconds from some arbitary time
        Added function THD::current_utime()
        
        Removed safe_time() as retry's are handled in my_time()
      sql/sql_connect.cc:
        User resources are now using microsecond resolution
      sql/sql_insert.cc:
        end_time() -> set_current_time()
      sql-common/client.c:
        time() -> my_time()
      sql/sql_parse.cc:
        Testing if we should print to slow_query_log() is now done with microsecond precission.
        If min_examined_row_limit is given, only log queries to slow query log that has examined more rows than this.
      sql/sql_select.cc:
        Simplify code now that Item_float() takes decimals as argument
      sql/sql_show.cc:
        time() -> my_time()
        Added support for SYS_DOUBLE
      sql/sql_table.cc:
        Added debug function for stopping in mysql_admin_table() when tables are locked
      sql/structs.h:
        intime -> reset_utime
      b59217eb
  25. 27 Jul, 2007 2 commits
    • unknown's avatar
      A fix and a test case for Bug#24918 drop table and lock / inconsistent · 0936976e
      unknown authored
      between perm and temp tables. Review fixes.
      
      The original bug report complains that if we locked a temporary table
      with LOCK TABLES statement, we would not leave LOCK TABLES mode
      when this temporary table is dropped.
      
      Additionally, the bug was escalated when it was discovered than
      when a temporary transactional table that was previously
      locked with LOCK TABLES statement was dropped, futher actions with
      this table, such as UNLOCK TABLES, would lead to a crash.
      
      The problem originates from incomplete support of transactional temporary
      tables. When we added calls to handler::store_lock()/handler::external_lock()
      to operations that work with such tables, we only covered the normal
      server code flow and did not cover LOCK TABLES mode. 
      In LOCK TABLES mode, ::external_lock(LOCK) would sometimes be called without
      matching ::external_lock(UNLOCK), e.g. when a transactional temporary table
      was dropped. Additionally, this table would be left in the list of LOCKed 
      TABLES.
      
      The patch aims to address this inadequacy. Now, whenever an instance
      of 'handler' is destroyed, we assert that it was priorly
      external_lock(UNLOCK)-ed. All the places that violate this assert
      were fixed.
      
      This patch introduces no changes in behavior -- the discrepancy in
      behavior will be fixed when we start calling ::store_lock()/::external_lock()
      for all tables, regardless whether they are transactional or not, 
      temporary or not.
      
      
      mysql-test/r/innodb_mysql.result:
        Update test results (Bug#24918)
      mysql-test/t/innodb_mysql.test:
        Add a test case for Bug#24918
      sql/handler.h:
        Make handler::external_lock() a protected method. Backport from 5.1 its
        public wrapper handler::ha_external_lock().
        Assert that the handler is not closed if it is still locked.
      sql/lock.cc:
        In mysql_lock_tables only call lock_external() for the list of tables that
        we called store_lock() for. 
        E.g. get_lock_data() does not add non-transactional temporary tables to the
        lock list, so lock_external() should not be called for them.
        
        Use handler::ha_external_lock() instead of handler::external_lock().
        
        Add comments for mysql_lock_remove(), parameterize one strange
        side effect that it has. At least in one place where mysql_lock_remove
        is used, this side effect is not desired (DROP TABLE). The parameter
        will be dropped in 5.1, along with the side effect.
      sql/mysql_priv.h:
        Update declaration of mysql_lock_remove().
      sql/opt_range.cc:
        Deploy handler::ha_external_lock() instead of handler::external_lock()
      sql/sql_base.cc:
        When closing a temporary table, remove the table from the list of LOCKed 
        TABLES of this thread, in case it's there. 
        It's there if it is a transactional temporary table.
        Use a new declaration of mysql_lock_remove().
      sql/sql_class.h:
        Extend the comment for THD::temporary_tables.
      sql/sql_table.cc:
        Deploy handler::ha_external_lock() instead of handler::external_lock()
      0936976e
    • unknown's avatar
      WL#3984 (Revise locking of mysql.general_log and mysql.slow_log) · 4462578a
      unknown authored
      Bug#25422 (Hang with log tables)
      Bug 17876 (Truncating mysql.slow_log in a SP after using cursor locks the
                thread)
      Bug 23044 (Warnings on flush of a log table)
      Bug 29129 (Resetting general_log while the GLOBAL READ LOCK is set causes
                 a deadlock)
      
      Prior to this fix, the server would hang when performing concurrent
      ALTER TABLE or TRUNCATE TABLE statements against the LOG TABLES,
      which are mysql.general_log and mysql.slow_log.
      
      The root cause traces to the following code:
      in sql_base.cc, open_table()
        if (table->in_use != thd)
        {
          /* wait_for_condition will unlock LOCK_open for us */
          wait_for_condition(thd, &LOCK_open, &COND_refresh);
        }
      The problem with this code is that the current implementation of the
      LOGGER creates 'fake' THD objects, like
      - Log_to_csv_event_handler::general_log_thd
      - Log_to_csv_event_handler::slow_log_thd
      which are not associated to a real thread running in the server,
      so that waiting for these non-existing threads to release table locks
      cause the dead lock.
      
      In general, the design of Log_to_csv_event_handler does not fit into the
      general architecture of the server, so that the concept of general_log_thd
      and slow_log_thd has to be abandoned:
      - this implementation does not work with table locking
      - it will not work with commands like SHOW PROCESSLIST
      - having the log tables always opened does not integrate well with DDL
      operations / FLUSH TABLES / SET GLOBAL READ_ONLY
      
      With this patch, the fundamental design of the LOGGER has been changed to:
      - always open and close a log table when writing a log
      - remove totally the usage of fake THD objects
      - clarify how locking of log tables is implemented in general.
      
      See WL#3984 for details related to the new locking design.
      
      Additional changes (misc bugs exposed and fixed):
      
      1)
      
      mysqldump which would ignore some tables in dump_all_tables_in_db(),
       but forget to ignore the same in dump_all_views_in_db().
      
      2)
      
      mysqldump would also issue an empty "LOCK TABLE" command when all the tables
      to lock are to be ignored (numrows == 0), instead of not issuing the query.
      
      3)
      
      Internal errors handlers could intercept errors but not warnings
      (see sql_error.cc).
      
      4)
      
      Implementing a nested call to open tables, for the performance schema tables,
      exposed an existing bug in remove_table_from_cache(), which would perform:
        in_use->some_tables_deleted=1;
      against another thread, without any consideration about thread locking.
      This call inside remove_table_from_cache() was not required anyway,
      since calling mysql_lock_abort() takes care of aborting -- cleanly -- threads
      that might hold a lock on a table.
      This line (in_use->some_tables_deleted=1) has been removed.
      
      
      sql/handler.cc:
        Moved logic for system / log tables in the SQL layer.
      sql/handler.h:
        Moved logic for system / log tables in the SQL layer.
      sql/lock.cc:
        Revised locking of log tables
      sql/log.cc:
        Major cleanup: changed how log tables are locked / written to.
      sql/log.h:
        Major cleanup: changed how log tables are locked / written to.
      sql/mysql_priv.h:
        performance schema helpers
      sql/slave.cc:
        open_ltable() lock flags
      sql/sp.cc:
        open_ltable() lock flags
      sql/sql_acl.cc:
        open_ltable() lock flags
      sql/sql_class.h:
        performance schema helpers
      sql/sql_delete.cc:
        log tables cleanup in TRUNCATE
      sql/sql_error.cc:
        Internal handlers can also intercept warnings
      sql/sql_insert.cc:
        open_ltable() lock flags
      sql/sql_parse.cc:
        performance schema helpers
      sql/sql_plugin.cc:
        open_ltable() lock flags
      sql/sql_rename.cc:
        log tables cleanup in RENAME
      sql/sql_servers.cc:
        open_ltable() lock flags
      sql/sql_show.cc:
        Move INFORMATION_SCHEMA_NAME to table.cc
      sql/sql_table.cc:
        log tables cleanup (admin operations, ALTER TABLE)
      sql/sql_udf.cc:
        open_ltable() lock flags
      sql/table.cc:
        Implemented TABLE_CATEGORY.
      sql/share/errmsg.txt:
        Changed the wording and name of ER_CANT_READ_LOCK_LOG_TABLE
      sql/table.h:
        Implemented TABLE_CATEGORY.
      storage/csv/ha_tina.cc:
        Moved logic for system / log tables in the SQL layer.
      storage/csv/ha_tina.h:
        Moved logic for system / log tables in the SQL layer.
      storage/myisam/ha_myisam.cc:
        Moved logic for system / log tables in the SQL layer.
      storage/myisam/ha_myisam.h:
        Moved logic for system / log tables in the SQL layer.
      client/mysqldump.c:
        Don't lock tables in the ignore list.
        Don't issue empty LOCK TABLES queries.
      sql/sql_base.cc:
        log tables cleanup
        performance schema helpers
      mysql-test/r/ps.result:
        Adjust test results
      mysql-test/r/show_check.result:
        Adjust test results
      mysql-test/r/status.result:
        Adjust test results
      mysql-test/t/log_state.test:
        Added tests for Bug#29129
      mysql-test/t/ps.test:
        Make the test output deterministic
      mysql-test/t/show_check.test:
        Make the test output deterministic
      mysql-test/r/log_state.result:
        Changed the default location of the log output to LOG_FILE,
        for backward compatibility with MySQL 5.0
        ---
        Adjust test results
      mysql-test/r/log_tables.result:
        cleanup for -ps-protocol
      mysql-test/t/log_tables.test:
        cleanup for -ps-protocol
      sql/set_var.cc:
        Changed the default location of the log output to LOG_FILE,
        for backward compatibility with MySQL 5.0
        ---
        log tables cleanup
      4462578a
  26. 18 Jul, 2007 1 commit
    • unknown's avatar
      A fix and a test case for Bug#26104 Bug on foreign key class constructor. · c0277a11
      unknown authored
      Fix the typo in the constructor. Cover a semantic check that previously
      never worked with a test.
      
      
      mysql-test/r/create.result:
        Update results (Bug#26104)
      mysql-test/r/innodb.result:
        Update results.
      mysql-test/t/create.test:
        Add a test case for Bug#26104 Bug on foreign key class constructor
      mysql-test/t/innodb.test:
        Return a new error number (MySQL error instead of internal InnoDB error).
      sql/sql_class.h:
        A fix for Bug#26104 Bug on foreign key class constructor -- fix
        the typo in the constructor
      c0277a11
  27. 16 Jul, 2007 1 commit
    • unknown's avatar
      Bug #29692 Single row inserts can incorrectly report a huge number of row insertions · fcc51efc
      unknown authored
      This bug was caused by unitialized value that was the result of a bad 5.0 merge.
      
      
      sql/sql_class.h:
        Readded comments lost in a bad merge.
      sql/sql_insert.cc:
        Fixed code to completely initialize (zero) the "COPY_INFO info" var in the same manner as the delayed write code.
        
        Readded a change that was lost in a bad merge.
      tests/mysql_client_test.c:
        Test case added for bug#29692.
      fcc51efc
  28. 13 Jul, 2007 2 commits
    • unknown's avatar
      A follow up after the patch for Bug#21074 - even though · 31ea7d04
      unknown authored
      we now have exclusive name lock on the table name in mysql_rm_table_part2,
      we still should keep LOCK_open - some storage engines are not
      ready for locking scope change and assume that LOCK_open is kept.
      Still, the binary logging and query cache invalidation calls
      moved out of LOCK_open scope.
      Fixes some of the broken 5.1-runtime tests (tests break on asserts).
      
      
      sql/ha_ndbcluster.cc:
        Do not lock LOCK_open for mysql_rm_table_part2 - it does that
        for us now.
      sql/mysql_priv.h:
        Remove an unused flag.
      sql/sql_class.h:
        Fix an unrelated compiler warning.
      sql/sql_db.cc:
        Adjust to the changed signature.
      sql/sql_table.cc:
        mysql_rm_table_part2: we need to keep LOCK_open while calling
        storage engine functions, even though now 
        we have an exclusive lock on the table name. Some of them assume that it's 
        kept and attempt to unlock it.
      31ea7d04
    • unknown's avatar
      Bug#27198: Error returns from time() are ignored · a7e5f73a
      unknown authored
      gettimeofday() can fail and presumably, so can time().
      Keep an eye on it.
      
      Since we have no data on this at all so far, we just
      retry on failure (and log the event), assuming that
      this is just an intermittant failure. This might of
      course hang the threat until we succeed. Once we know
      more about these failures, an appropriate more clever
      scheme may be picked (only try so many times per thread,
      etc., if that fails, return last "good" time() we got or
      some such).  Using sql_print_information() to log as this
      probably only occurs in high load scenarios where the debug-
      trace likely is disabled (or might interfere with testing
      the effect).  No test-case as this is a non-deterministic
      issue.
      
      
      sql/mysql_priv.h:
        Bug#27198: Error returns from time() are ignored
        
        move declarations for log.cc to before inclusion of
        sql_class.h as we now use sql_print_information() in
        there.
      sql/sql_class.h:
        Bug#27198: Error returns from time() are ignored
        
        gettimeofday() can fail and presumably, so can time().
        Keep an eye on it.
      a7e5f73a