← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/join.cc

  • Committer: Jay Pipes
  • Date: 2009-09-21 14:33:44 UTC
  • mfrom: (1126.10.26 dtrace-probes)
  • mto: This revision was merged to the branch mainline in revision 1133.
  • Revision ID: jpipes@serialcoder-20090921143344-jnarp7gcn6zmg19c
Merge fixes from Trond and Padraig on dtrace probes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/join.cc
27
27
 * @{
28
28
 */
29
29
 
30
 
#include "config.h"
31
 
 
32
 
#include <float.h>
33
 
#include <math.h>
34
 
 
 
30
#include "drizzled/server_includes.h"
 
31
#include "drizzled/table_map_iterator.h"
35
32
#include "drizzled/item/cache.h"
36
33
#include "drizzled/item/cmpfunc.h"
37
34
#include "drizzled/item/copy_string.h"
47
44
#include "drizzled/field/blob.h"
48
45
#include "drizzled/optimizer/position.h"
49
46
#include "drizzled/optimizer/sargable_param.h"
50
 
#include "drizzled/optimizer/key_use.h"
51
 
#include "drizzled/optimizer/range.h"
52
 
#include "drizzled/optimizer/sum.h"
53
 
#include "drizzled/optimizer/explain_plan.h"
54
 
#include "drizzled/records.h"
55
 
#include "drizzled/probes.h"
56
 
#include "drizzled/internal/my_bit.h"
57
 
#include "drizzled/internal/my_sys.h"
58
 
#include "drizzled/internal/iocache.h"
 
47
#include "mysys/my_bit.h"
59
48
 
60
49
#include <algorithm>
61
50
 
62
51
using namespace std;
63
 
 
64
 
namespace drizzled
65
 
{
66
 
 
67
 
extern plugin::StorageEngine *heap_engine;
68
 
extern std::bitset<12> test_flags;
 
52
using namespace drizzled;
69
53
 
70
54
/** Declarations of static functions used in this source file. */
71
55
static bool make_group_fields(JOIN *main_join, JOIN *curr_join);
74
58
static uint32_t cache_record_length(JOIN *join, uint32_t index);
75
59
static double prev_record_reads(JOIN *join, uint32_t idx, table_map found_ref);
76
60
static bool get_best_combination(JOIN *join);
77
 
static void set_position(JOIN *join,
78
 
                         uint32_t index,
79
 
                         JoinTable *table,
80
 
                         optimizer::KeyUse *key);
 
61
static void set_position(JOIN *join,uint32_t index,JoinTable *table,KeyUse *key);
81
62
static bool choose_plan(JOIN *join,table_map join_tables);
82
63
static void best_access_path(JOIN *join, JoinTable *s,
83
64
                             Session *session,
97
78
static uint32_t determine_search_depth(JOIN* join);
98
79
static bool make_simple_join(JOIN *join,Table *tmp_table);
99
80
static void make_outerjoin_info(JOIN *join);
100
 
static bool make_join_select(JOIN *join, optimizer::SqlSelect *select,COND *item);
 
81
static bool make_join_select(JOIN *join,SQL_SELECT *select,COND *item);
101
82
static bool make_join_readinfo(JOIN *join, uint64_t options, uint32_t no_jbuf_after);
102
83
static void update_depend_map(JOIN *join);
103
84
static void update_depend_map(JOIN *join, order_st *order);
199
180
        select_lex->leaf_tables, fields_list,
200
181
        all_fields, &conds, order, group_list,
201
182
        &hidden_group_fields))
202
 
    return(-1);
 
183
    return(-1);       /* purecov: inspected */
203
184
 
204
185
  ref_pointer_array= *rref_pointer_array;
205
186
 
214
195
        having->check_cols(1)));
215
196
    select_lex->having_fix_field= 0;
216
197
    if (having_fix_rc || session->is_error())
217
 
      return(-1);
 
198
      return(-1);       /* purecov: inspected */
218
199
    session->lex->allow_sum_func= save_allow_sum_func;
219
200
  }
220
201
 
231
212
        in_subs= (Item_in_subselect*)subselect;
232
213
 
233
214
      {
234
 
        bool do_materialize= true;
 
215
        bool do_materialize= !test(session->variables.optimizer_switch &
 
216
                                   OPTIMIZER_SWITCH_NO_MATERIALIZATION);
235
217
        /*
236
218
          Check if the subquery predicate can be executed via materialization.
237
219
          The required conditions are:
249
231
             (Subquery is non-correlated ||
250
232
              Subquery is correlated to any query outer to IN predicate ||
251
233
              (Subquery is correlated to the immediate outer query &&
252
 
               Subquery !contains {GROUP BY, ORDER BY [LIMIT],
 
234
               Subquery !contains {GROUP BY, order_st BY [LIMIT],
253
235
               aggregate functions) && subquery predicate is not under "NOT IN"))
254
236
          6. No execution method was already chosen (by a prepared statement).
255
237
 
335
317
  }
336
318
 
337
319
  if (error)
338
 
    goto err;
 
320
    goto err;         /* purecov: inspected */
339
321
 
340
 
  /* 
341
 
   * The below will create the new table for
342
 
   * CREATE TABLE ... SELECT
343
 
   *
344
 
   * @see create_table_from_items() in drizzled/sql_insert.cc
345
 
   */
346
322
  if (result && result->prepare(fields_list, unit_arg))
347
 
    goto err;
 
323
    goto err;         /* purecov: inspected */
348
324
 
349
325
  /* Init join struct */
350
326
  count_field_types(select_lex, &tmp_table_param, all_fields, 0);
367
343
  return(0); // All OK
368
344
 
369
345
err:
370
 
  return(-1);
 
346
  return(-1);       /* purecov: inspected */
371
347
}
372
348
 
373
349
/*
428
404
{
429
405
  // to prevent double initialization on EXPLAIN
430
406
  if (optimized)
431
 
    return 0;
 
407
    return(0);
432
408
  optimized= 1;
433
409
 
434
410
  session->set_proc_info("optimizing");
504
480
  {
505
481
    int res;
506
482
    /*
507
 
      optimizer::sum_query() returns HA_ERR_KEY_NOT_FOUND if no rows match
 
483
      opt_sum_query() returns HA_ERR_KEY_NOT_FOUND if no rows match
508
484
      to the WHERE conditions,
509
485
      or 1 if all items were resolved,
510
486
      or 0, or an error number HA_ERR_...
511
487
    */
512
 
    if ((res= optimizer::sum_query(select_lex->leaf_tables, all_fields, conds)))
 
488
    if ((res=opt_sum_query(select_lex->leaf_tables, all_fields, conds)))
