← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/explain_plan.cc

  • Committer: Monty Taylor
  • Date: 2010-08-12 20:27:32 UTC
  • mto: (1720.1.5 build)
  • mto: This revision was merged to the branch mainline in revision 1722.
  • Revision ID: mordred@inaugust.com-20100812202732-9kzchbkvkyki4n3u
Merged libdrizzle directly into tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/explain_plan.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008-2009 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008-2009 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include <config.h>
21
 
 
22
 
#include <drizzled/session.h>
23
 
#include <drizzled/item/uint.h>
24
 
#include <drizzled/item/float.h>
25
 
#include <drizzled/item/string.h>
26
 
#include <drizzled/optimizer/explain_plan.h>
27
 
#include <drizzled/optimizer/position.h>
28
 
#include <drizzled/optimizer/quick_ror_intersect_select.h>
29
 
#include <drizzled/optimizer/range.h>
30
 
#include <drizzled/sql_select.h>
31
 
#include <drizzled/join.h>
32
 
#include <drizzled/internal/m_string.h>
33
 
#include <drizzled/select_result.h>
 
20
#include "config.h"
 
21
#include "drizzled/session.h"
 
22
#include "drizzled/item/uint.h"
 
23
#include "drizzled/item/float.h"
 
24
#include "drizzled/optimizer/explain_plan.h"
 
25
#include "drizzled/optimizer/position.h"
 
26
#include "drizzled/optimizer/quick_ror_intersect_select.h"
 
27
#include "drizzled/optimizer/range.h"
 
28
#include "drizzled/sql_select.h"
 
29
#include "drizzled/join.h"
 
30
#include "drizzled/internal/m_string.h"
34
31
 
35
32
#include <cstdio>
36
33
#include <string>
37
34
#include <sstream>
38
 
#include <bitset>
39
35
 
40
36
using namespace std;
41
37
 
75
71
 
76
72
void optimizer::ExplainPlan::printPlan()
77
73
{
 
74
  List<Item> field_list;
78
75
  List<Item> item_list;
79
76
  Session *session= join->session;
80
77
  select_result *result= join->result;
99
96
    for (uint32_t i= 0; i < 7; i++)
100
97
      item_list.push_back(item_null);
101
98
 
102
 
    if (join->session->getLex()->describe & DESCRIBE_EXTENDED)
 
99
    if (join->session->lex->describe & DESCRIBE_EXTENDED)
103
100
      item_list.push_back(item_null);
104
101
 
105
102
    item_list.push_back(new Item_string(message,strlen(message),cs));
116
113
       appreciated :)
117
114
     */
118
115
    char table_name_buffer[NAME_LEN];
119
 
    item_list.clear();
 
116
    item_list.empty();
120
117
    /* id */
121
118
    item_list.push_back(new Item_null);
122
119
    /* select_type */
159
156
    /* ref */
160
157
    item_list.push_back(item_null);
161
158
    /* in_rows */
162
 
    if (join->session->getLex()->describe & DESCRIBE_EXTENDED)
 
159
    if (join->session->lex->describe & DESCRIBE_EXTENDED)
163
160
      item_list.push_back(item_null);
164
161
    /* rows */
165
162
    item_list.push_back(item_null);
181
178
    {
182
179
      JoinTable *tab= join->join_tab + i;
183
180
      Table *table= tab->table;
 
181
      char buff[512];
 
182
      char buff1[512], buff2[512], buff3[512];
184
183
      char keylen_str_buf[64];
185
 
      string extra;
 
184
      String extra(buff, sizeof(buff),cs);
186
185
      char table_name_buffer[NAME_LEN];
187
 
      string tmp1;
188
 
      string tmp2;
189
 
      string tmp3;
 
186
      String tmp1(buff1,sizeof(buff1),cs);
 
187
      String tmp2(buff2,sizeof(buff2),cs);
 
188
      String tmp3(buff3,sizeof(buff3),cs);
 
189
      extra.length(0);
 
190
      tmp1.length(0);
 
191
      tmp2.length(0);
 
192
      tmp3.length(0);
190
193
 
191
194
      quick_type= -1;
192
 
      item_list.clear();
 
195
      item_list.empty();
193
196
      /* id */
194
197
      item_list.push_back(new Item_uint((uint32_t)
195
198
            join->select_lex->select_number));
236
239
          if (tab->keys.test(j))
237
240
          {
238
241
            if (tmp1.length())
239
 
              tmp1.append(",");
 
242
              tmp1.append(',');
240
243
            tmp1.append(table->key_info[j].name,
241
 
                        strlen(table->key_info[j].name));
 
244
                        strlen(table->key_info[j].name),
 
245
                        system_charset_info);
242
246
          }
243
247
        }
244
248
      }
245
249
      if (tmp1.length())
246
 
        item_list.push_back(new Item_string(tmp1.c_str(),tmp1.length(),cs));
 
250
        item_list.push_back(new Item_string(tmp1.ptr(),tmp1.length(),cs));
247
251
      else
