Merge with 4.0

BitKeeper/etc/ignore:
  auto-union
BitKeeper/etc/logging_ok:
  auto-union
BitKeeper/deleted/.del-compile-netware-standard:
  Delete: netware/BUILD/compile-netware-standard
BitKeeper/deleted/.del-mwenv:
  Delete: netware/BUILD/mwenv
BitKeeper/deleted/.del-nwbootstrap:
  Delete: netware/BUILD/nwbootstrap
BitKeeper/deleted/.del-compile-AUTOTOOLS:
  Delete: netware/BUILD/compile-AUTOTOOLS
BitKeeper/deleted/.del-compile-linux-tools:
  Delete: netware/BUILD/compile-linux-tools
BitKeeper/deleted/.del-compile-netware-END:
  Delete: netware/BUILD/compile-netware-END
BitKeeper/deleted/.del-compile-netware-START:
  Delete: netware/BUILD/compile-netware-START
BitKeeper/deleted/.del-compile-netware-all:
  Delete: netware/BUILD/compile-netware-all
BitKeeper/deleted/.del-compile-netware-debug:
  Delete: netware/BUILD/compile-netware-debug
BitKeeper/deleted/.del-mwasmnlm~bc5746809d67feb5:
  Auto merged
BitKeeper/deleted/.del-mwenv~35c8b56062f4b6aa:
  Auto merged
BitKeeper/deleted/.del-mwccnlm~be63afd25a14c3f:
  Auto merged
BitKeeper/deleted/.del-mwldnlm~efb26c57cba3c980:
  Auto merged
BitKeeper/deleted/.del-netware.patch~f70a3a965f54d9ee:
  Auto merged
Docs/internals.texi:
  Auto merged
VC++Files/bdb/bdb.dsp:
  Auto merged
VC++Files/bdb/build_win32/Berkeley_DB.dsw:
  Auto merged
VC++Files/bdb/build_win32/db_archive.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_buildall.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_checkpoint.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_deadlock.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_dll.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_dump.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_java.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_load.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_printlog.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_recover.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_stat.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_static.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_static1.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_tcl.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_test.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_upgrade.dsp:
  Auto merged
VC++Files/bdb/build_win32/db_verify.dsp:
  Auto merged
VC++Files/bdb/build_win32/ex_access.dsp:
  Auto merged
VC++Files/bdb/build_win32/ex_btrec.dsp:
  Auto merged
VC++Files/bdb/build_win32/ex_env.dsp:
  Auto merged
VC++Files/bdb/build_win32/ex_lock.dsp:
  Auto merged
VC++Files/bdb/build_win32/ex_mpool.dsp:
  Auto merged
VC++Files/bdb/build_win32/ex_tpcb.dsp:
  Auto merged
VC++Files/bdb/build_win32/excxx_access.dsp:
  Auto merged
VC++Files/bdb/build_win32/excxx_btrec.dsp:
  Auto merged
VC++Files/bdb/build_win32/excxx_env.dsp:
  Auto merged
VC++Files/bdb/build_win32/excxx_lock.dsp:
  Auto merged
VC++Files/bdb/build_win32/excxx_mpool.dsp:
  Auto merged
VC++Files/bdb/build_win32/excxx_tpcb.dsp:
  Auto merged
VC++Files/client/mysql.dsp:
  Auto merged
VC++Files/client/mysqladmin.dsp:
  Auto merged
VC++Files/client/mysqlcheck.dsp:
  Auto merged
VC++Files/client/mysqlclient.dsp:
  Auto merged
VC++Files/client/mysqlclient.dsw:
  Auto merged
VC++Files/client/mysqldump.dsp:
  Auto merged
VC++Files/client/mysqlimport.dsp:
  Auto merged
VC++Files/client/mysqlshow.dsp:
  Auto merged
VC++Files/comp_err/comp_err.dsp:
  Auto merged
VC++Files/contrib/asm386/zlibvc.dsp:
  Auto merged
VC++Files/contrib/asm386/zlibvc.dsw:
  Auto merged
VC++Files/contrib/minizip/zlibvc.dsp:
  Auto merged
VC++Files/contrib/minizip/zlibvc.dsw:
  Auto merged
VC++Files/dbug/dbug.dsp:
  Auto merged
VC++Files/dbug/dbug.dsw:
  Auto merged
VC++Files/heap/heap.dsp:
  Auto merged
VC++Files/innobase/innobase.dsp:
  Auto merged
VC++Files/isam/isam.dsp:
  Auto merged
VC++Files/isam/isam.dsw:
  Auto merged
VC++Files/isamchk/isamchk.dsp:
  Auto merged
VC++Files/libmysql/libmysql.dsp:
  Auto merged
VC++Files/libmysql/libmysql.dsw:
  Auto merged
VC++Files/libmysqld/examples/test_libmysqld.dsp:
  Auto merged
VC++Files/libmysqld/libmysqld.dsp:
  Auto merged
VC++Files/libmysqltest/myTest.dsp:
  Auto merged
VC++Files/libmysqltest/mytest.dsw:
  Auto merged
VC++Files/merge/merge.dsp:
  Auto merged
VC++Files/merge/merge.dsw:
  Auto merged
VC++Files/my_print_defaults/my_print_defaults.dsp:
  Auto merged
VC++Files/myisam/myisam.dsp:
  Auto merged
VC++Files/myisamchk/myisamchk.dsp:
  Auto merged
VC++Files/myisamlog/myisamlog.dsp:
  Auto merged
VC++Files/myisammrg/myisammrg.dsp:
  Auto merged
VC++Files/mysql.dsp:
  Auto merged
VC++Files/mysql.dsw:
  Auto merged
VC++Files/myisampack/myisampack.dsp:
  Auto merged
VC++Files/mysqlbinlog/mysqlbinlog.dsp:
  Auto merged
VC++Files/mysqlcheck/mysqlcheck.dsp:
  Auto merged
VC++Files/mysqldemb/mysqldemb.dsp:
  Auto merged
VC++Files/mysqlmanager/MySqlManager.dsp:
  Auto merged
VC++Files/mysqlmanager/mysqlmanager.dsw:
  Auto merged
VC++Files/mysqlserver/mysqlserver.dsp:
  Auto merged
VC++Files/mysqlshutdown/myshutdown.dsp:
  Auto merged
VC++Files/mysqlshutdown/mysqlshutdown.dsp:
  Auto merged
VC++Files/mysqlwatch/mysqlwatch.dsp:
  Auto merged
VC++Files/mysys/mysys.dsp:
  Auto merged
VC++Files/mysys/mysys.dsw:
  Auto merged
VC++Files/pack_isam/pack_isam.dsp:
  Auto merged
VC++Files/perror/perror.dsp:
  Auto merged
VC++Files/regex/regex.dsp:
  Auto merged
VC++Files/regex/regex.dsw:
  Auto merged
VC++Files/replace/replace.dsp:
  Auto merged
VC++Files/sql/mysqld.dsw:
  Auto merged
VC++Files/sql/mysqldmax.dsp:
  Auto merged
VC++Files/sql/old/mysqld.dsw:
  Auto merged
VC++Files/strings/MASM6x/strings.dsp:
  Auto merged
VC++Files/strings/MASM6x/strings.dsw:
  Auto merged
VC++Files/strings/backup/strings.dsp:
  Auto merged
VC++Files/strings/backup/strings.dsw:
  Auto merged
VC++Files/strings/noMASM/strings.dsp:
  Auto merged
VC++Files/strings/noMASM/strings.dsw:
  Auto merged
VC++Files/strings/strings.dsw:
  Auto merged
VC++Files/test1/test1.dsp:
  Auto merged
VC++Files/thr_insert_test/thr_insert_test.dsp:
  Auto merged
VC++Files/thr_test/thr_test.dsp:
  Auto merged
VC++Files/vio/vio.dsp:
  Auto merged
VC++Files/zlib/zlib.dsp:
  Auto merged
client/mysqlbinlog.cc:
  Auto merged
client/mysqlshow.c:
  Auto merged
include/my_global.h:
  Auto merged
include/my_sys.h:
  Auto merged
include/myisam.h:
  Auto merged
include/thr_lock.h:
  Auto merged
include/violite.h:
  Auto merged
innobase/buf/buf0buf.c:
  Auto merged
innobase/os/os0file.c:
  Auto merged
innobase/row/row0sel.c:
  Auto merged
innobase/srv/srv0start.c:
  Auto merged
innobase/trx/trx0sys.c:
  Auto merged
libmysqld/lib_vio.c:
  Auto merged
myisam/mi_create.c:
  Auto merged
mysql-test/Makefile.am:
  Auto merged
mysql-test/r/create.result:
  Auto merged
mysql-test/r/group_by.result:
  Auto merged
mysql-test/r/innodb.result:
  Auto merged
mysql-test/r/join.result:
  Auto merged
mysql-test/r/rpl000001.result:
  Auto merged
mysql-test/r/select.result:
  Auto merged
mysql-test/t/auto_increment.test:
  Auto merged
mysql-test/t/create.test:
  Auto merged
mysql-test/t/func_like.test:
  Auto merged
mysql-test/t/group_by.test:
  Auto merged
mysql-test/t/innodb.test:
  Auto merged
mysql-test/t/join.test:
  Auto merged
mysql-test/t/type_datetime.test:
  Auto merged
mysql-test/t/type_timestamp.test:
  Auto merged
mysys/default.c:
  Auto merged
mysys/thr_lock.c:
  Auto merged
scripts/make_binary_distribution.sh:
  Auto merged
scripts/mysqld_safe.sh:
  Auto merged
sql/filesort.cc:
  Auto merged
sql/ha_innodb.h:
  Auto merged
sql/ha_myisam.cc:
  Auto merged
sql/handler.cc:
  Auto merged
sql/handler.h:
  Auto merged
sql/item.cc:
  Auto merged
sql/item_cmpfunc.cc:
  Auto merged
sql/item_func.cc:
  Auto merged
sql/lock.cc:
  Auto merged
sql/log.cc:
  Auto merged
sql/log_event.h:
  Auto merged
sql/mf_iocache.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/net_serv.cc:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/repl_failsafe.cc:
  Auto merged
sql/repl_failsafe.h:
  Auto merged
sql/slave.cc:
  Auto merged
sql/slave.h:
  Auto merged
sql/sql_analyse.cc:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql-bench/crash-me.sh:
  Auto merged
sql/share/polish/errmsg.txt:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_rename.cc:
  Auto merged
sql/sql_repl.cc:
  Auto merged
sql/sql_repl.h:
  Auto merged
sql/sql_update.cc:
  Auto merged
sql/stacktrace.c:
  Auto merged
sql/table.cc:
  Auto merged
sql/unireg.h:
  Auto merged
strings/ctype-tis620.c:
  Auto merged
strings/t_ctype.h:
  Auto merged
support-files/mysql.spec.sh:
  Auto merged
tests/grant.res:
  Auto merged
vio/viosocket.c:
  Auto merged

40 files changed, 813 insertions, 432 deletions

diff --git a/sql/field.h b/sql/field.h
index 37d194ac372..3877068aa0e 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -71,7 +71,7 @@ public:
   virtual String *val_str(String*,String *)=0;
   virtual Item_result result_type () const=0;
   virtual Item_result cmp_type () const { return result_type(); }
-  bool eq(Field *field) { return ptr == field->ptr; }
+  bool eq(Field *field) { return ptr == field->ptr && null_ptr == field->null_ptr; }
   virtual bool eq_def(Field *field);
   virtual uint32 pack_length() const { return (uint32) field_length; }
   virtual void reset(void) { bzero(ptr,pack_length()); }
diff --git a/sql/filesort.cc b/sql/filesort.cc
index cc7b15f1f4a..0f6e4d7abba 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -68,7 +68,7 @@ ha_rows filesort(THD *thd, TABLE *table, SORT_FIELD *sortorder, uint s_length,
 		 SQL_SELECT *select, ha_rows max_rows, ha_rows *examined_rows)
 {
   int error;
-  ulong memavl;
+  ulong memavl, min_sort_memory;
   uint maxbuffer;
   BUFFPEK *buffpek;
   ha_rows records;
@@ -123,7 +123,8 @@ ha_rows filesort(THD *thd, TABLE *table, SORT_FIELD *sortorder, uint s_length,
     goto err;
 
   memavl= thd->variables.sortbuff_size;
-  while (memavl >= MIN_SORT_MEMORY)
+  min_sort_memory= max(MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
+  while (memavl >= min_sort_memory)
   {
     ulong old_memavl;
     ulong keys= memavl/(param.sort_length+sizeof(char*));
@@ -132,10 +133,10 @@ ha_rows filesort(THD *thd, TABLE *table, SORT_FIELD *sortorder, uint s_length,
 					       MYF(0))))
       break;
     old_memavl=memavl;
-    if ((memavl=memavl/4*3) < MIN_SORT_MEMORY && old_memavl > MIN_SORT_MEMORY)
-      memavl=MIN_SORT_MEMORY;
+    if ((memavl=memavl/4*3) < min_sort_memory && old_memavl > min_sort_memory)
+      memavl= min_sort_memory;
   }
-  if (memavl < MIN_SORT_MEMORY)
+  if (memavl < min_sort_memory)
   {
     my_error(ER_OUTOFMEMORY,MYF(ME_ERROR+ME_WAITTANG),
 	     thd->variables.sortbuff_size);
diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc
index 31f9ba483a3..eaa088647c3 100644
--- a/sql/ha_innodb.cc
+++ b/sql/ha_innodb.cc
@@ -151,6 +151,19 @@ innobase_release_stat_resources(
 }
 
 /************************************************************************
+Call this function when mysqld passes control to the client. That is to
+avoid deadlocks on the adaptive hash S-latch possibly held by thd. For more
+documentation, see handler.cc. */
+
+void
+innobase_release_temporary_latches(
+/*===============================*/
+        void*   innobase_tid)
+{
+        innobase_release_stat_resources((trx_t*)innobase_tid);
+}
+
+/************************************************************************
 Increments innobase_active_counter and every INNOBASE_WAKE_INTERVALth
 time calls srv_active_wake_master_thread. This function should be used
 when a single database operation may introduce a small need for
@@ -895,12 +908,13 @@ innobase_commit_low(
 	trx_t*	trx)	/* in: transaction handle */
 {
 #ifdef HAVE_REPLICATION
+        /* TODO: Guilhem should check if master_log_name, pending
+        etc. are right if the master log gets rotated! Possible bug here.
+	Comment by Heikki March 4, 2003. */
+
         if (current_thd->slave_thread) {
                 /* Update the replication position info inside InnoDB */
-#ifdef NEED_TO_BE_FIXED	  
-                trx->mysql_relay_log_file_name = active_mi->rli.log_file_name;
-                trx->mysql_relay_log_pos = active_mi->rli.relay_log_pos;
-#endif
+
                 trx->mysql_master_log_file_name
                                         = active_mi->rli.master_log_name;
                 trx->mysql_master_log_pos = ((ib_longlong)
@@ -3512,6 +3526,16 @@ ha_innobase::records_in_range(
 
 	prebuilt->trx->op_info = (char*)"";
 
+	/* The MySQL optimizer seems to believe an estimate of 0 rows is
+	always accurate and may return the result 'Empty set' based on that.
+	The accuracy is not guaranteed, and even if it were, for a locking
+	read we should anyway perform the search to set the next-key lock.
+	Add 1 to the value to make sure MySQL does not make the assumption! */
+
+	if (n_rows == 0) {
+	        n_rows = 1;
+	}
+
 	DBUG_RETURN((ha_rows) n_rows);
 }
 
diff --git a/sql/ha_innodb.h b/sql/ha_innodb.h
index 86fb5d1947b..55832c0a079 100644
--- a/sql/ha_innodb.h
+++ b/sql/ha_innodb.h
@@ -82,7 +82,8 @@ class ha_innobase: public handler
 			  HA_PRIMARY_KEY_IN_READ_INDEX |
 			  HA_DROP_BEFORE_CREATE |
 			  HA_NO_PREFIX_CHAR_KEYS |
-			  HA_TABLE_SCAN_ON_INDEX),
+			  HA_TABLE_SCAN_ON_INDEX | 
+			  HA_NOT_MULTI_UPDATE),
 	  last_dup_key((uint) -1),
 	  start_of_scan(0)
   	{
@@ -209,3 +210,4 @@ int innodb_show_status(THD* thd);
 
 my_bool innobase_query_caching_of_table_permitted(THD* thd, char* full_name,
 						uint full_name_len);
+void innobase_release_temporary_latches(void* innobase_tid);
diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc
index 7cd5927bd24..4f61ee48748 100644
--- a/sql/ha_myisam.cc
+++ b/sql/ha_myisam.cc
@@ -420,7 +420,7 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
     param.db_name    = table->table_cache_key;
     param.table_name = table->table_name;
     param.testflag = 0;
-    mi_check_print_error(&param,errmsg, my_errno);
+    mi_check_print_error(&param, errmsg, my_errno);
     DBUG_RETURN(error);
   }
 }
@@ -438,17 +438,17 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
   if (fn_format_relative_to_data_home(dst_path, table_name, backup_dir,
 				      reg_ext))
   {
-    errmsg = "Failed in fn_format() for .frm file: errno = %d";
+    errmsg = "Failed in fn_format() for .frm file (errno: %d)";
     error = HA_ADMIN_INVALID;
     goto err;
   }
 
   if (my_copy(fn_format(src_path, table->path,"", reg_ext, MY_UNPACK_FILENAME),
 	      dst_path,
-	      MYF(MY_WME | MY_HOLD_ORIGINAL_MODES)))
+	      MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_DONT_OVERWRITE_FILE)))
   {
     error = HA_ADMIN_FAILED;
-    errmsg = "Failed copying .frm file: errno = %d";
+    errmsg = "Failed copying .frm file (errno: %d)";
     goto err;
   }
 
@@ -456,7 +456,7 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
   if (!fn_format(dst_path, dst_path, "", MI_NAME_DEXT,
 		 MY_REPLACE_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH))
   {
-    errmsg = "Failed in fn_format() for .MYD file: errno = %d";
+    errmsg = "Failed in fn_format() for .MYD file (errno: %d)";
     error = HA_ADMIN_INVALID;
     goto err;
   }
@@ -464,9 +464,9 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
   if (my_copy(fn_format(src_path, table->path,"", MI_NAME_DEXT,
 			MY_UNPACK_FILENAME),
 	      dst_path,
-	      MYF(MY_WME | MY_HOLD_ORIGINAL_MODES)))
+	      MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_DONT_OVERWRITE_FILE)))
   {
-    errmsg = "Failed copying .MYD file: errno = %d";
+    errmsg = "Failed copying .MYD file (errno: %d)";
     error= HA_ADMIN_FAILED;
     goto err;
   }
