← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_union.cc

  • Committer: David Shrewsbury
  • Date: 2011-02-28 14:33:56 UTC
  • mfrom: (2207 bootstrap)
  • mto: (2208.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2209.
  • Revision ID: shrewsbury.dave@gmail.com-20110228143356-ws2m2tp7an44egkd
https://launchpad.net/bugs/720908
Merge with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_union.cc
27
27
#include <drizzled/select_union.h>
28
28
#include <drizzled/sql_lex.h>
29
29
#include <drizzled/session.h>
 
30
#include <drizzled/item/subselect.h>
30
31
 
31
32
namespace drizzled
32
33
{
126
127
{
127
128
  assert(table == NULL);
128
129
  tmp_table_param.init();
129
 
  tmp_table_param.field_count= column_types->elements;
 
130
  tmp_table_param.field_count= column_types->size();
130
131
 
131
132
  if (! (table= create_tmp_table(session_arg, &tmp_table_param, *column_types,
132
133
                                 (Order*) NULL, is_union_distinct, 1,
172
173
void
173
174
Select_Lex_Unit::init_prepare_fake_select_lex(Session *session_arg)
174
175
{
175
 
  session_arg->lex->current_select= fake_select_lex;
 
176
  session_arg->getLex()->current_select= fake_select_lex;
176
177
  fake_select_lex->table_list.link_in_list((unsigned char *)&result_table_list,
177
178
                                           (unsigned char **)
178
179
                                           &result_table_list.next_local);
198
199
bool Select_Lex_Unit::prepare(Session *session_arg, select_result *sel_result,
199
200
                              uint64_t additional_options)
200
201
{
201
 
  Select_Lex *lex_select_save= session_arg->lex->current_select;
 
202
  Select_Lex *lex_select_save= session_arg->getLex()->current_select;
202
203
  Select_Lex *sl, *first_sl= first_select();
203
204
  select_result *tmp_result;
204
205
  bool is_union_select;
235
236
  prepared= 1;
236
237
  saved_error= false;
237
238
 
238
 
  session_arg->lex->current_select= sl= first_sl;
 
239
  session_arg->getLex()->current_select= sl= first_sl;
239
240
  found_rows_for_union= first_sl->options & OPTION_FOUND_ROWS;
240
241
  is_union_select= is_union() || fake_select_lex;
241
242
 
270
271
    if (!join)
271
272
      goto err;
272
273
 
273
 
    session_arg->lex->current_select= sl;
 
274
    session_arg->getLex()->current_select= sl;
274
275
 
275
276
    can_skip_order_by= is_union_select && !(sl->braces && sl->explicit_limit);
276
277
 
279
280
                               sl->with_wild,
280
281
                               sl->where,
281
282
                               (can_skip_order_by ? 0 :
282
 
                                sl->order_list.elements) +
283
 
                               sl->group_list.elements,
 
283
                                sl->order_list.size()) +
 
284
                               sl->group_list.size(),
284
285
                               can_skip_order_by ?
285
286
                               (Order*) NULL : (Order *)sl->order_list.first,
286
287
                               (Order*) sl->group_list.first,
308
309
      assert(!empty_table);
309
310
      empty_table= (Table*) session->calloc(sizeof(Table));
310
311
      types.clear();
311
 
      List_iterator_fast<Item> it(sl->item_list);
 
312
      List<Item>::iterator it(sl->item_list.begin());
312
313
      Item *item_tmp;
313
314
      while ((item_tmp= it++))
314
315
      {
321
322
    }
322
323
    else
323
324
    {
324
 
      if (types.elements != sl->item_list.elements)
 
325
      if (types.size() != sl->item_list.size())
325
326
      {
326
327
        my_message(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT,
327
328
                   ER(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT),MYF(0));
328
329
        goto err;
329
330
      }
330
 
      List_iterator_fast<Item> it(sl->item_list);
331
 
      List_iterator_fast<Item> tp(types);
 
331
      List<Item>::iterator it(sl->item_list.begin());
 
332
      List<Item>::iterator tp(types.begin());
332
333
      Item *type, *item_tmp;
333
334
      while ((type= tp++, item_tmp= it++))
334
335
      {
344
345
      Check that it was possible to aggregate
345
346
      all collations together for UNION.
346
347
    */
347
 
    List_iterator_fast<Item> tp(types);
 
348
    List<Item>::iterator tp(types.begin());
348
349
    Item *type;
349
350
    uint64_t create_options;
350
351
 
370
371
    result_table_list.setTableName((char *) "union");
371
372
    result_table_list.table= table= union_result->table;
372
373
 
373
 
    session_arg->lex->current_select= lex_select_save;
374
 
    if (!item_list.elements)
 
374
    session_arg->getLex()->current_select= lex_select_save;
 
375
    if (!item_list.size())
375
376
    {
376
377
      saved_error= table->fill_item_list(&item_list);
377
378
      if (saved_error)
387
388
    }
388
389
  }
389
390
 
390
 
  session_arg->lex->current_select= lex_select_save;
 
391
  session_arg->getLex()->current_select= lex_select_save;
391
392
 
392
393
  return(saved_error || session_arg->is_fatal_error);
393
394
 
394
395
err:
395
 
  session_arg->lex->current_select= lex_select_save;
 
396
  session_arg->getLex()->current_select= lex_select_save;
396
397
  return(true);
397
398
}
398
399
 
399
400
 
400
401
bool Select_Lex_Unit::exec()
401
402
{
402
 
  Select_Lex *lex_select_save= session->lex->current_select;
 
403
  Select_Lex *lex_select_save= session->getLex()->current_select;
403
404
  Select_Lex *select_cursor=first_select();
404
405
  uint64_t add_rows=0;
405
406
  ha_rows examined_rows= 0;
429
430
    for (Select_Lex *sl= select_cursor; sl; sl= sl->next_select())
430
431
    {
431
432
      ha_rows records_at_start= 0;
432
 
      session->lex->current_select= sl;
 
433
      session->getLex()->current_select= sl;
433
434
 
434
435
      if (optimized)
435
436
        saved_error= sl->join->reinit();
477
478
          examined_rows+= session->examined_row_count;
478
479
          if (union_result->flush())
479
480
          {
480
 
            session->lex->current_select= lex_select_save;
 
481
            session->getLex()->current_select= lex_select_save;
481
482
            return(1);
482
483
          }
483
484
        }
484
485
      }
485
486
      if (saved_error)
486
487
      {
487
 
        session->lex->current_select= lex_select_save;
 
488
        session->getLex()->current_select= lex_select_save;
488
489
        return(saved_error);
489
490
      }
490
491
      /* Needed for the following test and for records_at_start in next loop */
544
545
        saved_error= select_query(session, &fake_select_lex->ref_pointer_array,
545
546
                              &result_table_list,
546
547
                              0, item_list, NULL,
547
 
                              global_parameters->order_list.elements,
 
548
                              global_parameters->order_list.size(),
548
549
                              (Order*)global_parameters->order_list.first,
549
550
                              (Order*) NULL, NULL,
550
551
                              fake_select_lex->options | SELECT_NO_UNLOCK,
567
568
          saved_error= select_query(session, &fake_select_lex->ref_pointer_array,
568
569
                                &result_table_list,
569
570
                                0, item_list, NULL,
570
 
                                global_parameters->order_list.elements,
 
571
                                global_parameters->order_list.size(),
571
572
                                (Order*)global_parameters->order_list.first,
572
573
                                (Order*) NULL, NULL,
573
574
                                fake_select_lex->options | SELECT_NO_UNLOCK,
593
594
      */
594
595
    }
595
596
  }
596
 
  session->lex->current_select= lex_select_save;
 
597
  session->getLex()->current_select= lex_select_save;
597
598
  return(saved_error);
598
599
}
599
600
 
610
611
 
611
612
  if (union_result)
612
613
  {
613
 
    delete union_result;
614
 
    union_result=0; // Safety
 
614
    safe_delete(union_result);
615
615
    table= 0; // Safety
616
616
  }
617
617
 
627
627
      join->tables= 0;
628
628
    }
629
629
    error|= fake_select_lex->cleanup();
630
 
    if (fake_select_lex->order_list.elements)
 
630
    if (fake_select_lex->order_list.size())
631
631
    {
632
632
      Order *ord;
633
633
      for (ord= (Order*)fake_select_lex->order_list.first; ord; ord= ord->next)
713
713
  {
714
714
    assert((Select_Lex*)join->select_lex == this);
715
715
    error= join->destroy();
716
 
    delete join;
717
 
    join= 0;
 
716
    safe_delete(join);
718
717
  }
719
718
  for (Select_Lex_Unit *lex_unit= first_inner_unit(); lex_unit ;
720
719
       lex_unit= lex_unit->next_unit())