Merge mysql.com:/home/mydev/mysql-4.1

into  mysql.com:/home/mydev/mysql-4.1-bug5390

38 files changed, 523 insertions, 166 deletions

diff --git a/sql/field.cc b/sql/field.cc
index b1d9167aee2..a64eaad7308 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -3385,6 +3385,11 @@ longlong Field_double::val_int(void)
   else
 #endif
     doubleget(j,ptr);
+  /* Check whether we fit into longlong range */
+  if (j <= (double) LONGLONG_MIN)
+    return (longlong) LONGLONG_MIN;
+  if (j >= (double) (ulonglong) LONGLONG_MAX)
+    return (longlong) LONGLONG_MAX;
   return ((longlong) j);
 }
 
@@ -6516,13 +6521,11 @@ bool Field_num::eq_def(Field *field)
     create_field::create_length_to_internal_length()
   
   DESCRIPTION
-    Convert create_field::length from number of characters to number of bytes,
-    save original value in chars_length.
+    Convert create_field::length from number of characters to number of bytes.
 */
 
 void create_field::create_length_to_internal_length(void)
 {
-  chars_length= length;
   switch (sql_type) {
   case MYSQL_TYPE_TINY_BLOB:
   case MYSQL_TYPE_MEDIUM_BLOB:
@@ -6775,6 +6778,7 @@ create_field::create_field(Field *old_field,Field *orig_field)
       break;
   }
 
+  char_length= length;
   decimals= old_field->decimals();
   if (sql_type == FIELD_TYPE_STRING)
   {
diff --git a/sql/field.h b/sql/field.h
index 04f1bd68c7a..966549516b1 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -1188,7 +1188,7 @@ public:
   /*
     The value of 'length' before a call to create_length_to_internal_length
   */
-  uint32 chars_length;
+  uint32 char_length;
   uint decimals,flags,pack_length;
   Field::utype unireg_check;
   TYPELIB *interval;			// Which interval to use
diff --git a/sql/ha_heap.cc b/sql/ha_heap.cc
index f8c2e6cc338..9c680daaf91 100644
--- a/sql/ha_heap.cc
+++ b/sql/ha_heap.cc
@@ -68,7 +68,7 @@ int ha_heap::open(const char *name, int mode, uint test_if_locked)
       ha_heap::info(), which is always called before key statistics are
       used.
     */
-    key_stats_ok= FALSE;
+    key_stat_version= file->s->key_stat_version-1;
   }
   return (file ? 0 : 1);
 }
@@ -114,14 +114,21 @@ void ha_heap::update_key_stats()
       continue;
     if (key->algorithm != HA_KEY_ALG_BTREE)
     {
-      ha_rows hash_buckets= file->s->keydef[i].hash_buckets;
-      key->rec_per_key[key->key_parts-1]= 
-        hash_buckets ? file->s->records/hash_buckets : 0;
+      if (key->flags & HA_NOSAME)
+        key->rec_per_key[key->key_parts-1]= 1;
+      else
+      {
+        ha_rows hash_buckets= file->s->keydef[i].hash_buckets;
+        uint no_records= hash_buckets ? file->s->records/hash_buckets : 2;
+        if (no_records < 2)
+          no_records= 2;
+        key->rec_per_key[key->key_parts-1]= no_records;
+      }
     }
   }
   records_changed= 0;
   /* At the end of update_key_stats() we can proudly claim they are OK. */
-  key_stats_ok= TRUE;
+  key_stat_version= file->s->key_stat_version;
 }
 
 int ha_heap::write_row(byte * buf)
@@ -135,7 +142,13 @@ int ha_heap::write_row(byte * buf)
   res= heap_write(file,buf);
   if (!res && ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > 
               file->s->records)
-    key_stats_ok= FALSE;
+  {
+    /*
+       We can perform this safely since only one writer at the time is
+       allowed on the table.
+    */
+    file->s->key_stat_version++;
+  }
   return res;
 }
 
@@ -148,7 +161,13 @@ int ha_heap::update_row(const byte * old_data, byte * new_data)
   res= heap_update(file,old_data,new_data);
   if (!res && ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > 
               file->s->records)
-    key_stats_ok= FALSE;
+  {
+    /*
+       We can perform this safely since only one writer at the time is
+       allowed on the table.
+    */
+    file->s->key_stat_version++;
+  }
   return res;
 }
 
@@ -159,7 +178,13 @@ int ha_heap::delete_row(const byte * buf)
   res= heap_delete(file,buf);
   if (!res && table->tmp_table == NO_TMP_TABLE && 
       ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > file->s->records)
-    key_stats_ok= FALSE;
+  {
+    /*
+       We can perform this safely since only one writer at the time is
+       allowed on the table.
+    */
+    file->s->key_stat_version++;
+  }
   return res;
 }
 
@@ -277,7 +302,7 @@ void ha_heap::info(uint flag)
     have to update the key statistics. Hoping that a table lock is now
     in place.
   */
-  if (! key_stats_ok)
+  if (key_stat_version != file->s->key_stat_version)
     update_key_stats();
 }
 
@@ -290,7 +315,13 @@ int ha_heap::delete_all_rows()
 {
   heap_clear(file);
   if (table->tmp_table == NO_TMP_TABLE)
-    key_stats_ok= FALSE;
+  {
+    /*
+       We can perform this safely since only one writer at the time is
+       allowed on the table.
+    */
+    file->s->key_stat_version++;
+  }
   return 0;
 }
 
@@ -449,12 +480,13 @@ ha_rows ha_heap::records_in_range(uint inx, key_range *min_key,
       min_key->flag != HA_READ_KEY_EXACT ||
       max_key->flag != HA_READ_AFTER_KEY)
     return HA_POS_ERROR;			// Can only use exact keys
-  else
-  {
-    /* Assert that info() did run. We need current statistics here. */
-    DBUG_ASSERT(key_stats_ok);
-    return key->rec_per_key[key->key_parts-1];
-  }
+
+  if (records <= 1)
+    return records;
+
+  /* Assert that info() did run. We need current statistics here. */
+  DBUG_ASSERT(key_stat_version == file->s->key_stat_version);
+  return key->rec_per_key[key->key_parts-1];
 }
 
 
diff --git a/sql/ha_heap.h b/sql/ha_heap.h
index cbe2474492d..0a087fde1b0 100644
--- a/sql/ha_heap.h
+++ b/sql/ha_heap.h
@@ -29,10 +29,10 @@ class ha_heap: public handler
   key_map btree_keys;
   /* number of records changed since last statistics update */
   uint    records_changed;
-  bool    key_stats_ok;
+  uint    key_stat_version;
 public:
   ha_heap(TABLE *table): handler(table), file(0), records_changed(0),
-      key_stats_ok(0) {}
+      key_stat_version(0) {}
   ~ha_heap() {}
   const char *table_type() const { return "HEAP"; }
   const char *index_type(uint inx)
diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc
index d24587e23ea..8455bbaf4d0 100644
--- a/sql/ha_innodb.cc
+++ b/sql/ha_innodb.cc
@@ -332,6 +332,13 @@ convert_error_code_to_mysql(
 
     		return(HA_ERR_NO_SAVEPOINT);
   	} else if (error == (int) DB_LOCK_TABLE_FULL) {
+          /* Since we rolled back the whole transaction, we must
+          tell it also to MySQL so that MySQL knows to empty the
+          cached binlog for this transaction */
+
+          if (thd) {
+                  ha_rollback(thd);
+          }
 
     		return(HA_ERR_LOCK_TABLE_FULL);
     	} else {
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index 594551b918a..876d5d2f8fd 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -45,8 +45,6 @@ static const int max_transactions= 256;
 
 static const char *ha_ndb_ext=".ndb";
 
-#define NDB_HIDDEN_PRIMARY_KEY_LENGTH 8
-
 #define NDB_FAILED_AUTO_INCREMENT ~(Uint64)0
 #define NDB_AUTO_INCREMENT_RETRIES 10
 
@@ -747,7 +745,7 @@ int ha_ndbcluster::get_ndb_value(NdbOperation *ndb_op, Field *field,
   }
 
   // Used for hidden key only
-  m_value[fieldnr].rec= ndb_op->getValue(fieldnr, NULL);
+  m_value[fieldnr].rec= ndb_op->getValue(fieldnr, m_ref);
   DBUG_RETURN(m_value[fieldnr].rec == NULL);
 }
 