@@ -1034,7 +1034,7 @@ int ha_myisam::create(const char *name, register TABLE *table_arg,
 {
   int error;
   uint i,j,recpos,minpos,fieldpos,temp_length,length;
-  bool found_auto_increment=0;
+  bool found_real_auto_increment=0;
   enum ha_base_keytype type;
   char buff[FN_REFLEN];
   KEY *pos;
@@ -1107,12 +1107,6 @@ int ha_myisam::create(const char *name, register TABLE *table_arg,
 	keydef[i].seg[j].null_bit=0;
 	keydef[i].seg[j].null_pos=0;
       }
-      if (j == 0 && field->flags & AUTO_INCREMENT_FLAG &&
-	  !found_auto_increment)
-      {
-	keydef[i].flag|=HA_AUTO_KEY;
-	found_auto_increment=1;
-      }
       if ((field->type() == FIELD_TYPE_BLOB) || (field->type() == FIELD_TYPE_GEOMETRY))
       {
 	keydef[i].seg[j].flag|=HA_BLOB_PART;
@@ -1124,6 +1118,12 @@ int ha_myisam::create(const char *name, register TABLE *table_arg,
     keyseg+=pos->key_parts;
   }
 
+  if (table_arg->found_next_number_field)
+  {
+    keydef[table_arg->next_number_index].flag|= HA_AUTO_KEY;
+    found_real_auto_increment= table_arg->next_number_key_offset == 0;
+  }
+
   recpos=0; recinfo_pos=recinfo;
   while (recpos < (uint) table_arg->reclength)
   {
@@ -1193,6 +1193,7 @@ int ha_myisam::create(const char *name, register TABLE *table_arg,
   bzero((char*) &create_info,sizeof(create_info));
   create_info.max_rows=table_arg->max_rows;
   create_info.reloc_rows=table_arg->min_rows;
+  create_info.with_auto_increment=found_real_auto_increment;
   create_info.auto_increment=(info->auto_increment_value ?
 			      info->auto_increment_value -1 :
 			      (ulonglong) 0);
diff --git a/sql/handler.cc b/sql/handler.cc
index af9b2fd4a35..d7ae960382c 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -238,8 +238,10 @@ int ha_autocommit_or_rollback(THD *thd, int error)
   handler must be the same as in the binlog.
 
   arguments:
+  thd:           the thread handle of the current connection
   log_file_name: latest binlog file name
   end_offset:	 the offset in the binlog file up to which we wrote
+  return value:  0 if success, 1 if error
 */
 
 int ha_report_binlog_offset_and_commit(THD *thd,
@@ -266,6 +268,34 @@ int ha_report_binlog_offset_and_commit(THD *thd,
   return error;
 }
 
+/*
+  This function should be called when MySQL sends rows of a SELECT result set
+  or the EOF mark to the client. It releases a possible adaptive hash index
+  S-latch held by thd in InnoDB and also releases a possible InnoDB query
+  FIFO ticket to enter InnoDB. To save CPU time, InnoDB allows a thd to
+  keep them over several calls of the InnoDB handler interface when a join
+  is executed. But when we let the control to pass to the client they have
+  to be released because if the application program uses mysql_use_result(),
+  it may deadlock on the S-latch if the application on another connection
+  performs another SQL query. In MySQL-4.1 this is even more important because
+  there a connection can have several SELECT queries open at the same time.
+
+  arguments:
+  thd:           the thread handle of the current connection
+  return value:  always 0
+*/
+
+int ha_release_temporary_latches(THD *thd)
+{
+#ifdef HAVE_INNOBASE_DB
+  THD_TRANS *trans;
+  trans = &thd->transaction.all;
+  if (trans->innobase_tid)
+    innobase_release_temporary_latches(trans->innobase_tid);
+#endif
+  return 0;
+}
+
 int ha_commit_trans(THD *thd, THD_TRANS* trans)
 {
   int error=0;
@@ -473,7 +503,8 @@ int handler::ha_open(const char *name, int mode, int test_if_locked)
   int error;
   DBUG_ENTER("handler::open");
   DBUG_PRINT("enter",("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
-		      name, table->db_type, table->db_stat, mode, test_if_locked));
+		      name, table->db_type, table->db_stat, mode,
+		      test_if_locked));
 
   if ((error=open(name,mode,test_if_locked)))
   {
diff --git a/sql/handler.h b/sql/handler.h
index 6cbd83af282..824f02b5a3d 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -67,6 +67,7 @@
 #define HA_CAN_FULLTEXT         (HA_NO_PREFIX_CHAR_KEYS*2)
 #define HA_CAN_SQL_HANDLER      (HA_CAN_FULLTEXT*2)
 #define HA_NO_AUTO_INCREMENT	(HA_CAN_SQL_HANDLER*2)
+#define HA_NOT_MULTI_UPDATE	(HA_NO_AUTO_INCREMENT*2)
 
 /*
   Next record gives next record according last record read (even
@@ -373,6 +374,7 @@ void ha_resize_key_cache(void);
 int ha_start_stmt(THD *thd); 
 int ha_report_binlog_offset_and_commit(THD *thd, char *log_file_name,
 				       my_off_t end_offset);
+int ha_release_temporary_latches(THD *thd);
 int ha_commit_trans(THD *thd, THD_TRANS *trans);
 int ha_rollback_trans(THD *thd, THD_TRANS *trans);
 int ha_autocommit_or_rollback(THD *thd, int error);
diff --git a/sql/item.cc b/sql/item.cc
index 3c6b85e933b..ea0d21ad300 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -257,6 +257,17 @@ bool Item_field::get_date(TIME *ltime,bool fuzzydate)
   return 0;
 }
 
+bool Item_field::get_date_result(TIME *ltime,bool fuzzydate)
+{
+  if ((null_value=result_field->is_null()) ||
+      result_field->get_date(ltime,fuzzydate))
+  {
+    bzero((char*) ltime,sizeof(*ltime));
+    return 1;
+  }
+  return 0;
+}
+
 bool Item_field::get_time(TIME *ltime)
 {
   if ((null_value=field->is_null()) || field->get_time(ltime))
diff --git a/sql/item.h b/sql/item.h
index 7b31f03f6ac..8e1f4a38237 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -98,6 +98,8 @@ public:
   virtual void split_sum_func(Item **ref_pointer_array, List<Item> &fields) {}
   virtual bool get_date(TIME *ltime,bool fuzzydate);
   virtual bool get_time(TIME *ltime);
+  virtual bool get_date_result(TIME *ltime,bool fuzzydate)
+  { return get_date(ltime,fuzzydate); }
   virtual bool is_null() { return 0; };
   virtual void top_level_item() {}
   virtual void set_result_field(Field *field) {}
@@ -186,8 +188,9 @@ public:
   }
   Field *tmp_table_field() { return result_field; }
   Field *tmp_table_field(TABLE *t_arg) { return result_field; }
-  bool get_date(TIME *ltime,bool fuzzydate);  
-  bool get_time(TIME *ltime);  
+  bool get_date(TIME *ltime,bool fuzzydate);
+  bool get_date_result(TIME *ltime,bool fuzzydate);
+  bool get_time(TIME *ltime);
   bool is_null() { return field->is_null(); }
   Item *get_tmp_table_item(THD *thd);
   friend class Item_default_value;
@@ -512,8 +515,8 @@ public:
     return (*ref)->null_value;
   }
   bool get_date(TIME *ltime,bool fuzzydate)
-  {  
-    return (null_value=(*ref)->get_date(ltime,fuzzydate));
+  {
+    return (null_value=(*ref)->get_date_result(ltime,fuzzydate));
   }
   bool send(Protocol *prot, String *tmp){ return (*ref)->send(prot, tmp); }
   void make_field(Send_field *field)	{ (*ref)->make_field(field); }
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 301e5b4454f..a88b269eedd 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -1759,12 +1759,16 @@ longlong Item_func_like::val_int()
 
 Item_func::optimize_type Item_func_like::select_optimize() const
 {
-  if (args[1]->type() == STRING_ITEM)
+  if (args[1]->const_item())
   {
-    if (((Item_string *) args[1])->str_value[0] != wild_many)
+    String* res2= args[1]->val_str((String *)&tmp_value2);
+
+    if (!res2)
+      return OPTIMIZE_NONE;
+
+    if (*res2->ptr() != wild_many)
     {
-      if ((args[0]->result_type() != STRING_RESULT) ||
-	  ((Item_string *) args[1])->str_value[0] != wild_one)
+      if (args[0]->result_type() != STRING_RESULT || *res2->ptr() != wild_one)
 	return OPTIMIZE_OP;
     }
   }
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 8fb97dc2873..6b932edf00e 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -791,20 +791,28 @@ double Item_func_round::val()
   double value=args[0]->val();
   int dec=(int) args[1]->val_int();
   uint abs_dec=abs(dec);
+  double tmp;
+  /*
+    tmp2 is here to avoid return the value with 80 bit precision
+    This will fix that the test round(0.1,1) = round(0.1,1) is true
+  */
+  volatile double tmp2;
 
   if ((null_value=args[0]->null_value || args[1]->null_value))
     return 0.0;
-  double tmp=(abs_dec < array_elements(log_10) ?
-	      log_10[abs_dec] : pow(10.0,(double) abs_dec));
+  tmp=(abs_dec < array_elements(log_10) ?
+       log_10[abs_dec] : pow(10.0,(double) abs_dec));
 
   if (truncate)
   {
     if (value >= 0)
-      return dec < 0 ? floor(value/tmp)*tmp : floor(value*tmp)/tmp;
+      tmp2= dec < 0 ? floor(value/tmp)*tmp : floor(value*tmp)/tmp;
     else
-      return dec < 0 ? ceil(value/tmp)*tmp : ceil(value*tmp)/tmp;
+      tmp2= dec < 0 ? ceil(value/tmp)*tmp : ceil(value*tmp)/tmp;
   }
-  return dec < 0 ? rint(value/tmp)*tmp : rint(value*tmp)/tmp;
+  else
+    tmp2=dec < 0 ? rint(value/tmp)*tmp : rint(value*tmp)/tmp;
+  return tmp2;
 }
 
 
diff --git a/sql/lock.cc b/sql/lock.cc
index 8f342b28d67..82004298453 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -319,6 +319,25 @@ void mysql_lock_abort(THD *thd, TABLE *table)
 }
 
 
+/* Abort one thread / table combination */
+
+void mysql_lock_abort_for_thread(THD *thd, TABLE *table)
+{
+  MYSQL_LOCK *locked;
+  TABLE *write_lock_used;
+  DBUG_ENTER("mysql_lock_abort_for_thread");
+
+  if ((locked = get_lock_data(thd,&table,1,1,&write_lock_used)))
+  {
+    for (uint i=0; i < locked->lock_count; i++)
+      thr_abort_locks_for_thread(locked->locks[i]->lock,
+				 table->in_use->real_id);
+    my_free((gptr) locked,MYF(0));
+  }
+  DBUG_VOID_RETURN;
+}
+
+
 MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b)
 {
   MYSQL_LOCK *sql_lock;
@@ -478,11 +497,12 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list)
 {
   TABLE *table;
   char  key[MAX_DBKEY_LENGTH];
+  char *db= table_list->db ? table_list->db : (thd->db ? thd->db : (char*) "");
   uint  key_length;
   DBUG_ENTER("lock_table_name");
   safe_mutex_assert_owner(&LOCK_open);
 
-  key_length=(uint) (strmov(strmov(key,table_list->db)+1,table_list->real_name)
+  key_length=(uint) (strmov(strmov(key,db)+1,table_list->real_name)
 		     -key)+ 1;
 
   /* Only insert the table if we haven't insert it already */
@@ -511,7 +531,7 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list)
     my_free((gptr) table,MYF(0));
     DBUG_RETURN(-1);
   }
-  if (remove_table_from_cache(thd, table_list->db, table_list->real_name))
+  if (remove_table_from_cache(thd, db, table_list->real_name))
     DBUG_RETURN(1);					// Table is in use
   DBUG_RETURN(0);
 }
@@ -555,6 +575,77 @@ bool wait_for_locked_table_names(THD *thd, TABLE_LIST *table_list)
   DBUG_RETURN(result);
 }
 
+
+/*
+  Lock all tables in list with a name lock
+
+  SYNOPSIS
+    lock_table_names()
+    thd			Thread handle
+    table_list		Names of tables to lock
+
+  NOTES
+    One must have a lock on LOCK_open when calling this
+
+  RETURN
+    0	ok
+    1	Fatal error (end of memory ?)
+*/
+
+bool lock_table_names(THD *thd, TABLE_LIST *table_list)
+{
+  bool got_all_locks=1;
+  TABLE_LIST *lock_table;
+
+  for (lock_table=table_list ; lock_table ; lock_table=lock_table->next)
+  {
+    int got_lock;
+    if ((got_lock=lock_table_name(thd,lock_table)) < 0)
+      goto end;					// Fatal error
+    if (got_lock)
+      got_all_locks=0;				// Someone is using table
+  }
+
+  /* If some table was in use, wait until we got the lock */
+  if (!got_all_locks && wait_for_locked_table_names(thd, table_list))
+    goto end;
+  return 0;
+
+end:
+  unlock_table_names(thd, table_list, lock_table);
+  return 1;
+}
+
+
+/*
+  Unlock all tables in list with a name lock
+
+  SYNOPSIS
+    unlock_table_names()
+    thd			Thread handle
+    table_list		Names of tables to unlock
+    last_table		Don't unlock any tables after this one.
+			(default 0, which will unlock all tables)
+
+  NOTES
+    One must have a lock on LOCK_open when calling this
+    This function will send a COND_refresh signal to inform other threads
+    that the name locks are removed
+
+  RETURN
+    0	ok
+    1	Fatal error (end of memory ?)
+*/
+
+void unlock_table_names(THD *thd, TABLE_LIST *table_list,
+			TABLE_LIST *last_table)
+{
+  for (TABLE_LIST *table=table_list ; table != last_table ; table=table->next)
+    unlock_table_name(thd,table);
+  pthread_cond_broadcast(&COND_refresh);
+}
+
+
 static void print_lock_error(int error)
 {
   int textno;
diff --git a/sql/log.cc b/sql/log.cc
index 170e976e643..02e34b773ef 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -1321,6 +1321,14 @@ bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache)
     */
     {
       Query_log_event qinfo(thd, "BEGIN", 5, TRUE);
+      /*
+        Now this Query_log_event has artificial log_pos 0. It must be adjusted
+        to reflect the real position in the log. Not doing it would confuse the
+        slave: it would prevent this one from knowing where he is in the master's
+        binlog, which would result in wrong positions being shown to the user,
+        MASTER_POS_WAIT undue waiting etc.
+      */
+      qinfo.set_log_pos(this);
       if (qinfo.write(&log_file))
 	goto err;
     }
@@ -1343,6 +1351,7 @@ bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache)
 
     {
       Query_log_event qinfo(thd, "COMMIT", 6, TRUE);
+      qinfo.set_log_pos(this);
       if (qinfo.write(&log_file) || flush_io_cache(&log_file))
 	goto err;
     }
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 12921eb0c01..fabc02a3293 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -550,6 +550,15 @@ err:
     sql_print_error("Error in Log_event::read_log_event(): '%s', \
 data_len=%d,event_type=%d",error,data_len,head[EVENT_TYPE_OFFSET]);
     my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
+    /*
+      The SQL slave thread will check if file->error<0 to know
+      if there was an I/O error. Even if there is no "low-level" I/O errors
+      with 'file', any of the high-level above errors is worrying
+      enough to stop the SQL thread now ; as we are skipping the current event,
+      going on with reading and successfully executing other events can
+      only corrupt the slave's databases. So stop.
+    */
+    file->error= -1;
   }
   return res;
 }
@@ -1545,6 +1554,7 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli,
     tables.db = thd->db;
     tables.alias = tables.real_name = (char*)table_name;
     tables.lock_type = TL_WRITE;
+    tables.updating= 1;
     // the table will be opened in mysql_load    
     if (table_rules_on && !tables_ok(thd, &tables))
     {
diff --git a/sql/mf_iocache.cc b/sql/mf_iocache.cc
index 4b0575c8579..b7e2a803e42 100644
--- a/sql/mf_iocache.cc
+++ b/sql/mf_iocache.cc
@@ -70,13 +70,17 @@ int _my_b_net_read(register IO_CACHE *info, byte *Buffer,
   /* to set up stuff for my_b_get (no _) */
   info->read_end = (info->read_pos = (byte*) net->read_pos) + read_length;
   Buffer[0] = info->read_pos[0];		/* length is always 1 */
-  info->read_pos++;
 
   /*
     info->request_pos is used by log_loaded_block() to know the size
-    of the current block
+    of the current block.
+    info->pos_in_file is used by log_loaded_block() too.
   */
+  info->pos_in_file+= read_length;
   info->request_pos=info->read_pos;
+
+  info->read_pos++;
+
   DBUG_RETURN(0);
 }
 
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index df9fbd5da53..61c5d308b4e 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -780,6 +780,7 @@ void mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock);
 void mysql_unlock_some_tables(THD *thd, TABLE **table,uint count);
 void mysql_lock_remove(THD *thd, MYSQL_LOCK *locked,TABLE *table);
 void mysql_lock_abort(THD *thd, TABLE *table);
+void mysql_lock_abort_for_thread(THD *thd, TABLE *table);
 MYSQL_LOCK *mysql_lock_merge(MYSQL_LOCK *a,MYSQL_LOCK *b);
 bool lock_global_read_lock(THD *thd);
 void unlock_global_read_lock(THD *thd);
@@ -791,6 +792,9 @@ int lock_and_wait_for_table_name(THD *thd, TABLE_LIST *table_list);
 int lock_table_name(THD *thd, TABLE_LIST *table_list);
 void unlock_table_name(THD *thd, TABLE_LIST *table_list);
 bool wait_for_locked_table_names(THD *thd, TABLE_LIST *table_list);
+bool lock_table_names(THD *thd, TABLE_LIST *table_list);
+void unlock_table_names(THD *thd, TABLE_LIST *table_list,
+			TABLE_LIST *last_table= 0);
 
 
 /* old unireg functions */
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index e01af4de543..c0a3527bc75 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -3755,8 +3755,10 @@ struct my_option my_long_options[] =
   {"safemalloc-mem-limit", OPT_SAFEMALLOC_MEM_LIMIT,
    "Simulate memory shortage when compiled with the --with-debug=full option",
    0, 0, 0, GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"new", 'n', "Use very new possible 'unsafe' functions", 0, 0, 0, GET_NO_ARG,
-   NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"new", 'n', "Use very new possible 'unsafe' functions",
+   (gptr*) &global_system_variables.new_mode,
+   (gptr*) &max_system_variables.new_mode,
+   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 #ifdef NOT_YET
   {"no-mix-table-types", OPT_NO_MIX_TYPE, "Don't allow commands with uses two different table types",
    (gptr*) &opt_no_mix_types, (gptr*) &opt_no_mix_types, 0, GET_BOOL, NO_ARG,
@@ -3944,8 +3946,8 @@ struct my_option my_long_options[] =
    (gptr*) &my_use_symdir, (gptr*) &my_use_symdir, 0, GET_BOOL, NO_ARG,
    IF_PURIFY(0,1), 0, 0, 0, 0, 0},
 #endif
-  {"user", 'u', "Run mysqld daemon as user", (gptr*) &mysqld_user,
-   (gptr*) &mysqld_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"user", 'u', "Run mysqld daemon as user", 0, 0, 0, GET_STR, REQUIRED_ARG,
+   0, 0, 0, 0, 0, 0},
   {"version", 'V', "Output version information and exit", 0, 0, 0, GET_NO_ARG,
    NO_ARG, 0, 0, 0, 0, 0, 0},
   {"version", 'v', "Synonym for option -v", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
@@ -4121,9 +4123,9 @@ struct my_option my_long_options[] =
    (gptr*) &max_connect_errors, (gptr*) &max_connect_errors, 0, GET_ULONG,
     REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ~0L, 0, 1, 0},
   {"max_delayed_threads", OPT_MAX_DELAYED_THREADS,
-   "Don't start more than this number of threads to handle INSERT DELAYED statements.",
+   "Don't start more than this number of threads to handle INSERT DELAYED statements. This option does not yet have effect (on TODO), unless it is set to zero, which means INSERT DELAYED is not used.",
    (gptr*) &max_insert_delayed_threads, (gptr*) &max_insert_delayed_threads,
-   0, GET_ULONG, REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},
+   0, GET_ULONG, REQUIRED_ARG, 20, 0, 16384, 0, 1, 0},
   {"max_error_count", OPT_MAX_ERROR_COUNT,
    "Max number of errors/warnings to store for a statement",
    (gptr*) &global_system_variables.max_error_count,
@@ -4607,12 +4609,15 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
     /* Correct pointer set by my_getopt (for embedded library) */
     mysql_data_home= mysql_real_data_home;
     break;
+  case 'u':
+    if (!mysqld_user)
+      mysqld_user= argument;
+    else
+      fprintf(stderr, "Warning: Ignoring user change to '%s' because the user was set to '%s' earlier on the command line\n", argument, mysqld_user);
+    break;
   case 'L':
     strmake(language, argument, sizeof(language)-1);
     break;
-  case 'n':
-    opt_specialflag|= SPECIAL_NEW_FUNC;
-    break;
   case 'o':
     protocol_version=PROTOCOL_VERSION-1;
     break;
@@ -4808,8 +4813,8 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
   case (int) OPT_SAFE:
     opt_specialflag|= SPECIAL_SAFE_MODE;
     delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
-    myisam_recover_options= HA_RECOVER_NONE;	// To be changed
-    ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);
+    myisam_recover_options= HA_RECOVER_DEFAULT;
+    ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);
     break;
   case (int) OPT_SKIP_PRIOR:
     opt_specialflag|= SPECIAL_NO_PRIOR;
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index c4c5cd28b39..92bab76bedd 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -1301,7 +1301,8 @@ key_and(SEL_ARG *key1,SEL_ARG *key2,uint clone_flag)
   }
 
   if (((clone_flag & CLONE_KEY2_MAYBE) &&
-       !(clone_flag & CLONE_KEY1_MAYBE)) ||
+       !(clone_flag & CLONE_KEY1_MAYBE) &&
+       key2->type != SEL_ARG::MAYBE_KEY) ||
       key1->type == SEL_ARG::MAYBE_KEY)
   {						// Put simple key in key2
     swap(SEL_ARG *,key1,key2);
@@ -1329,7 +1330,10 @@ key_and(SEL_ARG *key1,SEL_ARG *key2,uint clone_flag)
     {
       key1->maybe_smaller();
       if (key2->next_key_part)
+      {
+	key1->use_count--;			// Incremented in and_all_keys
 	return and_all_keys(key1,key2,clone_flag);
+      }
       key2->use_count--;			// Key2 doesn't have a tree
     }
     return key1;
@@ -2028,7 +2032,7 @@ void SEL_ARG::test_use_count(SEL_ARG *root)
 {
   if (this == root && use_count != 1)
   {
-    sql_print_error("Use_count: Wrong count %lu for root",use_count);
+    sql_print_error("Note: Use_count: Wrong count %lu for root",use_count);
     return;
   }
   if (this->type != SEL_ARG::KEY_RANGE)
@@ -2042,7 +2046,7 @@ void SEL_ARG::test_use_count(SEL_ARG *root)
       ulong count=count_key_part_usage(root,pos->next_key_part);
       if (count > pos->next_key_part->use_count)
       {
-	sql_print_error("Use_count: Wrong count for key at %lx, %lu should be %lu",
+	sql_print_error("Note: Use_count: Wrong count for key at %lx, %lu should be %lu",
 			pos,pos->next_key_part->use_count,count);
 	return;
       }
@@ -2050,7 +2054,7 @@ void SEL_ARG::test_use_count(SEL_ARG *root)
     }
   }
   if (e_count != elements)
-    sql_print_error("Wrong use count: %u for tree at %lx", e_count,
+    sql_print_error("Warning: Wrong use count: %u for tree at %lx", e_count,
 		    (gptr) this);
 }
 
diff --git a/sql/repl_failsafe.cc b/sql/repl_failsafe.cc
index 3991d9f21f1..1be84723c1e 100644
--- a/sql/repl_failsafe.cc
+++ b/sql/repl_failsafe.cc
@@ -449,8 +449,33 @@ int show_new_master(THD* thd)
   }
 }
 
+/*
+  Asks the master for the list of its other connected slaves.
+  This is for failsafe replication : 
+  in order for failsafe replication to work, the servers involved in replication
+  must know of each other. We accomplish this by having each slave report to the
+  master how to reach it, and on connection, each slave receives information
+  about where the other slaves are.
+
+  SYNOPSIS
+    update_slave_list()
+    mysql           pre-existing connection to the master
+    mi              master info
+
+  NOTES
+    mi is used only to give detailed error messages which include the
+    hostname/port of the master, the username used by the slave to connect to
+    the master.
+    If the user used by the slave to connect to the master does not have the
+    REPLICATION SLAVE privilege, it will pop in this function because SHOW SLAVE
+    HOSTS will fail on the master.
+
+  RETURN VALUES
+    1           error
+    0           success
+ */
 
-int update_slave_list(MYSQL* mysql)
+int update_slave_list(MYSQL* mysql, MASTER_INFO* mi)
 {
   MYSQL_RES* res=0;
   MYSQL_ROW row;
@@ -462,7 +487,7 @@ int update_slave_list(MYSQL* mysql)
   if (mc_mysql_query(mysql,"SHOW SLAVE HOSTS",16) ||
       !(res = mc_mysql_store_result(mysql)))
   {
-    error = "Query error";
+    error= mc_mysql_error(mysql);
     goto err;
   }
 
@@ -476,7 +501,8 @@ int update_slave_list(MYSQL* mysql)
     port_ind=4;
     break;
   default:
-    error = "Invalid number of fields in SHOW SLAVE HOSTS";
+    error= "the master returned an invalid number of fields for SHOW SLAVE \
+HOSTS";
     goto err;
   }
 
