Merge baker@bk-internal.mysql.com:/home/bk/mysql-5.0

into avenger.(none):/export/brian/mysql/test/5.0


sql/item.cc:
  Auto merged
sql/item.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged

19 files changed, 267 insertions, 71 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 1275e1bbb8e..56e3ab71bd8 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -4418,6 +4418,8 @@ String *Field_string::val_str(String *val_buffer __attribute__((unused)),
 
 int Field_string::cmp(const char *a_ptr, const char *b_ptr)
 {
+  uint a_len, b_len;
+
   if (field_charset->strxfrm_multiply > 1)
   {
     /*
@@ -4429,10 +4431,19 @@ int Field_string::cmp(const char *a_ptr, const char *b_ptr)
                                             (const uchar*) b_ptr,
                                             field_length);
   }
-  return my_strnncoll(field_charset,(const uchar*) a_ptr, field_length,
-                                    (const uchar*) b_ptr, field_length);
+  if (field_charset->mbmaxlen != 1)
+  {
+    uint char_len= field_length/field_charset->mbmaxlen;
+    a_len= my_charpos(field_charset, a_ptr, a_ptr + field_length, char_len);
+    b_len= my_charpos(field_charset, b_ptr, b_ptr + field_length, char_len);
+  }
+  else
+    a_len= b_len= field_length;
+  return my_strnncoll(field_charset,(const uchar*) a_ptr, a_len,
+                                    (const uchar*) b_ptr, b_len);
 }
 
+
 void Field_string::sort_string(char *to,uint length)
 {
   uint tmp=my_strnxfrm(field_charset,
@@ -5958,8 +5969,14 @@ Field *make_field(char *ptr, uint32 field_length,
   if (f_is_alpha(pack_flag))
   {
     if (!f_is_packed(pack_flag))
-      return new Field_string(ptr,field_length,null_pos,null_bit,
-			      unireg_check, field_name, table, field_charset);
+    {
+      if (field_type == FIELD_TYPE_STRING ||
+          field_type == FIELD_TYPE_VAR_STRING)
+        return new Field_string(ptr,field_length,null_pos,null_bit,
+                                unireg_check, field_name, table,
+                                field_charset);
+      return 0;                                 // Error
+    }
 
     uint pack_length=calc_pack_length((enum_field_types)
 				      f_packtype(pack_flag),
diff --git a/sql/field_conv.cc b/sql/field_conv.cc
index 890687fc925..61a5a28f47b 100644
--- a/sql/field_conv.cc
+++ b/sql/field_conv.cc
@@ -473,7 +473,7 @@ void (*Copy_field::get_copy_func(Field *to,Field *from))(Copy_field*)
 {
   if (to->flags & BLOB_FLAG)
   {
-    if (!(from->flags & BLOB_FLAG))
+    if (!(from->flags & BLOB_FLAG) || from->charset() != to->charset())
       return do_conv_blob;
     if (from_length != to_length ||
 	to->table->db_low_byte_first != from->table->db_low_byte_first)
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index b2e115e9779..17aaaf20fa2 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -1290,7 +1290,6 @@ int ha_ndbcluster::set_bounds(NdbIndexScanOperation *op,
     Field *field= key_part->field;
     uint part_len= key_part->length;
     uint part_store_len= key_part->store_length;
-    bool part_nullable= (bool) key_part->null_bit;
     // Info about each key part
     struct part_st {
       bool part_last;
@@ -1312,9 +1311,9 @@ int ha_ndbcluster::set_bounds(NdbIndexScanOperation *op,
         p.part_last= (tot_len + part_store_len >= key_tot_len[j]);
         p.key= keys[j];
         p.part_ptr= &p.key->key[tot_len];
-        p.part_null= (field->maybe_null() && *p.part_ptr);
+        p.part_null= key_part->null_bit && *p.part_ptr;
         p.bound_ptr= (const char *)
-          p.part_null ? 0 : part_nullable ? p.part_ptr + 1 : p.part_ptr;
+          p.part_null ? 0 : key_part->null_bit ? p.part_ptr + 1 : p.part_ptr;
 
         if (j == 0)
         {
@@ -2325,7 +2324,7 @@ int ha_ndbcluster::index_last(byte *buf)
       DBUG_RETURN(0);
     }
   }
-  DBUG_RETURN(1);
+  DBUG_RETURN(res);
 }
 
 
@@ -2788,7 +2787,7 @@ int ha_ndbcluster::reset()
 
 
 const char **ha_ndbcluster::bas_ext() const
-{ static const char *ext[]= { ".ndb", NullS }; return ext; }
+{ static const char *ext[]= { ha_ndb_ext, NullS }; return ext; }
 
 
 /*
@@ -3322,7 +3321,7 @@ int ha_ndbcluster::create(const char *name,
 {
   NDBTAB tab;
   NDBCOL col;
-  uint pack_length, length, i;
+  uint pack_length, length, i, pk_length= 0;
   const void *data, *pack_data;
   const char **key_names= form->keynames.type_names;
   char name2[FN_HEADLEN];
@@ -3369,6 +3368,8 @@ int ha_ndbcluster::create(const char *name,
     if ((my_errno= create_ndb_column(col, field, info)))
       DBUG_RETURN(my_errno);
     tab.addColumn(col);
+    if(col.getPrimaryKey())
+      pk_length += (field->pack_length() + 3) / 4;
   }
   
   // No primary key, create shadow key as 64 bit, auto increment  
@@ -3382,6 +3383,39 @@ int ha_ndbcluster::create(const char *name,
     col.setPrimaryKey(TRUE);
     col.setAutoIncrement(TRUE);
     tab.addColumn(col);
+    pk_length += 2;
+  }
+  
+  // Make sure that blob tables don't have to big part size
+  for (i= 0; i < form->fields; i++) 
+  {
+    /**
+     * The extra +7 concists
+     * 2 - words from pk in blob table
+     * 5 - from extra words added by tup/dict??
+     */
+    switch (form->field[i]->real_type()) {
+    case MYSQL_TYPE_BLOB:    
+    case MYSQL_TYPE_MEDIUM_BLOB:   
+    case MYSQL_TYPE_LONG_BLOB: 
+    {
+      NdbDictionary::Column * col = tab.getColumn(i);
+      int size = pk_length + (col->getPartSize()+3)/4 + 7;
+      if(size > NDB_MAX_TUPLE_SIZE_IN_WORDS && 
+	 (pk_length+7) < NDB_MAX_TUPLE_SIZE_IN_WORDS)
+      {
+	size = NDB_MAX_TUPLE_SIZE_IN_WORDS - pk_length - 7;
+	col->setPartSize(4*size);
+      }
+      /**
+       * If size > NDB_MAX and pk_length+7 >= NDB_MAX
+       *   then the table can't be created anyway, so skip
+       *   changing part size, and have error later
+       */ 
+    }
+    default:
+      break;
+    }
   }
   
   if ((my_errno= check_ndb_connection()))
diff --git a/sql/handler.cc b/sql/handler.cc
index bb5e980f7bf..b2acb262763 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -105,6 +105,9 @@ const char *tx_isolation_names[] =
 TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
 			       tx_isolation_names, NULL};
 
+static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
+uint known_extensions_id= 0;
+
 enum db_type ha_resolve_by_name(const char *name, uint namelen)
 {
   THD *thd= current_thd;
@@ -577,6 +580,12 @@ int ha_rollback_trans(THD *thd, THD_TRANS *trans)
   if (opt_using_transactions)
   {
     bool operation_done=0;
+    /*
+      As rollback can be 30 times slower than insert in InnoDB, and user may
+      not know there's rollback (if it's because of a dupl row), better warn.
+    */
+    const char *save_proc_info= thd->proc_info;
+    thd->proc_info= "Rolling back";
 #ifdef HAVE_NDBCLUSTER_DB
     if (trans->ndb_tid)
     {
@@ -647,7 +656,8 @@ int ha_rollback_trans(THD *thd, THD_TRANS *trans)
     }
     thd->variables.tx_isolation=thd->session_tx_isolation;
     if (operation_done)
-      statistic_increment(thd->status_var.ha_rollback_count,&LOCK_status);
+      statistic_increment(ha_rollback_count,&LOCK_status);
+    thd->proc_info= save_proc_info;
   }
 #endif /* USING_TRANSACTIONS */
   DBUG_RETURN(error);
@@ -760,6 +770,25 @@ int ha_savepoint(THD *thd, char *savepoint_name)
   DBUG_RETURN(error);
 }
 
+
+int ha_start_consistent_snapshot(THD *thd)
+{
+#ifdef HAVE_INNOBASE_DB
+  if ((have_innodb == SHOW_OPTION_YES) &&
+      !innobase_start_trx_and_assign_read_view(thd))
+    return 0;
+#endif
+  /*
+    Same idea as when one wants to CREATE TABLE in one engine which does not
+    exist:
+  */
+  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
+               "This MySQL server does not support any "
+               "consistent-read capable storage engine");
+  return 0;
+}
+
+
 bool ha_flush_logs()
 {
   bool result=0;
@@ -1755,3 +1784,65 @@ int handler::index_read_idx(byte * buf, uint index, const byte * key,
     error= ha_index_end();
   return error;
 }
+
+
+/*
+  Returns a list of all known extensions.
+
+  SYNOPSIS
+    ha_known_exts()
+ 
+  NOTES
+    No mutexes, worst case race is a minor surplus memory allocation
+    We have to recreate the extension map if mysqld is restarted (for example
+    within libmysqld)
+
+  RETURN VALUE
+    pointer		pointer to TYPELIB structure
+*/
+
+TYPELIB *ha_known_exts(void)
+{
+  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
+  {
+    show_table_type_st *types;
+    List<char> found_exts;
+    List_iterator_fast<char> it(found_exts);
+    const char **ext, *old_ext;
+
+    known_extensions_id= mysys_usage_id;
+    found_exts.push_back((char*) ".db");
+    for (types= sys_table_types; types->type; types++)
+    {      
+      if (*types->value == SHOW_OPTION_YES)
+      {
+	handler *file= get_new_handler(0,(enum db_type) types->db_type);
+	for (ext= file->bas_ext(); *ext; ext++)
+	{
+	  while ((old_ext= it++))
+          {
+	    if (!strcmp(old_ext, *ext))
+	      break;
+          }
+	  if (!old_ext)
+	    found_exts.push_back((char *) *ext);
+
+	  it.rewind();
+	}
+	delete file;
+      }
+    }
+    ext= (const char **) my_once_alloc(sizeof(char *)*
+                                       (found_exts.elements+1),
+                                       MYF(MY_WME | MY_FAE));
+    
+    DBUG_ASSERT(ext);
+    known_extensions.count= found_exts.elements;
+    known_extensions.type_names= ext;
+
+    while ((old_ext= it++))
+      *ext++= old_ext;
+    *ext= 0;
+  }
+  return &known_extensions;
+}
diff --git a/sql/handler.h b/sql/handler.h
index c408425ed60..858a7861dba 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -138,6 +138,8 @@
 #define HA_CACHE_TBL_ASKTRANSACT 2
 #define HA_CACHE_TBL_TRANSACT    4
 
+/* Options of START TRANSACTION statement (and later of SET TRANSACTION stmt) */
+#define MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT 1
 
 enum db_type
 {
@@ -590,5 +592,5 @@ int ha_discover(THD* thd, const char* dbname, const char* name,
 int ha_find_files(THD *thd,const char *db,const char *path,
 		  const char *wild, bool dir,List<char>* files);
 int ha_table_exists(THD* thd, const char* db, const char* name);
-
-
+TYPELIB *ha_known_exts(void);
+int ha_start_consistent_snapshot(THD *thd);
diff --git a/sql/item.cc b/sql/item.cc
index 429b8f63afa..05e5eb9076f 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -490,13 +490,13 @@ bool DTCollation::aggregate(DTCollation &dt, uint flags)
     }
     else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
              derivation < dt.derivation &&
-             dt.derivation == DERIVATION_COERCIBLE)
+             dt.derivation >= DERIVATION_COERCIBLE)
     {
       // Do nothing;
     }
     else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
              dt.derivation < derivation &&
