← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/join.cc

  • Committer: Lee Bieber
  • Date: 2011-01-19 01:50:26 UTC
  • mfrom: (2095.1.5 build)
  • Revision ID: kalebral@gmail.com-20110119015026-j1ukv30cz662e51e
Merge Shrews - Refactor the TransactionServices public interface
Merge Monty - fix bug 583375: support configure option to specify static/dynamic build for a plugin
Merge Shrews - fix bug 702505: transaction_reader utility does not check for errors from statement transformation
Merge Vijay - Convert structs to classes
Merge Joe - 702529: PRINT_TRANSACTION_MESSAGE udf does not output UUID

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/join.cc
728
728
  }
729
729
  if (group_list || tmp_table_param.sum_func_count)
730
730
  {
731
 
    if (! hidden_group_fields && rollup.state == ROLLUP::STATE_NONE)
 
731
    if (! hidden_group_fields && rollup.getState() == Rollup::STATE_NONE)
732
732
      select_distinct=0;
733
733
  }
734
734
  else if (select_distinct && tables - const_tables == 1)
792
792
  {
793
793
    Order *old_group_list;
794
794
    group_list= remove_constants(this, (old_group_list= group_list), conds,
795
 
                                 rollup.state == ROLLUP::STATE_NONE,
 
795
                                 rollup.getState() == Rollup::STATE_NONE,
796
796
                                 &simple_group);
797
797
    if (session->is_error())
798
798
    {
1985
1985
    If we are using rollup, we need a copy of the summary functions for
1986
1986
    each level
1987
1987
  */
1988
 
  if (rollup.state != ROLLUP::STATE_NONE)
 
1988
  if (rollup.getState() != Rollup::STATE_NONE)
1989
1989
    func_count*= (send_group_parts+1);
1990
1990
 
1991
1991
  group_parts= send_group_parts;
2048
2048
         ((Item_sum *)item)->depended_from() == select_lex))
2049
2049
      *func++= (Item_sum*) item;
2050
2050
  }
2051
 
  if (before_group_by && rollup.state == ROLLUP::STATE_INITED)
 
2051
  if (before_group_by && rollup.getState() == Rollup::STATE_INITED)
2052
2052
  {
2053
 
    rollup.state= ROLLUP::STATE_READY;
 
2053
    rollup.setState(Rollup::STATE_READY);
2054
2054
    if (rollup_make_fields(field_list, send_fields, &func))
2055
2055
      return true;     // Should never happen
2056
2056
  }
2057
 
  else if (rollup.state == ROLLUP::STATE_NONE)
 
2057
  else if (rollup.getState() == Rollup::STATE_NONE)
2058
2058
  {
2059
2059
    for (uint32_t i=0 ; i <= send_group_parts ;i++)
2060
2060
      sum_funcs_end[i]= func;
2061
2061
  }
2062
 
  else if (rollup.state == ROLLUP::STATE_READY)
 
2062
  else if (rollup.getState() == Rollup::STATE_READY)
2063
2063
    return(false);                         // Don't put end marker
2064
2064
  *func=0;          // End marker
2065
2065
  return(false);
2071
2071
  Item **ref_array;
2072
2072
 
2073
2073
  tmp_table_param.quick_group= 0; // Can't create groups in tmp table
2074
 
  rollup.state= ROLLUP::STATE_INITED;
 
2074
  rollup.setState(Rollup::STATE_INITED);
2075
2075
 
2076
2076
  /*
2077
2077
    Create pointers to the different sum function groups
2079
2079
  */
2080
2080
  tmp_table_param.group_parts= send_group_parts;
2081
2081
 