@@ -494,7 +520,7 @@ int update_slave_list(MYSQL* mysql)
     {
       if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
       {
-	error = "Out of memory";
+	error= "the slave is out of memory";
 	pthread_mutex_unlock(&LOCK_slave_list);
 	goto err;
       }
@@ -518,7 +544,9 @@ err:
     mc_mysql_free_result(res);
   if (error)
   {
-    sql_print_error("Error updating slave list: %s",error);
+    sql_print_error("While trying to obtain the list of slaves from the master \
+'%s:%d', user '%s' got the following error: '%s'", 
+                    mi->host, mi->port, mi->user, error);
     DBUG_RETURN(1);
   }
   DBUG_RETURN(0);
diff --git a/sql/repl_failsafe.h b/sql/repl_failsafe.h
index 72ea0cf2a56..a9c504330ab 100644
--- a/sql/repl_failsafe.h
+++ b/sql/repl_failsafe.h
@@ -20,7 +20,7 @@ extern const char* rpl_role_type[], *rpl_status_type[];
 pthread_handler_decl(handle_failsafe_rpl,arg);
 void change_rpl_status(RPL_STATUS from_status, RPL_STATUS to_status);
 int find_recovery_captain(THD* thd, MYSQL* mysql);
-int update_slave_list(MYSQL* mysql);
+int update_slave_list(MYSQL* mysql, MASTER_INFO* mi);
 
 extern HASH slave_list;
 
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 0b85f50e0ef..b6e10cbc5b1 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -194,6 +194,7 @@ sys_var_thd_ulong	sys_net_write_timeout("net_write_timeout",
 sys_var_thd_ulong	sys_net_retry_count("net_retry_count",
 					    &SV::net_retry_count,
 					    fix_net_retry_count);
+sys_var_thd_bool	sys_new_mode("new", &SV::new_mode);
 sys_var_thd_ulong	sys_read_buff_size("read_buffer_size",
 					   &SV::read_buff_size);
 sys_var_thd_ulong	sys_read_rnd_buff_size("read_rnd_buffer_size",
@@ -383,6 +384,7 @@ sys_var *sys_variables[]=
   &sys_net_retry_count,
   &sys_net_wait_timeout,
   &sys_net_write_timeout,
+  &sys_new_mode,
   &sys_pseudo_thread_id,
   &sys_query_cache_size,
 #ifdef HAVE_QUERY_CACHE
@@ -539,6 +541,7 @@ struct show_var_st init_vars[]= {
   {sys_net_read_timeout.name, (char*) &sys_net_read_timeout,        SHOW_SYS},
   {sys_net_retry_count.name,  (char*) &sys_net_retry_count,	    SHOW_SYS},
   {sys_net_write_timeout.name,(char*) &sys_net_write_timeout,       SHOW_SYS},
+  {sys_new_mode.name,         (char*) &sys_new_mode,                SHOW_SYS},
   {"open_files_limit",	      (char*) &open_files_limit,	    SHOW_LONG},
   {"pid_file",                (char*) pidfile_name,                 SHOW_CHAR},
   {"log_error",               (char*) log_error_file,               SHOW_CHAR},
diff --git a/sql/share/polish/errmsg.txt b/sql/share/polish/errmsg.txt
index 7ffec4b6519..2d07b362257 100644
--- a/sql/share/polish/errmsg.txt
+++ b/sql/share/polish/errmsg.txt
@@ -7,8 +7,8 @@
 
 "hashchk",
 "isamchk",
-"TAK",
 "NIE",
+"TAK",
 "Nie mo¿na stworzyæ pliku '%-.64s' (Kod b³êdu: %d)",
 "Nie mo¿na stworzyæ tabeli '%-.64s' (Kod b³êdu: %d)",
 "Nie mo¿na stworzyæ bazy danych '%-.64s'. B³?d %d",
diff --git a/sql/share/russian/errmsg.txt b/sql/share/russian/errmsg.txt
index 666f8e01232..b5d1a0a7e07 100644
--- a/sql/share/russian/errmsg.txt
+++ b/sql/share/russian/errmsg.txt
@@ -1,246 +1,245 @@
-/* Copyright Abandoned 1998.
+/* Copyright 2003 MySQL AB
+   Translation done in 2003 by Egor Egorov; Ensita.NET, http://www.ensita.net/
    This file is public domain and comes with NO WARRANTY of any kind */
-/* Primary translation was done by "Timur I. Bakeyev" <translate@bat.ru> */
-/* Additional translation by "Alexander I. Barkov" <bar@izhcom.ru> */
 /* charset: KOI8-R */
 
 "hashchk",
 "isamchk",
 "îåô",
 "äá",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ ÆÁÊÌ '%-.64s' (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ ÔÁÂÌÉÃÕ '%-.64s' (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ ÂÁÚÕ '%-.64s'. ïÛÉÂËÁ: %d",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ ÂÁÚÕ '%-.64s'. âÁÚÁ ÕÖÅ ÓÕÝÅÓÔ×ÕÅÔ",
-"îÅ ÍÏÇÕ ÕÄÁÌÉÔØ ÂÁÚÕ '%-.64s'. âÁÚÁ ÎÅ ÓÕÝÅÓÔ×ÕÅÔ",
-"ïÛÉÂËÁ ÐÒÉ ÕÄÁÌÅÎÉÉ ÂÁÚÙ (îÅ ÍÏÇÕ ÕÄÁÌÉÔØ '%-.64s', ÏÛÉÂËÁ %d)",
-"ïÛÉÂËÁ ÐÒÉ ÕÄÁÌÅÎÉÉ ÂÁÚÙ (îÅ ÍÏÇÕ ÕÄÁÌÉÔØ ËÁÔÁÌÏÇ '%-.64s', ÏÛÉÂËÁ %d)",
-"ïÛÉÂËÁ ÐÒÉ ÕÄÁÌÅÎÉÉ '%-.64s' (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÐÒÏÞÅÓÔØ ÚÁÐÉÓØ × ÓÉÓÔÅÍÎÏÊ ÔÁÂÌÉÃÅ",
-"îÅ ÍÏÇÕ ÐÏÌÕÞÉÔØ ÓÔÁÔÕÓ '%-.64s' (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÏÐÒÅÄÅÌÉÔØ ÒÁÂÏÞÉÊ ËÁÔÁÌÏÇ (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÂÌÏËÉÒÏ×ÁÔØ ÆÁÊÌ (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÏÔËÒÙÔØ ÆÁÊÌ: '%-.64s'. (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÎÁÊÔÉ ÆÁÊÌ: '%-.64s' (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÐÒÏÞÅÓÔØ ËÁÔÁÌÏÇ '%-.64s' (ïÛÉÂËÁ: %d)",
-"îÅ ÍÏÇÕ ÐÅÒÅÊÔÉ × ËÁÔÁÌÏÇ '%-.64s' (ïÛÉÂËÁ: %d)",
-"úÁÐÉÓØ ÂÙÌÁ ÉÚÍÅÎÅÎÁ ÓÏ ×ÒÅÍÅÎÉ ÐÏÓÌÅÄÎÅÇÏ ÞÔÅÎÉÑ ÔÁÂÌÉÃÙ '%-.64s'",
-"ðÅÒÅÐÏÌÎÅÎ ÄÉÓË (%-.64s). íÏÖÅÔ, ËÔÏ-ÎÉÂÕÄØ ÕÂÅÒÅÔ ÚÁ ÓÏÂÏÊ ÍÕÓÏÒ....",
-"îÅ ÍÏÇÕ ÐÒÏÉÚ×ÅÓÔÉ ÚÁÐÉÓØ, ËÌÀÞ ÄÕÂÌÉÒÕÅÔÓÑ × ÔÁÂÌÉÃÅ '%-.64s'",
-"ïÛÉÂËÁ ÐÒÉ ÚÁËÒÙÔÉÉ '%-.64s' (ïÛÉÂËÁ: %d)",
-"ïÛÉÂËÁ ÞÔÅÎÉÑ ÆÁÊÌÁ '%-.64s' (ïÛÉÂËÁ: %d)",
-"ïÛÉÂËÁ ÐÒÉ ÐÅÒÅÉÍÅÎÏ×ÁÎÉÉ '%-.64s' × '%-.64s' (ïÛÉÂËÁ: %d)",
-"ïÛÉÂËÁ ÚÁÐÉÓÉ × ÆÁÊÌ '%-.64s' (ïÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ ÆÁÊÌ '%-.64s' (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ ÔÁÂÌÉÃÕ '%-.64s' (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ ÂÁÚÕ ÄÁÎÎÙÈ '%-.64s'. (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ ÂÁÚÕ ÄÁÎÎÙÈ '%-.64s'. âÁÚÁ ÄÁÎÎÙÈ ÕÖÅ ÓÕÝÅÓÔ×ÕÅÔ",
+"îÅ×ÏÚÍÏÖÎÏ ÕÄÁÌÉÔØ ÂÁÚÕ ÄÁÎÎÙÈ '%-.64s'. ôÁËÏÊ ÂÁÚÙ ÄÁÎÎÙÈ ÎÅÔ",
+"ïÛÉÂËÁ ÐÒÉ ÕÄÁÌÅÎÉÉ ÂÁÚÙ ÄÁÎÎÙÈ (ÎÅ×ÏÚÍÏÖÎÏ ÕÄÁÌÉÔØ '%-.64s', ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÕÄÁÌÉÔØ ÂÁÚÕ ÄÁÎÎÙÈ (ÎÅ×ÏÚÍÏÖÎÏ ÕÄÁÌÉÔØ ËÁÔÁÌÏÇ '%-.64s', ÏÛÉÂËÁ: %d)",
+"ïÛÉÂËÁ ÐÒÉ ÕÄÁÌÅÎÉÉ '%-.64s' (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÐÒÏÞÉÔÁÔØ ÚÁÐÉÓØ × ÓÉÓÔÅÍÎÏÊ ÔÁÂÌÉÃÅ",
+"îÅ×ÏÚÍÏÖÎÏ ÐÏÌÕÞÉÔØ ÓÔÁÔÕÓÎÕÀ ÉÎÆÏÒÍÁÃÉÀ Ï '%-.64s' (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÏÐÒÅÄÅÌÉÔØ ÒÁÂÏÞÉÊ ËÁÔÁÌÏÇ (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÐÏÓÔÁ×ÉÔØ ÂÌÏËÉÒÏ×ËÕ ÎÁ ÆÁÊÌÅ (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÆÁÊÌ: '%-.64s'. (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÎÁÊÔÉ ÆÁÊÌ: '%-.64s' (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÐÒÏÞÉÔÁÔØ ËÁÔÁÌÏÇ '%-.64s' (ÏÛÉÂËÁ: %d)",
+"îÅ×ÏÚÍÏÖÎÏ ÐÅÒÅÊÔÉ × ËÁÔÁÌÏÇ '%-.64s' (ÏÛÉÂËÁ: %d)",
+"úÁÐÉÓØ ÉÚÍÅÎÉÌÁÓØ Ó ÍÏÍÅÎÔÁ ÐÏÓÌÅÄÎÅÊ ×ÙÂÏÒËÉ × ÔÁÂÌÉÃÅ '%-.64s'",
+"äÉÓË ÚÁÐÏÌÎÅÎ. (%s). ïÖÉÄÁÅÍ, ÐÏËÁ ËÔÏ-ÔÏ ÎÅ ÕÂÅÒÅÔ ÐÏÓÌÅ ÓÅÂÑ ÍÕÓÏÒ....",
+"îÅ×ÏÚÍÏÖÎÏ ÐÒÏÉÚ×ÅÓÔÉ ÚÁÐÉÓØ, ÄÕÂÌÉÒÕÀÝÉÊÓÑ ËÌÀÞ × ÔÁÂÌÉÃÅ '%-.64s'",
+"ïÛÉÂËÁ ÐÒÉ ÚÁËÒÙÔÉÉ '%-.64s' (ÏÛÉÂËÁ: %d)",
+"ïÛÉÂËÁ ÞÔÅÎÉÑ ÆÁÊÌÁ '%-.64s' (ÏÛÉÂËÁ: %d)",
+"ïÛÉÂËÁ ÐÒÉ ÐÅÒÅÉÍÅÎÏ×ÁÎÉÉ '%-.64s' × '%-.64s' (ÏÛÉÂËÁ: %d)",
+"ïÛÉÂËÁ ÚÁÐÉÓÉ × ÆÁÊÌ '%-.64s' (ÏÛÉÂËÁ: %d)",
 "'%-.64s' ÚÁÂÌÏËÉÒÏ×ÁÎ ÄÌÑ ÉÚÍÅÎÅÎÉÊ",
 "óÏÒÔÉÒÏ×ËÁ ÐÒÅÒ×ÁÎÁ",
-"View '%-.64s' ÎÅ ÓÕÝÅÓÔ×ÕÅÔ ÄÌÑ '%-.64s'",
-"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ %d ÏÔ ÄÅÓËÒÉÐÔÏÒÁ ÔÁÂÌÉÃÙ",
-"äÅÓËÒÉÐÔÏÒ ÔÁÂÌÉÃÙ '%-.64s' ÎÅ ÉÍÅÅÔ ÔÁËÏÇÏ Ó×ÏÊÓÔ×Á",
-"îÅ ÍÏÇÕ ÎÁÊÔÉ ÚÁÐÉÓØ × '%-.64s'",
-"îÅ×ÅÒÎÁÑ ÉÎÆÏÒÍÁÃÉÑ × ÆÁÊÌÅ: '%-.64s'",
-"îÅ×ÅÒÎÙÊ ÉÎÄÅËÓÎÙÊ ÆÁÊÌ ÄÌÑ ÔÁÂÌÉÃÙ: '%-.64s'. ðÏÐÒÏÂÕÊÔÅ ÅÇÏ ×ÏÓÓÏÚÄÁÔØ",
-"óÔÁÒÙÊ ÉÎÄÅËÓÎÙÊ ÆÁÊÌ ÄÌÑ ÔÁÂÌÉÃÙ '%-.64s'; òÅÉÎÄÅËÓÉÒÕÊÔÅ ÅÅ!",
-"'%-.64s' ÔÏÌØËÏ ÄÌÑ ÞÔÅÎÉÑ",
-"îÅ È×ÁÔÁÅÔ ÐÁÍÑÔÉ. ðÅÒÅÇÒÕÚÉÔÅ ÓÅÒ×ÅÒ É ÐÏÐÒÏÂÕÊÔÅ ÓÎÏ×Á (ÎÕÖÎÏ %d ÂÁÊÔ)",
-"îÅ È×ÁÔÁÅÔ ÐÁÍÑÔÉ ÄÌÑ ÓÏÒÔÉÒÏ×ËÉ. õ×ÅÌÉÞØÔÅ ÒÁÚÍÅÒ ÂÕÆÅÒÁ ÓÏÒÔÉÒÏ×ËÉ Õ ÓÅÒ×ÅÒÁ",
-"îÅÏÖÉÄÁÎÎÙÊ ËÏÎÅà ÆÁÊÌÁ '%-.64s' (ïÛÉÂËÁ: %d)",
+"ðÒÅÄÓÔÁ×ÌÅÎÉÅ '%-.64s' ÎÅ ÓÕÝÅÓÔ×ÕÅÔ ÄÌÑ '%-.64s'",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ %d ÏÔ ÏÂÒÁÂÏÔÞÉËÁ ÔÁÂÌÉÃ",
+"ïÂÒÁÂÏÔÞÉË ÔÁÂÌÉÃÙ '%-.64s' ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ÜÔÕ ×ÏÚÍÏÖÎÏÓÔØ",
+"îÅ×ÏÚÍÏÖÎÏ ÎÁÊÔÉ ÚÁÐÉÓØ × '%-.64s'",
+"îÅËÏÒÒÅËÔÎÁÑ ÉÎÆÏÒÍÁÃÉÑ × ÆÁÊÌÅ '%-.64s'",
+"îÅËÏÒÒÅËÔÎÙÊ ÉÎÄÅËÓÎÙÊ ÆÁÊÌ ÄÌÑ ÔÁÂÌÉÃÙ: '%-.64s'. ðÏÐÒÏÂÕÊÔÅ ×ÏÓÓÔÁÎÏ×ÉÔØ ÅÇÏ",
+"óÔÁÒÙÊ ÉÎÄÅËÓÎÙÊ ÆÁÊÌ ÄÌÑ ÔÁÂÌÉÃÙ '%-.64s'; ÏÔÒÅÍÏÎÔÉÒÕÊÔÅ ÅÇÏ!",
+"ôÁÂÌÉÃÁ '%-.64s' ÐÒÅÄÎÁÚÎÁÞÅÎÁ ÔÏÌØËÏ ÄÌÑ ÞÔÅÎÉÑ",
+"îÅÄÏÓÔÁÔÏÞÎÏ ÐÁÍÑÔÉ. ðÅÒÅÚÁÐÕÓÔÉÔÅ ÓÅÒ×ÅÒ É ÐÏÐÒÏÂÕÊÔÅ ÅÝÅ ÒÁÚ (ÎÕÖÎÏ %d ÂÁÊÔ)",
+"îÅÄÏÓÔÁÔÏÞÎÏ ÐÁÍÑÔÉ ÄÌÑ ÓÏÒÔÉÒÏ×ËÉ. õ×ÅÌÉÞØÔÅ ÒÁÚÍÅÒ ÂÕÆÅÒÁ ÓÏÒÔÉÒÏ×ËÉ ÎÁ ÓÅÒ×ÅÒÅ",
+"îÅÏÖÉÄÁÎÎÙÊ ËÏÎÅà ÆÁÊÌÁ '%-.64s' (ÏÛÉÂËÁ: %d)",
 "óÌÉÛËÏÍ ÍÎÏÇÏ ÓÏÅÄÉÎÅÎÉÊ",
-"îÅÄÏÓÔÁÔÏË ÍÅÓÔÁ/ÐÁÍÑÔÉ ÄÌÑ ÎÉÔÉ",
-"îÅ ÍÏÇÕ ÏÐÒÅÄÅÌÉÔØ ÉÍÑ ÈÏÓÔÁ ÐÏ ÷ÁÛÅÍÕ ÁÄÒÅÓÕ",
-"îÅËÏÒÒÅËÔÎÁÑ ÉÎÉÃÉÁÌÉÚÁÃÉÑ Ó×ÑÚÉ",
-"äÏÓÔÕÐ ÚÁËÒÙÔ ÄÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ: '%-.32s@%-.64s' Ë ÂÁÚÅ '%-.64s'",
-"äÏÓÔÕÐ ÚÁËÒÙÔ ÄÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ: '%-.32s@%-.64s' (âÙÌ ÉÓÐÏÌØÚÏ×ÁÎ ÐÁÒÏÌØ: %-.64s)",
-"îÅ ×ÙÂÒÁÎÁ ÂÁÚÁ",
-"îÅÉÚ×ÅÓÔÎÁÑ ËÏÍÁÎÄÁ",
-"óÔÏÌÂÅà '%-.64s' ÎÅ ÍÏÖÅÔ ÂÙÔØ ÐÕÓÔÙÍ/ÎÕÌÅ×ÙÍ",
-"îÅÉÚ×ÅÓÔÎÁÑ ÂÁÚÁ '%-.64s'",
-"ôÁÂÌÉÃÁ '%-.64s' ÕÖÅ ÅÓÔØ",
+"îÅÄÏÓÔÁÔÏÞÎÏ ÐÁÍÑÔÉ; ÕÄÏÓÔÏ×ÅÒØÔÅÓØ, ÞÔÏ mysqld ÉÌÉ ËÁËÏÊ-ÌÉÂÏ ÄÒÕÇÏÊ ÐÒÏÃÅÓÓ ÎÅ ÚÁÎÉÍÁÅÔ ×ÓÀ ÄÏÓÔÕÐÎÕÀ ÐÁÍÑÔØ. åÓÌÉ ÎÅÔ, ÔÏ ×Ù ÍÏÖÅÔÅ ÉÓÐÏÌØÚÏ×ÁÔØ ulimit, ÞÔÏÂÙ ×ÙÄÅÌÉÔØ ÄÌÑ mysqld ÂÏÌØÛÅ ÐÁÍÑÔÉ, ÉÌÉ Õ×ÅÌÉÞÉÔØ ÏÂßÅÍ ÆÁÊÌÁ ÐÏÄËÁÞËÉ",
+"îÅ×ÏÚÍÏÖÎÏ ÐÏÌÕÞÉÔØ ÉÍÑ ÈÏÓÔÁ ÄÌÑ ×ÁÛÅÇÏ ÁÄÒÅÓÁ",
+"îÅËÏÒÒÅËÔÎÏÅ ÐÒÉ×ÅÔÓÔ×ÉÅ",
+"äÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s@%-.64s' ÄÏÓÔÕÐ Ë ÂÁÚÅ ÄÁÎÎÙÈ '%-.64s' ÚÁËÒÙÔ",
+"äÏÓÔÕÐ ÚÁËÒÙÔ ÄÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s@%-.64s' (ÂÙÌ ÉÓÐÏÌØÚÏ×ÁÎ ÐÁÒÏÌØ: %s)",
+"âÁÚÁ ÄÁÎÎÙÈ ÎÅ ×ÙÂÒÁÎÁ",
+"îÅÉÚ×ÅÓÔÎÁÑ ËÏÍÁÎÄÁ ËÏÍÍÕÎÉËÁÃÉÏÎÎÏÇÏ ÐÒÏÔÏËÏÌÁ",
+"óÔÏÌÂÅà '%-.64s' ÎÅ ÍÏÖÅÔ ÐÒÉÎÉÍÁÔØ ×ÅÌÉÞÉÎÕ NULL",
+"îÅÉÚ×ÅÓÔÎÁÑ ÂÁÚÁ ÄÁÎÎÙÈ '%-.64s'",
+"ôÁÂÌÉÃÁ '%-.64s' ÕÖÅ ÓÕÝÅÓÔ×ÕÅÔ",
 "îÅÉÚ×ÅÓÔÎÁÑ ÔÁÂÌÉÃÁ '%-.64s'",
-"ðÏÌÅ '%-.64s' × %-.64s ÎÅ ÏÄÎÏÚÎÁÞÎÏ",
-"ðÒÏÉÓÈÏÄÉÔ ×ÙËÌÀÞÅÎÉÅ ÓÅÒ×ÅÒÁ",
-"îÅÉÚ×ÅÓÔÎÏÅ ÐÏÌÅ '%-.64s' × %-.64s",
-" '%-.64s' ÉÓÐÏÌØÚÏ×ÁÎÏ ×ÎÅ ×ÙÒÁÖÅÎÉÑ GROUP BY",
-"îÅ ÍÏÇÕ ÐÒÏÉÚ×ÅÓÔÉ ÇÒÕÐÐÉÒÏ×ËÕ ÐÏ '%-.64s'",
-"÷ ÏÄÎÏÍ ×ÙÒÁÖÅÎÉÉ ÓÏÄÅÒÖÁÔØÓÑ É ÉÍÅÎÁ ÐÏÌÅÊ, É ÓÕÍÍÉÒÕÀÝÉÅ ÆÕÎËÃÉÉ",
-"þÉÓÌÏ ÓÔÏÌÂÃÏ× ÎÅ ÓÏÏÔ×ÅÔÓÔ×ÕÅÔ ÞÉÓÌÕ ÚÎÁÞÅÎÉÊ",
-"óÌÉÛËÏÍ ÄÌÉÎÎÙÊ ÉÄÅÎÔÉÆÉËÁÔÏÒ: '%-.64s'",
-"äÕÂÌÉÒÏ×ÁÎÎÏÅ ÉÍÑ ÐÏÌÑ '%-.64s'",
-"äÕÂÌÉÒÏ×ÁÎÎÏÅ ÉÍÑ ËÌÀÞÁ '%-.64s'",
-"ðÏ×ÔÏÒÑÀÝÅÅÓÑ ÚÎÁÞÅÎÉÅ '%-.64s' ÄÌÑ ËÌÀÞÁ %d",
-"îÅ×ÅÒÎÙÊ ÓÐÅÃÉÆÉËÁÔÏÒ ÐÏÌÑ: '%-.64s'",
-"%-.64s ÏËÏÌÏ '%-.64s', × ÓÔÒÏËÅ %d",
-"ðÕÓÔÏÊ ÚÁÐÒÏÓ",
-"îÅ ÕÎÉËÁÌØÎÁÑ ÔÁÂÌÉÃÁ/ÐÓÅ×ÄÏÎÉÍ: '%-.64s'",
-"îÅ×ÅÒÎÏÅ ÚÎÁÞÅÎÉÅ ÐÏ ÕÍÏÌÞÁÎÉÀ '%-.64s'",
-"ðÅÒ×ÉÞÎÙÊ ËÌÀÞ ÏÐÒÅÄÅÌÅÎ ÎÅÓËÏÌØËÏ ÒÁÚ",
-"ïÐÒÅÄÅÌÅÎÎÏ ÓÌÉÛËÏÍ ÍÎÏÇÏ ËÌÀÞÅÊ. ÷ÏÚÍÏÖÎÏ ÍÁËÓÉÍÁÌØÎÏ %d ËÌÀÞÅÊ",
-"ïÐÒÅÄÅÌÅÎÎÏ ÓÌÉÛËÏÍ ÍÎÏÇÏ ÓÏÓÔÁ×ÌÑÀÝÉÈ ËÌÀÞÁ. ÷ÏÚÍÏÖÎÏ ÍÁËÓÉÍÁÌØÎÏ %d ÓÏÓÔÁ×ÌÑÀÝÉÈ",
-"ëÌÀÞ ÓÌÉÛËÏÍ ÂÏÌØÛÏÊ. íÁËÓÉÍÁÌØÎÁÑ ÄÌÉÎÁ %d",
-"ëÌÀÞÅ×ÏÅ ÐÏÌÅ '%-.64s' ÎÅ ÓÏÄÅÒÖÉÔÓÑ × ÔÁÂÌÉÃÅ",
-"ïÂßÅËÔ BLOB '%-.64s' ÎÅ ÍÏÖÅÔ ÐÒÉÓÕÔÓÔ×Ï×ÁÔØ × ÏÐÒÅÄÅÌÅÎÉÉ ËÌÀÞÁ",
-"óÌÉÛËÏÍ ×ÅÌÉË ÒÁÚÍÅÒ ÐÏÌÑ '%-.64s' (max = %d). ÷ÏÓÐÏÌØÚÕÊÔÅÓØ ÏÂßÅËÔÏÍ BLOB",
-"á×ÔÏÍÁÔÉÞÅÓËÏÅ ÐÏÌÅ ÍÏÖÅÔ ÂÙÔØ ÔÏÌØËÏ ÏÄÎÏ É ÄÏÌÖÎÏ ÂÙÔØ ËÌÀÞÏÍ",
-"%-.64s: îÁ Ó×ÑÚÉ!\n",
-"%-.64s: îÏÒÍÁÌØÎÏÅ ÚÁ×ÅÒÛÅÎÉÅ\n",
-"%-.64s: ðÏÌÕÞÅÎ ÓÉÇÎÁÌ %d. õÍÙ×ÁÀ ÒÕËÉ!\n",
-"%-.64s: ïÔËÌÀÞÅÎÉÅ ×ÙÐÏÌÎÅÎÏ\n",
-"%-.64s: ðÒÉÎÕÄÉÔÅÌØÎÏÅ ÐÒÅËÒÁÝÅÎÉÅ ÎÉÔÉ %ld ÐÏÌØÚÏ×ÁÔÅÌÑ: '%-.64s'\n",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ IP socket",
-"ôÁÂÌÉÃÁ '%-.64s' ÉÍÅÅÔ ÉÎÄÅËÓ, ÎÅ ÓÏ×ÐÁÄÁÀÝÉÊ Ó ÕËÁÚÁÎÎÙÍ × CREATE INDEX. óÏÚÄÁÊÔÅ ÔÁÂÌÉÃÕ ÅÝÅ ÒÁÚ",
-"òÁÚÄÅÌÉÔÅÌÉ ÐÏÌÅÊ ÎÅ ÓÏ×ÐÁÄÁÀÔ Ó ÏÖÉÄÁÅÍÙÍÉ. ðÒÏÞÔÉÔÅ ÎÁËÏÎÅà ÉÎÓÔÒÕËÃÉÀ!",
-"îÅÌØÚÑ ÓÓÙÌÁÔØÓÑ ÎÁ ÆÉËÓÉÒÏ×ÁÎÎÕÀ ÄÌÉÎÕ ÓÔÒÏËÉ × BLOB. éÓÐÏÌØÚÕÊÔÅ 'fields terminated by'.",
-"æÁÊÌ '%-.64s' ÄÏÌÖÅÎ ÂÙÔØ × ËÁÔÁÌÏÇÅ ÂÁÚ ÌÉÂÏ ÄÏÓÔÕÐÅÎ ×ÓÅÍ ÄÌÑ ÞÔÅÎÉÑ",
-"æÁÊÌ '%-.64s' ÕÖÅ ÅÓÔØ",
+"óÔÏÌÂÅÃ '%-.64s' × %-.64s ÚÁÄÁÎ ÎÅÏÄÎÏÚÎÁÞÎÏ",
+"óÅÒ×ÅÒ ÎÁÈÏÄÉÔÓÑ × ÐÒÏÃÅÓÓÅ ÏÓÔÁÎÏ×ËÉ",
+"îÅÉÚ×ÅÓÔÎÙÊ ÓÔÏÌÂÅà '%-.64s' × '%-.64s'",
+"'%-.64s' ÎÅ ÐÒÉÓÕÔÓÔ×ÕÅÔ × GROUP BY",
+"îÅ×ÏÚÍÏÖÎÏ ÐÒÏÉÚ×ÅÓÔÉ ÇÒÕÐÐÉÒÏ×ËÕ ÐÏ '%-.64s'",
+"÷ÙÒÁÖÅÎÉÅ ÓÏÄÅÒÖÉÔ ÇÒÕÐÐÏ×ÙÅ ÆÕÎËÃÉÉ É ÓÔÏÌÂÃÙ, ÎÏ ÎÅ ×ËÌÀÞÁÅÔ GROUP BY. á ËÁË ×Ù ÕÍÕÄÒÉÌÉÓØ ÐÏÌÕÞÉÔØ ÜÔÏ ÓÏÏÂÝÅÎÉÅ Ï ÏÛÉÂËÅ?",
+"ëÏÌÉÞÅÓÔ×Ï ÓÔÏÌÂÃÏ× ÎÅ ÓÏ×ÐÁÄÁÅÔ Ó ËÏÌÉÞÅÓÔ×ÏÍ ÚÎÁÞÅÎÉÊ",
+"óÌÉÛËÏÍ ÄÌÉÎÎÙÊ ÉÄÅÎÔÉÆÉËÁÔÏÒ '%-.100s'",
+"äÕÂÌÉÒÕÀÝÅÅÓÑ ÉÍÑ ÓÔÏÌÂÃÁ '%-.64s'",
+"äÕÂÌÉÒÕÀÝÅÅÓÑ ÉÍÑ ËÌÀÞÁ '%-.64s'",
+"äÕÂÌÉÒÕÀÝÁÑÓÑ ÚÁÐÉÓØ '%-.64s' ÐÏ ËÌÀÞÕ %d",
+"îÅËÏÒÒÅËÔÎÙÊ ÏÐÒÅÄÅÌÉÔÅÌØ ÓÔÏÌÂÃÁ ÄÌÑ ÓÔÏÌÂÃÁ '%-.64s'",
+"%s ÏËÏÌÏ '%-.80s' ÎÁ ÓÔÒÏËÅ %d",
+"úÁÐÒÏÓ ÏËÁÚÁÌÓÑ ÐÕÓÔÙÍ",
+"ðÏ×ÔÏÒÑÀÝÁÑÓÑ ÔÁÂÌÉÃÁ/ÐÓÅ×ÄÏÎÉÍ '%-.64s'",
+"îÅËÏÒÒÅËÔÎÏÅ ÚÎÁÞÅÎÉÅ ÐÏ ÕÍÏÌÞÁÎÉÀ ÄÌÑ '%-.64s'",
+"õËÁÚÁÎÏ ÎÅÓËÏÌØËÏ ÐÅÒ×ÉÞÎÙÈ ËÌÀÞÅÊ",
+"õËÁÚÁÎÏ ÓÌÉÛËÏÍ ÍÎÏÇÏ ËÌÀÞÅÊ. òÁÚÒÅÛÁÅÔÓÑ ÕËÁÚÙ×ÁÔØ ÎÅ ÂÏÌÅÅ %d ËÌÀÞÅÊ",
+"õËÁÚÁÎÏ ÓÌÉÛËÏÍ ÍÎÏÇÏ ÞÁÓÔÅÊ ÓÏÓÔÁ×ÎÏÇÏ ËÌÀÞÁ. òÁÚÒÅÛÁÅÔÓÑ ÕËÁÚÙ×ÁÔØ ÎÅ ÂÏÌÅÅ %d ÞÁÓÔÅÊ",
+"õËÁÚÁÎ ÓÌÉÛËÏÍ ÄÌÉÎÎÙÊ ËÌÀÞ. íÁËÓÉÍÁÌØÎÁÑ ÄÌÉÎÁ ËÌÀÞÁ ÓÏÓÔÁ×ÌÑÅÔ %d",
+"ëÌÀÞÅ×ÏÊ ÓÔÏÌÂÅà '%-.64s' × ÔÁÂÌÉÃÅ ÎÅ ÓÕÝÅÓÔ×ÕÅÔ",
+"óÔÏÌÂÅà ÔÉÐÁ BLOB '%-.64s' ÎÅ ÍÏÖÅÔ ÂÙÔØ ÉÓÐÏÌØÚÏ×ÁÎ ËÁË ÚÎÁÞÅÎÉÅ ËÌÀÞÁ × ÔÁÂÌÉÃÅ ÔÁËÏÇÏ ÔÉÐÁ",
+"óÌÉÛËÏÍ ÂÏÌØÛÁÑ ÄÌÉÎÁ ÓÔÏÌÂÃÁ '%-.64s' (ÍÁËÓÉÍÕÍ = %d). éÓÐÏÌØÚÕÊÔÅ ÔÉÐ BLOB ×ÍÅÓÔÏ ÔÅËÕÝÅÇÏ",
+"îÅËÏÒÒÅËÔÎÏÅ ÏÐÒÅÄÅÌÅÎÉÅ ÔÁÂÌÉÃÙ: ÍÏÖÅÔ ÓÕÝÅÓÔ×Ï×ÁÔØ ÔÏÌØËÏ ÏÄÉÎ Á×ÔÏÉÎËÒÅÍÅÎÔÎÙÊ ÓÔÏÌÂÅÃ, É ÏÎ ÄÏÌÖÅÎ ÂÙÔØ ÏÐÒÅÄÅÌÅÎ ËÁË ËÌÀÞ",
+"%s: çÏÔÏ× ÐÒÉÎÉÍÁÔØ ÓÏÅÄÉÎÅÎÉÑ.\n÷ÅÒÓÉÑ: '%s'  ÓÏËÅÔ: '%s'  ÐÏÒÔ: %d\n",
+"%s: ëÏÒÒÅËÔÎÁÑ ÏÓÔÁÎÏ×ËÁ\n",
+"%s: ðÏÌÕÞÅÎ ÓÉÇÎÁÌ %d. ðÒÅËÒÁÝÁÅÍ!\n",
+"%s: ïÓÔÁÎÏ×ËÁ ÚÁ×ÅÒÛÅÎÁ\n",
+"%s: ðÒÉÎÕÄÉÔÅÌØÎÏ ÚÁËÒÙ×ÁÅÍ ÐÏÔÏË %ld  ÐÏÌØÚÏ×ÁÔÅÌÑ: '%-.32s'\n",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ IP-ÓÏËÅÔ",
+"÷ ÔÁÂÌÉÃÅ '%-.64s' ÎÅÔ ÔÁËÏÇÏ ÉÎÄÅËÓÁ, ËÁË × CREATE INDEX. óÏÚÄÁÊÔÅ ÔÁÂÌÉÃÕ ÚÁÎÏ×Ï",
+"áÒÇÕÍÅÎÔ ÒÁÚÄÅÌÉÔÅÌÑ ÐÏÌÅÊ - ÎÅ ÔÏÔ, ËÏÔÏÒÙÊ ÏÖÉÄÁÌÓÑ. ïÂÒÁÝÁÊÔÅÓØ Ë ÄÏËÕÍÅÎÔÁÃÉÉ",
+"æÉËÓÉÒÏ×ÁÎÎÙÊ ÒÁÚÍÅÒ ÚÁÐÉÓÉ Ó ÐÏÌÑÍÉ ÔÉÐÁ BLOB ÉÓÐÏÌØÚÏ×ÁÔØ ÎÅÌØÚÑ. ðÒÉÍÅÎÑÊÔÅ 'fields terminated by'.",
+"æÁÊÌ '%-.64s' ÄÏÌÖÅÎ ÎÁÈÏÄÉÔØÓÑ × ÔÏÍ ÖÅ ËÁÔÁÌÏÇÅ, ÞÔÏ É ÂÁÚÁ ÄÁÎÎÙÈ, ÉÌÉ ÂÙÔØ ÏÂÝÅÄÏÓÔÕÐÎÙÍ ÄÌÑ ÞÔÅÎÉÑ",
+"æÁÊÌ '%-.80s' ÕÖÅ ÓÕÝÅÓÔ×ÕÅÔ",
 "úÁÐÉÓÅÊ: %ld  õÄÁÌÅÎÏ: %ld  ðÒÏÐÕÝÅÎÏ: %ld  ðÒÅÄÕÐÒÅÖÄÅÎÉÊ: %ld",
-"úÁÐÉÓÅÊ: %ld  äÕÂÌÅÊ: %ld",
-"îÅ×ÅÒÎÁÑ ÓÏÓÔÁ×ÌÑÀÝÁÑ ËÌÀÞÁ. äÁÎÎÁÑ ÓÏÓÔÁ×ÌÑÀÝÁÑ ÌÉÂÏ ÎÅ ÓÔÒÏËÏ×ÁÑ, ÌÉÂÏ ÂÏÌØÛÅ, ÞÅÍ ÍÏÖÅÔ ÂÙÔØ",
-"îÅÌØÚÑ ÕÄÁÌÉÔØ ×ÓÅ ÐÏÌÑ ÞÅÒÅÚ ALTER TABLE. ÷ÏÓÐÏÌØÚÕÊÔÅÓØ DROP TABLE",
-"îÅ ÍÏÇÕ ÓÂÒÏÓÉÔØ '%-.64s'. ðÒÏ×ÅÒØÔÅ, ÞÔÏ ÜÔÏ ÐÏÌÅ/ËÌÀÞ ÓÕÝÅÓÔ×ÕÀÔ",
-"úÁÐÉÓÅÊ: %ld  äÕÂÌÅÊ: %ld  ðÒÅÄÕÐÒÅÖÄÅÎÉÊ: %ld",
-"÷Ù ÎÅ ÍÏÖÅÔÅ ÕËÁÚÁÔØ ÉÚÍÅÎÅÑÍÕÀ ÔÁÂÌÉÃÕ '%-.64s' × ÓÐÉÓËÅ ÔÁÂÌÉÃ  FROM",
-"îÅÉÚ×ÅÓÔÎÁÑ ÎÉÔØ: %lu",
-"÷Ù ÎÅ ×ÌÁÄÅÌÅà ÎÉÔÉ %lu",
-"ôÁÂÌÉÃÙ ÎÅ ÉÓÐÏÌØÚÏ×ÁÎÙ",
-"ïÞÅÎØ ÍÎÏÇÏ ÓÔÒÏË ÄÌÑ ÐÏÌÑ %-.64s É SET",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ ÕÎÉËÁÌØÎÙÊ ÌÏÇ-ÆÁÊÌ %-.64s.(1-999)\n",
-"ôÁÂÌÉÃÁ '%-.64s' ÚÁÂÌÏËÉÒÏ×ÁÎÁ READ É ÎÅ ÍÏÖÅÔ ÂÙÔØ ÏÂÎÏ×ÌÅÎÁ",
-"ôÁÂÌÉÃÁ '%-.64s' ÎÅ ÂÙÌÁ ÂÌÏËÉÒÏ×ÁÎÁ LOCK TABLES",
-"ïÂßÅËÔ BLOB '%-.64s' ÎÅ ÍÏÖÅÔ ÉÍÅÅÔ ÚÎÁÞÅÎÉÊ ÐÏ ÕÍÏÌÞÁÎÉÀ",
-"îÅÄÏÐÕÓÔÉÍÏÅ ÉÍÑ ÂÁÚÙ '%-.64s'",
-"îÅÄÏÐÕÓÔÉÍÏÅ ÉÍÑ ÔÁÂÌÉÃÙ '%-.64s'",
-"SELECT ÏÂÒÁÂÏÔÁÅÔ ÏÞÅÎØ ÍÎÏÇÏ ÚÁÐÉÓÅÊ É ÜÔÏ îáäïìçï. ðÒÏ×ÅÒØÔÅ ÕÓÌÏ×ÉÅ WHERE É ×ÏÓÐÏÌØÚÕÊÔÅÓØ SQL_OPTION BIG_SELECTS=1 ÅÓÌÉ SELECT ËÏÒÒÅËÔÅÎ",
+"úÁÐÉÓÅÊ: %ld  äÕÂÌÉËÁÔÏ×: %ld",
+"îÅËÏÒÒÅËÔÎÁÑ ÞÁÓÔØ ËÌÀÞÁ. éÓÐÏÌØÚÕÅÍÁÑ ÞÁÓÔØ ËÌÀÞÁ ÎÅ Ñ×ÌÑÅÔÓÑ ÓÔÒÏËÏÊ, ÕËÁÚÁÎÎÁÑ ÄÌÉÎÁ ÂÏÌØÛÅ, ÞÅÍ ÄÌÉÎÁ ÞÁÓÔÉ ËÌÀÞÁ, ÉÌÉ ÏÂÒÁÂÏÔÞÉË ÔÁÂÌÉÃÙ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ÕÎÉËÁÌØÎÙÅ ÞÁÓÔÉ ËÌÀÞÁ",
+"îÅÌØÚÑ ÕÄÁÌÉÔØ ×ÓÅ ÓÔÏÌÂÃÙ Ó ÐÏÍÏÝØÀ ALTER TABLE. éÓÐÏÌØÚÕÊÔÅ  DROP TABLE",
+"îÅ×ÏÚÍÏÖÎÏ ÕÄÁÌÉÔØ (DROP) '%-.64s'. õÂÅÄÉÔÅÓØ ÞÔÏ ÓÔÏÌÂÅÃ/ËÌÀÞ ÄÅÊÓÔ×ÉÔÅÌØÎÏ ÓÕÝÅÓÔ×ÕÅÔ",
+"úÁÐÉÓÅÊ: %ld  äÕÂÌÉËÁÔÏ×: %ld  ðÒÅÄÕÐÒÅÖÄÅÎÉÊ: %ld",
+"îÅ ÄÏÐÕÓËÁÅÔÓÑ ÕËÁÚÁÎÉÅ ÔÁÂÌÉÃÙ '%-.64s' × ÓÐÉÓËÅ ÔÁÂÌÉà FROM ÄÌÑ ×ÎÅÓÅÎÉÑ × ÎÅÅ ÉÚÍÅÎÅÎÉÊ",
+"îÅÉÚ×ÅÓÔÎÙÊ ÎÏÍÅÒ ÐÏÔÏËÁ: %lu",
+"÷Ù ÎÅ Ñ×ÌÑÅÔÅÓØ ×ÌÁÄÅÌØÃÅÍ ÐÏÔÏËÁ %lu",
+"îÉËÁËÉÅ ÔÁÂÌÉÃÙ ÎÅ ÉÓÐÏÌØÚÏ×ÁÎÙ",
+"óÌÉÛËÏÍ ÍÎÏÇÏ ÚÎÁÞÅÎÉÊ ÄÌÑ ÓÔÏÌÂÃÁ %-.64s × SET",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ ÕÎÉËÁÌØÎÏÅ ÉÍÑ ÆÁÊÌÁ ÖÕÒÎÁÌÁ %-.64s.(1-999)\n",
+"ôÁÂÌÉÃÁ '%-.64s' ÚÁÂÌÏËÉÒÏ×ÁÎÁ ÕÒÏ×ÎÅÍ READ lock É ÎÅ ÍÏÖÅÔ ÂÙÔØ ÉÚÍÅÎÅÎÁ",
+"ôÁÂÌÉÃÁ '%-.64s' ÎÅ ÂÙÌÁ ÚÁÂÌÏËÉÒÏ×ÁÎÁ Ó ÐÏÍÏÝØÀ LOCK TABLES",
+"îÅ×ÏÚÍÏÖÎÏ ÕËÁÚÙ×ÁÔØ ÚÎÁÞÅÎÉÅ ÐÏ ÕÍÏÌÞÁÎÉÀ ÄÌÑ ÓÔÏÌÂÃÁ BLOB '%-.64s'",
+"îÅËÏÒÒÅËÔÎÏÅ ÉÍÑ ÂÁÚÙ ÄÁÎÎÙÈ '%-.100s'",
+"îÅËÏÒÒÅËÔÎÏÅ ÉÍÑ ÔÁÂÌÉÃÙ '%-.100s'",
+"äÌÑ ÔÁËÏÊ ×ÙÂÏÒËÉ SELECT ÄÏÌÖÅÎ ÂÕÄÅÔ ÐÒÏÓÍÏÔÒÅÔØ ÓÌÉÛËÏÍ ÍÎÏÇÏ ÚÁÐÉÓÅÊ É, ×ÉÄÉÍÏ, ÜÔÏ ÚÁÊÍÅÔ ÏÞÅÎØ ÍÎÏÇÏ ×ÒÅÍÅÎÉ. ðÒÏ×ÅÒØÔÅ ×ÁÛÅ ÕËÁÚÁÎÉÅ WHERE, É, ÅÓÌÉ × ÎÅÍ ×ÓÅ × ÐÏÒÑÄËÅ, ÕËÁÖÉÔÅ SET OPTION SQL_BIG_SELECTS=1",
 "îÅÉÚ×ÅÓÔÎÁÑ ÏÛÉÂËÁ",
-"îÅÉÚ×ÅÓÔÎÁÑ ÐÒÏÃÅÄÕÒÁ %-.64s",
-"îÅ×ÅÒÎÏÅ ËÏÌÉÞÅÓÔ×Ï ÐÁÒÁÍÅÔÒÏ× × ×ÙÚÏ×Å %-.64s",
-"îÅ×ÅÒÎÙÅ ÐÁÒÁÍÅÔÒÙ × ÐÒÏÃÅÄÕÒÅ %-.64s",
-"îÅÉÚ×ÅÓÔÎÁÑ ÔÁÂÌÉÃÁ '%-.64s' × %-.64s",
-"ðÏÌÅ '%-.64s' ÏÂßÑ×ÌÅÎÎÏ Ä×ÁÖÄÙ",
-"îÅ×ÅÒÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ ÇÒÕÐÐÏ×ÏÊ ÆÕÎËÃÉÉ",
-"ôÁÂÌÉÃÁ '%-.64s' ÉÓÐÏÌØÚÕÅÔ ÒÁÓÛÉÒÅÎÉÅ, ÎÅ ÓÕÝÅÓÔ×ÕÀÝÅÅ × ÄÁÎÎÏÊ ×ÅÒÓÉÉ MySQL",
-"÷ ÔÁÂÌÉÃÅ ÄÏÌÖÎÏ ÂÙÔØ ÈÏÔÑ ÂÙ ÏÄÎÏ ÐÏÌÅ",
+"îÅÉÚ×ÅÓÔÎÁÑ ÐÒÏÃÅÄÕÒÁ '%-.64s'",
+"îÅËÏÒÒÅËÔÎÏÅ ËÏÌÉÞÅÓÔ×Ï ÐÁÒÁÍÅÔÒÏ× ÄÌÑ ÐÒÏÃÅÄÕÒÙ '%-.64s'",
+"îÅËÏÒÒÅËÔÎÙÅ ÐÁÒÁÍÅÔÒÙ ÄÌÑ ÐÒÏÃÅÄÕÒÙ '%-.64s'",
+"îÅÉÚ×ÅÓÔÎÁÑ ÔÁÂÌÉÃÁ '%-.64s' × %-.32s",
+"óÔÏÌÂÅà '%-.64s' ÕËÁÚÁÎ Ä×ÁÖÄÙ",
+"îÅÐÒÁ×ÉÌØÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ ÇÒÕÐÐÏ×ÙÈ ÆÕÎËÃÉÊ",
+"÷ ÔÁÂÌÉÃÅ '%-.64s' ÉÓÐÏÌØÚÕÀÔÓÑ ×ÏÚÍÏÖÎÏÓÔÉ, ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÍÙÅ × ÜÔÏÊ ×ÅÒÓÉÉ MySQL",
+"÷ ÔÁÂÌÉÃÅ ÄÏÌÖÅÎ ÂÙÔØ ËÁË ÍÉÎÉÍÕÍ ÏÄÉÎ ÓÔÏÌÂÅÃ",
 "ôÁÂÌÉÃÁ '%-.64s' ÐÅÒÅÐÏÌÎÅÎÁ",
-"îÅÉÚ×ÅÓÔÎÙÊ ÎÁÂÏÒ ÓÉÍ×ÏÌÏ×: '%-.64s'",
-"óÌÉÛËÏÍ ÍÎÏÇÏ ÔÁÂÌÉÃ. MySQL ÍÏÖÅÔ ÉÓÐÏÌØÚÏ×ÁÔØ ÔÏÌØËÏ %d ÔÁÂÌÉÃ × ÏÂßÅÄÉÎÅÎÉÉ",
-"óÌÉÛËÏÍ ÍÎÏÇÏ ÐÏÌÅÊ",
-"óÌÉÛËÏÍ ÂÏÌØÛÏÊ ÒÁÚÍÅÒ ÚÁÐÉÓÉ. íÁËÓÉÍÁÌØÎÙÊ ÒÁÚÍÅÒ ÚÁÐÉÓÉ - %d, ÎÅ ÓÞÉÔÁÑ blob. úÁÍÅÎÉÔÅ ÎÅËÏÔÏÒÙÅ ÐÏÌÑ ÎÁ blob",
-"ðÅÒÅÐÏÌÎÅÎÉÅ ÎÉÔÅ×ÏÇÏ ÓÔÅËÁ: éÓÐÏÌØÚÏ×ÁÎÏ %ld ÉÚ %ld. åÓÌÉ ÎÅÏÂÈÏÄÉÍÏ, ÉÓÐÏÌØÚÕÊÔÅ 'mysqld -O thread_stack=#' ÞÔÏÂÙ Õ×ÅÌÉÞÉÔØ ÒÁÚÍÅÒ ÓÔÅËÁ",
-"ðÅÒÅËÒÅÓÔÎÁÑ ÚÁ×ÉÓÉÍÏÓÔØ × OUTER JOIN. ðÒÏ×ÅÒØÔÅ ÕÓÌÏ×ÉÑ ON",
-"ðÏÌÅ '%-.32s' ÉÓÐÏÌØÚÕÅÔÓÑ ËÁË UNIQUE ÉÌÉ INDEX ÎÏ ÎÅ ÏÐÒÅÄÅÌÅÎÏ ËÁË NOT NULL",
-"îÅ ÍÏÇÕ ÚÁÇÒÕÚÉÔØ ÆÕÎËÃÉÀ '%-.64s'",
-"îÅ ÍÏÇÕ ÉÎÉÃÉÁÌÉÚÉÒÏ×ÁÔØ ÆÕÎËÃÉÀ '%-.64s'; %-.80s",
-"îÅÌØÚÑ ÉÓÐÏÌØÚÏ×ÁÔØ ÐÕÔÉ ÄÌÑ ÒÁÚÄÅÌÑÅÍÙÈ ÂÉÂÌÉÏÔÅË",
+"îÅÉÚ×ÅÓÔÎÁÑ ËÏÄÉÒÏ×ËÁ '%-.64s'",
+"óÌÉÛËÏÍ ÍÎÏÇÏ ÔÁÂÌÉÃ. MySQL ÍÏÖÅÔ ÉÓÐÏÌØÚÏ×ÁÔØ ÔÏÌØËÏ %d ÔÁÂÌÉÃ × ÓÏÅÄÉÎÅÎÉÉ",
+"óÌÉÛËÏÍ ÍÎÏÇÏ ÓÔÏÌÂÃÏ×",
+"óÌÉÛËÏÍ ÂÏÌØÛÏÊ ÒÁÚÍÅÒ ÚÁÐÉÓÉ. íÁËÓÉÍÁÌØÎÙÊ ÒÁÚÍÅÒ ÓÔÒÏËÉ, ÉÓËÌÀÞÁÑ ÐÏÌÑ BLOB, - %d. ÷ÏÚÍÏÖÎÏ, ×ÁÍ ÓÌÅÄÕÅÔ ÉÚÍÅÎÉÔØ ÔÉÐ ÎÅËÏÔÏÒÙÈ ÐÏÌÅÊ ÎÁ BLOB",
+"óÔÅË ÐÏÔÏËÏ× ÐÅÒÅÐÏÌÎÅÎ:  ÉÓÐÏÌØÚÏ×ÁÎÏ: %ld ÉÚ %ld ÓÔÅËÁ.  ðÒÉÍÅÎÑÊÔÅ 'mysqld -O thread_stack=#' ÄÌÑ ÕËÁÚÁÎÉÑ ÂÏÌØÛÅÇÏ ÒÁÚÍÅÒÁ ÓÔÅËÁ, ÅÓÌÉ ÎÅÏÂÈÏÄÉÍÏ",
+"÷ OUTER JOIN ÏÂÎÁÒÕÖÅÎÁ ÐÅÒÅËÒÅÓÔÎÁÑ ÚÁ×ÉÓÉÍÏÓÔØ. ÷ÎÉÍÁÔÅÌØÎÏ ÐÒÏÁÎÁÌÉÚÉÒÕÊÔÅ Ó×ÏÉ ÕÓÌÏ×ÉÑ ON",
+"óÔÏÌÂÅÃ '%-.64s' ÉÓÐÏÌØÚÕÅÔÓÑ × UNIQUE ÉÌÉ × INDEX, ÎÏ ÎÅ ÏÐÒÅÄÅÌÅÎ ËÁË NOT NULL",
+"îÅ×ÏÚÍÏÖÎÏ ÚÁÇÒÕÚÉÔØ ÆÕÎËÃÉÀ '%-.64s'",
+"îÅ×ÏÚÍÏÖÎÏ ÉÎÉÃÉÁÌÉÚÉÒÏ×ÁÔØ ÆÕÎËÃÉÀ '%-.64s'; %-.80s",
+"îÅÄÏÐÕÓÔÉÍÏ ÕËÁÚÙ×ÁÔØ ÐÕÔÉ ÄÌÑ ÄÉÎÁÍÉÞÅÓËÉÈ ÂÉÂÌÉÏÔÅË",
 "æÕÎËÃÉÑ '%-.64s' ÕÖÅ ÓÕÝÅÓÔ×ÕÅÔ",
-"îÅ ÍÏÇÕ ÏÔËÒÙÔØ ÒÁÚÄÅÌÑÅÍÕÀ ÂÉÂÌÉÏÔÅËÕ '%-.64s' (ïÛÉÂËÁ: %d %-.64s)",
-"îÅ ÍÏÇÕ ÎÁÊÔÉ ÆÕÎËÃÉÀ '%-.64s' × ÂÉÂÌÉÏÔÅËÅ'",
+"îÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÄÉÎÁÍÉÞÅÓËÕÀ ÂÉÂÌÉÏÔÅËÕ '%-.64s' (ÏÛÉÂËÁ: %d %-.64s)",
+"îÅ×ÏÚÍÏÖÎÏ ÏÔÙÓËÁÔØ ÆÕÎËÃÉÀ '%-.64s' × ÂÉÂÌÉÏÔÅËÅ",
 "æÕÎËÃÉÑ '%-.64s' ÎÅ ÏÐÒÅÄÅÌÅÎÁ",
-"èÏÓÔ '%-.64s' ÚÁÂÌÏËÉÒÏ×ÁÎ ÉÚ-ÚÁ ÏÂÉÌÉÑ ÏÛÉÂÏË ÓÏÅÄÉÎÅÎÉÑ.  òÁÚÂÌÏËÉÒÏ×ÁÔØ ÍÏÖÎÏ Ó ÐÏÍÏÝØÀ 'mysqladmin flush-hosts'",
-"èÏÓÔÕ '%-.64s' ÎÅ ÒÁÚÒÅÛÅÎÏ ÓÏÅÄÉÎÑÔØÓÑ Ó ÄÁÎÎÙÍ ÓÅÒ×ÅÒÏÍ MySQL",
-"÷Ù ÐÏÄËÌÀÞÅÎÙ Ë MySQL ËÁË ÁÎÏÎÉÍÎÙÊ ÐÏÌØÚÏ×ÁÔÅÌØ É ÷ÁÍ ÎÅ ÒÁÚÒÅÛÅÎÏ ÉÚÍÅÎÑÔØ ÐÁÒÏÌÉ",
-"÷Ù ÄÏÌÖÎÙ ÉÍÅÔØ ÐÒÁ×Á ÎÁ ÏÂÎÏ×ÌÅÎÉÅ ÔÁÂÌÉÃ × ÂÁÚÅ, ÞÔÏÂÙ ÉÚÍÅÎÉÔØ ÐÁÒÏÌØ ÄÒÕÇÉÍ ÐÏÌØÚÏ×ÁÔÅÌÑÍ",
-"îÅ ÍÏÇÕ ÎÁÊÔÉ ÎÉ ÏÄÎÏÇÏ ÓÏÏÔ×ÅÔÓÔ×ÉÑ × ÔÁÂÌÉÃÅ ÐÏÌØÚÏ×ÁÔÅÌÅÊ",
-"óÏÏÔ×ÅÔÓÔ×ÕÀÝÉÈ ÚÁÐÉÓÅÊ: %ld  éÚÍÅÎÅÎÏ: %ld  ðÒÅÄÕÐÒÅÖÄÅÎÉÊ: %ld",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ ÎÏ×ÕÀ ÎÉÔØ (ÏÛÉÂËÁ %d). åÓÌÉ ÜÔÏ ÎÅ ÉÚ-ÚÁ ÎÅÈ×ÁÔËÉ ÐÁÍÑÔÉ, ÐÏÓÍÏÔÒÉÔÅ × ÒÕËÏ×ÏÄÓÔ×Å ×ÏÚÍÏÖÎÙÅ OS-ÚÁ×ÉÓÉÍÙÅ ÇÌÀËÉ",
-"þÉÓÌÏ ÓÔÏÌÂÃÏ× ÎÅ ÓÏÏÔ×ÅÔÓÔ×ÕÅÔ ÞÉÓÌÕ ÚÎÁÞÅÎÉÊ × ÓÔÒÏËÅ %ld",
-"îÅ ÍÏÇÕ ÚÁÎÏ×Ï ÏÔËÒÙÔØ ÔÁÂÌÉÃÕ: '%-.64s",
-"îÅÐÒÁ×ÉÌØÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ ÚÎÁÞÅÎÉÑ NULL",
-"REGEXP ×ÅÒÎÕÌ ÏÛÉÂËÕ '%-.64s'",
-"éÓÐÏÌØÚÏ×ÁÎÉÅ ÁÇÒÅÇÁÔÎÙÈ ÆÕÎËÃÉÊ (MIN(),MAX(),COUNT()...) ÓÏ×ÍÅÓÔÎÏ Ó ÏÂÙÞÎÙÍÉ ÚÎÁÞÅÎÉÑÍÉ ×ÏÚÍÏÖÎÏ ÔÏÌØËÏ ÐÒÉ ÎÁÌÉÞÉÉ ÒÁÚÄÅÌÁ GROUP BY",
-"äÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s' Ó ÈÏÓÔÁ '%-.64s' ÐÒÉ×ÉÌÅÇÉÉ ÎÅ ÏÐÒÅÄÅÌÅÎÙ",
-"%-.16s ËÏÍÁÎÄÁ ÎÅ ÒÁÚÒÅÛÅÎÁ ÐÏÌØÚÏ×ÁÔÅÌÀ: '%-.32s@%-.64s' ÄÌÑ ÔÁÂÌÉÃÙ '%-.64s'",
-"%-.16s ËÏÍÁÎÄÁ ÎÅ ÒÁÚÒÅÛÅÎÁ ÐÏÌØÚÏ×ÁÔÅÌÀ: '%-.32s@%-.64s'\n ÄÌÑ ÐÏÌÑ '%-.64s' ÉÚ ÔÁÂÌÉÃÙ '%-.64s'",
-"úÁÄÁÎÙ ÎÅ×ÅÒÎÙÅ ÐÒÉ×ÉÌÅÇÉÉ ÄÌÑ ÔÁÂÌÉÃÙ",
-"éÍÑ ÈÏÓÔÁ ÉÌÉ ÐÏÌØÚÏ×ÁÔÅÌÑ ÓÌÉÛËÏÍ ×ÅÌÉËÏ ÄÌÑ ÔÁÂÌÉÃÙ ÐÒÉ×ÉÌÅÇÉÊ",
+"èÏÓÔ '%-.64s' ÚÁÂÌÏËÉÒÏ×ÁÎ ÉÚ-ÚÁ ÓÌÉÛËÏÍ ÂÏÌØÛÏÇÏ ËÏÌÉÞÅÓÔ×Á ÏÛÉÂÏË ÓÏÅÄÉÎÅÎÉÑ. òÁÚÂÌÏËÉÒÏ×ÁÔØ ÅÇÏ ÍÏÖÎÏ Ó ÐÏÍÏÝØÀ 'mysqladmin flush-hosts'",
+"èÏÓÔÕ '%-.64s' ÎÅ ÒÁÚÒÅÛÁÅÔÓÑ ÐÏÄËÌÀÞÁÔØÓÑ Ë ÜÔÏÍÕ ÓÅÒ×ÅÒÕ MySQL",
+"÷Ù ÉÓÐÏÌØÚÕÅÔÅ MySQL ÏÔ ÉÍÅÎÉ ÁÎÏÎÉÍÎÏÇÏ ÐÏÌØÚÏ×ÁÔÅÌÑ, Á ÁÎÏÎÉÍÎÙÍ ÐÏÌØÚÏ×ÁÔÅÌÑÍ ÎÅ ÒÁÚÒÅÛÁÅÔÓÑ ÍÅÎÑÔØ ÐÁÒÏÌÉ",
+"äÌÑ ÔÏÇÏ ÞÔÏÂÙ ÉÚÍÅÎÑÔØ ÐÁÒÏÌÉ ÄÒÕÇÉÈ ÐÏÌØÚÏ×ÁÔÅÌÅÊ, Õ ×ÁÓ ÄÏÌÖÎÙ ÂÙÔØ ÐÒÉ×ÉÌÅÇÉÉ ÎÁ ÉÚÍÅÎÅÎÉÅ ÔÁÂÌÉÃ × ÂÁÚÅ ÄÁÎÎÙÈ mysql",
+"îÅ×ÏÚÍÏÖÎÏ ÏÔÙÓËÁÔØ ÐÏÄÈÏÄÑÝÕÀ ÚÁÐÉÓØ × ÔÁÂÌÉÃÅ ÐÏÌØÚÏ×ÁÔÅÌÅÊ",
+"óÏ×ÐÁÌÏ ÚÁÐÉÓÅÊ: %ld  éÚÍÅÎÅÎÏ: %ld  ðÒÅÄÕÐÒÅÖÄÅÎÉÊ: %ld",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ ÎÏ×ÙÊ ÐÏÔÏË (ÏÛÉÂËÁ %d). åÓÌÉ ÜÔÏ ÎÅ ÓÉÔÕÁÃÉÑ, Ó×ÑÚÁÎÎÁÑ Ó ÎÅÈ×ÁÔËÏÊ ÐÁÍÑÔÉ, ÔÏ ×ÁÍ ÓÌÅÄÕÅÔ ÉÚÕÞÉÔØ ÄÏËÕÍÅÎÔÁÃÉÀ ÎÁ ÐÒÅÄÍÅÔ ÏÐÉÓÁÎÉÑ ×ÏÚÍÏÖÎÏÊ ÏÛÉÂËÉ ÒÁÂÏÔÙ × ËÏÎËÒÅÔÎÏÊ ïó",
+"ëÏÌÉÞÅÓÔ×Ï ÓÔÏÌÂÃÏ× ÎÅ ÓÏ×ÐÁÄÁÅÔ Ó ËÏÌÉÞÅÓÔ×ÏÍ ÚÎÁÞÅÎÉÊ × ÚÁÐÉÓÉ %ld",
+"îÅ×ÏÚÍÏÖÎÏ ÚÁÎÏ×Ï ÏÔËÒÙÔØ ÔÁÂÌÉÃÕ '%-.64s'",
+"îÅÐÒÁ×ÉÌØÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ ×ÅÌÉÞÉÎÙ NULL",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ '%-.64s' ÏÔ ÒÅÇÕÌÑÒÎÏÇÏ ×ÙÒÁÖÅÎÉÑ",
+"ïÄÎÏ×ÒÅÍÅÎÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ ÓÇÒÕÐÐÉÒÏ×ÁÎÎÙÈ (GROUP) ÓÔÏÌÂÃÏ× (MIN(),MAX(),COUNT(),...) Ó ÎÅÓÇÒÕÐÐÉÒÏ×ÁÎÎÙÍÉ ÓÔÏÌÂÃÁÍÉ Ñ×ÌÑÅÔÓÑ ÎÅËÏÒÒÅËÔÎÙÍ, ÅÓÌÉ × ×ÙÒÁÖÅÎÉÉ ÅÓÔØ GROUP BY",
+"ôÁËÉÅ ÐÒÁ×Á ÎÅ ÏÐÒÅÄÅÌÅÎÙ ÄÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s' ÎÁ ÈÏÓÔÅ '%-.64s'",
+"ëÏÍÁÎÄÁ %-.16s ÚÁÐÒÅÝÅÎÁ ÐÏÌØÚÏ×ÁÔÅÌÀ '%-.32s@%-.64s' ÄÌÑ ÔÁÂÌÉÃÙ '%-.64s'",
+"ëÏÍÁÎÄÁ %-.16s ÚÁÐÒÅÝÅÎÁ ÐÏÌØÚÏ×ÁÔÅÌÀ '%-.32s@%-.64s' ÄÌÑ ÓÔÏÌÂÃÁ '%-.64s' × ÔÁÂÌÉÃÅ '%-.64s'",
+"îÅ×ÅÒÎÁÑ ËÏÍÁÎÄÁ GRANT ÉÌÉ REVOKE. ïÂÒÁÔÉÔÅÓØ Ë ÄÏËÕÍÅÎÔÁÃÉÉ, ÞÔÏÂÙ ×ÙÑÓÎÉÔØ, ËÁËÉÅ ÐÒÉ×ÉÌÅÇÉÉ ÍÏÖÎÏ ÉÓÐÏÌØÚÏ×ÁÔØ",
+"óÌÉÛËÏÍ ÄÌÉÎÎÏÅ ÉÍÑ ÐÏÌØÚÏ×ÁÔÅÌÑ/ÈÏÓÔÁ ÄÌÑ GRANT",
 "ôÁÂÌÉÃÁ '%-.64s.%-.64s' ÎÅ ÓÕÝÅÓÔ×ÕÅÔ",
-"ðÒÉ×ÉÌÅÇÉÉ ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s' Ó ÈÏÓÔÁ '%-.64s' ÄÌÑ ÔÁÂÌÉÃÙ '%-.64s' ÎÅ ÏÐÒÅÄÅÌÅÎÙ",
-"äÁÎÎÁÑ ËÏÍÁÎÄÁ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔÓÑ ÜÔÏÊ ×ÅÒÓÉÅÊ MySQL",
-"ëÁËÁÑ-ÔÏ ÓÉÎÔÁËÓÉÞÅÓËÁÑ ÏÛÉÂËÁ",
-"ðÏÔÏË ÄÌÑ delayed insert ÎÅ ÍÏÖÅÔ ÐÏÌÕÞÉÔØ ÂÌÏËÉÒÏ×ËÕ ÄÌÑ ÔÁÂÌÉÃÙ %-.64s",
-"éÓÐÏÌØÚÕÅÔÓÑ ÓÌÉÛËÏÍ ÍÎÏÇÏ delayed ÐÏÔÏËÏ×",
-"ðÒÅÒ×ÁÎÎÁÑ Ó×ÑÚØ %ld Ó ÂÁÚÏÊ ÄÁÎÎÙÈ: '%-.64s' ÐÏÌØÚÏ×ÁÔÅÌØ: '%-.64s' (%-.64s)",
-"ðÁËÅÔ ÂÏÌØÛÅ ÞÅÍ 'max_allowed_packet'",
-"ïÛÉÂËÁ ÞÔÅÎÉÑ ÉÚ ÔÒÕÂÙ ËÏÎÎÅËÔÁ",
-"fcntl() ×ÅÒÎÕÌ ÏÛÉÂËÕ",
-"ðÏÌÕÞÅÎ ÐÁËÅÔ × ÎÅÐÒÁ×ÉÌØÎÏÍ ÐÏÒÑÄËÅ",
-"îÅ ÍÏÇÕ ÒÁÓÐÁËÏ×ÁÔØ ÐÁËÅÔ",
-"ïÛÉÂËÁ ÐÒÉ ÞÔÅÎÉÉ ÐÁËÅÔÏ×",
-"ôÁÊÍÁÕÔ ÐÒÉ ÞÔÅÎÉÉ ÐÁËÅÔÏ×",
-"ïÛÉÂËÁ ÐÒÉ ÏÔÐÒÁ×ËÅ ÐÁËÅÔÏ×",
-"ïÛÉÂËÁ ÐÒÉ ÏÔÐÒÁ×ËÅ ÐÁËÅÔÏ×",
-"òÅÚÕÌØÔÉÒÕÀÝÁÑ ÓÔÒÏËÁ ÂÏÌØÛÅ ÞÅÍ max_allowed_packet",
-"éÓÐÏÌØÚÕÅÍÁÑ ÔÁÂÌÉÃÁ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ÐÏÌÑ BLOB/TEXT",
-"éÓÐÏÌØÚÕÅÍÁÑ ÔÁÂÌÉÃÁ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ÐÏÌÑ AUTO_INCREMENT",
-"INSERT DELAYED ÎÅ ÍÏÖÅÔ ÉÓÐÏÌØÚÏ×ÁÔØÓÑ Ó ÔÁÂÌÉÃÅÊ '%-.64s', ÏÎÁ ÚÁÎÑÔÁ ÉÓÐÏÌØÚÏ×ÁÎÉÅÍ LOCK TABLES",
-"îÅ×ÅÒÎÏÅ ÉÍÑ ÐÏÌÑ '%-.100s'",
-"ôÁÂÌÉÃÁ ÉÓÐÏÌØÚÕÅÍÏÇÏ ÔÉÐÁ ÎÅ ÍÏÖÅÔ ÉÎÄÅËÓÉÒÏ×ÁÔØ ÐÏÌÅ '%-.64s'",
+"ôÁËÉÅ ÐÒÁ×Á ÎÅ ÏÐÒÅÄÅÌÅÎÙ ÄÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s' ÎÁ ËÏÍÐØÀÔÅÒÅ '%-.64s' ÄÌÑ ÔÁÂÌÉÃÙ '%-.64s'",
+"üÔÁ ËÏÍÁÎÄÁ ÎÅ ÄÏÐÕÓËÁÅÔÓÑ × ÄÁÎÎÏÊ  ×ÅÒÓÉÉ MySQL",
+"õ ×ÁÓ ÏÛÉÂËÁ × ÚÁÐÒÏÓÅ. éÚÕÞÉÔÅ ÄÏËÕÍÅÎÔÁÃÉÀ ÐÏ ÉÓÐÏÌØÚÕÅÍÏÊ ×ÅÒÓÉÉ MySQL ÎÁ ÐÒÅÄÍÅÔ ËÏÒÒÅËÔÎÏÇÏ ÓÉÎÔÁËÓÉÓÁ",
+"ðÏÔÏË, ÏÂÓÌÕÖÉ×ÁÀÝÉÊ ÏÔÌÏÖÅÎÎÕÀ ×ÓÔÁ×ËÕ (delayed insert), ÎÅ ÓÍÏÇ ÐÏÌÕÞÉÔØ ÚÁÐÒÁÛÉ×ÁÅÍÕÀ ÂÌÏËÉÒÏ×ËÕ ÎÁ ÔÁÂÌÉÃÕ %-.64s",
+"óÌÉÛËÏÍ ÍÎÏÇÏ ÐÏÔÏËÏ×, ÏÂÓÌÕÖÉ×ÁÀÝÉÈ ÏÔÌÏÖÅÎÎÕÀ ×ÓÔÁ×ËÕ (delayed insert)",
+"ðÒÅÒ×ÁÎÏ ÓÏÅÄÉÎÅÎÉÅ %ld Ë ÂÁÚÅ ÄÁÎÎÙÈ '%-.64s' ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s' (%-.64s)",
+"ðÏÌÕÞÅÎÎÙÊ ÐÁËÅÔ ÂÏÌØÛÅ, ÞÅÍ 'max_allowed_packet'",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ ÞÔÅÎÉÑ ÏÔ ÐÏÔÏËÁ ÓÏÅÄÉÎÅÎÉÑ (connection pipe)",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ ÏÔ fcntl()",
+"ðÁËÅÔÙ ÐÏÌÕÞÅÎÙ × ÎÅ×ÅÒÎÏÍ ÐÏÒÑÄËÅ",
+"îÅ×ÏÚÍÏÖÎÏ ÒÁÓÐÁËÏ×ÁÔØ ÐÁËÅÔ, ÐÏÌÕÞÅÎÎÙÊ ÞÅÒÅÚ ËÏÍÍÕÎÉËÁÃÉÏÎÎÙÊ ÐÒÏÔÏËÏÌ",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ × ÐÒÏÃÅÓÓÅ ÐÏÌÕÞÅÎÉÑ ÐÁËÅÔÁ ÞÅÒÅÚ ËÏÍÍÕÎÉËÁÃÉÏÎÎÙÊ ÐÒÏÔÏËÏÌ ",
+"ðÏÌÕÞÅÎ ÔÁÊÍÁÕÔ ÏÖÉÄÁÎÉÑ ÐÁËÅÔÁ ÞÅÒÅÚ ËÏÍÍÕÎÉËÁÃÉÏÎÎÙÊ ÐÒÏÔÏËÏÌ ",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ ÐÒÉ ÐÅÒÅÄÁÞÅ ÐÁËÅÔÁ ÞÅÒÅÚ ËÏÍÍÕÎÉËÁÃÉÏÎÎÙÊ ÐÒÏÔÏËÏÌ ",
+"ðÏÌÕÞÅÎ ÔÁÊÍÁÕÔ × ÐÒÏÃÅÓÓÅ ÐÅÒÅÄÁÞÉ ÐÁËÅÔÁ ÞÅÒÅÚ ËÏÍÍÕÎÉËÁÃÉÏÎÎÙÊ ÐÒÏÔÏËÏÌ ",
+"òÅÚÕÌØÔÉÒÕÀÝÁÑ ÓÔÒÏËÁ ÂÏÌØÛÅ, ÞÅÍ 'max_allowed_packet'",
+"éÓÐÏÌØÚÕÅÍÁÑ ÔÁÂÌÉÃÁ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ÔÉÐÙ BLOB/TEXT",
+"éÓÐÏÌØÚÕÅÍÁÑ ÔÁÂÌÉÃÁ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ Á×ÔÏÉÎËÒÅÍÅÎÔÎÙÅ ÓÔÏÌÂÃÙ",
+"îÅÌØÚÑ ÉÓÐÏÌØÚÏ×ÁÔØ INSERT DELAYED ÄÌÑ ÔÁÂÌÉÃÙ '%-.64s', ÐÏÔÏÍÕ ÞÔÏ ÏÎÁ ÚÁÂÌÏËÉÒÏ×ÁÎÁ Ó ÐÏÍÏÝØÀ LOCK TABLES",
+"îÅ×ÅÒÎÏÅ ÉÍÑ ÓÔÏÌÂÃÁ '%-.100s'",
+"éÓÐÏÌØÚÏ×ÁÎÎÙÊ ÏÂÒÁÂÏÔÞÉË ÔÁÂÌÉÃÙ ÎÅ ÍÏÖÅÔ ÐÒÏÉÎÄÅËÓÉÒÏ×ÁÔØ ÓÔÏÌÂÅà '%-.64s'",
 "îÅ ×ÓÅ ÔÁÂÌÉÃÙ × MERGE ÏÐÒÅÄÅÌÅÎÙ ÏÄÉÎÁËÏ×Ï",
-"îÅ ÍÏÇÕ ÐÉÓÁÔØ × ÔÁÂÌÉÃÕ '%-.64s' ÉÚ-ÚÁ UNIQUE ÕÓÌÏ×ÉÊ",
-"ðÏÌÅ ÔÉÐÁ BLOB '%-.64s' × ÏÐÒÅÄÅÌÅÎÉÉ ÉÎÄÅËÓÁ ÂÅÚ ÕËÁÚÁÎÉÑ ÄÌÉÎÙ",
-"÷ÓÅ ÞÁÓÔÉ PRIMARY KEY ÄÏÌÖÎÙ ÂÙÔØ NOT NULL; ÅÓÌÉ NULL × ÉÎÄÅËÓÅ ÎÅÏÂÈÏÄÉÍ, ÉÓÐÏÌØÚÕÊÔÅ UNIQUE",
-"òÅÚÕÌØÔÁÔ ÓÏÄÅÒÖÉÔ ÂÏÌØÛÅ ÏÄÎÏÊ ÓÔÒÏËÉ",
-"ôÁÂÌÉÃÁ ÜÔÏÇÏ ÔÉÐÁ ÏÂÑÚÁÎÁ ÉÍÅÔØ PRIMARY KEY",
-"üÔÁ ËÏÐÉÑ MySQL ÓËÏÍÐÉÌÉÒÏ×ÁÎÁ ÂÅÚ ÐÏÄÄÅÒÖËÉ RAID",
-"MySQL ÒÁÂÏÔÁÅÔ × ÒÅÖÉÍÅ ÚÁÝÉÔÙ ÏÔ ÄÕÒÁËÏ× (safe_mode) - ÎÅ ÍÏÇÕ UPDATE ÂÅÚ WHERE Ó ËÁËÉÍ-ÎÅÂÕÄØ KEY",
-"éÎÄÅËÓ '%-.64s' ÎÅ ÎÁÊÄÅÎ × ÔÁÂÌÉÃÅ '%-.64s'",
-"îÅ ÍÏÇÕ ÏÔËÒÙÔØ ÔÁÂÌÉÃÕ",
-"äÁÎÎÙÊ ÔÉÐ ÔÁÂÌÉà ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ËÏÍÁÎÄÕ %s",
-"üÔÁ ËÏÍÁÎÄÁ ×ÎÕÔÒÉ ÔÒÁÎÚÁËÃÉÉ ÚÁÐÒÅÝÅÎÁ",
-"ïÛÉÂËÁ %d ×Ï ×ÒÅÍÑ COMMIT",
-"ïÛÉÂËÁ %d ×Ï ×ÒÅÍÑ ROLLBACK",
-"ïÛÉÂËÁ %d ×Ï ×ÒÅÍÑ FLUSH_LOGS",
-"ïÛÉÂËÁ %d ×Ï ×ÒÅÍÑ CHECKPOINT",
-"ðÒÅÒ×ÁÎÎÏÅ ÓÏÅÄÉÎÅÎÉÅ %ld Ë ÂÁÚÅ ÄÁÎÎÙÈ: '%-.64s' ÐÏÌØÚÏ×ÁÔÅÌØ: '%-.32s' ÈÏÓÔ: `%-.64s' (%-.64s)",
-"üÔÏÔ ÔÉÐ ÔÁÂÌÉà ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ binary table dump",
-"òÅÐÌÉËÁÃÉÏÎÎÙÊ ÌÏÇ ÚÁËÒÙÔ, ÎÅ ÍÏÇÕ ÓÄÅÌÁÔØ RESET MASTER",
-"ïÛÉÂËÁ ÐÒÉ ×ÏÓÓÔÁÎÏ×ÌÅÎÉÉ ÉÎÄÅËÓÁ ÐÅÒÅËÁÞÁÎÎÏÊ ÔÁÂÌÉÃÙ '%-.64s'",
-"ïÛÉÂËÁ ÎÁ ÍÁÓÔÅÒÅ: '%-.64s'",
-"óÅÔÅ×ÁÑ ÏÛÉÂËÁ ÐÒÉ ÞÔÅÎÉÉ Ó ÍÁÓÔÅÒÁ",
-"óÅÔÅ×ÁÑ ÏÛÉÂËÁ ÐÒÉ ÐÉÓÁÎÉÉ ÍÁÓÔÅÒÕ",
-"FULLTEXT ÉÎÄÅËÓ, ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÉÊ ÚÁÄÁÎÎÏÍÕ ÓÐÉÓËÕ ÓÔÏÌÂÃÏ×, ÎÅ ÎÁÊÄÅÎ",
-"îÅ ÍÏÇÕ ×ÙÐÏÌÎÉÔØ ËÏÍÍÁÎÄÕ ÉÚ-ÚÁ ÁËÔÉ×ÎÙÈ locked ÔÁÂÌÉà ÉÌÉ ÁËÔÉ×ÎÏÊ ÔÒÁÎÚÁËÃÉÉ",
+"îÅ×ÏÚÍÏÖÎÏ ÚÁÐÉÓÁÔØ × ÔÁÂÌÉÃÕ '%-.64s' ÉÚ-ÚÁ ÏÇÒÁÎÉÞÅÎÉÊ ÕÎÉËÁÌØÎÏÇÏ ËÌÀÞÁ",
+"óÔÏÌÂÅÃ ÔÉÐÁ BLOB '%-.64s' ÂÙÌ ÕËÁÚÁÎ × ÏÐÒÅÄÅÌÅÎÉÉ ËÌÀÞÁ ÂÅÚ ÕËÁÚÁÎÉÑ ÄÌÉÎÙ ËÌÀÞÁ",
+"÷ÓÅ ÞÁÓÔÉ ÐÅÒ×ÉÞÎÏÇÏ ËÌÀÞÁ (PRIMARY KEY) ÄÏÌÖÎÙ ÂÙÔØ ÏÐÒÅÄÅÌÅÎÙ ËÁË NOT NULL; åÓÌÉ ×ÁÍ ÎÕÖÎÁ ÐÏÄÄÅÒÖËÁ ×ÅÌÉÞÉÎ NULL × ËÌÀÞÅ, ×ÏÓÐÏÌØÚÕÊÔÅÓØ ÉÎÄÅËÓÏÍ UNIQUE",
+"÷ ÒÅÚÕÌØÔÁÔÅ ×ÏÚ×ÒÁÝÅÎÁ ÂÏÌÅÅ ÞÅÍ ÏÄÎÁ ÓÔÒÏËÁ",
+"üÔÏÔ ÔÉÐ ÔÁÂÌÉÃÙ ÔÒÅÂÕÅÔ ÏÐÒÅÄÅÌÅÎÉÑ ÐÅÒ×ÉÞÎÏÇÏ ËÌÀÞÁ",
+"üÔÁ ×ÅÒÓÉÑ MySQL ÓËÏÍÐÉÌÉÒÏ×ÁÎÁ ÂÅÚ ÐÏÄÄÅÒÖËÉ RAID",
+"÷Ù ÒÁÂÏÔÁÅÔÅ × ÒÅÖÉÍÅ ÂÅÚÏÐÁÓÎÙÈ ÏÂÎÏ×ÌÅÎÉÊ (safe update mode) É ÐÏÐÒÏÂÏ×ÁÌÉ ÉÚÍÅÎÉÔØ ÔÁÂÌÉÃÕ ÂÅÚ ÉÓÐÏÌØÚÏ×ÁÎÉÑ ËÌÀÞÅ×ÏÇÏ ÓÔÏÌÂÃÁ × ÞÁÓÔÉ WHERE",
+"ëÌÀÞ '%-.64s' ÎÅ ÓÕÝÅÓÔ×ÕÅÔ × ÔÁÂÌÉÃÅ '%-.64s'",
+"îÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÔÁÂÌÉÃÕ",
+"ïÂÒÁÂÏÔÞÉË ÔÁÂÌÉÃÙ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ÜÔÏÇÏ: %s",
+"÷ÁÍ ÎÅ ÒÁÚÒÅÛÅÎÏ ×ÙÐÏÌÎÑÔØ ÜÔÕ ËÏÍÁÎÄÕ × ÔÒÁÎÚÁËÃÉÉ",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ %d × ÐÒÏÃÅÓÓÅ COMMIT",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ %d × ÐÒÏÃÅÓÓÅ ROLLBACK",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ %d × ÐÒÏÃÅÓÓÅ FLUSH_LOGS",
+"ðÏÌÕÞÅÎÁ ÏÛÉÂËÁ %d × ÐÒÏÃÅÓÓÅ CHECKPOINT",
+"ðÒÅÒ×ÁÎÏ ÓÏÅÄÉÎÅÎÉÅ %ld Ë ÂÁÚÅ ÄÁÎÎÙÈ '%-.64s' ÐÏÌØÚÏ×ÁÔÅÌÑ '%-.32s' Ó ÈÏÓÔÁ `%-.64s' (%-.64s)",
+"ïÂÒÁÂÏÔÞÉË ÜÔÏÊ ÔÁÂÌÉÃÙ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ Ä×ÏÉÞÎÏÇÏ ÓÏÈÒÁÎÅÎÉÑ ÏÂÒÁÚÁ ÔÁÂÌÉÃÙ (dump)",
+"ä×ÏÉÞÎÙÊ ÖÕÒÎÁÌ ÏÂÎÏ×ÌÅÎÉÑ ÚÁËÒÙÔ, ÎÅ×ÏÚÍÏÖÎÏ ×ÙÐÏÌÎÉÔØ RESET MASTER",
+"ïÛÉÂËÁ ÐÅÒÅÓÔÒÏÊËÉ ÉÎÄÅËÓÁ ÓÏÈÒÁÎÅÎÎÏÊ ÔÁÂÌÉÃÙ '%-.64s'",
+"ïÛÉÂËÁ ÏÔ ÇÏÌÏ×ÎÏÇÏ ÓÅÒ×ÅÒÁ: '%-.64s'",
+"÷ÏÚÎÉËÌÁ ÏÛÉÂËÁ ÞÔÅÎÉÑ × ÐÒÏÃÅÓÓÅ ËÏÍÍÕÎÉËÁÃÉÉ Ó ÇÏÌÏ×ÎÙÍ ÓÅÒ×ÅÒÏÍ",
+"÷ÏÚÎÉËÌÁ ÏÛÉÂËÁ ÚÁÐÉÓÉ × ÐÒÏÃÅÓÓÅ ËÏÍÍÕÎÉËÁÃÉÉ Ó ÇÏÌÏ×ÎÙÍ ÓÅÒ×ÅÒÏÍ",
+"îÅ×ÏÚÍÏÖÎÏ ÏÔÙÓËÁÔØ ÐÏÌÎÏÔÅËÓÔÏ×ÙÊ (FULLTEXT) ÉÎÄÅËÓ, ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÉÊ ÓÐÉÓËÕ ÓÔÏÌÂÃÏ×",
+"îÅ×ÏÚÍÏÖÎÏ ×ÙÐÏÌÎÉÔØ ÕËÁÚÁÎÎÕÀ ËÏÍÁÎÄÕ, ÐÏÓËÏÌØËÕ Õ ×ÁÓ ÐÒÉÓÕÔÓÔ×ÕÀÔ ÁËÔÉ×ÎÏ ÚÁÂÌÏËÉÒÏ×ÁÎÎÙÅ ÔÁÂÌÉÃÁ ÉÌÉ ÏÔËÒÙÔÁÑ ÔÒÁÎÚÁËÃÉÑ",
 "îÅÉÚ×ÅÓÔÎÁÑ ÓÉÓÔÅÍÎÁÑ ÐÅÒÅÍÅÎÎÁÑ '%-.64s'",
-"ôÁÂÌÉÃÁ '%-.64s' ÐÏÍÅÞÅÎÁ ËÁË ÉÓÐÏÒÞÅÎÎÁÑ É ÄÏÌÖÎÁ ÂÙÔØ ÉÓÐÒÁ×ÌÅÎÁ",
-"ôÁÂÌÉÃÁ '%-.64s' ÐÏÍÅÞÅÎÁ ËÁË ÉÓÐÏÒÞÅÎÎÁÑ É ÐÏÓÌÅÄÎÑÑ ÐÏÐÙÔËÁ ÉÓÐÒÁ×ÌÅÎÉÑ (Á×ÔÏÍÁÔÉÞÅÓËÁÑ?) ÎÅ ÕÄÁÌÁÓØ",
-"ðÒÅÄÕÐÒÅÖÄÅÎÉÅ: ÎÅËÏÔÏÒÙÅ ÎÅÔÒÁÎÚÁËÃÉÏÎÎÙÅ ÔÁÂÌÉÃÙ ÎÅ ÐÏÄÞÉÎÑÀÔÓÑ ROLLBACK",
-"íÎÏÇÏÚÁÐÒÏÓÎÁÑ ÔÒÁÎÚÁËÃÉÑ ÔÒÅÂÕÅÔ Õ×ÅÌÉÞÅÎÉÑ 'max_binlog_cache_size' - Õ×ÅÌÉÞÔÅ ÜÔÕ ÐÅÒÅÍÅÎÎÕÀ É ÐÏÐÒÏÂÕÊÔÅ ÅÝÅ ÒÁÚ",
-"üÔÁ ÏÐÅÒÁÃÉÑ ÎÅ×ÏÚÍÏÖÎÁ Ó ÁËÔÉ×ÎÙÍ  slave, ÎÁÄÏ STOP SLAVE",
-"üÔÁ ÏÐÅÒÁÃÉÑ ÎÅ×ÏÚÍÏÖÎÁ Ó ÐÁÓÓÉ×ÎÙÍ slave, ÎÁÄÏ START SLAVE",
-"üÔÏÔ ÓÅÒ×ÅÒ ÎÅ slave, ÉÓÐÒÁ×ØÔÅ × ËÏÎÆÉÇÕÒÁÃÉÏÎÎÏÍ ÆÁÊÌÅ ÉÌÉ ËÏÍÍÁÎÄÏÊ CHANGE MASTER TO",
-"îÅ ÐÏÌÕÞÉÌÏÓØ ÉÎÉÃÉÁÌÉÚÉÒÏ×ÁÔØ ÓÔÒÕËÔÕÒÕ master info, ÐÒÏ×ÅÒÔÅ persmissions ÎÁ ÆÁÊÌÅ master.info",
-"îÅ ÍÏÇÕ ÓÏÚÄÁÔØ ÐÒÏÃÅÓÓ SLAVE, ÐÒÏ×ÅÒØÔÅ ÓÉÓÔÅÍÎÙÅ ÒÅÓÕÒÓÙ",
+"ôÁÂÌÉÃÁ '%-.64s' ÐÏÍÅÞÅÎÁ ËÁË ÉÓÐÏÒÞÅÎÎÁÑ É ÄÏÌÖÎÁ ÐÒÏÊÔÉ ÐÒÏ×ÅÒËÕ É ÒÅÍÏÎÔ",
+"ôÁÂÌÉÃÁ '%-.64s' ÐÏÍÅÞÅÎÁ ËÁË ÉÓÐÏÒÞÅÎÎÁÑ É ÐÏÓÌÅÄÎÉÊ (Á×ÔÏÍÁÔÉÞÅÓËÉÊ?) ÒÅÍÏÎÔ ÎÅ ÂÙÌ ÕÓÐÅÛÎÙÍ",
+"÷ÎÉÍÁÎÉÅ: ÐÏ ÎÅËÏÔÏÒÙÍ ÉÚÍÅÎÅÎÎÙÍ ÎÅÔÒÁÎÚÁËÃÉÏÎÎÙÍ ÔÁÂÌÉÃÁÍ ÎÅ×ÏÚÍÏÖÎÏ ÂÕÄÅÔ ÐÒÏÉÚ×ÅÓÔÉ ÏÔËÁÔ ÔÒÁÎÚÁËÃÉÉ",
+"ôÒÁÎÚÁËÃÉÉ, ×ËÌÀÞÁÀÝÅÊ ÂÏÌØÛÏÅ ËÏÌÉÞÅÓÔ×Ï ËÏÍÁÎÄ, ÐÏÔÒÅÂÏ×ÁÌÏÓØ ÂÏÌÅÅ ÞÅÍ 'max_binlog_cache_size' ÂÁÊÔ. õ×ÅÌÉÞØÔÅ ÜÔÕ ÐÅÒÅÍÅÎÎÕÀ ÓÅÒ×ÅÒÁ mysqld É ÐÏÐÒÏÂÕÊÔÅ ÅÝÅ ÒÁÚ",
+"üÔÕ ÏÐÅÒÁÃÉÀ ÎÅ×ÏÚÍÏÖÎÏ ×ÙÐÏÌÎÉÔØ ÐÒÉ ÒÁÂÏÔÁÀÝÅÍ ÐÏÔÏËÅ ÐÏÄÞÉÎÅÎÎÏÇÏ ÓÅÒ×ÅÒÁ. óÎÁÞÁÌÁ ×ÙÐÏÌÎÉÔÅ STOP SLAVE",
+"äÌÑ ÜÔÏÊ ÏÐÅÒÁÃÉÉ ÔÒÅÂÕÅÔÓÑ ÒÁÂÏÔÁÀÝÉÊ ÐÏÄÞÉÎÅÎÎÙÊ ÓÅÒ×ÅÒ. óÎÁÞÁÌÁ ×ÙÐÏÌÎÉÔÅ START SLAVE",
+"üÔÏÔ ÓÅÒ×ÅÒ ÎÅ ÎÁÓÔÒÏÅÎ ËÁË ÐÏÄÞÉÎÅÎÎÙÊ. ÷ÎÅÓÉÔÅ ÉÓÐÒÁ×ÌÅÎÉÑ × ËÏÎÆÉÇÕÒÁÃÉÏÎÎÏÍ ÆÁÊÌÅ ÉÌÉ Ó ÐÏÍÏÝØÀ CHANGE MASTER TO",
+"îÅ×ÏÚÍÏÖÎÏ ÉÎÉÃÉÁÌÉÚÉÒÏ×ÁÔØ ÓÔÒÕËÔÕÒÕ ÄÌÑ ÉÎÆÏÒÍÁÃÉÉ Ï ÇÏÌÏ×ÎÏÍ ÓÅÒ×ÅÒÅ. ðÒÏ×ÅÒØÔÅ ÐÒÁ×Á ÎÁ ÆÁÊÌ master.info",
+"îÅ×ÏÚÍÏÖÎÏ ÓÏÚÄÁÔØ ÐÏÔÏË ÐÏÄÞÉÎÅÎÎÏÇÏ ÓÅÒ×ÅÒÁ. ðÒÏ×ÅÒØÔÅ ÓÉÓÔÅÍÎÙÅ ÒÅÓÕÒÓÙ",
 "õ ÐÏÌØÚÏ×ÁÔÅÌÑ %-.64s ÕÖÅ ÂÏÌØÛÅ ÞÅÍ 'max_user_connections' ÁËÔÉ×ÎÙÈ ÓÏÅÄÉÎÅÎÉÊ",
-"íÏÖÎÏ ÉÓÐÏÌØÚÏ×ÁÔØ ÔÏÌØËÏ ×ÙÒÁÖÅÎÉÅ-ËÏÎÓÔÁÎÔÕ ÓÏ×ÍÅÓÔÎÏ Ó SET",
-"ôÁÊÍÁÕÔ ÏÖÉÄÁÎÉÑ ÂÌÏËÉÒÏ×ËÉ",
-"ïÂÝÅÅ ËÏÌÉÞÅÓÔ×Ï ÂÌÏËÉÒÏ×ÏË ÐÒÅ×ÙÓÉÌÏ ÒÁÚÍÅÒ ÔÁÂÌÉÃÙ ÂÌÏËÉÒÏ×ÏË",
-"âÌÏËÉÒÏ×ËÁ ÉÚÍÅÎÅÎÉÑ ÎÅ ÍÏÖÅÔ ÂÙÔØ ÐÏÌÕÞÅÎÁ ×Ï ×ÒÅÍÑ READ UNCOMMITTED ÔÒÁÎÚÁËÃÉÉ",
-"DROP DATABASE ÚÁÐÒÅÝÅÎ ×Ï ×ÒÅÍÑ ÇÌÏÂÁÌØÎÏÊ ÂÌÏËÉÒÏ×ËÉ ÞÔÅÎÉÑ",
-"CREATE DATABASE ÚÁÐÒÅÝÅÎ ×Ï ×ÒÅÍÑ ÇÌÏÂÁÌØÎÏÊ ÂÌÏËÉÒÏ×ËÉ ÞÔÅÎÉÑ",
-"îÅÐÒÁ×ÉÌØÎÙÅ ÁÒÇÕÍÅÔÎÙ Õ %s",
-"%-.32s@%-.64s ÎÅ ÉÍÅÅÔ ÐÒÉ×ÉÌÅÇÉÊ ÓÏÚÄÁ×ÁÔØ ÎÏ×ÙÈ ÐÏÌØÚÏ×ÁÔÅÌÅÊ",
-"îÅ×ÅÒÎÏÅ ÏÐÒÅÄÅÌÅÎÉÅ ÔÁÂÌÉÃÙ; ÷ÓÅ MERGE-ÔÁÂÌÉÃÙ ÄÏÌÖÎÙ ÂÙÔØ × ÏÄÎÏÊ ÂÁÚÅ ÄÁÎÎÙÈ",
-"ïÂÎÁÒÕÖÅÎ deadlock ×Ï ×ÒÅÍÑ ÐÏÌÕÞÅÎÉÑ ÂÌÏËÉÒÏ×ËÉ; ðÏÐÒÏÂÕÊÔÅ ÐÅÒÅÚÁÐÕÓÔÉÔØ ÔÒÁÎÚÁËÃÉÀ",
-"ôÁÂÌÉÃÁ ÄÁÎÎÏÇÏ ÔÉÐÁ ÎÅ ÍÏÖÅÔ ÉÍÅÔØ FULLTEXT ÉÎÄÅËÓÁ",
-"Cannot add foreign key constraint",
-"Cannot add a child row: a foreign key constraint fails",
-"Cannot delete a parent row: a foreign key constraint fails",
-"ïÛÉÂËÁ ÓÏÅÄÉÎÅÎÉÑ Ó master: %-.128s",
-"ïÛÉÂËÁ ×Ù×ÏÌÎÅÎÉÑ ÚÁÐÒÏÓÁ ÎÁ master: %-.128s",
-"ïÛÉÂËÁ ×ÙÐÏÌÎÅÎÉÑ ËÏÍÁÎÄÙ %s: %-.128s",
-"îÅÐÒÁ×ÉÌØÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ %s É %s",
-"éÓÐÏÌØÚÕÅÍÙÅ SELECT-×ÙÒÁÖÅÎÉÑ ÉÍÅÀÔ ÒÁÚÎÙÅ ËÏÌÉÞÅÓÔ×Á ÓÔÏÌÂÃÏ×",
-"îÅ×ÏÚÍÏÖÎÏ ×ÙÐÏÌÎÉÔØ ÚÁÐÒÏÓ ÉÚ-ÚÁ ËÏÎÆÌÉËÔÎÏÊ ÂÌÏËÉÒÏ×ËÉ ÞÔÅÎÉÑ",
-"ïÄÎÏ×ÒÅÍÅÎÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ transactional É non-transactional ÔÁÂÌÉà ÏÔËÌÀÞÅÎÏ",
-"ïÐÃÉÑ '%s' ÉÓÐÏÌØÚÏ×ÁÎÁ Ä×ÁÖÄÙ",
-"User '%-.64s' has exceeded the '%s' resource (current value: %ld)",
-"Access denied. You need the %-.128s privilege for this operation",
-"Variable '%-.64s' is a LOCAL variable and can't be used with SET GLOBAL",
-"Variable '%-.64s' is a GLOBAL variable and should be set with SET GLOBAL",
-"Variable '%-.64s' doesn't have a default value",
-"Variable '%-.64s' can't be set to the value of '%-.64s'",
-"Wrong argument type to variable '%-.64s'",
-"Variable '%-.64s' can only be set, not read",
-"Wrong usage/placement of '%s'",
-"This version of MySQL doesn't yet support '%s'",
-"Got fatal error %d: '%-.128s' from master when reading data from binary log",
+"÷Ù ÍÏÖÅÔÅ ÉÓÐÏÌØÚÏ×ÁÔØ × SET ÔÏÌØËÏ ËÏÎÓÔÁÎÔÎÙÅ ×ÙÒÁÖÅÎÉÑ",
+"ôÁÊÍÁÕÔ ÏÖÉÄÁÎÉÑ ÂÌÏËÉÒÏ×ËÉ ÉÓÔÅË; ÐÏÐÒÏÂÕÊÔÅ ÐÅÒÅÚÁÐÕÓÔÉÔØ ÔÒÁÎÚÁËÃÉÀ",
+"ïÂÝÅÅ ËÏÌÉÞÅÓÔ×Ï ÂÌÏËÉÒÏ×ÏË ÐÒÅ×ÙÓÉÌÏ ÒÁÚÍÅÒÙ ÔÁÂÌÉÃÙ ÂÌÏËÉÒÏ×ÏË",
+"âÌÏËÉÒÏ×ËÉ ÏÂÎÏ×ÌÅÎÉÊ ÎÅÌØÚÑ ÐÏÌÕÞÉÔØ × ÐÒÏÃÅÓÓÅ ÞÔÅÎÉÑ ÎÅ ÐÒÉÎÑÔÏÊ (× ÒÅÖÉÍÅ READ UNCOMMITTED) ÔÒÁÎÚÁËÃÉÉ",
+"îÅ ÄÏÐÕÓËÁÅÔÓÑ DROP DATABASE, ÐÏËÁ ÐÏÔÏË ÄÅÒÖÉÔ ÇÌÏÂÁÌØÎÕÀ ÂÌÏËÉÒÏ×ËÕ ÞÔÅÎÉÑ",
+"îÅ ÄÏÐÕÓËÁÅÔÓÑ CREATE DATABASE, ÐÏËÁ ÐÏÔÏË ÄÅÒÖÉÔ ÇÌÏÂÁÌØÎÕÀ ÂÌÏËÉÒÏ×ËÕ ÞÔÅÎÉÑ",
+"îÅ×ÅÒÎÙÅ ÐÁÒÁÍÅÔÒÙ ÄÌÑ %s",
+"%-.32s@%-.64s ÎÅ ÒÁÚÒÅÛÁÅÔÓÑ ÓÏÚÄÁ×ÁÔØ ÎÏ×ÙÈ ÐÏÌØÚÏ×ÁÔÅÌÅÊ",
+"îÅ×ÅÒÎÏÅ ÏÐÒÅÄÅÌÅÎÉÅ ÔÁÂÌÉÃÙ; ÷ÓÅ ÔÁÂÌÉÃÙ × MERGE ÄÏÌÖÎÙ ÐÒÉÎÁÄÌÅÖÁÔØ ÏÄÎÏÊ É ÔÏÊ ÖÅ ÂÁÚÅ ÄÁÎÎÙÈ",
+"÷ÏÚÎÉËÌÁ ÔÕÐÉËÏ×ÁÑ ÓÉÔÕÁÃÉÑ × ÐÒÏÃÅÓÓÅ ÐÏÌÕÞÅÎÉÑ ÂÌÏËÉÒÏ×ËÉ; ðÏÐÒÏÂÕÊÔÅ ÐÅÒÅÚÁÐÕÓÔÉÔØ ÔÒÁÎÚÁËÃÉÀ",
+"éÓÐÏÌØÚÕÅÍÙÊ ÔÉÐ ÔÁÂÌÉà ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ ÐÏÌÎÏÔÅËÓÔÏ×ÙÈ ÉÎÄÅËÓÏ×",
+"îÅ×ÏÚÍÏÖÎÏ ÄÏÂÁ×ÉÔØ ÏÇÒÁÎÉÞÅÎÉÑ ×ÎÅÛÎÅÇÏ ËÌÀÞÁ",
+"îÅ×ÏÚÍÏÖÎÏ ÄÏÂÁ×ÉÔØ ÉÌÉ ÏÂÎÏ×ÉÔØ ÄÏÞÅÒÎÀÀ ÓÔÒÏËÕ: ÐÒÏ×ÅÒËÁ ÏÇÒÁÎÉÞÅÎÉÊ ×ÎÅÛÎÅÇÏ ËÌÀÞÁ ÎÅ ×ÙÐÏÌÎÑÅÔÓÑ",
+"îÅ×ÏÚÍÏÖÎÏ ÕÄÁÌÉÔØ ÉÌÉ ÏÂÎÏ×ÉÔØ ÒÏÄÉÔÅÌØÓËÕÀ ÓÔÒÏËÕ: ÐÒÏ×ÅÒËÁ ÏÇÒÁÎÉÞÅÎÉÊ ×ÎÅÛÎÅÇÏ ËÌÀÞÁ ÎÅ ×ÙÐÏÌÎÑÅÔÓÑ",
+"ïÛÉÂËÁ ÓÏÅÄÉÎÅÎÉÑ Ó ÇÏÌÏ×ÎÙÍ ÓÅÒ×ÅÒÏÍ: %-.128s",
+"ïÛÉÂËÁ ×ÙÐÏÌÎÅÎÉÑ ÚÁÐÒÏÓÁ ÎÁ ÇÏÌÏ×ÎÏÍ ÓÅÒ×ÅÒÅ: %-.128s",
+"ïÛÉÂËÁ ÐÒÉ ×ÙÐÏÌÎÅÎÉÉ ËÏÍÁÎÄÙ %s: %-.128s",
+"îÅ×ÅÒÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ %s É %s",
+"éÓÐÏÌØÚÏ×ÁÎÎÙÅ ÏÐÅÒÁÔÏÒÙ ×ÙÂÏÒËÉ (SELECT) ÄÁÀÔ ÒÁÚÎÏÅ ËÏÌÉÞÅÓÔ×Ï ÓÔÏÌÂÃÏ×",
+"îÅ×ÏÚÍÏÖÎÏ ÉÓÐÏÌÎÉÔØ ÚÁÐÒÏÓ, ÐÏÓËÏÌØËÕ Õ ×ÁÓ ÕÓÔÁÎÏ×ÌÅÎÙ ËÏÎÆÌÉËÔÕÀÝÉÅ ÂÌÏËÉÒÏ×ËÉ ÞÔÅÎÉÑ",
+"éÓÐÏÌØÚÏ×ÁÎÉÅ ÔÒÁÎÚÁËÃÉÏÎÎÙÈ ÔÁÂÌÉà ÎÁÒÑÄÕ Ó ÎÅÔÒÁÎÚÁËÃÉÏÎÎÙÍÉ ÚÁÐÒÅÝÅÎÏ",
+"ïÐÃÉÑ '%s' Ä×ÁÖÄÙ ÉÓÐÏÌØÚÏ×ÁÎÁ × ×ÙÒÁÖÅÎÉÉ",
+"ðÏÌØÚÏ×ÁÔÅÌØ '%-.64s' ÐÒÅ×ÙÓÉÌ ÉÓÐÏÌØÚÏ×ÁÎÉÅ ÒÅÓÕÒÓÁ '%s' (ÔÅËÕÝÅÅ ÚÎÁÞÅÎÉÅ: %ld)",
+"÷ ÄÏÓÔÕÐÅ ÏÔËÁÚÁÎÏ. ÷ÁÍ ÎÕÖÎÙ ÐÒÉ×ÉÌÅÇÉÉ %-.128s ÄÌÑ ÜÔÏÊ ÏÐÅÒÁÃÉÉ",
+"ðÅÒÅÍÅÎÎÁÑ '%-.64s' Ñ×ÌÑÅÔÓÑ ÐÏÔÏËÏ×ÏÊ (LOCAL) ÐÅÒÅÍÅÎÎÏÊ É ÎÅ ÍÏÖÅÔ ÂÙÔØ ÉÚÍÅÎÅÎÁ Ó ÐÏÍÏÝØÀ SET GLOBAL",
+"ðÅÒÅÍÅÎÎÁÑ '%-.64s' Ñ×ÌÑÅÔÓÑ ÇÌÏÂÁÌØÎÏÊ (GLOBAL) ÐÅÒÅÍÅÎÎÏÊ, É ÅÅ ÓÌÅÄÕÅÔ ÉÚÍÅÎÑÔØ Ó ÐÏÍÏÝØÀ SET GLOBAL",
+"ðÅÒÅÍÅÎÎÁÑ '%-.64s' ÎÅ ÉÍÅÅÔ ÚÎÁÞÅÎÉÑ ÐÏ ÕÍÏÌÞÁÎÉÀ",
+"ðÅÒÅÍÅÎÎÁÑ '%-.64s' ÎÅ ÍÏÖÅÔ ÂÙÔØ ÕÓÔÁÎÏ×ÌÅÎÁ × ÚÎÁÞÅÎÉÅ '%-.64s'",
+"îÅ×ÅÒÎÙÊ ÔÉÐ ÁÒÇÕÍÅÎÔÁ ÄÌÑ ÐÅÒÅÍÅÎÎÏÊ '%-.64s'",
+"ðÅÒÅÍÅÎÎÁÑ '%-.64s' ÍÏÖÅÔ ÂÙÔØ ÔÏÌØËÏ ÕÓÔÁÎÏ×ÌÅÎÁ, ÎÏ ÎÅ ÓÞÉÔÁÎÁ",
+"îÅ×ÅÒÎÏÅ ÉÓÐÏÌØÚÏ×ÁÎÉÅ ÉÌÉ × ÎÅ×ÅÒÎÏÍ ÍÅÓÔÅ ÕËÁÚÁÎ '%s'",
+"üÔÁ ×ÅÒÓÉÑ MySQL ÐÏËÁ ÅÝÅ ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ '%s'",
+"ðÏÌÕÞÅÎÁ ÎÅÉÓÐÒÁ×ÉÍÁÑ ÏÛÉÂËÁ %d: '%-.128s' ÏÔ ÇÏÌÏ×ÎÏÇÏ ÓÅÒ×ÅÒÁ × ÐÒÏÃÅÓÓÅ ×ÙÂÏÒËÉ ÄÁÎÎÙÈ ÉÚ Ä×ÏÉÞÎÏÇÏ ÖÕÒÎÁÌÁ",
 "Wrong foreign key definition for '%-.64s': %s",
 "Key reference and table reference doesn't match",
 "ïÛÉÂËÁ ÍÏÝØÎÏÓÔÉ ÍÎÏÖÅÓÔ×Á (ÂÏÌØÛÅ/ÍÅÎØÛÅ %d ËÏÌÏÎÏË)",
diff --git a/sql/slave.cc b/sql/slave.cc
index a5761f7b74e..6ab25959063 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -235,8 +235,6 @@ int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,
   DBUG_ENTER("init_relay_log_pos");
 
   *errmsg=0;
-  if (rli->log_pos_current)			// TODO: When can this happen ?
-    DBUG_RETURN(0);
   pthread_mutex_t *log_lock=rli->relay_log.get_log_lock();
   pthread_mutex_lock(log_lock);
   if (need_data_lock)
@@ -298,7 +296,6 @@ int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,
   }
   if (pos > BIN_LOG_HEADER_SIZE)
     my_b_seek(rli->cur_log,(off_t)pos);
-  rli->log_pos_current=1;
 
 err:
   pthread_cond_broadcast(&rli->data_cond);
@@ -361,17 +358,37 @@ int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
 {
   int error=0;
   DBUG_ENTER("purge_relay_logs");
+
+  /*
+    Even if rli->inited==0, we still try to empty rli->master_log_* variables.
+    Indeed, rli->inited==0 does not imply that they already are empty.
+    It could be that slave's info initialization partly succeeded : 
+    for example if relay-log.info existed but *relay-bin*.*
+    have been manually removed, init_relay_log_info reads the old 
+    relay-log.info and fills rli->master_log_*, then init_relay_log_info
+    checks for the existence of the relay log, this fails and
+    init_relay_log_info leaves rli->inited to 0.
+    In that pathological case, rli->master_log_pos* will be properly reinited
+    at the next START SLAVE (as RESET SLAVE or CHANGE
+    MASTER, the callers of purge_relay_logs, will delete bogus *.info files
+    or replace them with correct files), however if the user does SHOW SLAVE
+    STATUS before START SLAVE, he will see old, confusing rli->master_log_*.
+    In other words, we reinit rli->master_log_* for SHOW SLAVE STATUS 
+    to display fine in any case.
+  */
+
+  rli->master_log_name[0]= 0;
+  rli->master_log_pos= 0;
+  rli->pending= 0;
+
   if (!rli->inited)
-    DBUG_RETURN(0); /* successfully do nothing */
+    DBUG_RETURN(0);
 
   DBUG_ASSERT(rli->slave_running == 0);
   DBUG_ASSERT(rli->mi->slave_running == 0);
 
   rli->slave_skip_counter=0;
   pthread_mutex_lock(&rli->data_lock);
-  rli->pending=0;
-  rli->master_log_name[0]=0;
-  rli->master_log_pos=0;			// 0 means uninitialized
   if (rli->relay_log.reset_logs(thd))
   {
     *errmsg = "Failed during log reset";
@@ -385,7 +402,6 @@ int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
   rli->log_space_total= BIN_LOG_HEADER_SIZE;
   rli->relay_log_pos=   BIN_LOG_HEADER_SIZE;
   rli->relay_log.reset_bytes_written();
-  rli->log_pos_current=0;
   if (!just_reset)
     error= init_relay_log_pos(rli, rli->relay_log_name, rli->relay_log_pos,
 			      0 /* do not need data lock */, errmsg);
@@ -421,9 +437,9 @@ int terminate_slave_threads(MASTER_INFO* mi,int thread_mask,bool skip_lock)
     DBUG_PRINT("info",("Terminating IO thread"));
     mi->abort_slave=1;
     if ((error=terminate_slave_thread(mi->io_thd,io_lock,
-				        io_cond_lock,
-					&mi->stop_cond,
-					&mi->slave_running)) &&
+				      io_cond_lock,
+				      &mi->stop_cond,
+				      &mi->slave_running)) &&
 	!force_all)
       DBUG_RETURN(error);
   }
@@ -463,12 +479,10 @@ int terminate_slave_thread(THD* thd, pthread_mutex_t* term_lock,
     be referening freed memory trying to kick it
   */
   THD_CHECK_SENTRY(thd);
-  if (*slave_running)
+
+  while (*slave_running)			// Should always be true
   {
     KICK_SLAVE(thd);
-  }
-  while (*slave_running)
-  {
     /*
       There is a small chance that slave thread might miss the first
       alarm. To protect againts it, resend the signal until it reacts
@@ -476,10 +490,6 @@ int terminate_slave_thread(THD* thd, pthread_mutex_t* term_lock,
     struct timespec abstime;
     set_timespec(abstime,2);
     pthread_cond_timedwait(term_cond, cond_lock, &abstime);
-    if (*slave_running)
-    {
-      KICK_SLAVE(thd);
-    }
   }
   if (term_lock)
     pthread_mutex_unlock(term_lock);
@@ -1225,7 +1235,6 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
   rli->pending = 0;
   rli->cur_log_fd = -1;
   rli->slave_skip_counter=0;
-  rli->log_pos_current=0;
   rli->abort_pos_wait=0;
   rli->skip_log_purge=0;
   rli->log_space_limit = relay_log_space_limit;
@@ -1270,8 +1279,9 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
     if (init_relay_log_pos(rli,NullS,BIN_LOG_HEADER_SIZE,0 /* no data lock */,
 			   &msg))
       goto err;
-    rli->master_log_pos = 0;			// uninitialized
-    rli->info_fd = info_fd;
+    rli->master_log_name[0]= 0;
+    rli->master_log_pos= 0;		
+    rli->info_fd= info_fd;
   }
   else // file exists
   {
@@ -1660,7 +1670,7 @@ st_relay_log_info::st_relay_log_info()
    cur_log_old_open_count(0), log_space_total(0), 
    slave_skip_counter(0), abort_pos_wait(0), slave_run_id(0),
    sql_thd(0), last_slave_errno(0), inited(0), abort_slave(0),
-   slave_running(0), log_pos_current(0), skip_log_purge(0),
+   slave_running(0), skip_log_purge(0),
    inside_transaction(0) /* the default is autocommit=1 */
 {
   relay_log_name[0] = master_log_name[0] = 0;
@@ -1882,7 +1892,8 @@ static int init_slave_thread(THD* thd, SLAVE_THD_TYPE thd_type)
 
   if (init_thr_lock() || thd->store_globals())
   {
-    end_thread(thd,0);
+    thd->cleanup();
+    delete thd;
     DBUG_RETURN(-1);
   }
 
@@ -2163,6 +2174,7 @@ extern "C" pthread_handler_decl(handle_slave_io,arg)
   
   // needs to call my_thread_init(), otherwise we get a coredump in DBUG_ stuff
   my_thread_init();
+  DBUG_ENTER("handle_slave_io");
 
 #ifndef DBUG_OFF
 slave_begin:  
@@ -2180,7 +2192,6 @@ slave_begin:
 #endif  
   
   thd= new THD; // note that contructor of THD uses DBUG_ !
-  DBUG_ENTER("handle_slave_io");
   THD_CHECK_SENTRY(thd);
 
   pthread_detach_this_thread();
@@ -2240,7 +2251,7 @@ connected:
       on with life.
     */
     thd->proc_info = "Registering slave on master";
-    if (register_slave_on_master(mysql) ||  update_slave_list(mysql))
+    if (register_slave_on_master(mysql) ||  update_slave_list(mysql, mi))
       goto err;
   }
   
@@ -2437,6 +2448,7 @@ extern "C" pthread_handler_decl(handle_slave_sql,arg)
 
   // needs to call my_thread_init(), otherwise we get a coredump in DBUG_ stuff
   my_thread_init();
+  DBUG_ENTER("handle_slave_sql");
 
 #ifndef DBUG_OFF
 slave_begin:  
@@ -2449,7 +2461,6 @@ slave_begin:
 #ifndef DBUG_OFF  
   rli->events_till_abort = abort_slave_event_count;
 #endif  
-  DBUG_ENTER("handle_slave_sql");
 
   thd = new THD; // note that contructor of THD uses DBUG_ !
   THD_CHECK_SENTRY(thd);
@@ -2542,7 +2553,6 @@ the slave SQL thread with \"SLAVE START\". We stopped at log \
     TODO: see if we can do this conditionally in next_event() instead
     to avoid unneeded position re-init
   */
-  rli->log_pos_current=0; 
   thd->temporary_tables = 0; // remove tempation from destructor to close them
   DBUG_ASSERT(thd->net.buff != 0);
   net_end(&thd->net); // destructor will not free it, because we are weird
@@ -2889,7 +2899,6 @@ void end_relay_log_info(RELAY_LOG_INFO* rli)
     rli->cur_log_fd = -1;
   }
   rli->inited = 0;
-  rli->log_pos_current=0;
   rli->relay_log.close(1);
   DBUG_VOID_RETURN;
 }
diff --git a/sql/slave.h b/sql/slave.h
index 4923eec3ae7..0ebd07bf6d8 100644
--- a/sql/slave.h
+++ b/sql/slave.h
@@ -186,7 +186,6 @@ typedef struct st_relay_log_info
   /* if not set, the value of other members of the structure are undefined */
   bool inited;
   volatile bool abort_slave, slave_running;
-  bool log_pos_current;
   bool skip_log_purge;
   bool inside_transaction;
 
diff --git a/sql/sql_analyse.cc b/sql/sql_analyse.cc
index d121a151011..9bcfff62ba0 100644
--- a/sql/sql_analyse.cc
+++ b/sql/sql_analyse.cc
@@ -240,14 +240,16 @@ bool test_if_number(NUM_INFO *info, const char *str, uint str_len)
   }
   else
     return 0;
-} //test_if_number
+}
 
 
-// Stores the biggest and the smallest value from current 'info'
-// to ev_num_info
-// If info contains an ulonglong number, which is bigger than
-// biggest positive number able to be stored in a longlong variable
-// and is marked as negative, function will return 0, else 1.
+/*
+  Stores the biggest and the smallest value from current 'info'
+  to ev_num_info
+  If info contains an ulonglong number, which is bigger than
+  biggest positive number able to be stored in a longlong variable
+  and is marked as negative, function will return 0, else 1.
+*/
 
 bool get_ev_num_info(EV_NUM_INFO *ev_info, NUM_INFO *info, const char *num)
 {
@@ -275,11 +277,13 @@ void free_string(String *s)
   s->free();
 }
 
