List:Commits« Previous MessageNext Message »
From:Jon Olav Hauglid Date:July 4 2012 2:07pm
Subject:bzr push into mysql-trunk-wl6406 branch (jon.hauglid:3969 to 3970) WL#6406
View as plain text  
 3970 Jon Olav Hauglid	2012-07-04
      WL#6406 Stacked diagnostic areas
      
      Patch 2: Refactoring:
      - Combined Warning_info and Diagnostics_area and
        removed Warning_info.
      - Combined Sql_condition::init() and Sql_condition::set()
        with constructor

    modified:
      sql/sp_rcontext.cc
      sql/sql_error.cc
      sql/sql_error.h
      sql/sql_signal.cc
 3969 Jon Olav Hauglid	2012-07-04
      WL#6406 Stacked diagnostic areas
      
      Patch 1:
      - Added THD::push_diagnostics_area(), THD::pop_diagnostics_area()
        and THD::get_stacked_da(). Related code added to sql_error.
      - Removed push/pop of warning info, used push/pop da instead.
      - Removed set_stmt_da(), used push/pop da instead.

    modified:
      sql/rpl_master.cc
      sql/sp_head.cc
      sql/sql_admin.cc
      sql/sql_class.h
      sql/sql_error.cc
      sql/sql_error.h
      sql/sql_get_diagnostics.cc
      sql/sql_partition.cc
      sql/sql_prepare.cc
      sql/sql_show.cc
=== modified file 'sql/sp_rcontext.cc'
--- a/sql/sp_rcontext.cc	2012-06-06 12:12:51 +0000
+++ b/sql/sp_rcontext.cc	2012-07-04 14:06:47 +0000
@@ -262,11 +262,12 @@ bool sp_rcontext::handle_sql_condition(T
     */
     if (!found_condition)
     {
-      Sql_condition *condition=
-        new (callers_arena->mem_root) Sql_condition(callers_arena->mem_root);
-      condition->set(da->sql_errno(), da->get_sqlstate(),
-                     Sql_condition::WARN_LEVEL_ERROR,
-                     da->message());
+      Sql_condition *condition= new (callers_arena->mem_root)
+        Sql_condition(callers_arena->mem_root,
+                      da->sql_errno(),
+                      da->get_sqlstate(),
+                      Sql_condition::WARN_LEVEL_ERROR,
+                      da->message());
       found_condition= condition;
     }
   }

=== modified file 'sql/sql_error.cc'
--- a/sql/sql_error.cc	2012-07-04 13:47:16 +0000
+++ b/sql/sql_error.cc	2012-07-04 14:06:47 +0000
@@ -170,7 +170,26 @@ using std::max;
     consequence of WL#751.
 */
 
-Sql_condition::Sql_condition()
+
+static void copy_string(MEM_ROOT *mem_root, String* dst, const String* src)
+{
+  size_t len= src->length();
+  if (len)
+  {
+    char* copy= (char*) alloc_root(mem_root, len + 1);
+    if (copy)
+    {
+      memcpy(copy, src->ptr(), len);
+      copy[len]= '\0';
+      dst->set(copy, len, src->charset());
+    }
+  }
+  else
+    dst->length(0);
+}
+
+
+Sql_condition::Sql_condition(MEM_ROOT *mem_root)
  : Sql_alloc(),
    m_class_origin((const char*) NULL, 0, & my_charset_utf8_bin),
    m_subclass_origin((const char*) NULL, 0, & my_charset_utf8_bin),
@@ -185,36 +204,17 @@ Sql_condition::Sql_condition()
    m_message_text(),
    m_sql_errno(0),
    m_level(Sql_condition::WARN_LEVEL_ERROR),
-   m_mem_root(NULL)
+   m_mem_root(mem_root)
 {
+  DBUG_ASSERT(mem_root != NULL);
   memset(m_returned_sqlstate, 0, sizeof(m_returned_sqlstate));
 }
 
-void Sql_condition::init(MEM_ROOT *mem_root)
-{
-  DBUG_ASSERT(mem_root != NULL);
-  DBUG_ASSERT(m_mem_root == NULL);
-  m_mem_root= mem_root;
-}
 
-void Sql_condition::clear()
-{
-  m_class_origin.length(0);
-  m_subclass_origin.length(0);
-  m_constraint_catalog.length(0);
-  m_constraint_schema.length(0);
-  m_constraint_name.length(0);
-  m_catalog_name.length(0);
-  m_schema_name.length(0);
-  m_table_name.length(0);
-  m_column_name.length(0);
-  m_cursor_name.length(0);
-  m_message_text.length(0);
-  m_sql_errno= 0;
-  m_level= Sql_condition::WARN_LEVEL_ERROR;
-}
-
-Sql_condition::Sql_condition(MEM_ROOT *mem_root)
+Sql_condition::Sql_condition(MEM_ROOT *mem_root, uint sql_errno,
+                             const char* sqlstate,
+                             Sql_condition::enum_warning_level level,
+                             const char* msg)
  : Sql_alloc(),
    m_class_origin((const char*) NULL, 0, & my_charset_utf8_bin),
    m_subclass_origin((const char*) NULL, 0, & my_charset_utf8_bin),
