← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_union.cc

  • Committer: Brian Aker
  • Date: 2008-10-12 01:59:02 UTC
  • Revision ID: brian@tangent.org-20081012015902-prhy6wsimdqr28om
Dead code around unsigned (first pass)

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"
 
20
#include <drizzled/server_includes.h>
21
21
#include <drizzled/sql_select.h>
22
 
#include <drizzled/error.h>
23
 
#include <drizzled/item/type_holder.h>
24
 
#include <drizzled/sql_base.h>
25
 
#include <drizzled/sql_union.h>
26
 
 
27
 
namespace drizzled
28
 
{
29
 
 
30
 
bool drizzle_union(Session *session, LEX *, select_result *result,
31
 
                   Select_Lex_Unit *unit, uint64_t setup_tables_done_option)
 
22
#include <drizzled/drizzled_error_messages.h>
 
23
 
 
24
bool mysql_union(THD *thd,
 
25
                 LEX *lex __attribute__((unused)),
 
26
                 select_result *result,
 
27
                 SELECT_LEX_UNIT *unit, ulong setup_tables_done_option)
32
28
{
33
29
  bool res;
34
 
  if (!(res= unit->prepare(session, result, SELECT_NO_UNLOCK |
 
30
  if (!(res= unit->prepare(thd, result, SELECT_NO_UNLOCK |
35
31
                           setup_tables_done_option)))
36
32
    res= unit->exec();
37
33
  if (res)
44
40
** store records in temporary table for UNION
45
41
***************************************************************************/
46
42
 
47
 
int select_union::prepare(List<Item> &, Select_Lex_Unit *u)
 
43
int select_union::prepare(List<Item> &list __attribute__((unused)),
 
44
                          SELECT_LEX_UNIT *u)
48
45
{
49
46
  unit= u;
50
47
  return 0;
59
56
    unit->offset_limit_cnt--;
60
57
    return 0;
61
58
  }
62
 
  fill_record(session, table->getFields(), values, true);
63
 
  if (session->is_error())
 
59
  fill_record(thd, table->field, values, 1);
 
60
  if (thd->is_error())
64
61
    return 1;
65
62
 
66
 
  if ((error= table->cursor->insertRecord(table->getInsertRecord())))
 
63
  if ((error= table->file->ha_write_row(table->record[0])))
67
64
  {
68
65
    /* create_myisam_from_heap will generate error if needed */
69
 
    if (table->cursor->is_fatal_error(error, HA_CHECK_DUP))
70
 
    {
71
 
      my_error(ER_USE_SQL_BIG_RESULT, MYF(0));
72
 
      return true;
73
 
    }
 
66
    if (table->file->is_fatal_error(error, HA_CHECK_DUP) &&
 
67
        create_myisam_from_heap(thd, table, tmp_table_param.start_recinfo, 
 
68
                                &tmp_table_param.recinfo, error, 1))
 
69
      return 1;
74
70
  }
75
71
  return 0;
76
72
}
85
81
bool select_union::flush()
86
82
{
87
83
  int error;
88
 
  if ((error=table->cursor->extra(HA_EXTRA_NO_CACHE)))
 
84
  if ((error=table->file->extra(HA_EXTRA_NO_CACHE)))
89
85
  {
90
 
    table->print_error(error, MYF(0));
 
86
    table->file->print_error(error, MYF(0));
91
87
    return 1;
92
88
  }
93
89
  return 0;
98
94
 
99
95
  SYNOPSIS
100
96
    select_union::create_result_table()
101
 
      session                thread handle
 
97
      thd                thread handle
102
98
      column_types       a list of items used to define columns of the
103
99
                         temporary table
104
100
      is_union_distinct  if set, the temporary table will eliminate
105
101
                         duplicates on insert
106
102
      options            create options
107
103
      table_alias        name of the temporary table
 
104
      bit_fields_as_long convert bit fields to uint64_t
108
105
 
109
106
  DESCRIPTION
110
107
    Create a temporary table that is used to store the result of a UNION,
116
113
*/
117
114
 
118
115
bool
119
 
select_union::create_result_table(Session *session_arg, List<Item> *column_types,
 
116
select_union::create_result_table(THD *thd_arg, List<Item> *column_types,
120
117
                                  bool is_union_distinct, uint64_t options,
121
 
                                  const char *table_alias)
 
118
                                  const char *table_alias,
 
119
                                  bool bit_fields_as_long)
122
120
{
123
 
  assert(table == NULL);
 
121
  assert(table == 0);
124
122
  tmp_table_param.init();
125
123
  tmp_table_param.field_count= column_types->elements;
 
124
  tmp_table_param.bit_fields_as_long= bit_fields_as_long;
126
125
 
127
 
  if (! (table= create_tmp_table(session_arg, &tmp_table_param, *column_types,
128
 
                                 (Order*) NULL, is_union_distinct, 1,
 
126
  if (! (table= create_tmp_table(thd_arg, &tmp_table_param, *column_types,
 
127
                                 (order_st*) 0, is_union_distinct, 1,
129
128
                                 options, HA_POS_ERROR, (char*) table_alias)))
130
 
  {
131
129
    return true;
132
 
  }
133
 
 
134
 
  table->cursor->extra(HA_EXTRA_WRITE_CACHE);
135
 
  table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
136
 
 
 
130
  table->file->extra(HA_EXTRA_WRITE_CACHE);
 
131
  table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
137
132
  return false;
138
133
}
139
134
 
147
142
 
148
143
void select_union::cleanup()
149
144
{
150
 
  table->cursor->extra(HA_EXTRA_RESET_STATE);
151
 
  table->cursor->ha_delete_all_rows();
152
 
  table->free_io_cache();
153
 
  table->filesort_free_buffers();
 
145
  table->file->extra(HA_EXTRA_RESET_STATE);
 
146
  table->file->ha_delete_all_rows();
 
147
  free_io_cache(table);
 
148
  filesort_free_buffers(table,0);
154
149
}
155
150
 
156
151
 
158
153
  initialization procedures before fake_select_lex preparation()
159
154
 
160
155
  SYNOPSIS
161
 
    Select_Lex_Unit::init_prepare_fake_select_lex()
162
 
    session             - thread handler
 
156
    st_select_lex_unit::init_prepare_fake_select_lex()
 
157
    thd         - thread handler
163
158
 
164
159
  RETURN
165
160
    options of SELECT
166
161
*/
167
162
 
168
163
void
169
 
Select_Lex_Unit::init_prepare_fake_select_lex(Session *session_arg)
 
164
st_select_lex_unit::init_prepare_fake_select_lex(THD *thd_arg) 
170
165
{
171
 
  session_arg->lex->current_select= fake_select_lex;
 
166
  thd_arg->lex->current_select= fake_select_lex;
172
167
  fake_select_lex->table_list.link_in_list((unsigned char *)&result_table_list,
173
168
                                           (unsigned char **)
174
169
                                           &result_table_list.next_local);
175
 
  fake_select_lex->context.table_list=
176
 
    fake_select_lex->context.first_name_resolution_table=
 
170
  fake_select_lex->context.table_list= 
 
171
    fake_select_lex->context.first_name_resolution_table= 
177
172
    fake_select_lex->get_table_list();
178
173
 
179
 
  for (Order *order= (Order *) global_parameters->order_list.first;
 
174
  for (order_st *order= (order_st *) global_parameters->order_list.first;
180
175
       order;
181
176
       order= order->next)
182
177
    order->item= &order->item_ptr;
183
178
 
184
 
  for (Order *order= (Order *)global_parameters->order_list.first;
 
179
  for (order_st *order= (order_st *)global_parameters->order_list.first;
185
180
       order;
186
181
       order=order->next)
187
182
  {
191
186
}
192
187
 
193
188
 
194
 
bool Select_Lex_Unit::prepare(Session *session_arg, select_result *sel_result,
195
 
                              uint64_t additional_options)
 
189
bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
 
190
                                 uint32_t additional_options)
196
191
{
197
 
  Select_Lex *lex_select_save= session_arg->lex->current_select;
198
 
  Select_Lex *sl, *first_sl= first_select();
 
192
  SELECT_LEX *lex_select_save= thd_arg->lex->current_select;
 
193
  SELECT_LEX *sl, *first_sl= first_select();
199
194
  select_result *tmp_result;
200
195
  bool is_union_select;
201
196
  Table *empty_table= 0;
230
225
  }
231
226
  prepared= 1;
232
227
  saved_error= false;
233
 
 
234
 
  session_arg->lex->current_select= sl= first_sl;
 
228
  
 
229
  thd_arg->lex->current_select= sl= first_sl;
235
230
  found_rows_for_union= first_sl->options & OPTION_FOUND_ROWS;
236
231
  is_union_select= is_union() || fake_select_lex;
237
232
 
253
248
  {
254
249
    bool can_skip_order_by;
255
250
    sl->options|=  SELECT_NO_UNLOCK;
256
 
    Join *join= new Join(session_arg, sl->item_list,
257
 
                         sl->options | session_arg->options | additional_options,
 
251
    JOIN *join= new JOIN(thd_arg, sl->item_list, 
 
252
                         sl->options | thd_arg->options | additional_options,
258
253
                         tmp_result);
259
254
    /*
260
255
      setup_tables_done_option should be set only for very first SELECT,
266
261
    if (!join)
267
262
      goto err;
268
263
 
269
 
    session_arg->lex->current_select= sl;
 
264
    thd_arg->lex->current_select= sl;
270
265
 
271
266
    can_skip_order_by= is_union_select && !(sl->braces && sl->explicit_limit);
272
267
 
278
273
                                sl->order_list.elements) +
279
274
                               sl->group_list.elements,
280
275
                               can_skip_order_by ?
281
 
                               (Order*) NULL : (Order *)sl->order_list.first,
282
 
                               (Order*) sl->group_list.first,
 
276
                               (order_st*) 0 : (order_st *)sl->order_list.first,
 
277
                               (order_st*) sl->group_list.first,
283
278
                               sl->having,
 
279
                               (is_union_select ? (order_st*) 0 :
 
280
                                (order_st*) thd_arg->lex->proc_list.first),
284
281
                               sl, this);
285
282
    /* There are no * in the statement anymore (for PS) */
286
283
    sl->with_wild= 0;
287
284
 
288
 
    if (saved_error || (saved_error= session_arg->is_fatal_error))
 
285
    if (saved_error || (saved_error= thd_arg->is_fatal_error))
289
286
      goto err;
290
287
    /*
291
288
      Use items list of underlaid select for derived tables to preserve
302
299
        field object without table.
303
300
      */
304
301
      assert(!empty_table);
305
 
      empty_table= (Table*) session->calloc(sizeof(Table));
 
302
      empty_table= (Table*) thd->calloc(sizeof(Table));
306
303
      types.empty();
307
304
      List_iterator_fast<Item> it(sl->item_list);
308
305
      Item *item_tmp;
309
306
      while ((item_tmp= it++))
310
307
      {
311
308
        /* Error's in 'new' will be detected after loop */
312
 
        types.push_back(new Item_type_holder(session_arg, item_tmp));
 
309
        types.push_back(new Item_type_holder(thd_arg, item_tmp));
313
310
      }
314
311
 
315
 
      if (session_arg->is_fatal_error)
 
312
      if (thd_arg->is_fatal_error)
316
313
        goto err; // out of memory
317
314
    }
318
315
    else
324
321
        goto err;
325
322
      }
326
323
      List_iterator_fast<Item> it(sl->item_list);
327
 
      List_iterator_fast<Item> tp(types);
 
324
      List_iterator_fast<Item> tp(types);       
328
325
      Item *type, *item_tmp;
329
326
      while ((type= tp++, item_tmp= it++))
330
327
      {
331
 
        if (((Item_type_holder*)type)->join_types(session_arg, item_tmp))
 
328
        if (((Item_type_holder*)type)->join_types(thd_arg, item_tmp))
332
329
          return(true);
333
330
      }
334
331
    }
353
350
        goto err;
354
351
      }
355
352
    }
356
 
 
357
 
    create_options= (first_sl->options | session_arg->options |
 
353
    
 
354
    create_options= (first_sl->options | thd_arg->options |
358
355
                     TMP_TABLE_ALL_COLUMNS);
359
356
 
360
 
    if (union_result->create_result_table(session, &types, test(union_distinct),
361
 
                                          create_options, ""))
 
357
    if (union_result->create_result_table(thd, &types, test(union_distinct),
 
358
                                          create_options, "", false))
362
359
      goto err;
363
360
    memset(&result_table_list, 0, sizeof(result_table_list));
364
 
    result_table_list.setSchemaName((char*) "");
365
 
    result_table_list.alias= "union";
366
 
    result_table_list.setTableName((char *) "union");
 
361
    result_table_list.db= (char*) "";
 
362
    result_table_list.table_name= result_table_list.alias= (char*) "union";
367
363
    result_table_list.table= table= union_result->table;
368
364
 
369
 
    session_arg->lex->current_select= lex_select_save;
 
365
    thd_arg->lex->current_select= lex_select_save;
370
366
    if (!item_list.elements)
371
367
    {
372
368
      saved_error= table->fill_item_list(&item_list);
383
379
    }
384
380
  }
385
381
 
386
 
  session_arg->lex->current_select= lex_select_save;
 
382
  thd_arg->lex->current_select= lex_select_save;
387
383
 
388
 
  return(saved_error || session_arg->is_fatal_error);
 
384
  return(saved_error || thd_arg->is_fatal_error);
389
385
 
390
386
err:
391
 
  session_arg->lex->current_select= lex_select_save;
 
387
  thd_arg->lex->current_select= lex_select_save;
392
388
  return(true);
393
389
}
394
390
 
395
391
 
396
 
bool Select_Lex_Unit::exec()
 
392
bool st_select_lex_unit::exec()
397
393
{
398
 
  Select_Lex *lex_select_save= session->lex->current_select;
399
 
  Select_Lex *select_cursor=first_select();
 
394
  SELECT_LEX *lex_select_save= thd->lex->current_select;
 
395
  SELECT_LEX *select_cursor=first_select();
400
396
  uint64_t add_rows=0;
401
397
  ha_rows examined_rows= 0;
402
398
 
403
 
  if (executed && uncacheable.none() && ! describe)
404
 
    return false;
 
399
  if (executed && !uncacheable && !describe)
 
400
    return(false);
405
401
  executed= 1;
406
 
 
407
 
  if (uncacheable.any() || ! item || ! item->assigned() || describe)
 
402
  
 
403
  if (uncacheable || !item || !item->assigned() || describe)
408
404
  {
409
405
    if (item)
410
406
      item->reset_value_registration();
414
410
      {
415
411
        item->assigned(0); // We will reinit & rexecute unit
416
412
        item->reset();
417
 
        table->cursor->ha_delete_all_rows();
 
413
        table->file->ha_delete_all_rows();
418
414
      }
419
415
      /* re-enabling indexes for next subselect iteration */
420
 
      if (union_distinct && table->cursor->ha_enable_indexes(HA_KEY_SWITCH_ALL))
 
416
      if (union_distinct && table->file->ha_enable_indexes(HA_KEY_SWITCH_ALL))
421
417
      {
422
418
        assert(0);
423
419
      }
424
420
    }
425
 
    for (Select_Lex *sl= select_cursor; sl; sl= sl->next_select())
 
421
    for (SELECT_LEX *sl= select_cursor; sl; sl= sl->next_select())
426
422
    {
427
423
      ha_rows records_at_start= 0;
428
 
      session->lex->current_select= sl;
 
424
      thd->lex->current_select= sl;
429
425
 
430
426
      if (optimized)
431
427
        saved_error= sl->join->reinit();
436
432
        {
437
433
          offset_limit_cnt= 0;
438
434
          /*
439
 
            We can't use LIMIT at this stage if we are using ORDER BY for the
 
435
            We can't use LIMIT at this stage if we are using order_st BY for the
440
436
            whole query
441
437
          */
442
438
          if (sl->order_list.first || describe)
448
444
          we don't calculate found_rows() per union part.
449
445
          Otherwise, SQL_CALC_FOUND_ROWS should be done on all sub parts.
450
446
        */
451
 
        sl->join->select_options=
 
447
        sl->join->select_options= 
452
448
          (select_limit_cnt == HA_POS_ERROR || sl->braces) ?
453
449
          sl->options & ~OPTION_FOUND_ROWS : sl->options | found_rows_for_union;
454
450
 
 
451
        /* dump_TableList_struct(select_lex, select_lex->leaf_tables); */
 
452
        if (sl->join->flatten_subqueries())
 
453
          return(true);
 
454
 
 
455
        /* dump_TableList_struct(select_lex, select_lex->leaf_tables); */
455
456
        saved_error= sl->join->optimize();
456
457
      }
457
458
      if (!saved_error)
458
459
      {
459
 
        records_at_start= table->cursor->stats.records;
 
460
        records_at_start= table->file->stats.records;
460
461
        sl->join->exec();
461
462
        if (sl == union_distinct)
462
463
        {
463
 
          if (table->cursor->ha_disable_indexes(HA_KEY_SWITCH_ALL))
 
464
          if (table->file->ha_disable_indexes(HA_KEY_SWITCH_ALL))
464
465
            return(true);
465
466
          table->no_keyread=1;
466
467
        }
470
471
                                    0);
471
472
        if (!saved_error)
472
473
        {
473
 
          examined_rows+= session->examined_row_count;
 
474
          examined_rows+= thd->examined_row_count;
474
475
          if (union_result->flush())
475
476
          {
476
 
            session->lex->current_select= lex_select_save;
 
477
            thd->lex->current_select= lex_select_save;
477
478
            return(1);
478
479
          }
479
480
        }
480
481
      }
481
482
      if (saved_error)
482
483
      {
483
 
        session->lex->current_select= lex_select_save;
 
484
        thd->lex->current_select= lex_select_save;
484
485
        return(saved_error);
485
486
      }
486
487
      /* Needed for the following test and for records_at_start in next loop */
487
 
      int error= table->cursor->info(HA_STATUS_VARIABLE);
488
 
      if (error)
 
488
      int error= table->file->info(HA_STATUS_VARIABLE);
 
489
      if(error)
489
490
      {
490
 
        table->print_error(error, MYF(0));
 
491
        table->file->print_error(error, MYF(0));
491
492
        return(1);
492
493
      }
493
 
      if (found_rows_for_union && !sl->braces &&
 
494
      if (found_rows_for_union && !sl->braces && 
494
495
          select_limit_cnt != HA_POS_ERROR)
495
496
      {
496
497
        /*
499
500
          We get this from the difference of between total number of possible
500
501
          rows and actual rows added to the temporary table.
501
502
        */
502
 
        add_rows+= (uint64_t) (session->limit_found_rows - (uint64_t)
503
 
                              ((table->cursor->stats.records -  records_at_start)));
 
503
        add_rows+= (uint64_t) (thd->limit_found_rows - (uint64_t)
 
504
                              ((table->file->stats.records -  records_at_start)));
504
505
      }
505
506
    }
506
507
  }
509
510
  /* Send result to 'result' */
510
511
  saved_error= true;
511
512
  {
512
 
    if (!session->is_fatal_error)                               // Check if EOM
 
513
    if (!thd->is_fatal_error)                           // Check if EOM
513
514
    {
514
515
      set_limit(global_parameters);
515
 
      init_prepare_fake_select_lex(session);
516
 
      Join *join= fake_select_lex->join;
 
516
      init_prepare_fake_select_lex(thd);
 
517
      JOIN *join= fake_select_lex->join;
517
518
      if (!join)
518
519
      {
519
520
        /*
524
525
          don't let it allocate the join. Perhaps this is because we need
525
526
          some special parameter values passed to join constructor?
526
527
        */
527
 
        if (!(fake_select_lex->join= new Join(session, item_list,
 
528
        if (!(fake_select_lex->join= new JOIN(thd, item_list,
528
529
                                              fake_select_lex->options, result)))
529
530
        {
530
531
          fake_select_lex->table_list.empty();
533
534
        fake_select_lex->join->no_const_tables= true;
534
535
 
535
536
        /*
536
 
          Fake Select_Lex should have item list for correctref_array
 
537
          Fake st_select_lex should have item list for correctref_array
537
538
          allocation.
538
539
        */
539
540
        fake_select_lex->item_list= item_list;
540
 
        saved_error= mysql_select(session, &fake_select_lex->ref_pointer_array,
 
541
        saved_error= mysql_select(thd, &fake_select_lex->ref_pointer_array,
541
542
                              &result_table_list,
542
543
                              0, item_list, NULL,
543
544
                              global_parameters->order_list.elements,
544
 
                              (Order*)global_parameters->order_list.first,
545
 
                              (Order*) NULL, NULL,
 
545
                              (order_st*)global_parameters->order_list.first,
 
546
                              (order_st*) NULL, NULL, (order_st*) NULL,
546
547
                              fake_select_lex->options | SELECT_NO_UNLOCK,
547
548
                              result, this, fake_select_lex);
548
549
      }
556
557
             - 1st time is a real evaluation to get the subquery value
557
558
             - 2nd time is to produce EXPLAIN output rows.
558
559
            1st execution sets certain members (e.g. select_result) to perform
559
 
            subquery execution rather than EXPLAIN line production. In order
 
560
            subquery execution rather than EXPLAIN line production. In order 
560
561
            to reset them back, we re-do all of the actions (yes it is ugly):
561
562
          */
562
 
                join->reset(session, item_list, fake_select_lex->options, result);
563
 
          saved_error= mysql_select(session, &fake_select_lex->ref_pointer_array,
 
563
          join->init(thd, item_list, fake_select_lex->options, result);
 
564
          saved_error= mysql_select(thd, &fake_select_lex->ref_pointer_array,
564
565
                                &result_table_list,
565
566
                                0, item_list, NULL,
566
567
                                global_parameters->order_list.elements,
567
 
                                (Order*)global_parameters->order_list.first,
568
 
                                (Order*) NULL, NULL,
 
568
                                (order_st*)global_parameters->order_list.first,
 
569
                                (order_st*) NULL, NULL, (order_st*) NULL,
569
570
                                fake_select_lex->options | SELECT_NO_UNLOCK,
570
571
                                result, this, fake_select_lex);
571
572
        }
580
581
      fake_select_lex->table_list.empty();
581
582
      if (!saved_error)
582
583
      {
583
 
        session->limit_found_rows = (uint64_t)table->cursor->stats.records + add_rows;
584
 
        session->examined_row_count+= examined_rows;
 
584
        thd->limit_found_rows = (uint64_t)table->file->stats.records + add_rows;
 
585
        thd->examined_row_count+= examined_rows;
585
586
      }
586
587
      /*
587
588
        Mark for slow query log if any of the union parts didn't use
589
590
      */
590
591
    }
591
592
  }
592
 
  session->lex->current_select= lex_select_save;
 
593
  thd->lex->current_select= lex_select_save;
593
594
  return(saved_error);
594
595
}
595
596
 
596
597
 
597
 
bool Select_Lex_Unit::cleanup()
 
598
bool st_select_lex_unit::cleanup()
598
599
{
599
600
  int error= 0;
600
601
 
608
609
  {
609
610
    delete union_result;
610
611
    union_result=0; // Safety
 
612
    if (table)
 
613
      table->free_tmp_table(thd);
611
614
    table= 0; // Safety
612
615
  }
613
616
 
614
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
617
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
615
618
    error|= sl->cleanup();
616
619
 
617
620
  if (fake_select_lex)
618
621
  {
619
 
    Join *join;
 
622
    JOIN *join;
620
623
    if ((join= fake_select_lex->join))
621
624
    {
622
625
      join->tables_list= 0;
625
628
    error|= fake_select_lex->cleanup();
626
629
    if (fake_select_lex->order_list.elements)
627
630
    {
628
 
      Order *ord;
629
 
      for (ord= (Order*)fake_select_lex->order_list.first; ord; ord= ord->next)
 
631
      order_st *ord;
 
632
      for (ord= (order_st*)fake_select_lex->order_list.first; ord; ord= ord->next)
630
633
        (*ord->item)->cleanup();
631
634
    }
632
635
  }
635
638
}
636
639
 
637
640
 
638
 
void Select_Lex_Unit::reinit_exec_mechanism()
 
641
void st_select_lex_unit::reinit_exec_mechanism()
639
642
{
640
643
  prepared= optimized= executed= 0;
641
644
}
645
648
  change select_result object of unit
646
649
 
647
650
  SYNOPSIS
648
 
    Select_Lex_Unit::change_result()
 
651
    st_select_lex_unit::change_result()
649
652
    result      new select_result object
650
653
    old_result  old select_result object
651
654
 
654
657
    true  - error
655
658
*/
656
659
 
657
 
bool Select_Lex_Unit::change_result(select_result_interceptor *new_result,
 
660
bool st_select_lex_unit::change_result(select_result_interceptor *new_result,
658
661
                                       select_result_interceptor *old_result)
659
662
{
660
663
  bool res= false;
661
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
664
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
662
665
  {
663
666
    if (sl->join && sl->join->result == old_result)
664
667
      if (sl->join->change_result(new_result))
673
676
  Get column type information for this unit.
674
677
 
675
678
  SYNOPSIS
676
 
    Select_Lex_Unit::get_unit_column_types()
 
679
    st_select_lex_unit::get_unit_column_types()
677
680
 
678
681
  DESCRIPTION
679
682
    For a single-select the column types are taken
680
683
    from the list of selected items. For a union this function
681
 
    assumes that Select_Lex_Unit::prepare has been called
 
684
    assumes that st_select_lex_unit::prepare has been called
682
685
    and returns the type holders that were created for unioned
683
686
    column types of all selects.
684
687
 
685
688
  NOTES
686
689
    The implementation of this function should be in sync with
687
 
    Select_Lex_Unit::prepare()
 
690
    st_select_lex_unit::prepare()
688
691
*/
689
692
 
690
 
List<Item> *Select_Lex_Unit::get_unit_column_types()
 
693
List<Item> *st_select_lex_unit::get_unit_column_types()
691
694
{
692
 
  Select_Lex *sl= first_select();
 
695
  SELECT_LEX *sl= first_select();
693
696
 
694
697
  if (is_union())
695
698
  {
701
704
  return &sl->item_list;
702
705
}
703
706
 
704
 
bool Select_Lex::cleanup()
 
707
bool st_select_lex::cleanup()
705
708
{
706
709
  bool error= false;
707
710
 
708
711
  if (join)
709
712
  {
710
 
    assert((Select_Lex*)join->select_lex == this);
 
713
    assert((st_select_lex*)join->select_lex == this);
711
714
    error= join->destroy();
712
715
    delete join;
713
716
    join= 0;
714
717
  }
715
 
  for (Select_Lex_Unit *lex_unit= first_inner_unit(); lex_unit ;
 
718
  for (SELECT_LEX_UNIT *lex_unit= first_inner_unit(); lex_unit ;
716
719
       lex_unit= lex_unit->next_unit())
717
720
  {
718
 
    error= (bool) ((uint32_t) error | (uint32_t) lex_unit->cleanup());
 
721
    error= (bool) ((uint) error | (uint) lex_unit->cleanup());
719
722
  }
720
723
  non_agg_fields.empty();
721
724
  inner_refs_list.empty();
723
726
}
724
727
 
725
728
 
726
 
void Select_Lex::cleanup_all_joins(bool full)
 
729
void st_select_lex::cleanup_all_joins(bool full)
727
730
{
728
 
  Select_Lex_Unit *unit;
729
 
  Select_Lex *sl;
 
731
  SELECT_LEX_UNIT *unit;
 
732
  SELECT_LEX *sl;
730
733
 
731
734
  if (join)
732
735
    join->cleanup(full);
735
738
    for (sl= unit->first_select(); sl; sl= sl->next_select())
736
739
      sl->cleanup_all_joins(full);
737
740
}
738
 
 
739
 
} /* namespace drizzled */