1 files changed, 188 insertions, 16 deletions

diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 2cd14c3f5e6..d34ff070eb1 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -163,6 +163,10 @@ static Item* part_of_refkey(TABLE *form,Field *field);
 uint find_shortest_key(TABLE *table, const key_map *usable_keys);
 static bool test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,
 				    ha_rows select_limit, bool no_changes);
+static bool list_contains_unique_index(TABLE *table,
+                          bool (*find_func) (Field *, void *), void *data);
+static bool find_field_in_item_list (Field *field, void *data);
+static bool find_field_in_order_list (Field *field, void *data);
 static int create_sort_index(THD *thd, JOIN *join, ORDER *order,
 			     ha_rows filesort_limit, ha_rows select_limit);
 static int remove_duplicates(JOIN *join,TABLE *entry,List<Item> &fields,
@@ -551,9 +555,6 @@ JOIN::optimize()
     DBUG_RETURN(0);
   optimized= 1;
 
-  if (thd->lex->orig_sql_command != SQLCOM_SHOW_STATUS)
-    thd->status_var.last_query_cost= 0.0;
-
   row_limit= ((select_distinct || order || group_list) ? HA_POS_ERROR :
 	      unit->select_limit_cnt);
   /* select_limit is used to decide if we are likely to scan the whole table */
@@ -871,6 +872,40 @@ JOIN::optimize()
     if (old_group_list && !group_list)
       select_distinct= 0;
   }
+  /*
+     Check if we can optimize away GROUP BY/DISTINCT.
+     We can do that if there are no aggregate functions and the
+     fields in DISTINCT clause (if present) and/or columns in GROUP BY
+     (if present) contain direct references to all key parts of
+     an unique index (in whatever order).
+     Note that the unique keys for DISTINCT and GROUP BY should not
+     be the same (as long as they are unique).
+
+     The FROM clause must contain a single non-constant table.
+  */
+  if (tables - const_tables == 1 && (group_list || select_distinct) &&
+      !tmp_table_param.sum_func_count &&
+      (!join_tab[const_tables].select ||
+       !join_tab[const_tables].select->quick ||
+       join_tab[const_tables].select->quick->get_type() != 
+       QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))
+  {
+    if (group_list &&
+       list_contains_unique_index(join_tab[const_tables].table,
+                                 find_field_in_order_list,
+                                 (void *) group_list))
+    {
+      group_list= 0;
+      group= 0;
+    }
+    if (select_distinct &&
+       list_contains_unique_index(join_tab[const_tables].table,
+                                 find_field_in_item_list,
+                                 (void *) &fields_list))
+    {
+      select_distinct= 0;
+    }
+  }
   if (!group_list && group)
   {
     order=0;					// The output has only one row
@@ -1074,8 +1109,9 @@ JOIN::optimize()
 			   group_list ? 0 : select_distinct,
 			   group_list && simple_group,
 			   select_options,
-			   (order == 0 || skip_sort_order) ? select_limit :
-			   HA_POS_ERROR,
+			   (order == 0 || skip_sort_order || 
+                            test(select_options & OPTION_BUFFER_RESULT)) ? 
+                             select_limit : HA_POS_ERROR,
 			   (char *) "")))
       DBUG_RETURN(1);
 
@@ -3875,10 +3911,8 @@ choose_plan(JOIN *join, table_map join_tables)
 
   /* 
     Store the cost of this query into a user variable
-    Don't update last_query_cost for 'show status' command
   */
-  if (join->thd->lex->orig_sql_command != SQLCOM_SHOW_STATUS)
-    join->thd->status_var.last_query_cost= join->best_read;
+  join->thd->status_var.last_query_cost= join->best_read;
   DBUG_VOID_RETURN;
 }
 
@@ -4823,7 +4857,7 @@ get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,
 */
 
 bool
-store_val_in_field(Field *field,Item *item)
+store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)
 {
   bool error;
   TABLE *table= field->table;
@@ -4838,7 +4872,7 @@ store_val_in_field(Field *field,Item *item)
     with select_insert, which make count_cuted_fields= 1
    */
   enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;
-  thd->count_cuted_fields= CHECK_FIELD_WARN;
+  thd->count_cuted_fields= check_flag;
   error= item->save_in_field(field, 1);
   thd->count_cuted_fields= old_count_cuted_fields;
   dbug_tmp_restore_column_map(table->write_set, old_map);
@@ -8899,6 +8933,11 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
       keyinfo->key_length+=  key_part_info->length;
     }
   }
