Merge lp:~vjsamuel/drizzle/convert-rollup-to-class into lp:drizzle/7.0

[Vijay Samuel]

=== modified file 'drizzled/join.cc'
--- drizzled/join.cc	2011-01-08 10:35:13 +0000
+++ drizzled/join.cc	2011-01-17 09:18:58 +0000
@@ -728,7 +728,7 @@
   }
   if (group_list || tmp_table_param.sum_func_count)
   {
-    if (! hidden_group_fields && rollup.state == ROLLUP::STATE_NONE)
+    if (! hidden_group_fields && rollup.getState() == Rollup::STATE_NONE)
       select_distinct=0;
   }
   else if (select_distinct && tables - const_tables == 1)
@@ -792,7 +792,7 @@
   {
     Order *old_group_list;
     group_list= remove_constants(this, (old_group_list= group_list), conds,
-                                 rollup.state == ROLLUP::STATE_NONE,
+                                 rollup.getState() == Rollup::STATE_NONE,
                                  &simple_group);
     if (session->is_error())
     {
@@ -1985,7 +1985,7 @@
     If we are using rollup, we need a copy of the summary functions for
     each level
   */
-  if (rollup.state != ROLLUP::STATE_NONE)
+  if (rollup.getState() != Rollup::STATE_NONE)
     func_count*= (send_group_parts+1);
 
   group_parts= send_group_parts;
@@ -2048,18 +2048,18 @@
          ((Item_sum *)item)->depended_from() == select_lex))
       *func++= (Item_sum*) item;
   }
-  if (before_group_by && rollup.state == ROLLUP::STATE_INITED)
+  if (before_group_by && rollup.getState() == Rollup::STATE_INITED)
   {
-    rollup.state= ROLLUP::STATE_READY;
+    rollup.setState(Rollup::STATE_READY);
     if (rollup_make_fields(field_list, send_fields, &func))
       return true;     // Should never happen
   }
-  else if (rollup.state == ROLLUP::STATE_NONE)
+  else if (rollup.getState() == Rollup::STATE_NONE)
   {
     for (uint32_t i=0 ; i <= send_group_parts ;i++)
       sum_funcs_end[i]= func;
   }
-  else if (rollup.state == ROLLUP::STATE_READY)
+  else if (rollup.getState() == Rollup::STATE_READY)
     return(false);                         // Don't put end marker
   *func=0;          // End marker
   return(false);
@@ -2071,7 +2071,7 @@
   Item **ref_array;
 
   tmp_table_param.quick_group= 0; // Can't create groups in tmp table
-  rollup.state= ROLLUP::STATE_INITED;
+  rollup.setState(Rollup::STATE_INITED);
 
   /*
     Create pointers to the different sum function groups
@@ -2079,18 +2079,19 @@
   */
   tmp_table_param.group_parts= send_group_parts;
 
