← 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-02-01 02:51:01 UTC
  • mto: (2132.1.1 drizzle-build)
  • mto: This revision was merged to the branch mainline in revision 2134.
  • Revision ID: brian@tangent.org-20110201025101-yaj5kkdk2towo6ou
Merge in error message rework. Many error messages are fixed in this patch.

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
61
 
63
62
#include <drizzled/debug.h>
64
63
 
68
67
 
69
68
namespace drizzled
70
69
{
 
70
 
71
71
extern plugin::StorageEngine *heap_engine;
72
72
 
73
73
/** Declarations of static functions used in this source file. */
134
134
static bool add_ref_to_table_cond(Session *session, JoinTable *join_tab);
135
135
static void free_blobs(Field **ptr); /* Rename this method...conflicts with another in global namespace... */
136
136
 
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
137
/**
316
138
  Prepare of whole select (including sub queries in future).
317
139
 
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