@@ -2098,13 +2096,10 @@ int ha_ndbcluster::update_row(const byte *old_data, byte *new_data)
       DBUG_PRINT("info", ("Using hidden key"));
       
       // Require that the PK for this record has previously been 
-      // read into m_value
-      uint no_fields= table->fields;
-      NdbRecAttr* rec= m_value[no_fields].rec;
-      DBUG_ASSERT(rec);
-      DBUG_DUMP("key", (char*)rec->aRef(), NDB_HIDDEN_PRIMARY_KEY_LENGTH);
+      // read into m_ref
+      DBUG_DUMP("key", m_ref, NDB_HIDDEN_PRIMARY_KEY_LENGTH);
       
-      if (set_hidden_key(op, no_fields, rec->aRef()))
+      if (set_hidden_key(op, table->fields, m_ref))
 	ERR_RETURN(op->getNdbError());
     } 
     else 
@@ -2181,11 +2176,8 @@ int ha_ndbcluster::delete_row(const byte *record)
     {
       // This table has no primary key, use "hidden" primary key
       DBUG_PRINT("info", ("Using hidden key"));
-      uint no_fields= table->fields;
-      NdbRecAttr* rec= m_value[no_fields].rec;
-      DBUG_ASSERT(rec != NULL);
       
-      if (set_hidden_key(op, no_fields, rec->aRef()))
+      if (set_hidden_key(op, table->fields, m_ref))
 	ERR_RETURN(op->getNdbError());
     } 
     else 
@@ -2792,7 +2784,7 @@ void ha_ndbcluster::position(const byte *record)
                 hidden_col->getAutoIncrement() &&
                 rec != NULL && 
                 ref_length == NDB_HIDDEN_PRIMARY_KEY_LENGTH);
-    memcpy(ref, (const void*)rec->aRef(), ref_length);
+    memcpy(ref, m_ref, ref_length);
   }
   
   DBUG_DUMP("ref", (char*)ref, ref_length);
@@ -3046,9 +3038,26 @@ int ha_ndbcluster::end_bulk_insert()
                         "rows_inserted:%d, bulk_insert_rows: %d", 
                         (int) m_rows_inserted, (int) m_bulk_insert_rows)); 
     m_bulk_insert_not_flushed= FALSE;
-    if (execute_no_commit(this,trans) != 0) {
-      no_uncommitted_rows_execute_failure();
-      my_errno= error= ndb_err(trans);
+    if (m_transaction_on)
+    {
+      if (execute_no_commit(this, trans) != 0)
+      {
+        no_uncommitted_rows_execute_failure();
+        my_errno= error= ndb_err(trans);
+      }
+    }
+    else
+    {
+      if (execute_commit(this, trans) != 0)
+      {
+        no_uncommitted_rows_execute_failure();
+        my_errno= error= ndb_err(trans);
+      }
+      else
+      {
+        int res= trans->restart();
+        DBUG_ASSERT(res == 0);
+      }
     }
   }
 
@@ -4867,7 +4876,7 @@ bool ha_ndbcluster::low_byte_first() const
 }
 bool ha_ndbcluster::has_transactions()
 {
-  return m_transaction_on;
+  return TRUE;
 }
 const char* ha_ndbcluster::index_type(uint key_number)
 {
diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h
index 90d5d59cabe..83d9d87777a 100644
--- a/sql/ha_ndbcluster.h
+++ b/sql/ha_ndbcluster.h
@@ -27,6 +27,8 @@
 
 #include <ndbapi_limits.h>
 
+#define NDB_HIDDEN_PRIMARY_KEY_LENGTH 8
+
 class Ndb;             // Forward declaration
 class NdbOperation;    // Forward declaration
 class NdbConnection;   // Forward declaration
@@ -226,6 +228,7 @@ class ha_ndbcluster: public handler
   // NdbRecAttr has no reference to blob
   typedef union { NdbRecAttr *rec; NdbBlob *blob; void *ptr; } NdbValue;
   NdbValue m_value[NDB_MAX_ATTRIBUTES_IN_TABLE];
+  byte m_ref[NDB_HIDDEN_PRIMARY_KEY_LENGTH];
   bool m_use_write;
   bool m_ignore_dup_key;
   bool m_primary_key_update;
diff --git a/sql/hostname.cc b/sql/hostname.cc
index 32e1d84fac3..32c4bb8533d 100644
--- a/sql/hostname.cc
+++ b/sql/hostname.cc
@@ -61,7 +61,7 @@ bool hostname_cache_init()
   if (!(hostname_cache=new hash_filo(HOST_CACHE_SIZE, offset,
 				     sizeof(struct in_addr),NULL,
 				     (hash_free_key) free,
-				     &my_charset_latin1)))
+				     &my_charset_bin)))
     return 1;
   hostname_cache->clear();
   (void) pthread_mutex_init(&LOCK_hostname,MY_MUTEX_INIT_SLOW);
diff --git a/sql/item.cc b/sql/item.cc
index f996e962cca..5964ed388c6 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -3258,7 +3258,7 @@ bool Item_type_holder::join_types(THD *thd, Item *item)
     const char *old_cs, *old_derivation;
     old_cs= collation.collation->name;
     old_derivation= collation.derivation_name();
-    if (collation.aggregate(item->collation))
+    if (collation.aggregate(item->collation, MY_COLL_ALLOW_CONV))
     {
       my_error(ER_CANT_AGGREGATE_2COLLATIONS, MYF(0),
 	       old_cs, old_derivation,
diff --git a/sql/item_func.cc b/sql/item_func.cc
index c82d505c1bb..d0d2eca7233 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -1540,11 +1540,8 @@ longlong Item_func_bit_count::val_int()
 {
   DBUG_ASSERT(fixed == 1);
   ulonglong value= (ulonglong) args[0]->val_int();
-  if (args[0]->null_value)
-  {
-    null_value=1; /* purecov: inspected */
+  if ((null_value= args[0]->null_value))
     return 0; /* purecov: inspected */
-  }
   return (longlong) my_count_bits(value);
 }
 
diff --git a/sql/item_func.h b/sql/item_func.h
index 2c4976d1152..51f9d3fb36f 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -1056,16 +1056,13 @@ public:
     if (!master && ft_handler)
     {
       ft_handler->please->close_search(ft_handler);
-      ft_handler=0;
-      if (join_key)
-	table->file->ft_handler=0;
-      table->fulltext_searched=0;
     }
     if (concat)
     {
       delete concat;
       concat= 0;
     }
+    ft_handler= 0;
     DBUG_VOID_RETURN;
   }
   enum Functype functype() const { return FT_FUNC; }
diff --git a/sql/item_row.cc b/sql/item_row.cc
index 12d202a1699..493eefc9ff0 100644
--- a/sql/item_row.cc
+++ b/sql/item_row.cc
@@ -26,7 +26,7 @@
 */
 
 Item_row::Item_row(List<Item> &arg):
-  Item(), used_tables_cache(0), array_holder(1), const_item_cache(1), with_null(0)
+  Item(), used_tables_cache(0), const_item_cache(1), with_null(0)
 {
 
   //TODO: think placing 2-3 component items in item (as it done for function)
@@ -85,6 +85,20 @@ bool Item_row::fix_fields(THD *thd, TABLE_LIST *tabl, Item **ref)
 }
 
 
+void Item_row::cleanup()
+{
+  DBUG_ENTER("Item_row::cleanup");
+
+  Item::cleanup();
+  /* Reset to the original values */
+  used_tables_cache= 0;
+  const_item_cache= 1;
+  with_null= 0;
+
+  DBUG_VOID_RETURN;
+}
+
+
 void Item_row::split_sum_func(THD *thd, Item **ref_pointer_array,
                               List<Item> &fields)
 {
diff --git a/sql/item_row.h b/sql/item_row.h
index 39bc4513e1e..28cb47b6815 100644
--- a/sql/item_row.h
+++ b/sql/item_row.h
@@ -19,7 +19,6 @@ class Item_row: public Item
   Item **items;
   table_map used_tables_cache;
   uint arg_count;
-  bool array_holder;
   bool const_item_cache;
   bool with_null;
 public:
@@ -29,7 +28,6 @@ public:
     items(item->items),
     used_tables_cache(item->used_tables_cache),
     arg_count(item->arg_count),
-    array_holder(0), 
     const_item_cache(item->const_item_cache),
     with_null(0)
   {}
@@ -57,6 +55,7 @@ public:
     return 0;
   };
   bool fix_fields(THD *thd, TABLE_LIST *tables, Item **ref);
+  void cleanup();
   void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
   table_map used_tables() const { return used_tables_cache; };
   bool const_item() const { return const_item_cache; };
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 43468adea1a..4b522cf06fa 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -1185,6 +1185,7 @@ void Item_sum_count_distinct::make_unique()
   original= 0;
   use_tree= 0; // to prevent delete_tree call on uninitialized tree
   tree= &tree_base;
+  force_copy_fields= 1;
 }
 
 