248
252
        item_list.push_back(item_null);
249
253
 
262
266
        for (StoredKey **ref= tab->ref.key_copy; *ref; ref++)
263
267
        {
264
268
          if (tmp2.length())
265
 
            tmp2.append(",");
266
 
          tmp2.append((*ref)->name(),
267
 
                      strlen((*ref)->name()));
 
269
            tmp2.append(',');
 
270
          tmp2.append((*ref)->name(), 
 
271
                       strlen((*ref)->name()),
 
272
                       system_charset_info);
268
273
        }
269
 
        item_list.push_back(new Item_string(tmp2.c_str(),tmp2.length(),cs));
 
274
        item_list.push_back(new Item_string(tmp2.ptr(),tmp2.length(),cs));
270
275
      }
271
276
      else if (tab->type == AM_NEXT)
272
277
      {
283
288
      else if (tab->select && tab->select->quick)
284
289
      {
285
290
        tab->select->quick->add_keys_and_lengths(&tmp2, &tmp3);
286
 
        item_list.push_back(new Item_string(tmp2.c_str(),tmp2.length(),cs));
287
 
        item_list.push_back(new Item_string(tmp3.c_str(),tmp3.length(),cs));
 
291
        item_list.push_back(new Item_string(tmp2.ptr(),tmp2.length(),cs));
 
292
        item_list.push_back(new Item_string(tmp3.ptr(),tmp3.length(),cs));
288
293
        item_list.push_back(item_null);
289
294
      }
290
295
      else
298
303
      double examined_rows;
299
304
      if (tab->select && tab->select->quick)
300
305
      {
301
 
        examined_rows= tab->select->quick->records;
 
306
        examined_rows= rows2double(tab->select->quick->records);
302
307
      }
303
308
      else if (tab->type == AM_NEXT || tab->type == AM_ALL)
304
309
      {
305
 
        examined_rows= tab->limit ? tab->limit : tab->table->cursor->records();
 
310
        examined_rows= rows2double(tab->limit ? tab->limit :
 
311
                                                tab->table->cursor->records());
306
312
      }
307
313
      else
308
314
      {
314
320
                                       MY_INT64_NUM_DECIMAL_DIGITS));
315
321
 
316
322
      /* Add "filtered" field to item_list. */
317
 
      if (join->session->getLex()->describe & DESCRIBE_EXTENDED)
 
323
      if (join->session->lex->describe & DESCRIBE_EXTENDED)
318
324
      {
319
325
        float f= 0.0;
320
326
        if (examined_rows)
339
345
      else if (tab->packed_info & TAB_INFO_HAVE_VALUE)
340
346
      {
341
347
        if (tab->packed_info & TAB_INFO_USING_INDEX)
342
 
          extra.append("; Using index");
 
348
          extra.append(STRING_WITH_LEN("; Using index"));
343
349
        if (tab->packed_info & TAB_INFO_USING_WHERE)
344
 
          extra.append("; Using where");
 
350
          extra.append(STRING_WITH_LEN("; Using where"));
345
351
        if (tab->packed_info & TAB_INFO_FULL_SCAN_ON_NULL)
346
 
          extra.append("; Full scan on NULL key");
347
 
        if (extra.length())
348
 
          extra.erase(0, 2);        /* Skip initial "; "*/
349
 
        item_list.push_back(new Item_string(extra.c_str(), extra.length(), cs));
 
352
          extra.append(STRING_WITH_LEN("; Full scan on NULL key"));
 
353
        /* Skip initial "; "*/
 
354
        const char *str= extra.ptr();
 
355
        uint32_t len= extra.length();
 
356
        if (len)
 
357
        {
 
358
          str += 2;
 
359
          len -= 2;
 
360
        }
 
361
        item_list.push_back(new Item_string(str, len, cs));
350
362
      }
351
363
      else
352
364
      {
360
372
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT ||
361
373
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE)
362
374
        {
363
 
          extra.append("; Using ");
 
375
          extra.append(STRING_WITH_LEN("; Using "));
364
376
          tab->select->quick->add_info_string(&extra);
365
377
        }
366
378
        if (tab->select)
385
397
              if (tmp.any())
386
398
                s << uppercase << hex << tmp.to_ulong();
387
399
            }
388
 
            extra.append("; Range checked for each record (index map: 0x");
 
400
            extra.append(STRING_WITH_LEN("; Range checked for each "
 
401
                  "record (index map: 0x"));
389
402
            extra.append(s.str().c_str());
390
 
            extra.append(")");
 
403
            extra.append(')');
391
404
          }
392
405
          else if (tab->select->cond)
393
406
          {
394
 
            extra.append("; Using where");
 
407
            extra.append(STRING_WITH_LEN("; Using where"));
395
408
          }
396
409
        }
397
410
        if (key_read)
398
411
        {
399
412
          if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX)
400
 
            extra.append("; Using index for group-by");
 
413
            extra.append(STRING_WITH_LEN("; Using index for group-by"));
401
414
          else
402
 
            extra.append("; Using index");
 
