1 files changed, 86 insertions, 35 deletions

diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index b9de54dbf5c..6836c53db4e 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -54,6 +54,36 @@ static int maxmin_in_range(bool max_fl, Field* field, COND *cond);
 
 
 /*
+  Get exact count of rows in all tables
+
+  SYNOPSIS
+    get_exact_records()
+    tables		List of tables
+
+  NOTES
+    When this is called, we know all table handlers supports HA_HAS_RECORDS
+    or HA_STATS_RECORDS_IS_EXACT
+
+  RETURN
+    ULONGLONG_MAX	Error: Could not calculate number of rows
+    #			Multiplication of number of rows in all tables
+*/
+
+static ulonglong get_exact_record_count(TABLE_LIST *tables)
+{
+  ulonglong count= 1;
+  for (TABLE_LIST *tl= tables; tl; tl= tl->next_leaf)
+  {
+    ha_rows tmp= tl->table->file->records();
+    if ((tmp == HA_POS_ERROR))
+      return ULONGLONG_MAX;
+    count*= tmp;
+  }
+  return count;
+}
+
+
+/*
   Substitutes constants for some COUNT(), MIN() and MAX() functions.
 
   SYNOPSIS
@@ -79,8 +109,8 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
   List_iterator_fast<Item> it(all_fields);
   int const_result= 1;
   bool recalc_const_item= 0;
-  longlong count= 1;
-  bool is_exact_count= TRUE;
+  ulonglong count= 1;
+  bool is_exact_count= TRUE, maybe_exact_count= TRUE;
   table_map removed_tables= 0, outer_tables= 0, used_tables= 0;
   table_map where_tables= 0;
   Item *item;
@@ -119,15 +149,18 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
       used_tables|= tl->table->map;
 
     /*
-      If the storage manager of 'tl' gives exact row count, compute the total
-      number of rows. If there are no outer table dependencies, this count
-      may be used as the real count.
+      If the storage manager of 'tl' gives exact row count as part of
+      statistics (cheap), compute the total number of rows. If there are
+      no outer table dependencies, this count may be used as the real count.
       Schema tables are filled after this function is invoked, so we can't
       get row count 
     */
-    if ((tl->table->file->table_flags() & HA_NOT_EXACT_COUNT) ||
+    if (!(tl->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) ||
         tl->schema_table)
     {
+      maybe_exact_count&= test(!tl->schema_table &&
+                               (tl->table->file->ha_table_flags() &
+                                HA_HAS_RECORDS));
       is_exact_count= FALSE;
       count= 1;                                 // ensure count != 0
     }
@@ -139,7 +172,7 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
         tl->table->file->print_error(error, MYF(0));
         return error;
       }
-      count*= tl->table->file->records;
+      count*= tl->table->file->stats.records;
     }
   }
 
@@ -161,9 +194,19 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
           there are no outer joins.
         */
         if (!conds && !((Item_sum_count*) item)->args[0]->maybe_null &&
-            !outer_tables && is_exact_count)
+            !outer_tables && maybe_exact_count)
         {
-          ((Item_sum_count*) item)->make_const(count);
+          if (!is_exact_count)
+          {
+            if ((count= get_exact_record_count(tables)) == ULONGLONG_MAX)
+            {
+              /* Error from handler in counting rows. Don't optimize count() */
+              const_result= 0;
+              continue;
+            }
+            is_exact_count= 1;                  // count is now exact
+          }
+          ((Item_sum_count*) item)->make_const((longlong) count);
           recalc_const_item= 1;
         }
         else
@@ -179,7 +222,7 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
         Item *expr=item_sum->args[0];
         if (expr->real_item()->type() == Item::FIELD_ITEM)
         {
-          byte key_buff[MAX_KEY_LENGTH];
+          uchar key_buff[MAX_KEY_LENGTH];
           TABLE_REF ref;
           uint range_fl, prefix_len;
 
@@ -202,7 +245,7 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
             const_result= 0;
             break;
           }
-          error= table->file->ha_index_init((uint) ref.key);
+          error= table->file->ha_index_init((uint) ref.key, 1);
 
           if (!ref.key_length)
             error= table->file->index_first(table->record[0]);
@@ -227,9 +270,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
                  Closed interval: Either The MIN argument is non-nullable, or
                  we have a >= predicate for the MIN argument.
               */