@@ -227,33 +227,25 @@ Sql_condition::Sql_condition(MEM_ROOT *m
    m_column_name((const char*) NULL, 0, & my_charset_utf8_bin),
    m_cursor_name((const char*) NULL, 0, & my_charset_utf8_bin),
    m_message_text(),
-   m_sql_errno(0),
-   m_level(Sql_condition::WARN_LEVEL_ERROR),
+   m_sql_errno(sql_errno),
+   m_level(level),
    m_mem_root(mem_root)
 {
   DBUG_ASSERT(mem_root != NULL);
+  DBUG_ASSERT(sql_errno != 0);
+  DBUG_ASSERT(sqlstate != NULL);
+  DBUG_ASSERT(msg != NULL);
+
   memset(m_returned_sqlstate, 0, sizeof(m_returned_sqlstate));
-}
 
-static void copy_string(MEM_ROOT *mem_root, String* dst, const String* src)
-{
-  size_t len= src->length();
-  if (len)
-  {
-    char* copy= (char*) alloc_root(mem_root, len + 1);
-    if (copy)
-    {
-      memcpy(copy, src->ptr(), len);
-      copy[len]= '\0';
-      dst->set(copy, len, src->charset());
-    }
-  }
-  else
-    dst->length(0);
+  set_builtin_message_text(msg);
+  set_sqlstate(sqlstate);
+  set_class_origin();
+  set_subclass_origin();
 }
 
-void
-Sql_condition::copy_opt_attributes(const Sql_condition *cond)
+
+void Sql_condition::copy_opt_attributes(const Sql_condition *cond)
 {
   DBUG_ASSERT(this != cond);
   copy_string(m_mem_root, & m_class_origin, & cond->m_class_origin);
@@ -268,26 +260,8 @@ Sql_condition::copy_opt_attributes(const
   copy_string(m_mem_root, & m_cursor_name, & cond->m_cursor_name);
 }
 
-void
-Sql_condition::set(uint sql_errno, const char* sqlstate,
-                   Sql_condition::enum_warning_level level, const char* msg)
-{
-  DBUG_ASSERT(sql_errno != 0);
-  DBUG_ASSERT(sqlstate != NULL);
-  DBUG_ASSERT(msg != NULL);
 
-  m_sql_errno= sql_errno;
-  memcpy(m_returned_sqlstate, sqlstate, SQLSTATE_LENGTH);
-  m_returned_sqlstate[SQLSTATE_LENGTH]= '\0';
-
-  set_class_origin();
-  set_subclass_origin();
-  set_builtin_message_text(msg);
-  m_level= level;
-}
-
-void
-Sql_condition::set_builtin_message_text(const char* str)
+void Sql_condition::set_builtin_message_text(const char* str)
 {
   /*
     See the comments
@@ -300,32 +274,21 @@ Sql_condition::set_builtin_message_text(
   DBUG_ASSERT(! m_message_text.is_alloced());
 }
 
-const char*
-Sql_condition::get_message_text() const
-{
-  return m_message_text.ptr();
-}
 
-int
-Sql_condition::get_message_octet_length() const
-{
-  return m_message_text.length();
-}
-
-void
-Sql_condition::set_sqlstate(const char* sqlstate)
+void Sql_condition::set_sqlstate(const char* sqlstate)
 {
   memcpy(m_returned_sqlstate, sqlstate, SQLSTATE_LENGTH);
   m_returned_sqlstate[SQLSTATE_LENGTH]= '\0';
 }
 
+
 static LEX_CSTRING sqlstate_origin[]= {
   { STRING_WITH_LEN("ISO 9075") },
   { STRING_WITH_LEN("MySQL") }
 };
 
-void
-Sql_condition::set_class_origin()
+
+void Sql_condition::set_class_origin()
 {
   char cls[2];
   LEX_CSTRING *origin;
@@ -356,8 +319,8 @@ Sql_condition::set_class_origin()
   m_class_origin.set_ascii(origin->str, origin->length);
 }
 
-void
-Sql_condition::set_subclass_origin()
+
+void Sql_condition::set_subclass_origin()
 {
   LEX_CSTRING *origin;
 
@@ -378,28 +341,67 @@ Sql_condition::set_subclass_origin()
   m_subclass_origin.set_ascii(origin->str, origin->length);
 }
 
+
+void Sql_condition::clear()
+{
+  m_class_origin.length(0);
+  m_subclass_origin.length(0);
+  m_constraint_catalog.length(0);
+  m_constraint_schema.length(0);
+  m_constraint_name.length(0);
+  m_catalog_name.length(0);
+  m_schema_name.length(0);
+  m_table_name.length(0);
+  m_column_name.length(0);
+  m_cursor_name.length(0);
+  m_message_text.length(0);
+  m_sql_errno= 0;
+  m_level= Sql_condition::WARN_LEVEL_ERROR;
+}
+
+
 Diagnostics_area::Diagnostics_area()
- : m_main_wi(0, false), m_stacked_da(NULL)
+ : m_stacked_da(NULL),
+   m_error_condition(NULL),
+   m_allow_unlimited_warnings(false),
+   m_read_only(false),
+   m_current_statement_warn_count(0),
+   m_current_row_for_warning(1),
+   m_warn_id(0)
 {
+  /* Initialize sub structures */
+  init_sql_alloc(&m_warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
+  m_warn_list.empty();
+  memset(m_warn_count, 0, sizeof(m_warn_count));
   reset_diagnostics_area();
 }
 
+
 Diagnostics_area::Diagnostics_area(ulonglong warning_info_id,
                                    bool allow_unlimited_warnings)
- : m_main_wi(warning_info_id, allow_unlimited_warnings),
-   m_stacked_da(NULL)
+ : m_stacked_da(NULL),
+   m_error_condition(NULL),
+   m_allow_unlimited_warnings(allow_unlimited_warnings),
+   m_read_only(false),
+   m_current_statement_warn_count(0),
+   m_current_row_for_warning(1),
+   m_warn_id(warning_info_id)
 {
+  /* Initialize sub structures */
+  init_sql_alloc(&m_warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
+  m_warn_list.empty();
+  memset(m_warn_count, 0, sizeof(m_warn_count));
   reset_diagnostics_area();
 }
 
-/**
-  Clear this diagnostics area.
 
-  Normally called at the end of a statement.
-*/
+Diagnostics_area::~Diagnostics_area()
+{
+  free_root(&m_warn_root,MYF(0));
+}
 
-void
-Diagnostics_area::reset_diagnostics_area()
+
+void Diagnostics_area::reset_diagnostics_area()
 {
   DBUG_ENTER("reset_diagnostics_area");
 #ifdef DBUG_OFF
@@ -411,7 +413,7 @@ Diagnostics_area::reset_diagnostics_area
   m_last_insert_id= 0;
   m_statement_warn_count= 0;
 #endif
-  m_main_wi.clear_error_condition();
+  clear_error_condition();
   set_is_sent(false);
   /** Tiny reset in debug mode to see garbage right away */
   m_status= DA_EMPTY;
@@ -419,15 +421,9 @@ Diagnostics_area::reset_diagnostics_area
 }
 
 
-/**
-  Set OK status -- ends commands that do not return a
-  result set, e.g. INSERT/UPDATE/DELETE.
-*/
-
-void
-Diagnostics_area::set_ok_status(ulonglong affected_rows,
-                                ulonglong last_insert_id,
-                                const char *message)
+void Diagnostics_area::set_ok_status(ulonglong affected_rows,
+                                     ulonglong last_insert_id,
+                                     const char *message)
 {
   DBUG_ENTER("set_ok_status");
   DBUG_ASSERT(! is_set());
@@ -450,12 +446,7 @@ Diagnostics_area::set_ok_status(ulonglon
 }
 
 
-/**
-  Set EOF status.
-*/
-
-void
-Diagnostics_area::set_eof_status(THD *thd)
+void Diagnostics_area::set_eof_status(THD *thd)
 {
   DBUG_ENTER("set_eof_status");
   /* Only allowed to report eof if has not yet reported an error */
@@ -480,16 +471,8 @@ Diagnostics_area::set_eof_status(THD *th
   DBUG_VOID_RETURN;
 }
 
-/**
-  Set ERROR status in the Diagnostics Area. This function should be used to
-  report fatal errors (such as out-of-memory errors) when no further
-  processing is possible.
-
-  @param sql_errno        SQL-condition error number
-*/
 
-void
-Diagnostics_area::set_error_status(uint sql_errno)
+void Diagnostics_area::set_error_status(uint sql_errno)
 {
   set_error_status(sql_errno,
                    ER(sql_errno),
@@ -497,23 +480,11 @@ Diagnostics_area::set_error_status(uint
                    NULL);
 }
 
-/**
-  Set ERROR status in the Diagnostics Area.
-
-  @note error_condition may be NULL. It happens if a) OOM error is being
-  reported; or b) when Warning_info is full.
 
-  @param sql_errno        SQL-condition error number
-  @param message          SQL-condition message
-  @param sqlstate         SQL-condition state
-  @param error_condition  SQL-condition object representing the error state
-*/
-
-void
-Diagnostics_area::set_error_status(uint sql_errno,
-                                   const char *message,
-                                   const char *sqlstate,
-                                   const Sql_condition *error_condition)
+void Diagnostics_area::set_error_status(uint sql_errno,
+                                        const char *message,
+                                        const char *sqlstate,
+                                        const Sql_condition *error_condition)
 {
   DBUG_ENTER("set_error_status");
   /*
@@ -543,50 +514,22 @@ Diagnostics_area::set_error_status(uint
   m_sqlstate[SQLSTATE_LENGTH]= '\0';
   strmake(m_message, message, sizeof(m_message)-1);
 
-  m_main_wi.set_error_condition(error_condition);
+  set_error_condition(error_condition);
 
   m_status= DA_ERROR;
   DBUG_VOID_RETURN;
 }
 
 
-/**
-  Mark the diagnostics area as 'DISABLED'.
-
-  This is used in rare cases when the COM_ command at hand sends a response
-  in a custom format. One example is the query cache, another is
-  COM_STMT_PREPARE.
-*/
-
-void
-Diagnostics_area::disable_status()
+void Diagnostics_area::disable_status()
 {
   DBUG_ASSERT(! is_set());
   m_status= DA_DISABLED;
 }
 
-Warning_info::Warning_info(ulonglong warn_id_arg, bool allow_unlimited_warnings)
-  :m_current_statement_warn_count(0),
-  m_current_row_for_warning(1),
-  m_warn_id(warn_id_arg),
-  m_error_condition(NULL),
-  m_allow_unlimited_warnings(allow_unlimited_warnings),
-  m_read_only(FALSE)
-{
-  /* Initialize sub structures */
-  init_sql_alloc(&m_warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
-  m_warn_list.empty();
-  memset(m_warn_count, 0, sizeof(m_warn_count));
-}
-
-Warning_info::~Warning_info()
-{
-  free_root(&m_warn_root,MYF(0));
-}
-
 
-bool Warning_info::has_sql_condition(const char *message_str,
-                                     ulong message_length) const
+bool Diagnostics_area::has_sql_condition(const char *message_str,
+                                         ulong message_length) const
 {
   Diagnostics_area::Sql_condition_iterator it(m_warn_list);
   const Sql_condition *err;
@@ -601,9 +544,9 @@ bool Warning_info::has_sql_condition(con
 }
 
 
-void Warning_info::clear(ulonglong new_id)
+void Diagnostics_area::clear_warning_info(ulonglong new_id)
 {
-  id(new_id);
+  set_warning_info_id(new_id);
   m_warn_list.empty();
   m_marked_sql_conditions.empty();
   free_root(&m_warn_root, MYF(0));
@@ -614,7 +557,7 @@ void Warning_info::clear(ulonglong new_i
 }
 
 
-void Warning_info::append_warning_info(THD *thd, const Warning_info *source)
+void Diagnostics_area::append_warning_info(THD *thd, const Diagnostics_area *source)
 {
   const Sql_condition *err;
   Diagnostics_area::Sql_condition_iterator it(source->m_warn_list);
@@ -623,7 +566,7 @@ void Warning_info::append_warning_info(T
   while ((err= it++))
   {
     // Do not use ::push_warning() to avoid invocation of THD-internal-handlers.
-    Sql_condition *new_error= Warning_info::push_warning(thd, err);
+    Sql_condition *new_error= Diagnostics_area::push_warning(thd, err);
 
     if (src_error_condition && src_error_condition == err)
       set_error_condition(new_error);
@@ -637,7 +580,7 @@ void Warning_info::append_warning_info(T
 void Diagnostics_area::copy_non_errors_from_da(THD *thd,
                                                const Diagnostics_area *src_da)
 {
-  Sql_condition_iterator it(src_da->m_main_wi.m_warn_list);
+  Sql_condition_iterator it(src_da->m_warn_list);
   const Sql_condition *cond;
 
   while ((cond= it++))
@@ -645,15 +588,15 @@ void Diagnostics_area::copy_non_errors_f
     if (cond->get_level() == Sql_condition::WARN_LEVEL_ERROR)
       continue;
 
-    Sql_condition *new_condition= m_main_wi.push_warning(thd, cond);
+    Sql_condition *new_condition= push_warning(thd, cond);
 
-    if (src_da->m_main_wi.is_marked_for_removal(cond))
-      m_main_wi.mark_condition_for_removal(new_condition);
+    if (src_da->is_marked_for_removal(cond))
+      mark_condition_for_removal(new_condition);
   }
 }
 
 
-void Warning_info::mark_sql_conditions_for_removal()
+void Diagnostics_area::mark_sql_conditions_for_removal()
 {
   Sql_condition_list::Iterator it(m_warn_list);
   Sql_condition *cond;
@@ -663,7 +606,7 @@ void Warning_info::mark_sql_conditions_f
 }
 
 
-void Warning_info::remove_marked_sql_conditions()
+void Diagnostics_area::remove_marked_sql_conditions()
 {
   List_iterator_fast<Sql_condition> it(m_marked_sql_conditions);
   Sql_condition *cond;
@@ -681,7 +624,7 @@ void Warning_info::remove_marked_sql_con
 }
 
 
-bool Warning_info::is_marked_for_removal(const Sql_condition *cond) const
+bool Diagnostics_area::is_marked_for_removal(const Sql_condition *cond) const
 {
   List_iterator_fast<Sql_condition> it(
     const_cast<List<Sql_condition>&> (m_marked_sql_conditions));
@@ -697,16 +640,17 @@ bool Warning_info::is_marked_for_removal
 }
 
 
-void Warning_info::reserve_space(THD *thd, uint count)
+void Diagnostics_area::reserve_space(THD *thd, uint count)
 {
   while ((m_warn_list.elements() + count) > thd->variables.max_error_count)
     m_warn_list.remove(m_warn_list.front());
 }
 
-Sql_condition *Warning_info::push_warning(THD *thd,
-                                          uint sql_errno, const char* sqlstate,
-                                          Sql_condition::enum_warning_level level,
-                                          const char *msg)
+
+Sql_condition *Diagnostics_area::push_warning(THD *thd,
+                                              uint sql_errno, const char* sqlstate,
+                                              Sql_condition::enum_warning_level level,
+                                              const char *msg)
 {
   Sql_condition *cond= NULL;
 
@@ -715,10 +659,10 @@ Sql_condition *Warning_info::push_warnin
     if (m_allow_unlimited_warnings ||
         m_warn_list.elements() < thd->variables.max_error_count)
     {
-      cond= new (& m_warn_root) Sql_condition(& m_warn_root);
+      cond= new (& m_warn_root) Sql_condition(& m_warn_root, sql_errno,
+                                              sqlstate, level, msg);
       if (cond)
       {
-        cond->set(sql_errno, sqlstate, level, msg);
         m_warn_list.push_back(cond);
       }
     }
@@ -729,7 +673,8 @@ Sql_condition *Warning_info::push_warnin
   return cond;
 }
 
-Sql_condition *Warning_info::push_warning(THD *thd, const Sql_condition *sql_condition)
+
+Sql_condition *Diagnostics_area::push_warning(THD *thd, const Sql_condition *sql_condition)
 {
   Sql_condition *new_condition= push_warning(thd,
                                            sql_condition->get_sql_errno(),
@@ -748,7 +693,7 @@ void Diagnostics_area::push_diagnostics_
 {
   DBUG_ASSERT(da->m_stacked_da == NULL);
   da->m_stacked_da= this;
-  da->m_main_wi.append_warning_info(thd, &m_main_wi);
+  da->append_warning_info(thd, this);
 }
 
 

=== modified file 'sql/sql_error.h'
--- a/sql/sql_error.h	2012-07-04 13:47:16 +0000
+++ b/sql/sql_error.h	2012-07-04 14:06:47 +0000
@@ -48,13 +48,15 @@ public:
     Get the MESSAGE_TEXT of this condition.
     @return the message text.
   */
-  const char* get_message_text() const;
+  const char* get_message_text() const
+  { return m_message_text.ptr(); }
 
   /**
     Get the MESSAGE_OCTET_LENGTH of this condition.
     @return the length in bytes of the message text.
   */
-  int get_message_octet_length() const;
+  int get_message_octet_length() const
+  { return m_message_text.length(); }
 
   /**
     Get the SQLSTATE of this condition.
@@ -91,7 +93,7 @@ private:
     which should be used.
   */
   friend class THD;
-  friend class Warning_info;
+  friend class Diagnostics_area;
   friend class Sql_cmd_common_signal;
   friend class Sql_cmd_signal;
   friend class Sql_cmd_resignal;
@@ -99,25 +101,26 @@ private:
   friend class Condition_information_item;
 
   /**
-    Default constructor.
-    This constructor is usefull when allocating arrays.
-    Note that the init() method should be called to complete the Sql_condition.
-  */
-  Sql_condition();
+    Constructor.
 
-  /**
-    Complete the Sql_condition initialisation.
-    @param mem_root The memory root to use for the condition items
-    of this condition
+    @param mem_root Memory root to use for the condition items
+                    of this condition.
   */
-  void init(MEM_ROOT *mem_root);
+  Sql_condition(MEM_ROOT *mem_root);
 
   /**
     Constructor.
-    @param mem_root The memory root to use for the condition items
-    of this condition
-  */
-  Sql_condition(MEM_ROOT *mem_root);
+
+    @param mem_root   Memory root to use for the condition items
+                      of this condition.
+    @param sql_errno  Error number.
+    @param sqlstate   SQLSTATE.
+    @param level      Condition level - error, warning or note.
+    @param msg        Message text.
+  */
+  Sql_condition(MEM_ROOT *mem_root, uint sql_errno, const char* sqlstate,
+                Sql_condition::enum_warning_level level,
+                const char *msg);
 
   /** Destructor. */
   ~Sql_condition()
@@ -130,18 +133,6 @@ private:
   void copy_opt_attributes(const Sql_condition *cond);
 
   /**
-    Set this condition area with a fixed message text.
-    @param thd the current thread.
-    @param code the error number for this condition.
-    @param str the message text for this condition.
-    @param level the error level for this condition.
-    @param MyFlags additional flags.
-  */
-  void set(uint sql_errno, const char* sqlstate,
-           Sql_condition::enum_warning_level level,
-           const char* msg);
-
-  /**
     Set the condition message test.
     @param str Message text, expressed in the character set derived from
     the server --language option
@@ -157,9 +148,7 @@ private:
   /** Set the SUBCLASS_ORIGIN of this condition. */
   void set_subclass_origin();
 
-  /**
-    Clear this SQL condition.
-  */
+  /** Clear this SQL condition. */
   void clear();
 
 private:
@@ -218,307 +207,6 @@ private:
 
 ///////////////////////////////////////////////////////////////////////////
 
-/**
-  Information about warnings of the current connection.
-*/
-class Warning_info
-{
-  /** The type of the counted and doubly linked list of conditions. */
-  typedef I_P_List<Sql_condition,
-                   I_P_List_adapter<Sql_condition,
-                                    &Sql_condition::next_in_wi,
-                                    &Sql_condition::prev_in_wi>,
-                   I_P_List_counter,
-                   I_P_List_fast_push_back<Sql_condition> >
-          Sql_condition_list;
-
-  /** A memory root to allocate warnings and errors */
-  MEM_ROOT           m_warn_root;
-
-  /** List of warnings of all severities (levels). */
-  Sql_condition_list   m_warn_list;
-
-  /** A break down of the number of warnings per severity (level). */
-  uint	             m_warn_count[(uint) Sql_condition::WARN_LEVEL_END];
-
-  /**
-    The number of warnings of the current statement. Warning_info
-    life cycle differs from statement life cycle -- it may span
-    multiple statements. In that case we get
-    m_current_statement_warn_count 0, whereas m_warn_list is not empty.
-  */
-  uint	             m_current_statement_warn_count;
-
-  /*
-    Row counter, to print in errors and warnings. Not increased in
-    create_sort_index(); may differ from examined_row_count.
-  */
-  ulong              m_current_row_for_warning;
-
-  /** Used to optionally clear warnings only once per statement. */
-  ulonglong          m_warn_id;
-
-  /**
-    A pointer to an element of m_warn_list. It determines SQL-condition
-    instance which corresponds to the error state in Diagnostics_area.
-  
-    This is needed for properly processing SQL-conditions in SQL-handlers.
-    When an SQL-handler is found for the current error state in Diagnostics_area,
-    this pointer is needed to remove the corresponding SQL-condition from the
-    Warning_info list.
-  
-    @note m_error_condition might be NULL in the following cases:
-       - Diagnostics_area set to fatal error state (like OOM);
-       - Max number of Warning_info elements has been reached (thus, there is
-         no corresponding SQL-condition object in Warning_info).
-  */
-  const Sql_condition *m_error_condition;
-
-  /** Indicates if push_warning() allows unlimited number of warnings. */
-  bool               m_allow_unlimited_warnings;
-
-  /** Read only status. */
-  bool m_read_only;
-
-  List<Sql_condition> m_marked_sql_conditions;
-
-  Warning_info(ulonglong warn_id_arg, bool allow_unlimited_warnings);
-  ~Warning_info();
-
-  Warning_info(const Warning_info &rhs); /* Not implemented */
-  Warning_info& operator=(const Warning_info &rhs); /* Not implemented */
-
-  /**
-    Checks if Warning_info contains SQL-condition with the given message.
-
-    @param message_str    Message string.
-    @param message_length Length of message string.
-
-    @return true if the Warning_info contains an SQL-condition with the given
-    message.
-  */
-  bool has_sql_condition(const char *message_str, ulong message_length) const;
-
-  /**
-    Reset the warning information. Clear all warnings,
-    the number of warnings, reset current row counter
-    to point to the first row.
-
-    @param new_id new Warning_info id.
-  */
-  void clear(ulonglong new_id);
-
-  /**
-    Only clear warning info if haven't yet done that already
-    for the current query. Allows to be issued at any time
-    during the query, without risk of clearing some warnings
-    that have been generated by the current statement.
-
-    @todo: This is a sign of sloppy coding. Instead we need to
-    designate one place in a statement life cycle where we call
-    Warning_info::clear().
-
-    @param query_id Current query id.
-  */
-  void opt_clear(ulonglong query_id)
-  {
-    if (query_id != m_warn_id)
-      clear(query_id);
-  }
-
-  /**
-    Concatenate the list of warnings.
-
-    It's considered tolerable to lose an SQL-condition in case of OOM-error,
-    or if the number of SQL-conditions in the Warning_info reached top limit.
-
-    @param thd    Thread context.
-    @param source Warning_info object to copy SQL-conditions from.
-  */
-  void append_warning_info(THD *thd, const Warning_info *source);
-
-  /**
-    Reset between two COM_ commands. Warnings are preserved
-    between commands, but statement_warn_count indicates
-    the number of warnings of this particular statement only.
-  */
-  void reset_for_next_command()
-  { m_current_statement_warn_count= 0; }
-
-  /**
-    Mark active SQL-conditions for later removal.
-    This is done to simulate stacked DAs for HANDLER statements.
-  */
-  void mark_sql_conditions_for_removal();
-
-  /**
-    Unmark SQL-conditions, which were marked for later removal.
-    This is done to simulate stacked DAs for HANDLER statements.
-  */
-  void unmark_sql_conditions_from_removal()
-  { m_marked_sql_conditions.empty(); }
-
-  /**
-    Remove SQL-conditions that are marked for deletion.
-    This is done to simulate stacked DAs for HANDLER statements.
-  */
-  void remove_marked_sql_conditions();
-
-  /**
-    Check if the given SQL-condition is marked for removal in this Warning_info
-    instance.
-
-    @param cond the SQL-condition.
-
-    @retval true if the given SQL-condition is marked for removal in this
-                 Warning_info instance.
-    @retval false otherwise.
-  */
-  bool is_marked_for_removal(const Sql_condition *cond) const;
-
-  /**
-    Mark a single SQL-condition for removal (add the given SQL-condition to the
-    removal list of this Warning_info instance).
-  */
-  void mark_condition_for_removal(Sql_condition *cond)
-  { m_marked_sql_conditions.push_back(cond, &m_warn_root); }
-
-  /**
-    Used for @@warning_count system variable, which prints
-    the number of rows returned by SHOW WARNINGS.
-  */
-  ulong warn_count() const
-  {
-    /*
-      This may be higher than warn_list.elements() if we have
-      had more warnings than thd->variables.max_error_count.
-    */
-    return (m_warn_count[(uint) Sql_condition::WARN_LEVEL_NOTE] +
-            m_warn_count[(uint) Sql_condition::WARN_LEVEL_ERROR] +
-            m_warn_count[(uint) Sql_condition::WARN_LEVEL_WARN]);
-  }
-
-  /**
-    The number of errors, or number of rows returned by SHOW ERRORS,
-    also the value of session variable @@error_count.
-  */
-  ulong error_count() const
-  { return m_warn_count[(uint) Sql_condition::WARN_LEVEL_ERROR]; }
-
-  /**
-    The number of conditions (errors, warnings and notes) in the list.
-  */
-  uint cond_count() const
-  {
-    return m_warn_list.elements();
-  }
-
-  /** Id of the warning information area. */
-  ulonglong id() const { return m_warn_id; }
-
-  /** Set id of the warning information area. */
-  void id(ulonglong id) { m_warn_id= id; }
-
-  /** Do we have any errors and warnings that we can *show*? */
-  bool is_empty() const { return m_warn_list.is_empty(); }
-
-  /** Increment the current row counter to point at the next row. */
-  void inc_current_row_for_warning() { m_current_row_for_warning++; }
-
-  /** Reset the current row counter. Start counting from the first row. */
-  void reset_current_row_for_warning() { m_current_row_for_warning= 1; }
-
-  /** Return the current counter value. */
-  ulong current_row_for_warning() const { return m_current_row_for_warning; }
-
-  /** Return the number of warnings thrown by the current statement. */
-  ulong current_statement_warn_count() const
-  { return m_current_statement_warn_count; }
-
-  /** Make sure there is room for the given number of conditions. */
-  void reserve_space(THD *thd, uint count);
-
-  /**
-    Add a new SQL-condition to the current list and increment the respective
-    counters.
-
-    @param thd        Thread context.
-    @param sql_errno  SQL-condition error number.
-    @param sqlstate   SQL-condition state.
-    @param level      SQL-condition level.
-    @param msg        SQL-condition message.
-
-    @return a pointer to the added SQL-condition.
-  */
-  Sql_condition *push_warning(THD *thd,
-                              uint sql_errno,
-                              const char* sqlstate,
-                              Sql_condition::enum_warning_level level,
-                              const char* msg);
-
-  /**
-    Add a new SQL-condition to the current list and increment the respective
-    counters.
-
-    @param thd            Thread context.
-    @param sql_condition  SQL-condition to copy values from.
-
-    @return a pointer to the added SQL-condition.
-  */
-  Sql_condition *push_warning(THD *thd, const Sql_condition *sql_condition);
-
-  /**
-    Set the read only status for this statement area.
-    This is a privileged operation, reserved for the implementation of
-    diagnostics related statements, to enforce that the statement area is
-    left untouched during execution.
-    The diagnostics statements are:
-    - SHOW WARNINGS
-    - SHOW ERRORS
-    - GET DIAGNOSTICS
-    @param read_only the read only property to set.
-  */
-  void set_read_only(bool read_only)
-  { m_read_only= read_only; }
-
-  /**
-    Read only status.
-    @return the read only property.
-  */
-  bool is_read_only() const
-  { return m_read_only; }
-
-  /**
-    @return SQL-condition, which corresponds to the error state in
-    Diagnostics_area.
-
-    @see m_error_condition.
-  */
-  const Sql_condition *get_error_condition() const
-  { return m_error_condition; }
-
-  /**
-    Set SQL-condition, which corresponds to the error state in Diagnostics_area.
-
-    @see m_error_condition.
-  */
-  void set_error_condition(const Sql_condition *error_condition)
-  { m_error_condition= error_condition; }
-
-  /**
-    Reset SQL-condition, which corresponds to the error state in
-    Diagnostics_area.
-
-    @see m_error_condition.
-  */
-  void clear_error_condition()
-  { m_error_condition= NULL; }
-
-  // for:
-  //   - is_marked_for_removal()
-  friend class Diagnostics_area;
-};
-
 uint err_conv(char *buff, size_t to_length, const char *from,
               size_t from_length, const CHARSET_INFO *from_cs);
 
@@ -579,9 +267,18 @@ public:
 */
 class Diagnostics_area
 {
+  /** The type of the counted and doubly linked list of conditions. */
+  typedef I_P_List<Sql_condition,
+                   I_P_List_adapter<Sql_condition,
+                                    &Sql_condition::next_in_wi,
+                                    &Sql_condition::prev_in_wi>,
+                   I_P_List_counter,
+                   I_P_List_fast_push_back<Sql_condition> >
+          Sql_condition_list;
+
 public:
   /** Const iterator used to iterate through the warning list. */
-  typedef Warning_info::Sql_condition_list::Const_Iterator
+  typedef Sql_condition_list::Const_Iterator
     Sql_condition_iterator;
 
   enum enum_diagnostics_status
@@ -598,6 +295,10 @@ public:
     DA_DISABLED
   };
 
+  Diagnostics_area();
+  Diagnostics_area(ulonglong warning_info_id, bool allow_unlimited_warnings);
+  ~Diagnostics_area();
+
   void set_overwrite_status(bool can_overwrite_status)
   { m_can_overwrite_status= can_overwrite_status; }
 
@@ -605,21 +306,58 @@ public:
 
   void set_is_sent(bool is_sent) { m_is_sent= is_sent; }
 
+  /**
+    Set OK status -- ends commands that do not return a
+    result set, e.g. INSERT/UPDATE/DELETE.
+  */
   void set_ok_status(ulonglong affected_rows,
                      ulonglong last_insert_id,
                      const char *message);
 
+  /**
+    Set EOF status.
+  */
   void set_eof_status(THD *thd);
 
-  void set_error_status(uint sql_errno);
+  /**
+    Set ERROR status in the Diagnostics Area. This function should be used to
+    report fatal errors (such as out-of-memory errors) when no further
+    processing is possible.
+
+    @param sql_errno        SQL-condition error number
+  */
+  void set_error_status(uint sql_errno);
+
+  /**
+    Set ERROR status in the Diagnostics Area.
+
+    @note error_condition may be NULL. It happens if a) OOM error is being
+    reported; or b) when Warning_info is full.
 
+    @param sql_errno        SQL-condition error number
+    @param message          SQL-condition message
+    @param sqlstate         SQL-condition state
+    @param error_condition  SQL-condition object representing the error state
+  */
   void set_error_status(uint sql_errno,
                         const char *message,
                         const char *sqlstate,
                         const Sql_condition *error_condition);
 
+  /**
+    Mark the diagnostics area as 'DISABLED'.
+
+    This is used in rare cases when the COM_ command at hand sends a response
+    in a custom format. One example is the query cache, another is
+    COM_STMT_PREPARE.
+  */
   void disable_status();
 
+  /**
+    Clear this diagnostics area.
+
+    Normally called at the end of a statement.
+  */
   void reset_diagnostics_area();
 
   bool is_set() const { return m_status != DA_EMPTY; }
@@ -655,14 +393,13 @@ public:
     return m_statement_warn_count;
   }
 
-  Diagnostics_area();
-  Diagnostics_area(ulonglong warning_info_id, bool allow_unlimited_warnings);
-
+  /** Set id of the warning information area. */
   void set_warning_info_id(ulonglong id)
-  { m_main_wi.id(id); }
+  { m_warn_id= id; }
 
+  /** Id of the warning information area. */
   ulonglong warning_info_id() const
-  { return m_main_wi.id(); }
+  { return m_warn_id; }
 
   /**
     Compare given current and given diagnostic area
@@ -675,82 +412,188 @@ public:
     @return    false if they are equal, true if they are not.
   */
   bool diagnostics_area_changed(const Diagnostics_area *da) const
-  { return m_main_wi.id() != da->m_main_wi.id(); }
+  { return warning_info_id() != da->warning_info_id(); }
 
+  /** Do we have any errors and warnings that we can *show*? */
   bool is_warning_info_empty() const
-  { return m_main_wi.is_empty(); }
+  { return m_warn_list.is_empty(); }
 
+  /** Return the number of warnings thrown by the current statement. */
   ulong current_statement_warn_count() const
-  { return m_main_wi.current_statement_warn_count(); }
-
-  bool has_sql_condition(const char *message_str, ulong message_length) const
-  { return m_main_wi.has_sql_condition(message_str, message_length); }
+  { return m_current_statement_warn_count; }
 
+  /**
+    Reset between two COM_ commands. Warnings are preserved
+    between commands, but statement_warn_count indicates
+    the number of warnings of this particular statement only.
+  */
   void reset_for_next_command()
-  { m_main_wi.reset_for_next_command(); }
+  { m_current_statement_warn_count= 0; }
+
+  /**
+    Checks if Warning_info contains SQL-condition with the given message.
+
+    @param message_str    Message string.
+    @param message_length Length of message string.
+
+    @return true if the Warning_info contains an SQL-condition with the given
+    message.
+  */
+  bool has_sql_condition(const char *message_str, ulong message_length) const;
+
+  /**
+    Reset the warning information. Clear all warnings,
+    the number of warnings, reset current row counter
+    to point to the first row.
+
+    @param new_id new Warning_info id.
+  */
+  void clear_warning_info(ulonglong id);
+
+  /**
+    Only clear warning info if haven't yet done that already
+    for the current query. Allows to be issued at any time
+    during the query, without risk of clearing some warnings
+    that have been generated by the current statement.
 
-  void clear_warning_info(ulonglong id)
-  { m_main_wi.clear(id); }
+    @todo: This is a sign of sloppy coding. Instead we need to
+    designate one place in a statement life cycle where we call
+    Warning_info::clear().
 
+    @param query_id Current query id.
+  */
   void opt_clear_warning_info(ulonglong query_id)
-  { m_main_wi.opt_clear(query_id); }
+  {
+    if (query_id != m_warn_id)
+      clear_warning_info(query_id);
+  }
 
+  /** Return the current counter value. */
   ulong current_row_for_warning() const
-  { return m_main_wi.current_row_for_warning(); }
+  { return m_current_row_for_warning; }
 
+  /** Increment the current row counter to point at the next row. */
   void inc_current_row_for_warning()
-  { m_main_wi.inc_current_row_for_warning(); }
+  { m_current_row_for_warning++; }
 
+  /** Reset the current row counter. Start counting from the first row. */
   void reset_current_row_for_warning()
-  { m_main_wi.reset_current_row_for_warning(); }
+  { m_current_row_for_warning= 1; }
 
+  /**
+    Read only status.
+    @return the read only property.
+  */
   bool is_warning_info_read_only() const
-  { return m_main_wi.is_read_only(); }
+  { return m_read_only; }
 
+  /**
+    Set the read only status for this statement area.
+    This is a privileged operation, reserved for the implementation of
+    diagnostics related statements, to enforce that the statement area is
+    left untouched during execution.
+    The diagnostics statements are:
+    - SHOW WARNINGS
+    - SHOW ERRORS
+    - GET DIAGNOSTICS
+    @param read_only the read only property to set.
+  */
   void set_warning_info_read_only(bool read_only)
-  { m_main_wi.set_read_only(read_only); }
+  { m_read_only= read_only; }
 
+  /**
+    The number of errors, or number of rows returned by SHOW ERRORS,
+    also the value of session variable @@error_count.
+  */
   ulong error_count() const
-  { return m_main_wi.error_count(); }
+  { return m_warn_count[(uint) Sql_condition::WARN_LEVEL_ERROR]; }
 
+  /**
+    Used for @@warning_count system variable, which prints
+    the number of rows returned by SHOW WARNINGS.
+  */
   ulong warn_count() const
-  { return m_main_wi.warn_count(); }
+  {
+    /*
+      This may be higher than warn_list.elements() if we have
+      had more warnings than thd->variables.max_error_count.
+    */
+    return (m_warn_count[(uint) Sql_condition::WARN_LEVEL_NOTE] +
+            m_warn_count[(uint) Sql_condition::WARN_LEVEL_ERROR] +
+            m_warn_count[(uint) Sql_condition::WARN_LEVEL_WARN]);
+  }
 
+  /**
+    The number of conditions (errors, warnings and notes) in the list.
+  */
   uint cond_count() const
-  { return m_main_wi.cond_count(); }
+  { return m_warn_list.elements(); }
 
   Sql_condition_iterator sql_conditions() const
-  { return m_main_wi.m_warn_list; }
+  { return m_warn_list; }
+
+  /** Make sure there is room for the given number of conditions. */
+  void reserve_space(THD *thd, uint count);
+
+  /**
+    Add a new SQL-condition to the current list and increment the respective
+    counters.
+
+    @param thd            Thread context.
+    @param sql_condition  SQL-condition to copy values from.
+
+    @return a pointer to the added SQL-condition.
+  */
+  Sql_condition *push_warning(THD *thd, const Sql_condition *sql_condition);
 
-  void reserve_space(THD *thd, uint count)
-  { m_main_wi.reserve_space(thd, count); }
+  /**
+    Add a new SQL-condition to the current list and increment the respective
+    counters.
 
-  Sql_condition *push_warning(THD *thd, const Sql_condition *sql_condition)
-  { return m_main_wi.push_warning(thd, sql_condition); }
+    @param thd        Thread context.
+    @param sql_errno  SQL-condition error number.
+    @param sqlstate   SQL-condition state.
+    @param level      SQL-condition level.
+    @param msg        SQL-condition message.
 
+    @return a pointer to the added SQL-condition.
+  */
   Sql_condition *push_warning(THD *thd,
                               uint sql_errno,
                               const char* sqlstate,
                               Sql_condition::enum_warning_level level,
-                              const char* msg)
-  {
-    return m_main_wi.push_warning(thd, sql_errno, sqlstate, level, msg);
-  }
+                              const char* msg);
+
+  /**
+    @return SQL-condition, which corresponds to the error state in
+    Diagnostics_area.
 
-  void mark_sql_conditions_for_removal()
-  { m_main_wi.mark_sql_conditions_for_removal(); }
+    @see m_error_condition.
+  */
+  const Sql_condition *get_error_condition() const
+  { return m_error_condition; }
 
-  void unmark_sql_conditions_from_removal()
-  { m_main_wi.unmark_sql_conditions_from_removal(); }
+  /**
+    Mark active SQL-conditions for later removal.
+    This is done to simulate stacked DAs for HANDLER statements.
+  */
+  void mark_sql_conditions_for_removal();
 
-  void remove_marked_sql_conditions()
-  { m_main_wi.remove_marked_sql_conditions(); }
+  /**
+    Unmark SQL-conditions, which were marked for later removal.
+    This is done to simulate stacked DAs for HANDLER statements.
+  */
+  void unmark_sql_conditions_from_removal()
+  { m_marked_sql_conditions.empty(); }
 
-  const Sql_condition *get_error_condition() const
-  { return m_main_wi.get_error_condition(); }
+  /**
+    Remove SQL-conditions that are marked for deletion.
+    This is done to simulate stacked DAs for HANDLER statements.
+  */
+  void remove_marked_sql_conditions();
 
   void copy_sql_conditions_from_da(THD *thd, const Diagnostics_area *src_da)
-  { m_main_wi.append_warning_info(thd, &src_da->m_main_wi); }
+  { append_warning_info(thd, src_da); }
 
   /**
     Copy Sql_conditions that are not WARN_LEVEL_ERROR from the source
@@ -795,23 +638,106 @@ private:
   { return m_stacked_da; }
 
 private:
+  /**
+    Concatenate the list of warnings.
+
+    It's considered tolerable to lose an SQL-condition in case of OOM-error,
+    or if the number of SQL-conditions in the Warning_info reached top limit.
+
+    @param thd    Thread context.
+    @param source Warning_info object to copy SQL-conditions from.
+  */
+  void append_warning_info(THD *thd, const Diagnostics_area *source);
+
+  /**
+    Check if the given SQL-condition is marked for removal in this Warning_info
+    instance.
+
+    @param cond the SQL-condition.
+
+    @retval true if the given SQL-condition is marked for removal in this
+                 Warning_info instance.
+    @retval false otherwise.
+  */
+  bool is_marked_for_removal(const Sql_condition *cond) const;
+
+  /**
+    Mark a single SQL-condition for removal (add the given SQL-condition to the
+    removal list of this Warning_info instance).
+  */
+  void mark_condition_for_removal(Sql_condition *cond)
+  { m_marked_sql_conditions.push_back(cond, &m_warn_root); }
+
+  /**
+    Set SQL-condition, which corresponds to the error state in Diagnostics_area.
+
+    @see m_error_condition.
+  */
+  void set_error_condition(const Sql_condition *error_condition)
+  { m_error_condition= error_condition; }
+
+  /**
+    Reset SQL-condition, which corresponds to the error state in
+    Diagnostics_area.
+
+    @see m_error_condition.
+  */
+  void clear_error_condition()
+  { m_error_condition= NULL; }
+
+private:
+  /** Pointer to the diagnostic area below on the stack. */
+  Diagnostics_area *m_stacked_da;
+
+  /** A memory root to allocate warnings and errors */
+  MEM_ROOT           m_warn_root;
+
+  /** List of warnings of all severities (levels). */
+  Sql_condition_list   m_warn_list;
+
+  /**
+    A pointer to an element of m_warn_list. It determines SQL-condition
+    instance which corresponds to the error state in Diagnostics_area.
+
+    This is needed for properly processing SQL-conditions in SQL-handlers.
+    When an SQL-handler is found for the current error state in Diagnostics_area,
+    this pointer is needed to remove the corresponding SQL-condition from the
+    Warning_info list.
+
+    @note m_error_condition might be NULL in the following cases:
+       - Diagnostics_area set to fatal error state (like OOM);
+       - Max number of Warning_info elements has been reached (thus, there is
+         no corresponding SQL-condition object in Warning_info).
+  */
+  const Sql_condition *m_error_condition;
+
+  List<Sql_condition> m_marked_sql_conditions;
+
   /** True if status information is sent to the client. */
   bool m_is_sent;
 
   /** Set to make set_error_status after set_{ok,eof}_status possible. */
   bool m_can_overwrite_status;
 
+  /** Indicates if push_warning() allows unlimited number of warnings. */
+  bool m_allow_unlimited_warnings;
+
+  /** Read only status. */
+  bool m_read_only;
+
   /** Message buffer. Can be used by OK or ERROR status. */
   char m_message[MYSQL_ERRMSG_SIZE];
 
+  char m_sqlstate[SQLSTATE_LENGTH+1];
+
+  enum_diagnostics_status m_status;
+
   /**
     SQL error number. One of ER_ codes from share/errmsg.txt.
     Set by set_error_status.
   */
   uint m_sql_errno;
 
-  char m_sqlstate[SQLSTATE_LENGTH+1];
-
   /**
     The number of rows affected by the last statement. This is
     semantically close to thd->row_count_func, but has a different
@@ -840,12 +766,25 @@ private:
   */
   uint	     m_statement_warn_count;
 
-  enum_diagnostics_status m_status;
+  /**
+    The number of warnings of the current statement. Warning_info
+    life cycle differs from statement life cycle -- it may span
+    multiple statements. In that case we get
+    m_current_statement_warn_count 0, whereas m_warn_list is not empty.
+  */
+  uint	             m_current_statement_warn_count;
 
-  Warning_info m_main_wi;
+  /** A break down of the number of warnings per severity (level). */
+  uint	             m_warn_count[(uint) Sql_condition::WARN_LEVEL_END];
 
-  /** Pointer to the diagnostic area below on the stack. */
-  Diagnostics_area *m_stacked_da;
+  /**
+    Row counter, to print in errors and warnings. Not increased in
+    create_sort_index(); may differ from examined_row_count.
+  */
+  ulong              m_current_row_for_warning;
+
+  /** Used to optionally clear warnings only once per statement. */
+  ulonglong          m_warn_id;
 
   friend class THD;
 };

=== modified file 'sql/sql_signal.cc'
--- a/sql/sql_signal.cc	2012-03-19 17:59:14 +0000
+++ b/sql/sql_signal.cc	2012-07-04 14:06:47 +0000
@@ -18,6 +18,7 @@
 #include "sp_pcontext.h"
 #include "sp_rcontext.h"
 #include "sql_signal.h"
+#include "sql_error.h"
 
 /*
   The parser accepts any error code (desired)
@@ -123,15 +124,15 @@ void Sql_cmd_common_signal::eval_default
 
   DBUG_ASSERT(sqlstate);
   /* SQLSTATE class "00": illegal, rejected in the parser. */
-  DBUG_ASSERT((sqlstate[0] != '0') || (sqlstate[1] != '0'));
+  DBUG_ASSERT(!is_sqlstate_completion(sqlstate));
 
-  if ((sqlstate[0] == '0') && (sqlstate[1] == '1'))
+  if (is_sqlstate_warning(sqlstate))
   {
     /* SQLSTATE class "01": warning. */
     assign_defaults(cond, set_defaults,
                     Sql_condition::WARN_LEVEL_WARN, ER_SIGNAL_WARN);
   }
-  else if ((sqlstate[0] == '0') && (sqlstate[1] == '2'))
+  else if (is_sqlstate_not_found(sqlstate))
   {
     /* SQLSTATE class "02": not found. */
     assign_defaults(cond, set_defaults,
@@ -503,11 +504,11 @@ bool Sql_cmd_resignal::execute(THD *thd)
     DBUG_RETURN(true);
   }
 
-  Sql_condition signaled_err(thd->mem_root);
-  signaled_err.set(signaled->sql_errno,
-                   signaled->sql_state,
-                   signaled->level,
-                   signaled->message);
+  Sql_condition signaled_err(thd->mem_root,
+                             signaled->sql_errno,
+                             signaled->sql_state,
+                             signaled->level,
+                             signaled->message);
 
 
   if (m_cond) // RESIGNAL with signal_value.

No bundle (reason: useless for push emails).
Thread
bzr push into mysql-trunk-wl6406 branch (jon.hauglid:3969 to 3970) WL#6406Jon Olav Hauglid4 Jul