← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/join.cc

  • Committer: Brian Aker
  • Date: 2011-01-18 07:21:16 UTC
  • mfrom: (2079.3.3 session-fix)
  • Revision ID: brian@tangent.org-20110118072116-nuflltzguzhq9rgg
Merge in update so that test-run.pl runs all of test/suite and fix for
create table like and FK.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/join.cc
59
59
#include "drizzled/internal/my_sys.h"
60
60
#include "drizzled/internal/iocache.h"
61
61
 
62
 
#include <drizzled/debug.h>
63
 
 
64
62
#include <algorithm>
65
63
 
66
64
using namespace std;
67
65
 
68
66
namespace drizzled
69
67
{
 
68
 
70
69
extern plugin::StorageEngine *heap_engine;
 
70
extern std::bitset<12> test_flags;
71
71
 
72
72
/** Declarations of static functions used in this source file. */
73
73
static bool make_group_fields(Join *main_join, Join *curr_join);
212
212
  if (having)
213
213
  {
214
214
    nesting_map save_allow_sum_func= session->lex->allow_sum_func;
215
 
    session->setWhere("having clause");
 
215
    session->where="having clause";
216
216
    session->lex->allow_sum_func|= 1 << select_lex_arg->nest_level;
217
217
    select_lex->having_fix_field= 1;
218
218
    bool having_fix_rc= (!having->fixed &&
728
728
  }
729
729
  if (group_list || tmp_table_param.sum_func_count)
730
730
  {
731
 
    if (! hidden_group_fields && rollup.getState() == Rollup::STATE_NONE)
 
731
    if (! hidden_group_fields && rollup.state == 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.getState() == Rollup::STATE_NONE,
 
795
                                 rollup.state == ROLLUP::STATE_NONE,
796
796
                                 &simple_group);
797
797
    if (session->is_error())
798
798
    {
984
984
 
985
985
    tmp_table_param.hidden_field_count= (all_fields.elements -
986
986
           fields_list.elements);
987
 
    Order *tmp_group= (((not simple_group) or not (getDebug().test(debug::NO_KEY_GROUP))) ? group_list : (Order*) 0);
988
 
 
 
987
    Order *tmp_group= ((!simple_group &&
 
988
                           ! (test_flags.test(TEST_NO_KEY_GROUP))) ? group_list :
 
989
                                                                     (Order*) 0);
989
990
    /*
990
991
      Pushing LIMIT to the temporary table creation is not applicable
991
992
      when there is ORDER BY or GROUP BY or there is no GROUP BY, but
1984
1985
    If we are using rollup, we need a copy of the summary functions for
1985
1986
    each level
1986
1987
  */
1987
 
  if (rollup.getState() != Rollup::STATE_NONE)
 
1988
  if (rollup.state != ROLLUP::STATE_NONE)
1988
1989
    func_count*= (send_group_parts+1);
1989
1990
 
1990
1991
  group_parts= send_group_parts;
2047
2048
         ((Item_sum *)item)->depended_from() == select_lex))
2048
2049
      *func++= (Item_sum*) item;
2049
2050
  }
2050
 
  if (before_group_by && rollup.getState() == Rollup::STATE_INITED)
 
2051
  if (before_group_by && rollup.state == ROLLUP::STATE_INITED)
2051
2052
  {
2052
 
    rollup.setState(Rollup::STATE_READY);
 
2053
    rollup.state= ROLLUP::STATE_READY;
2053
2054
    if (rollup_make_fields(field_list, send_fields, &func))
2054
2055
      return true;     // Should never happen
2055
2056
  }
2056
 
  else if (rollup.getState() == Rollup::STATE_NONE)
 
2057
  else if (rollup.state == ROLLUP::STATE_NONE)
2057
2058
  {
2058
2059
    for (uint32_t i=0 ; i <= send_group_parts ;i++)
2059
2060
      sum_funcs_end[i]= func;
2060
2061
  }
2061
 
  else if (rollup.getState() == Rollup::STATE_READY)
 
2062
  else if (rollup.state == ROLLUP::STATE_READY)
2062
2063
    return(false);                         // Don't put end marker
2063
2064
  *func=0;          // End marker
2064
2065
  return(false);
2070
2071
  Item **ref_array;
2071
2072
 
2072
2073
  tmp_table_param.quick_group= 0; // Can't create groups in tmp table
2073
 
  rollup.setState(Rollup::STATE_INITED);
 
2074
  rollup.state= ROLLUP::STATE_INITED;
2074
2075
 
2075
2076
  /*
2076
2077
    Create pointers to the different sum function groups
2078
2079
  */
2079
2080
  tmp_table_param.group_parts= send_group_parts;
2080
2081
 
2081
 
  rollup.setNullItems((Item_null_result**) session->alloc((sizeof(Item*) +
 
2082
  if (!(rollup.null_items= (Item_null_result**) session->alloc((sizeof(Item*) +
2082
2083
                                                                sizeof(Item**) +
2083
2084
                                                                sizeof(List<Item>) +
2084
2085
                                                                ref_pointer_array_size)
2085
 
                                                               * send_group_parts ));
2086
 
  if (! rollup.getNullItems())
 
2086
                                                               * send_group_parts )))
2087
2087
  {
2088
2088
    return 1;
2089
2089
  }
2090
2090
 
2091
 
  rollup.setFields((List<Item>*) (rollup.getNullItems() + send_group_parts));
2092
 
  rollup.setRefPointerArrays((Item***) (rollup.getFields() + send_group_parts));
2093
 
  ref_array= (Item**) (rollup.getRefPointerArrays()+send_group_parts);
 
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);
2094
2094
 
2095
2095
  /*
2096
2096
    Prepare space for field list for the different levels
2098
2098
  */
2099
2099
  for (uint32_t i= 0 ; i < send_group_parts ; i++)
2100
2100
  {
2101
 
    rollup.getNullItems()[i]= new (session->mem_root) Item_null_result();
2102
 
    List<Item> *rollup_fields= &rollup.getFields()[i];
 
2101
    rollup.null_items[i]= new (session->mem_root) Item_null_result();
 
2102
    List<Item> *rollup_fields= &rollup.fields[i];
2103
2103
    rollup_fields->empty();
2104
 
    rollup.getRefPointerArrays()[i]= ref_array;
 
2104
    rollup.ref_pointer_arrays[i]= ref_array;
2105
2105
    ref_array+= all_fields.elements;
2106
2106
  }
2107
2107
 
2109
2109
  {
2110
2110
    for (uint32_t j= 0 ; j < fields_list.elements ; j++)
2111
2111
    {
2112
 
      rollup.getFields()[i].push_back(rollup.getNullItems()[i]);
 
2112
      rollup.fields[i].push_back(rollup.null_items[i]);
2113
2113
    }
2114
2114
  }
2115
2115
 
2219
2219
    uint32_t pos= send_group_parts - level -1;
2220
2220
    bool real_fields= 0;
2221
2221
    Item *item;
2222
 
    List_iterator<Item> new_it(rollup.getFields()[pos]);
2223
 
    Item **ref_array_start= rollup.getRefPointerArrays()[pos];
 
2222
    List_iterator<Item> new_it(rollup.fields[pos]);
 
2223
    Item **ref_array_start= rollup.ref_pointer_arrays[pos];
2224
2224
    Order *start_group;
2225
2225
 
2226
2226
    /* Point to first hidden field */
2321
2321
  for (uint32_t i= send_group_parts ; i-- > idx ; )
2322
2322
  {
2323
2323
    /* Get reference pointers to sum functions in place */
2324
 
    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i], ref_pointer_array_size);
 
