← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/join.cc

  • Committer: Mark Atwood
  • Date: 2011-08-09 01:21:52 UTC
  • mfrom: (2380.1.2 drizzle-autoconf)
  • Revision ID: me@mark.atwood.name-20110809012152-zxq2dgan8e6nsvse
merge lp:~brianaker/drizzle/autoreconf

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"
 
30
#include <config.h>
31
31
 
32
32
#include <float.h>
33
33
#include <math.h>
34
34
 
35
 
#include "drizzled/item/cache.h"
36
 
#include "drizzled/item/cmpfunc.h"
37
 
#include "drizzled/item/copy_string.h"
38
 
#include "drizzled/item/uint.h"
39
 
#include "drizzled/cached_item.h"
40
 
#include "drizzled/sql_base.h"
41
 
#include "drizzled/sql_select.h" /* include join.h */
42
 
#include "drizzled/lock.h"
43
 
#include "drizzled/nested_join.h"
44
 
#include "drizzled/join.h"
45
 
#include "drizzled/join_cache.h"
46
 
#include "drizzled/show.h"
47
 
#include "drizzled/field/blob.h"
48
 
#include "drizzled/optimizer/position.h"
49
 
#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/optimizer/access_method_factory.h"
55
 
#include "drizzled/optimizer/access_method.h"
56
 
#include "drizzled/records.h"
57
 
#include "drizzled/probes.h"
58
 
#include "drizzled/internal/my_bit.h"
59
 
#include "drizzled/internal/my_sys.h"
60
 
#include "drizzled/internal/iocache.h"
61
 
#include "drizzled/plugin/storage_engine.h"
62
 
 
 
35
#include <drizzled/item/cache.h>
 
36
#include <drizzled/item/cmpfunc.h>
 
37
#include <drizzled/item/copy_string.h>
 
38
#include <drizzled/item/uint.h>
 
39
#include <drizzled/cached_item.h>
 
40
#include <drizzled/sql_base.h>
 
41
#include <drizzled/sql_select.h> /* include join.h */
 
42
#include <drizzled/lock.h>
 
43
#include <drizzled/nested_join.h>
 
44
#include <drizzled/join.h>
 
45
#include <drizzled/join_cache.h>
 
46
#include <drizzled/show.h>
 
47
#include <drizzled/field/blob.h>
 
48
#include <drizzled/open_tables_state.h>
 
49
#include <drizzled/optimizer/position.h>
 
50
#include <drizzled/optimizer/sargable_param.h>
 
51
#include <drizzled/optimizer/key_use.h>
 
52
#include <drizzled/optimizer/range.h>
 
53
#include <drizzled/optimizer/sum.h>
 
54
#include <drizzled/optimizer/explain_plan.h>
 
55
#include <drizzled/optimizer/access_method_factory.h>
 
56
#include <drizzled/optimizer/access_method.h>
 
57
#include <drizzled/records.h>
 
58
#include <drizzled/probes.h>
 
59
#include <drizzled/internal/my_bit.h>
 
60
#include <drizzled/internal/my_sys.h>
 
61
#include <drizzled/internal/iocache.h>
 
62
#include <drizzled/plugin/storage_engine.h>
 
63
#include <drizzled/session.h>
 
64
#include <drizzled/select_result.h>
63
65
#include <drizzled/debug.h>
64
 
 
 
66
#include <drizzled/item/subselect.h>
 
67
#include <drizzled/my_hash.h>
 
68
#include <drizzled/sql_lex.h>
 
69
#include <drizzled/statistics_variables.h>
 
70
#include <drizzled/system_variables.h>
65
71
#include <algorithm>
66
72
 
67
73
using namespace std;
68
74
 
69
 
namespace drizzled
70
 
{
 
75
namespace drizzled {
 
76
 
71
77
extern plugin::StorageEngine *heap_engine;
72
78
 
73
79
/** Declarations of static functions used in this source file. */
98
104
                                             uint32_t depth,
99
105
                                             uint32_t prune_level);
100
106
static uint32_t determine_search_depth(Join* join);
101
 
static bool make_simple_join(Join *join,Table *tmp_table);
 
107
static void make_simple_join(Join*, Table*);
102
108
static void make_outerjoin_info(Join *join);
103
109
static bool make_join_select(Join *join, optimizer::SqlSelect *select,COND *item);
104
 
static bool make_join_readinfo(Join *join);
 
110
static void make_join_readinfo(Join&);
105
111
static void update_depend_map(Join *join);
106
112
static void update_depend_map(Join *join, Order *order);
107
113
static Order *remove_constants(Join *join,Order *first_order,COND *cond, bool change_list, bool *simple_order);
108
 
static int return_zero_rows(Join *join,
 
114
static void return_zero_rows(Join *join,
109
115
                            select_result *res,
110
116
                            TableList *tables,
111
117
                            List<Item> &fields,
191
197
  having_history(NULL),
192
198
  select_options(select_options_arg),
193
199
  result(result_arg),
194
 
  lock(session_arg->lock),
 
200
  lock(session_arg->open_tables.lock),
195
201
  tmp_join(NULL),
196
202
  all_fields(fields_arg),
197
203
  error(0),
281
287
  having_history= NULL;
282
288
  select_options= select_options_arg;
283
289
  result= result_arg;
284
 
  lock= session_arg->lock;
 
290
  lock= session_arg->open_tables.lock;
285
291
  tmp_join= NULL;
286
292
  all_fields= fields_arg;
287
293
  error= 0;
308
314
 
309
315
bool Join::is_top_level_join() const
310
316
{
311
 
  return (unit == &session->lex->unit && (unit->fake_select_lex == 0 ||
312
 
                                          select_lex == unit->fake_select_lex));
 
317
  return unit == &session->lex().unit && (unit->fake_select_lex == 0 || select_lex == unit->fake_select_lex);
313
318
}
314
319
 
315
320
/**
349
354
  join_list= &select_lex->top_join_list;
350
355
  union_part= unit_arg->is_union();
351
356
 
352
 
  session->lex->current_select->is_item_list_lookup= 1;
 
357
  session->lex().current_select->is_item_list_lookup= 1;
353
358
  /*
354
359
    If we have already executed SELECT, then it have not sense to prevent
355
360
    its table from update (see unique_table())
360
365
  /* Check that all tables, fields, conds and order are ok */
361
366
 
362
367
  if (!(select_options & OPTION_SETUP_TABLES_DONE) &&
363
 
      setup_tables_and_check_access(session, &select_lex->context, join_list,
364
 
                                    tables_list, &select_lex->leaf_tables,
365
 
                                    false))
 
368
      setup_tables_and_check_access(session, &select_lex->context, join_list, tables_list, &select_lex->leaf_tables, false))
366
369
  {
367
370
      return(-1);
368
371
  }
369
372
 
370
373
  TableList *table_ptr;
371
 
  for (table_ptr= select_lex->leaf_tables;
372
 
       table_ptr;
373
 
       table_ptr= table_ptr->next_leaf)
 
374
  for (table_ptr= select_lex->leaf_tables; table_ptr; table_ptr= table_ptr->next_leaf)
374
375
  {
375
376
    tables++;
376
377
  }
377
378
 
378
379
 
379
 
  if (setup_wild(session, fields_list, &all_fields, wild_num) ||
380
 
      select_lex->setup_ref_array(session, og_num) ||
381
 
      setup_fields(session, (*rref_pointer_array), fields_list, MARK_COLUMNS_READ,
382
 
       &all_fields, 1) ||
383
 
      setup_without_group(session, (*rref_pointer_array), tables_list,
384
 
        select_lex->leaf_tables, fields_list,
385
 
        all_fields, &conds, order, group_list,
386
 
        &hidden_group_fields))
387
 
    return(-1);
 
380
  if (setup_wild(session, fields_list, &all_fields, wild_num))
 
381
    return -1;
 
382
  select_lex->setup_ref_array(session, og_num);
 
383
  if (setup_fields(session, *rref_pointer_array, fields_list, MARK_COLUMNS_READ, &all_fields, 1) ||
 
384
    setup_without_group(session, *rref_pointer_array, tables_list, select_lex->leaf_tables, fields_list,
 
385
    all_fields, &conds, order, group_list, &hidden_group_fields))
 
386
    return -1;
388
387
 
389
388
  ref_pointer_array= *rref_pointer_array;
390
389
 
391
390
  if (having)
392
391
  {
393
 
    nesting_map save_allow_sum_func= session->lex->allow_sum_func;
 
392
    nesting_map save_allow_sum_func= session->lex().allow_sum_func;
394
393
    session->setWhere("having clause");
395
 
    session->lex->allow_sum_func|= 1 << select_lex_arg->nest_level;
 
394
    session->lex().allow_sum_func|= 1 << select_lex_arg->nest_level;
396
395
    select_lex->having_fix_field= 1;
397
396
    bool having_fix_rc= (!having->fixed &&
398
397
       (having->fix_fields(session, &having) ||
400
399
    select_lex->having_fix_field= 0;
401
400
    if (having_fix_rc || session->is_error())
402
401
      return(-1);
403
 
    session->lex->allow_sum_func= save_allow_sum_func;
 
402
    session->lex().allow_sum_func= save_allow_sum_func;
404
403
  }
405
404
 
406
405
  {
450
449
            in_subs  &&                                                   // 1
451
450
            !select_lex->master_unit()->first_select()->next_select() &&  // 2
452
451
            select_lex->master_unit()->first_select()->leaf_tables &&     // 3
453
 
            session->lex->sql_command == SQLCOM_SELECT)                       // *
 
452
            session->lex().sql_command == SQLCOM_SELECT)                       // *
454
453
        {
455
454
          if (in_subs->is_top_level_item() &&                             // 4
456
455
              !in_subs->is_correlated &&                                  // 5
494
493
    } while (item_sum != end);
495
494
  }
496
495
 
497
 
  if (select_lex->inner_refs_list.elements &&
 
496
  if (select_lex->inner_refs_list.size() &&
498
497
      fix_inner_refs(session, all_fields, select_lex, ref_pointer_array))
499
498
    return(-1);
500
499
 
533
532
 
534
533
  /* Init join struct */
535
534
  count_field_types(select_lex, &tmp_table_param, all_fields, 0);
536
 
  ref_pointer_array_size= all_fields.elements*sizeof(Item*);
 
535
  ref_pointer_array_size= all_fields.size() * sizeof(Item*);
537
536
  this->group= group_list != 0;
538
537
  unit= unit_arg;
539
538
 
623
622
    select_limit= HA_POS_ERROR;
624
623
  do_send_rows = (unit->select_limit_cnt) ? 1 : 0;
625
624
  // Ignore errors of execution if option IGNORE present
626
 
  if (session->lex->ignore)
627
 
    session->lex->current_select->no_error= 1;
 
625
  if (session->lex().ignore)
 
626
    session->lex().current_select->no_error= 1;
628
627
 
629
628
#ifdef HAVE_REF_TO_FIELDS     // Not done yet
630
629
  /* Add HAVING to WHERE if possible */
635
634
      conds= having;
636
635
      having= 0;
637
636
    }
638
 
    else if ((conds=new Item_cond_and(conds,having)))
 
637
    else
639
638
    {
 
639
      conds= new Item_cond_and(conds,having);
 
640
 
640
641
      /*
641
642
        Item_cond_and can't be fixed after creation, so we do not check
642
643
        conds->fixed
724
725
        conjunctions.
725
726
        Preserve conditions for EXPLAIN.
726
727
      */
727
 
      if (conds && !(session->lex->describe & DESCRIBE_EXTENDED))
 
728
      if (conds && !(session->lex().describe & DESCRIBE_EXTENDED))
728
729
      {
729
730
        COND *table_independent_conds= make_cond_for_table(conds, PSEUDO_TABLE_BITS, 0, 0);
730
731
        conds= table_independent_conds;
735
736
  if (!tables_list)
736
737
  {
737
738
    error= 0;
738
 
    return(0);
 
739
    return 0;
739
740
  }
740
741
  error= -1;          // Error is sent to client
741
742
  sort_by_table= get_sort_by_table(order, group_list, select_lex->leaf_tables);
759
760
      !(select_options & SELECT_DESCRIBE) &&
760
761
      (!conds ||
761
762
       !(conds->used_tables() & RAND_TABLE_BIT) ||
762
 
       select_lex->master_unit() == &session->lex->unit)) // upper level SELECT
 
763
       select_lex->master_unit() == &session->lex().unit)) // upper level SELECT
763
764
  {
764
765
    zero_result_cause= "no matching row in const table";
765
766
    goto setup_subq_exit;
819
820
 
820
821
  if (conds &&!outer_join && const_table_map != found_const_table_map &&
821
822
      (select_options & SELECT_DESCRIBE) &&
822
 
      select_lex->master_unit() == &session->lex->unit) // upper level SELECT
 
823
      select_lex->master_unit() == &session->lex().unit) // upper level SELECT
823
824
  {
824
 
    conds=new Item_int((int64_t) 0,1);  // Always false
 
825
    conds=new Item_int(0, 1);  // Always false
825
826
  }
826
827
 
827
828
  if (make_join_select(this, select, conds))
1020
1021
        test(select_options & OPTION_BUFFER_RESULT)));
