refactor THD::raise_condition() family

to remove

Sql_condition*
raise_condition(const Sql_condition *cond)
{
  Sql_condition *raised= raise_condition(cond->get_sql_errno(),
                                         cond->get_sqlstate(),
                                         cond->get_level(),
                                         *cond,
                                         cond->get_message_text());
  return raised;
}

10 files changed, 79 insertions, 120 deletions

diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 84ca70574d5..4e5c61ec00b 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -3269,7 +3269,7 @@ void my_message_sql(uint error, const char *str, myf MyFlags)
   {
     if (unlikely(MyFlags & ME_FATAL))
       thd->is_fatal_error= 1;
-    (void) thd->raise_condition(error, NULL, level, str);
+    (void) thd->raise_condition(error, "\0\0\0\0\0", level, str);
   }
   else
     mysql_audit_general(0, MYSQL_AUDIT_GENERAL_ERROR, error, str);
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index c5a0baaaa80..ac050eb2fd4 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -965,10 +965,8 @@ Internal_error_handler *THD::pop_internal_handler()
 void THD::raise_error(uint sql_errno)
 {
   const char* msg= ER_THD(this, sql_errno);
-  (void) raise_condition(sql_errno,
-                         NULL,
-                         Sql_condition::WARN_LEVEL_ERROR,
-                         msg);
+  (void) raise_condition(sql_errno, "\0\0\0\0\0",
+                         Sql_condition::WARN_LEVEL_ERROR, msg);
 }
 
 void THD::raise_error_printf(uint sql_errno, ...)
@@ -981,20 +979,16 @@ void THD::raise_error_printf(uint sql_errno, ...)
   va_start(args, sql_errno);
   my_vsnprintf(ebuff, sizeof(ebuff), format, args);
   va_end(args);
-  (void) raise_condition(sql_errno,
-                         NULL,
-                         Sql_condition::WARN_LEVEL_ERROR,
-                         ebuff);
+  (void) raise_condition(sql_errno, "\0\0\0\0\0",
+                         Sql_condition::WARN_LEVEL_ERROR, ebuff);
   DBUG_VOID_RETURN;
 }
 
 void THD::raise_warning(uint sql_errno)
 {
   const char* msg= ER_THD(this, sql_errno);
-  (void) raise_condition(sql_errno,
-                         NULL,
-                         Sql_condition::WARN_LEVEL_WARN,
-                         msg);
+  (void) raise_condition(sql_errno, "\0\0\0\0\0",
+                         Sql_condition::WARN_LEVEL_WARN, msg);
 }
 
 void THD::raise_warning_printf(uint sql_errno, ...)
@@ -1007,10 +1001,8 @@ void THD::raise_warning_printf(uint sql_errno, ...)
   va_start(args, sql_errno);
   my_vsnprintf(ebuff, sizeof(ebuff), format, args);
   va_end(args);
-  (void) raise_condition(sql_errno,
-                         NULL,
-                         Sql_condition::WARN_LEVEL_WARN,
-                         ebuff);
+  (void) raise_condition(sql_errno, "\0\0\0\0\0",
+                         Sql_condition::WARN_LEVEL_WARN, ebuff);
   DBUG_VOID_RETURN;
 }
 
@@ -1021,10 +1013,8 @@ void THD::raise_note(uint sql_errno)
   if (!(variables.option_bits & OPTION_SQL_NOTES))
     DBUG_VOID_RETURN;
   const char* msg= ER_THD(this, sql_errno);
-  (void) raise_condition(sql_errno,
-                         NULL,
-                         Sql_condition::WARN_LEVEL_NOTE,
-                         msg);
+  (void) raise_condition(sql_errno, "\0\0\0\0\0",
+                         Sql_condition::WARN_LEVEL_NOTE, msg);
   DBUG_VOID_RETURN;
 }
 
@@ -1040,21 +1030,20 @@ void THD::raise_note_printf(uint sql_errno, ...)
   va_start(args, sql_errno);
   my_vsnprintf(ebuff, sizeof(ebuff), format, args);
   va_end(args);
-  (void) raise_condition(sql_errno,
-                         NULL,
-                         Sql_condition::WARN_LEVEL_NOTE,
-                         ebuff);
+  (void) raise_condition(sql_errno, "\0\0\0\0\0",
+                         Sql_condition::WARN_LEVEL_NOTE, ebuff);
   DBUG_VOID_RETURN;
 }
 