+
 void field_str::add()
 {
   char buff[MAX_FIELD_WIDTH], *ptr;
   String s(buff, sizeof(buff),&my_charset_bin), *res;
   ulong length;
+  TREE_ELEMENT *element;
 
   if (!(res = item->val_str(&s)))
   {
@@ -414,9 +418,11 @@ void field_real::add()
       room_in_tree = 0;    // Remove tree, out of RAM ?
       delete_tree(&tree);
     }
-    // if element->count == 1, this element can be found only once from tree
-    // if element->count == 2, or more, this element is already in tree
-    else if (element->count == 1 && (tree_elements++) > pc->max_tree_elements)
+    /*
+      if element->count == 1, this element can be found only once from tree
+      if element->count == 2, or more, this element is already in tree
+    */
+    else if (element->count == 1 && (tree_elements++) >= pc->max_tree_elements)
     {
       room_in_tree = 0;  // Remove tree, too many elements
       delete_tree(&tree);
@@ -445,6 +451,7 @@ void field_real::add()
   }
 } // field_real::add
 
+
 void field_longlong::add()
 {
   char buff[MAX_FIELD_WIDTH];
@@ -467,9 +474,11 @@ void field_longlong::add()
       room_in_tree = 0;    // Remove tree, out of RAM ?
       delete_tree(&tree);
     }