1021
1022
 
1022
1023
  // No cache for MATCH == 'Don't use join buffering when we use MATCH'.
1023
 
  if (make_join_readinfo(this))
1024
 
    return 1;
 
1024
  make_join_readinfo(*this);
1025
1025
 
1026
1026
  /* Create all structures needed for materialized subquery execution. */
1027
1027
  if (setup_subquery_materialization())
1136
1136
  if (select_options & SELECT_DESCRIBE)
1137
1137
  {
1138
1138
    error= 0;
1139
 
    return(0);
 
1139
    return 0;
1140
1140
  }
1141
1141
  having= 0;
1142
1142
 
1161
1161
 
1162
1162
    init_items_ref_array();
1163
1163
 
1164
 
    tmp_table_param.hidden_field_count= (all_fields.elements -
1165
 
           fields_list.elements);
1166
 
    Order *tmp_group= (((not simple_group) or not (getDebug().test(debug::NO_KEY_GROUP))) ? group_list : (Order*) 0);
 
1164
    tmp_table_param.hidden_field_count= all_fields.size() - fields_list.size();
 
1165
    Order *tmp_group= (((not simple_group) or not (getDebug().test(debug::NO_KEY_GROUP))) ? group_list : NULL);
1167
1166
 
1168
1167
    /*
1169
1168
      Pushing LIMIT to the temporary table creation is not applicable
1173
1172
    */
1174
1173
    ha_rows tmp_rows_limit= ((order == 0 || skip_sort_order) &&
1175
1174
                             !tmp_group &&
1176
 
                             !session->lex->current_select->with_sum_func) ?
 
1175
                             !session->lex().current_select->with_sum_func) ?
1177
1176
                            select_limit : HA_POS_ERROR;
1178
1177
 
1179
1178
    if (!(exec_tmp_table1=
1226
1225
      if (!group_list && ! exec_tmp_table1->distinct && order && simple_order)
1227
1226
      {
1228
1227
        session->set_proc_info("Sorting for order");
1229
 
        if (create_sort_index(session, this, order,
1230
 
                              HA_POS_ERROR, HA_POS_ERROR, true))
 
1228
        if (create_sort_index(session, this, order, HA_POS_ERROR, HA_POS_ERROR, true))
1231
1229
        {
1232
1230
          return 1;
1233
1231
        }
1267
1265
      If this join belongs to an uncacheable subquery save
1268
1266
      the original join
1269
1267
    */
1270
 
    if (select_lex->uncacheable.any() && 
1271
 
        ! is_top_level_join() &&
1272
 
        init_save_join_tab())
1273
 
    {
1274
 
      return -1;
1275
 
    }
 
1268
    if (select_lex->uncacheable.any() && not is_top_level_join())
 
1269
      init_save_join_tab();
1276
1270
  }
1277
1271
 
1278
1272
  error= 0;
1335
1329
      func->clear();
1336
1330
  }
1337
1331
 
1338
 
  return(0);
 
1332
  return 0;
1339
1333
}
1340
1334
 
1341
1335
/**
1348
1342
   @retval 0      success.
1349
1343
   @retval 1      error occurred.
1350
1344
*/
1351
 
bool Join::init_save_join_tab()
 
1345
void Join::init_save_join_tab()
1352
1346
{
1353
 
  if (!(tmp_join= (Join*)session->getMemRoot()->allocate(sizeof(Join))))
1354
 
    return 1;
 
1347
  tmp_join= (Join*)session->mem.alloc(sizeof(Join));
1355
1348
 
1356
1349
  error= 0;              // Ensure that tmp_join.error= 0
1357
1350
  restore_tmp();
1358
 
 
1359
 
  return 0;
1360
1351
}
1361
1352
 
1362
 
bool Join::save_join_tab()
 
1353
void Join::save_join_tab()
1363
1354
{
1364
1355
  if (! join_tab_save && select_lex->master_unit()->uncacheable.any())
1365
1356
  {
1366
 
    if (!(join_tab_save= (JoinTable*)session->getMemRoot()->duplicate((unsigned char*) join_tab,
1367
 
            sizeof(JoinTable) * tables)))
1368
 
      return 1;
 
1357
    join_tab_save= (JoinTable*)session->mem.memdup(join_tab, sizeof(JoinTable) * tables);
1369
1358
  }
1370
 
  return 0;
1371
1359
}
1372
1360
 