@@ -1219,6 +1220,7 @@ bool Item_sum_count_distinct::setup(THD *thd)
     free_tmp_table(thd, table);
     tmp_table_param->cleanup();
   }
+  tmp_table_param->force_copy_fields= force_copy_fields;
   if (!(table= create_tmp_table(thd, tmp_table_param, list, (ORDER*) 0, 1,
 				0,
 				select_lex->options | thd->options,
@@ -1724,6 +1726,7 @@ Item_func_group_concat::Item_func_group_concat(bool is_distinct,
 					       String *is_separator)
   :Item_sum(), tmp_table_param(0), max_elements_in_tree(0), warning(0),
    key_length(0), tree_mode(0), distinct(is_distinct), warning_for_row(0),
+   force_copy_fields(0),
    separator(is_separator), tree(&tree_base), table(0),
    order(0), tables_list(0),
    arg_count_order(0), arg_count_field(0),
@@ -1785,6 +1788,7 @@ Item_func_group_concat::Item_func_group_concat(THD *thd,
   tree_mode(item->tree_mode),
   distinct(item->distinct),
   warning_for_row(item->warning_for_row),
+  force_copy_fields(item->force_copy_fields),
   separator(item->separator),
   tree(item->tree),
   table(item->table),
@@ -2004,6 +2008,7 @@ bool Item_func_group_concat::setup(THD *thd)
     free_tmp_table(thd, table);
     tmp_table_param->cleanup();
   }
+  tmp_table_param->force_copy_fields= force_copy_fields;
   /*
     We have to create a temporary table to get descriptions of fields 
     (types, sizes and so on).
@@ -2079,6 +2084,7 @@ void Item_func_group_concat::make_unique()
   original= 0;
   tree_mode= 0; // to prevent delete_tree call on uninitialized tree
   tree= &tree_base;
+  force_copy_fields= 1;
 }
 
 
diff --git a/sql/item_sum.h b/sql/item_sum.h
index d53d8d861ae..c972240fcba 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -185,6 +185,7 @@ class Item_sum_count_distinct :public Item_sum_int
   TMP_TABLE_PARAM *tmp_table_param;
   TREE tree_base;
   TREE *tree;
+  bool force_copy_fields;
   /*
     Following is 0 normal object and pointer to original one for copy 
     (to correctly free resources)
@@ -226,15 +227,16 @@ class Item_sum_count_distinct :public Item_sum_int
   public:
   Item_sum_count_distinct(List<Item> &list)
     :Item_sum_int(list), table(0), used_table_cache(~(table_map) 0),
-     tmp_table_param(0), tree(&tree_base), original(0), use_tree(0),
-     always_null(0)
+     tmp_table_param(0), tree(&tree_base), force_copy_fields(0), original(0),
+     use_tree(0), always_null(0)
   { quick_group= 0; }
   Item_sum_count_distinct(THD *thd, Item_sum_count_distinct *item)
     :Item_sum_int(thd, item), table(item->table),
      used_table_cache(item->used_table_cache),
      field_lengths(item->field_lengths),
      tmp_table_param(item->tmp_table_param),
-     tree(item->tree), original(item), key_length(item->key_length),
+     tree(item->tree), force_copy_fields(item->force_copy_fields),
+     original(item), key_length(item->key_length),
      max_elements_in_tree(item->max_elements_in_tree),
      rec_offset(item->rec_offset), use_tree(item->use_tree),
      always_null(item->always_null)
@@ -685,6 +687,7 @@ class Item_func_group_concat : public Item_sum
   bool distinct;
   bool warning_for_row;
   bool always_null;
+  bool force_copy_fields;
 
   friend int group_concat_key_cmp_with_distinct(void* arg, byte* key1,
 					      byte* key2);
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 3f545df5776..19c32b2d28e 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -949,6 +949,7 @@ Query_log_event::Query_log_event(const char* buf, int event_len,
 void Query_log_event::print(FILE* file, bool short_form, char* last_db)
 {
   char buff[40],*end;				// Enough for SET TIMESTAMP
+  const uint set_len= sizeof("SET ONE_SHOT CHARACTER_SET_CLIENT=") - 1;
   if (!short_form)
   {
     print_header(file);
@@ -978,6 +979,17 @@ void Query_log_event::print(FILE* file, bool short_form, char* last_db)
   my_fwrite(file, (byte*) buff, (uint) (end-buff),MYF(MY_NABP | MY_WME));
   if (flags & LOG_EVENT_THREAD_SPECIFIC_F)
     fprintf(file,"SET @@session.pseudo_thread_id=%lu;\n",(ulong)thread_id);
+  /* charset_name command for mysql client */
+  if (!strncmp(query, "SET ONE_SHOT CHARACTER_SET_CLIENT=", set_len))
+  {
+    char * endptr;
+    int cs_number= strtoul(query + set_len, &endptr, 10);
+    DBUG_ASSERT(*endptr == ',');
+    CHARSET_INFO *cs_info= get_charset(cs_number, MYF(MY_WME));
+    if (cs_info) {
+      fprintf(file, "/*!\\C %s */;\n", cs_info->csname);
+    }
+  }
   my_fwrite(file, (byte*) query, q_len, MYF(MY_NABP | MY_WME));
   fprintf(file, ";\n");
 }
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 429a71b4437..6676d994cfa 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -537,8 +537,9 @@ int mysql_union(THD *thd, LEX *lex, select_result *result,
 		SELECT_LEX_UNIT *unit);
 int mysql_handle_derived(LEX *lex);
 Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
-			Item ***copy_func, Field **from_field,
-			bool group, bool modify_item, uint convert_blob_length);
+                        Item ***copy_func, Field **from_field,
+                        bool group, bool modify_item, uint convert_blob_length,
+                        bool make_copy_field);
 int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
 		       List<create_field> &fields,
 		       List<Key> &keys, uint &db_options, 
@@ -917,6 +918,7 @@ extern ulong ha_commit_count, ha_rollback_count,table_cache_size;
 extern ulong max_connections,max_connect_errors, connect_timeout;
 extern ulong slave_net_timeout, slave_trans_retries;
 extern ulong max_user_connections;
+extern ulong max_prepared_stmt_count, prepared_stmt_count;
 extern ulong long_query_count, what_to_log,flush_time;
 extern ulong query_buff_size, thread_stack,thread_stack_min;
 extern ulong binlog_cache_size, max_binlog_cache_size, open_files_limit;
@@ -960,7 +962,8 @@ extern pthread_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open,
        LOCK_error_log, LOCK_delayed_insert, LOCK_uuid_generator,
        LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,
        LOCK_slave_list, LOCK_active_mi, LOCK_manager,
-       LOCK_global_system_variables, LOCK_user_conn;
+       LOCK_global_system_variables, LOCK_user_conn,
+       LOCK_prepared_stmt_count;
 #ifdef HAVE_OPENSSL
 extern pthread_mutex_t LOCK_des_key_file;
 #endif
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index cce48cc0d54..e68762868a4 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -336,6 +336,22 @@ ulong specialflag=0,opened_tables=0,created_tmp_tables=0,
 ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;
 ulong max_connections,max_used_connections,
       max_connect_errors, max_user_connections = 0;