-             derivation == DERIVATION_COERCIBLE)
+             derivation >= DERIVATION_COERCIBLE)
     {
       set(dt);
       strong= nagg;
diff --git a/sql/item.h b/sql/item.h
index 329c25073ee..9c036c28408 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -32,6 +32,7 @@ class Item_field;
 
 enum Derivation
 {
+  DERIVATION_IGNORABLE= 4,
   DERIVATION_COERCIBLE= 3,
   DERIVATION_IMPLICIT= 2,
   DERIVATION_NONE= 1,
@@ -99,6 +100,7 @@ public:
   {
     switch(derivation)
     {
+      case DERIVATION_IGNORABLE: return "IGNORABLE";
       case DERIVATION_COERCIBLE: return "COERCIBLE";
       case DERIVATION_IMPLICIT:  return "IMPLICIT";
       case DERIVATION_EXPLICIT:  return "EXPLICIT";
@@ -577,6 +579,7 @@ public:
     max_length= 0;
     name= name_par ? name_par : (char*) "NULL";
     fixed= 1;
+    collation.set(&my_charset_bin, DERIVATION_IGNORABLE);
   }
   enum Type type() const { return NULL_ITEM; }
   bool eq(const Item *item, bool binary_cmp) const;
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
index 566cacca487..394507af4f0 100644
--- a/sql/item_timefunc.cc
+++ b/sql/item_timefunc.cc
@@ -161,21 +161,24 @@ static bool extract_date_time(DATE_TIME_FORMAT *format,
 {
   int weekday= 0, yearday= 0, daypart= 0;
   int week_number= -1;
-  CHARSET_INFO *cs= &my_charset_bin;
   int error= 0;
-  bool usa_time= 0;
-  bool sunday_first_n_first_week_non_iso= -2;
-  bool strict_week_number;
   int  strict_week_number_year= -1;
-  bool strict_week_number_year_type= -1;
   int frac_part;
+  bool usa_time= 0;
+  bool sunday_first_n_first_week_non_iso;
+  bool strict_week_number;
+  bool strict_week_number_year_type;
   const char *val_begin= val;
   const char *val_end= val + length;
   const char *ptr= format->format.str;
   const char *end= ptr + format->format.length;
+  CHARSET_INFO *cs= &my_charset_bin;
   DBUG_ENTER("extract_date_time");
 
   LINT_INIT(strict_week_number);
+  /* Remove valgrind varnings when using gcc 3.3 and -O1 */
+  PURIFY_OR_LINT_INIT(strict_week_number_year_type);
+  PURIFY_OR_LINT_INIT(sunday_first_n_first_week_non_iso);
 
   if (!sub_pattern_end)
     bzero((char*) l_time, sizeof(*l_time));
diff --git a/sql/lex.h b/sql/lex.h
index 89daf46218c..db31b3af994 100644
--- a/sql/lex.h
+++ b/sql/lex.h
@@ -120,6 +120,7 @@ static SYMBOL symbols[] = {
   { "CONCURRENT",	SYM(CONCURRENT)},
   { "CONDITION",        SYM(CONDITION_SYM)},
   { "CONNECTION",       SYM(CONNECTION_SYM)},
+  { "CONSISTENT",	SYM(CONSISTENT_SYM)},
   { "CONSTRAINT",	SYM(CONSTRAINT)},
   { "CONTAINS",         SYM(CONTAINS_SYM)},
   { "CONTINUE",         SYM(CONTINUE_SYM)},
@@ -421,6 +422,7 @@ static SYMBOL symbols[] = {
   { "SIGNED",		SYM(SIGNED_SYM)},
   { "SIMPLE",		SYM(SIMPLE_SYM)},
   { "SLAVE",            SYM(SLAVE)},
+  { "SNAPSHOT",         SYM(SNAPSHOT_SYM)},
   { "SMALLINT",		SYM(SMALLINT)},
   { "SOME",             SYM(ANY_SYM)},
   { "SONAME",		SYM(UDF_SONAME_SYM)},
diff --git a/sql/log.cc b/sql/log.cc
index ef538c3b03f..86b76ed883e 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -1714,12 +1714,19 @@ bool MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
   time_t current_time;
   if (!is_open())
     return 0;
+  DBUG_ENTER("MYSQL_LOG::write");
+
   VOID(pthread_mutex_lock(&LOCK_log));
   if (is_open())
   {						// Safety agains reopen
     int tmp_errno=0;
     char buff[80],*end;
     end=buff;
+    if (!(thd->options & OPTION_UPDATE_LOG))
+    {
+      VOID(pthread_mutex_unlock(&LOCK_log));
+      DBUG_RETURN(0);
+    }
     if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT) || query_start_arg)
     {
       current_time=time(NULL);
@@ -1818,7 +1825,7 @@ bool MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
     }
   }
   VOID(pthread_mutex_unlock(&LOCK_log));
-  return error;
+  DBUG_RETURN(error);
 }
 
 
@@ -1838,16 +1845,19 @@ bool MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
     THD::enter_cond() (see NOTES in sql_class.h).
 */
 
-void MYSQL_LOG:: wait_for_update(THD* thd, bool master_or_slave)
+void MYSQL_LOG::wait_for_update(THD* thd, bool master_or_slave)
 {
-  const char* old_msg = thd->enter_cond(&update_cond, &LOCK_log,
-                                        master_or_slave ?
-                                        "Has read all relay log; waiting for \
-the slave I/O thread to update it" : 
-                                        "Has sent all binlog to slave; \
-waiting for binlog to be updated"); 
+  const char *old_msg;
+  DBUG_ENTER("wait_for_update");
+  old_msg= thd->enter_cond(&update_cond, &LOCK_log,
+                           master_or_slave ?
+                           "Has read all relay log; waiting for the slave I/O "
+                           "thread to update it" : 
+                           "Has sent all binlog to slave; waiting for binlog "
+                           "to be updated"); 
   pthread_cond_wait(&update_cond, &LOCK_log);
   thd->exit_cond(old_msg);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2204,6 +2214,15 @@ void MYSQL_LOG::report_pos_in_innodb()
   DBUG_VOID_RETURN;
 }
 
+
+void MYSQL_LOG::signal_update()
+{
+  DBUG_ENTER("MYSQL_LOG::signal_update");
+  pthread_cond_broadcast(&update_cond);
+  DBUG_VOID_RETURN;
+}
+
+
 #ifdef __NT__
 void print_buffer_to_nt_eventlog(enum loglevel level, char *buff,
                                  uint length, int buffLen)
diff --git a/sql/log_event.cc b/sql/log_event.cc
index c7f6f25e74a..7fba19cb000 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -1384,11 +1384,6 @@ int Query_log_event::exec_event(struct st_relay_log_info* rli)
   if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
   {
     thd->set_time((time_t)when);
-    /*
-      We cannot use db_len from event to fill thd->db_length, because
-      rewrite_db() may have changed db.
-    */ 
-    thd->db_length= thd->db ? strlen(thd->db) : 0;
     thd->query_length= q_len;
     thd->query = (char*)query;
     VOID(pthread_mutex_lock(&LOCK_thread_count));
@@ -1466,10 +1461,10 @@ START SLAVE; . Query: '%s'", expected_error, thd->query);
 Query caused different errors on master and slave. \
 Error on master: '%s' (%d), Error on slave: '%s' (%d). \
 Default database: '%s'. Query: '%s'",
- 			ER_SAFE(expected_error),
- 			expected_error,
- 			actual_error ? thd->net.last_error: "no error",
- 			actual_error,
+			ER_SAFE(expected_error),
+			expected_error,
+			actual_error ? thd->net.last_error: "no error",
+			actual_error,
 			print_slave_db_safe(db), query);
       thd->query_error= 1;
     }
@@ -1489,9 +1484,9 @@ Default database: '%s'. Query: '%s'",
     {
       slave_print_error(rli,actual_error,
 			"Error '%s' on query. Default database: '%s'. Query: '%s'",
- 			(actual_error ? thd->net.last_error :
- 			 "unexpected success or fatal error"),
-			print_slave_db_safe(db), query);
+			(actual_error ? thd->net.last_error :
+			 "unexpected success or fatal error"),
+			print_slave_db_safe(thd->db), query);
       thd->query_error= 1;
     }
 
@@ -2435,7 +2430,8 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli,
 			       bool use_rli_only_for_errors)
 {
   char *load_data_query= 0;
-  thd->db= (char*) rewrite_db(db); // thd->db_length is set later if needed
+  thd->db_length= db_len;
+  thd->db= (char*) rewrite_db(db, &thd->db_length);
   DBUG_ASSERT(thd->query == 0);
   thd->query_length= 0;                         // Should not be needed
   thd->query_error= 0;
@@ -2467,7 +2463,6 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli,
   if (db_ok(thd->db, replicate_do_db, replicate_ignore_db))
   {
     thd->set_time((time_t)when);
-    thd->db_length= thd->db ? strlen(thd->db) : 0;
     VOID(pthread_mutex_lock(&LOCK_thread_count));
     thd->query_id = query_id++;
     VOID(pthread_mutex_unlock(&LOCK_thread_count));
@@ -2573,7 +2568,7 @@ Slave: load data infile on table '%s' at log position %s in log \
                         (char*) table_name,
                         llstr(log_pos,llbuff), RPL_LOG_NAME, 
 			(ulong) thd->cuted_fields,
-                        print_slave_db_safe(db));
+                        print_slave_db_safe(thd->db));
       }
       if (net)
         net->pkt_nr= thd->net.pkt_nr;
