← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_union.cc

Renamed namespace slot to namespace service.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_union.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/*
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 <drizzled/server_includes.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
 
 
31
 
namespace drizzled
32
 
{
33
26
 
34
27
bool drizzle_union(Session *session, LEX *, select_result *result,
35
28
                   Select_Lex_Unit *unit, uint64_t setup_tables_done_option)
63
56
    unit->offset_limit_cnt--;
64
57
    return 0;
65
58
  }
66
 
  fill_record(session, table->getFields(), values, true);
 
59
  fill_record(session, table->field, values, 1);
67
60
  if (session->is_error())
68
61
    return 1;
69
62
 
70
 
  if ((error= table->cursor->insertRecord(table->getInsertRecord())))
 
63
  if ((error= table->file->ha_write_row(table->record[0])))
71
64
  {
72
65
    /* create_myisam_from_heap will generate error if needed */
73
 
    if (table->cursor->is_fatal_error(error, HA_CHECK_DUP))
74
 
    {
75
 
      my_error(ER_USE_SQL_BIG_RESULT, MYF(0));
76
 
      return true;
77
 
    }
 
66
    if (table->file->is_fatal_error(error, HA_CHECK_DUP) &&
 
67
        create_myisam_from_heap(session, table, tmp_table_param.start_recinfo,
 
68
                                &tmp_table_param.recinfo, error, 1))
 
69
      return 1;
78
70
  }
79
71
  return 0;
80
72
}
89
81
bool select_union::flush()
90
82
{
91
83
  int error;
92
 
  if ((error=table->cursor->extra(HA_EXTRA_NO_CACHE)))
 
84
  if ((error=table->file->extra(HA_EXTRA_NO_CACHE)))
93
85
  {
94
 
    table->print_error(error, MYF(0));
 
86
    table->file->print_error(error, MYF(0));
95
87
    return 1;
96
88
  }
97
89
  return 0;
109
101
                         duplicates on insert
110
102
      options            create options
111
103
      table_alias        name of the temporary table
 
104
      bit_fields_as_long convert bit fields to uint64_t
112
105
 
113
106
  DESCRIPTION
114
107
    Create a temporary table that is used to store the result of a UNION,
122
115
bool
123
116
select_union::create_result_table(Session *session_arg, List<Item> *column_types,
124
117
                                  bool is_union_distinct, uint64_t options,
125
 
                                  const char *table_alias)
 
118
                                  const char *table_alias,
 
119
                                  bool bit_fields_as_long)
126
120
{
127
 
  assert(table == NULL);
 
121
  assert(table == 0);
128
122
  tmp_table_param.init();
129
123
  tmp_table_param.field_count= column_types->elements;
 
124
  tmp_table_param.bit_fields_as_long= bit_fields_as_long;
130
125
 
131
126
  if (! (table= create_tmp_table(session_arg, &tmp_table_param, *column_types,
132
 
                                 (Order*) NULL, is_union_distinct, 1,
 
127
                                 (order_st*) 0, is_union_distinct, 1,
133
128
                                 options, HA_POS_ERROR, (char*) table_alias)))
134
 
  {
135
129
    return true;
136
 
  }
137
 
 
138
 
  table->cursor->extra(HA_EXTRA_WRITE_CACHE);
139
 
  table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
140
 
 
 
130
  table->file->extra(HA_EXTRA_WRITE_CACHE);
 
131
  table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
141
132
  return false;
142
133
}
143
134
 
151
142
 