-              error= table->file->index_read(table->record[0], ref.key_buff,
-                                             ref.key_length, 
-                                             HA_READ_KEY_OR_NEXT);
+              error= table->file->index_read_map(table->record[0],
+                                                 ref.key_buff,
+                                                 make_prev_keypart_map(ref.key_parts),
+                                                 HA_READ_KEY_OR_NEXT);
             else
             {
               /*
@@ -238,8 +282,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
                 2) there is a > predicate on it, nullability is irrelevant.
                 We need to scan the next bigger record first.
               */
-              error= table->file->index_read(table->record[0], ref.key_buff, 
-                                             ref.key_length, HA_READ_AFTER_KEY);
+              error= table->file->index_read_map(table->record[0],
+                                                 ref.key_buff, 
+                                                 make_prev_keypart_map(ref.key_parts),
+                                                 HA_READ_AFTER_KEY);
               /* 
                  If the found record is outside the group formed by the search
                  prefix, or there is no such record at all, check if all
@@ -261,9 +307,10 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
                    key_cmp_if_same(table, ref.key_buff, ref.key, prefix_len)))
               {
                 DBUG_ASSERT(item_field->field->real_maybe_null());
-                error= table->file->index_read(table->record[0], ref.key_buff,
-                                               ref.key_length, 
-                                               HA_READ_KEY_EXACT);
+                error= table->file->index_read_map(table->record[0],
+                                                   ref.key_buff,
+                                                   make_prev_keypart_map(ref.key_parts),
+                                                   HA_READ_KEY_EXACT);
               }
             }
           }
@@ -322,7 +369,7 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
         Item *expr=item_sum->args[0];
         if (expr->real_item()->type() == Item::FIELD_ITEM)
         {
-          byte key_buff[MAX_KEY_LENGTH];
+          uchar key_buff[MAX_KEY_LENGTH];
           TABLE_REF ref;
           uint range_fl, prefix_len;
 
@@ -345,17 +392,17 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
             const_result= 0;
             break;
           }
-          error= table->file->ha_index_init((uint) ref.key);
+          error= table->file->ha_index_init((uint) ref.key, 1);
 
           if (!ref.key_length)
             error= table->file->index_last(table->record[0]);
           else
-	    error= table->file->index_read(table->record[0], key_buff,
-					   ref.key_length,
-					   range_fl & NEAR_MAX ?
-					   HA_READ_BEFORE_KEY :
-					   HA_READ_PREFIX_LAST_OR_PREV);
-	  if (!error && reckey_in_range(1, &ref, item_field->field, 
+	    error= table->file->index_read_map(table->record[0], key_buff,
+                                               make_prev_keypart_map(ref.key_parts),
+                                               range_fl & NEAR_MAX ?
+                                               HA_READ_BEFORE_KEY :
+                                               HA_READ_PREFIX_LAST_OR_PREV);
+	  if (!error && reckey_in_range(1, &ref, item_field->field,
 			                conds, range_fl, prefix_len))
 	    error= HA_ERR_KEY_NOT_FOUND;
           if (table->key_read)
@@ -616,17 +663,15 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
     less_fl= 1-less_fl;                         // Convert '<' -> '>' (etc)
 
   /* Check if field is part of the tested partial key */
-  byte *key_ptr= ref->key_buff;
+  uchar *key_ptr= ref->key_buff;
   KEY_PART_INFO *part;
-  for (part= keyinfo->key_part;
-       ;
-       key_ptr+= part++->store_length)
+  for (part= keyinfo->key_part; ; key_ptr+= part++->store_length)
 
   {
     if (part > field_part)
       return 0;                     // Field is beyond the tested parts
     if (part->field->eq(((Item_field*) args[0])->field))
-      break;                        // Found a part od the key for the field
+      break;                        // Found a part of the key for the field
   }
 
   bool is_field_part= part == field_part;
@@ -638,8 +683,11 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
   {
     uint length= (key_ptr-ref->key_buff)+part->store_length;
     if (ref->key_length < length)
+    {
     /* Ultimately ref->key_length will contain the length of the search key */
       ref->key_length= length;      
+      ref->key_parts= (part - keyinfo->key_part) + 1;
+    }
     if (!*prefix_len && part+1 == field_part)       
       *prefix_len= length;
     if (is_field_part && eq_type)
@@ -664,15 +712,15 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
     if (is_null)
     {
       part->field->set_null();
-      *key_ptr= (byte) 1;
+      *key_ptr= (uchar) 1;
     }
     else
     {
       store_val_in_field(part->field, args[between && max_fl ? 2 : 1],
                          CHECK_FIELD_IGNORE);
       if (part->null_bit) 
-        *key_ptr++= (byte) test(part->field->is_null());
-      part->field->get_key_image((char*) key_ptr, part->length, Field::itRAW);
+        *key_ptr++= (uchar) test(part->field->is_null());
+      part->field->get_key_image(key_ptr, part->length, Field::itRAW);
     }
     if (is_field_part)
     {
@@ -786,6 +834,7 @@ static bool find_key_for_maxmin(bool max_fl, TABLE_REF *ref,
       {
         ref->key= idx;
         ref->key_length= 0;
+        ref->key_parts= 0;
         key_part_map key_part_used= 0;
         *range_fl= NO_MIN_RANGE | NO_MAX_RANGE;
         if (matching_cond(max_fl, ref, keyinfo, part, cond,
@@ -811,6 +860,8 @@ static bool find_key_for_maxmin(bool max_fl, TABLE_REF *ref,
             /* Set the first byte of key_part_k to 1, that means NULL */
             ref->key_buff[ref->key_length]= 1;
             ref->key_length+= part->store_length;
+            ref->key_parts++;
+            DBUG_ASSERT(ref->key_parts == jdx+1);
             *range_fl&= ~NO_MIN_RANGE;
             *range_fl|= NEAR_MIN; // Open interval
           }