@@ -2591,6 +2586,7 @@ Slave: load data infile on table '%s' at log position %s in log \
   }
 	    
   thd->net.vio = 0; 
+  char *save_db= thd->db;
   VOID(pthread_mutex_lock(&LOCK_thread_count));
   thd->db= thd->catalog= 0;
   thd->query= 0;
@@ -2613,7 +2609,7 @@ Slave: load data infile on table '%s' at log position %s in log \
     }
     slave_print_error(rli,sql_errno,"\
 Error '%s' running LOAD DATA INFILE on table '%s'. Default database: '%s'",
-		      err, (char*)table_name, print_slave_db_safe(db));
+		      err, (char*)table_name, print_slave_db_safe(save_db));
     free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
     return 1;
   }
@@ -2623,7 +2619,7 @@ Error '%s' running LOAD DATA INFILE on table '%s'. Default database: '%s'",
   {
     slave_print_error(rli,ER_UNKNOWN_ERROR, "\
 Fatal error running LOAD DATA INFILE on table '%s'. Default database: '%s'",
-		      (char*)table_name, print_slave_db_safe(db));
+		      (char*)table_name, print_slave_db_safe(save_db));
     return 1;
   }
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 196b7af46b1..675f57c4ea5 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -543,7 +543,7 @@ static void close_connections(void)
     struct timespec abstime;
     int error;
     LINT_INIT(error);
