← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_union.cc

edit

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_union.cc
17
17
  UNION  of select's
18
18
  UNION's  were introduced by Monty and Sinisa <sinisa@mysql.com>
19
19
*/
20
 
#include <config.h>
21
 
 
 
20
#include "config.h"
22
21
#include <drizzled/sql_select.h>
23
22
#include <drizzled/error.h>
24
23
#include <drizzled/item/type_holder.h>
25
24
#include <drizzled/sql_base.h>
26
25
#include <drizzled/sql_union.h>
27
 
#include <drizzled/select_union.h>
28
 
#include <drizzled/sql_lex.h>
29
 
#include <drizzled/session.h>
30
26
 
31
27
namespace drizzled
32
28
{
172
168
void
173
169
Select_Lex_Unit::init_prepare_fake_select_lex(Session *session_arg)
174
170
{
175
 
  session_arg->getLex()->current_select= fake_select_lex;
 
171
  session_arg->lex->current_select= fake_select_lex;
176
172
  fake_select_lex->table_list.link_in_list((unsigned char *)&result_table_list,
177
173
                                           (unsigned char **)
178
174
                                           &result_table_list.next_local);
198
194
bool Select_Lex_Unit::prepare(Session *session_arg, select_result *sel_result,
199
195
                              uint64_t additional_options)
200
196
{
201
 
  Select_Lex *lex_select_save= session_arg->getLex()->current_select;
 
197
  Select_Lex *lex_select_save= session_arg->lex->current_select;
202
198
  Select_Lex *sl, *first_sl= first_select();
203
199
  select_result *tmp_result;
204
200
  bool is_union_select;
235
231
  prepared= 1;
236
232
  saved_error= false;
237
233
 
238
 
  session_arg->getLex()->current_select= sl= first_sl;
 
234
  session_arg->lex->current_select= sl= first_sl;
239
235
  found_rows_for_union= first_sl->options & OPTION_FOUND_ROWS;
240
236
  is_union_select= is_union() || fake_select_lex;
241
237
 
270
266
    if (!join)
271
267
      goto err;
272
268
 
273
 
    session_arg->getLex()->current_select= sl;
 
269
    session_arg->lex->current_select= sl;
274
270
 
275
271
    can_skip_order_by= is_union_select && !(sl->braces && sl->explicit_limit);
276
272
 
307
303
      */
308
304
      assert(!empty_table);
309
305
      empty_table= (Table*) session->calloc(sizeof(Table));
310
 
      types.clear();
311
 
      List<Item>::iterator it(sl->item_list.begin());
 
306
      types.empty();
 
307
      List_iterator_fast<Item> it(sl->item_list);
312
308
      Item *item_tmp;
313
309
      while ((item_tmp= it++))
314
310
      {
327
323
                   ER(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT),MYF(0));
328
324
        goto err;
329
325
      }
330
 
      List<Item>::iterator it(sl->item_list.begin());
331
 
      List<Item>::iterator tp(types.begin());
 
326
      List_iterator_fast<Item> it(sl->item_list);
 
327
      List_iterator_fast<Item> tp(types);
332
328
      Item *type, *item_tmp;
333
329
      while ((type= tp++, item_tmp= it++))
334
330
      {
344
340
      Check that it was possible to aggregate
345
341
      all collations together for UNION.
346
342
    */
347
 
    List<Item>::iterator tp(types.begin());
 
343
    List_iterator_fast<Item> tp(types);
348
344
    Item *type;
349
345
    uint64_t create_options;
350
346
 
370
366
    result_table_list.setTableName((char *) "union");
371
367
    result_table_list.table= table= union_result->table;
372
368
 
373
 
    session_arg->getLex()->current_select= lex_select_save;
 
369
    session_arg->lex->current_select= lex_select_save;
374
370
    if (!item_list.elements)
375
371
    {
376
372
      saved_error= table->fill_item_list(&item_list);
387
383
    }
388
384
  }
389
385
 
390
 
  session_arg->getLex()->current_select= lex_select_save;
 
386
  session_arg->lex->current_select= lex_select_save;
391
387
 
392
388
  return(saved_error || session_arg->is_fatal_error);
393
389
 
394
390
err:
395
 
  session_arg->getLex()->current_select= lex_select_save;
 
391
  session_arg->lex->current_select= lex_select_save;
396
392
  return(true);
397
393
}
398
394
 
399
395
 
400
396
bool Select_Lex_Unit::exec()
401
397
{
402
 
  Select_Lex *lex_select_save= session->getLex()->current_select;
 
398
  Select_Lex *lex_select_save= session->lex->current_select;
403
399
  Select_Lex *select_cursor=first_select();
404
400
  uint64_t add_rows=0;
405
401
  ha_rows examined_rows= 0;
429
425
    for (Select_Lex *sl= select_cursor; sl; sl= sl->next_select())
430
426
    {
431
427
      ha_rows records_at_start= 0;
432
 
      session->getLex()->current_select= sl;
 
428
      session->lex->current_select= sl;
433
429
 
434
430
      if (optimized)
435
431
        saved_error= sl->join->reinit();
477
473
          examined_rows+= session->examined_row_count;
478
474
          if (union_result->flush())
479
475
          {
480
 
            session->getLex()->current_select= lex_select_save;
 
476
            session->lex->current_select= lex_select_save;
481
477
            return(1);
482
478
          }
483
479
        }
484
480
      }
485
481
      if (saved_error)
486
482
      {
487
 
        session->getLex()->current_select= lex_select_save;
 
483
        session->lex->current_select= lex_select_save;
488
484
        return(saved_error);
489
485
      }
490
486
      /* Needed for the following test and for records_at_start in next loop */
531
527
        if (!(fake_select_lex->join= new Join(session, item_list,
532
528
                                              fake_select_lex->options, result)))
533
529
        {
534
 
          fake_select_lex->table_list.clear();
 
530
          fake_select_lex->table_list.empty();
535
531
          return(true);
536
532
        }
537
533
        fake_select_lex->join->no_const_tables= true;
581
577
        }
582
578
      }
583
579
 
584
 
      fake_select_lex->table_list.clear();
 
580
      fake_select_lex->table_list.empty();
585
581
      if (!saved_error)
586
582
      {
587
583
        session->limit_found_rows = (uint64_t)table->cursor->stats.records + add_rows;
593
589
      */
594
590
    }
595
591
  }
596
 
  session->getLex()->current_select= lex_select_save;
 
592
  session->lex->current_select= lex_select_save;
597
593
  return(saved_error);
598
594
}
599
595
 
610
606
 
611
607
  if (union_result)
612
608
  {
613
 
    safe_delete(union_result);
 
609
    delete union_result;
 
610
    union_result=0; // Safety
614
611
    table= 0; // Safety
615
612
  }
616
613
 
712
709
  {
713
710
    assert((Select_Lex*)join->select_lex == this);
714
711
    error= join->destroy();
715
 
    safe_delete(join);
 
712
    delete join;
 
713
    join= 0;
716
714
  }
717
715
  for (Select_Lex_Unit *lex_unit= first_inner_unit(); lex_unit ;
718
716
       lex_unit= lex_unit->next_unit())
719
717
  {
720
718
    error= (bool) ((uint32_t) error | (uint32_t) lex_unit->cleanup());
721
719
  }
722
 
  non_agg_fields.clear();
723
 
  inner_refs_list.clear();
 
720
  non_agg_fields.empty();
 
721
  inner_refs_list.empty();
724
722
  return(error);
725
723
}
726
724