An error occurred fetching the project authors.
  1. 01 Apr, 2010 1 commit
    • Davi Arnaut's avatar
      Bug#50755: Crash if stored routine def contains version comments · 7ecad98c
      Davi Arnaut authored
      The problem was that a syntactically invalid trigger could cause
      the server to crash when trying to list triggers. The crash would
      happen due to a mishap in the backup/restore procedure that should
      protect parser items which are not associated with the trigger. The
      backup/restore is used to isolate the parse tree (and context) of
      a statement from the load (and parsing) of a trigger. In this case,
      a error during the parsing of a trigger could cause the improper
      backup/restore sequence.
      
      The solution is to properly restore the original statement context
      before the parser is exited due to syntax errors in the trigger body.
      
      mysql-test/r/trigger.result:
        Add test case result for Bug#50755
      mysql-test/t/trigger.test:
        Add test case for Bug#50755
      sql/sp_head.cc:
        Merge sp_head::destroy() and sp_head destructor. Retrieve THD
        from the LEX so that m_thd is not necessary.
      sql/sql_lex.cc:
        Explicitly restore the original environment.
      7ecad98c
  2. 29 Mar, 2010 1 commit
    • Tatiana A. Nurnberg's avatar
      Bug#48525: trigger changes "Column 'id' cannot be null" behaviour · 28e95ba5
      Tatiana A. Nurnberg authored
      CHECK_FIELD_IGNORE was treated as CHECK_FIELD_ERROR_FOR_NULL;
      UPDATE...SET...NULL on NOT NULL fields behaved differently after
      a trigger.
      
      Now distinguishes between IGNORE and ERROR_FOR_NULL and save/restores
      check-field options.
      
      
      mysql-test/r/trigger.result:
        Show that UPDATE...SET...NULL on NOT NULL columns doesn't behave differently
        when run after a trigger.
      mysql-test/t/trigger.test:
        Show that UPDATE...SET...NULL on NOT NULL columns doesn't behave differently
        when run after a trigger.
      sql/field_conv.cc:
        CHECK_FIELD_IGNORE was treated as CHECK_FIELD_ERROR_FOR_NULL.
        Distinguish between the two.
      sql/sp_head.cc:
        Raise error as needed.
      sql/sql_class.cc:
        Save and restore check-fields options.
      sql/sql_class.h:
        Make room so we can save check-fields options.
      sql/sql_insert.cc:
        Raise error as needed.
      28e95ba5
  3. 22 Feb, 2010 1 commit
  4. 18 Feb, 2010 1 commit
    • Tatiana A. Nurnberg's avatar
      Bug#48525: trigger changes "Column 'id' cannot be null" behaviour · e0fbc5d2
      Tatiana A. Nurnberg authored
      CHECK_FIELD_IGNORE was treated as CHECK_FIELD_ERROR_FOR_NULL;
      UPDATE...SET...NULL on NOT NULL fields behaved differently after
      a trigger.
      
      Now distinguishes between IGNORE and ERROR_FOR_NULL and save/restores
      check-field options.
      
      mysql-test/r/trigger.result:
        Show that UPDATE...SET...NULL on NOT NULL columns doesn't behave differently
        when run after a trigger.
      mysql-test/t/trigger.test:
        Show that UPDATE...SET...NULL on NOT NULL columns doesn't behave differently
        when run after a trigger.
      sql/field_conv.cc:
        CHECK_FIELD_IGNORE was treated as CHECK_FIELD_ERROR_FOR_NULL.
        Distinguish between the two.
      sql/sp_head.cc:
        raise error as needed
      sql/sql_class.cc:
        Save and restore check-fields options.
      sql/sql_class.h:
        Make room so we can save check-fields options.
      sql/sql_insert.cc:
        raise error as needed
      e0fbc5d2
  5. 11 Feb, 2010 1 commit
    • Staale Smedseng's avatar
      Bug #47905 stored procedures with conditional statements not · f4a16558
      Staale Smedseng authored
      being logged to slow query log
      
      The problem is that the execution time for a multi-statement
      stored procedure as a whole may not be accurate, and thus not
      be entered into the slow query log even if the total time
      exceeds long_query_time. The reason for this is that
      THD::utime_after_lock used for time calculation may be reset
      at the start of each new statement, possibly leaving the total
      SP execution equal to the time spent executing the last
      statement in the SP.
      
      This patch stores the utime on start of SP execution, and
      restores it on exit of SP execution. A test is added.
      
      
      mysql-test/suite/sys_vars/r/slow_query_log_func.result:
        New test results for #47905.
      mysql-test/suite/sys_vars/t/slow_query_log_func.test:
        New test case for #47905.
      sql/sp_head.cc:
        Save and restore the THD::utime_after_lock on entry and 
        exit of execute_procedure().
      f4a16558
  6. 24 Jan, 2010 1 commit
  7. 23 Dec, 2009 1 commit
    • Sergey Glukhov's avatar
      Bug#47649 crash during CALL procedure · 87731177
      Sergey Glukhov authored
      If first call of the procedure is failed on
      the open_table stage stmt_arena->state is set to
      EXECUTED state. On second call(if no errors on
      open_table stage) it leads to use of worng memory arena
      in find_field_in_view() function as
      thd->stmt_arena->is_stmt_prepare_or_first_sp_execute()
      returns FALSE for EXECUTED state. The item is created 
      not in its own arena and it leads to crash on further
      calls of the procedure.
      The fix: 
      change state of arena only if
      no errors on open_table stage happens.
      
      
      mysql-test/r/sp.result:
        test result
      mysql-test/t/sp.test:
        test case
      sql/sp_head.cc:
        If first call of the procedure is failed on
        the open_table stage stmt_arena->state is set to
        EXECUTED state. On second call(if no errors on
        open_table stage) it leads to use of worng memory arena
        in find_field_in_view() function as
        thd->stmt_arena->is_stmt_prepare_or_first_sp_execute()
        returns FALSE for EXECUTED state. The item is created 
        not in its own arena and it leads to crash on further
        calls of the procedure.
        The fix: 
        change state of arena only if
        no errors on open_table stage happens.
      87731177
  8. 20 Nov, 2009 1 commit
  9. 26 Oct, 2009 1 commit
  10. 16 Oct, 2009 1 commit
    • Georgi Kodinov's avatar
      Bug #40877: multi statement execution fails in 5.1.30 · 7b4ef910
      Georgi Kodinov authored
            
      Implemented the server infrastructure for the fix:
      
      1. Added a function LEX_STRING *thd_query_string(THD) to return
      a LEX_STRING structure instead of char *.
      This is the function that must be called in innodb instead of 
      thd_query()
      
      2. Did some encapsulation in THD : aggregated thd_query and 
      thd_query_length into a LEX_STRING and made accessor and mutator 
      methods for easy code updating. 
      
      3. Updated the server code to use the new methods where applicable.
      7b4ef910
  11. 22 Sep, 2009 1 commit
    • MySQL Build Team's avatar
      Backport into build-200909221805-5.1.37sp1 · c42a04fd
      MySQL Build Team authored
      > ------------------------------------------------------------
      > revno: 3044.1.1
      > revision-id: kristofer.pettersson@sun.com-20090729200708-cb0td7n9r5md0aa0
      > parent: davi.arnaut@sun.com-20090728195938-qabe9ldm2l4k8xns
      > committer: Kristofer Pettersson <kristofer.pettersson@sun.com>
      > branch nick: mysql-5.1-bugteam
      > timestamp: Wed 2009-07-29 22:07:08 +0200
      > message:
      >   Bug#44521 Executing a stored procedure as a prepared statement can sometimes cause
      >             an assertion in a debug build.
      >   
      >   The reason is that the C API doesn't support multiple result sets for prepared
      >   statements and attempting to execute a stored routine which returns multiple result
      >   sets sometimes lead to a network error. The network error sets the diagnostic area
      >   prematurely which later leads to the assert when an attempt is made to set a second
      >   server state.
      >   
      >   This patch fixes the issue by changing the scope of the error code returned by
      >   sp_instr_stmt::execute() to include any error which happened during the execution.
      >   To assure that Diagnostic_area::is_sent really mean that the message was sent all
      >   network related functions are checked for return status.
      c42a04fd
  12. 29 Jul, 2009 1 commit
    • Kristofer Pettersson's avatar
      Bug#44521 Executing a stored procedure as a prepared statement can sometimes cause · fc1acef6
      Kristofer Pettersson authored
                an assertion in a debug build.
      
      The reason is that the C API doesn't support multiple result sets for prepared
      statements and attempting to execute a stored routine which returns multiple result
      sets sometimes lead to a network error. The network error sets the diagnostic area
      prematurely which later leads to the assert when an attempt is made to set a second
      server state.
      
      This patch fixes the issue by changing the scope of the error code returned by
      sp_instr_stmt::execute() to include any error which happened during the execution.
      To assure that Diagnostic_area::is_sent really mean that the message was sent all
      network related functions are checked for return status.
      
      libmysqld/lib_sql.cc:
        * Changed prototype to return success/failure status on net_send_error_packet(),
          net_send_ok(), net_send_eof(), write_eof_packet().
      mysql-test/r/sp_notembedded.result:
        * Added test case for bug 44521
      mysql-test/t/sp_notembedded.test:
        * Added test case for bug 44521
      sql/protocol.cc:
        * Changed prototype to return success/failure status on net_send_error_packet(),
          net_send_ok(), net_send_eof(), write_eof_packet().
      sql/protocol.h:
        * Changed prototype to return success/failure status on net_send_error_packet(),
          net_send_ok(), net_send_eof(), write_eof_packet().
      sql/sp_head.cc:
        * Changed prototype to return success/failure status on net_send_error_packet(),
          net_send_ok(), net_send_eof(), write_eof_packet().
      fc1acef6
  13. 24 Jul, 2009 1 commit
    • Gleb Shchepa's avatar
      Bug #38816: kill + flush tables with read lock + stored · dc0a87fd
      Gleb Shchepa authored
                  procedures causes crashes!
      
      The problem of that bugreport was mostly fixed by the
      patch for bug 38691.
      However, attached test case focused on another crash or
      valgrind warning problem: SHOW PROCESSLIST query accesses
      freed memory of SP instruction that run in a parallel
      connection.
      
      Changes of thd->query/thd->query_length in dangerous
      places have been guarded with the per-thread
      LOCK_thd_data mutex (the THD::LOCK_delete mutex has been
      renamed to THD::LOCK_thd_data).
      
      
      sql/ha_myisam.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        Modification of THD::query/query_length has been guarded
        with the a THD::set_query() method call/LOCK_thd_data
        mutex.
        Unnecessary locking with the global LOCK_thread_count
        mutex has been removed.
      sql/log_event.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        Modification of THD::query/query_length has been guarded
        with the THD::set_query()) method call/LOCK_thd_data
        mutex.
      sql/slave.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        Modification of THD::query/query_length has been guarded
        with the THD::set_query() method call/LOCK_thd_data mutex.
        
        The THD::LOCK_delete mutex has been renamed to
        THD::LOCK_thd_data.
      sql/sp_head.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        Modification of THD::query/query_length has been guarded
        with the a THD::set_query() method call/LOCK_thd_data
        mutex.
      sql/sql_class.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        The new THD::LOCK_thd_data mutex and THD::set_query()
        method has been added to guard modifications of THD::query/
        THD::query_length fields, also the Statement::set_statement()
        method has been overloaded in the THD class.
        
        The THD::LOCK_delete mutex has been renamed to
        THD::LOCK_thd_data.
      sql/sql_class.h:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        The new THD::LOCK_thd_data mutex and THD::set_query()
        method has been added to guard modifications of THD::query/
        THD::query_length fields, also the Statement::set_statement()
        method has been overloaded in the THD class.
        
        The THD::LOCK_delete mutex has been renamed to
        THD::LOCK_thd_data.
      sql/sql_insert.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        Modification of THD::query/query_length has been guarded
        with the a THD::set_query() method call/LOCK_thd_data
        mutex.
      sql/sql_parse.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        Modification of THD::query/query_length has been guarded
        with the a THD::set_query() method call/LOCK_thd_data mutex.
      sql/sql_repl.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        The THD::LOCK_delete mutex has been renamed to
        THD::LOCK_thd_data.
      sql/sql_show.cc:
        Bug #38816: kill + flush tables with read lock + stored
                    procedures causes crashes!
        
        Inter-thread read of THD::query/query_length field has
        been protected with a new per-thread LOCK_thd_data
        mutex in the mysqld_list_processes function.
      dc0a87fd
  14. 30 May, 2009 1 commit
    • He Zhenxing's avatar
      BUG#41948 Query_log_event constructor needlessly contorted · abf5f8da
      He Zhenxing authored
      Make the caller of Query_log_event, Execute_load_log_event
      constructors and THD::binlog_query to provide the error code
      instead of having the constructors to figure out the error code.
      
      sql/log_event.cc:
        Changed constructors of Query_log_event and Execute_load_log_event to accept the error code argument instead of figuring it out by itself
      sql/log_event.h:
        Changed constructors of Query_log_event and Execute_load_log_event to accept the error code argument
      abf5f8da
  15. 05 May, 2009 1 commit
  16. 30 Apr, 2009 1 commit
    • Sergey Glukhov's avatar
      Bug#43962 "Packets out of order" calling a SHOW TABLE STATUS · 5d41d821
      Sergey Glukhov authored
      Error happens because sp_head::MULTI_RESULTS is not set for SP
      which has 'show table status' command.
      The fix is to add a SQLCOM_SHOW_TABLE_STATUS case into
      sp_get_flags_for_command() func.
      
      
      mysql-test/r/sp.result:
        test result
      mysql-test/t/sp.test:
        test case
      sql/sp_head.cc:
        Error happens because sp_head::MULTI_RESULTS is not set for SP
        which has 'show table status' command.
        The fix is to add a SQLCOM_SHOW_TABLE_STATUS case into
        sp_get_flags_for_command() func.
      5d41d821
  17. 27 Mar, 2009 1 commit
    • He Zhenxing's avatar
      BUG#37145 Killing a statement doing DDL may log binlog event with error code 1053 · 51a91166
      He Zhenxing authored
      When the thread executing a DDL was killed after finished its
      execution but before writing the binlog event, the error code in
      the binlog event could be set wrongly to ER_SERVER_SHUTDOWN or
      ER_QUERY_INTERRUPTED.
      
      This patch fixed the problem by ignoring the kill status when
      constructing the event for DDL statements.
      
      This patch also included the following changes in order to
      provide the test case.
      
       1) modified mysqltest to support variable for connection command
      
       2) modified mysql-test-run.pl, add new variable MYSQL_SLAVE to
          run mysql client against the slave mysqld.
      51a91166
  18. 25 Mar, 2009 1 commit
    • Ramil Kalimullin's avatar
      Fix for bug#35383: binlog playback and replication breaks · bce4c76a
      Ramil Kalimullin authored
      due to name_const substitution
      
      Problem:
      "In general, statements executed within a stored procedure
      are written to the binary log using the same rules that
      would apply were the statements to be executed in standalone
      fashion. Some special care is taken when logging procedure
      statements because statement execution within procedures
      is not quite the same as in non-procedure context".
      
      For example, each reference to a local variable in SP's
      statements is replaced by NAME_CONST(var_name, var_value).
      Queries like
      "CREATE TABLE ... SELECT FUNC(local_var ..."
      are logged as
      "CREATE TABLE ... SELECT FUNC(NAME_CONST("local_var", var_value) ..."
      that leads to differrent field names and
      might result in "Incorrect column name" if var_value is long enough.
      
      Fix: in 5.x we'll issue a warning in such a case.
      In 6.0 we should get rid of NAME_CONST().
      
      Note: this issue and change should be described in the documentation
      ("Binary Logging of Stored Programs").
      
      
      mysql-test/r/binlog.result:
        Fix for bug#35383: binlog playback and replication breaks
        due to name_const substitution
          - test result.
      mysql-test/t/binlog.test:
        Fix for bug#35383: binlog playback and replication breaks
        due to name_const substitution
          - test case.
      sql/sp_head.cc:
        Fix for bug#35383: binlog playback and replication breaks 
        due to name_const substitution
          - set thd->query_name_consts if there's NAME_CONST()
        substitution(s).
      sql/sql_parse.cc:
        Fix for bug#35383: binlog playback and replication breaks 
        due to name_const substitution
          - issue a warning if there's NAME_CONST() substitution and
        binary logging is on for "CREATE TABLE ... SELECT ...".
      bce4c76a
  19. 10 Feb, 2009 1 commit
  20. 21 Nov, 2008 1 commit
    • Alexey Botchkov's avatar
      Bug#25058 ignored return codes in memory allocation functions · d445b215
      Alexey Botchkov authored
         memory allocation error checks added for functions
         calling insert_dynamic()
      
      per-file messages:
        myisam/mi_delete.c
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        myisam/mi_write.c
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        server-tools/instance-manager/instance_options.cc
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        sql/slave.cc
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        sql/sp_head.cc
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        sql/sp_head.h
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        sql/sp_pcontext.cc
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        sql/sp_pcontext.h
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        sql/sql_select.cc
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
        sql/sql_yacc.yy
      Bug#25058 ignored return codes in memory allocation functions
          out-of-memory errors handled
      d445b215
  21. 10 Nov, 2008 1 commit
  22. 23 Oct, 2008 1 commit
  23. 01 Oct, 2008 1 commit
    • Ramil Kalimullin's avatar
      Fix for bug#39182: Binary log producing incompatible character set query · d3e317d1
      Ramil Kalimullin authored
      from stored procedure. 
      
      Problem: we replace all references to local variables in stored procedures     
      with NAME_CONST(name, value) logging to the binary log. However, if the
      value's collation differs we might get an 'illegal mix of collation'           
      error as we don't pass the collation to the function.
      
      Fix: pass the value's collation to NAME_CONST().
      
      Note: actually we should pass to NAME_CONST() the value's derivation as well.
      It's impossible without the parser modifying. Now we always set the 
      derivation to DERIVATION_IMPLICIT, the same as local variables have.
      
      
      mysql-test/r/binlog.result:
        Fix for bug#39182: Binary log producing incompatible character set query
        from stored procedure.
          - test result.
      mysql-test/r/ctype_cp932_binlog.result:
        Fix for bug#39182: Binary log producing incompatible character set query
        from stored procedure.
          - results adjusted.
      mysql-test/r/rpl_sp.result:
        Fix for bug#39182: Binary log producing incompatible character set query
        from stored procedure.
          - results adjusted.
      mysql-test/t/binlog.test:
        Fix for bug#39182: Binary log producing incompatible character set query
        from stored procedure.
          - test case.
      sql/item.cc:
        Fix for bug#39182: Binary log producing incompatible character set query
        from stored procedure.
          - allow NAME_CONST() to get _charset'foo' COLLATE 'bar' strings
        (see Item_func_set_collation).
      sql/sp_head.cc:
        Fix for bug#39182: Binary log producing incompatible character set query
        from stored procedure. 
          - pass the value's collation to NAME_CONST().
      d3e317d1
  24. 29 Sep, 2008 1 commit
    • Alexey Botchkov's avatar
      Bug#37949 Crash if argument to SP is a subquery that returns more than one row · ce64a16b
      Alexey Botchkov authored
           JOIN for the subselect wasn't cleaned if we came upon an error
           during sub_select() execution. That leads to the assertion failure
           in close_thread_tables()
      
           part of the 6.0 code backported
      
      per-file comments:
        mysql-test/r/sp-error.result
      Bug#37949 Crash if argument to SP is a subquery that returns more than one row 
          test result
      
        mysql-test/t/sp-error.test
      Bug#37949 Crash if argument to SP is a subquery that returns more than one row 
          test case
      
        sql/sp_head.cc
      Bug#37949 Crash if argument to SP is a subquery that returns more than one row 
          lex->unit.cleanup() call added if not substatement
      ce64a16b
  25. 11 Aug, 2008 1 commit
    • Marc Alff's avatar
      Bug#38296 (low memory crash with many conditions in a query) · e04dfffb
      Marc Alff authored
      This fix is for 5.0 only : back porting the 6.0 patch manually
      
      The parser code in sql/sql_yacc.yy needs to be more robust to out of
      memory conditions, so that when parsing a query fails due to OOM,
      the thread gracefully returns an error.
      
      Before this fix, a new/alloc returning NULL could:
      - cause a crash, if dereferencing the NULL pointer,
      - produce a corrupted parsed tree, containing NULL nodes,
      - alter the semantic of a query, by silently dropping token values or nodes
      
      With this fix:
      - C++ constructors are *not* executed with a NULL "this" pointer
      when operator new fails.
      This is achieved by declaring "operator new" with a "throw ()" clause,
      so that a failed new gracefully returns NULL on OOM conditions.
      
      - calls to new/alloc are tested for a NULL result,
      
      - The thread diagnostic area is set to an error status when OOM occurs.
      This ensures that a request failing in the server properly returns an
      ER_OUT_OF_RESOURCES error to the client.
      
      - OOM conditions cause the parser to stop immediately (MYSQL_YYABORT).
      This prevents causing further crashes when using a partially built parsed
      tree in further rules in the parser.
      
      No test scripts are provided, since automating OOM failures is not
      instrumented in the server.
      Tested under the debugger, to verify that an error in alloc_root cause the
      thread to returns gracefully all the way to the client application, with
      an ER_OUT_OF_RESOURCES error.
      e04dfffb
  26. 14 Jul, 2008 1 commit
    • Marc Alff's avatar
      Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on · e73e7bb9
      Marc Alff authored
      build)
      
      The crash was caused by freeing the internal parser stack during the parser
      execution.
      This occured only for complex stored procedures, after reallocating the parser
      stack using my_yyoverflow(), with the following C call stack:
      - MYSQLparse()
      - any rule calling sp_head::restore_lex()
      - lex_end()
      - x_free(lex->yacc_yyss), xfree(lex->yacc_yyvs)
      
      The root cause is the implementation of stored procedures, which breaks the
      assumption from 4.1 that there is only one LEX structure per parser call.
      
      The solution is to separate the LEX structure into:
      - attributes that represent a statement (the current LEX structure),
      - attributes that relate to the syntax parser itself (Yacc_state),
      so that parsing multiple statements in stored programs can create multiple
      LEX structures while not changing the unique Yacc_state.
      
      Now, Yacc_state and the existing Lex_input_stream are aggregated into
      Parser_state, a structure that represent the complete state of the (Lexical +
      Syntax) parser.
      
      
      mysql-test/r/parser_stack.result:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      mysql-test/t/parser_stack.test:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sp.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sp_head.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_class.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_class.h:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_lex.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_lex.h:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_parse.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_prepare.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_trigger.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_view.cc:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      sql/sql_yacc.yy:
        Bug#35577 (CREATE PROCEDURE causes either crash or syntax error depending on
        build)
      e73e7bb9
  27. 20 May, 2008 1 commit
    • unknown's avatar
      Bug#27430 "Crash in subquery code when in PS and table DDL changed after · 37b2c32d
      unknown authored
      PREPARE": rename members, methods, classes to follow the spec 
      (a code review request)
      
      
      sql/mysql_priv.h:
        enum_metadata_type -> enum_table_ref_type
      sql/sp_head.cc:
        Metadata_version_observer -> Reprepare_observer
      sql/sql_base.cc:
        metadata -> table_ref
      sql/sql_class.cc:
        Replace an abstract interface with a concrete implementation.
      sql/sql_class.h:
        enum_metadata_type -> enum_table_ref_type
      sql/sql_prepare.cc:
        Move implementation of Execute_observer to sql_class.cc and
        rename the class to Reprepare_observer.
        Use getters instead of direct access to the members.
      sql/table.h:
        metadata -> table_ref
      37b2c32d
  28. 15 May, 2008 1 commit
    • unknown's avatar
      Bug#36570: Parse error of CREATE PROCEDURE stmt with comments on \ · 55012e42
      unknown authored
      	slave
      
      The stored-routine code took the contents of the (lowest) parser
      and copied it directly to the binlog, which causes problems if there
      is a special case of interpretation at the parser level -- which 
      there is, in the "/*!VER */" comments.  The trailing "*/" caused
      errors on the slave, naturally.
      
      Now, since by that point we have /properly/ created parse-tree (as 
      the rest of the server should do!) for the stored-routine CREATE, we
      can construct a perfect statement from that information, instead of
      writing uncertain information from an unknown parser state.  
      Fortunately, there's already a function nearby that does exactly 
      that.
      ---
      Update for Bug#36570.  Qualify routine names with db name when
      writing to the binlog ONLY if the source text is qualified.
      
      
      mysql-test/r/binlog_innodb.result:
        Offsets changed due to quoting.
        ---
        New offset to account for db-qualified names.
      mysql-test/r/ctype_cp932_binlog.result:
        Offsets changed due to quoting.
        ---
        Qualify routine names with DB.  Offsets change also.
      mysql-test/r/mysqlbinlog.result:
        Case changed in result due to interpretation of data instead of 
        literal recitation.
        ---
        Qualify procedure name with db.
      mysql-test/r/rpl_sp.result:
        Offsets changed due to quoting.  Added tests.
        ---
        Qualify routine names with DB if qualified in query.  Offsets change also.
      mysql-test/t/rpl_sp.test:
        Add version-limiting quotes to exercise bug#36570.  Test that 
        backtick-quoted identifiers and labels work also.
        ---
        Use different db to show qualification works.  Qualify routine names
        with DB if qualified in query.
      sql/sp.cc:
        In create_string, we may not have a sp_name parameter yet, so
        instead pass the char* and length of the only member we'd get out
        of it.
        
        Having done that, we can use the same function to write the 
        CREATE (FUNC|TRIG|PROC) statement to the binlog as we always used
        to display the statement to the user.
        ---
        Make the db name part of the CREATE string if it is specified.
        
        Specify it in part of writing to the binlog when creating a new
        routine.
      sql/sp_head.cc:
        Set the sp_head m_explicit_name member as the sp_name member is set.  
        We can not peek at this later, as the sp_name is gone by then.
      sql/sp_head.h:
        Add a member to track whether the name is qualified with the 
        database.
      55012e42
  29. 16 Apr, 2008 1 commit
    • unknown's avatar
      WL#4165 "Prepared statements: validation". · bd2a7328
      unknown authored
      Add metadata validation to ~20 more SQL commands. Make sure that
      these commands actually work in ps-protocol, since until now they
      were enabled, but not carefully tested.
      Fixes the ml003 bug found by Matthias during internal testing of the
      patch.
      
      
      mysql-test/r/ps_ddl.result:
        Update test results (WL#4165)
      mysql-test/t/ps_ddl.test:
        Cover with tests metadata validation of 26 SQL statements.
      sql/mysql_priv.h:
        Fix the name in the comment.
      sql/sp_head.cc:
        Changed the way the observer is removed in case of stored procedures
        to support validation prepare stmt from "call p1(<expr>)": whereas
        tables used in the expression must be validated, substatements
        of p1 must not.
        The previous scheme used to silence the observer only in stored
        functions and triggers.
      sql/sql_class.cc:
        Now the observer is silenced in sp_head::execute(). Remove it from
        Sub_statement_state.
      sql/sql_class.h:
        Now the observer is silenced in sp_head::execute(). Remove it from
        Sub_statement_state.
      sql/sql_parse.cc:
        Add CF_REEXECUTION_FRAGILE to 20 more SQLCOMs that need it.
      sql/sql_prepare.cc:
        Add metadata validation to ~20 new SQLCOMs that need it.
        Fix memory leaks with expressions used in SHOW DATABASES and CALL
        (and prepared statements).
        We need to fix all expressions at prepare, since if these expressions
        use subqueries, there are one-time transformations of the parse
        tree that must be done at prepare. 
        List of fixed commands includes: SHOW TABLES, SHOW DATABASES,
        SHOW TRIGGERS, SHOW EVENTS, SHOW OPEN TABLES,SHOW KEYS, SHOW FIELDS, 
        SHOW COLLATIONS, SHOW CHARSETS, SHOW VARIABLES, SHOW TATUS, SHOW TABLE
        STATUS, SHOW PROCEDURE STATUS, SHOW FUNCTION STATUS, CALL.
        Add comment to set_parameters().
      sql/table.h:
        Update comments.
      bd2a7328
  30. 22 Feb, 2008 1 commit
    • unknown's avatar
      Fix for Bug#30217: Views: changes in metadata behaviour · a3e83048
      unknown authored
      between 5.0 and 5.1.
        
      The problem was that in the patch for Bug#11986 it was decided
      to store original query in UTF8 encoding for the INFORMATION_SCHEMA.
      This approach however turned out to be quite difficult to implement
      properly. The main problem is to preserve the same IS-output after
      dump/restore.
        
      So, the fix is to rollback to the previous functionality, but also
      to fix it to support multi-character-set-queries properly. The idea
      is to generate INFORMATION_SCHEMA-query from the item-tree after
      parsing view declaration. The IS-query should:
        - be completely in UTF8;
        - not contain character set introducers.
        
      For more information, see WL4052.
      
      
      mysql-test/include/ddl_i18n.check_views.inc:
        Add a test case for Bug#30217.
      mysql-test/r/ddl_i18n_koi8r.result:
        Update result file.
      mysql-test/r/ddl_i18n_utf8.result:
        Update result file.
      mysql-test/r/information_schema.result:
        Update result file.
      mysql-test/r/information_schema_db.result:
        Update result file.
      mysql-test/r/mysqldump.result:
        Update result file.
      mysql-test/r/show_check.result:
        Update result file.
      mysql-test/t/ddl_i18n_koi8r.test:
        Add a test case for Bug#30217.
      mysql-test/t/ddl_i18n_utf8.test:
        Add a test case for Bug#30217.
      mysql-test/t/mysqldump.test:
        Add a test case for Bug#30217.
      sql/ha_ndbcluster.cc:
        Add a parameter to print().
      sql/item.cc:
        1. Add a parameter to print().
        2. Item_string::print():
              - Do not append character set introducer to the text literal
                if we're building a query for INFORMATION_SCHEMA;
              - Convert text literal to UTF8 if we're building a query
                for INFORMATION_SCHEMA.
      sql/item.h:
        Add a parameter to print().
      sql/item_cmpfunc.cc:
        Add a parameter to print().
      sql/item_cmpfunc.h:
        Add a parameter to print().
      sql/item_func.cc:
        Add a parameter to print().
      sql/item_func.h:
        Add a parameter to print().
      sql/item_geofunc.h:
        Add a parameter to print().
      sql/item_row.cc:
        Add a parameter to print().
      sql/item_row.h:
        Add a parameter to print().
      sql/item_strfunc.cc:
        Add a parameter to print().
      sql/item_strfunc.h:
        Add a parameter to print().
      sql/item_subselect.cc:
        Add a parameter to print().
      sql/item_subselect.h:
        Add a parameter to print().
      sql/item_sum.cc:
        Add a parameter to print().
      sql/item_sum.h:
        Add a parameter to print().
      sql/item_timefunc.cc:
        Add a parameter to print().
      sql/item_timefunc.h:
        Add a parameter to print().
      sql/mysql_priv.h:
        Add a parameter to print().
      sql/sp_head.cc:
        Add a parameter to print().
      sql/sql_lex.cc:
        Add a parameter to print().
      sql/sql_lex.h:
        Add a parameter to print().
      sql/sql_parse.cc:
        Add a parameter to print().
      sql/sql_select.cc:
        Add a parameter to print().
      sql/sql_show.cc:
        Add a parameter to print().
      sql/sql_test.cc:
        Add a parameter to print().
      sql/sql_view.cc:
        Build INFORMATION_SCHEMA query from Item-tree.
      sql/sql_yacc.yy:
        Build INFORMATION_SCHEMA query from Item-tree.
      sql/table.h:
        Add a parameter to print().
      a3e83048
  31. 19 Feb, 2008 2 commits
    • unknown's avatar
    • 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
  32. 30 Jan, 2008 1 commit
    • unknown's avatar
      A fix and a test case for Bug#34166 Server crash in SHOW OPEN TABLES and · 39509d64
      unknown authored
      pre-locking.
      
      The crash was caused by an implicit assumption in check_table_access() that
      table_list parameter is always a part of lex->query_tables.
      
      When iterating over the passed list of tables, check_table_access() used
      to stop only when lex->query_tables_last_not_own was reached. 
      In case of pre-locking, lex->query_tables_last_own is not NULL and points
      to some element of lex->query_tables. When the parameter
      of check_table_access() was not part of lex->query_tables, loop invariant
      could never be violated and a crash would happen when the current table
      pointer would point beyond the end of the provided list.
      
      The fix is to change the signature of check_table_access() to also accept
      a numeric limit of loop iterations, similarly to check_grant(), and 
      supply this limit in all places when we want to check access of tables
      that are outside lex->query_tables, or just want to check access to one table.
      
      
      mysql-test/r/information_schema.result:
        Update test results (Bug#34166).
      mysql-test/t/information_schema.test:
        Add a test case for Bug#34166.
      sql/mysql_priv.h:
        Change signature of check_table_access() to accept a numeric limit
        of tables to check.
      sql/sp_head.cc:
        Update to the new signature of check_table_access().
      sql/sql_acl.cc:
        Improve code clarity: if there is a numeric limit, we should not need
        to look at first_not_own_table.
      sql/sql_base.cc:
        Update to the new signature of check_table_access().
      sql/sql_cache.cc:
        Update to the new signature of check_table_access().
      sql/sql_parse.cc:
        Update to the new signature of check_table_access().
        Change check_table_access() to accept an optional numeric limit of tables
        to check. A crash would happen when check_table_access() was
        passed a list of tables that is not part of lex->query_tables and
        lex->query_tables_last_own was not NULL.
      sql/sql_plugin.cc:
        Update to the new signature of check_table_access().
      sql/sql_prepare.cc:
        Update to the new signature of check_table_access().
      sql/sql_show.cc:
        Update to the new signature of check_table_access().
        Ensure that check_table_access() only checks access to the first
        table in the table list when called from list_open_tables().
        list_open_tables() supplies a table list that is created on stack,
        whereas check_table_access() used to assume that the supplied list is a part
        of thd->lex.
      sql/sql_trigger.cc:
        Update to the new signature of check_table_access().
      sql/sql_view.cc:
        Update to the new signature of check_table_access().
      39509d64
  33. 23 Jan, 2008 1 commit
    • unknown's avatar
      Bug#33618 (Crash in sp_rcontext) · e6a077e3
      unknown authored
      Bug 33983 (Stored Procedures: wrong end <label> syntax is accepted)
      
      The server used to crash when REPEAT or another control instruction
      was used in conjunction with labels and a LEAVE instruction.
      
      The crash was caused by a missing "pop" of handlers or cursors in the
      code representing the stored program. When executing the code in a loop,
      this missing "pop" would result in a stack overflow, corrupting memory.
      
      Code generation has been fixed to produce the missing h_pop/c_pop
      instructions.
      
      Also, the logic checking that labels at the beginning and the end of a
      statement are matched was incorrect, causing Bug 33983.
      End labels, when used, must match the label used at the beginning of a block.
      
      
      mysql-test/r/sp-code.result:
        Bug#33618 (Crash in sp_rcontext)
      mysql-test/r/sp-error.result:
        Bug 33983 (Stored Procedures: wrong end <label> syntax is accepted)
      mysql-test/r/sp.result:
        Bug#33618 (Crash in sp_rcontext)
      mysql-test/t/sp-code.test:
        Bug#33618 (Crash in sp_rcontext)
      mysql-test/t/sp-error.test:
        Bug 33983 (Stored Procedures: wrong end <label> syntax is accepted)
      mysql-test/t/sp.test:
        Bug#33618 (Crash in sp_rcontext)
      sql/sp_head.cc:
        Bug#33618 (Crash in sp_rcontext)
      sql/sp_head.h:
        Bug#33618 (Crash in sp_rcontext)
      sql/sp_rcontext.cc:
        Bug#33618 (Crash in sp_rcontext)
      sql/sp_rcontext.h:
        Bug#33618 (Crash in sp_rcontext)
      sql/sql_yacc.yy:
        Bug#33618 (Crash in sp_rcontext)
      e6a077e3
  34. 14 Dec, 2007 2 commits
    • unknown's avatar
      sp_head.cc: · 81c29da8
      unknown authored
        Corrected typo
      
      
      sql/sp_head.cc:
        Corrected typo
      81c29da8
    • unknown's avatar
      sp_head.cc: · e1fe5ab9
      unknown authored
        Made sp_head::operator delete() match prototype, added throw()
      mysql_test_run.c, mysqld_safe.c:
        Include "mysql_version.h" to get MYSQL_PORT defined
      
      
      sql/sp_head.cc:
        Made sp_head::operator delete() match prototype, added throw()
      netware/mysql_test_run.c:
        Include "mysql_version.h" to get MYSQL_PORT defined
      netware/mysqld_safe.c:
        Include "mysql_version.h" to get MYSQL_PORT defined
      e1fe5ab9
  35. 12 Dec, 2007 1 commit
    • unknown's avatar
      Bug#12713 "Error in a stored function called from a SELECT doesn't · 2a0d2fef
      unknown authored
      cause ROLLBACK of statement", part 1. Review fixes.
      
      Do not send OK/EOF packets to the client until we reached the end of 
      the current statement.
      This is a consolidation, to keep the functionality that is shared by all 
      SQL statements in one place in the server.
      Currently this functionality includes:
      - close_thread_tables()
      - log_slow_statement().
      
      After this patch and the subsequent patch for Bug#12713, it shall also include:
      - ha_autocommit_or_rollback()
      - net_end_statement()
      - query_cache_end_of_result().
      
      In future it may also include:
      - mysql_reset_thd_for_next_command().
      
      
      include/mysql_com.h:
        Rename now unused members of NET: no_send_ok, no_send_error, report_error.
        These were server-specific variables related to the client/server
        protocol. They have been made obsolete by this patch.
        
        Previously the same members of NET were used to store the error message
        both on the client and on the server. 
        The error message was stored in net.last_error (client: mysql->net.last_error,
        server: thd->net.last_error).
        The error code was stored in net.last_errno (client: mysql->net.last_errno,
        server: thd->net.last_errno).
        The server error code and message are now stored elsewhere 
        (in the Diagnostics_area), thus NET members are no longer used by the
        server.
        Rename last_error to client_last_error, last_errno to client_last_errno
        to avoid potential bugs introduced by merges.
      include/mysql_h.ic:
        Update the ABI file to reflect a rename. 
        Renames do not break the binary compatibility.
      libmysql/libmysql.c:
        Rename last_error to client_last_error, last_errno to client_last_errno.
        This is necessary to ensure no unnoticed bugs introduced by merged
        changesets.
        
        Remove net.report_error, net.no_send_ok, net.no_send_error.
      libmysql/manager.c:
        Rename net.last_errno to net.client_last_errno.
      libmysqld/lib_sql.cc:
        Rename net.last_errno to net.client_last_errno.
        
        Update the embedded implementation of the client-server protocol to
        reflect the refactoring of protocol.cc.
      libmysqld/libmysqld.c:
        Rename net.last_errno to net.client_last_errno.
      mysql-test/r/events.result:
        Update to reflect the change in mysql_rm_db(). Now we drop stored
        routines and events for a given database name only if there
        is a directory for this database name. ha_drop_database() and
        query_cache_invalidate() are called likewise. 
        Previously we would attempt to drop routines/events even if database
        directory was not found (it worked, since routines and events are stored
        in tables). This fixes Bug 29958 "Weird message on DROP DATABASE if mysql.proc
        does not exist".
        The change was done because the previous code used to call send_ok()
        twice, which led to an assertion failure when asserts against it were
        added by this patch.
      mysql-test/r/grant.result:
        Fix the patch for Bug 16470, now FLUSH PRIVILEGES produces an error 
        if mysql.procs_priv is missing.
        This fixes the assert that send_ok() must not called after send_error()
        (the original patch for Bug 16470 was prone to this).
      mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result:
        Produce a more detailed error message.
      mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result:
        Produce a more detailed error message.
      mysql-test/t/grant.test:
        Update the test, now FLUSH PRIVILEGES returns an error if mysql.procs_priv
        is missing.
      server-tools/instance-manager/mysql_connection.cc:
        Rename net.last_errno to net.client_last_errno.
      sql/ha_ndbcluster_binlog.cc:
        Add asserts. 
        
        Use getters to access statement status information.
        
        Add a comment why run_query() is broken. Reset the diagnostics area
        in the end of run_query() to fulfill the invariant that the diagnostics_area
        is never assigned twice per statement (see the comment in the code
        when this can happen). We still do not clear thd->is_fatal_error and
        thd->is_slave_error, which may lead to bugs, I consider the whole affair
        as something to be dealt with separately.
      sql/ha_partition.cc:
        fatal_error() doesn't set an error by itself. Perhaps we should
        remove this method altogether and instead add a flag to my_error 
        to set thd->is_fatal_error property.
        
        Meanwhile, this change is a part of inspection made to the entire source
        code with the goal to ensure that fatal_error()
        is always accompanied by my_error().
      sql/item_func.cc:
        There is no net.last_error anymore. Remove the obsolete assignment.
      sql/log_event.cc:
        Use getters to access statement error status information.
      sql/log_event_old.cc:
        Use getters to access statement error status information.
      sql/mysqld.cc:
        Previously, if a continue handler for an error was found, my_message_sql() 
        would not set an error in THD. Since the current statement
        must be aborted in any case, find_handler() had a hack to assign 
        thd->net.report_error to 1.
        
        Remove this hack. Set an error in my_message_sql() even if the continue
        handler is found. The error will be cleared anyway when the handler
        is executed. This is one action among many in this patch to ensure the 
        invariant that whenever thd->is_error() is TRUE, we have a message in 
        thd->main_da.message().
      sql/net_serv.cc:
        Use a full-blown my_error() in net_serv.cc to report an error,
        instead of just setting net->last_errno. This ensures the invariant that
        whenever thd->is_error() returns TRUE, we have a message in 
        thd->main_da.message().
        
        Remove initialization of removed NET members.
      sql/opt_range.cc:
        Use my_error() instead of just raising thd->net.report_error. 
        This ensures the invariant that whenever thd->is_error() returns TRUE, 
        there is a message in thd->main_da.message().
      sql/opt_sum.cc:
        Move invocation of fatal_error() right next to the place where
        we set the error message. That makes it easier to track that whenever
        fatal_error() is called, there is a message in THD.
      sql/protocol.cc:
        Rename send_ok() and send_eof() to net_send_ok() and net_send_eof() 
        respectively. These functions write directly to the network and are not 
        for use anywhere outside the client/server protocol code. 
        
        Remove the code that was responsible for cases when either there is 
        no error code, or no error message, or both.
        Instead the calling code ensures that they are always present. Asserts
        are added to enforce the invariant.
        
        Instead of a direct access to thd->server_status and thd->total_warn_count
        use function parameters, since these from now on don't always come directly
        from THD.
        
        Introduce net_end_statement(), the single-entry-point replacement API for 
        send_ok(), send_eof() and net_send_error().
        
        Implement Protocol::end_partial_result_set to use in select_send::abort()
        when there is a continue handler.
      sql/protocol.h:
        Update declarations.
      sql/repl_failsafe.cc:
        Use getters to access statement status information in THD.
        Rename net.last_error to net.client_last_error.
      sql/rpl_record.cc:
        Set an error message in prepare_record() if there is no default
        value for the field -- later we do print this message to the client.
      sql/rpl_rli.cc:
        Use getters to access statement status information in THD.
      sql/slave.cc:
        In create_table_from_dump() (a common function that is used in 
        LOAD MASTER TABLE SQL statement and COM_LOAD_MASTER_DATA), instead of hacks
        with no_send_ok, clear the diagnostics area when mysql_rm_table() succeeded.
        
        Update has_temporary_error() to work correctly when no error is set.
        This is the case when Incident_log_event is executed: it always returns
        an error but does not set an error message.
        
        Use getters to access error status information.
      sql/sp_head.cc:
        Instead of hacks with no_send_error, work through the diagnostics area 
        interface to suppress sending of OK/ERROR packets to the client.
        
        Move query_cache_end_of_result before log_slow_statement(), similarly
        to how it's done in dispatch_command().
      sql/sp_rcontext.cc:
        Remove hacks with assignment of thd->net.report_error, they are not
        necessary any more (see the changes in mysqld.cc).
      sql/sql_acl.cc:
        Use getters to access error status information in THD.
      sql/sql_base.cc:
        Access thd->main_da.sql_errno() only if there is an error. This fixes
        a bug when auto-discovery, that was effectively disabled under pre-locking.
      sql/sql_binlog.cc:
        Remove hacks with no_send_ok/no_send_error, they are not necessary 
        anymore: the caller is responsible for network communication.
      sql/sql_cache.cc:
        Disable sending of OK/ERROR/EOF packet in the end of dispatch_command
        if the response has been served from the query cache. This raises the 
        question whether we should store EOF packet in the query cache at all,
        or generate it anew for each statement (we should generate it anew), but
        this is to be addressed separately.
      sql/sql_class.cc:
        Implement class Diagnostics_area. Please see comments in sql_class.h
        for details.
        
        Fix a subtle coding mistake in select_send::send_data: when on slave, 
        an error in Item::send() was ignored.
        The problem became visible due to asserts that the diagnostics area is
        never double assigned.
        
        Remove initialization of removed NET members.
        
        In select_send::abort() do not call select_send::send_eof(). This is
        not inheritance-safe. Even if a stored procedure continue handler is
        found, the current statement is aborted, not succeeded.
        Instead introduce a Protocol API to send the required response, 
        Protocol::end_partial_result_set().
        
        This simplifies implementation of select_send::send_eof(). No need
        to add more asserts that there is no error, there is an assert inside
        Diagnostics_area::set_ok_status() already.
        
        Leave no trace of no_send_* in the code.
      sql/sql_class.h:
        Declare class Diagnostics_area. 
        
        Remove the hack with no_send_ok from
        Substatement_state.
        
        Provide inline implementations of send_ok/send_eof.
        
        Add commetns.
      sql/sql_connect.cc:
        Remove hacks with no_send_error. 
        
        Since now an error in THD is always set if net->error, it's not necessary
        to check both net->error and thd->is_error() in the do_command loop.
        
        Use thd->main_da.message() instead of net->last_errno.
        
        Remove the hack with is_slave_error in sys_init_connect. Since now we do not
        reset the diagnostics area in net_send_error (it's reset at the beginning
        of the next statement), we can access it safely even after 
        execute_init_command.
      sql/sql_db.cc:
        Update the code to satisfy the invariant that the diagnostics area is never
        assigned twice.
        Incidentally, this fixes Bug 29958 "Weird message on DROP DATABASE if 
        mysql.proc does not exist".
      sql/sql_delete.cc:
        Change multi-delete to abort in abort(), as per select_send protocol.
        Fixes the merge error with the test for Bug 29136
      sql/sql_derived.cc:
        Use getters to access error information.
      sql/sql_insert.cc:
        Use getters to access error information.
      sql-common/client.c:
        Rename last_error to client_last_error, last_errno to client_last_errno.
      sql/sql_parse.cc:
        Remove hacks with no_send_error. Deploy net_end_statement().
        
        The story of COM_SHUTDOWN is interesting. Long story short, the server 
        would become on its death's door, and only no_send_ok/no_send_error assigned
        by send_ok()/net_send_error() would hide its babbling from the client.
        
        First of all, COM_QUIT does not require a response. So, the comment saying
        "Let's send a response to possible COM_QUIT" is not only groundless 
        (even mysqladmin shutdown/mysql_shutdown() doesn't send COM_QUIT after 
        COM_SHUTDOWN), it's plainly incorrect.
        
        Secondly, besides this additional 'OK' packet to respond to a hypothetical
        COM_QUIT, there was the following code in dispatch_command():
        
        if (thd->killed)
          thd->send_kill_message();
        if (thd->is_error()
          net_send_error(thd);
        
        This worked out really funny for the thread through which COM_SHUTDOWN
        was delivered: we would get COM_SHUTDOWN, say okay, say okay again, 
        kill everybody, get the kill signal ourselves, and then attempt to say 
        "Server shutdown in progress" to the client that is very likely long gone.
        
        This all became visible when asserts were added that the Diagnostics_area
        is not assigned twice.
        
        Move query_cache_end_of_result() to the end of dispatch_command(), since
        net_send_eof() has been moved there. This is safe, query_cache_end_of_result()
        is a no-op if there is no started query in the cache.
        
        Consistently use select_send interface to call abort() or send_eof()
        depending on the operation result.
        
        Remove thd->fatal_error() from reset_master(), it was a no-op. 
        in hacks with no_send_error woudl save us
        from complete breakage of the client/server protocol.
        
        Consistently use select_send::abort() whenever there is an error, 
        and select_send::send_eof() in case of success.
        The issue became visible due to added asserts.
      sql/sql_partition.cc:
        Always set an error in THD whenever there is a call to fatal_error().
      sql/sql_prepare.cc:
        Deploy class Diagnostics_area.
        Remove the unnecessary juggling with the protocol in 
        Select_fetch_protocol_binary::send_eof(). EOF packet format is 
        protocol-independent.
      sql/sql_select.cc:
        Call fatal_error() directly in opt_sum_query.
        Call my_error() whenever we call thd->fatal_error().
      sql/sql_servers.cc:
        Use getters to access error information in THD.
      sql/sql_show.cc:
        Use getters to access error information in THD.
        
        Add comments.
        
        Call my_error() whenever we call fatal_error().
      sql/sql_table.cc:
        Replace hacks with no_send_ok with the interface of the diagnostics area.
        
        Clear the error if ENOENT error in ha_delete_table().
      sql/sql_update.cc:
        Introduce multi_update::abort(), which is the proper way to abort a
        multi-update. This fixes the merge conflict between this patch and
        the patch for Bug 29136.
      sql/table.cc:
        Use a getter to access error information in THD.
      sql/tztime.cc:
        Use a getter to access error information in THD.
      2a0d2fef
  36. 19 Nov, 2007 1 commit
    • unknown's avatar
      Bug #31153 calling stored procedure crashes server if available memory is low · bb681dbc
      unknown authored
      When the server was out of memory it crashed because of invalid memory access.
      
      This patch adds detection for failed memory allocations and make the server
      output a proper error message.
      
      
      sql/mysqld.cc:
        Don't try to push_warning from within push_warning. It will cause a recursion
        until the stack is consumed.
        
        If my_net_init fails (for example: because of OOM) the temporary vio object 
        might have been attached to the thd object already. This will cause a double
        free on the vio object when the thd object is deleted later on and the server
        will crash.
      sql/sp_head.cc:
        Added check for out-of-memory on a 'new' operation.
        Refactored reset_lex method to return a error state code instead of void.
        Initialize the mem-root with init_sql_alloc to get a basic error handler for
        memory allocation problems. This alone won't prevent the server from crashing,
        NULL pointers have to be accounted for as well.
      sql/sp_head.h:
        Use the throw() clause in operator new, to indicate to the compiler that
        memory allocation can fail and return NULL, so that the compiler should
        generate code to check for NULL before invoking C++ constructors, to be
        crash safe.
      sql/sql_base.cc:
        Use init_sql_alloc to get basic out-of-memory error handling.
      sql/sql_lex.h:
        Use the throw() clause in operator new, to indicate to the compiler that
        memory allocation can fail and return NULL, so that the compiler should
        generate code to check for NULL before invoking C++ constructors, to be
        crash safe.
      sql/sql_prepare.cc:
        Use init_sql_alloc to get basic out-of-memory error handling.
      sql/sql_yacc.yy:
        Check for memory allocation failures where it matters.
      bb681dbc
  37. 14 Nov, 2007 1 commit
    • unknown's avatar
      Push history-limiting code until after the code that adds new · c1a36d80
      unknown authored
      history entries.  Lazy deletion isn't smart or useful here.
      
      Backport from 5.1 .
      
      
      include/my_sys.h:
        Prepare for rename in 5.1.
      mysql-test/r/profiling.result:
        Backport tests from 5.1.
      mysql-test/t/profiling.test:
        Backport tests from 5.1.
      sql/mysql_priv.h:
        Backport changes from 5.1 .
      sql/sp_head.cc:
        Backport changes from 5.1 .
      sql/sql_class.cc:
        Backport changes from 5.1 .
      sql/sql_parse.cc:
        Backport changes from 5.1 .
      sql/sql_profile.cc:
        Push history-limiting code until after the code that adds new 
        history entries.  Lazy deletion isn't smart or useful here.
        
        Correct for 5.0 member existance and execution.
      sql/sql_profile.h:
        Backport changes from 5.1 .
      sql/sql_show.cc:
        Backport changes from 5.1 .
      c1a36d80
  38. 13 Nov, 2007 1 commit
    • unknown's avatar
      Insert profiling instructions into s-p code to make each statement · 7eb9aac7
      unknown authored
      be profiled separately.
      
      Expand the time formats in i_s.profiling to wide enough for larger
      numbers.
      
      
      mysql-test/r/profiling.result:
        Show that each query inside a procedure is profiled separately.
      mysql-test/t/profiling.test:
        Show that each query inside a procedure is profiled separately.
      sql/sp_head.cc:
        Poke profiling into stored-procedure code.  For statement parts only
        of routines, process them as profilable discrete queries.
      sql/sql_profile.cc:
        Encode decimal size correctly.
      7eb9aac7