-    DBUG_PRINT("info",("Waiting for select_thread"));
+    DBUG_PRINT("info",("Waiting for select thread"));
 
 #ifndef DONT_USE_THR_ALARM
     if (pthread_kill(select_thread,THR_CLIENT_ALARM))
diff --git a/sql/slave.cc b/sql/slave.cc
index 88dffbd8411..b25bdb7e926 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -1150,7 +1150,7 @@ bool net_request_file(NET* net, const char* fname)
 }
 
 
-const char *rewrite_db(const char* db)
+const char *rewrite_db(const char* db, uint *new_len)
 {
   if (replicate_rewrite_db.is_empty() || !db)
     return db;
@@ -1160,7 +1160,10 @@ const char *rewrite_db(const char* db)
   while ((tmp=it++))
   {
     if (!strcmp(tmp->key, db))
+    {
+      *new_len= strlen(tmp->val);
       return tmp->val;
+    }
   }
   return db;
 }
@@ -1174,7 +1177,7 @@ const char *rewrite_db(const char* db)
 
 const char *print_slave_db_safe(const char* db)
 {
-  return (db ? rewrite_db(db) : "");
+  return (db ? db : "");
 }
 
 /*
@@ -2829,7 +2832,7 @@ static int request_dump(MYSQL* mysql, MASTER_INFO* mi,
   DBUG_ENTER("request_dump");
 
   // TODO if big log files: Change next to int8store()
-  int4store(buf, (longlong) mi->master_log_pos);
+  int4store(buf, (ulong) mi->master_log_pos);
   int2store(buf + 4, binlog_flags);
   int4store(buf + 6, server_id);
   len = (uint) strlen(logname);
diff --git a/sql/slave.h b/sql/slave.h
index 2a9b96b75a1..b8ff86cf301 100644
--- a/sql/slave.h
+++ b/sql/slave.h
@@ -508,8 +508,8 @@ int add_table_rule(HASH* h, const char* table_spec);
 int add_wild_table_rule(DYNAMIC_ARRAY* a, const char* table_spec);
 void init_table_rule_hash(HASH* h, bool* h_inited);
 void init_table_rule_array(DYNAMIC_ARRAY* a, bool* a_inited);
-const char *rewrite_db(const char* db);
-const char *print_slave_db_safe(const char* db);
+const char *rewrite_db(const char* db, uint *new_db_len);
+const char *print_slave_db_safe(const char *db);
 int check_expected_error(THD* thd, RELAY_LOG_INFO* rli, int error_code);
 void skip_load_data_infile(NET* net);
 void slave_print_error(RELAY_LOG_INFO* rli, int err_code, const char* msg, ...);
diff --git a/sql/sql_class.h b/sql/sql_class.h
index f820f8b9cb9..85a18b10671 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -153,7 +153,7 @@ public:
     DBUG_VOID_RETURN;
   }
   void set_max_size(ulong max_size_arg);
-  void signal_update() { pthread_cond_broadcast(&update_cond);}
+  void signal_update();
   void wait_for_update(THD* thd, bool master_or_slave);
   void set_need_start_event() { need_start_event = 1; }
   void init(enum_log_type log_type_arg,
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 7a100d05b93..ad74bb8f833 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -31,11 +31,6 @@ const char *del_exts[]= {".frm", ".BAK", ".TMD",".opt", NullS};
 static TYPELIB deletable_extentions=
 {array_elements(del_exts)-1,"del_exts", del_exts, NULL};
 
-const char *known_exts[]=
-{".ISM",".ISD",".ISM",".MRG",".MYI",".MYD",".db", ".ibd", NullS};
-static TYPELIB known_extentions=
-{array_elements(known_exts)-1,"known_exts", known_exts, NULL};
-
 static long mysql_rm_known_files(THD *thd, MY_DIR *dirp,
 				 const char *db, const char *path,
 				 uint level);
@@ -755,7 +750,7 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db,
     extension= fn_ext(file->name);
     if (find_type(extension, &deletable_extentions,1+2) <= 0)
     {
-      if (find_type(extension, &known_extentions,1+2) <= 0)
+      if (find_type(extension, ha_known_exts(),1+2) <= 0)
 	found_other_files++;
       continue;
     }
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index c8b4faa47c2..fd1c1dee0b7 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -706,7 +706,7 @@ typedef struct st_lex
   uint uint_geom_type;
   uint grant, grant_tot_col, which_columns;
   uint fk_delete_opt, fk_update_opt, fk_match_option;
-  uint slave_thd_opt;
+  uint slave_thd_opt, start_transaction_opt;
   uint8 describe;
   uint8 derived_tables;
   uint8 create_view_algorithm;
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 1adc40e8446..6d90b4eac05 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -1658,15 +1658,15 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
 #ifndef EMBEDDED_LIBRARY
   case COM_BINLOG_DUMP:
     {
+      ulong pos;
+      ushort flags;
+      uint32 slave_server_id;
+
       statistic_increment(thd->status_var.com_other,&LOCK_status);
       thd->slow_command = TRUE;
       if (check_global_access(thd, REPL_SLAVE_ACL))
 	break;
-      mysql_log.write(thd,command, 0);
 
-      ulong pos;
-      ushort flags;
-      uint32 slave_server_id;
       /* TODO: The following has to be changed to an 8 byte integer */
       pos = uint4korr(packet);
       flags = uint2korr(packet + 4);