-    // if element->count == 1, this element can be found only once from tree
-    // if element->count == 2, or more, this element is already in tree
-    else if (element->count == 1 && (tree_elements++) > pc->max_tree_elements)
+    /*
+      if element->count == 1, this element can be found only once from tree
+      if element->count == 2, or more, this element is already in tree
+    */
+    else if (element->count == 1 && (tree_elements++) >= pc->max_tree_elements)
     {
       room_in_tree = 0;  // Remove tree, too many elements
       delete_tree(&tree);
@@ -521,9 +530,11 @@ void field_ulonglong::add()
       room_in_tree = 0;    // Remove tree, out of RAM ?
       delete_tree(&tree);
     }
-    // if element->count == 1, this element can be found only once from tree
-    // if element->count == 2, or more, this element is already in tree
-    else if (element->count == 1 && (tree_elements++) > pc->max_tree_elements)
+    /*
+      if element->count == 1, this element can be found only once from tree
+      if element->count == 2, or more, this element is already in tree
+    */
+    else if (element->count == 1 && (tree_elements++) >= pc->max_tree_elements)
     {
       room_in_tree = 0;  // Remove tree, too many elements
       delete_tree(&tree);
@@ -604,14 +615,16 @@ bool analyse::end_of_records()
       func_items[8]->null_value = 1;
     else
       func_items[8]->set(res->ptr(), res->length(), res->charset());
-    // count the dots, quotas, etc. in (ENUM("a","b","c"...))
-    // if tree has been removed, don't suggest ENUM.
-    // treemem is used to measure the size of tree for strings,
-    // tree_elements is used to count the elements in tree in case of numbers.
-    // max_treemem tells how long the string starting from ENUM("... and
-    // ending to ..") shall at maximum be. If case is about numbers,
-    // max_tree_elements will tell the length of the above, now
-    // every number is considered as length 1
+    /*
+      count the dots, quotas, etc. in (ENUM("a","b","c"...))
+      If tree has been removed, don't suggest ENUM.
+      treemem is used to measure the size of tree for strings,
+      tree_elements is used to count the elements
+      max_treemem tells how long the string starting from ENUM("... and
+      ending to ..") shall at maximum be. If case is about numbers,
+      max_tree_elements will tell the length of the above, now
+      every number is considered as length 1
+    */
     if (((*f)->treemem || (*f)->tree_elements) &&
 	(*f)->tree.elements_in_tree &&
 	(((*f)->treemem ? max_treemem : max_tree_elements) >
@@ -654,6 +667,7 @@ bool analyse::end_of_records()
 	ans.append("DATETIME", 8);
 	break;
       case FIELD_TYPE_DATE:
+      case FIELD_TYPE_NEWDATE:
 	ans.append("DATE", 4);
 	break;
       case FIELD_TYPE_SET:
@@ -665,9 +679,6 @@ bool analyse::end_of_records()
       case FIELD_TYPE_TIME:
 	ans.append("TIME", 4);
 	break;
-      case FIELD_TYPE_NEWDATE:
-	ans.append("NEWDATE", 7);
-	break;
       case FIELD_TYPE_DECIMAL:
 	ans.append("DECIMAL", 7);
 	// if item is FIELD_ITEM, it _must_be_ Field_num in this case
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 79f0e7eb269..34884003da3 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -1239,25 +1239,44 @@ bool drop_locked_tables(THD *thd,const char *db, const char *table_name)
 }
 
 
-/* lock table to force abort of any threads trying to use table */
+/*
+  If we have the table open, which only happens when a LOCK TABLE has been
+  done on the table, change the lock type to a lock that will abort all
+  other threads trying to get the lock.
+*/
 
 void abort_locked_tables(THD *thd,const char *db, const char *table_name)
 {
   TABLE *table;
-  for (table=thd->open_tables; table ; table=table->next)
+  for (table= thd->open_tables; table ; table= table->next)
   {
     if (!strcmp(table->real_name,table_name) &&
 	!strcmp(table->table_cache_key,db))
+    {
       mysql_lock_abort(thd,table);
+      break;
+    }
   }
 }
 
-/****************************************************************************
-**	open_unireg_entry
-**	Purpose : Load a table definition from file and open unireg table
-**	Args	: entry with DB and table given
-**	Returns : 0 if ok
-**	Note that the extra argument for open is taken from thd->open_options
+
+/*
+  Load a table definition from file and open unireg table
+
+  SYNOPSIS
+    open_unireg_entry()
+    thd			Thread handle
+    entry		Store open table definition here
+    db			Database name
+    name		Table name
+    alias		Alias name
+
+  NOTES
+   Extra argument for open is taken from thd->open_options
+
+  RETURN
+    0	ok
+    #	Error
 */
 
 static int open_unireg_entry(THD *thd, TABLE *entry, const char *db,
@@ -1677,8 +1696,7 @@ Field *find_field_in_table(THD *thd,TABLE *table,const char *name,uint length,
     else
       thd->dupp_field=field;
   }
-  if (check_grants && !thd->master_access &&
-      check_grant_column(thd,table,name,length))
+  if (check_grants  && check_grant_column(thd,table,name,length))
     return WRONG_GRANT;
   return field;
 }
@@ -1728,7 +1746,9 @@ find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *tables,
       {
 	found_table=1;
 	Field *find=find_field_in_table(thd,tables->table,name,length,
-					grant_option && !thd->master_access,1);
+					grant_option && 
+					tables->table->grant.want_privilege,
+					1);
 	if (find)
 	{
 	  (*where)= tables;
@@ -1785,7 +1805,8 @@ find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *tables,
 
     Field *field=find_field_in_table(thd,tables->table,name,length,
 				     grant_option &&
-				     !thd->master_access, allow_rowid);
+				     tables->table->grant.want_privilege,
+				     allow_rowid);
     if (field)
     {
       if (field == WRONG_GRANT)
@@ -2400,6 +2421,17 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
 	}
 	pthread_mutex_unlock(&in_use->mysys_var->mutex);
       }
+      /*
+	Now we must abort all tables locks used by this thread
+	as the thread may be waiting to get a lock for another table
+      */
+      for (TABLE *thd_table= in_use->open_tables;
+	   thd_table ;
+	   thd_table= thd_table->next)
+      {
+	if (thd_table->db_stat)			// If table is open
+	  mysql_lock_abort_for_thread(thd, thd_table);
+      }
     }
     else
       result= result || return_if_owned_by_thd;
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index d215db8736a..f67db09ee67 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -480,6 +480,7 @@ int THD::send_explain_fields(select_result *result)
 #ifdef SIGNAL_WITH_VIO_CLOSE
 void THD::close_active_vio()
 {
+  DBUG_ENTER("close_active_vio");
   safe_mutex_assert_owner(&LOCK_delete); 
 #ifndef EMBEDDED_LIBRARY
   if (active_vio)
@@ -488,6 +489,7 @@ void THD::close_active_vio()
     active_vio = 0;
   }
 #endif