+  else
+  {
+    set_if_smaller(table->s->max_rows, rows_limit);
+    param->end_write_records= rows_limit;
+  }
 
   if (distinct && field_count != param->hidden_field_count)
   {
@@ -9354,9 +9393,9 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
   /* copy row that filled HEAP table */
   if ((write_err=new_table.file->write_row(table->record[0])))
   {
-    if (write_err != HA_ERR_FOUND_DUPP_KEY &&
-	write_err != HA_ERR_FOUND_DUPP_UNIQUE || !ignore_last_dupp_key_error)
-    goto err;
+    if (new_table.file->is_fatal_error(write_err, HA_CHECK_DUP) ||
+	!ignore_last_dupp_key_error)
+      goto err;
   }
 
   /* remove heap table and change to use myisam table */
@@ -10777,8 +10816,7 @@ end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
       join->found_records++;
       if ((error=table->file->write_row(table->record[0])))
       {
-	if (error == HA_ERR_FOUND_DUPP_KEY ||
-	    error == HA_ERR_FOUND_DUPP_UNIQUE)
+        if (!table->file->is_fatal_error(error, HA_CHECK_DUP))
 	  goto end;
 	if (create_myisam_from_heap(join->thd, table, &join->tmp_table_param,
 				    error,1))
@@ -11031,7 +11069,7 @@ static bool test_if_ref(Item_field *left_item,Item *right_item)
 	    field->real_type() != MYSQL_TYPE_VARCHAR &&
 	    (field->type() != FIELD_TYPE_FLOAT || field->decimals() == 0))
 	{
-	  return !store_val_in_field(field,right_item);
+	  return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);
 	}
       }
     }
@@ -11306,6 +11344,140 @@ test_if_subkey(ORDER *order, TABLE *table, uint ref, uint ref_key_parts,
   return best;
 }
 
+
+/*
+  Check if GROUP BY/DISTINCT can be optimized away because the set is 
+  already known to be distinct.
+  
+  SYNOPSIS
+    list_contains_unique_index ()
+    table                The table to operate on.
+    find_func            function to iterate over the list and search
+                         for a field
+  
+  DESCRIPTION
+    Used in removing the GROUP BY/DISTINCT of the following types of
+    statements:
+      SELECT [DISTINCT] <unique_key_cols>... FROM <single_table_ref>
+        [GROUP BY <unique_key_cols>,...]
+
+    If (a,b,c is distinct)
+      then <any combination of a,b,c>,{whatever} is also distinct
+
+    This function checks if all the key parts of any of the unique keys
+    of the table are referenced by a list : either the select list 
+    through find_field_in_item_list or GROUP BY list through
+    find_field_in_order_list.
+    If the above holds then we can safely remove the GROUP BY/DISTINCT,
+    as no result set can be more distinct than an unique key.
+  
+  RETURN VALUE
+    1                    found
+    0                    not found.
+*/
+
+static bool
+list_contains_unique_index(TABLE *table,
+                          bool (*find_func) (Field *, void *), void *data)
+{
+  for (uint keynr= 0; keynr < table->s->keys; keynr++)
+  {
+    if (keynr == table->s->primary_key ||
+         (table->key_info[keynr].flags & HA_NOSAME))
+    {
+      KEY *keyinfo= table->key_info + keynr;
+      KEY_PART_INFO *key_part, *key_part_end;
+
+      for (key_part=keyinfo->key_part,
+           key_part_end=key_part+ keyinfo->key_parts;
+           key_part < key_part_end;
+           key_part++)
+      {
+        if (!find_func(key_part->field, data))
+          break;
+      }
+      if (key_part == key_part_end)
+        return 1;
+    }
+  }
+  return 0;
+}
+
+
+/*
+  Helper function for list_contains_unique_index.
+  Find a field reference in a list of ORDER structures.
+  
+  SYNOPSIS
+    find_field_in_order_list ()
+    field                The field to search for.
+    data                 ORDER *.The list to search in
+  
+  DESCRIPTION
+    Finds a direct reference of the Field in the list.
+  
+  RETURN VALUE
+    1                    found
+    0                    not found.
+*/
+
+static bool
+find_field_in_order_list (Field *field, void *data)
+{
+  ORDER *group= (ORDER *) data;
+  bool part_found= 0;
+  for (ORDER *tmp_group= group; tmp_group; tmp_group=tmp_group->next)
+  {
+    Item *item= (*tmp_group->item)->real_item();
+    if (item->type() == Item::FIELD_ITEM &&
+        ((Item_field*) item)->field->eq(field))
+    {
+      part_found= 1;
+      break;
+    }
+  }
+  return part_found;
+}
+
+
+/*
+  Helper function for list_contains_unique_index.
+  Find a field reference in a dynamic list of Items.
+  
+  SYNOPSIS
+    find_field_in_item_list ()
+    field in             The field to search for.
+    data  in             List<Item> *.The list to search in
+  
+  DESCRIPTION
+    Finds a direct reference of the Field in the list.
+  
+  RETURN VALUE
+    1                    found
+    0                    not found.
+*/
+
+static bool
+find_field_in_item_list (Field *field, void *data)
+{
+  List<Item> *fields= (List<Item> *) data;
+  bool part_found= 0;
+  List_iterator<Item> li(*fields);
+  Item *item;
+
+  while ((item= li++))
+  {
+    if (item->type() == Item::FIELD_ITEM &&
+        ((Item_field*) item)->field->eq(field))
+    {
+      part_found= 1;
+      break;
+    }
+  }
+  return part_found;
+}
+
+
 /*
   Test if we can skip the ORDER BY by using an index.