@@ -1674,6 +1674,9 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
       if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
 	kill_zombie_dump_threads(slave_server_id);
       thd->server_id = slave_server_id;
+
+      mysql_log.write(thd, command, "Log: '%s'  Pos: %ld", packet+10,
+                      (long) pos);
       mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
       unregister_slave(thd,1,1);
       /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
@@ -3208,6 +3211,12 @@ purposes internal to the MySQL server", MYF(0));
   }
 
   case SQLCOM_UNLOCK_TABLES:
+    /*
+      It is critical for mysqldump --single-transaction --master-data that
+      UNLOCK TABLES does not implicitely commit a connection which has only
+      done FLUSH TABLES WITH READ LOCK + BEGIN. If this assumption becomes
+      false, mysqldump will not work.
+    */
     unlock_locked_tables(thd);
     if (thd->options & OPTION_TABLE_LOCK)
     {
@@ -3567,7 +3576,9 @@ purposes internal to the MySQL server", MYF(0));
       thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
 		     OPTION_BEGIN);
       thd->server_status|= SERVER_STATUS_IN_TRANS;
-      send_ok(thd);
+      if (!(lex->start_transaction_opt & MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT) ||
+          !(res= ha_start_consistent_snapshot(thd)))
+        send_ok(thd);
     }
     break;
   case SQLCOM_COMMIT:
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 309a9249d0e..fe5ce7640ea 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -140,6 +140,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token	CLIENT_SYM
 %token	COMMENT_SYM
 %token	COMMIT_SYM