152
143
void select_union::cleanup()
153
144
{
154
 
  table->cursor->extra(HA_EXTRA_RESET_STATE);
155
 
  table->cursor->ha_delete_all_rows();
 
145
  table->file->extra(HA_EXTRA_RESET_STATE);
 
146
  table->file->ha_delete_all_rows();
156
147
  table->free_io_cache();
157
148
  table->filesort_free_buffers();
158
149
}
172
163
void
173
164
Select_Lex_Unit::init_prepare_fake_select_lex(Session *session_arg)
174
165
{
175
 
  session_arg->getLex()->current_select= fake_select_lex;
 
166
  session_arg->lex->current_select= fake_select_lex;
176
167
  fake_select_lex->table_list.link_in_list((unsigned char *)&result_table_list,
177
168
                                           (unsigned char **)
178
169
                                           &result_table_list.next_local);
180
171
    fake_select_lex->context.first_name_resolution_table=
181
172
    fake_select_lex->get_table_list();
182
173
 
183
 
  for (Order *order= (Order *) global_parameters->order_list.first;
 
174
  for (order_st *order= (order_st *) global_parameters->order_list.first;
184
175
       order;
185
176
       order= order->next)
186
177
    order->item= &order->item_ptr;
187
178
 
188
 
  for (Order *order= (Order *)global_parameters->order_list.first;
 
179
  for (order_st *order= (order_st *)global_parameters->order_list.first;
189
180
       order;
190
181
       order=order->next)
191
182
  {
198
189
bool Select_Lex_Unit::prepare(Session *session_arg, select_result *sel_result,
199
190
                              uint64_t additional_options)
200
191
{
201
 
  Select_Lex *lex_select_save= session_arg->getLex()->current_select;
 
192
  Select_Lex *lex_select_save= session_arg->lex->current_select;
202
193
  Select_Lex *sl, *first_sl= first_select();
203
194
  select_result *tmp_result;
204
195
  bool is_union_select;
235
226
  prepared= 1;
236
227
  saved_error= false;
237
228
 
238
 
  session_arg->getLex()->current_select= sl= first_sl;
 
229
  session_arg->lex->current_select= sl= first_sl;
239
230
  found_rows_for_union= first_sl->options & OPTION_FOUND_ROWS;
240
231
  is_union_select= is_union() || fake_select_lex;
241
232
 
257
248
  {
258
249
    bool can_skip_order_by;
259
250
    sl->options|=  SELECT_NO_UNLOCK;
260
 
    Join *join= new Join(session_arg, sl->item_list,
 
251
    JOIN *join= new JOIN(session_arg, sl->item_list,
261
252
                         sl->options | session_arg->options | additional_options,
262
253
                         tmp_result);
263
254
    /*
270
261
    if (!join)
271
262
      goto err;
272
263
 
273
 
    session_arg->getLex()->current_select= sl;
 
264
    session_arg->lex->current_select= sl;
274
265
 
275
266
    can_skip_order_by= is_union_select && !(sl->braces && sl->explicit_limit);
276
267
 
282
273
                                sl->order_list.elements) +
283
274
                               sl->group_list.elements,
284
275
                               can_skip_order_by ?
285
 
                               (Order*) NULL : (Order *)sl->order_list.first,
286
 
                               (Order*) sl->group_list.first,
 
276
                               (order_st*) 0 : (order_st *)sl->order_list.first,
 
277
                               (order_st*) sl->group_list.first,
287
278
                               sl->having,
288
279
                               sl, this);
289
280
    /* There are no * in the statement anymore (for PS) */
307
298
      */
308
299
      assert(!empty_table);
309
300
      empty_table= (Table*) session->calloc(sizeof(Table));
310
 
      types.clear();
311
 
      List<Item>::iterator it(sl->item_list.begin());
 
301
      types.empty();
 
302
      List_iterator_fast<Item> it(sl->item_list);
312
303
      Item *item_tmp;
313
304
      while ((item_tmp= it++))
314
305
      {
327
318
                   ER(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT),MYF(0));
328
319
        goto err;
329
320
      }
330
 
      List<Item>::iterator it(sl->item_list.begin());
331
 
      List<Item>::iterator tp(types.begin());
 
321
      List_iterator_fast<Item> it(sl->item_list);
 
322
      List_iterator_fast<Item> tp(types);
332
323
      Item *type, *item_tmp;
333
324
      while ((type= tp++, item_tmp= it++))
334
325
      {
344
335
      Check that it was possible to aggregate
345
336
      all collations together for UNION.
346
337
    */
347
 
    List<Item>::iterator tp(types.begin());
 
338
    List_iterator_fast<Item> tp(types);
348
339
    Item *type;
349
340
    uint64_t create_options;
350
341
 
362
353
                     TMP_TABLE_ALL_COLUMNS);
363
354
 
364
355
    if (union_result->create_result_table(session, &types, test(union_distinct),
365
 
                                          create_options, ""))
 
356
                                          create_options, "", false))
366
357
      goto err;
367
358
    memset(&result_table_list, 0, sizeof(result_table_list));
368
 
    result_table_list.setSchemaName((char*) "");
 
359
    result_table_list.db= (char*) "";
369
360
    result_table_list.alias= "union";
370
 
    result_table_list.setTableName((char *) "union");
 
361
    result_table_list.table_name= (char *) "union";
371
362
    result_table_list.table= table= union_result->table;
372
363
 
373
 
    session_arg->getLex()->current_select= lex_select_save;
 
364
    session_arg->lex->current_select= lex_select_save;
374
365
    if (!item_list.elements)
375
366
    {
376
367
      saved_error= table->fill_item_list(&item_list);
387
378
    }
388
379
  }
389
380
 
390
 
  session_arg->getLex()->current_select= lex_select_save;
 
381
  session_arg->lex->current_select= lex_select_save;
391
382
 
392
383
  return(saved_error || session_arg->is_fatal_error);
393
384
 
394
385
err:
395
 
  session_arg->getLex()->current_select= lex_select_save;
 
386
  session_arg->lex->current_select= lex_select_save;
396
387
  return(true);
397
388
}
398
389
 
399
390
 
400
391
bool Select_Lex_Unit::exec()
401
392
{
402
 
  Select_Lex *lex_select_save= session->getLex()->current_select;
 
393
  Select_Lex *lex_select_save= session->lex->current_select;
403
394
  Select_Lex *select_cursor=first_select();
404
395
  uint64_t add_rows=0;
405
396
  ha_rows examined_rows= 0;
406
397
 
407
 
  if (executed && uncacheable.none() && ! describe)
408
 
    return false;
 
398
  if (executed && !uncacheable && !describe)
 
399
    return(false);
409
400
  executed= 1;
410
401
 
411
 
  if (uncacheable.any() || ! item || ! item->assigned() || describe)
 
402
  if (uncacheable || !item || !item->assigned() || describe)
412
403
  {
413
404
    if (item)
414
405
      item->reset_value_registration();
418
409
      {
419
410
        item->assigned(0); // We will reinit & rexecute unit
420
411
        item->reset();
421
 
        table->cursor->ha_delete_all_rows();
 
412
        table->file->ha_delete_all_rows();
422
413
      }
423
414
      /* re-enabling indexes for next subselect iteration */
424
 
      if (union_distinct && table->cursor->ha_enable_indexes(HA_KEY_SWITCH_ALL))
 
415
      if (union_distinct && table->file->ha_enable_indexes(HA_KEY_SWITCH_ALL))
425
416
      {
426
417
        assert(0);
427
418
      }
429
420
    for (Select_Lex *sl= select_cursor; sl; sl= sl->next_select())
430
421
    {
431
422
      ha_rows records_at_start= 0;
432
 
      session->getLex()->current_select= sl;
 
423
      session->lex->current_select= sl;
433
424
 
434
425
      if (optimized)
435
426
        saved_error= sl->join->reinit();
440
431
        {
441
432
          offset_limit_cnt= 0;
442
433
          /*
443
 
            We can't use LIMIT at this stage if we are using ORDER BY for the
 
434
            We can't use LIMIT at this stage if we are using order_st BY for the
444
435
            whole query
445
436
          */
446
437
          if (sl->order_list.first || describe)
460
451
      }
461
452
      if (!saved_error)
462
453
      {
463
 
        records_at_start= table->cursor->stats.records;
 
454
        records_at_start= table->file->stats.records;
464
455
        sl->join->exec();
465
456
        if (sl == union_distinct)
466
457
        {
467
 
          if (table->cursor->ha_disable_indexes(HA_KEY_SWITCH_ALL))
 
458
          if (table->file->ha_disable_indexes(HA_KEY_SWITCH_ALL))
468
459
            return(true);
469
460
          table->no_keyread=1;
470
461
        }
477
468
          examined_rows+= session->examined_row_count;
478
469
          if (union_result->flush())
479
470
          {
480
 
            session->getLex()->current_select= lex_select_save;
 
471
            session->lex->current_select= lex_select_save;
481
472
            return(1);
482
473
          }
483
474
        }
484
475
      }
485
476
      if (saved_error)
486
477
      {
487
 
        session->getLex()->current_select= lex_select_save;
 
478
        session->lex->current_select= lex_select_save;
488
479
        return(saved_error);
489
480
      }
490
481
      /* Needed for the following test and for records_at_start in next loop */
491
 
      int error= table->cursor->info(HA_STATUS_VARIABLE);
492
 
      if (error)
 
482
      int error= table->file->info(HA_STATUS_VARIABLE);
 
483
      if(error)
493
484
      {
494
 
        table->print_error(error, MYF(0));
 
485
        table->file->print_error(error, MYF(0));
495
486
        return(1);
496
487
      }
497
488
      if (found_rows_for_union && !sl->braces &&
504
495
          rows and actual rows added to the temporary table.
505
496
        */
506
497
        add_rows+= (uint64_t) (session->limit_found_rows - (uint64_t)
507
 
                              ((table->cursor->stats.records -  records_at_start)));
 
498
                              ((table->file->stats.records -  records_at_start)));
508
499
      }
509
500
    }
510
501
  }
517
508
    {
518
509
      set_limit(global_parameters);
519
510
      init_prepare_fake_select_lex(session);
520
 
      Join *join= fake_select_lex->join;
 
511
      JOIN *join= fake_select_lex->join;
521
512
      if (!join)
522
513
      {
523
514
        /*
524
515
          allocate JOIN for fake select only once (prevent
525
 
          select_query automatic allocation)
526
 
          TODO: The above is nonsense. select_query() will not allocate the
 
516
          mysql_select automatic allocation)
 
517
          TODO: The above is nonsense. mysql_select() will not allocate the
527
518
          join if one already exists. There must be some other reason why we
528
519
          don't let it allocate the join. Perhaps this is because we need
529
520
          some special parameter values passed to join constructor?
530
521
        */
531
 
        if (!(fake_select_lex->join= new Join(session, item_list,
 
522
        if (!(fake_select_lex->join= new JOIN(session, item_list,
532
523
                                              fake_select_lex->options, result)))
533
524
        {
534
 
          fake_select_lex->table_list.clear();
 
525
          fake_select_lex->table_list.empty();
535
526
          return(true);
536
527
        }
537
528
        fake_select_lex->join->no_const_tables= true;
541
532
          allocation.
542
533
        */
543
534
        fake_select_lex->item_list= item_list;
544
 
        saved_error= select_query(session, &fake_select_lex->ref_pointer_array,
 
535
        saved_error= mysql_select(session, &fake_select_lex->ref_pointer_array,
545
536
                              &result_table_list,
546
537
                              0, item_list, NULL,
547
538
                              global_parameters->order_list.elements,
548
 
                              (Order*)global_parameters->order_list.first,
549
 
                              (Order*) NULL, NULL,
 
539
                              (order_st*)global_parameters->order_list.first,
 
540
                              (order_st*) NULL, NULL,
550
541
                              fake_select_lex->options | SELECT_NO_UNLOCK,
551
542
                              result, this, fake_select_lex);
552
543
      }
564
555
            to reset them back, we re-do all of the actions (yes it is ugly):
565
556
          */
566
557
                join->reset(session, item_list, fake_select_lex->options, result);
567
 
          saved_error= select_query(session, &fake_select_lex->ref_pointer_array,
 
558
          saved_error= mysql_select(session, &fake_select_lex->ref_pointer_array,
568
559
                                &result_table_list,
569
560
                                0, item_list, NULL,
570
561
                                global_parameters->order_list.elements,
571
 
                                (Order*)global_parameters->order_list.first,
572
 
                                (Order*) NULL, NULL,
 
562
                                (order_st*)global_parameters->order_list.first,
 
563
                                (order_st*) NULL, NULL,
573
564
                                fake_select_lex->options | SELECT_NO_UNLOCK,
574
565
                                result, this, fake_select_lex);
575
566
        }
581
572
        }
582
573
      }
583
574
 
584
 
      fake_select_lex->table_list.clear();
 
575
      fake_select_lex->table_list.empty();
585
576
      if (!saved_error)
586
577
      {
587
 
        session->limit_found_rows = (uint64_t)table->cursor->stats.records + add_rows;
 
578
        session->limit_found_rows = (uint64_t)table->file->stats.records + add_rows;
588
579
        session->examined_row_count+= examined_rows;
589
580
      }
590
581
      /*
593
584
      */
594
585
    }
595
586
  }
596
 
  session->getLex()->current_select= lex_select_save;
 
587
  session->lex->current_select= lex_select_save;
597
588
  return(saved_error);
598
589
}
599
590
 
610
601
 
611
602
  if (union_result)
612
603
  {
613
 
    safe_delete(union_result);
 
604
    delete union_result;
 
605
    union_result=0; // Safety
 
606
    if (table)
 
607
      table->free_tmp_table(session);
614
608
    table= 0; // Safety
615
609
  }
616
610
 
619
613
 
620
614
  if (fake_select_lex)
621
615
  {
622
 
    Join *join;
 
616
    JOIN *join;
623
617
    if ((join= fake_select_lex->join))
624
618
    {
625
619
      join->tables_list= 0;
628
622
    error|= fake_select_lex->cleanup();
629
623
    if (fake_select_lex->order_list.elements)
630
624
    {
631
 
      Order *ord;
632
 
      for (ord= (Order*)fake_select_lex->order_list.first; ord; ord= ord->next)
 
625
      order_st *ord;
 
626
      for (ord= (order_st*)fake_select_lex->order_list.first; ord; ord= ord->next)
633
627
        (*ord->item)->cleanup();
634
628
    }
635
629
  }
712
706
  {
713
707
    assert((Select_Lex*)join->select_lex == this);
714
708
    error= join->destroy();
715
 
    safe_delete(join);
 
709
    delete join;
 
710
    join= 0;
716
711
  }
717
712
  for (Select_Lex_Unit *lex_unit= first_inner_unit(); lex_unit ;
718
713
       lex_unit= lex_unit->next_unit())
719
714
  {
720
715
    error= (bool) ((uint32_t) error | (uint32_t) lex_unit->cleanup());
721
716
  }
722
 
  non_agg_fields.clear();
723
 
  inner_refs_list.clear();
 
717
  non_agg_fields.empty();
 
718
  inner_refs_list.empty();
724
719
  return(error);
725
720
}
726
721
 
737
732
    for (sl= unit->first_select(); sl; sl= sl->next_select())
738
733
      sl->cleanup_all_joins(full);
739
734
}
740
 
 
741
 
} /* namespace drizzled */