-Sql_condition* THD::raise_condition(uint sql_errno,
-                                    const char* sqlstate,
-                                    Sql_condition::enum_warning_level level,
-                                    const Sql_user_condition_identity &ucid,
-                                    const char* msg)
+Sql_condition* THD::raise_condition(const Sql_condition *cond)
 {
+  uint sql_errno= cond->get_sql_errno();
+  const char *sqlstate= cond->get_sqlstate();
+  Sql_condition::enum_warning_level level= cond->get_level();
+  const char *msg= cond->get_message_text();
+
   Diagnostics_area *da= get_stmt_da();
-  Sql_condition *cond= NULL;
+  Sql_condition *raised= NULL;
   DBUG_ENTER("THD::raise_condition");
   DBUG_ASSERT(level < Sql_condition::WARN_LEVEL_END);
 
@@ -1082,22 +1071,18 @@ Sql_condition* THD::raise_condition(uint sql_errno,
     sql_errno= ER_UNKNOWN_ERROR;
   if (msg == NULL)
     msg= ER_THD(this, sql_errno);
-  if (sqlstate == NULL)
+  if (!*sqlstate)
    sqlstate= mysql_errno_to_sqlstate(sql_errno);
 
-  if ((level == Sql_condition::WARN_LEVEL_WARN) &&
-      really_abort_on_warning())
+  if ((level == Sql_condition::WARN_LEVEL_WARN) && really_abort_on_warning())
   {
-    /*
-      FIXME:
-      push_warning and strict SQL_MODE case.
-    */
+    /* FIXME: push_warning and strict SQL_MODE case. */
     level= Sql_condition::WARN_LEVEL_ERROR;
   }
 
   if (!is_fatal_error &&
-      handle_condition(sql_errno, sqlstate, &level, msg, &cond))
-    DBUG_RETURN(cond);
+      handle_condition(sql_errno, sqlstate, &level, msg, &raised))
+    goto ret;
 
   switch (level) {
   case Sql_condition::WARN_LEVEL_NOTE:
@@ -1122,8 +1107,7 @@ Sql_condition* THD::raise_condition(uint sql_errno,
       With wsrep we allow converting BF abort error to warning if
       errors are ignored.
      */
-    if (!is_fatal_error &&
-        no_errors       &&
+    if (!is_fatal_error && no_errors &&
         (wsrep_trx().bf_aborted() || wsrep_retry_counter))
     {
       WSREP_DEBUG("BF abort error converted to warning");
@@ -1134,7 +1118,7 @@ Sql_condition* THD::raise_condition(uint sql_errno,
       if (!da->is_error())
       {
 	set_row_count_func(-1);
-	da->set_error_status(sql_errno, msg, sqlstate, ucid, cond);
+	da->set_error_status(sql_errno, msg, sqlstate, *cond, raised);
       }
     }
   }
@@ -1149,10 +1133,13 @@ Sql_condition* THD::raise_condition(uint sql_errno,
   if (likely(!(is_fatal_error && (sql_errno == EE_OUTOFMEMORY ||
                                   sql_errno == ER_OUTOFMEMORY))))
   {
-    cond= da->push_warning(this, sql_errno, sqlstate, level, ucid, msg,
-                           da->current_row_for_warning());
+    raised= da->push_warning(this, sql_errno, sqlstate, level, *cond, msg,
+                             cond->m_row_number);
   }
-  DBUG_RETURN(cond);
+ret:
+  if (raised)
+    raised->copy_opt_attributes(cond);
+  DBUG_RETURN(raised);
 }
 
 extern "C"
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 242d622a9a0..f35a2daaba5 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -4801,45 +4801,17 @@ private:
     @param msg the condition message text
     @return The condition raised, or NULL
   */
-  Sql_condition*
-  raise_condition(uint sql_errno,
-                  const char* sqlstate,
-                  Sql_condition::enum_warning_level level,
-                  const char* msg)
+  Sql_condition* raise_condition(uint sql_errno, const char* sqlstate,
+                  Sql_condition::enum_warning_level level, const char* msg)
   {
-    return raise_condition(sql_errno, sqlstate, level,
-                           Sql_user_condition_identity(), msg);
+    Sql_condition cond(NULL, // don't strdup the msg
+                       Sql_condition_identity(sql_errno, sqlstate, level,
+                                              Sql_user_condition_identity()),
+                       msg, get_stmt_da()->current_row_for_warning());
+    return raise_condition(&cond);
   }
 
-  /**
-    Raise a generic or a user defined SQL condition.
-    @param ucid      - the user condition identity
-                       (or an empty identity if not a user condition)
-    @param sql_errno - the condition error number
-    @param sqlstate  - the condition SQLSTATE
-    @param level     - the condition level
-    @param msg       - the condition message text
-    @return The condition raised, or NULL
-  */
-  Sql_condition*
-  raise_condition(uint sql_errno,
-                  const char* sqlstate,
-                  Sql_condition::enum_warning_level level,
-                  const Sql_user_condition_identity &ucid,
-                  const char* msg);
-
-  Sql_condition*
-  raise_condition(const Sql_condition *cond)
-  {
-    Sql_condition *raised= raise_condition(cond->get_sql_errno(),
-                                           cond->get_sqlstate(),
-                                           cond->get_level(),
-                                           *cond/*Sql_user_condition_identity*/,
-                                           cond->get_message_text());
-    if (raised)
-      raised->copy_opt_attributes(cond);
-    return raised;
-  }
+  Sql_condition* raise_condition(const Sql_condition *cond);
 
 private:
   void push_warning_truncated_priv(Sql_condition::enum_warning_level level,
diff --git a/sql/sql_error.cc b/sql/sql_error.cc
index 9251a73cb06..85be61c34ef 100644
--- a/sql/sql_error.cc
+++ b/sql/sql_error.cc
@@ -217,7 +217,7 @@ Sql_condition::set_builtin_message_text(const char* str)
   */
   const char* copy;
 
-  copy= strdup_root(m_mem_root, str);
+  copy= m_mem_root ? strdup_root(m_mem_root, str) : str;
   m_message_text.set(copy, strlen(copy), error_message_charset_info);
   DBUG_ASSERT(! m_message_text.is_alloced());
 }
@@ -727,7 +727,7 @@ void push_warning(THD *thd, Sql_condition::enum_warning_level level,
   if (level == Sql_condition::WARN_LEVEL_ERROR)
     level= Sql_condition::WARN_LEVEL_WARN;
 
-  (void) thd->raise_condition(code, NULL, level, msg);
+  (void) thd->raise_condition(code, "\0\0\0\0\0", level, msg);
 
   /* Make sure we also count warnings pushed after calling set_ok_status(). */
   thd->get_stmt_da()->increment_warning();
diff --git a/sql/sql_error.h b/sql/sql_error.h
index a1cc34a63ee..d9d7f420baa 100644
--- a/sql/sql_error.h
+++ b/sql/sql_error.h
@@ -443,7 +443,6 @@ private:
                 const char *msg, ulong current_row_for_warning)
    : Sql_condition_identity(value), m_mem_root(mem_root)
   {
-    DBUG_ASSERT(mem_root != NULL);
     DBUG_ASSERT(value.get_sql_errno() != 0);
     DBUG_ASSERT(msg != NULL);
     set_builtin_message_text(msg);
@@ -746,10 +745,8 @@ private:
 
     @return a pointer to the added SQL-condition.
   */
-  Sql_condition *push_warning(THD *thd,
-                              const Sql_condition_identity *identity,
-                              const char* msg,
-                              ulong current_row_number);
+  Sql_condition *push_warning(THD *thd, const Sql_condition_identity *identity,
+                              const char* msg, ulong current_row_number);
 
   /**
     Add a new SQL-condition to the current list and increment the respective
diff --git a/storage/connect/bsonudf.cpp b/storage/connect/bsonudf.cpp
index d735bbee491..f513ffbdeab 100644
--- a/storage/connect/bsonudf.cpp
+++ b/storage/connect/bsonudf.cpp
@@ -9,6 +9,7 @@
 /*********************************************************************************/
 #include <my_global.h>
 #include <mysqld.h>
+#include <mysqld_error.h>
 #include <mysql.h>
 #include <sql_error.h>
 #include <stdio.h>
@@ -22,7 +23,7 @@
 
 #define MEMFIX  4096
 #if defined(connect_EXPORTS)
-#define PUSH_WARNING(M) push_warning(current_thd, Sql_condition::WARN_LEVEL_WARN, 0, M)
+#define PUSH_WARNING(M) push_warning(current_thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, M)
 #else
 #define PUSH_WARNING(M) htrc(M)
 #endif
diff --git a/storage/connect/ha_connect.cc b/storage/connect/ha_connect.cc
index f49b6d692b3..f3e40afc3b0 100644
--- a/storage/connect/ha_connect.cc
+++ b/storage/connect/ha_connect.cc
@@ -516,7 +516,7 @@ void SetWorkSize(size_t)
 {
   // Changing the session variable value seems to be impossible here
   // and should be done in a check function 
-  push_warning(current_thd, Sql_condition::WARN_LEVEL_WARN, 0, 
+  push_warning(current_thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, 
     "Work size too big, try setting a smaller value");
 } // end of SetWorkSize
 
@@ -719,7 +719,7 @@ void PushWarning(PGLOBAL g, THD *thd, int level)
     Sql_condition::enum_warning_level wlvl;
 
     wlvl= (Sql_condition::enum_warning_level)level;
-    push_warning(thd, wlvl, 0, g->Message);
+    push_warning(thd, wlvl, ER_UNKNOWN_ERROR, g->Message);
   } else
     htrc("%s\n", g->Message);
 
@@ -2298,7 +2298,7 @@ int ha_connect::MakeRecord(char *buf)
             fp->field_name.str,
             thd->get_stmt_da()->current_row_for_warning());
 
-          push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, buf);
+          push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, buf);
           DBUG_PRINT("MakeRecord", ("%s", buf));
           rc= 0;
         } else if (rc < 0)
@@ -3591,7 +3591,7 @@ int ha_connect::optimize(THD* thd, HA_CHECK_OPT*)
 
 			if ((rc= ((PTDBASE)tdbp)->ResetTableOpt(g, dop, dox))) {
 				if (rc == RC_INFO) {
-					push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+					push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
 					rc= 0;
 				} else
 					rc= HA_ERR_CRASHED_ON_USAGE;		// Table must be repaired
@@ -4816,7 +4816,7 @@ int ha_connect::start_stmt(THD *thd, thr_lock_type lock_type)
 	if (newmode == MODE_ANY) {
 		if (CloseTable(g)) {
 			// Make error a warning to avoid crash
-			push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+			push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
 			rc= 0;
 		} // endif Close
 
@@ -4898,18 +4898,18 @@ int ha_connect::external_lock(THD *thd, int lock_type)
                            && sqlcom != SQLCOM_BEGIN
                            && sqlcom != SQLCOM_DROP_TABLE) {
       sprintf(g->Message, "external_lock: unexpected command %d", sqlcom);
-      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
       DBUG_RETURN(0);
     } else if (g->Xchk) {
       if (!tdbp) {
 				if (!(tdbp= GetTDB(g))) {
 //        DBUG_RETURN(HA_ERR_INTERNAL_ERROR);  causes assert error
-					push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+					push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
 					DBUG_RETURN(0);
 				} else if (!tdbp->GetDef()->Indexable()) {
           sprintf(g->Message, "external_lock: Table %s is not indexable", tdbp->GetName());
 //        DBUG_RETURN(HA_ERR_INTERNAL_ERROR);  causes assert error
-          push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+          push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
           DBUG_RETURN(0);
         } else if (tdbp->GetDef()->Indexable() == 1) {
           bool    oldsep= ((PCHK)g->Xchk)->oldsep;
@@ -4988,7 +4988,7 @@ int ha_connect::external_lock(THD *thd, int lock_type)
             if (tdp->MakeIndex(g, adp, true) == RC_FX) {
               // Make it a warning to avoid crash
               //push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 
-              //                  0, g->Message);
+              //             ER_UNKNOWN_ERROR, g->Message);
               //rc= 0;
 							my_message(ER_TOO_MANY_KEYS, g->Message, MYF(0));
 							rc= HA_ERR_INDEX_CORRUPT;
@@ -4998,7 +4998,7 @@ int ha_connect::external_lock(THD *thd, int lock_type)
           if (CheckVirtualIndex(NULL)) {
             // Make it a warning to avoid crash
             push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 
-                              0, g->Message);
+                         ER_UNKNOWN_ERROR, g->Message);
             rc= 0;
             } // endif Check
 
@@ -5011,7 +5011,7 @@ int ha_connect::external_lock(THD *thd, int lock_type)
     if (CloseTable(g)) {
       // This is an error while builing index
       // Make it a warning to avoid crash
-      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
       rc= 0;
 		} // endif Close
 
@@ -5722,7 +5722,7 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 			topt->type= (src) ? "MYSQL" : (tab) ? "PROXY" : "DOS";
 			ttp= GetTypeID(topt->type);
 			sprintf(g->Message, "No table_type. Was set to %s", topt->type);
-			push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, 0, g->Message);
+			push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, ER_UNKNOWN_ERROR, g->Message);
 		} else if (ttp == TAB_NIY) {
 			sprintf(g->Message, "Unsupported table type %s", topt->type);
 			rc= HA_ERR_INTERNAL_ERROR;
@@ -5732,7 +5732,7 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
       if (ttp == TAB_UNDEF) {
         ttr= TAB_JSON;
         strcpy(g->Message, "No table_type. Was set to JSON");
-        push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, 0, g->Message);
+        push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, ER_UNKNOWN_ERROR, g->Message);
       } else
         ttr= ttp;
 