+/*
+  Limit of the total number of prepared statements in the server.
+  Is necessary to protect the server against out-of-memory attacks.
+*/
+ulong max_prepared_stmt_count;
+/*
+  Current total number of prepared statements in the server. This number
+  is exact, and therefore may not be equal to the difference between
+  `com_stmt_prepare' and `com_stmt_close' (global status variables), as
+  the latter ones account for all registered attempts to prepare
+  a statement (including unsuccessful ones).  Prepared statements are
+  currently connection-local: if the same SQL query text is prepared in
+  two different connections, this counts as two distinct prepared
+  statements.
+*/
+ulong prepared_stmt_count=0;
 ulong thread_id=1L,current_pid;
 ulong slow_launch_threads = 0, sync_binlog_period;
 ulong expire_logs_days = 0;
@@ -421,6 +437,14 @@ pthread_mutex_t LOCK_mysql_create_db, LOCK_Acl, LOCK_open, LOCK_thread_count,
 		LOCK_crypt, LOCK_bytes_sent, LOCK_bytes_received,
 	        LOCK_global_system_variables,
 		LOCK_user_conn, LOCK_slave_list, LOCK_active_mi;
+/*
+  The below lock protects access to two global server variables:
+  max_prepared_stmt_count and prepared_stmt_count. These variables
+  set the limit and hold the current total number of prepared statements
+  in the server, respectively. As PREPARE/DEALLOCATE rate in a loaded
+  server may be fairly high, we need a dedicated lock.
+*/
+pthread_mutex_t LOCK_prepared_stmt_count;
 #ifdef HAVE_OPENSSL
 pthread_mutex_t LOCK_des_key_file;
 #endif
@@ -1118,6 +1142,7 @@ static void clean_up_mutexes()
   (void) rwlock_destroy(&LOCK_sys_init_connect);
   (void) rwlock_destroy(&LOCK_sys_init_slave);
   (void) pthread_mutex_destroy(&LOCK_global_system_variables);
+  (void) pthread_mutex_destroy(&LOCK_prepared_stmt_count);
   (void) pthread_cond_destroy(&COND_thread_count);
   (void) pthread_cond_destroy(&COND_refresh);
   (void) pthread_cond_destroy(&COND_thread_cache);