+  DBUG_VOID_RETURN;
 }
 #endif
 
@@ -530,6 +532,16 @@ bool select_send::send_data(List<Item> &items)
     return 0;
   }
 
+#ifdef HAVE_INNOBASE_DB
+  /*
+    We may be passing the control from mysqld to the client: release the
+    InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
+    by thd
+  */
+  if (thd->transaction.all.innobase_tid)
+    ha_release_temporary_latches(thd);
+#endif
+
   List_iterator_fast<Item> li(items);
   Protocol *protocol= thd->protocol;
   char buff[MAX_FIELD_WIDTH];
@@ -555,6 +567,14 @@ bool select_send::send_data(List<Item> &items)
 
 bool select_send::send_eof()
 {
+#ifdef HAVE_INNOBASE_DB
+  /* We may be passing the control from mysqld to the client: release the
+     InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
+     by thd */
+  if (thd->transaction.all.innobase_tid)
+    ha_release_temporary_latches(thd);
+#endif
+
   /* Unlock tables before sending packet to gain some speed */
   if (thd->lock)
   {
diff --git a/sql/sql_class.h b/sql/sql_class.h
index dbf9f0d13d6..079c095b2f5 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -398,7 +398,8 @@ struct system_variables
   ulong pseudo_thread_id;
 
   my_bool log_warnings;
-  my_bool low_priority_updates; 
+  my_bool low_priority_updates;
+  my_bool new_mode;
 
   CONVERT	*convert_set;
   CHARSET_INFO 	*thd_charset;
@@ -447,8 +448,9 @@ public:
     db - currently selected database
     ip - client IP
    */
-  
   char	  *host,*user,*priv_user,*db,*ip;
+  /* remote (peer) port */
+  uint16 peer_port;
   /* Points to info-string that will show in SHOW PROCESSLIST */
   const char *proc_info;
   /* points to host if host is available, otherwise points to ip */
@@ -996,7 +998,7 @@ class multi_update : public select_result
 {
   TABLE_LIST *all_tables, *update_tables, *table_being_updated;
   THD *thd;
-  TABLE **tmp_tables, *main_table;
+  TABLE **tmp_tables, *main_table, *table_to_update;
   TMP_TABLE_PARAM *tmp_table_param;
   ha_rows updated, found;
   List <Item> *fields, *values;
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index 9ca51ebc053..dcb39f8526f 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -23,7 +23,7 @@
 static int check_null_fields(THD *thd,TABLE *entry);
 static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list);
 static int write_delayed(THD *thd,TABLE *table, enum_duplicates dup,
-			 char *query, uint query_length, bool log_on);
+			 char *query, uint query_length, int log_on);
 static void end_delayed_insert(THD *thd);
 extern "C" pthread_handler_decl(handle_delayed_insert,arg);
 static void unlink_blobs(register TABLE *table);
@@ -38,6 +38,8 @@ static void unlink_blobs(register TABLE *table);
 #define my_safe_afree(ptr, size, min_length) if (size > min_length) my_free(ptr,MYF(0))
 #endif
 
+#define DELAYED_LOG_UPDATE 1
+#define DELAYED_LOG_BIN    2
 
 /*
   Check if insert fields are correct
@@ -107,8 +109,13 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list,
                  enum_duplicates duplic)
 {
   int error;
-  bool log_on= ((thd->options & OPTION_UPDATE_LOG) ||
-		!(thd->master_access & SUPER_ACL));
+  /*
+    log_on is about delayed inserts only.
+    By default, both logs are enabled (this won't cause problems if the server
+    runs without --log-update or --log-bin).
+  */
+  int log_on= DELAYED_LOG_UPDATE | DELAYED_LOG_BIN ;
+
   bool transactional_table, log_delayed, bulk_insert;
   uint value_count;
   ulong counter = 1;
@@ -123,6 +130,14 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list,
     thd->lex.select_lex.table_list.first;
   DBUG_ENTER("mysql_insert");
 
+  if (thd->master_access & SUPER_ACL)
+  {
+    if (!(thd->options & OPTION_UPDATE_LOG))
+      log_on&= ~(int) DELAYED_LOG_UPDATE;
+    if (!(thd->options & OPTION_BIN_LOG))
+      log_on&= ~(int) DELAYED_LOG_BIN;
+  }
+
   /*
     in safe mode or with skip-new change delayed insert to be regular
     if we are told to replace duplicates, the insert cannot be concurrent
@@ -130,7 +145,7 @@ int mysql_insert(THD *thd,TABLE_LIST *table_list,
    */
   if ((lock_type == TL_WRITE_DELAYED &&
        ((specialflag & (SPECIAL_NO_NEW_FUNC | SPECIAL_SAFE_MODE)) ||
-	thd->slave_thread)) ||
+	thd->slave_thread || !max_insert_delayed_threads)) ||
       (lock_type == TL_WRITE_CONCURRENT_INSERT && duplic == DUP_REPLACE) ||
       (duplic == DUP_UPDATE))
     lock_type=TL_WRITE;