1373
1361
/**
1442
1430
 
1443
1431
  if (zero_result_cause)
1444
1432
  {
1445
 
    (void) return_zero_rows(this, result, select_lex->leaf_tables,
1446
 
                            *columns_list,
1447
 
          send_row_on_empty_set(),
1448
 
          select_options,
1449
 
          zero_result_cause,
1450
 
          having);
 
1433
    return_zero_rows(this, result, select_lex->leaf_tables, *columns_list, send_row_on_empty_set(), select_options, zero_result_cause, having);
1451
1434
    return;
1452
1435
  }
1453
1436
 
1512
1495
    session->set_proc_info("Copying to tmp table");
1513
1496
    if (! curr_join->sort_and_group && curr_join->const_tables != curr_join->tables)
1514
1497
      curr_join->join_tab[curr_join->const_tables].sorted= 0;
1515
 
    if ((tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))
 
1498
    if ((tmp_error= do_select(curr_join, NULL, curr_tmp_table)))
1516
1499
    {
1517
1500
      error= tmp_error;
1518
1501
      return;
1526
1509
    curr_join->all_fields= *curr_all_fields;
1527
1510
    if (!items1)
1528
1511
    {
1529
 
      items1= items0 + all_fields.elements;
 
1512
      items1= items0 + all_fields.size();
1530
1513
      if (sort_and_group || curr_tmp_table->group)
1531
1514
      {
1532
1515
        if (change_to_use_tmp_fields(session, items1,
1533
1516
                  tmp_fields_list1, tmp_all_fields1,
1534
 
                  fields_list.elements, all_fields))
 
1517
                  fields_list.size(), all_fields))
1535
1518
          return;
1536
1519
      }
1537
1520
      else
1538
1521
      {
1539
1522
        if (change_refs_to_tmp_fields(session, items1,
1540
1523
                    tmp_fields_list1, tmp_all_fields1,
1541
 
                    fields_list.elements, all_fields))
 
1524
                    fields_list.size(), all_fields))
1542
1525
          return;
1543
1526
      }
1544
1527
      curr_join->tmp_all_fields1= tmp_all_fields1;
1582
1565
    {         /* Must copy to another table */
1583
1566
      /* Free first data from old join */
1584
1567
      curr_join->join_free();
1585
 
      if (make_simple_join(curr_join, curr_tmp_table))
1586
 
        return;
 
1568
      make_simple_join(curr_join, curr_tmp_table);
1587
1569
      calc_group_buffer(curr_join, group_list);
1588
1570
      count_field_types(select_lex, &curr_join->tmp_table_param,
1589
1571
      curr_join->tmp_all_fields1,
1590
1572
      curr_join->select_distinct && !curr_join->group_list);
1591
 
      curr_join->tmp_table_param.hidden_field_count= curr_join->tmp_all_fields1.elements
1592
 
                                                   - curr_join->tmp_fields_list1.elements;
 
1573
      curr_join->tmp_table_param.hidden_field_count= curr_join->tmp_all_fields1.size()
 
1574
                                                   - curr_join->tmp_fields_list1.size();
1593
1575
 
1594
1576
      if (exec_tmp_table2)