2082
 
  if (!(rollup.null_items= (Item_null_result**) session->alloc((sizeof(Item*) +
 
2082
  rollup.setNullItems((Item_null_result**) session->alloc((sizeof(Item*) +
2083
2083
                                                                sizeof(Item**) +
2084
2084
                                                                sizeof(List<Item>) +
2085
2085
                                                                ref_pointer_array_size)
2086
 
                                                               * send_group_parts )))
 
2086
                                                               * send_group_parts ));
 
2087
  if (! rollup.getNullItems())
2087
2088
  {
2088
2089
    return 1;
2089
2090
  }
2090
2091
 
2091
 
  rollup.fields= (List<Item>*) (rollup.null_items + send_group_parts);
2092
 
  rollup.ref_pointer_arrays= (Item***) (rollup.fields + send_group_parts);
2093
 
  ref_array= (Item**) (rollup.ref_pointer_arrays+send_group_parts);
 
2092
  rollup.setFields((List<Item>*) (rollup.getNullItems() + send_group_parts));
 
2093
  rollup.setRefPointerArrays((Item***) (rollup.getFields() + send_group_parts));
 
2094
  ref_array= (Item**) (rollup.getRefPointerArrays()+send_group_parts);
2094
2095
 
2095
2096
  /*
2096
2097
    Prepare space for field list for the different levels
2098
2099
  */
2099
2100
  for (uint32_t i= 0 ; i < send_group_parts ; i++)
2100
2101
  {
2101
 
    rollup.null_items[i]= new (session->mem_root) Item_null_result();
2102
 
    List<Item> *rollup_fields= &rollup.fields[i];
 
2102
    rollup.getNullItems()[i]= new (session->mem_root) Item_null_result();
 
2103
    List<Item> *rollup_fields= &rollup.getFields()[i];
2103
2104
    rollup_fields->empty();
2104
 
    rollup.ref_pointer_arrays[i]= ref_array;
 
2105
    rollup.getRefPointerArrays()[i]= ref_array;
2105
2106
    ref_array+= all_fields.elements;
2106
2107
  }
2107
2108
 
2109
2110
  {
2110
2111
    for (uint32_t j= 0 ; j < fields_list.elements ; j++)
2111
2112
    {
2112
 
      rollup.fields[i].push_back(rollup.null_items[i]);
 
2113
      rollup.getFields()[i].push_back(rollup.getNullItems()[i]);
2113
2114
    }
2114
2115
  }
2115
2116
 
2219
2220
    uint32_t pos= send_group_parts - level -1;
2220
2221
    bool real_fields= 0;
2221
2222
    Item *item;
2222
 
    List_iterator<Item> new_it(rollup.fields[pos]);
2223
 
    Item **ref_array_start= rollup.ref_pointer_arrays[pos];
 
2223
    List_iterator<Item> new_it(rollup.getFields()[pos]);
 
2224
    Item **ref_array_start= rollup.getRefPointerArrays()[pos];
2224
2225
    Order *start_group;
2225
2226
 
2226
2227
    /* Point to first hidden field */
2321
2322
  for (uint32_t i= send_group_parts ; i-- > idx ; )
2322
2323
  {
2323
2324
    /* Get reference pointers to sum functions in place */
2324
 
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i], ref_pointer_array_size);
 
2325
    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i], ref_pointer_array_size);
2325
2326
 
2326
2327
    if ((!having || having->val_int()))
2327
2328
    {
2328
 
      if (send_records < unit->select_limit_cnt && do_send_rows && result->send_data(rollup.fields[i]))
 
2329
      if (send_records < unit->select_limit_cnt && do_send_rows && result->send_data(rollup.getFields()[i]))
2329
2330
      {
2330
2331
        return 1;
2331
2332
      }
2362
2363
  for (uint32_t i= send_group_parts ; i-- > idx ; )
2363
2364
  {
2364
2365
    /* Get reference pointers to sum functions in place */
2365
 
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
 
2366
    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i],
2366
2367
           ref_pointer_array_size);
2367
2368
    if ((!having || having->val_int()))
2368
2369
    {
2369
2370
      int write_error;
2370
2371
      Item *item;
2371
 
      List_iterator_fast<Item> it(rollup.fields[i]);
 
2372
      List_iterator_fast<Item> it(rollup.getFields()[i]);
2372
2373
      while ((item= it++))
2373
2374
      {
2374
2375
        if (item->type() == Item::NULL_ITEM && item->is_result_field())