@@ -547,12 +562,13 @@ public:
   char *record,*query;
   enum_duplicates dup;
   time_t start_time;
-  bool query_start_used,last_insert_id_used,insert_id_used,log_query;
+  bool query_start_used,last_insert_id_used,insert_id_used;
+  int log_query;
   ulonglong last_insert_id;
   ulong time_stamp;
   uint query_length;
 
-  delayed_row(enum_duplicates dup_arg, bool log_query_arg)
+  delayed_row(enum_duplicates dup_arg, int log_query_arg)
     :record(0),query(0),dup(dup_arg),log_query(log_query_arg) {}
   ~delayed_row()
   {
@@ -855,7 +871,7 @@ TABLE *delayed_insert::get_local_table(THD* client_thd)
 /* Put a question in queue */
 
 static int write_delayed(THD *thd,TABLE *table,enum_duplicates duplic,
-			 char *query, uint query_length, bool log_on)
+			 char *query, uint query_length, int log_on)
 {
   delayed_row *row=0;
   delayed_insert *di=thd->di;
@@ -1242,13 +1258,14 @@ bool delayed_insert::handle_inserts(void)
       using_ignore=0;
       table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
     }
-    if (row->query && row->log_query)
+    if (row->query)
     {
-      mysql_update_log.write(&thd,row->query, row->query_length);
-      if (using_bin_log)
+      if (row->log_query & DELAYED_LOG_UPDATE)
+        mysql_update_log.write(&thd,row->query, row->query_length);
+      if (row->log_query & DELAYED_LOG_BIN && using_bin_log)
       {
-	Query_log_event qinfo(&thd, row->query, row->query_length,0);
-	mysql_bin_log.write(&qinfo);
+        Query_log_event qinfo(&thd, row->query, row->query_length,0);
+        mysql_bin_log.write(&qinfo);
       }
     }
     if (table->blob_fields)