415
            extra.append(STRING_WITH_LEN("; Using index"));
403
416
        }
404
417
        if (table->reginfo.not_exists_optimize)
405
 
          extra.append("; Not exists");
 
418
          extra.append(STRING_WITH_LEN("; Not exists"));
406
419
 
407
420
        if (need_tmp_table)
408
421
        {
409
422
          need_tmp_table=0;
410
 
          extra.append("; Using temporary");
 
423
          extra.append(STRING_WITH_LEN("; Using temporary"));
411
424
        }
412
425
        if (need_order)
413
426
        {
414
427
          need_order=0;
415
 
          extra.append("; Using filesort");
 
428
          extra.append(STRING_WITH_LEN("; Using filesort"));
416
429
        }
417
430
        if (distinct & test_all_bits(used_tables,session->used_tables))
418
 
          extra.append("; Distinct");
 
431
          extra.append(STRING_WITH_LEN("; Distinct"));
419
432
 
420
433
        if (tab->insideout_match_tab)
421
434
        {
422
 
          extra.append("; LooseScan");
 
435
          extra.append(STRING_WITH_LEN("; LooseScan"));
423
436
        }
424
437
 
425
438
        for (uint32_t part= 0; part < tab->ref.key_parts; part++)
426
439
        {
427
440
          if (tab->ref.cond_guards[part])
428
441
          {
429
 
            extra.append("; Full scan on NULL key");
 
442
            extra.append(STRING_WITH_LEN("; Full scan on NULL key"));
430
443
            break;
431
444
          }
432
445
        }
433
446
 
434
447
        if (i > 0 && tab[-1].next_select == sub_select_cache)
435
 
          extra.append("; Using join buffer");
 
448
          extra.append(STRING_WITH_LEN("; Using join buffer"));
436
449
 
437
 
        if (extra.length())
438
 
          extra.erase(0, 2);
439
 
        item_list.push_back(new Item_string(extra.c_str(), extra.length(), cs));
 
450
        /* Skip initial "; "*/
 
451
        const char *str= extra.ptr();
 
452
        uint32_t len= extra.length();
 
453
        if (len)
 
454
        {
 
455
          str += 2;
 
456
          len -= 2;
 
457
        }
 
458
        item_list.push_back(new Item_string(str, len, cs));
440
459
      }
441
460
      // For next iteration
442
461
      used_tables|=table->map;
466
485
       sl= sl->next_select())
467
486
  {
468
487
    // drop UNCACHEABLE_EXPLAIN, because it is for internal usage only
469
 
    sl->uncacheable.reset(UNCACHEABLE_EXPLAIN);
470
 
    if (&session->getLex()->select_lex == sl)
 
488
    uint8_t uncacheable= (sl->uncacheable & ~UNCACHEABLE_EXPLAIN);
 
489
    if (&session->lex->select_lex == sl)
471
490
    {
472
491
      if (sl->first_inner_unit() || sl->next_select())
473
492
      {
488
507
        }
489
508
        else
490
509
        {
491
 
          if (sl->uncacheable.test(UNCACHEABLE_DEPENDENT))
 
510
          if (uncacheable & UNCACHEABLE_DEPENDENT)
492
511
          {
493
512
            sl->type= optimizer::ST_DEPENDENT_SUBQUERY;
494
513
          }
495
514
          else
496
515
          {
497
 
            if (sl->uncacheable.any())
 
516
            if (uncacheable)
498
517
            {
499
518
              sl->type= optimizer::ST_UNCACHEABLE_SUBQUERY;
500
519
            }
507
526
      }
508
527
      else
509
528
      {
510
 
        if (sl->uncacheable.test(UNCACHEABLE_DEPENDENT))
 
529
        if (uncacheable & UNCACHEABLE_DEPENDENT)
511
530
        {
512
531
          sl->type= optimizer::ST_DEPENDENT_UNION;
513
532
        }
514
533
        else
515
534
        {
516
 
          if (sl->uncacheable.any())
 
535
          if (uncacheable)
517
536
          {
518
537
            sl->type= optimizer::ST_UNCACHEABLE_UNION;
519
538
          }
540
559
  }
541
560
  else
542
561
  {
543
 
    session->getLex()->current_select= first;
 
562
    session->lex->current_select= first;
544
563
    unit->set_limit(unit->global_parameters);
545
 
    res= select_query(session, 
 
564
    res= mysql_select(session, 
546
565
                      &first->ref_pointer_array,
547
566
                      (TableList*) first->table_list.first,
548
567
                      first->with_wild, 
549
568
                      first->item_list,
550
569
                      first->where,
551
570
                      first->order_list.elements + first->group_list.elements,
552
 
                      (Order*) first->order_list.first,
553
 
                      (Order*) first->group_list.first,
 
571
                      (order_st*) first->order_list.first,
 
572
                      (order_st*) first->group_list.first,
554
573
                      first->having,
555
574
                      first->options | session->options | SELECT_DESCRIBE,
556
575
                      result,