1595
1577
      {
1611
1593
              exec_tmp_table2= create_tmp_table(session,
1612
1594
                                                &curr_join->tmp_table_param,
1613
1595
                                                *curr_all_fields,
1614
 
                                                (Order*) 0,
 
1596
                                                NULL,
1615
1597
                                                curr_join->select_distinct &&
1616
1598
                                                !curr_join->group_list,
1617
1599
                                                1, curr_join->select_options,
1626
1608
      if (curr_join->group_list)
1627
1609
      {
1628
1610
        session->set_proc_info("Creating sort index");
1629
 
        if (curr_join->join_tab == join_tab && save_join_tab())
1630
 
        {
1631
 
          return;
1632
 
        }
1633
 
        if (create_sort_index(session, curr_join, curr_join->group_list,
1634
 
                  HA_POS_ERROR, HA_POS_ERROR, false) ||
 
1611
        if (curr_join->join_tab == join_tab)
 
1612
          save_join_tab();
 
1613
        if (create_sort_index(session, curr_join, curr_join->group_list, HA_POS_ERROR, HA_POS_ERROR, false) ||
1635
1614
            make_group_fields(this, curr_join))
1636
1615
        {
1637
1616
          return;
1663
1642
        curr_join->join_tab[curr_join->const_tables].sorted= 0;
1664
1643
      
1665
1644
      if (setup_sum_funcs(curr_join->session, curr_join->sum_funcs) 
1666
 
        || (tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))
 
1645
        || (tmp_error= do_select(curr_join, NULL, curr_tmp_table)))
1667
1646
      {
1668
1647
        error= tmp_error;
1669
1648
        return;
1675
1654
      // No sum funcs anymore
1676
1655
      if (!items2)
1677
1656
      {
1678
 
        items2= items1 + all_fields.elements;
 
1657
        items2= items1 + all_fields.size();
1679
1658
        if (change_to_use_tmp_fields(session, items2,
1680
1659
                  tmp_fields_list2, tmp_all_fields2,
1681
 
                  fields_list.elements, tmp_all_fields1))
 
1660
                  fields_list.size(), tmp_all_fields1))
1682
1661
          return;
1683
1662
        curr_join->tmp_fields_list2= tmp_fields_list2;
1684
1663
        curr_join->tmp_all_fields2= tmp_all_fields2;
1707
1686
      curr_join->select_distinct=0;
1708
1687
    }
1709
1688
    curr_tmp_table->reginfo.lock_type= TL_UNLOCK;
1710
 
    if (make_simple_join(curr_join, curr_tmp_table))
1711
 
      return;
 
1689
    make_simple_join(curr_join, curr_tmp_table);
1712
1690
    calc_group_buffer(curr_join, curr_join->group_list);
1713
1691
    count_field_types(select_lex, &curr_join->tmp_table_param, *curr_all_fields, 0);
1714
1692
 
1723
1701
    {
1724
1702
      if (! items0)
1725
1703
        init_items_ref_array();
1726
 
      items3= ref_pointer_array + (all_fields.elements*4);
 
1704
      items3= ref_pointer_array + (all_fields.size() * 4);
1727
1705
      setup_copy_fields(session, &curr_join->tmp_table_param,
1728
1706
      items3, tmp_fields_list3, tmp_all_fields3,
1729
 
      curr_fields_list->elements, *curr_all_fields);
 
1707
      curr_fields_list->size(), *curr_all_fields);
1730
1708
      tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;
1731
1709
      tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;
1732
1710
      tmp_table_param.save_copy_field_end= curr_join->tmp_table_param.copy_field_end;
1765
1743
      if (sort_table_cond)
1766
1744
      {
1767
1745
        if (!curr_table->select)
1768
 
          if (!(curr_table->select= new optimizer::SqlSelect()))
1769
 
            return;
 
1746
          curr_table->select= new optimizer::SqlSelect;
1770
1747
        if (!curr_table->select->cond)
1771
1748
          curr_table->select->cond= sort_table_cond;
1772
1749
        else          // This should never happen
1773
1750
        {
1774
 
          if (!(curr_table->select->cond=
1775
 
          new Item_cond_and(curr_table->select->cond,
1776
 
                sort_table_cond)))
1777
 
            return;
 
1751
          curr_table->select->cond= new Item_cond_and(curr_table->select->cond, sort_table_cond);
1778
1752
          /*
1779
1753
            Item_cond_and do not need fix_fields for execution, its parameters
1780
1754
            are fixed or do not need fix_fields, too
1783
1757
        }
1784
1758
        curr_table->select_cond= curr_table->select->cond;
1785
1759
        curr_table->select_cond->top_level_item();
1786
 
        curr_join->tmp_having= make_cond_for_table(curr_join->tmp_having,
1787
 
                    ~ (table_map) 0,
1788
 
                    ~used_tables, 0);
 
1760
        curr_join->tmp_having= make_cond_for_table(curr_join->tmp_having, ~ (table_map) 0, ~used_tables, 0);
1789
1761
      }
1790
1762
    }
1791
1763
    {
1814
1786
          }
1815
1787
        }
1816
1788
      }
1817
 
      if (curr_join->join_tab == join_tab && save_join_tab())
1818
 
        return;
 
1789
      if (curr_join->join_tab == join_tab)
 
1790
        save_join_tab();
1819
1791
      /*
1820
1792
        Here we sort rows for order_st BY/GROUP BY clause, if the optimiser
1821
1793
        chose FILESORT to be faster than INDEX SCAN or there is no
1869
1841
    for a derived table which is always materialized.
1870
1842
    Otherwise we would not be able to print the query  correctly.
1871
1843
  */
1872
 
  if (items0 && (session->lex->describe & DESCRIBE_EXTENDED) && select_lex->linkage == DERIVED_TABLE_TYPE)
 
1844
  if (items0 && (session->lex().describe & DESCRIBE_EXTENDED) && select_lex->linkage == DERIVED_TABLE_TYPE)
1873
1845
    set_items_ref_array(items0);
1874
1846
 
1875
1847
  return;
2001
1973
    Optimization: if not EXPLAIN and we are done with the Join,
2002
1974
    free all tables.
2003
1975
  */
2004
 
  bool full= (select_lex->uncacheable.none() && ! session->lex->describe);
 
1976
  bool full= (select_lex->uncacheable.none() && ! session->lex().describe);
2005
1977
  bool can_unlock= full;
2006
1978
 
2007
1979
  cleanup(full);
2033
2005
    We are not using tables anymore
2034
2006
    Unlock all tables. We may be in an INSERT .... SELECT statement.
2035
2007
  */
2036
 
  if (can_unlock && lock && session->lock &&
 
2008
  if (can_unlock && lock && session->open_tables.lock &&
2037
2009
      !(select_options & SELECT_NO_UNLOCK) &&
2038
2010
      !select_lex->subquery_in_having &&
2039
 
      (select_lex == (session->lex->unit.fake_select_lex ?
2040
 
                      session->lex->unit.fake_select_lex : &session->lex->select_lex)))
 
2011
      (select_lex == (session->lex().unit.fake_select_lex ?
 
2012
                      session->lex().unit.fake_select_lex : &session->lex().select_lex)))
2041
2013
  {
2042
2014
    /*
2043
2015
      TODO: unlock tables even if the join isn't top level select in the
2110
2082
      We can't call delete_elements() on copy_funcs as this will cause
2111
2083
      problems in free_elements() as some of the elements are then deleted.
2112
2084
    */
2113
 
    tmp_table_param.copy_funcs.empty();
 
2085
    tmp_table_param.copy_funcs.clear();
2114
2086
    /*
2115
2087
      If we have tmp_join and 'this' Join is not tmp_join and
2116
2088
      tmp_table_param.copy_field's  of them are equal then we have to remove
2173
2145
  */
2174
2146
  if (select_distinct)
2175
2147
  {
2176
 
    group_parts+= fields_list.elements;
 
2148
    group_parts+= fields_list.size();
2177
2149
    /*
2178
2150
      If the order_st clause is specified then it's possible that
2179
2151
      it also will be optimized, so reserve space for it too
2187
2159
  }
2188
2160
 
2189
2161
  /* This must use calloc() as rollup_make_fields depends on this */
2190
 
  sum_funcs= (Item_sum**) session->calloc(sizeof(Item_sum**) * (func_count+1) +
 
2162
  sum_funcs= (Item_sum**) session->mem.calloc(sizeof(Item_sum**) * (func_count+1) +
2191
2163
              sizeof(Item_sum***) * (group_parts+1));
2192
2164
  sum_funcs_end= (Item_sum***) (sum_funcs+func_count+1);
2193
2165
  return(sum_funcs == 0);
2211
2183
                              bool before_group_by, 
2212
2184
                              bool recompute)
2213
2185
{
2214
 
  List_iterator_fast<Item> it(field_list);
 
2186
  List<Item>::iterator it(field_list.begin());
2215
2187
  Item_sum **func;
2216
2188
  Item *item;
2217
2189
 
2218
2190
  if (*sum_funcs && !recompute)
2219
 
    return(false); /* We have already initialized sum_funcs. */
 
2191
    return false; /* We have already initialized sum_funcs. */
2220
2192
 
2221
2193
  func= sum_funcs;
2222
2194
  while ((item=it++))
2238
2210
      sum_funcs_end[i]= func;
2239
2211
  }
2240
2212
  else if (rollup.getState() == Rollup::STATE_READY)
2241
 
    return(false);                         // Don't put end marker
 
2213
    return false;                         // Don't put end marker
2242
2214
  *func=0;          // End marker
2243
 
  return(false);
 
2215
  return false;
2244
2216
}
2245
2217
 
2246
2218
/** Allocate memory needed for other rollup functions. */
2247
2219
bool Join::rollup_init()
2248
2220
{
2249
 
  Item **ref_array;
2250
2221
 
2251
2222
  tmp_table_param.quick_group= 0; // Can't create groups in tmp table
2252
2223
  rollup.setState(Rollup::STATE_INITED);
2257
2228
  */
2258
2229
  tmp_table_param.group_parts= send_group_parts;
2259
2230
 
2260
 
  rollup.setNullItems((Item_null_result**) session->getMemRoot()->allocate((sizeof(Item*) +
2261
 
                                                                sizeof(Item**) +
2262
 
                                                                sizeof(List<Item>) +
2263
 
                                                                ref_pointer_array_size)
2264
 
                                                               * send_group_parts ));
2265
 
  if (! rollup.getNullItems())
2266
 
  {
2267
 
    return 1;
2268
 
  }
2269
 
 
 
2231
  rollup.setNullItems((Item_null_result**) session->mem.alloc((sizeof(Item*) + sizeof(Item**) + sizeof(List<Item>) + ref_pointer_array_size) * send_group_parts));
2270
2232
  rollup.setFields((List<Item>*) (rollup.getNullItems() + send_group_parts));
2271
2233
  rollup.setRefPointerArrays((Item***) (rollup.getFields() + send_group_parts));
2272
 
  ref_array= (Item**) (rollup.getRefPointerArrays()+send_group_parts);
 
2234
  Item** ref_array= (Item**) (rollup.getRefPointerArrays()+send_group_parts);
2273
2235
 
2274
2236
  /*
2275
2237
    Prepare space for field list for the different levels
2277
2239
  */
2278
2240
  for (uint32_t i= 0 ; i < send_group_parts ; i++)
2279
2241
  {
2280
 
    rollup.getNullItems()[i]= new (session->mem_root) Item_null_result();
 
2242
    rollup.getNullItems()[i]= new (session->mem) Item_null_result();
2281
2243
    List<Item> *rollup_fields= &rollup.getFields()[i];
2282
 
    rollup_fields->empty();
 
2244
    rollup_fields->clear();
2283
2245
    rollup.getRefPointerArrays()[i]= ref_array;
2284
 
    ref_array+= all_fields.elements;
 
2246
    ref_array+= all_fields.size();
2285
2247
  }
2286
2248
 
2287
2249
  for (uint32_t i= 0 ; i < send_group_parts; i++)
2288
2250
  {
2289
 
    for (uint32_t j= 0 ; j < fields_list.elements ; j++)
 
2251
    for (uint32_t j= 0 ; j < fields_list.size() ; j++)
2290
2252
    {
2291
2253
      rollup.getFields()[i].push_back(rollup.getNullItems()[i]);
2292
2254
    }
2293
2255
  }
2294
2256
 
2295
 
  List_iterator<Item> it(all_fields);
2296
 
  Item *item;
2297
 
  while ((item= it++))
 
2257
  List<Item>::iterator it(all_fields.begin());
 
2258
  while (Item* item= it++)
2298
2259
  {
2299
2260
    Order *group_tmp;
2300
2261
    bool found_in_group= 0;
2321
2282
            result we do not include fields for constant expressions.
2322
2283
          */
2323
2284
          Item* new_item= new Item_func_rollup_const(item);
2324
 
          if (!new_item)
2325
 
            return 1;
2326
 
          new_item->fix_fields(session, (Item **) 0);
2327
 
          session->change_item_tree(it.ref(), new_item);
 
2285
          new_item->fix_fields(session, NULL);
 
2286
          *it.ref()= new_item;
2328
2287
          for (Order *tmp= group_tmp; tmp; tmp= tmp->next)
2329
2288
          {
2330
2289
            if (*tmp->item == item)
2331
 
              session->change_item_tree(tmp->item, new_item);
 
2290
              *tmp->item= new_item;
2332
2291
          }
2333
2292
        }
2334
2293
      }
2367
2326
*/
2368
2327
bool Join::rollup_make_fields(List<Item> &fields_arg, List<Item> &sel_fields, Item_sum ***func)
2369
2328
{
2370
 
  List_iterator_fast<Item> it(fields_arg);
2371
 
  Item *first_field= sel_fields.head();
 
2329
  List<Item>::iterator it(fields_arg.begin());
 
2330
  Item *first_field= &sel_fields.front();
2372
2331
  uint32_t level;
2373
2332
 
2374
2333
  /*
2398
2357
    uint32_t pos= send_group_parts - level -1;
2399
2358
    bool real_fields= 0;
2400
2359
    Item *item;
2401
 
    List_iterator<Item> new_it(rollup.getFields()[pos]);
 
2360
    List<Item>::iterator new_it(rollup.getFields()[pos].begin());
2402
2361
    Item **ref_array_start= rollup.getRefPointerArrays()[pos];
2403
2362
    Order *start_group;
2404
2363
 
2405
2364
    /* Point to first hidden field */
2406
 
    Item **ref_array= ref_array_start + fields_arg.elements-1;
 
2365
    Item **ref_array= ref_array_start + fields_arg.size()-1;
2407
2366
 
2408
2367
    /* Remember where the sum functions ends for the previous level */
2409
2368
    sum_funcs_end[pos+1]= *func;
2412
2371
    for (i= 0, start_group= group_list ;i++ < pos ;start_group= start_group->next)
2413
2372
    {}
2414
2373
 
2415
 
    it.rewind();
 
2374
    it= fields_arg.begin();
2416
2375
    while ((item= it++))
2417
2376
    {
2418
2377
      if (item == first_field)
2452
2411
              This is an element that is used by the GROUP BY and should be
2453
2412
              set to NULL in this level
2454
2413
            */
2455
 
                  Item_null_result *null_item= new (session->mem_root) Item_null_result();
2456
 
                  if (!null_item)
2457
 
                    return 1;
 
2414
                  Item_null_result *null_item= new (session->mem) Item_null_result();
2458
2415
            item->maybe_null= 1;    // Value will be null sometimes
2459
2416
                  null_item->result_field= item->get_tmp_table_field();
2460
2417
                  item= null_item;
2545
2502
           ref_pointer_array_size);
2546
2503
    if ((!having || having->val_int()))
2547
2504
    {
2548
 
      int write_error;
2549
 
      Item *item;
2550
 
      List_iterator_fast<Item> it(rollup.getFields()[i]);
2551
 
      while ((item= it++))
 
2505
      List<Item>::iterator it(rollup.getFields()[i].begin());
 
2506
      while (Item* item= it++)
2552
2507
      {
2553
2508
        if (item->type() == Item::NULL_ITEM && item->is_result_field())
2554
2509
          item->save_in_result_field(1);
2555
2510
      }
2556
2511
      copy_sum_funcs(sum_funcs_end[i+1], sum_funcs_end[i]);
2557
 
      if ((write_error= table_arg->cursor->insertRecord(table_arg->getInsertRecord())))
 
2512
      if (table_arg->cursor->insertRecord(table_arg->getInsertRecord()))
2558
2513
      {
2559
2514
        my_error(ER_USE_SQL_BIG_RESULT, MYF(0));
2560
2515
        return 1;
2599
2554
  result= res;
2600
2555
  if (result->prepare(fields_list, select_lex->master_unit()))
2601
2556
  {
2602
 
    return(true);
 
2557
    return true;
2603
2558
  }
2604
 
  return(false);
 
2559
  return false;
2605
2560
}
2606
2561
 
2607
2562
/**
2849
2804
 
2850
2805
  if (join_tab->use_quick == 2)
2851
2806
  {
2852
 
    if (join_tab->select->quick)
2853
 
    {                                   /* Used quick select last. reset it */
2854
 
      delete join_tab->select->quick;
2855
 
      join_tab->select->quick=0;
2856
 
    }
 
2807
    delete join_tab->select->quick;
 
2808
    join_tab->select->quick= 0;
2857
2809
  }
2858
2810
  /* read through all records */
2859
2811
  if ((error=join_init_read_record(join_tab)))
3167
3119
*/
3168
3120
static bool make_group_fields(Join *main_join, Join *curr_join)
3169
3121
{
3170
 
  if (main_join->group_fields_cache.elements)
 
3122
  if (main_join->group_fields_cache.size())
3171
3123
  {
3172
3124
    curr_join->group_fields= main_join->group_fields_cache;
3173
3125
    curr_join->sort_and_group= 1;
3229
3181
            have STRING_RESULT result type, we increase the length
3230
3182
            by 8 as maximum pack length of such fields.
3231
3183
          */
3232
 
          if (type == DRIZZLE_TYPE_DATE ||
3233
 
              type == DRIZZLE_TYPE_TIME ||
3234
 
              type == DRIZZLE_TYPE_DATETIME ||
3235
 
              type == DRIZZLE_TYPE_MICROTIME ||
3236
 
              type == DRIZZLE_TYPE_TIMESTAMP)
 
3184
          if (field::isDateTime(type))
3237
3185
          {
3238
3186
            key_length+= 8;
3239
3187
          }
3280
3228
    for (; group ; group=group->next)
3281
3229
    {
3282
3230
      Cached_item *tmp= new_Cached_item(join->session, *group->item);
3283
 
      if (!tmp || join->group_fields.push_front(tmp))
 
3231
      if (!tmp)
3284
3232
        return true;
 
3233
                        join->group_fields.push_front(tmp);
3285
3234
    }
3286
3235
  }
3287
3236
  join->sort_and_group=1;     /* Mark for do_select */
3404
3353
  optimizer::Position cur_pos;
3405
3354
 
3406
3355
  table_count=join->tables;
3407
 
  if (!(join->join_tab=join_tab=
3408
 
  (JoinTable*) session->getMemRoot()->allocate(sizeof(JoinTable)*table_count)))
3409
 
    return(true);
3410
 
 
3411
 
  for (i= 0; i < table_count; i++)
3412
 
    new (join_tab+i) JoinTable();
3413
 
 
 
3356
  join->join_tab=join_tab= new (session->mem) JoinTable[table_count];
3414
3357
  join->full_join=0;
3415
3358
 
3416
3359
  used_tables= OUTER_REF_TABLE_BIT;   // Outer row is already read
3439
3382
        join->full_join=1;
3440
3383
    }
3441
3384
    else if (create_ref_for_key(join, j, keyuse, used_tables))
3442
 
      return(true);                        // Something went wrong
 
3385
      return true;                        // Something went wrong
3443
3386
  }
3444
3387
 
3445
3388
  for (i=0 ; i < table_count ; i++)
3446
3389
    join->map2table[join->join_tab[i].table->tablenr]=join->join_tab+i;
3447
3390
  update_depend_map(join);
3448
 
  return(0);
 
3391
  return 0;
3449
3392
}
3450
3393
 
3451
3394
/** Save const tables first as used tables. */
3529
3472
    i.e. they have subqueries, unions or call stored procedures.
3530
3473
    TODO: calculate a correct cost for a query with subqueries and UNIONs.
3531
3474
  */
3532
 
  if (join->session->lex->is_single_level_stmt())
 
3475
  if (join->session->lex().is_single_level_stmt())
3533
3476
    join->session->status_var.last_query_cost= join->best_read;
3534
 
  return(false);
 
3477
  return false;
3535
3478
}
3536
3479
 
3537
3480
/**
4042
3985
        will ensure that this will be used
4043
3986
      */
4044
3987
      best= tmp;
4045
 
      records= rows2double(rnd_records);
 
3988
      records= rnd_records;
4046
3989
      best_key= 0;
4047
3990
      /* range/index_merge/ALL/index access method are "independent", so: */
4048
3991
      best_ref_depends_map= 0;
4219
4162
    join->best_read= DBL_MAX;
4220
4163
    if (best_extension_by_limited_search(join, remaining_tables, idx, record_count,
4221
4164
                                         read_time, search_depth, prune_level))
4222
 
      return(true);
 
4165
      return true;
4223
4166
 
4224
4167
    if (size_remain <= search_depth)
4225
4168
    {
4227
4170
        'join->best_positions' contains a complete optimal extension of the
4228
4171
        current partial QEP.
4229
4172
      */
4230
 
      return(false);
 
4173
      return false;
4231
4174
    }
4232
4175
 
4233
4176
    /* select the first table in the optimal extension as most promising */
4396
4339
{
4397
4340
  Session *session= join->session;
4398
4341
  if (session->getKilled())  // Abort
4399
 
    return(true);
 
4342
    return true;
4400
4343
 
4401
4344
  /*
4402
4345
     'join' is a partial plan with lower cost than the best plan so far,
4476
4419
                                             current_read_time,
4477
4420
                                             search_depth - 1,
4478
4421
                                             prune_level))
4479
 
          return(true);
 
4422
          return true;
4480
4423
        std::swap(join->best_ref[idx], *pos);
4481
4424
      }
4482
4425
      else
4499
4442
      restore_prev_nj_state(s);
4500
4443
    }
4501
4444
  }
4502
 
  return(false);
 
4445
  return false;
4503
4446
}
4504
4447
 
4505
4448
/**
4552
4495
  return search_depth;
4553
4496
}
4554
4497
 
4555
 
static bool make_simple_join(Join *join,Table *tmp_table)
 
4498
static void make_simple_join(Join *join,Table *tmp_table)
4556
4499
{
4557
 
  Table **tableptr;
4558
 
  JoinTable *join_tab;
4559
 
 
4560
4500
  /*
4561
4501
    Reuse Table * and JoinTable if already allocated by a previous call
4562
4502
    to this function through Join::exec (may happen for sub-queries).
4563
4503
  */
4564
4504
  if (!join->table_reexec)
4565
4505
  {
4566
 
    if (!(join->table_reexec= (Table**) join->session->getMemRoot()->allocate(sizeof(Table*))))
4567
 
      return(true);
 
4506
    join->table_reexec= new (join->session->mem) Table*;
4568
4507
    if (join->tmp_join)
4569
4508
      join->tmp_join->table_reexec= join->table_reexec;
4570
4509
  }
4571
4510
  if (!join->join_tab_reexec)
4572
4511
  {
4573
 
    if (!(join->join_tab_reexec=
4574
 
          (JoinTable*) join->session->getMemRoot()->allocate(sizeof(JoinTable))))
4575
 
      return(true);
4576
 
    new (join->join_tab_reexec) JoinTable();
 
4512
    join->join_tab_reexec= new (join->session->mem) JoinTable;
4577
4513
    if (join->tmp_join)
4578
4514
      join->tmp_join->join_tab_reexec= join->join_tab_reexec;
4579
4515
  }
4580
 
  tableptr= join->table_reexec;
4581
 
  join_tab= join->join_tab_reexec;
 
4516
  Table** tableptr= join->table_reexec;
 
4517
  JoinTable* join_tab= join->join_tab_reexec;
4582
4518
 
4583
4519
  join->join_tab=join_tab;
4584
4520
  join->table=tableptr; tableptr[0]=tmp_table;
4612
4548
  join_tab->read_record.init();
4613
4549
  tmp_table->status=0;
4614
4550
  tmp_table->null_row=0;
4615
 
 
4616
 
  return false;
4617
4551
}
4618
4552
 
4619
4553
/**
4699
4633
      }
4700
4634
      if (!tab->first_inner)
4701
4635
        tab->first_inner= nested_join->first_nested;
4702
 
      if (++nested_join->counter_ < nested_join->join_list.elements)
 
4636
      if (++nested_join->counter_ < nested_join->join_list.size())
4703
4637
        break;
4704
4638
      /* Table tab is the last inner table for nested join. */
4705
4639
      nested_join->first_nested->last_inner= tab;
4723
4657
      if (join->tables > 1)
4724
4658
        cond->update_used_tables();             // Tablenr may have changed
4725
4659
      if (join->const_tables == join->tables &&
4726
 
          session->lex->current_select->master_unit() ==
4727
 
          &session->lex->unit)          // not upper level SELECT
 
4660
          session->lex().current_select->master_unit() ==
 
4661
          &session->lex().unit)         // not upper level SELECT
4728
4662
        join->const_table_map|=RAND_TABLE_BIT;
4729
4663
      {                                         // Check const tables
4730
4664
        COND *const_cond=
4731
4665
          make_cond_for_table(cond,
4732
4666
              join->const_table_map,
4733
 
              (table_map) 0, 1);
 
4667
              0, 1);
4734
4668
        for (JoinTable *tab= join->join_tab+join->const_tables;
4735
4669
            tab < join->join_tab+join->tables ; tab++)
4736
4670
        {
4793
4727
        tab->ref.key= -1;
4794
4728
        tab->ref.key_parts= 0;          // Don't use ref key.
4795
4729
        cur_pos= join->getPosFromOptimalPlan(i);
4796
 
        cur_pos.setFanout(rows2double(tab->quick->records));
 
4730
        cur_pos.setFanout(tab->quick->records);
4797
4731
        /*
4798
4732
           We will use join cache here : prevent sorting of the first
4799
4733
           table only and sort at the end.
4802
4736
          join->full_join= 1;
4803
4737
      }
4804
4738
 
4805
 
      if (join->full_join and not session->lex->current_select->is_cross and not cond)
 
4739
      if (join->full_join and not session->lex().current_select->is_cross and not cond)
4806
4740
      {
4807
4741
        my_error(ER_CARTESIAN_JOIN_ATTEMPTED, MYF(0));
4808
4742
        return 1;
4837
4771
      if (tmp || !cond || tab->type == AM_REF || tab->type == AM_REF_OR_NULL ||
4838
4772
          tab->type == AM_EQ_REF)
4839
4773
      {
4840
 
        optimizer::SqlSelect *sel= tab->select= ((optimizer::SqlSelect*)
4841
 
            session->getMemRoot()->duplicate((unsigned char*) select,
4842
 
              sizeof(*select)));
4843
 
        if (! sel)
4844
 
          return 1;                     // End of memory
 
4774
        optimizer::SqlSelect *sel= tab->select= ((optimizer::SqlSelect*)session->mem.memdup(select, sizeof(*select)));
4845
4775
        /*
4846
4776
           If tab is an inner table of an outer join operation,
4847
4777
           add a match guard to the pushed down predicate.
4975
4905
                                         current_map,
4976
4906
                                         current_map, 0)))
4977
4907
            {
4978
 
              tab->cache.select= (optimizer::SqlSelect*)
4979
 
                session->getMemRoot()->duplicate((unsigned char*) sel, sizeof(optimizer::SqlSelect));
 
4908
              tab->cache.select= (optimizer::SqlSelect*)session->mem.memdup(sel, sizeof(optimizer::SqlSelect));
4980
4909
              tab->cache.select->cond= tmp;
4981
4910
              tab->cache.select->read_tables= join->const_table_map;
4982
4911
            }
5068
4997
      }
5069
4998
    }
5070
4999
  }
5071
 
  return(0);
 
5000
  return 0;
5072
5001
}
5073
5002
 
5074
5003
/*
5092
5021
    false - OK
5093
5022
    true  - Out of memory
5094
5023
*/
5095
 
static bool make_join_readinfo(Join *join)
 
5024
static void make_join_readinfo(Join& join)
5096
5025
{
5097
5026
  bool sorted= true;
5098
5027
 
5099
 
  for (uint32_t i= join->const_tables ; i < join->tables ; i++)
 
5028
  for (uint32_t i= join.const_tables; i < join.tables; i++)
5100
5029
  {
5101
 
    JoinTable *tab=join->join_tab+i;
 
5030
    JoinTable *tab=join.join_tab+i;
5102
5031
    Table *table=tab->table;
5103
5032
    tab->read_record.table= table;
5104
5033
    tab->read_record.cursor= table->cursor;
5112
5041
 
5113
5042
    if (tab->insideout_match_tab)
5114
5043
    {
5115
 
      if (! (tab->insideout_buf= (unsigned char*) join->session->getMemRoot()->allocate(tab->table->key_info
5116
 
                                                                       [tab->index].
5117
 
                                                                       key_length)))
5118
 
        return true;
5119
 
    }
5120
 
 
5121
 
    optimizer::AccessMethodFactory &factory= optimizer::AccessMethodFactory::singleton();
5122
 
    boost::shared_ptr<optimizer::AccessMethod> access_method(factory.createAccessMethod(tab->type));
5123
 
 
5124
 
    if (! access_method)
5125
 
    {
5126
 
      /**
5127
 
       * @todo
5128
 
       * Is abort() the correct thing to call here? I call this here because it was what was called in
5129
 
       * the default case for the switch statement that used to be here.
5130
 
       */
5131
 
      abort();
5132
 
    }
5133
 
 
5134
 
    access_method->getStats(table, tab);
 
5044
      tab->insideout_buf= join.session->mem.alloc(tab->table->key_info[tab->index].key_length);
 
5045
    }
 
5046
 
 
5047
    optimizer::AccessMethodFactory::create(tab->type)->getStats(*table, *tab);
5135
5048
  }
5136
5049
 
5137
 
  join->join_tab[join->tables-1].next_select= NULL; /* Set by do_select */
5138
 
 
5139
 
  return false;
 
5050
  join.join_tab[join.tables-1].next_select= NULL; /* Set by do_select */
5140
5051
}
5141
5052
 
5142
5053
/** Update the dependency map for the tables. */
5261
5172
  return(first_order);
5262
5173
}
5263
5174
 
5264
 
static int return_zero_rows(Join *join,
5265
 
                            select_result *result,
5266
 
                            TableList *tables,
5267
 
                                        List<Item> &fields,
5268
 
                            bool send_row,
5269
 
                            uint64_t select_options,
5270
 
                            const char *info,
5271
 
                            Item *having)
 
5175
static void return_zero_rows(Join *join, select_result *result, TableList *tables, List<Item> &fields, bool send_row, uint64_t select_options, const char *info, Item *having)
5272
5176
{
5273
5177
  if (select_options & SELECT_DESCRIBE)
5274
5178
  {
5275
 
    optimizer::ExplainPlan planner(join,
5276
 
                                   false,
5277
 
                                   false,
5278
 
                                   false,
5279
 
                                   info);
 
5179
    optimizer::ExplainPlan planner(join, false, false, false, info);
5280
5180
    planner.printPlan();
5281
 
    return 0;
 
5181
    return;
5282
5182
  }
5283
5183
 
5284
5184
  join->join_free();
5290
5190
    if (having && having->val_int() == 0)
5291
5191
      send_row=0;
5292
5192
  }
5293
 
  if (! (result->send_fields(fields)))
 
5193
  result->send_fields(fields);
 
5194
  if (send_row)
5294
5195
  {
5295
 
    if (send_row)
5296
 
    {
5297
 
      List_iterator_fast<Item> it(fields);
5298
 
      Item *item;
5299
 
      while ((item= it++))
5300
 
        item->no_rows_in_result();
5301
 
      result->send_data(fields);
5302
 
    }
5303
 
    result->send_eof();                         // Should be safe
 
5196
    List<Item>::iterator it(fields.begin());
 
5197
    while (Item* item= it++)
 
5198
      item->no_rows_in_result();
 
5199
    result->send_data(fields);
5304
5200
  }
 
5201
  result->send_eof();                           // Should be safe
5305
5202
  /* Update results for FOUND_ROWS */
5306
5203
  join->session->limit_found_rows= join->session->examined_row_count= 0;
5307
 
  return(0);
5308
5204
}
5309
5205
 