@@ -6295,7 +6295,7 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 								// Skip this column
 								sprintf(g->Message, "Column %s skipped (unsupported type %d)",
 									cnm, typ);
-								push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+								push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
 								continue;
 							} else {
 								sprintf(g->Message, "Unsupported SQL type %d", typ);
@@ -6310,7 +6310,7 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 							case TYPE_STRING:
 								if (w) {
 									sprintf(g->Message, "Column %s is wide characters", cnm);
-									push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, 0, g->Message);
+									push_warning(thd, Sql_condition::WARN_LEVEL_NOTE, ER_UNKNOWN_ERROR, g->Message);
 								} // endif w
 
 								break;
@@ -6337,7 +6337,7 @@ static int connect_assisted_discovery(handlerton *, THD* thd,
 									// Skip this column
 									sprintf(g->Message, "Column %s skipped (unsupported type %d)",
 										cnm, typ);
-									push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+									push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
 									continue;
 								} else {
 									sprintf(g->Message, "Unsupported SQL type %d", typ);
@@ -6502,7 +6502,7 @@ int ha_connect::create(const char *name, TABLE *table_arg,
     sprintf(g->Message, "No table_type. Will be set to %s", options->type);
 
     if (sqlcom == SQLCOM_CREATE_TABLE)
-      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
 
   } else if (type == TAB_NIY) {
     sprintf(g->Message, "Unsupported table type %s", options->type);
@@ -6551,7 +6551,7 @@ int ha_connect::create(const char *name, TABLE *table_arg,
       case TAB_OCCUR:
         if (options->srcdef) {
           strcpy(g->Message, "Cannot check looping reference");
-          push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+          push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
         } else if (options->tabname) {
           if (!stricmp(options->tabname, create_info->alias.str) &&
              (!options->dbname || 
@@ -6847,7 +6847,7 @@ int ha_connect::create(const char *name, TABLE *table_arg,
       sprintf(g->Message, "No file name. Table will use %s", buf);
   
       if (sqlcom == SQLCOM_CREATE_TABLE)
-        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
   
       strcat(strcat(strcpy(dbpath, "./"), table->s->db.str), "/");
     } // endif part_info
@@ -6860,12 +6860,12 @@ int ha_connect::create(const char *name, TABLE *table_arg,
       else
         sprintf(g->Message, "Error %d creating file %s", errno, fn);
 
-      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
     } else
       ::close(h);
     
     if ((type == TAB_FMT || options->readonly) && sqlcom == SQLCOM_CREATE_TABLE)
-      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0,
+      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
         "Congratulation, you just created a read-only void table!");
 
     } // endif sqlcom
@@ -6911,7 +6911,7 @@ int ha_connect::create(const char *name, TABLE *table_arg,
           sqlcom == SQLCOM_CREATE_INDEX || sqlcom == SQLCOM_DROP_INDEX))  
 //         (sqlcom == SQLCOM_CREATE_INDEX && part_info) ||  
 //         (sqlcom == SQLCOM_DROP_INDEX && part_info)))  
-      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0,
+      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
         "Unexpected command in create, please contact CONNECT team");
 
     if (part_info && !inward)
@@ -6922,7 +6922,7 @@ int ha_connect::create(const char *name, TABLE *table_arg,
         (!IsFileType(type) || FileExists(options->filename, false))) {
       if (part_info) {
         sprintf(g->Message, "Data repartition in %s is unchecked", partname); 
-        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
       } else if (sqlcom == SQLCOM_ALTER_TABLE) {
         // This is an ALTER to CONNECT from another engine.
         // It cannot be accepted because the table data would be modified
@@ -7035,7 +7035,7 @@ bool ha_connect::FileExists(const char *fn, bool bf)
         char buf[_MAX_PATH + 20];
 
         sprintf(buf, "Error %d for file %s", errno, filename);
-        push_warning(table->in_use, Sql_condition::WARN_LEVEL_WARN, 0, buf);
+        push_warning(table->in_use, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, buf);
         return true;
       } else
         return false;
@@ -7337,7 +7337,7 @@ fin:
     DBUG_RETURN(HA_ALTER_ERROR);
   } else if (outward) {
     if (IsFileType(type))
-      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0,
+      push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
         "This is an outward table, table data were not modified.");
 
     DBUG_RETURN(HA_ALTER_INPLACE_EXCLUSIVE_LOCK);
@@ -7363,7 +7363,7 @@ bool ha_connect::check_if_incompatible_data(HA_CREATE_INFO *, uint)
 {
   DBUG_ENTER("ha_connect::check_if_incompatible_data");
   // TO DO: really implement and check it.
-  push_warning(ha_thd(), Sql_condition::WARN_LEVEL_WARN, 0,
+  push_warning(ha_thd(), Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
       "Unexpected call to check_if_incompatible_data.");
   DBUG_RETURN(COMPATIBLE_DATA_NO);
 } // end of check_if_incompatible_data
diff --git a/storage/connect/jsonudf.cpp b/storage/connect/jsonudf.cpp
index d38cf52699a..4a92990d233 100644
--- a/storage/connect/jsonudf.cpp
+++ b/storage/connect/jsonudf.cpp
@@ -9,6 +9,7 @@
 /*********************************************************************************/
 #include <my_global.h>
 #include <mysqld.h>
+#include <mysqld_error.h>
 #include <mysql.h>
 #include <sql_error.h>
 #include <m_string.h>
@@ -21,7 +22,7 @@
 
 #define MEMFIX  4096
 #if defined(connect_EXPORTS)
-#define PUSH_WARNING(M) push_warning(current_thd, Sql_condition::WARN_LEVEL_WARN, 0, M)
+#define PUSH_WARNING(M) push_warning(current_thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, M)
 #else
 #define PUSH_WARNING(M) htrc(M)
 #endif
diff --git a/storage/connect/tabrest.cpp b/storage/connect/tabrest.cpp
index c66d8d76f3d..d1975dae32d 100644
--- a/storage/connect/tabrest.cpp
+++ b/storage/connect/tabrest.cpp
@@ -12,6 +12,7 @@
 /***********************************************************************/
 #include <my_global.h>    // All MariaDB stuff
 #include <mysqld.h>
+#include <mysqld_error.h>
 #include <sql_error.h>
 #if !defined(_WIN32) && !defined(_WINDOWS)
 #include <sys/types.h>
@@ -37,7 +38,7 @@
 #include "tabrest.h"
 
 #if defined(connect_EXPORTS)
-#define PUSH_WARNING(M) push_warning(current_thd, Sql_condition::WARN_LEVEL_NOTE, 0, M)
+#define PUSH_WARNING(M) push_warning(current_thd, Sql_condition::WARN_LEVEL_NOTE, ER_UNKNOWN_ERROR, M)
 #else
 #define PUSH_WARNING(M) htrc(M)
 #endif
diff --git a/storage/connect/tabutil.cpp b/storage/connect/tabutil.cpp
index 15305cc856b..9730f8a6981 100644
--- a/storage/connect/tabutil.cpp
+++ b/storage/connect/tabutil.cpp
@@ -205,7 +205,7 @@ PQRYRES TabColumns(PGLOBAL g, THD *thd, const char *db,
       if (v == 'K') {
         // Skip this column
         sprintf(g->Message, "Column %s skipped (unsupported type)", colname);
-        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
         continue;
         } // endif v
 
@@ -218,7 +218,7 @@ PQRYRES TabColumns(PGLOBAL g, THD *thd, const char *db,
         len = zconv;
         sprintf(g->Message, "Column %s converted to varchar(%d)",
                 colname, len);
-        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
+        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
         } // endif v
 
     crp = crp->Next;                       // Data_Type