@@ -1399,6 +1416,14 @@ bool select_insert::send_eof()
   if (!(error=table->file->extra(HA_EXTRA_NO_CACHE)))
     error=table->file->activate_all_index(thd);
   table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
+
+  /* Write to binlog before commiting transaction */
+  if (mysql_bin_log.is_open())
+  {
+    Query_log_event qinfo(thd, thd->query, thd->query_length,
+			  table->file->has_transactions());
+    mysql_bin_log.write(&qinfo);
+  }
   if ((error2=ha_autocommit_or_rollback(thd,error)) && ! error)
     error=error2;
   if (info.copied || info.deleted)
@@ -1425,12 +1450,6 @@ bool select_insert::send_eof()
       thd->insert_id(last_insert_id);		// For update log
     ::send_ok(thd,info.copied,last_insert_id,buff);
     mysql_update_log.write(thd,thd->query,thd->query_length);
-    if (mysql_bin_log.is_open())
-    {
-      Query_log_event qinfo(thd, thd->query, thd->query_length,
-			    table->file->has_transactions());
-      mysql_bin_log.write(&qinfo);
-    }
     return 0;
   }
 }
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index bdbec6bc76f..eed5e62555b 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -550,7 +550,7 @@ check_connections(THD *thd)
   {
     char ip[30];
 
-    if (vio_peer_addr(net->vio,ip))
+    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
       return (ER_BAD_HOST_ERROR);
     if (!(thd->ip = my_strdup(ip,MYF(0))))
       return (ER_OUT_OF_RESOURCES);
@@ -582,8 +582,9 @@ check_connections(THD *thd)
   else /* Hostname given means that the connection was on a socket */
   {
     DBUG_PRINT("info",("Host: %s",thd->host));
-    thd->host_or_ip=thd->host;
-    thd->ip=0;
+    thd->host_or_ip= thd->host;
+    thd->ip= 0;
+    thd->peer_port= 0;
     bzero((char*) &thd->remote,sizeof(struct sockaddr));
   }
   /* Ensure that wrong hostnames doesn't cause buffer overflows */
@@ -1959,6 +1960,7 @@ mysql_execute_command(THD *thd)
 	if (check_table_access(thd, SELECT_ACL, tables->next))
 	  goto error;				// Error message is given
       }
+      select_lex->options|= SELECT_NO_UNLOCK;
       unit->offset_limit_cnt= select_lex->offset_limit;
       unit->select_limit_cnt= select_lex->select_limit+
 	select_lex->offset_limit;
@@ -2216,8 +2218,14 @@ mysql_execute_command(THD *thd)
     break;
   }
   case SQLCOM_UPDATE:
-    if (check_access(thd,UPDATE_ACL,tables->db,&tables->grant.privilege))
+    TABLE_LIST *table;
+    if (check_db_used(thd,tables))
       goto error;
+    for (table=tables ; table ; table=table->next)
+    {
+      if (check_access(thd,UPDATE_ACL,table->db,&table->grant.privilege))
+	goto error;
+    }
     if (grant_option && check_grant(thd,UPDATE_ACL,tables))
       goto error;
     if (select_lex->item_list.elements != lex->value_list.elements)
@@ -2310,6 +2318,8 @@ mysql_execute_command(THD *thd)
       if ((res=check_table_access(thd, SELECT_ACL, save_next)))
 	goto error;
     }
+    /* Don't unlock tables until command is written to binary log */
+    select_lex->options|= SELECT_NO_UNLOCK;
 
     select_result *result;
     unit->offset_limit_cnt= select_lex->offset_limit;
@@ -2341,6 +2351,8 @@ mysql_execute_command(THD *thd)
   case SQLCOM_TRUNCATE:
     if (check_access(thd,DELETE_ACL,tables->db,&tables->grant.privilege))
       goto error; /* purecov: inspected */
+    if (grant_option && check_grant(thd,DELETE_ACL,tables))
+      goto error;
     /*
       Don't allow this within a transaction because we want to use
       re-generate table
@@ -3793,9 +3805,7 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
   if (!table)
     DBUG_RETURN(0);				// End of memory
   alias_str= alias ? alias->str : table->table.str;
-  if (table->table.length > NAME_LEN ||
-      (table->table.length &&
-       check_table_name(table->table.str,table->table.length)) ||
+  if (check_table_name(table->table.str,table->table.length) ||
       table->db.str && check_db_name(table->db.str))
   {
     net_printf(thd,ER_WRONG_TABLE_NAME,table->table.str);
diff --git a/sql/sql_rename.cc b/sql/sql_rename.cc
index 5b0ec2ec843..19b4d299e59 100644
--- a/sql/sql_rename.cc
+++ b/sql/sql_rename.cc
@@ -31,8 +31,8 @@ static TABLE_LIST *rename_tables(THD *thd, TABLE_LIST *table_list,
 
 bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list)
 {
-  bool error=1,got_all_locks=1;
-  TABLE_LIST *lock_table,*ren_table=0;
+  bool error= 1;
+  TABLE_LIST *ren_table= 0;
   DBUG_ENTER("mysql_rename_tables");
 
   /*
@@ -47,23 +47,11 @@ bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list)
   }
 
   VOID(pthread_mutex_lock(&LOCK_open));
-  for (lock_table=table_list ; lock_table ; lock_table=lock_table->next)
-  {
-    int got_lock;
-    if ((got_lock=lock_table_name(thd,lock_table)) < 0)
-      goto end;
-    if (got_lock)
-      got_all_locks=0;
-  }
-
-  if (!got_all_locks && wait_for_locked_table_names(thd,table_list))
-    goto end;
-
-  if (!(ren_table=rename_tables(thd,table_list,0)))
-    error=0;
-
-end:
-  if (ren_table)
+  if (lock_table_names(thd, table_list))
+    goto err;
+  
+  error=0;
+  if ((ren_table=rename_tables(thd,table_list,0)))
   {
     /* Rename didn't succeed;  rename back the tables in reverse order */
     TABLE_LIST *prev=0,*table;
@@ -85,7 +73,7 @@ end:
     table=table->next->next;			// Skip error table
     /* Revert to old names */
     rename_tables(thd, table, 1);
-    /* Note that lock_table == 0 here, so the unlock loop will work */
+    error= 1;
   }
 
   /* Lets hope this doesn't fail as the result will be messy */ 
@@ -100,9 +88,9 @@ end:
     send_ok(thd);
   }
 
-  for (TABLE_LIST *table=table_list ; table != lock_table ; table=table->next)
-    unlock_table_name(thd,table);
-  pthread_cond_broadcast(&COND_refresh);
+  unlock_table_names(thd,table_list);
+
+err:
   pthread_mutex_unlock(&LOCK_open);
   DBUG_RETURN(error);
 }
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index dfb4f8fd303..7b05d0d2b98 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -776,12 +776,18 @@ int reset_slave(THD *thd, MASTER_INFO* mi)
     error=1;
     goto err;
   }
+  //delete relay logs, clear relay log coordinates
   if ((error= purge_relay_logs(&mi->rli, thd,
 			       1 /* just reset */,
 			       &errmsg)))
     goto err;
   
+  //Clear master's log coordinates (only for good display of SHOW SLAVE STATUS)
+  mi->master_log_name[0]= 0;
+  mi->master_log_pos= BIN_LOG_HEADER_SIZE;
+  //close master_info_file, relay_log_info_file, set mi->inited=rli->inited=0
   end_master_info(mi);
+  //and delete these two files
   fn_format(fname, master_info_file, mysql_data_home, "", 4+32);
   if (my_stat(fname, &stat_area, MYF(0)) && my_delete(fname, MYF(MY_WME)))
   {
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 3e20f21f567..50c666ab64e 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -2925,6 +2925,12 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
     {
       JOIN_TAB *tab=join->join_tab+i;
       table_map current_map= tab->table->map;
+      /*
+	Following force including random expression in last table condition.
+	It solve problem with select like SELECT * FROM t1 WHERE rand() > 0.5
+      */
+      if (i == join->tables-1)
+	current_map|= RAND_TABLE_BIT;
       bool use_quick_range=0;
       used_tables|=current_map;
 
@@ -3758,6 +3764,7 @@ remove_eq_conds(COND *cond,Item::cond_result *cond_value)
       == Item_func::COND_AND_FUNC;
     List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
     Item::cond_result tmp_cond_value;
+    bool should_fix_fields=0;
 
     *cond_value=Item::COND_UNDEF;
     Item *item;
@@ -3777,6 +3784,7 @@ remove_eq_conds(COND *cond,Item::cond_result *cond_value)
 	delete item;				// This may be shared
 #endif
 	VOID(li.replace(new_item));
+	should_fix_fields=1;
       }
       if (*cond_value == Item::COND_UNDEF)
 	*cond_value=tmp_cond_value;
@@ -3803,6 +3811,9 @@ remove_eq_conds(COND *cond,Item::cond_result *cond_value)
 	break; /* purecov: deadcode */
       }
     }
+    if (should_fix_fields)
+      cond->fix_fields(current_thd,0);
+
     if (!((Item_cond*) cond)->argument_list()->elements ||
 	*cond_value != Item::COND_OK)
       return (COND*) 0;
@@ -4903,6 +4914,10 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
     error=0;
     if (!table)					// If sending data to client
     {
+      /*
+	The following will unlock all cursors if the command wasn't an
+	update command
+      */
       join_free(join, 0);				// Unlock all cursors
       if (join->result->send_eof())
 	error= 1;				// Don't send error
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 9c2280768da..76f5a14c6ad 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -1020,6 +1020,7 @@ append_identifier(THD *thd, String *packet, const char *name)
   }
 }
 
+#define LIST_PROCESS_HOST_LEN 64
 
 static int
 store_create_info(THD *thd, TABLE *table, String *packet)
@@ -1292,7 +1293,7 @@ void mysqld_list_processes(THD *thd,const char *user, bool verbose)
 
   field_list.push_back(new Item_int("Id",0,11));
   field_list.push_back(new Item_empty_string("User",16));
-  field_list.push_back(new Item_empty_string("Host",64));
+  field_list.push_back(new Item_empty_string("Host",LIST_PROCESS_HOST_LEN));
   field_list.push_back(field=new Item_empty_string("db",NAME_LEN));
   field->maybe_null=1;
   field_list.push_back(new Item_empty_string("Command",16));
@@ -1326,7 +1327,14 @@ void mysqld_list_processes(THD *thd,const char *user, bool verbose)
         thd_info->user=thd->strdup(tmp->user ? tmp->user :
 				   (tmp->system_thread ?
 				    "system user" : "unauthenticated user"));
-        thd_info->host= thd->strdup(tmp->host_or_ip);
+	if (tmp->peer_port && (tmp->host || tmp->ip))
+	{
+	  if ((thd_info->host= thd->alloc(LIST_PROCESS_HOST_LEN+1)))
+	    my_snprintf((char *) thd_info->host, LIST_PROCESS_HOST_LEN,
+			"%s:%u", thd->host_or_ip, tmp->peer_port);
+	}
+	else
+	  thd_info->host= thd->strdup(thd->host_or_ip);
         if ((thd_info->db=tmp->db))             // Safe test
           thd_info->db=thd->strdup(thd_info->db);
         thd_info->command=(int) tmp->command;
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index a8428d4f3da..f8d7ba5d277 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+/* Copyright (C) 2000-2003 MySQL AB
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -65,7 +65,7 @@ static int copy_data_between_tables(TABLE *from,TABLE *to,
 int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
 		   my_bool drop_temporary)
 {
-  int error;
+  int error= 0;
   DBUG_ENTER("mysql_rm_table");
 
   /* mark for close and remove all cached entries */
@@ -80,7 +80,7 @@ int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
     {
       my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE,MYF(0),
 	       tables->real_name);
-      error = 1;
+      error= 1;
       goto err;
     }
     while (global_read_lock && ! thd->killed)
@@ -93,7 +93,6 @@ int mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists,
 
  err:
   pthread_mutex_unlock(&LOCK_open);
-  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
 
   pthread_mutex_lock(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= 0;
@@ -139,7 +138,6 @@ int mysql_rm_table_part2_with_lock(THD *thd,
 			     dont_log_query);
 
   pthread_mutex_unlock(&LOCK_open);
-  VOID(pthread_cond_broadcast(&COND_refresh)); // Signal to refresh
 
   pthread_mutex_lock(&thd->mysys_var->mutex);
   thd->mysys_var->current_mutex= 0;
@@ -188,9 +186,12 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
   bool some_tables_deleted=0, tmp_table_deleted=0;
   DBUG_ENTER("mysql_rm_table_part2");
 
+  if (lock_table_names(thd, tables))
+    DBUG_RETURN(1);
+
   for (table=tables ; table ; table=table->next)
   {
-    char *db=table->db ? table->db : thd->db;
+    char *db=table->db;
     mysql_ha_closeall(thd, table);
     if (!close_temporary_table(thd, db, table->real_name))
     {
@@ -266,11 +267,12 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
     }
   }
 
-  error = 0;
+  unlock_table_names(thd, tables);
+  error= 0;
   if (wrong_tables.length())
   {
     my_error(ER_BAD_TABLE_ERROR,MYF(0),wrong_tables.c_ptr());
-    error=1;
+    error= 1;
   }
   DBUG_RETURN(error);
 }
@@ -418,6 +420,12 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
     if (!(sql_field->flags & NOT_NULL_FLAG))
       null_fields++;
 
+    if (check_column_name(sql_field->field_name))
+    {
+      my_error(ER_WRONG_COLUMN_NAME, MYF(0), sql_field->field_name);
+      DBUG_RETURN(-1);
+    }
+
     /* Check if we have used the same field name before */
     for (dup_no=0; (dup_field=it2++) != sql_field; dup_no++)
     {
@@ -979,12 +987,6 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
   while ((item=it++))
   {
     create_field *cr_field;
-    if (strlen(item->name) > NAME_LEN ||
-	check_column_name(item->name))
-    {
-      my_error(ER_WRONG_COLUMN_NAME,MYF(0),item->name);
-      DBUG_RETURN(0);
-    }
     Field *field;
     if (item->type() == Item::FUNC_ITEM)
       field=item->tmp_table_field(&tmp_table);
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 95128b2db3d..d07b4f1a8d5 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -565,12 +565,13 @@ multi_update::initialize_tables(JOIN *join)
   main_table=join->join_tab->table;
   trans_safe= transactional_tables= main_table->file->has_transactions();
   log_delayed= trans_safe || main_table->tmp_table != NO_TMP_TABLE;
-
+  table_to_update= (main_table->file->table_flags() & HA_NOT_MULTI_UPDATE) ? 
+    (TABLE *) 0 : main_table;
   /* Create a temporary table for all tables after except main table */
   for (table_ref= update_tables; table_ref; table_ref=table_ref->next)
   {
     TABLE *table=table_ref->table;
-    if (table != main_table)
+    if (table != table_to_update)
     {
       uint cnt= table_ref->shared;
       ORDER     group;
@@ -645,13 +646,24 @@ bool multi_update::send_data(List<Item> &not_used_values)
   for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
   {
     TABLE *table= cur_table->table;
-    /* Check if we are using outer join and we didn't find the row */
+    /*
+      Check if we are using outer join and we didn't find the row
+      or if we have already updated this row in the previous call to this
+      function.
+
+      The same row may be presented here several times in a join of type
+      UPDATE t1 FROM t1,t2 SET t1.a=t2.a
+
+      In this case we will do the update for the first found row combination.
+      The join algorithm guarantees that we will not find the a row in
+      t1 several times.
+    */
     if (table->status & (STATUS_NULL_ROW | STATUS_UPDATED))
       continue;
 
     uint offset= cur_table->shared;
     table->file->position(table->record[0]);
-    if (table == main_table)
+    if (table == table_to_update)
     {
       table->status|= STATUS_UPDATED;
       store_record(table,1);
@@ -745,7 +757,7 @@ int multi_update::do_updates(bool from_send_error)
   for (cur_table= update_tables; cur_table ; cur_table= cur_table->next)
   {
     table = cur_table->table;
-    if (table == main_table)
+    if (table == table_to_update)
       continue;					// Already updated
 
     org_updated= updated;
diff --git a/sql/stacktrace.c b/sql/stacktrace.c
index 762c45e7184..d0478052fb1 100644
--- a/sql/stacktrace.c
+++ b/sql/stacktrace.c
@@ -197,7 +197,7 @@ terribly wrong...\n");
   fprintf(stderr, "Stack trace seems successful - bottom reached\n");
 
 end:
-  fprintf(stderr, "Please read http://www.mysql.com/doc/U/s/Using_stack_trace.html and follow instructions on how to resolve the stack trace. Resolved\n\
+  fprintf(stderr, "Please read http://www.mysql.com/doc/en/Using_stack_trace.html and follow instructions on how to resolve the stack trace. Resolved\n\
 stack trace is much more helpful in diagnosing the problem, so please do \n\
 resolve it\n");
 }
diff --git a/sql/table.cc b/sql/table.cc
index 08f6e29489d..58375ecdbeb 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -1229,6 +1229,8 @@ bool check_db_name(char *name)
 bool check_table_name(const char *name, uint length)
 {
   const char *end= name+length;
+  if (!length || length > NAME_LEN)
+    return 1;
 
   while (name != end)
   {
@@ -1252,6 +1254,8 @@ bool check_table_name(const char *name, uint length)
 
 bool check_column_name(const char *name)
 {
+  const char *start= name;
+
   while (*name)
   {
 #if defined(USE_MB) && defined(USE_MB_IDENT)
@@ -1270,7 +1274,8 @@ bool check_column_name(const char *name)
       return 1;
     name++;
   }
-  return 0;
+  /* Error if empty or too long column name */
+  return (name == start || (uint) (name - start) > NAME_LEN);
 }
 
 /*
diff --git a/sql/unireg.h b/sql/unireg.h
index 2dc84720b2d..a5cd784a14a 100644
--- a/sql/unireg.h
+++ b/sql/unireg.h
@@ -84,7 +84,7 @@
 
 #define SPECIAL_USE_LOCKS	1		/* Lock used databases */
 #define SPECIAL_NO_NEW_FUNC	2		/* Skip new functions */
-#define SPECIAL_NEW_FUNC	4		/* New nonstandard functions */
+#define SPECIAL_SKIP_SHOW_DB    4               /* Don't allow 'show db' */
 #define SPECIAL_WAIT_IF_LOCKED	8		/* Wait if locked database */
 #define SPECIAL_SAME_DB_NAME   16		/* form name = file name */
 #define SPECIAL_ENGLISH        32		/* English error messages */
@@ -94,7 +94,6 @@
 #define SPECIAL_NO_HOST_CACHE	512		/* Don't cache hosts */
 #define SPECIAL_LONG_LOG_FORMAT 1024
 #define SPECIAL_SAFE_MODE	2048
-#define SPECIAL_SKIP_SHOW_DB	4096		/* Don't allow 'show db' */
 
 	/* Extern defines */
 #define store_record(A,B) bmove_allign((A)->record[B],(A)->record[0],(size_t) (A)->reclength)