513
489
    {
514
490
      if (res == HA_ERR_KEY_NOT_FOUND)
515
491
      {
532
508
      tables_list= 0;       // All tables resolved
533
509
      /*
534
510
        Extract all table-independent conditions and replace the WHERE
535
 
        clause with them. All other conditions were computed by optimizer::sum_query
 
511
        clause with them. All other conditions were computed by opt_sum_query
536
512
        and the MIN/MAX/COUNT function(s) have been replaced by constants,
537
513
        so there is no need to compute the whole WHERE clause again.
538
514
        Notice that make_cond_for_table() will always succeed to remove all
539
 
        computed conditions, because optimizer::sum_query() is applicable only to
 
515
        computed conditions, because opt_sum_query() is applicable only to
540
516
        conjunctions.
541
517
        Preserve conditions for EXPLAIN.
542
518
      */
583
559
  if (!(session->options & OPTION_BIG_SELECTS) &&
584
560
      best_read > (double) session->variables.max_join_size &&
585
561
      !(select_options & SELECT_DESCRIBE))
586
 
  {
 
562
  {           /* purecov: inspected */
587
563
    my_message(ER_TOO_BIG_SELECT, ER(ER_TOO_BIG_SELECT), MYF(0));
588
564
    error= -1;
589
565
    return 1;
595
571
    /* Handle the case where we have an OUTER JOIN without a WHERE */
596
572
    conds=new Item_int((int64_t) 1,1);  // Always true
597
573
  }
598
 
  select= optimizer::make_select(*table, const_table_map,
599
 
                                 const_table_map, conds, 1, &error);
 
574
  select= make_select(*table, const_table_map,
 
575
                      const_table_map, conds, 1, &error);
600
576
  if (error)
601
 
  {
602
 
    error= -1;
 
577
  {           /* purecov: inspected */
 
578
    error= -1;          /* purecov: inspected */
603
579
    return 1;
604
580
  }
605
581
 
639
615
  {
640
616
    conds=new Item_int((int64_t) 0,1);  // Always false
641
617
  }
642
 
 
643
618
  if (make_join_select(this, select, conds))
644
619
  {
645
620
    zero_result_cause=
660
635
    }
661
636
 
662
637
    /*
663
 
      If we are using ORDER BY NULL or ORDER BY const_expression,
 
638
      If we are using order_st BY NULL or order_st BY const_expression,
664
639
      return result in any order (even if we are using a GROUP BY)
665
640
    */
666
641
    if (!order && org_order)
679
654
     The FROM clause must contain a single non-constant table.
680
655
  */
681
656
  if (tables - const_tables == 1 && (group_list || select_distinct) &&
682
 
      ! tmp_table_param.sum_func_count &&
683
 
      (! join_tab[const_tables].select ||
684
 
       ! join_tab[const_tables].select->quick ||
 
657
      !tmp_table_param.sum_func_count &&
 
658
      (!join_tab[const_tables].select ||
 
659
       !join_tab[const_tables].select->quick ||
685
660
       join_tab[const_tables].select->quick->get_type() !=
686
 
       optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX))
 
661
       QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))
687
662
  {
688
663
    if (group_list && list_contains_unique_index(join_tab[const_tables].table, find_field_in_order_list, (void *) group_list))
689
664
    {
691
666
        We have found that grouping can be removed since groups correspond to
692
667
        only one row anyway, but we still have to guarantee correct result
693
668
        order. The line below effectively rewrites the query from GROUP BY
694
 
        <fields> to ORDER BY <fields>. There are two exceptions:
 
669
        <fields> to order_st BY <fields>. There are two exceptions:
695
670
        - if skip_sort_order is set (see above), then we can simply skip
696
671
          GROUP BY;
697
 
        - we can only rewrite ORDER BY if the ORDER BY fields are 'compatible'
 
672
        - we can only rewrite order_st BY if the order_st BY fields are 'compatible'
698
673
          with the GROUP BY ones, i.e. either one is a prefix of another.
699
 
          We only check if the ORDER BY is a prefix of GROUP BY. In this case
 
674
          We only check if the order_st BY is a prefix of GROUP BY. In this case
700
675
          test_if_subpart() copies the ASC/DESC attributes from the original
701
 
          ORDER BY fields.
 
676
          order_st BY fields.
702
677
          If GROUP BY is a prefix of order_st BY, then it is safe to leave
703
678
          'order' as is.
704
679
       */
705
 
      if (! order || test_if_subpart(group_list, order))
 
680
      if (!order || test_if_subpart(group_list, order))
706
681
          order= skip_sort_order ? 0 : group_list;
707
682
      /*
708
683
        If we have an IGNORE INDEX FOR GROUP BY(fields) clause, this must be
737
712
      - We are scanning the whole table without LIMIT
738
713
        This can happen if:
739
714
        - We are using CALC_FOUND_ROWS
740
 
        - We are using an ORDER BY that can't be optimized away.
 
715
        - We are using an order_st BY that can't be optimized away.
741
716
 
742
717
      We don't want to use this optimization when we are using LIMIT
743
718
      because in this case we can just create a temporary table that
769
744
          {
770
745
            /*
771
746
              Force MySQL to read the table in sorted order to get result in
772
 
              ORDER BY order.
 
747
              order_st BY order.
773
748
            */
774
749
            tmp_table_param.quick_group=0;
775
750
          }
826
801
    This has to be done if all tables are not already read (const tables)
827
802
    and one of the following conditions holds:
828
803
    - We are using DISTINCT (simple distinct's are already optimized away)
829
 
    - We are using an ORDER BY or GROUP BY on fields not in the first table
830
 
    - We are using different ORDER BY and GROUP BY orders
 
804
    - We are using an order_st BY or GROUP BY on fields not in the first table
 
805
    - We are using different order_st BY and GROUP BY orders
831
806
    - The user wants us to buffer the result.
832
807
  */
833
808
  need_tmp= (const_tables != tables &&
847
822
  if (setup_subquery_materialization())
848
823
    return 1;
849
824
 
850
 
  /* Cache constant expressions in WHERE, HAVING, ON clauses. */
851
 
  cache_const_exprs();
852
 
 
853
825
  /*
854
826
    is this simple IN subquery?
855
827
  */
1006
978
                                                                     (order_st*) 0);
1007
979
    /*
1008
980
      Pushing LIMIT to the temporary table creation is not applicable
1009
 
      when there is ORDER BY or GROUP BY or there is no GROUP BY, but
 
981
      when there is order_st BY or GROUP BY or there is no GROUP BY, but
1010
982
      there are aggregate functions, because in all these cases we need
1011
983
      all result rows.
1012
984
    */
1108
1080
    */
1109
1081
    if (select_lex->uncacheable && !is_top_level_join() &&
1110
1082
        init_save_join_tab())
1111
 
      return(-1);
 
1083
      return(-1);                         /* purecov: inspected */
1112
1084
  }
1113
1085
 
1114
1086
  error= 0;
1133
1105
 
1134
1106
  if (exec_tmp_table1)
1135
1107
  {
1136
 
    exec_tmp_table1->cursor->extra(HA_EXTRA_RESET_STATE);
1137
 
    exec_tmp_table1->cursor->ha_delete_all_rows();
 
1108
    exec_tmp_table1->file->extra(HA_EXTRA_RESET_STATE);
 
1109
    exec_tmp_table1->file->ha_delete_all_rows();
1138
1110
    exec_tmp_table1->free_io_cache();
1139
1111
    exec_tmp_table1->filesort_free_buffers();
1140
1112
  }
1141
1113
  if (exec_tmp_table2)
1142
1114
  {
1143
 
    exec_tmp_table2->cursor->extra(HA_EXTRA_RESET_STATE);
1144
 
    exec_tmp_table2->cursor->ha_delete_all_rows();
 
1115
    exec_tmp_table2->file->extra(HA_EXTRA_RESET_STATE);
 
1116
    exec_tmp_table2->file->ha_delete_all_rows();
1145
1117
    exec_tmp_table2->free_io_cache();
1146
1118
    exec_tmp_table2->filesort_free_buffers();
1147
1119
  }
1178
1150
bool JOIN::init_save_join_tab()
1179
1151
{
1180
1152
  if (!(tmp_join= (JOIN*)session->alloc(sizeof(JOIN))))
1181
 
    return 1;
 
1153
    return 1;                                  /* purecov: inspected */
1182
1154
  error= 0;              // Ensure that tmp_join.error= 0
1183
1155
  restore_tmp();
1184
1156
  return 0;
1218
1190
  {                                           
1219
1191
    /* Only test of functions */
1220
1192
    if (select_options & SELECT_DESCRIBE)
1221
 
    {
1222
 
      optimizer::ExplainPlan planner(this, 
1223
 
                                     false,
1224
 
                                     false,
1225
 
                                     false,
1226
 
                                     (zero_result_cause ? zero_result_cause : "No tables used"));
1227
 
      planner.printPlan();
1228
 
    }
 
1193
      select_describe(this, false, false, false, (zero_result_cause?zero_result_cause:"No tables used"));
1229
1194
    else
1230
1195
    {
1231
1196
      result->send_fields(*columns_list);
1276
1241
    return;
1277
1242
  }
1278
1243
 
 
1244
  if ((this->select_lex->options & OPTION_SCHEMA_TABLE) && get_schema_tables_result(this, PROCESSED_BY_JOIN_EXEC))
 
1245
    return;
 
1246
 
1279
1247
  if (select_options & SELECT_DESCRIBE)
1280
1248
  {
1281
1249
    /*
1282
 
      Check if we managed to optimize ORDER BY away and don't use temporary
 
1250
      Check if we managed to optimize order_st BY away and don't use temporary
1283
1251
      table to resolve order_st BY: in that case, we only may need to do
1284
1252
      filesort for GROUP BY.
1285
1253
    */
1298
1266
      order= 0;
1299
1267
    }
1300
1268
    having= tmp_having;
1301
 
    optimizer::ExplainPlan planner(this,
1302
 
                                   need_tmp,
1303
 
                                   order != 0 && ! skip_sort_order,
1304
 
                                   select_distinct,
1305
 
                                   ! tables ? "No tables used" : NULL);
1306
 
    planner.printPlan();
 
1269
    select_describe(this, need_tmp, order != 0 && !skip_sort_order,  select_distinct, !tables ? "No tables used" : NULL);
1307
1270
    return;
1308
1271
  }
1309
1272
 
1342
1305
      error= tmp_error;
1343
1306
      return;
1344
1307
    }
1345
 
    curr_tmp_table->cursor->info(HA_STATUS_VARIABLE);
 
1308
    curr_tmp_table->file->info(HA_STATUS_VARIABLE);
1346
1309
 
1347
1310
    if (curr_join->having)
1348
1311
      curr_join->having= curr_join->tmp_having= 0; // Allready done
1585
1548
      if (sort_table_cond)
1586
1549
      {
1587
1550
        if (!curr_table->select)
1588
 
          if (!(curr_table->select= new optimizer::SqlSelect))
 
1551
          if (!(curr_table->select= new SQL_SELECT))
1589
1552
            return;
1590
1553
        if (!curr_table->select->cond)
1591
1554
          curr_table->select->cond= sort_table_cond;
1907
1870
      for (tab= join_tab, end= tab+tables; tab != end; tab++)
1908
1871
      {
1909
1872
        if (tab->table)
1910
 
          tab->table->cursor->ha_index_or_rnd_end();
 
1873
          tab->table->file->ha_index_or_rnd_end();
1911
1874
      }
1912
1875
    }
1913
1876
  }
2360
2323
          item->save_in_result_field(1);
2361
2324
      }
2362
2325
      copy_sum_funcs(sum_funcs_end[i+1], sum_funcs_end[i]);
2363
 
      if ((write_error= table_arg->cursor->ha_write_row(table_arg->record[0])))
 
2326
      if ((write_error= table_arg->file->ha_write_row(table_arg->record[0])))
2364
2327
      {
2365
2328
  if (create_myisam_from_heap(session, table_arg,
2366
2329
                                    tmp_table_param.start_recinfo,
2413
2376
}
2414
2377
 
2415
2378
/**
2416
 
  Cache constant expressions in WHERE, HAVING, ON conditions.
2417
 
*/
2418
 
 
2419
 
void JOIN::cache_const_exprs()
2420
 
{
2421
 
  bool cache_flag= false;
2422
 
  bool *analyzer_arg= &cache_flag;
2423
 
 
2424
 
  /* No need in cache if all tables are constant. */
2425
 
  if (const_tables == tables)
2426
 
    return;
2427
 
 
2428
 
  if (conds)
2429
 
    conds->compile(&Item::cache_const_expr_analyzer, (unsigned char **)&analyzer_arg,
2430
 
                  &Item::cache_const_expr_transformer, (unsigned char *)&cache_flag);
2431
 
  cache_flag= false;
2432
 
  if (having)
2433
 
    having->compile(&Item::cache_const_expr_analyzer, (unsigned char **)&analyzer_arg,
2434
 
                    &Item::cache_const_expr_transformer, (unsigned char *)&cache_flag);
2435
 
 
2436
 
  for (JoinTable *tab= join_tab + const_tables; tab < join_tab + tables ; tab++)
2437
 
  {
2438
 
    if (*tab->on_expr_ref)
2439
 
    {
2440
 
      cache_flag= false;
2441
 
      (*tab->on_expr_ref)->compile(&Item::cache_const_expr_analyzer,
2442
 
                                 (unsigned char **)&analyzer_arg,
2443
 
                                 &Item::cache_const_expr_transformer,
2444
 
                                 (unsigned char *)&cache_flag);
2445
 
    }
2446
 
  }
2447
 
}
2448
 
 
2449
 
/**
2450
2379
  @brief
2451
2380
  
2452
2381
  Process one record of the nested loop join.
2470
2399
  if (join->session->killed)                    // Aborted by user
2471
2400
  {
2472
2401
    join->session->send_kill_message();
2473
 
    return NESTED_LOOP_KILLED;
 
2402
    return NESTED_LOOP_KILLED;               /* purecov: inspected */
2474
2403
  }
2475
2404
  if (!select_cond || select_cond->val_int())
2476
2405
  {
2560
2489
        return NESTED_LOOP_NO_MORE_ROWS;
2561
2490
    }
2562
2491
    else
2563
 
      join_tab->read_record.cursor->unlock_row();
 
2492
      join_tab->read_record.file->unlock_row();
2564
2493
  }
2565
2494
  else
2566
2495
  {
2570
2499
    */
2571
2500
    join->examined_rows++;
2572
2501
    join->session->row_count++;
2573
 
    join_tab->read_record.cursor->unlock_row();
 
2502
    join_tab->read_record.file->unlock_row();
2574
2503
  }
2575
2504
  return NESTED_LOOP_OK;
2576
2505
}
2675
2604
    if (join->session->killed)
2676
2605
    {
2677
2606
      join->session->send_kill_message();
2678
 
      return NESTED_LOOP_KILLED;
 
2607
      return NESTED_LOOP_KILLED; // Aborted by user /* purecov: inspected */
2679
2608
    }
2680
 
    optimizer::SqlSelect *select= join_tab->select;
 
2609
    SQL_SELECT *select=join_tab->select;
2681
2610
    if (rc == NESTED_LOOP_OK &&
2682
2611
        (!join_tab->cache.select || !join_tab->cache.select->skip_record()))
2683
2612
    {
2708
2637
    join_tab->readCachedRecord();               // Restore current record
2709
2638
  reset_cache_write(&join_tab->cache);
2710
2639
  if (error > 0)                                // Fatal error
2711
 
    return NESTED_LOOP_ERROR;
 
2640
    return NESTED_LOOP_ERROR;                   /* purecov: inspected */
2712
2641
  for (JoinTable *tmp2=join->join_tab; tmp2 != join_tab ; tmp2++)
2713
2642
    tmp2->table->status=tmp2->status;
2714
2643
  return NESTED_LOOP_OK;
2749
2678
    if (join->do_send_rows)
2750
2679
      error=join->result->send_data(*join->fields);
2751
2680
    if (error)
2752
 
      return NESTED_LOOP_ERROR;
 
2681
      return NESTED_LOOP_ERROR; /* purecov: inspected */
2753
2682
    if (++join->send_records >= join->unit->select_limit_cnt && join->do_send_rows)
2754
2683
    {
2755
2684
      if (join->select_options & OPTION_FOUND_ROWS)
2758
2687
        if ((join->tables == 1) && !join->tmp_table && !join->sort_and_group
2759
2688
            && !join->send_group_parts && !join->having && !jt->select_cond &&
2760
2689
            !(jt->select && jt->select->quick) &&
2761
 
            (jt->table->cursor->getEngine()->check_flag(HTON_BIT_STATS_RECORDS_IS_EXACT)) &&
 
2690
            (jt->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&
2762
2691
                  (jt->ref.key < 0))
2763
2692
        {
2764
2693
          /* Join over all rows in table;  Return number of found rows */
2773
2702
          }
2774
2703
          else
2775
2704
          {
2776
 
            table->cursor->info(HA_STATUS_VARIABLE);
2777
 
            join->send_records= table->cursor->stats.records;
 
2705
            table->file->info(HA_STATUS_VARIABLE);
 
2706
            join->send_records= table->file->stats.records;
2778
2707
          }
2779
2708
        }
2780
2709
        else
2807
2736
  if (join->session->killed)                    // Aborted by user
2808
2737
  {
2809
2738
    join->session->send_kill_message();
2810
 
    return NESTED_LOOP_KILLED;
 
2739
    return NESTED_LOOP_KILLED;             /* purecov: inspected */
2811
2740
  }
2812
2741
  if (!end_of_records)
2813
2742
  {
2817
2746
    {
2818
2747
      int error;
2819
2748
      join->found_records++;
2820
 
      if ((error=table->cursor->ha_write_row(table->record[0])))
 
2749
      if ((error=table->file->ha_write_row(table->record[0])))
2821
2750
      {
2822
 
        if (!table->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
2751
        if (!table->file->is_fatal_error(error, HA_CHECK_DUP))
2823
2752
          goto end;
2824
2753
        if (create_myisam_from_heap(join->session, table,
2825
2754
                                          join->tmp_table_param.start_recinfo,
2854
2783
  if (join->session->killed)                    // Aborted by user
2855
2784
  {
2856
2785
    join->session->send_kill_message();
2857
 
    return NESTED_LOOP_KILLED;
 
2786
    return NESTED_LOOP_KILLED;             /* purecov: inspected */
2858
2787
  }
2859
2788
 
2860
2789
  join->found_records++;
2868
2797
    if (item->maybe_null)
2869
2798
      group->buff[-1]= (char) group->field->is_null();
2870
2799
  }
2871
 
  if (!table->cursor->index_read_map(table->record[1],
 
2800
  if (!table->file->index_read_map(table->record[1],
2872
2801
                                   join->tmp_table_param.group_buff,
2873
2802
                                   HA_WHOLE_KEY,
2874
2803
                                   HA_READ_KEY_EXACT))
2875
2804
  {                                             /* Update old record */
2876
2805
    table->restoreRecord();
2877
2806
    update_tmptable_sum_func(join->sum_funcs,table);
2878
 
    if ((error= table->cursor->ha_update_row(table->record[1],
 
2807
    if ((error= table->file->ha_update_row(table->record[1],
2879
2808
                                          table->record[0])))
2880
2809
    {
2881
 
      table->print_error(error,MYF(0));
2882
 
      return NESTED_LOOP_ERROR;
 
2810
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
 
2811
      return NESTED_LOOP_ERROR;            /* purecov: inspected */
2883
2812
    }
2884
2813
    return NESTED_LOOP_OK;
2885
2814
  }
2899
2828
  }
2900
2829
  init_tmptable_sum_functions(join->sum_funcs);
2901
2830
  copy_funcs(join->tmp_table_param.items_to_copy);
2902
 
  if ((error=table->cursor->ha_write_row(table->record[0])))
 
2831
  if ((error=table->file->ha_write_row(table->record[0])))
2903
2832
  {
2904
2833
    if (create_myisam_from_heap(join->session, table,
2905
2834
                                join->tmp_table_param.start_recinfo,
2907
2836
                                error, 0))
2908
2837
      return NESTED_LOOP_ERROR;            // Not a table_is_full error
2909
2838
    /* Change method to update rows */
2910
 
    table->cursor->ha_index_init(0, 0);
 
2839
    table->file->ha_index_init(0, 0);
2911
2840
    join->join_tab[join->tables-1].next_select= end_unique_update;
2912
2841
  }
2913
2842
  join->send_records++;
2925
2854
  if (join->session->killed)                    // Aborted by user
2926
2855
  {
2927
2856
    join->session->send_kill_message();
2928
 
    return NESTED_LOOP_KILLED;
 
2857
    return NESTED_LOOP_KILLED;             /* purecov: inspected */
2929
2858
  }
2930
2859
 
2931
2860
  init_tmptable_sum_functions(join->sum_funcs);
2932
2861
  copy_fields(&join->tmp_table_param);          // Groups are copied twice.
2933
2862
  copy_funcs(join->tmp_table_param.items_to_copy);
2934
2863
 
2935
 
  if (!(error= table->cursor->ha_write_row(table->record[0])))
 
2864
  if (!(error= table->file->ha_write_row(table->record[0])))
2936
2865
    join->send_records++;                       // New group
2937
2866
  else
2938
2867
  {
2939
 
    if ((int) table->get_dup_key(error) < 0)
 
2868
    if ((int) table->file->get_dup_key(error) < 0)
2940
2869
    {
2941
 
      table->print_error(error,MYF(0));
2942
 
      return NESTED_LOOP_ERROR;
 
2870
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
 
2871
      return NESTED_LOOP_ERROR;            /* purecov: inspected */
2943
2872
    }
2944
 
    if (table->cursor->rnd_pos(table->record[1],table->cursor->dup_ref))
 
2873
    if (table->file->rnd_pos(table->record[1],table->file->dup_ref))
2945
2874
    {
2946
 
      table->print_error(error,MYF(0));
2947
 
      return NESTED_LOOP_ERROR;
 
2875
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
 
2876
      return NESTED_LOOP_ERROR;            /* purecov: inspected */
2948
2877
    }
2949
2878
    table->restoreRecord();
2950
2879
    update_tmptable_sum_func(join->sum_funcs,table);
2951
 
    if ((error= table->cursor->ha_update_row(table->record[1],
 
2880
    if ((error= table->file->ha_update_row(table->record[1],
2952
2881
                                          table->record[0])))
2953
2882
    {
2954
 
      table->print_error(error,MYF(0));
2955
 
      return NESTED_LOOP_ERROR;
 
2883
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
 
2884
      return NESTED_LOOP_ERROR;            /* purecov: inspected */
2956
2885
    }
2957
2886
  }
2958
2887
  return NESTED_LOOP_OK;
3074
3003
  {
3075
3004
    for (; group ; group=group->next)
3076
3005
    {
3077
 
      Cached_item *tmp= new_Cached_item(join->session, *group->item);
 
3006
      Cached_item *tmp=new_Cached_item(join->session, *group->item, false);
3078
3007
      if (!tmp || join->group_fields.push_front(tmp))
3079
3008
        return true;
3080
3009
    }
3193
3122
  uint32_t i,tablenr;
3194
3123
  table_map used_tables;
3195
3124
  JoinTable *join_tab,*j;
3196
 
  optimizer::KeyUse *keyuse;
 
3125
  KeyUse *keyuse;
3197
3126
  uint32_t table_count;
3198
3127
  Session *session=join->session;
3199
3128
  optimizer::Position cur_pos;
3241
3170
}
3242
3171
 
3243
3172
/** Save const tables first as used tables. */
3244
 
static void set_position(JOIN *join,
3245
 
                         uint32_t idx,
3246
 
                         JoinTable *table,
3247
 
                         optimizer::KeyUse *key)
 
3173
static void set_position(JOIN *join,uint32_t idx,JoinTable *table,KeyUse *key)
3248
3174
{
3249
3175
  optimizer::Position tmp_pos(1.0, /* This is a const table */
3250
3176
                              0.0,
3299
3225
      Apply heuristic: pre-sort all access plans with respect to the number of
3300
3226
      records accessed.
3301
3227
  */
3302
 
  internal::my_qsort(join->best_ref + join->const_tables,
3303
 
                     join->tables - join->const_tables, sizeof(JoinTable*),
3304
 
                     straight_join ? join_tab_cmp_straight : join_tab_cmp);
 
3228
  my_qsort(join->best_ref + join->const_tables,
 
3229
           join->tables - join->const_tables, sizeof(JoinTable*),
 
3230
           straight_join ? join_tab_cmp_straight : join_tab_cmp);
3305
3231
  if (straight_join)
3306
3232
  {
3307
3233
    optimize_straight_join(join, join_tables);
3358
3284
                             double record_count,
3359
3285
                             double)
3360
3286
{
3361
 
  optimizer::KeyUse *best_key= NULL;
3362
 
  uint32_t best_max_key_part= 0;
 
3287
  KeyUse *best_key=         0;
 
3288
  uint32_t best_max_key_part=   0;
3363
3289
  bool found_constraint= 0;
3364
 
  double best= DBL_MAX;
3365
 
  double best_time= DBL_MAX;
3366
 
  double records= DBL_MAX;
 
3290
  double best=              DBL_MAX;
 
3291
  double best_time=         DBL_MAX;
 
3292
  double records=           DBL_MAX;
3367
3293
  table_map best_ref_depends_map= 0;
3368
3294
  double tmp;
3369
3295
  ha_rows rec;
3371
3297
  if (s->keyuse)
3372
3298
  {                                            /* Use key if possible */
3373
3299
    Table *table= s->table;
3374
 
    optimizer::KeyUse *keyuse= NULL;
3375
 
    optimizer::KeyUse *start_key= NULL;
 
3300
    KeyUse *keyuse,*start_key=0;
3376
3301
    double best_records= DBL_MAX;
3377
3302
    uint32_t max_key_part=0;
3378
3303
 
3379
3304
    /* Test how we can use keys */
3380
3305
    rec= s->records/MATCHING_ROWS_IN_OTHER_TABLE;  // Assumed records/key
3381
 
    for (keyuse= s->keyuse; keyuse->getTable() == table; )
 
3306
    for (keyuse=s->keyuse ; keyuse->table == table ;)
3382
3307
    {
3383
3308
      key_part_map found_part= 0;
3384
3309
      table_map found_ref= 0;
3385
 
      uint32_t key= keyuse->getKey();
3386
 
      KEY *keyinfo= table->key_info + key;
 
3310
      uint32_t key= keyuse->key;
 
3311
      KEY *keyinfo= table->key_info+key;
3387
3312
      /* Bitmap of keyparts where the ref access is over 'keypart=const': */
3388
3313
      key_part_map const_part= 0;
3389
3314
      /* The or-null keypart in ref-or-null access: */
3394
3319
 
3395
3320
      do /* For each keypart */
3396
3321
      {
3397
 
        uint32_t keypart= keyuse->getKeypart();
 
3322
        uint32_t keypart= keyuse->keypart;
3398
3323
        table_map best_part_found_ref= 0;
3399
3324
        double best_prev_record_reads= DBL_MAX;
3400
3325
 
3405
3330
            if 1. expression doesn't refer to forward tables
3406
3331
               2. we won't get two ref-or-null's
3407
3332
          */
3408
 
          if (! (remaining_tables & keyuse->getUsedTables()) &&
3409
 
              ! (ref_or_null_part && (keyuse->getOptimizeFlags() &
3410
 
                                      KEY_OPTIMIZE_REF_OR_NULL)))
 
3333
          if (!(remaining_tables & keyuse->used_tables) &&
 
3334
              !(ref_or_null_part && (keyuse->optimize &
 
3335
                                     KEY_OPTIMIZE_REF_OR_NULL)))
3411
3336
          {
3412
 
            found_part|= keyuse->getKeypartMap();
3413
 
            if (! (keyuse->getUsedTables() & ~join->const_table_map))
3414
 
              const_part|= keyuse->getKeypartMap();
 
3337
            found_part|= keyuse->keypart_map;
 
3338
            if (!(keyuse->used_tables & ~join->const_table_map))
 
3339
              const_part|= keyuse->keypart_map;
3415
3340
 
3416
3341
            double tmp2= prev_record_reads(join, idx, (found_ref |
3417
 
                                                       keyuse->getUsedTables()));
 
3342
                                                      keyuse->used_tables));
3418
3343
            if (tmp2 < best_prev_record_reads)
3419
3344
            {
3420
 
              best_part_found_ref= keyuse->getUsedTables() & ~join->const_table_map;
 
3345
              best_part_found_ref= keyuse->used_tables & ~join->const_table_map;
3421
3346
              best_prev_record_reads= tmp2;
3422
3347
            }
3423
 
            if (rec > keyuse->getTableRows())
3424
 
              rec= keyuse->getTableRows();
 
3348
            if (rec > keyuse->ref_table_rows)
 
3349
              rec= keyuse->ref_table_rows;
3425
3350
      /*
3426
3351
        If there is one 'key_column IS NULL' expression, we can
3427
3352
        use this ref_or_null optimisation of this field
3428
3353
      */
3429
 
            if (keyuse->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL)
3430
 
              ref_or_null_part|= keyuse->getKeypartMap();
 
3354
            if (keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL)
 
3355
              ref_or_null_part |= keyuse->keypart_map;
3431
3356
          }
3432
3357
 
3433
3358
          keyuse++;
3434
 
        } while (keyuse->getTable() == table && keyuse->getKey() == key &&
3435
 
                 keyuse->getKeypart() == keypart);
3436
 
        found_ref|= best_part_found_ref;
3437
 
      } while (keyuse->getTable() == table && keyuse->getKey() == key);
 
3359
        } while (keyuse->table == table && keyuse->key == key &&
 
3360
                 keyuse->keypart == keypart);
 
3361
  found_ref|= best_part_found_ref;
 
3362
      } while (keyuse->table == table && keyuse->key == key);
3438
3363
 
3439
3364
      /*
3440
3365
        Assume that that each key matches a proportional part of table.
3525
3450
            if (table->covering_keys.test(key))
3526
3451
            {
3527
3452
              /* we can use only index tree */
3528
 
              tmp= record_count * table->cursor->index_only_read_time(key, tmp);
 
3453
              tmp= record_count * table->file->index_only_read_time(key, tmp);
3529
3454
            }
3530
3455
            else
3531
3456
              tmp= record_count * min(tmp,s->worst_seeks);
3539
3464
            Set tmp to (previous record count) * (records / combination)
3540
3465
          */
3541
3466
          if ((found_part & 1) &&
3542
 
              (!(table->index_flags(key) & HA_ONLY_WHOLE_INDEX) ||
3543
 
               found_part == PREV_BITS(uint, keyinfo->key_parts)))
 
3467
              (!(table->file->index_flags(key, 0, 0) & HA_ONLY_WHOLE_INDEX) ||
 
3468
               found_part == PREV_BITS(uint,keyinfo->key_parts)))
3544
3469
          {
3545
3470
            max_key_part= max_part_bit(found_part);
3546
3471
            /*
3619
3544
              else
3620
3545
              {
3621
3546
                /*
3622
 
                  Assume that the first key part matches 1% of the cursor
 
3547
                  Assume that the first key part matches 1% of the file
3623
3548
                  and that the whole key matches 10 (duplicates) or 1
3624
3549
                  (unique) records.
3625
3550
                  Assume also that more key matches proportionally more
3690
3615
            if (table->covering_keys.test(key))
3691
3616
            {
3692
3617
              /* we can use only index tree */
3693
 
              tmp= record_count * table->cursor->index_only_read_time(key, tmp);
 
3618
              tmp= record_count * table->file->index_only_read_time(key, tmp);
3694
3619
            }
3695
3620
            else
3696
3621
              tmp= record_count * min(tmp,s->worst_seeks);
3742
3667
        scan.
3743
3668
  */
3744
3669
  if ((records >= s->found_records || best > s->read_time) &&            // (1)
3745
 
      ! (s->quick && best_key && s->quick->index == best_key->getKey() &&      // (2)
3746
 
        best_max_key_part >= s->table->quick_key_parts[best_key->getKey()]) &&// (2)
3747
 
      ! ((s->table->cursor->getEngine()->check_flag(HTON_BIT_TABLE_SCAN_ON_INDEX)) &&   // (3)
3748
 
        ! s->table->covering_keys.none() && best_key && !s->quick) && // (3)
3749
 
      ! (s->table->force_index && best_key && !s->quick))                 // (4)
 
3670
      !(s->quick && best_key && s->quick->index == best_key->key &&      // (2)
 
3671
        best_max_key_part >= s->table->quick_key_parts[best_key->key]) &&// (2)
 
3672
      !((s->table->file->ha_table_flags() & HA_TABLE_SCAN_ON_INDEX) &&   // (3)
 
3673
        ! s->table->covering_keys.none() && best_key && !s->quick) &&// (3)
 
3674
      !(s->table->force_index && best_key && !s->quick))                 // (4)
3750
3675
  {                                             // Check full join
3751
3676
    ha_rows rnd_records= s->found_records;
3752
3677
    /*
3791
3716
    else
3792
3717
    {
3793
3718
      /* Estimate cost of reading table. */
3794
 
      tmp= s->table->cursor->scan_time();
 
3719
      tmp= s->table->file->scan_time();
3795
3720
      if (s->table->map & join->outer_join)     // Can't use join cache
3796
3721
      {
3797
3722
        /*
4004
3929
  JoinTable  *best_table; // the next plan node to be added to the curr QEP
4005
3930
 
4006
3931
  /* number of tables that remain to be optimized */
4007
 
  size_remain= internal::my_count_bits(remaining_tables);
 
3932
  size_remain= my_count_bits(remaining_tables);
4008
3933
 
4009
3934
  do {
4010
3935
    /* Find the extension of the current QEP with the lowest cost */
4351
4276
  if (!join->table_reexec)
4352
4277
  {
4353
4278
    if (!(join->table_reexec= (Table**) join->session->alloc(sizeof(Table*))))
4354
 
      return(true);
 
4279
      return(true);                        /* purecov: inspected */
4355
4280
    if (join->tmp_join)
4356
4281
      join->tmp_join->table_reexec= join->table_reexec;
4357
4282
  }
4359
4284
  {
4360
4285
    if (!(join->join_tab_reexec=
4361
4286
          (JoinTable*) join->session->alloc(sizeof(JoinTable))))
4362
 
      return(true);
 
4287
      return(true);                        /* purecov: inspected */
4363
4288
    if (join->tmp_join)
4364
4289
      join->tmp_join->join_tab_reexec= join->join_tab_reexec;
4365
4290
  }
4494
4419
  return;
4495
4420
}
4496
4421
 
4497
 
static bool make_join_select(JOIN *join,
4498
 
                             optimizer::SqlSelect *select,
4499
 
                             COND *cond)
 
4422
static bool make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
4500
4423
{
4501
4424
  Session *session= join->session;
4502
4425
  optimizer::Position cur_pos;
4617
4540
      if (tmp || !cond || tab->type == AM_REF || tab->type == AM_REF_OR_NULL ||
4618
4541
          tab->type == AM_EQ_REF)
4619
4542
      {
4620
 
        optimizer::SqlSelect *sel= tab->select= ((optimizer::SqlSelect*)
 
4543
        SQL_SELECT *sel= tab->select= ((SQL_SELECT*)
4621
4544
            session->memdup((unsigned char*) select,
4622
4545
              sizeof(*select)));
4623
4546
        if (! sel)
4755
4678
                                         current_map,
4756
4679
                                         current_map, 0)))
4757
4680
            {
4758
 
              tab->cache.select= (optimizer::SqlSelect*)
4759
 
                session->memdup((unsigned char*) sel, sizeof(optimizer::SqlSelect));
 
4681
              tab->cache.select= (SQL_SELECT*)
 
4682
                session->memdup((unsigned char*) sel, sizeof(SQL_SELECT));
4760
4683
              tab->cache.select->cond= tmp;
4761
4684
              tab->cache.select->read_tables= join->const_table_map;
4762
4685
            }
4884
4807
    Table *table=tab->table;
4885
4808
    bool using_join_cache;
4886
4809
    tab->read_record.table= table;
4887
 
    tab->read_record.cursor= table->cursor;
 
4810
    tab->read_record.file=table->file;
4888
4811
    tab->next_select=sub_select;                /* normal select */
4889
4812
    /*
4890
4813
      TODO: don't always instruct first table's ref/range access method to
4913
4836
          !table->no_keyread)
4914
4837
      {
4915
4838
        table->key_read=1;
4916
 
        table->cursor->extra(HA_EXTRA_KEYREAD);
 
4839
        table->file->extra(HA_EXTRA_KEYREAD);
4917
4840
      }
4918
4841
      break;
4919
4842
    case AM_EQ_REF:
4930
4853
      if (table->covering_keys.test(tab->ref.key) && !table->no_keyread)
4931
4854
      {
4932
4855
        table->key_read=1;
4933
 
        table->cursor->extra(HA_EXTRA_KEYREAD);
 
4856
        table->file->extra(HA_EXTRA_KEYREAD);
4934
4857
      }
4935
4858
      break;
4936
4859
    case AM_REF_OR_NULL:
4946
4869
      if (table->covering_keys.test(tab->ref.key) && !table->no_keyread)
4947
4870
      {
4948
4871
        table->key_read=1;
4949
 
        table->cursor->extra(HA_EXTRA_KEYREAD);
 
4872
        table->file->extra(HA_EXTRA_KEYREAD);
4950
4873
      }
4951
4874
      if (tab->type == AM_REF)
4952
4875
      {
5025
4948
              table->covering_keys.test(tab->select->quick->index))
5026
4949
          {
5027
4950
            table->key_read=1;
5028
 
            table->cursor->extra(HA_EXTRA_KEYREAD);
 
4951
            table->file->extra(HA_EXTRA_KEYREAD);
5029
4952
          }
5030
4953
          else if (!table->covering_keys.none() &&
5031
4954
            !(tab->select && tab->select->quick))
5037
4960
                      is always faster than using a secondary index".
5038
4961
                    */
5039
4962
                    if (table->s->primary_key != MAX_KEY &&
5040
 
                        table->cursor->primary_key_is_clustered())
 
4963
                        table->file->primary_key_is_clustered())
5041
4964
                      tab->index= table->s->primary_key;
5042
4965
                    else
5043
4966
                      tab->index= table->find_shortest_key(&table->covering_keys);
5049
4972
      }
5050
4973
      break;
5051
4974
    default:
5052
 
      break;
 
4975
      break;                                    /* purecov: deadcode */
5053
4976
    case AM_UNKNOWN:
5054
4977
    case AM_MAYBE_REF:
5055
 
      abort();
 
4978
      abort();                                  /* purecov: deadcode */
5056
4979
    }
5057
4980
  }
5058
4981
  join->join_tab[join->tables-1].next_select=0; /* Set by do_select */
5192
5115
{
5193
5116
  if (select_options & SELECT_DESCRIBE)
5194
5117
  {
5195
 
    optimizer::ExplainPlan planner(join,
5196
 
                                   false,
5197
 
                                   false,
5198
 
                                   false,
5199
 
                                   info);
5200
 
    planner.printPlan();
5201
 
    return 0;
 
5118
    select_describe(join, false, false, false, info);
 
5119
    return(0);
5202
5120
  }
5203
5121
 
5204
5122
  join->join_free();
5536
5454
  reclength= entry->s->reclength-offset;
5537
5455
 
5538
5456
  entry->free_io_cache();                               // Safety
5539
 
  entry->cursor->info(HA_STATUS_VARIABLE);
 
5457
  entry->file->info(HA_STATUS_VARIABLE);
5540
5458
  if (entry->s->db_type() == heap_engine ||
5541
5459
      (!entry->s->blob_fields &&
5542
 
       ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->cursor->stats.records <
 
5460
       ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->file->stats.records <
5543
5461
        session->variables.sortbuff_size)))
5544
5462
    error= remove_dup_with_hash_index(join->session, entry,
5545
5463
                                     field_count, first_field,
5594
5512
{
5595
5513
  int error;
5596
5514
  Table *table;
5597
 
  uint32_t i;
5598
 
  uint32_t table_count;
5599
 
  uint32_t const_count;
5600
 
  uint32_t key;
5601
 
  table_map found_const_table_map;
5602
 
  table_map all_table_map;
5603
 
  table_map found_ref;
5604
 
  table_map refs;
5605
 
  key_map const_ref;
5606
 
  key_map eq_part;
5607
 
  Table **table_vector= NULL;
5608
 
  JoinTable *stat= NULL;
5609
 
  JoinTable *stat_end= NULL;
5610
 
  JoinTable *s= NULL;
5611
 
  JoinTable **stat_ref= NULL;
5612
 
  optimizer::KeyUse *keyuse= NULL;
5613
 
  optimizer::KeyUse *start_keyuse= NULL;
5614
 
  table_map outer_join= 0;
 
5515
  uint32_t i,table_count,const_count,key;
 
5516
  table_map found_const_table_map, all_table_map, found_ref, refs;
 
5517
  key_map const_ref, eq_part;
 
5518
  Table **table_vector;
 
5519
  JoinTable *stat,*stat_end,*s,**stat_ref;
 
5520
  KeyUse *keyuse,*start_keyuse;
 
5521
  table_map outer_join=0;
5615
5522
  vector<optimizer::SargableParam> sargables;
5616
5523
  JoinTable *stat_vector[MAX_TABLES+1];
5617
5524
  optimizer::Position *partial_pos;
5618
5525
 
5619
 
  table_count= join->tables;
5620
 
  stat= (JoinTable*) join->session->calloc(sizeof(JoinTable)*table_count);
5621
 
  stat_ref= (JoinTable**) join->session->alloc(sizeof(JoinTable*)*MAX_TABLES);
5622
 
  table_vector= (Table**) join->session->alloc(sizeof(Table*)*(table_count*2));
 
5526
  table_count=join->tables;
 
5527
  stat=(JoinTable*) join->session->calloc(sizeof(JoinTable)*table_count);
 
5528
  stat_ref=(JoinTable**) join->session->alloc(sizeof(JoinTable*)*MAX_TABLES);
 
5529
  table_vector=(Table**) join->session->alloc(sizeof(Table*)*(table_count*2));
5623
5530
  if (! stat || ! stat_ref || ! table_vector)
5624
 
    return 1;
 
5531
    return 1;                           // Eom /* purecov: inspected */
5625
5532
 
5626
5533
  join->best_ref=stat_vector;
5627
5534
 
5641
5548
    s->needed_reg.reset();
5642
5549
    table_vector[i]=s->table=table=tables->table;
5643
5550
    table->pos_in_table_list= tables;
5644
 
    error= table->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
 
5551
    error= table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
5645
5552
    if (error)
5646
5553
    {
5647
 
        table->print_error(error, MYF(0));
 
5554
        table->file->print_error(error, MYF(0));
5648
5555
        return 1;
5649
5556
    }
5650
5557
    table->quick_keys.reset();
5658
5565
 
5659
5566
    s->dependent= tables->dep_tables;
5660
5567
    s->key_dependent= 0;
5661
 
    table->quick_condition_rows= table->cursor->stats.records;
 
5568
    if (tables->schema_table)
 
5569
      table->file->stats.records= 2;
 
5570
    table->quick_condition_rows= table->file->stats.records;
5662
5571
 
5663
5572
    s->on_expr_ref= &tables->on_expr;
5664
5573
    if (*s->on_expr_ref)
5665
5574
    {
5666
5575
      /* s is the only inner table of an outer join */
5667
 
      if (!table->cursor->stats.records && !embedding)
 
5576
      if (!table->file->stats.records && !embedding)
5668
5577
      {                                         // Empty table
5669
5578
        s->dependent= 0;                        // Ignore LEFT JOIN depend.
5670
 
        set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5579
        set_position(join,const_count++,s,(KeyUse*) 0);
5671
5580
        continue;
5672
5581
      }
5673
5582
      outer_join|= table->map;
5691
5600
      while (embedding);
5692
5601
      continue;
5693
5602
    }
5694
 
    if ((table->cursor->stats.records <= 1) && !s->dependent &&
5695
 
              (table->cursor->getEngine()->check_flag(HTON_BIT_STATS_RECORDS_IS_EXACT)) &&
 
5603
    if ((table->file->stats.records <= 1) && !s->dependent &&
 
5604
              (table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) && 
5696
5605
        !join->no_const_tables)
5697
5606
    {
5698
 
      set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5607
      set_position(join,const_count++,s,(KeyUse*) 0);
5699
5608
    }
5700
5609
  }
5701
5610
  stat_vector[i]=0;
5775
5684
      set_position() will move all const_tables first in stat_vector
5776
5685
    */
5777
5686
 
5778
 
    for (JoinTable **pos= stat_vector+const_count; (s= *pos); pos++)
 
5687
    for (JoinTable **pos=stat_vector+const_count ; (s= *pos) ; pos++)
5779
5688
    {
5780
 
      table= s->table;
 
5689
      table=s->table;
5781
5690
 
5782
5691
      /*
5783
5692
        If equi-join condition by a key is null rejecting and after a
5796
5705
          TODO. Apply single row substitution to null complemented inner tables
5797
5706
          for nested outer join operations.
5798
5707
        */
5799
 
        while (keyuse->getTable() == table)
 
5708
        while (keyuse->table == table)
5800
5709
        {
5801
 
          if (! (keyuse->getVal()->used_tables() & ~join->const_table_map) &&
5802
 
              keyuse->getVal()->is_null() && keyuse->isNullRejected())
 
5710
          if (!(keyuse->val->used_tables() & ~join->const_table_map) &&
 
5711
              keyuse->val->is_null() && keyuse->null_rejecting)
5803
5712
          {
5804
5713
            s->type= AM_CONST;
5805
5714
            table->mark_as_null_row();
5806
5715
            found_const_table_map|= table->map;
5807
5716
            join->const_table_map|= table->map;
5808
 
            set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5717
            set_position(join,const_count++,s,(KeyUse*) 0);
5809
5718
            goto more_const_tables_found;
5810
5719
           }
5811
5720
          keyuse++;
5817
5726
        // All dep. must be constants
5818
5727
        if (s->dependent & ~(found_const_table_map))
5819
5728
          continue;
5820
 
        if (table->cursor->stats.records <= 1L &&
5821
 
            (table->cursor->getEngine()->check_flag(HTON_BIT_STATS_RECORDS_IS_EXACT)) &&
 
5729
        if (table->file->stats.records <= 1L &&
 
5730
            (table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&
5822
5731
                  !table->pos_in_table_list->embedding)
5823
5732
        {                                       // system table
5824
5733
          int tmp= 0;
5825
5734
          s->type= AM_SYSTEM;
5826
5735
          join->const_table_map|=table->map;
5827
 
          set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5736
          set_position(join,const_count++,s,(KeyUse*) 0);
5828
5737
          partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5829
5738
          if ((tmp= join_read_const_table(s, partial_pos)))
5830
5739
          {
5840
5749
      if ((keyuse=s->keyuse))
5841
5750
      {
5842
5751
        s->type= AM_REF;
5843
 
        while (keyuse->getTable() == table)
 
5752
        while (keyuse->table == table)
5844
5753
        {
5845
 
          start_keyuse= keyuse;
5846
 
          key= keyuse->getKey();
 
5754
          start_keyuse=keyuse;
 
5755
          key=keyuse->key;
5847
5756
          s->keys.set(key);               // QQ: remove this ?
5848
5757
 
5849
 
          refs= 0;
5850
 
          const_ref.reset();
 
5758
          refs=0;
 
5759
                const_ref.reset();
5851
5760
          eq_part.reset();
5852
5761
          do
5853
5762
          {
5854
 
            if (keyuse->getVal()->type() != Item::NULL_ITEM && 
5855
 
                ! keyuse->getOptimizeFlags())
 
5763
            if (keyuse->val->type() != Item::NULL_ITEM && !keyuse->optimize)
5856
5764
            {
5857
 
              if (! ((~found_const_table_map) & keyuse->getUsedTables()))
5858
 
                const_ref.set(keyuse->getKeypart());
 
5765
              if (!((~found_const_table_map) & keyuse->used_tables))
 
5766
                const_ref.set(keyuse->keypart);
5859
5767
              else
5860
 
                refs|= keyuse->getUsedTables();
5861
 
              eq_part.set(keyuse->getKeypart());
 
5768
                refs|=keyuse->used_tables;
 
5769
              eq_part.set(keyuse->keypart);
5862
5770
            }
5863
5771
            keyuse++;
5864
 
          } while (keyuse->getTable() == table && keyuse->getKey() == key);
 
5772
          } while (keyuse->table == table && keyuse->key == key);
5865
5773
 
5866
5774
          if (is_keymap_prefix(eq_part, table->key_info[key].key_parts) &&
5867
 
              ! table->pos_in_table_list->embedding)
 
5775
              !table->pos_in_table_list->embedding)
5868
5776
          {
5869
5777
            if ((table->key_info[key].flags & (HA_NOSAME)) == HA_NOSAME)
5870
5778
            {
5874
5782
                ref_changed = 1;
5875
5783
                s->type= AM_CONST;
5876
5784
                join->const_table_map|= table->map;
5877
 
                set_position(join, const_count++, s, start_keyuse);
 
5785
                set_position(join,const_count++,s,start_keyuse);
5878
5786
                if (create_ref_for_key(join, s, start_keyuse, found_const_table_map))
5879
5787
                  return 1;
5880
5788
                partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5931
5839
      continue;
5932
5840
    }
5933
5841
    /* Approximate found rows and time to read them */
5934
 
    s->found_records=s->records=s->table->cursor->stats.records;
5935
 
    s->read_time=(ha_rows) s->table->cursor->scan_time();
 
5842
    s->found_records=s->records=s->table->file->stats.records;
 
5843
    s->read_time=(ha_rows) s->table->file->scan_time();
5936
5844
 
5937
5845
    /*
5938
5846
      Set a max range of how many seeks we can expect when using keys
5954
5862
        !s->table->pos_in_table_list->embedding)
5955
5863
    {
5956
5864
      ha_rows records;
5957
 
      optimizer::SqlSelect *select= NULL;
5958
 
      select= optimizer::make_select(s->table, found_const_table_map, found_const_table_map, *s->on_expr_ref ? *s->on_expr_ref : conds, 1, &error);
 
5865
      SQL_SELECT *select;
 
5866
      select= make_select(s->table, found_const_table_map, found_const_table_map, *s->on_expr_ref ? *s->on_expr_ref : conds, 1, &error);
5959
5867
      if (! select)
5960
5868
        return 1;
5961
5869
      records= get_quick_record_count(join->session, select, s->table, &s->const_keys, join->row_limit);
5971
5879
          caller to abort with a zero row result.
5972
5880
        */
5973
5881
        join->const_table_map|= s->table->map;
5974
 
        set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5882
        set_position(join,const_count++,s,(KeyUse*) 0);
5975
5883
        s->type= AM_CONST;
5976
5884
        if (*s->on_expr_ref)
5977
5885
        {
6001
5909
  if (join->const_tables != join->tables)
6002
5910
  {
6003
5911
    optimize_keyuse(join, keyuse_array);
6004
 
    DRIZZLE_QUERY_OPT_CHOOSE_PLAN_START(join->session->query.c_str(), join->session->thread_id);
6005
 
    bool res= choose_plan(join, all_table_map & ~join->const_table_map);
6006
 
    DRIZZLE_QUERY_OPT_CHOOSE_PLAN_DONE(res ? 1 : 0);
6007
 
    if (res)
6008
 
      return true;
 
5912
    if (choose_plan(join, all_table_map & ~join->const_table_map))
 
5913
      return(true);
6009
5914
  }
6010
5915
  else
6011
5916
  {
6232
6137
    error=(int) cond->add(join_tab->select->cond);
6233
6138
    join_tab->select_cond=join_tab->select->cond=cond;
6234
6139
  }
6235
 
  else if ((join_tab->select= optimizer::make_select(join_tab->table, 0, 0, cond, 0,
6236
 
                                                     &error)))
 
6140
  else if ((join_tab->select= make_select(join_tab->table, 0, 0, cond, 0,
 
6141
                                          &error)))
6237
6142
    join_tab->select_cond=cond;
6238
6143
 
6239
6144
  return(error ? true : false);
6251
6156
/**
6252
6157
  @} (end of group Query_Optimizer)
6253
6158
*/
6254
 
 
6255
 
} /* namespace drizzled */