← 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-25 07:22:15 UTC
  • mfrom: (2109.1.7 drizzle-build)
  • Revision ID: brian@tangent.org-20110125072215-567z6uzy5vdvn4va
Merge in build/timestamp patches/fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/join.cc
58
58
#include "drizzled/internal/my_bit.h"
59
59
#include "drizzled/internal/my_sys.h"
60
60
#include "drizzled/internal/iocache.h"
61
 
#include "drizzled/plugin/storage_engine.h"
62
 
 
63
 
#include <drizzled/debug.h>
64
61
 
65
62
#include <algorithm>
66
63
 
68
65
 
69
66
namespace drizzled
70
67
{
 
68
 
71
69
extern plugin::StorageEngine *heap_engine;
 
70
extern std::bitset<12> test_flags;
72
71
 
73
72
/** Declarations of static functions used in this source file. */
74
73
static bool make_group_fields(Join *main_join, Join *curr_join);
134
133
static bool add_ref_to_table_cond(Session *session, JoinTable *join_tab);
135
134
static void free_blobs(Field **ptr); /* Rename this method...conflicts with another in global namespace... */
136
135
 
137
 
Join::Join(Session *session_arg, 
138
 
           List<Item> &fields_arg, 
139
 
           uint64_t select_options_arg,
140
 
           select_result *result_arg) :
141
 
  join_tab(NULL),
142
 
  best_ref(NULL),
143
 
  map2table(NULL),
144
 
  join_tab_save(NULL),
145
 
  table(NULL),
146
 
  all_tables(NULL),
147
 
  sort_by_table(NULL),
148
 
  tables(0),
149
 
  outer_tables(0),
150
 
  const_tables(0),
151
 
  send_group_parts(0),
152
 
  sort_and_group(false),
153
 
  first_record(false),
154
 
  full_join(false),
155
 
  group(false),
156
 
  no_field_update(false),
157
 
  do_send_rows(true),
158
 
  resume_nested_loop(false),
159
 
  no_const_tables(false),
160
 
  select_distinct(false),
161
 
  group_optimized_away(false),
162
 
  simple_order(false),
163
 
  simple_group(false),
164
 
  no_order(false),
165
 
  skip_sort_order(false),
166
 
  union_part(false),
167
 
  optimized(false),
168
 
  need_tmp(false),
169
 
  hidden_group_fields(false),
170
 
  const_table_map(0),
171
 
  found_const_table_map(0),
172
 
  outer_join(0),
173
 
  send_records(0),
174
 
  found_records(0),
175
 
  examined_rows(0),
176
 
  row_limit(0),
177
 
  select_limit(0),
178
 
  fetch_limit(HA_POS_ERROR),
179
 
  session(session_arg),
180
 
  fields_list(fields_arg), 
181
 
  join_list(NULL),
182
 
  unit(NULL),
183
 
  select_lex(NULL),
184
 
  select(NULL),
185
 
  exec_tmp_table1(NULL),
186
 
  exec_tmp_table2(NULL),
187
 
  sum_funcs(NULL),
188
 
  sum_funcs2(NULL),
189
 
  having(NULL),
190
 
  tmp_having(NULL),
191
 
  having_history(NULL),
192
 
  select_options(select_options_arg),
193
 
  result(result_arg),
194
 
  lock(session_arg->lock),
195
 
  tmp_join(NULL),
196
 
  all_fields(fields_arg),
197
 
  error(0),
198
 
  cond_equal(NULL),
199
 
  return_tab(NULL),
200
 
  ref_pointer_array(NULL),
201
 
  items0(NULL),
202
 
  items1(NULL),
203
 
  items2(NULL),
204
 
  items3(NULL),
205
 
  ref_pointer_array_size(0),
206
 
  zero_result_cause(NULL),
207
 
  sortorder(NULL),
208
 
  table_reexec(NULL),
209
 
  join_tab_reexec(NULL)
210
 
{
211
 
  select_distinct= test(select_options & SELECT_DISTINCT);
212
 
  if (&fields_list != &fields_arg) /* only copy if not same*/
213
 
    fields_list= fields_arg;
214
 
  memset(&keyuse, 0, sizeof(keyuse));
215
 
  tmp_table_param.init();
216
 
  tmp_table_param.end_write_records= HA_POS_ERROR;
217
 
  rollup.setState(Rollup::STATE_NONE);
218
 
}
219
 
 
220
 
  /** 
221
 
   * This method is currently only used when a subselect EXPLAIN is performed.
222
 
   * I pulled out the init() method and have simply reset the values to what
223
 
   * was previously in the init() method.  See the note about the hack in 
224
 
   * sql_union.cc...
225
 
   */
226
 
void Join::reset(Session *session_arg, 
227
 
                 List<Item> &fields_arg, 
228
 
                 uint64_t select_options_arg,
229
 
                 select_result *result_arg)
230
 
{
231
 
  join_tab= NULL;
232
 
  best_ref= NULL;
233
 
  map2table= NULL;
234
 
  join_tab_save= NULL;
235
 
  table= NULL;
236
 
  all_tables= NULL;
237
 
  sort_by_table= NULL;
238
 
  tables= 0;
239
 
  outer_tables= 0;
240
 
  const_tables= 0;
241
 
  send_group_parts= 0;
242
 
  sort_and_group= false;
243
 
  first_record= false;
244
 
  full_join= false;
245
 
  group= false;
246
 
  no_field_update= false;
247
 
  do_send_rows= true;
248
 
  resume_nested_loop= false;
249
 
  no_const_tables= false;
250
 
  select_distinct= false;
251
 
  group_optimized_away= false;
252
 
  simple_order= false;
253
 
  simple_group= false;
254
 
  no_order= false;
255
 
  skip_sort_order= false;
256
 
  union_part= false;
257
 
  optimized= false;
258
 
  need_tmp= false;
259
 
  hidden_group_fields= false;
260
 
  const_table_map= 0;
261
 
  found_const_table_map= 0;
262
 
  outer_join= 0;
263
 
  send_records= 0;
264
 
  found_records= 0;
265
 
  examined_rows= 0;
266
 
  row_limit= 0;
267
 
  select_limit= 0;
268
 
  fetch_limit= HA_POS_ERROR;
269
 
  session= session_arg;
270
 
  fields_list= fields_arg; 
271
 
  join_list= NULL;
272
 
  unit= NULL;
273
 
  select_lex= NULL;
274
 
  select= NULL;
275
 
  exec_tmp_table1= NULL;
276
 
  exec_tmp_table2= NULL;
277
 
  sum_funcs= NULL;
278
 
  sum_funcs2= NULL;
279
 
  having= NULL;
280
 
  tmp_having= NULL;
281
 
  having_history= NULL;
282
 
  select_options= select_options_arg;
283
 
  result= result_arg;
284
 
  lock= session_arg->lock;
285
 
  tmp_join= NULL;
286
 
  all_fields= fields_arg;
287
 
  error= 0;
288
 
  cond_equal= NULL;
289
 
  return_tab= NULL;
290
 
  ref_pointer_array= NULL;
291
 
  items0= NULL;
292
 
  items1= NULL;
293
 
  items2= NULL;
294
 
  items3= NULL;
295
 
  ref_pointer_array_size= 0;
296
 
  zero_result_cause= NULL;
297
 
  sortorder= NULL;
298
 
  table_reexec= NULL;
299
 
  join_tab_reexec= NULL;
300
 
  select_distinct= test(select_options & SELECT_DISTINCT);
301
 
  if (&fields_list != &fields_arg) /* only copy if not same*/
302
 
    fields_list= fields_arg;
303
 
  memset(&keyuse, 0, sizeof(keyuse));
304
 
  tmp_table_param.init();
305
 
  tmp_table_param.end_write_records= HA_POS_ERROR;
306
 
  rollup.setState(Rollup::STATE_NONE);
307
 
}
308
 
 
309
 
bool Join::is_top_level_join() const
310
 
{
311
 
  return (unit == &session->lex->unit && (unit->fake_select_lex == 0 ||
312
 
                                          select_lex == unit->fake_select_lex));
313
 
}
314
 
 
315
136
/**
316
137
  Prepare of whole select (including sub queries in future).
317
138
 
391
212
  if (having)
392
213
  {
393
214
    nesting_map save_allow_sum_func= session->lex->allow_sum_func;
394
 
    session->setWhere("having clause");
 
215
    session->where="having clause";
395
216
    session->lex->allow_sum_func|= 1 << select_lex_arg->nest_level;
396
217
    select_lex->having_fix_field= 1;
397
218
    bool having_fix_rc= (!having->fixed &&
1163
984
 
1164
985
    tmp_table_param.hidden_field_count= (all_fields.elements -
1165
986
           fields_list.elements);
1166
 
    Order *tmp_group= (((not simple_group) or not (getDebug().test(debug::NO_KEY_GROUP))) ? group_list : (Order*) 0);
1167
 
 
 
987
    Order *tmp_group= ((!simple_group &&
 
988
                           ! (test_flags.test(TEST_NO_KEY_GROUP))) ? group_list :
 
989
                                                                     (Order*) 0);
1168
990
    /*
1169
991
      Pushing LIMIT to the temporary table creation is not applicable
1170
992
      when there is ORDER BY or GROUP BY or there is no GROUP BY, but
1350
1172
*/
1351
1173
bool Join::init_save_join_tab()
1352
1174
{
1353
 
  if (!(tmp_join= (Join*)session->getMemRoot()->allocate(sizeof(Join))))
 
1175
  if (!(tmp_join= (Join*)session->alloc(sizeof(Join))))
1354
1176
    return 1;
1355
1177
 
1356
1178
  error= 0;              // Ensure that tmp_join.error= 0
1363
1185
{
1364
1186
  if (! join_tab_save && select_lex->master_unit()->uncacheable.any())
1365
1187
  {
1366
 
    if (!(join_tab_save= (JoinTable*)session->getMemRoot()->duplicate((unsigned char*) join_tab,
 
1188
    if (!(join_tab_save= (JoinTable*)session->memdup((unsigned char*) join_tab,
1367
1189
            sizeof(JoinTable) * tables)))
1368
1190
      return 1;
1369
1191
  }
2257
2079
  */
2258
2080
  tmp_table_param.group_parts= send_group_parts;
2259
2081
 
2260
 
  rollup.setNullItems((Item_null_result**) session->getMemRoot()->allocate((sizeof(Item*) +
 
2082
  rollup.setNullItems((Item_null_result**) session->alloc((sizeof(Item*) +
2261
2083
                                                                sizeof(Item**) +
2262
2084
                                                                sizeof(List<Item>) +
2263
2085
                                                                ref_pointer_array_size)
3405
3227
 
3406
3228
  table_count=join->tables;
3407
3229
  if (!(join->join_tab=join_tab=
3408
 
  (JoinTable*) session->getMemRoot()->allocate(sizeof(JoinTable)*table_count)))
 
3230
  (JoinTable*) session->alloc(sizeof(JoinTable)*table_count)))
3409
3231
    return(true);
3410
3232
 
3411
3233
  for (i= 0; i < table_count; i++)
4563
4385
  */
4564
4386
  if (!join->table_reexec)
4565
4387
  {
4566
 
    if (!(join->table_reexec= (Table**) join->session->getMemRoot()->allocate(sizeof(Table*))))
 
4388
    if (!(join->table_reexec= (Table**) join->session->alloc(sizeof(Table*))))
4567
4389
      return(true);
4568
4390
    if (join->tmp_join)
4569
4391
      join->tmp_join->table_reexec= join->table_reexec;
4571
4393
  if (!join->join_tab_reexec)
4572
4394
  {
4573
4395
    if (!(join->join_tab_reexec=
4574
 
          (JoinTable*) join->session->getMemRoot()->allocate(sizeof(JoinTable))))
 
4396
          (JoinTable*) join->session->alloc(sizeof(JoinTable))))
4575
4397
      return(true);
4576
4398
    new (join->join_tab_reexec) JoinTable();
4577
4399
    if (join->tmp_join)
4684
4506
      /* Ignore sj-nests: */
4685
4507
      if (!embedding->on_expr)
4686
4508
        continue;
4687
 
      NestedJoin *nested_join= embedding->getNestedJoin();
 
4509
      nested_join_st *nested_join= embedding->getNestedJoin();
4688
4510
      if (!nested_join->counter_)
4689
4511
      {
4690
4512
        /*
4802
4624
          join->full_join= 1;
4803
4625
      }
4804
4626
 
4805
 
      if (join->full_join and not session->lex->current_select->is_cross and not cond)
4806
 
      {
4807
 
        my_error(ER_CARTESIAN_JOIN_ATTEMPTED, MYF(0));
4808
 
        return 1;
4809
 
      }
4810
 
 
4811
4627
      tmp= NULL;
4812
4628
      if (cond)
4813
4629
        tmp= make_cond_for_table(cond,used_tables,current_map, 0);
4838
4654
          tab->type == AM_EQ_REF)
4839
4655
      {
4840
4656
        optimizer::SqlSelect *sel= tab->select= ((optimizer::SqlSelect*)
4841
 
            session->getMemRoot()->duplicate((unsigned char*) select,
 
4657
            session->memdup((unsigned char*) select,
4842
4658
              sizeof(*select)));
4843
4659
        if (! sel)
4844
4660
          return 1;                     // End of memory
4976
4792
                                         current_map, 0)))
4977
4793
            {
4978
4794
              tab->cache.select= (optimizer::SqlSelect*)
4979
 
                session->getMemRoot()->duplicate((unsigned char*) sel, sizeof(optimizer::SqlSelect));
 
4795
                session->memdup((unsigned char*) sel, sizeof(optimizer::SqlSelect));
4980
4796
              tab->cache.select->cond= tmp;
4981
4797
              tab->cache.select->read_tables= join->const_table_map;
4982
4798
            }
5112
4928
 
5113
4929
    if (tab->insideout_match_tab)
5114
4930
    {
5115
 
      if (! (tab->insideout_buf= (unsigned char*) join->session->getMemRoot()->allocate(tab->table->key_info
 
4931
      if (! (tab->insideout_buf= (unsigned char*) join->session->alloc(tab->table->key_info
5116
4932
                                                                       [tab->index].
5117
4933
                                                                       key_length)))
5118
4934
        return true;
5430
5246
static COND *simplify_joins(Join *join, List<TableList> *join_list, COND *conds, bool top)
5431
5247
{
5432
5248
  TableList *table;
5433
 
  NestedJoin *nested_join;
 
5249
  nested_join_st *nested_join;
5434
5250
  TableList *prev_table= 0;
5435
5251
  List_iterator<TableList> li(*join_list);
5436
5252
 
5703
5519
 
5704
5520
  table_count= join->tables;
5705
5521
  stat= (JoinTable*) join->session->calloc(sizeof(JoinTable)*table_count);
5706
 
  stat_ref= (JoinTable**) join->session->getMemRoot()->allocate(sizeof(JoinTable*)*MAX_TABLES);
5707
 
  table_vector= (Table**) join->session->getMemRoot()->allocate(sizeof(Table*)*(table_count*2));
 
5522
  stat_ref= (JoinTable**) join->session->alloc(sizeof(JoinTable*)*MAX_TABLES);
 
5523
  table_vector= (Table**) join->session->alloc(sizeof(Table*)*(table_count*2));
5708
5524
  if (! stat || ! stat_ref || ! table_vector)
5709
5525
    return 1;
5710
5526
 
5768
5584
      s->embedding_map.reset();
5769
5585
      do
5770
5586
      {
5771
 
        NestedJoin *nested_join= embedding->getNestedJoin();
 
5587
        nested_join_st *nested_join= embedding->getNestedJoin();
5772
5588
        s->embedding_map|= nested_join->nj_map;
5773
5589
        s->dependent|= embedding->getDepTables();
5774
5590
        embedding= embedding->getEmbedding();
5852
5668
    s= p_pos->getJoinTable();
5853
5669
    s->type= AM_SYSTEM;
5854
5670
    join->const_table_map|=s->table->map;
5855
 
    if ((tmp= s->joinReadConstTable(p_pos)))
 
5671
    if ((tmp= join_read_const_table(s, p_pos)))
5856
5672
    {
5857
5673
      if (tmp > 0)
5858
5674
        return 1;                       // Fatal error
5926
5742
          join->const_table_map|=table->map;
5927
5743
          set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
5928
5744
          partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5929
 
          if ((tmp= s->joinReadConstTable(partial_pos)))
 
5745
          if ((tmp= join_read_const_table(s, partial_pos)))
5930
5746
          {
5931
5747
            if (tmp > 0)
5932
5748
              return 1;                 // Fatal error
5978
5794
                if (create_ref_for_key(join, s, start_keyuse, found_const_table_map))
5979
5795
                  return 1;
5980
5796
                partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5981
 
                if ((tmp=s->joinReadConstTable(partial_pos)))
 
5797
                if ((tmp=join_read_const_table(s, partial_pos)))
5982
5798
                {
5983
5799
                  if (tmp > 0)
5984
5800
                    return 1;                   // Fatal error
6062
5878
      s->quick=select->quick;
6063
5879
      s->needed_reg=select->needed_reg;
6064
5880
      select->quick=0;
6065
 
 
6066
5881
      if (records == 0 && s->table->reginfo.impossible_range)
6067
5882
      {
6068
5883
        /*
6144
5959
  TableList *table;
6145
5960
  while ((table= li++))
6146
5961
  {
6147
 
    NestedJoin *nested_join;
 
5962
    nested_join_st *nested_join;
6148
5963
    if ((nested_join= table->getNestedJoin()))
6149
5964
    {
6150
5965
      /*
6201
6016
}
6202
6017
 
6203
6018
/**
6204
 
  Set NestedJoin::counter=0 in all nested joins in passed list.
 
6019
  Set nested_join_st::counter=0 in all nested joins in passed list.
6205
6020
 
6206
 
    Recursively set NestedJoin::counter=0 for all nested joins contained in
 
6021
    Recursively set nested_join_st::counter=0 for all nested joins contained in
6207
6022
    the passed join_list.
6208
6023
 
6209
6024
  @param join_list  List of nested joins to process. It may also contain base
6215
6030
  TableList *table;
6216
6031
  while ((table= li++))
6217
6032
  {
6218
 
    NestedJoin *nested_join;
 
6033
    nested_join_st *nested_join;
6219
6034
    if ((nested_join= table->getNestedJoin()))
6220
6035
    {
6221
6036
      nested_join->counter_= 0;
6301
6116
  Join *join= last->join;
6302
6117
  for (;last_emb != NULL; last_emb= last_emb->getEmbedding())
6303
6118
  {
6304
 
    NestedJoin *nest= last_emb->getNestedJoin();
 
6119
    nested_join_st *nest= last_emb->getNestedJoin();
6305
6120
    
6306
6121
    bool was_fully_covered= nest->is_fully_covered();
6307
6122