2324
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i], ref_pointer_array_size);
2325
2325
 
2326
2326
    if ((!having || having->val_int()))
2327
2327
    {
2328
 
      if (send_records < unit->select_limit_cnt && do_send_rows && result->send_data(rollup.getFields()[i]))
 
2328
      if (send_records < unit->select_limit_cnt && do_send_rows && result->send_data(rollup.fields[i]))
2329
2329
      {
2330
2330
        return 1;
2331
2331
      }
2362
2362
  for (uint32_t i= send_group_parts ; i-- > idx ; )
2363
2363
  {
2364
2364
    /* Get reference pointers to sum functions in place */
2365
 
    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i],
 
2365
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
2366
2366
           ref_pointer_array_size);
2367
2367
    if ((!having || having->val_int()))
2368
2368
    {
2369
2369
      int write_error;
2370
2370
      Item *item;
2371
 
      List_iterator_fast<Item> it(rollup.getFields()[i]);
 
2371
      List_iterator_fast<Item> it(rollup.fields[i]);
2372
2372
      while ((item= it++))
2373
2373
      {
2374
2374
        if (item->type() == Item::NULL_ITEM && item->is_result_field())
4505
4505
      /* Ignore sj-nests: */
4506
4506
      if (!embedding->on_expr)
4507
4507
        continue;
4508
 
      NestedJoin *nested_join= embedding->getNestedJoin();
 
4508
      nested_join_st *nested_join= embedding->getNestedJoin();
4509
4509
      if (!nested_join->counter_)
4510
4510
      {
4511
4511
        /*
4623
4623
          join->full_join= 1;
4624
4624
      }
4625
4625
 
4626
 
      if (join->full_join and not session->lex->current_select->is_cross and not cond)
4627
 
      {
4628
 
        my_error(ER_CARTESIAN_JOIN_ATTEMPTED, MYF(0));
4629
 
        return 1;
4630
 
      }
4631
 
 
4632
4626
      tmp= NULL;
4633
4627
      if (cond)
4634
4628
        tmp= make_cond_for_table(cond,used_tables,current_map, 0);
5251
5245
static COND *simplify_joins(Join *join, List<TableList> *join_list, COND *conds, bool top)
5252
5246
{
5253
5247
  TableList *table;
5254
 
  NestedJoin *nested_join;
 
5248
  nested_join_st *nested_join;
5255
5249
  TableList *prev_table= 0;
5256
5250
  List_iterator<TableList> li(*join_list);
5257
5251
 
5589
5583
      s->embedding_map.reset();
5590
5584
      do
5591
5585
      {
5592
 
        NestedJoin *nested_join= embedding->getNestedJoin();
 
5586
        nested_join_st *nested_join= embedding->getNestedJoin();
5593
5587
        s->embedding_map|= nested_join->nj_map;
5594
5588
        s->dependent|= embedding->getDepTables();
5595
5589
        embedding= embedding->getEmbedding();
5673
5667
    s= p_pos->getJoinTable();
5674
5668
    s->type= AM_SYSTEM;
5675
5669
    join->const_table_map|=s->table->map;
5676
 
    if ((tmp= s->joinReadConstTable(p_pos)))
 
5670
    if ((tmp= join_read_const_table(s, p_pos)))
5677
5671
    {
5678
5672
      if (tmp > 0)
5679
5673
        return 1;                       // Fatal error
5747
5741
          join->const_table_map|=table->map;
5748
5742
          set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
5749
5743
          partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5750
 
          if ((tmp= s->joinReadConstTable(partial_pos)))
 
5744
          if ((tmp= join_read_const_table(s, partial_pos)))
5751
5745
          {
5752
5746
            if (tmp > 0)
5753
5747
              return 1;                 // Fatal error
5799
5793
                if (create_ref_for_key(join, s, start_keyuse, found_const_table_map))
5800
5794
                  return 1;
5801
5795
                partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5802
 
                if ((tmp=s->joinReadConstTable(partial_pos)))
 
5796
                if ((tmp=join_read_const_table(s, partial_pos)))
5803
5797
                {
5804
5798
                  if (tmp > 0)
5805
5799
                    return 1;                   // Fatal error
5883
5877
      s->quick=select->quick;
5884
5878
      s->needed_reg=select->needed_reg;
5885
5879
      select->quick=0;
5886
 
 
5887
5880
      if (records == 0 && s->table->reginfo.impossible_range)
5888
5881
      {
5889
5882
        /*
5965
5958
  TableList *table;
5966
5959
  while ((table= li++))
5967
5960
  {
5968
 
    NestedJoin *nested_join;
 
5961
    nested_join_st *nested_join;
5969
5962
    if ((nested_join= table->getNestedJoin()))
5970
5963
    {
5971
5964
      /*
6022
6015
}
6023
6016
 
6024
6017
/**
6025
 
  Set NestedJoin::counter=0 in all nested joins in passed list.
 
6018
  Set nested_join_st::counter=0 in all nested joins in passed list.
6026
6019
 
6027
 
    Recursively set NestedJoin::counter=0 for all nested joins contained in
 
6020
    Recursively set nested_join_st::counter=0 for all nested joins contained in
6028
6021
    the passed join_list.
6029
6022
 
6030
6023
  @param join_list  List of nested joins to process. It may also contain base
6036
6029
  TableList *table;
6037
6030
  while ((table= li++))
6038
6031
  {
6039
 
    NestedJoin *nested_join;
 
6032
    nested_join_st *nested_join;
6040
6033
    if ((nested_join= table->getNestedJoin()))
6041
6034
    {
6042
6035
      nested_join->counter_= 0;
6122
6115
  Join *join= last->join;
6123
6116
  for (;last_emb != NULL; last_emb= last_emb->getEmbedding())
6124
6117
  {
6125
 
    NestedJoin *nest= last_emb->getNestedJoin();
 
6118
    nested_join_st *nest= last_emb->getNestedJoin();
6126
6119
    
6127
6120
    bool was_fully_covered= nest->is_fully_covered();
6128
6121