@@ -2635,6 +2660,7 @@ static int init_thread_environment()
   (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
   (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
   (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
+  (void) pthread_mutex_init(&LOCK_prepared_stmt_count, MY_MUTEX_INIT_FAST);
   (void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
 #ifdef HAVE_OPENSSL
   (void) pthread_mutex_init(&LOCK_des_key_file,MY_MUTEX_INIT_FAST);
@@ -4238,7 +4264,8 @@ enum options_mysqld
   OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,
   OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,
   OPT_MAX_DELAYED_THREADS, OPT_MAX_HEP_TABLE_SIZE,
-  OPT_MAX_JOIN_SIZE, OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH, 
+  OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,
+  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,
   OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
   OPT_MAX_LENGTH_FOR_SORT_DATA,
   OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,
@@ -5225,6 +5252,10 @@ The minimum value for this variable is 4096.",
     (gptr*) &global_system_variables.max_length_for_sort_data,
     (gptr*) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
     REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
+  {"max_prepared_stmt_count", OPT_MAX_PREPARED_STMT_COUNT,
+   "Maximum numbrer of prepared statements in the server.",
+   (gptr*) &max_prepared_stmt_count, (gptr*) &max_prepared_stmt_count,
+   0, GET_ULONG, REQUIRED_ARG, 16382, 0, 1*1024*1024, 0, 1, 0},
   {"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,
    "If non-zero: relay log will be rotated automatically when the size exceeds this value; if zero (the default): when the size exceeds max_binlog_size. 0 excepted, the minimum value for this variable is 4096.",
    (gptr*) &max_relay_log_size, (gptr*) &max_relay_log_size, 0, GET_ULONG,
diff --git a/sql/set_var.cc b/sql/set_var.cc
index e10bfda62b7..681c70c4c02 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -118,6 +118,7 @@ static KEY_CACHE *create_key_cache(const char *name, uint length);
 void fix_sql_mode_var(THD *thd, enum_var_type type);
 static byte *get_error_count(THD *thd);
 static byte *get_warning_count(THD *thd);
+static byte *get_prepared_stmt_count(THD *thd);
 static byte *get_have_innodb(THD *thd);
 
 /*
@@ -239,6 +240,10 @@ sys_var_thd_ha_rows	sys_sql_max_join_size("sql_max_join_size",
 					      &SV::max_join_size,
 					      fix_max_join_size);
 #endif
+static sys_var_long_ptr_global
+sys_max_prepared_stmt_count("max_prepared_stmt_count",
+                            &max_prepared_stmt_count,
+                            &LOCK_prepared_stmt_count);
 sys_var_long_ptr	sys_max_relay_log_size("max_relay_log_size",
                                                &max_relay_log_size,
                                                fix_max_relay_log_size);
@@ -472,6 +477,9 @@ static sys_var_readonly		sys_warning_count("warning_count",
 						  OPT_SESSION,
 						  SHOW_LONG,
 						  get_warning_count);
+static sys_var_readonly	sys_prepared_stmt_count("prepared_stmt_count",
+                                                OPT_GLOBAL, SHOW_LONG,
+                                                get_prepared_stmt_count);
 
 /* alias for last_insert_id() to be compatible with Sybase */
 #ifdef HAVE_REPLICATION
@@ -569,6 +577,7 @@ sys_var *sys_variables[]=
   &sys_max_heap_table_size,
   &sys_max_join_size,
   &sys_max_length_for_sort_data,
+  &sys_max_prepared_stmt_count,
   &sys_max_relay_log_size,
   &sys_max_seeks_for_key,
   &sys_max_sort_length,
@@ -589,6 +598,7 @@ sys_var *sys_variables[]=
   &sys_new_mode,
   &sys_old_passwords,
   &sys_preload_buff_size,
+  &sys_prepared_stmt_count,
   &sys_pseudo_thread_id,
   &sys_query_alloc_block_size,
   &sys_query_cache_size,
@@ -801,6 +811,8 @@ struct show_var_st init_vars[]= {
   {sys_max_join_size.name,	(char*) &sys_max_join_size,	    SHOW_SYS},
   {sys_max_length_for_sort_data.name, (char*) &sys_max_length_for_sort_data,
    SHOW_SYS},
+  {sys_max_prepared_stmt_count.name, (char*) &sys_max_prepared_stmt_count,
+    SHOW_SYS},
   {sys_max_relay_log_size.name, (char*) &sys_max_relay_log_size,    SHOW_SYS},
   {sys_max_seeks_for_key.name,  (char*) &sys_max_seeks_for_key,	    SHOW_SYS},
   {sys_max_sort_length.name,	(char*) &sys_max_sort_length,	    SHOW_SYS},
@@ -838,6 +850,7 @@ struct show_var_st init_vars[]= {
   {sys_old_passwords.name,    (char*) &sys_old_passwords,           SHOW_SYS},
   {"open_files_limit",	      (char*) &open_files_limit,	    SHOW_LONG},
   {"pid_file",                (char*) pidfile_name,                 SHOW_CHAR},
+  {sys_prepared_stmt_count.name, (char*) &sys_prepared_stmt_count, SHOW_SYS},
   {"port",                    (char*) &mysqld_port,                  SHOW_INT},
   {sys_preload_buff_size.name, (char*) &sys_preload_buff_size,      SHOW_SYS},
   {"protocol_version",        (char*) &protocol_version,            SHOW_INT},
@@ -1251,29 +1264,40 @@ static void fix_server_id(THD *thd, enum_var_type type)
   server_id_supplied = 1;
 }
 
-bool sys_var_long_ptr::check(THD *thd, set_var *var)
+
+sys_var_long_ptr::
+sys_var_long_ptr(const char *name_arg, ulong *value_ptr,
+                 sys_after_update_func after_update_arg)
+  :sys_var_long_ptr_global(name_arg, value_ptr,
+                           &LOCK_global_system_variables, after_update_arg)
+{}
+
+
+bool sys_var_long_ptr_global::check(THD *thd, set_var *var)
 {
   longlong v= var->value->val_int();
   var->save_result.ulonglong_value= v < 0 ? 0 : v;
   return 0;
 }
 
-bool sys_var_long_ptr::update(THD *thd, set_var *var)
+bool sys_var_long_ptr_global::update(THD *thd, set_var *var)
 {
   ulonglong tmp= var->save_result.ulonglong_value;
-  pthread_mutex_lock(&LOCK_global_system_variables);
+  pthread_mutex_lock(guard);
   if (option_limits)
     *value= (ulong) getopt_ull_limit_value(tmp, option_limits);
   else
     *value= (ulong) tmp;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
+  pthread_mutex_unlock(guard);
   return 0;
 }
 
 
-void sys_var_long_ptr::set_default(THD *thd, enum_var_type type)
+void sys_var_long_ptr_global::set_default(THD *thd, enum_var_type type)
 {
+  pthread_mutex_lock(guard);
   *value= (ulong) option_limits->def_value;
+  pthread_mutex_unlock(guard);
 }
 
 
@@ -2642,6 +2666,14 @@ static byte *get_have_innodb(THD *thd)
 }
 
 
+static byte *get_prepared_stmt_count(THD *thd)
+{
+  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  thd->sys_var_tmp.ulong_value= prepared_stmt_count;
+  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+  return (byte*) &thd->sys_var_tmp.ulong_value;
+}
+
 /****************************************************************************
   Main handling of variables:
   - Initialisation
diff --git a/sql/set_var.h b/sql/set_var.h
index 2ac4fc2c260..c6319a79cf6 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -47,13 +47,7 @@ public:
 #if MYSQL_VERSION_ID < 50000
   bool no_support_one_shot;
 #endif
-  sys_var(const char *name_arg)
-    :name(name_arg), after_update(0)
-#if MYSQL_VERSION_ID < 50000
-    , no_support_one_shot(1)
-#endif
-    {}
-  sys_var(const char *name_arg,sys_after_update_func func)
+  sys_var(const char *name_arg, sys_after_update_func func= NULL)
     :name(name_arg), after_update(func)
 #if MYSQL_VERSION_ID < 50000
     , no_support_one_shot(1)
@@ -79,15 +73,35 @@ public:
 };
 
 
-class sys_var_long_ptr :public sys_var
+/*
+  A base class for all variables that require its access to
+  be guarded with a mutex.
+*/
+
+class sys_var_global: public sys_var
+{
+protected:
+  pthread_mutex_t *guard;
+public:
+  sys_var_global(const char *name_arg, sys_after_update_func after_update_arg,
+                 pthread_mutex_t *guard_arg)
+    :sys_var(name_arg, after_update_arg), guard(guard_arg) {}
+};
+
+
+/*
+  A global-only ulong variable that requires its access to be
+  protected with a mutex.
+*/
+
+class sys_var_long_ptr_global: public sys_var_global
 {
 public:
   ulong *value;
-  sys_var_long_ptr(const char *name_arg, ulong *value_ptr)
-    :sys_var(name_arg),value(value_ptr) {}
-  sys_var_long_ptr(const char *name_arg, ulong *value_ptr,
-		   sys_after_update_func func)
-    :sys_var(name_arg,func), value(value_ptr) {}
+  sys_var_long_ptr_global(const char *name_arg, ulong *value_ptr,
+                        pthread_mutex_t *guard_arg,
+                        sys_after_update_func after_update_arg= NULL)
+    :sys_var_global(name_arg, after_update_arg, guard_arg), value(value_ptr) {}
   bool check(THD *thd, set_var *var);
   bool update(THD *thd, set_var *var);
   void set_default(THD *thd, enum_var_type type);
@@ -97,6 +111,18 @@ public:
 };
 
 
+/*
+  A global ulong variable that is protected by LOCK_global_system_variables
+*/
+
+class sys_var_long_ptr :public sys_var_long_ptr_global
+{
+public:
+  sys_var_long_ptr(const char *name_arg, ulong *value_ptr,
+                   sys_after_update_func after_update_arg= NULL);
+};
+
+
 class sys_var_ulonglong_ptr :public sys_var
 {
 public:
@@ -175,7 +201,7 @@ class sys_var_const_str :public sys_var
 public:
   char *value;					// Pointer to const value
   sys_var_const_str(const char *name_arg, const char *value_arg)
-    :sys_var(name_arg), value((char*) value_arg)
+    :sys_var(name_arg),value((char*) value_arg)
   {}
   bool check(THD *thd, set_var *var)
   {
@@ -221,10 +247,7 @@ public:
 class sys_var_thd :public sys_var
 {
 public:
-  sys_var_thd(const char *name_arg)
-    :sys_var(name_arg)
-  {}
-  sys_var_thd(const char *name_arg, sys_after_update_func func)
+  sys_var_thd(const char *name_arg, sys_after_update_func func= NULL)
     :sys_var(name_arg,func)
   {}
   bool check_type(enum_var_type type) { return 0; }
diff --git a/sql/share/charsets/Index.xml b/sql/share/charsets/Index.xml
index ff74de9a02d..97fc27e1431 100644
--- a/sql/share/charsets/Index.xml
+++ b/sql/share/charsets/Index.xml
@@ -115,7 +115,10 @@ To make maintaining easier please:
   <alias>l1</alias>
   <alias>latin1</alias>
   <collation name="latin1_german1_ci"	id="5"	order="German Duden"/>
-  <collation name="latin1_swedish_ci"	id="8"	order="Finnish, Swedish"	flag="primary"/>
+  <collation name="latin1_swedish_ci"	id="8"	order="Finnish, Swedish">
+    <flag>primary</flag>
+    <flag>compiled</flag>
+  </collation>
   <collation name="latin1_danish_ci"	id="15"	order="Danish"/>
   <collation name="latin1_german2_ci"	id="31"	order="German Phonebook"	flag="compiled"/>
   <collation name="latin1_spanish_ci"	id="94"	order="Spanish"/>
diff --git a/sql/share/charsets/latin1.xml b/sql/share/charsets/latin1.xml
index 0b6f54dc800..5814a17b0e1 100644
--- a/sql/share/charsets/latin1.xml
+++ b/sql/share/charsets/latin1.xml
@@ -33,14 +33,14 @@
  01 01 01 01 01 01 01 01 01 01 01 10 10 10 10 10
  10 82 82 82 82 82 82 02 02 02 02 02 02 02 02 02
  02 02 02 02 02 02 02 02 02 02 02 10 10 10 10 20
- 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20
- 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20
- 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
- 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+ 10 00 10 02 10 10 10 10 10 10 01 10 01 00 01 00
+ 00 10 10 10 10 10 10 10 10 10 02 10 02 00 02 01
+ 48 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10
+ 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10
  01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
- 01 01 01 01 01 01 01 00 01 01 01 01 01 01 01 02
+ 01 01 01 01 01 01 01 10 01 01 01 01 01 01 01 02
  02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02
- 02 02 02 02 02 02 02 00 02 02 02 02 02 02 02 02
+ 02 02 02 02 02 02 02 10 02 02 02 02 02 02 02 02
 </map>
 </ctype>
 
@@ -99,8 +99,8 @@
  0050 0051 0052 0053 0054 0055 0056 0057 0058 0059 005A 005B 005C 005D 005E 005F
  0060 0061 0062 0063 0064 0065 0066 0067 0068 0069 006A 006B 006C 006D 006E 006F
  0070 0071 0072 0073 0074 0075 0076 0077 0078 0079 007A 007B 007C 007D 007E 007F
- 0080 0081 0082 0083 0084 0085 0086 0087 0088 0089 008A 008B 008C 008D 008E 008F
- 0090 0091 0092 0093 0094 0095 0096 0097 0098 0099 009A 009B 009C 009D 009E 009F
+ 20AC 0081 201A 0192 201E 2026 2020 2021 02C6 2030 0160 2039 0152 008D 017D 008F
+ 0090 2018 2019 201C 201D 2022 2013 2014 02DC 2122 0161 203A 0153 009D 017E 0178
  00A0 00A1 00A2 00A3 00A4 00A5 00A6 00A7 00A8 00A9 00AA 00AB 00AC 00AD 00AE 00AF
  00B0 00B1 00B2 00B3 00B4 00B5 00B6 00B7 00B8 00B9 00BA 00BB 00BC 00BD 00BE 00BF
  00C0 00C1 00C2 00C3 00C4 00C5 00C6 00C7 00C8 00C9 00CA 00CB 00CC 00CD 00CE 00CF
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index c1847d010c5..4626e5892a4 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -2001,7 +2001,10 @@ static GRANT_TABLE *table_hash_search(const char *host,const char* ip,
   {
     if (exact)
     {
-      if (compare_hostname(&grant_table->host, host, ip))
+      if ((host &&
+	   !my_strcasecmp(system_charset_info, host,
+                          grant_table->host.hostname)) ||
+	  (ip && !strcmp(ip, grant_table->host.hostname)))
 	return grant_table;
     }
     else
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index ea013bb4e1e..223e8482f49 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -988,6 +988,8 @@ TABLE *open_table(THD *thd,const char *db,const char *table_name,
   table->status=STATUS_NO_RECORD;
   table->keys_in_use_for_query= table->keys_in_use;
   table->used_keys= table->keys_for_keyread;
+  table->file->ft_handler=0;
+  table->fulltext_searched=0;
   if (table->timestamp_field)
     table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
   DBUG_ASSERT(table->key_read == 0);
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index ef938a13489..d278ebe8dfa 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -1616,27 +1616,128 @@ Statement_map::Statement_map() :
             NULL,MYF(0));
 }
 
-int Statement_map::insert(Statement *statement)
+/*
+  Insert a new statement to the thread-local statement map.
+
+  DESCRIPTION
+    If there was an old statement with the same name, replace it with the
+    new one. Otherwise, check if max_prepared_stmt_count is not reached yet,
+    increase prepared_stmt_count, and insert the new statement. It's okay
+    to delete an old statement and fail to insert the new one.
+
+  POSTCONDITIONS
+    All named prepared statements are also present in names_hash.
+    Statement names in names_hash are unique.
+    The statement is added only if prepared_stmt_count < max_prepard_stmt_count
+    last_found_statement always points to a valid statement or is 0
+
+  RETURN VALUE
+    0  success
+    1  error: out of resources or max_prepared_stmt_count limit has been
+       reached. An error is sent to the client, the statement is deleted.
+*/
+
+int Statement_map::insert(THD *thd, Statement *statement)
 {
-  int rc= my_hash_insert(&st_hash, (byte *) statement);
-  if (rc == 0)
-    last_found_statement= statement;
+  if (my_hash_insert(&st_hash, (byte*) statement))
+  {
+    /*
+      Delete is needed only in case of an insert failure. In all other
+      cases hash_delete will also delete the statement.
+    */
+    delete statement;
+    my_error(ER_OUT_OF_RESOURCES, MYF(0));
+    goto err_st_hash;
+  }
   if (statement->name.str)
   {
     /*
-      If there is a statement with the same name, remove it. It is ok to 
+      If there is a statement with the same name, remove it. It is ok to
       remove old and fail to insert new one at the same time.
     */
     Statement *old_stmt;
     if ((old_stmt= find_by_name(&statement->name)))
-      erase(old_stmt); 
-    if ((rc= my_hash_insert(&names_hash, (byte*)statement)))
-      hash_delete(&st_hash, (byte*)statement);
+      erase(old_stmt);
+    if (my_hash_insert(&names_hash, (byte*) statement))
+    {
+      my_error(ER_OUT_OF_RESOURCES, MYF(0));
+      goto err_names_hash;
+    }
+  }
+  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  /*
+    We don't check that prepared_stmt_count is <= max_prepared_stmt_count
+    because we would like to allow to lower the total limit
+    of prepared statements below the current count. In that case
+    no new statements can be added until prepared_stmt_count drops below
+    the limit.
+  */
+  if (prepared_stmt_count >= max_prepared_stmt_count)
+  {
+    pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+    my_error(ER_UNKNOWN_ERROR, MYF(0));
+    goto err_max;
   }
-  return rc;
+  prepared_stmt_count++;
+  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+
+  last_found_statement= statement;
+  return 0;
+
+err_max:
+  if (statement->name.str)
+    hash_delete(&names_hash, (byte*) statement);
+err_names_hash:
+  hash_delete(&st_hash, (byte*) statement);
+err_st_hash:
+  send_error(thd);
+  return 1;
 }
 
 
+void Statement_map::erase(Statement *statement)
+{
+  if (statement == last_found_statement)
+    last_found_statement= 0;
+  if (statement->name.str)
+  {
+    hash_delete(&names_hash, (byte *) statement);
+  }
+  hash_delete(&st_hash, (byte *) statement);
+  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  DBUG_ASSERT(prepared_stmt_count > 0);
+  prepared_stmt_count--;
+  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+}
+
+
+void Statement_map::reset()
+{
+  /* Must be first, hash_free will reset st_hash.records */
+  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  DBUG_ASSERT(prepared_stmt_count >= st_hash.records);
+  prepared_stmt_count-= st_hash.records;
+  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+
+  my_hash_reset(&names_hash);
+  my_hash_reset(&st_hash);
+  last_found_statement= 0;
+}
+
+
+Statement_map::~Statement_map()
+{
+  /* Must go first, hash_free will reset st_hash.records */
+  pthread_mutex_lock(&LOCK_prepared_stmt_count);
+  DBUG_ASSERT(prepared_stmt_count >= st_hash.records);
+  prepared_stmt_count-= st_hash.records;
+  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
+
+  hash_free(&names_hash);
+  hash_free(&st_hash);
+
+}
+
 bool select_dumpvar::send_data(List<Item> &items)
 {
   List_iterator_fast<Item_func_set_user_var> li(vars);
@@ -1681,7 +1782,10 @@ bool select_dumpvar::send_eof()
 
 void TMP_TABLE_PARAM::init()
 {
+  DBUG_ENTER("TMP_TABLE_PARAM::init");
+  DBUG_PRINT("enter", ("this: 0x%lx", (ulong)this));
   field_count= sum_func_count= func_count= hidden_field_count= 0;
   group_parts= group_length= group_null_parts= 0;
   quick_group= 1;
+  DBUG_VOID_RETURN;
 }
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 41170192892..d482a524934 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -620,7 +620,7 @@ class Statement_map
 public:
   Statement_map();
 
-  int insert(Statement *statement);
+  int insert(THD *thd, Statement *statement);
 
   Statement *find_by_name(LEX_STRING *name)
   {
@@ -642,29 +642,10 @@ public:
     }
     return last_found_statement;
   }
-  void erase(Statement *statement)
-  {
-    if (statement == last_found_statement)
-      last_found_statement= 0;
-    if (statement->name.str)
-    {
-      hash_delete(&names_hash, (byte *) statement);  
-    }
-    hash_delete(&st_hash, (byte *) statement);
-  }
+  void erase(Statement *statement);
   /* Erase all statements (calls Statement destructor) */
-  void reset()
-  {
-    my_hash_reset(&names_hash);
-    my_hash_reset(&st_hash);
-    last_found_statement= 0;
-  }
-
-  ~Statement_map()
-  {
-    hash_free(&names_hash);
-    hash_free(&st_hash);
-  }
+  void reset();
+  ~Statement_map();
 private:
   HASH st_hash;
   HASH names_hash;
@@ -932,6 +913,7 @@ public:
   {
     my_bool my_bool_value;
     long    long_value;
+    ulong   ulong_value;
   } sys_var_tmp;
 
   THD();
@@ -1334,10 +1316,11 @@ public:
   bool  using_indirect_summary_function;
   /* If >0 convert all blob fields to varchar(convert_blob_length) */
   uint  convert_blob_length; 
-
+  bool force_copy_fields;
   TMP_TABLE_PARAM()
     :copy_field(0), group_parts(0),
-    group_length(0), group_null_parts(0), convert_blob_length(0)
+    group_length(0), group_null_parts(0), convert_blob_length(0),
+    force_copy_fields(0)
   {}
   ~TMP_TABLE_PARAM()
   {
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 7c834c91183..035a0b22a6b 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -388,6 +388,12 @@ bool load_db_opt(THD *thd, const char *path, HA_CREATE_INFO *create)
   silent	Used by replication when internally creating a database.
 		In this case the entry should not be logged.
 
+  SIDE-EFFECTS
+   1. Report back to client that command succeeded (send_ok)
+   2. Report errors to client
+   3. Log event to binary log
+   (The 'silent' flags turns off 1 and 3.)
+
   RETURN VALUES
   0	ok
   -1	Error
@@ -421,16 +427,17 @@ int mysql_create_db(THD *thd, char *db, HA_CREATE_INFO *create_info,
 
   if (my_stat(path,&stat_info,MYF(0)))
   {
-   if (!(create_options & HA_LEX_CREATE_IF_NOT_EXISTS))
+    if (!(create_options & HA_LEX_CREATE_IF_NOT_EXISTS))
     {
       my_error(ER_DB_CREATE_EXISTS,MYF(0),db);
       error= -1;
       goto exit;
     }
     push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
-                        ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS), db);
+			ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS), db);
+    if (!silent)
+      send_ok(thd);
     error= 0;
-    send_ok(thd);
     goto exit;
   }
   else
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index 203173f52f4..b085d37be78 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -641,6 +641,8 @@ int mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
     strmov(path,table->path);
     *table_ptr= table->next;			// Unlink table from list
     close_temporary(table,0);
+    if (thd->slave_thread)
+      --slave_open_temp_tables;
     *fn_ext(path)=0;				// Remove the .frm extension
     ha_create_table(path, &create_info,1);
     // We don't need to call invalidate() because this table is not in cache
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index aa4ea3e6c8c..4e6c458cc43 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -285,8 +285,11 @@ int mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list,
     else
       error=read_sep_field(thd,info,table,fields,read_info,*enclosed,
 			   skip_lines);
-    if (table->file->end_bulk_insert())
-      error=1;					/* purecov: inspected */
+    if (table->file->end_bulk_insert() && !error)
+    {
+      table->file->print_error(my_errno, MYF(0));
+      error= 1;
+    }
     table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
     table->next_number_field=0;
   }
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 90de630da60..21a335637b9 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -2840,21 +2840,26 @@ unsent_create_error:
     if ((res= multi_update_precheck(thd, tables)))
       break;
 
-    if ((res= mysql_multi_update_lock(thd, tables, &select_lex->item_list,
-				      select_lex)))
-      break;
-
+    res= mysql_multi_update_lock(thd, tables, &select_lex->item_list,
+                                 select_lex);
 #ifdef HAVE_REPLICATION
     /* Check slave filtering rules */
     if (thd->slave_thread)
       if (all_tables_not_ok(thd,tables))
       {
+        if (res!= 0)
+        {
+          res= 0;             /* don't care of prev failure  */
+          thd->clear_error(); /* filters are of highest prior */
+        }
 	/* we warn the slave SQL thread */
 	my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
 	break;
       }
 #endif /* HAVE_REPLICATION */
-
+    if (res)
+      break;
+    
     res= mysql_multi_update(thd,tables,
 			    &select_lex->item_list,
 			    &lex->value_list,
@@ -4475,6 +4480,7 @@ bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
 						  NOT_FIXED_DEC-1) : 0;
   new_field->sql_type=type;
   new_field->length=0;
+  new_field->char_length= 0;
   new_field->change=change;
   new_field->interval=0;
   new_field->pack_length=0;
@@ -4745,6 +4751,7 @@ bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
 					    FIELD_TYPE_STRING :
 					    new_field->sql_type,
 					    new_field->length);
+  new_field->char_length= new_field->length;
   lex->create_list.push_back(new_field);
   lex->last_field=new_field;
   DBUG_RETURN(0);
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index 8a50d0bd50e..741d84eab44 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -1593,10 +1593,12 @@ int mysql_stmt_prepare(THD *thd, char *packet, uint packet_length,
     }
   }
 
-  if (thd->stmt_map.insert(stmt))
+  if (thd->stmt_map.insert(thd, stmt))
   {
-    delete stmt;
-    send_error(thd, ER_OUT_OF_RESOURCES);
+    /*
+      The error is sent in the insert. The statement itself
+      will be also deleted there (this is how the hash works).
+    */
     DBUG_RETURN(1);
   }
 
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 1b09913dcc8..d7aa617cffd 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -4107,6 +4107,20 @@ JOIN::join_free(bool full)
       problems in free_elements() as some of the elements are then deleted.
     */
     tmp_table_param.copy_funcs.empty();
+    /*
+      If we have tmp_join and 'this' JOIN is not tmp_join and
+      tmp_table_param.copy_field's  of them are equal then we have to remove
+      pointer to  tmp_table_param.copy_field from tmp_join, because it qill
+      be removed in tmp_table_param.cleanup().
+    */
+    if (tmp_join &&
+        tmp_join != this &&
+        tmp_join->tmp_table_param.copy_field ==
+        tmp_table_param.copy_field)
+    {
+      tmp_join->tmp_table_param.copy_field=
+        tmp_join->tmp_table_param.save_copy_field= 0;
+    }
     tmp_table_param.cleanup();
   }
   DBUG_VOID_RETURN;
@@ -4970,7 +4984,8 @@ static Field* create_tmp_field_from_item(THD *thd, Item *item, TABLE *table,
 
 Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
                         Item ***copy_func, Field **from_field,
-                        bool group, bool modify_item, uint convert_blob_length)
+                        bool group, bool modify_item, uint convert_blob_length,
+                        bool make_copy_field)
 {
   switch (type) {
   case Item::SUM_FUNC_ITEM:
@@ -5057,7 +5072,13 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
   case Item::REF_ITEM:
   case Item::NULL_ITEM:
   case Item::VARBIN_ITEM:
-    return create_tmp_field_from_item(thd, item, table, copy_func, modify_item,
+    if (make_copy_field)
+    {
+      DBUG_ASSERT(((Item_result_field*)item)->result_field);
+      *from_field= ((Item_result_field*)item)->result_field;
+    }
+    return create_tmp_field_from_item(thd, item, table, (make_copy_field ? 0 :
+                                      copy_func), modify_item,
                                       convert_blob_length);
   case Item::TYPE_HOLDER:
     return ((Item_type_holder *)item)->make_field_by_type(table);
@@ -5096,7 +5117,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
   Item **copy_func;
   MI_COLUMNDEF *recinfo;
   uint temp_pool_slot=MY_BIT_NONE;
-
+  bool force_copy_fields= param->force_copy_fields;
   DBUG_ENTER("create_tmp_table");
   DBUG_PRINT("enter",("distinct: %d  save_sum_fields: %d  rows_limit: %lu  group: %d",
 		      (int) distinct, (int) save_sum_fields,
@@ -5227,7 +5248,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
 	  Field *new_field=
             create_tmp_field(thd, table, arg, arg->type(), &copy_func,
                              tmp_from_field, group != 0,not_all_columns,
-                             param->convert_blob_length);
+                             param->convert_blob_length, 0);
 	  if (!new_field)
 	    goto err;					// Should be OOM
 	  tmp_from_field++;
@@ -5265,8 +5286,10 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
       */
       Field *new_field= create_tmp_field(thd, table, item, type, &copy_func,
                                          tmp_from_field, group != 0,
-                                         not_all_columns || group !=0,
-                                         param->convert_blob_length);
+                                         !force_copy_fields &&
+                                           (not_all_columns || group !=0),
+                                         param->convert_blob_length,
+                                         force_copy_fields);
       if (!new_field)
       {
 	if (thd->is_fatal_error)
diff --git a/sql/sql_select.h b/sql/sql_select.h
index 636ee967645..94cc8839466 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -227,7 +227,14 @@ class JOIN :public Sql_alloc
   {
     init(thd_arg, fields_arg, select_options_arg, result_arg);
   }
-  
+
+  JOIN(JOIN &join)
+    :fields_list(join.fields_list)
+  {
+    init(join.thd, join.fields_list, join.select_options,
+         join.result);
+  }
+
   void init(THD *thd_arg, List<Item> &fields_arg, ulong select_options_arg,
        select_result *result_arg)
   {
@@ -272,7 +279,7 @@ class JOIN :public Sql_alloc
 
     fields_list= fields_arg;
     bzero((char*) &keyuse,sizeof(keyuse));
-    tmp_table_param.copy_field=0;
+    tmp_table_param.init();
     tmp_table_param.end_write_records= HA_POS_ERROR;
     rollup.state= ROLLUP::STATE_NONE;
   }
diff --git a/sql/sql_string.cc b/sql/sql_string.cc
index ab2db4aaf53..939ffe8d9d2 100644
--- a/sql/sql_string.cc
+++ b/sql/sql_string.cc
@@ -806,8 +806,18 @@ copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
       from++;
       wc= '?';
     }
+    else if (cnvres > MY_CS_TOOSMALL)
+    {
+      /*
+        A correct multibyte sequence detected
+        But it doesn't have Unicode mapping.
+      */
+      error_count++;
+      from+= (-cnvres);
+      wc= '?';
+    }
     else
-      break;					// Impossible char.
+      break;  // Not enough characters
 
 outp:
     if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 71cbc0be1e3..c9513ec71ab 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -488,6 +488,12 @@ int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
 
   for (field_no=0; (sql_field=it++) ; field_no++)
   {
+    /*
+      Initialize length from its original value (number of characters),
+      which was set in the parser. This is necessary if we're
+      executing a prepared statement for the second time.
+    */
+    sql_field->length= sql_field->char_length;
     if (!sql_field->charset)
       sql_field->charset= create_info->default_table_charset;
     /*
@@ -534,6 +540,11 @@ int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
                                                sql_field->interval_list);
         List_iterator<String> it(sql_field->interval_list);
         String conv, *tmp;
+        char comma_buf[2];
+        int comma_length= cs->cset->wc_mb(cs, ',', (uchar*) comma_buf,
+                                          (uchar*) comma_buf + 
+                                          sizeof(comma_buf));
+        DBUG_ASSERT(comma_length > 0);
         for (uint i= 0; (tmp= it++); i++)
         {
           if (String::needs_conversion(tmp->length(), tmp->charset(),
@@ -553,6 +564,18 @@ int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
                                             interval->type_lengths[i]);
           interval->type_lengths[i]= lengthsp;
           ((uchar *)interval->type_names[i])[lengthsp]= '\0';
+          if (sql_field->sql_type == FIELD_TYPE_SET)
+          {
+            if (cs->coll->instr(cs, interval->type_names[i], 
+                                interval->type_lengths[i], 
+                                comma_buf, comma_length, NULL, 0))
+            {
+              my_printf_error(ER_UNKNOWN_ERROR,
+                              "Illegal %s '%-.64s' value found during parsing",
+                              MYF(0), "set", tmp->ptr());
+              DBUG_RETURN(-1);
+            }
+          }
         }
         sql_field->interval_list.empty(); // Don't need interval_list anymore
       }
@@ -665,7 +688,7 @@ int mysql_prepare_table(THD *thd, HA_CREATE_INFO *create_info,
 	  sql_field->charset=		(dup_field->charset ?
 					 dup_field->charset :
 					 create_info->default_table_charset);
-	  sql_field->length=		dup_field->chars_length;
+	  sql_field->length=		dup_field->char_length;
           sql_field->pack_length=	dup_field->pack_length;
 	  sql_field->create_length_to_internal_length();
 	  sql_field->decimals=		dup_field->decimals;
@@ -1562,7 +1585,7 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
       field=item->tmp_table_field(&tmp_table);
     else
       field=create_tmp_field(thd, &tmp_table, item, item->type(),
-				  (Item ***) 0, &tmp_field, 0, 0, 0);
+				  (Item ***) 0, &tmp_field, 0, 0, 0, 0);
     if (!field ||
 	!(cr_field=new create_field(field,(item->type() == Item::FIELD_ITEM ?
 					   ((Item_field *)item)->field :
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 24c7a278e79..48a8cf93917 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -212,7 +212,6 @@ int mysql_update(THD *thd,
       SORT_FIELD  *sortorder;
       ha_rows examined_rows;
 
-      used_index= MAX_KEY;                   // For call to init_read_record()
       table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
 						    MYF(MY_FAE | MY_ZEROFILL));
       if (!(sortorder=make_unireg_sortorder(order, &length)) ||
@@ -244,7 +243,17 @@ int mysql_update(THD *thd,
 			   DISK_BUFFER_SIZE, MYF(MY_WME)))
 	goto err;
 
-      if (used_index == MAX_KEY)
+      /*
+        When we get here, we have one of the following options:
+        A. used_index == MAX_KEY
+           This means we should use full table scan, and start it with
+           init_read_record call
+        B. used_index != MAX_KEY
+           B.1 quick select is used, start the scan with init_read_record
+           B.2 quick select is not used, this is full index scan (with LIMIT)
+               Full index scan must be started with init_read_record_idx
+      */
+      if (used_index == MAX_KEY || (select && select->quick))
         init_read_record(&info,thd,table,select,0,1);
       else
         init_read_record_idx(&info, thd, table, 1, used_index);
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index c99abc7d349..05d95b57abb 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -3564,9 +3564,8 @@ select_derived2:
         {
 	  LEX *lex= Lex;
 	  lex->derived_tables= 1;
-	  if (((int)lex->sql_command >= (int)SQLCOM_HA_OPEN &&
-	       lex->sql_command <= (int)SQLCOM_HA_READ) ||
-	       lex->sql_command == (int)SQLCOM_KILL)
+          if (lex->sql_command == (int)SQLCOM_HA_READ ||
+              lex->sql_command == (int)SQLCOM_KILL)
 	  {
 	    yyerror(ER(ER_SYNTAX_ERROR));
 	    YYABORT;
@@ -4739,16 +4738,15 @@ purge_option:
 /* kill threads */
 
 kill:
-	KILL_SYM expr
+	KILL_SYM { Lex->sql_command= SQLCOM_KILL; } expr
 	{
 	  LEX *lex=Lex;
-	  if ($2->fix_fields(lex->thd, 0, &$2) || $2->check_cols(1))
+	  if ($3->fix_fields(lex->thd, 0, &$3) || $3->check_cols(1))
 	  {
 	    send_error(lex->thd, ER_SET_CONSTANTS_ONLY);
 	    YYABORT;
 	  }
-          lex->sql_command=SQLCOM_KILL;
-	  lex->thread_id= (ulong) $2->val_int();
+	  lex->thread_id= (ulong) $3->val_int();
 	};
 
 /* change database */
@@ -6162,9 +6160,8 @@ subselect_start:
 	'(' SELECT_SYM
 	{
 	  LEX *lex=Lex;
-	  if (((int)lex->sql_command >= (int)SQLCOM_HA_OPEN &&
-	       lex->sql_command <= (int)SQLCOM_HA_READ) ||
-	       lex->sql_command == (int)SQLCOM_KILL)
+          if (lex->sql_command == (int)SQLCOM_HA_READ ||
+              lex->sql_command == (int)SQLCOM_KILL)
 	  {
             yyerror(ER(ER_SYNTAX_ERROR));
 	    YYABORT;
diff --git a/sql/table.cc b/sql/table.cc
index de539205ffd..8ac64ac198d 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -1423,7 +1423,7 @@ bool check_db_name(char *name)
   while (*name)
   {
 #if defined(USE_MB) && defined(USE_MB_IDENT)
-    last_char_is_space= my_isspace(default_charset_info, *name);
+    last_char_is_space= my_isspace(system_charset_info, *name);
     if (use_mb(system_charset_info))
     {
       int len=my_ismbchar(system_charset_info, name, 
@@ -1469,7 +1469,7 @@ bool check_table_name(const char *name, uint length)
   while (name != end)
   {
 #if defined(USE_MB) && defined(USE_MB_IDENT)
-    last_char_is_space= my_isspace(default_charset_info, *name);
+    last_char_is_space= my_isspace(system_charset_info, *name);
     if (use_mb(system_charset_info))
     {
       int len=my_ismbchar(system_charset_info, name, end);
@@ -1500,7 +1500,7 @@ bool check_column_name(const char *name)
   while (*name)
   {
 #if defined(USE_MB) && defined(USE_MB_IDENT)
-    last_char_is_space= my_isspace(default_charset_info, *name);
+    last_char_is_space= my_isspace(system_charset_info, *name);
     if (use_mb(system_charset_info))
     {
       int len=my_ismbchar(system_charset_info, name,