5310
5206
/**
5429
5325
*/
5430
5326
static COND *simplify_joins(Join *join, List<TableList> *join_list, COND *conds, bool top)
5431
5327
{
5432
 
  TableList *table;
5433
5328
  NestedJoin *nested_join;
5434
5329
  TableList *prev_table= 0;
5435
 
  List_iterator<TableList> li(*join_list);
 
5330
  List<TableList>::iterator li(join_list->begin());
5436
5331
 
5437
5332
  /*
5438
5333
    Try to simplify join operations from join_list.
5439
5334
    The most outer join operation is checked for conversion first.
5440
5335
  */
5441
 
  while ((table= li++))
 
5336
  while (TableList* table= li++)
5442
5337
  {
5443
5338
    table_map used_tables;
5444
5339
    table_map not_null_tables= (table_map) 0;
5568
5463
    Flatten nested joins that can be flattened.
5569
5464
    no ON expression and not a semi-join => can be flattened.
5570
5465
  */
5571
 
  li.rewind();
5572
 
  while ((table= li++))
 
5466
  li= join_list->begin();
 
5467
  while (TableList* table= li++)
5573
5468
  {
5574
5469
    nested_join= table->getNestedJoin();
5575
5470
    if (nested_join && !table->on_expr)
5576
5471
    {
5577
 
      TableList *tbl;
5578
 
      List_iterator<TableList> it(nested_join->join_list);
5579
 
      while ((tbl= it++))
 
5472
      List<TableList>::iterator it(nested_join->join_list.begin());
 
5473
      while (TableList* tbl= it++)
5580
5474
      {
5581
5475
        tbl->setEmbedding(table->getEmbedding());
5582
5476
        tbl->setJoinList(table->getJoinList());
5589
5483
 
5590
5484
static int remove_duplicates(Join *join, Table *entry,List<Item> &fields, Item *having)
5591
5485
{
5592
 
  int error;
5593
 
  uint32_t reclength,offset;
5594
 
  uint32_t field_count;
5595
 
  Session *session= join->session;
5596
 
 
5597
5486
  entry->reginfo.lock_type=TL_WRITE;
5598
5487
 
5599
5488
  /* Calculate how many saved fields there is in list */
5600
 
  field_count=0;
5601
 
  List_iterator<Item> it(fields);
5602
 
  Item *item;
5603
 
  while ((item=it++))
 
5489
  uint32_t field_count= 0;
 
5490
  List<Item>::iterator it(fields.begin());
 
5491
  while (Item* item=it++)
5604
5492
  {
5605
5493
    if (item->get_tmp_table_field() && ! item->const_item())
5606
5494
      field_count++;
5609
5497
  if (!field_count && !(join->select_options & OPTION_FOUND_ROWS) && !having)
5610
5498
  {                    // only const items with no OPTION_FOUND_ROWS
5611
5499
    join->unit->select_limit_cnt= 1;            // Only send first row
5612
 
    return(0);
 
5500
    return 0;
5613
5501
  }
5614
5502
  Field **first_field=entry->getFields() + entry->getShare()->sizeFields() - field_count;
5615
 
  offset= (field_count ?
5616
 
           entry->getField(entry->getShare()->sizeFields() - field_count)->offset(entry->getInsertRecord()) : 0);
5617
 
  reclength= entry->getShare()->getRecordLength() - offset;
 
5503
  uint32_t offset= field_count ? entry->getField(entry->getShare()->sizeFields() - field_count)->offset(entry->getInsertRecord()) : 0;
 
5504
  uint32_t reclength= entry->getShare()->getRecordLength() - offset;
5618
5505
 
5619
5506
  entry->free_io_cache();                               // Safety
5620
5507
  entry->cursor->info(HA_STATUS_VARIABLE);
 
5508
  int error;
5621
5509
  if (entry->getShare()->db_type() == heap_engine ||
5622
5510
      (!entry->getShare()->blob_fields &&
5623
 
       ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->cursor->stats.records <
5624
 
        session->variables.sortbuff_size)))
 
5511
       ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->cursor->stats.records < join->session->variables.sortbuff_size)))
5625
5512
  {
5626
 
    error= remove_dup_with_hash_index(join->session, entry,
5627
 
                                      field_count, first_field,
5628
 
                                      reclength, having);
 
5513
    error= remove_dup_with_hash_index(join->session, entry, field_count, first_field, reclength, having);
5629
5514
  }
5630
5515
  else
5631
5516
  {
5632
5517
    error= remove_dup_with_compare(join->session, entry, first_field, offset, having);
5633
5518
  }
5634
 
 
5635
5519
  free_blobs(first_field);
5636
 
 
5637
 
  return(error);
 
5520
  return error;
5638
5521
}
5639
5522
 
5640
5523
/**
5652
5535
                               bool *hidden_group_fields)
5653
5536
{
5654
5537
  int res;
5655
 
  nesting_map save_allow_sum_func=session->lex->allow_sum_func ;
 
5538
  nesting_map save_allow_sum_func=session->lex().allow_sum_func;
5656
5539
 
5657
 
  session->lex->allow_sum_func&= ~(1 << session->lex->current_select->nest_level);
 
5540
  session->lex().allow_sum_func&= ~(1 << session->lex().current_select->nest_level);
5658
5541
  res= session->setup_conds(tables, conds);
5659
5542
 
5660
 
  session->lex->allow_sum_func|= 1 << session->lex->current_select->nest_level;
5661
 
  res= res || setup_order(session, ref_pointer_array, tables, fields, all_fields,
5662
 
                          order);
5663
 
  session->lex->allow_sum_func&= ~(1 << session->lex->current_select->nest_level);
5664
 
  res= res || setup_group(session, ref_pointer_array, tables, fields, all_fields,
5665
 
                          group, hidden_group_fields);
5666
 
  session->lex->allow_sum_func= save_allow_sum_func;
5667
 
  return(res);
 
5543
  session->lex().allow_sum_func|= 1 << session->lex().current_select->nest_level;
 
5544
  res= res || setup_order(session, ref_pointer_array, tables, fields, all_fields, order);
 
5545
  session->lex().allow_sum_func&= ~(1 << session->lex().current_select->nest_level);
 
5546
  res= res || setup_group(session, ref_pointer_array, tables, fields, all_fields, group, hidden_group_fields);
 
5547
  session->lex().allow_sum_func= save_allow_sum_func;
 
5548
  return res;
5668
5549
}
5669
5550
 
5670
5551
/**
5702
5583
  optimizer::Position *partial_pos;
5703
5584
 
5704
5585
  table_count= join->tables;
5705
 
  stat= (JoinTable*) join->session->calloc(sizeof(JoinTable)*table_count);
5706
 
  stat_ref= (JoinTable**) join->session->getMemRoot()->allocate(sizeof(JoinTable*)*MAX_TABLES);
5707
 
  table_vector= (Table**) join->session->getMemRoot()->allocate(sizeof(Table*)*(table_count*2));
5708
 
  if (! stat || ! stat_ref || ! table_vector)
5709
 
    return 1;
 
5586
  stat= (JoinTable*) join->session->mem.calloc(sizeof(JoinTable)*table_count);
 
5587
  stat_ref= new (join->session->mem) JoinTable*[MAX_TABLES];
 
5588
  table_vector= new (join->session->mem) Table*[2 * table_count];
5710
5589
 
5711
5590
  join->best_ref=stat_vector;
5712
5591
 
5736
5615
    table->quick_keys.reset();
5737
5616
    table->reginfo.join_tab=s;
5738
5617
    table->reginfo.not_exists_optimize=0;
5739
 
    memset(table->const_key_parts, 0,
5740
 
           sizeof(key_part_map)*table->getShare()->sizeKeys());
 
5618
    memset(table->const_key_parts, 0, sizeof(key_part_map)*table->getShare()->sizeKeys());
5741
5619
    all_table_map|= table->map;
5742
5620
    s->join=join;
5743
5621
    s->info=0;                                  // For describe
5753
5631
      if (!table->cursor->stats.records && !embedding)
5754
5632
      {                                         // Empty table
5755
5633
        s->dependent= 0;                        // Ignore LEFT JOIN depend.
5756
 
        set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5634
        set_position(join, const_count++, s, NULL);
5757
5635
        continue;
5758
5636
      }
5759
5637
      outer_join|= table->map;
5781
5659
              (table->cursor->getEngine()->check_flag(HTON_BIT_STATS_RECORDS_IS_EXACT)) &&
5782
5660
        !join->no_const_tables)
5783
5661
    {
5784
 
      set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5662
      set_position(join, const_count++, s, NULL);
5785
5663
    }
5786
5664
  }
5787
5665
  stat_vector[i]=0;
5836
5714
  }
5837
5715
 
5838
5716
  if (conds || outer_join)
5839
 
    if (update_ref_and_keys(join->session, keyuse_array, stat, join->tables,
5840
 
                            conds, join->cond_equal,
5841
 
                            ~outer_join, join->select_lex, sargables))
5842
 
      return 1;
 
5717
    update_ref_and_keys(join->session, keyuse_array, stat, join->tables, conds, join->cond_equal, ~outer_join, join->select_lex, sargables);
5843
5718
 
5844
5719
  /* Read tables with 0 or 1 rows (system tables) */
5845
5720
  join->const_table_map= 0;
5905
5780
            table->mark_as_null_row();
5906
5781
            found_const_table_map|= table->map;
5907
5782
            join->const_table_map|= table->map;
5908
 
            set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5783
            set_position(join, const_count++, s, NULL);
5909
5784
            goto more_const_tables_found;
5910
5785
           }
5911
5786
          keyuse++;
5924
5799
          int tmp= 0;
5925
5800
          s->type= AM_SYSTEM;
5926
5801
          join->const_table_map|=table->map;
5927
 
          set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5802
          set_position(join, const_count++, s, NULL);
5928
5803
          partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5929
5804
          if ((tmp= s->joinReadConstTable(partial_pos)))
5930
5805
          {
6004
5879
  */
6005
5880
  if (const_count && ! sargables.empty())
6006
5881
  {
6007
 
    vector<optimizer::SargableParam>::iterator iter= sargables.begin();
6008
 
    while (iter != sargables.end())
 
5882
    BOOST_FOREACH(vector<optimizer::SargableParam>::reference iter, sargables)
6009
5883
    {
6010
 
      Field *field= (*iter).getField();
6011
 
      JoinTable *join_tab= field->getTable()->reginfo.join_tab;
6012
 
      key_map possible_keys= field->key_start;
6013
 
      possible_keys&= field->getTable()->keys_in_use_for_query;
 
5884
      Field& field= *iter.getField();
 
5885
      JoinTable *join_tab= field.getTable()->reginfo.join_tab;
 
5886
      key_map possible_keys= field.key_start & field.getTable()->keys_in_use_for_query;
6014
5887
      bool is_const= true;
6015
 
      for (uint32_t j= 0; j < (*iter).getNumValues(); j++)
6016
 
        is_const&= (*iter).isConstItem(j);
 
5888
      for (uint32_t j= 0; j < iter.getNumValues(); j++)
 
5889
        is_const&= iter.isConstItem(j);
6017
5890
      if (is_const)
6018
5891
        join_tab[0].const_keys|= possible_keys;
6019
 
      ++iter;
6020
5892
    }
6021
5893
  }
6022
5894
 
6072
5944
          caller to abort with a zero row result.
6073
5945
        */
6074
5946
        join->const_table_map|= s->table->map;
6075
 
        set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
 
5947
        set_position(join, const_count++, s, NULL);
6076
5948
        s->type= AM_CONST;
6077
5949
        if (*s->on_expr_ref)
6078
5950
        {
6116
5988
    join->best_read= 1.0;
6117
5989
  }
6118
5990
  /* Generate an execution plan from the found optimal join order. */
6119
 
  return (join->session->getKilled() || get_best_combination(join));
 
5991
  return join->session->getKilled() || get_best_combination(join);
6120
5992
}
6121
5993
 
6122
5994
/**
6140
6012
*/
6141
6013
static uint32_t build_bitmap_for_nested_joins(List<TableList> *join_list, uint32_t first_unused)
6142
6014
{
6143
 
  List_iterator<TableList> li(*join_list);
6144
 
  TableList *table;
6145
 
  while ((table= li++))
 
6015
  List<TableList>::iterator li(join_list->begin());
 
6016
  while (TableList* table= li++)
6146
6017
  {
6147
 
    NestedJoin *nested_join;
6148
 
    if ((nested_join= table->getNestedJoin()))
 
6018
    if (NestedJoin* nested_join= table->getNestedJoin())
6149
6019
    {
6150
6020
      /*
6151
6021
        It is guaranteed by simplify_joins() function that a nested join
6158
6028
            with anything)
6159
6029
        2. we could run out of bits in the nested join bitset otherwise.
6160
6030
      */
6161
 
      if (nested_join->join_list.elements != 1)
 
6031
      if (nested_join->join_list.size() != 1)
6162
6032
      {
6163
6033
        /* Don't assign bits to sj-nests */
6164
6034
        if (table->on_expr)
6178
6048
*/
6179
6049
static Table *get_sort_by_table(Order *a, Order *b,TableList *tables)
6180
6050
{
6181
 
  table_map map= (table_map) 0;
 
6051
  table_map map= 0;
6182
6052
 
6183
6053
  if (!a)
6184
6054
    a= b;                                       // Only one need to be given
6188
6058
  for (; a && b; a=a->next,b=b->next)
6189
6059
  {
6190
6060
    if (!(*a->item)->eq(*b->item,1))
6191
 
      return (Table *) NULL;
 
6061
      return NULL;
6192
6062
    map|= a->item[0]->used_tables();
6193
6063
  }
6194
6064
  if (!map || (map & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT)))
6195
 
    return (Table *) NULL;
 
6065
    return NULL;
6196
6066
 
6197
6067
  for (; !(map & tables->table->map); tables= tables->next_leaf) {};
6198
6068
  if (map != tables->table->map)
6199
 
    return (Table *) NULL;                              // More than one table
 
6069
    return NULL;                                // More than one table
6200
6070
  return tables->table;
6201
6071
}
6202
6072
 
6211
6081
*/
6212
6082
static void reset_nj_counters(List<TableList> *join_list)
6213
6083
{
6214
 
  List_iterator<TableList> li(*join_list);
6215
 
  TableList *table;
6216
 
  while ((table= li++))
 
6084
  List<TableList>::iterator li(join_list->begin());
 
6085
  while (TableList* table= li++)
6217
6086
  {
6218
6087
    NestedJoin *nested_join;
6219
6088
    if ((nested_join= table->getNestedJoin()))
6222
6091
      reset_nj_counters(&nested_join->join_list);
6223
6092
    }
6224
6093
  }
6225
 
  return;
6226
6094
}
6227
6095
 
6228
6096
/**
6322
6190
static bool add_ref_to_table_cond(Session *session, JoinTable *join_tab)
6323
6191
{
6324
6192
  if (!join_tab->ref.key_parts)
6325
 
    return(false);
 
6193
    return false;
6326
6194
 
6327
6195
  Item_cond_and *cond=new Item_cond_and();
6328
6196
  Table *table=join_tab->table;
6329
 
  int error;
6330
 
  if (!cond)
6331
 
    return(true);
6332
6197
 
6333
6198
  for (uint32_t i=0 ; i < join_tab->ref.key_parts ; i++)
6334
6199
  {
6337
6202
    cond->add(new Item_func_equal(new Item_field(field), value));
6338
6203
  }
6339
6204
  if (session->is_fatal_error)
6340
 
    return(true);
 
6205
    return true;
6341
6206
 
6342
6207
  if (!cond->fixed)
6343
6208
    cond->fix_fields(session, (Item**)&cond);
 
6209
  int error = 0;
6344
6210
  if (join_tab->select)
6345
6211
  {
6346
 
    error=(int) cond->add(join_tab->select->cond);
 
6212
    cond->add(join_tab->select->cond);
6347
6213
    join_tab->select_cond=join_tab->select->cond=cond;
6348
6214
  }
6349
 
  else if ((join_tab->select= optimizer::make_select(join_tab->table, 0, 0, cond, 0,
6350
 
                                                     &error)))
 
6215
  else if ((join_tab->select= optimizer::make_select(join_tab->table, 0, 0, cond, 0, &error)))
6351
6216
    join_tab->select_cond=cond;
6352
6217
 
6353
 
  return(error ? true : false);
 
6218
  return error;
6354
6219
}
6355
6220
 
6356
6221
static void free_blobs(Field **ptr)