+%token  CONSISTENT_SYM
 %token	COUNT_SYM
 %token	CREATE
 %token	CROSS
@@ -176,6 +177,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token	SELECT_SYM
 %token	SHOW
 %token	SLAVE
+%token  SNAPSHOT_SYM
 %token  SQL_SYM
 %token	SQL_THREAD
 %token	START_SYM
@@ -676,6 +678,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         table_option opt_if_not_exists opt_no_write_to_binlog opt_var_type
         opt_var_ident_type delete_option opt_temporary all_or_any opt_distinct
         opt_ignore_leaves fulltext_options spatial_type union_option
+        start_transaction_opts
 
 %type <ulong_num>
 	ULONG_NUM raid_types merge_insert_types
@@ -3473,10 +3476,21 @@ slave:
 
 
 start:
-	START_SYM TRANSACTION_SYM { Lex->sql_command = SQLCOM_BEGIN;}
-	{}
+	START_SYM TRANSACTION_SYM start_transaction_opts
+        {
+           Lex->sql_command = SQLCOM_BEGIN;
+           Lex->start_transaction_opt= $3;
+        }
 	;
 
+start_transaction_opts:
+        /*empty*/ { $$ = 0; }
+        | WITH CONSISTENT_SYM SNAPSHOT_SYM
+        {
+           $$= MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT;
+        }
+        ;
+
 slave_thread_opts:
 	{ Lex->slave_thd_opt= 0; }
 	slave_thread_opt_list