-  if (!(rollup.null_items= (Item_null_result**) session->alloc((sizeof(Item*) +
+  rollup.setNullItems((Item_null_result**) session->alloc((sizeof(Item*) +
                                                                 sizeof(Item**) +
                                                                 sizeof(List<Item>) +
                                                                 ref_pointer_array_size)
-                                                               * send_group_parts )))
+                                                               * send_group_parts ));
+  if (! rollup.getNullItems())
   {
     return 1;
   }
 
-  rollup.fields= (List<Item>*) (rollup.null_items + send_group_parts);
-  rollup.ref_pointer_arrays= (Item***) (rollup.fields + send_group_parts);
-  ref_array= (Item**) (rollup.ref_pointer_arrays+send_group_parts);
+  rollup.setFields((List<Item>*) (rollup.getNullItems() + send_group_parts));
+  rollup.setRefPointerArrays((Item***) (rollup.getFields() + send_group_parts));
+  ref_array= (Item**) (rollup.getRefPointerArrays()+send_group_parts);
 
   /*
     Prepare space for field list for the different levels
@@ -2098,10 +2099,10 @@
   */
   for (uint32_t i= 0 ; i < send_group_parts ; i++)
   {
-    rollup.null_items[i]= new (session->mem_root) Item_null_result();
-    List<Item> *rollup_fields= &rollup.fields[i];
+    rollup.getNullItems()[i]= new (session->mem_root) Item_null_result();
+    List<Item> *rollup_fields= &rollup.getFields()[i];
     rollup_fields->empty();
-    rollup.ref_pointer_arrays[i]= ref_array;
+    rollup.getRefPointerArrays()[i]= ref_array;
     ref_array+= all_fields.elements;
   }
 
@@ -2109,7 +2110,7 @@
   {
     for (uint32_t j= 0 ; j < fields_list.elements ; j++)
     {
-      rollup.fields[i].push_back(rollup.null_items[i]);
+      rollup.getFields()[i].push_back(rollup.getNullItems()[i]);
     }
   }
 
@@ -2219,8 +2220,8 @@
     uint32_t pos= send_group_parts - level -1;
     bool real_fields= 0;
     Item *item;
-    List_iterator<Item> new_it(rollup.fields[pos]);
-    Item **ref_array_start= rollup.ref_pointer_arrays[pos];
+    List_iterator<Item> new_it(rollup.getFields()[pos]);
+    Item **ref_array_start= rollup.getRefPointerArrays()[pos];
     Order *start_group;
 
     /* Point to first hidden field */
@@ -2321,11 +2322,11 @@
   for (uint32_t i= send_group_parts ; i-- > idx ; )
   {
     /* Get reference pointers to sum functions in place */
-    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i], ref_pointer_array_size);
+    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i], ref_pointer_array_size);
 
     if ((!having || having->val_int()))
     {
-      if (send_records < unit->select_limit_cnt && do_send_rows && result->send_data(rollup.fields[i]))
+      if (send_records < unit->select_limit_cnt && do_send_rows && result->send_data(rollup.getFields()[i]))
       {
         return 1;
       }
@@ -2362,13 +2363,13 @@
   for (uint32_t i= send_group_parts ; i-- > idx ; )
   {
     /* Get reference pointers to sum functions in place */
-    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
+    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i],
            ref_pointer_array_size);
     if ((!having || having->val_int()))
     {
       int write_error;
       Item *item;
-      List_iterator_fast<Item> it(rollup.fields[i]);
+      List_iterator_fast<Item> it(rollup.getFields()[i]);
       while ((item= it++))
       {
         if (item->type() == Item::NULL_ITEM && item->is_result_field())
 
=== modified file 'drizzled/join.h'
--- drizzled/join.h	2010-12-24 07:15:43 +0000
+++ drizzled/join.h	2011-01-17 09:18:58 +0000
@@ -180,7 +180,7 @@
   DrizzleLock *lock;
 
   Join *tmp_join; /**< copy of this Join to be used with temporary tables */
-  ROLLUP rollup;				/**< Used with rollup */
+  Rollup rollup;				/**< Used with rollup */
   DYNAMIC_ARRAY keyuse;
   Item::cond_result cond_value;
   Item::cond_result having_value;
@@ -306,7 +306,7 @@
     memset(&keyuse, 0, sizeof(keyuse));
     tmp_table_param.init();
     tmp_table_param.end_write_records= HA_POS_ERROR;
-    rollup.state= ROLLUP::STATE_NONE;
+    rollup.setState(Rollup::STATE_NONE);
   }
 
   /** 
@@ -395,7 +395,7 @@
     memset(&keyuse, 0, sizeof(keyuse));
     tmp_table_param.init();
     tmp_table_param.end_write_records= HA_POS_ERROR;
-    rollup.state= ROLLUP::STATE_NONE;
+    rollup.setState(Rollup::STATE_NONE);
   }
 
   int prepare(Item ***rref_pointer_array, 
 
=== modified file 'drizzled/sql_select.cc'
--- drizzled/sql_select.cc	2011-01-09 08:39:30 +0000
+++ drizzled/sql_select.cc	2011-01-17 09:18:58 +0000
@@ -3932,7 +3932,7 @@
               error=join->result->send_data(*join->fields) ? 1 : 0;
             join->send_records++;
           }
-          if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)
+          if (join->rollup.getState() != Rollup::STATE_NONE && error <= 0)
           {
             if (join->rollup_send_data((uint32_t) (idx+1)))
               error= 1;
@@ -4022,7 +4022,7 @@
             return NESTED_LOOP_ERROR;
           }
         }
-        if (join->rollup.state != ROLLUP::STATE_NONE)
+        if (join->rollup.getState() != Rollup::STATE_NONE)
         {
           if (join->rollup_write_data((uint32_t) (idx+1), table))
             return NESTED_LOOP_ERROR;
 
=== modified file 'drizzled/sql_select.h'
--- drizzled/sql_select.h	2011-01-12 21:31:39 +0000
+++ drizzled/sql_select.h	2011-01-17 09:18:58 +0000
@@ -56,14 +56,76 @@
 enum_nested_loop_state end_send_group(Join *join, JoinTable *join_tab, bool end_of_records);
 enum_nested_loop_state end_write_group(Join *join, JoinTable *join_tab, bool end_of_records);
 
-typedef struct st_rollup
+class Rollup
 {
+public:
   enum State { STATE_NONE, STATE_INITED, STATE_READY };
+
+  Rollup()
+  :
+  state(),
+  null_items(NULL),
+  ref_pointer_arrays(NULL),
+  fields()
+  {}
+  
+  Rollup(State in_state,
+         Item_null_result **in_null_items,
+         Item ***in_ref_pointer_arrays,
+         List<Item> *in_fields)
+  :
+  state(in_state),
+  null_items(in_null_items),
+  ref_pointer_arrays(in_ref_pointer_arrays),
+  fields(in_fields)
+  {}
+  
+  State getState() const
+  {
+    return state;
+  }
+
+  void setState(State in_state)
+  {
+    state= in_state;
+  }
+ 
+  Item_null_result **getNullItems() const
+  {
+    return null_items;
+  }
+
+  void setNullItems(Item_null_result **in_null_items)
+  {
+    null_items= in_null_items;
+  }
+
+  Item ***getRefPointerArrays() const
+  {
+    return ref_pointer_arrays;
+  }
+
+  void setRefPointerArrays(Item ***in_ref_pointer_arrays)
+  {
+    ref_pointer_arrays= in_ref_pointer_arrays;
+  }
+
+  List<Item> *getFields() const
+  {
+    return fields;
+  }
+
+  void setFields(List<Item> *in_fields)
+  {
+    fields= in_fields;
+  }
+  
+private:
   State state;
   Item_null_result **null_items;
   Item ***ref_pointer_arrays;
   List<Item> *fields;
-} ROLLUP;
+};
 
 } /* namespace drizzled */