@@ -6846,6 +6860,7 @@ keyword:
 	| COMMIT_SYM		{}
 	| COMPRESSED_SYM	{}
 	| CONCURRENT		{}
+	| CONSISTENT_SYM	{}
 	| CONTAINS_SYM          {}
 	| CUBE_SYM		{}
 	| DATA_SYM		{}
@@ -6998,6 +7013,7 @@ keyword:
 	| SHARE_SYM		{}
 	| SHUTDOWN		{}
 	| SLAVE			{}
+	| SNAPSHOT_SYM		{}
 	| SOUNDS_SYM		{}
 	| SQL_CACHE_SYM		{}
 	| SQL_BUFFER_RESULT	{}
@@ -7489,7 +7505,7 @@ revoke_command:
 	grant_privileges ON opt_table FROM user_list
 	{}
 	|
-	ALL PRIVILEGES ',' GRANT OPTION FROM user_list
+	ALL opt_privileges ',' GRANT OPTION FROM user_list
 	{
 	  Lex->sql_command = SQLCOM_REVOKE_ALL;
 	}
@@ -7515,10 +7531,14 @@ grant:
 
 grant_privileges:
 	grant_privilege_list {}
-	| ALL PRIVILEGES	{ Lex->grant = GLOBAL_ACLS;}
-	| ALL			{ Lex->grant = GLOBAL_ACLS;}
+	| ALL opt_privileges	{ Lex->grant = GLOBAL_ACLS;}
         ;
 
+opt_privileges:
+	/* empty */
+	| PRIVILEGES
+	;
+
 grant_privilege_list:
 	grant_privilege
 	| grant_privilege_list ',' grant_privilege;
@@ -7767,7 +7787,7 @@ grant_option:
         ;
 
 begin:
-	BEGIN_SYM   { Lex->sql_command = SQLCOM_BEGIN;} opt_work {}
+	BEGIN_SYM   { Lex->sql_command = SQLCOM_BEGIN; Lex->start_transaction_opt= 0;} opt_work {}
 	;
 
 opt_work: