← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/join.cc

  • Committer: Stewart Smith
  • Date: 2010-11-07 06:43:17 UTC
  • mfrom: (1909 merge)
  • mto: This revision was merged to the branch mainline in revision 1915.
  • Revision ID: stewart@flamingspork.com-20101107064317-i0usp0cqk97ftxev
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/join.cc
1
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008-2009 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008-2009 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
58
58
#include "drizzled/internal/my_bit.h"
59
59
#include "drizzled/internal/my_sys.h"
60
60
#include "drizzled/internal/iocache.h"
61
 
#include "drizzled/plugin/storage_engine.h"
62
 
 
63
 
#include <drizzled/debug.h>
64
61
 
65
62
#include <algorithm>
66
63
 
68
65
 
69
66
namespace drizzled
70
67
{
 
68
 
71
69
extern plugin::StorageEngine *heap_engine;
 
70
extern std::bitset<12> test_flags;
72
71
 
73
72
/** Declarations of static functions used in this source file. */
74
73
static bool make_group_fields(Join *main_join, Join *curr_join);
134
133
static bool add_ref_to_table_cond(Session *session, JoinTable *join_tab);
135
134
static void free_blobs(Field **ptr); /* Rename this method...conflicts with another in global namespace... */
136
135
 
137
 
Join::Join(Session *session_arg, 
138
 
           List<Item> &fields_arg, 
139
 
           uint64_t select_options_arg,
140
 
           select_result *result_arg) :
141
 
  join_tab(NULL),
142
 
  best_ref(NULL),
143
 
  map2table(NULL),
144
 
  join_tab_save(NULL),
145
 
  table(NULL),
146
 
  all_tables(NULL),
147
 
  sort_by_table(NULL),
148
 
  tables(0),
149
 
  outer_tables(0),
150
 
  const_tables(0),
151
 
  send_group_parts(0),
152
 
  sort_and_group(false),
153
 
  first_record(false),
154
 
  full_join(false),
155
 
  group(false),
156
 
  no_field_update(false),
157
 
  do_send_rows(true),
158
 
  resume_nested_loop(false),
159
 
  no_const_tables(false),
160
 
  select_distinct(false),
161
 
  group_optimized_away(false),
162
 
  simple_order(false),
163
 
  simple_group(false),
164
 
  no_order(false),
165
 
  skip_sort_order(false),
166
 
  union_part(false),
167
 
  optimized(false),
168
 
  need_tmp(false),
169
 
  hidden_group_fields(false),
170
 
  const_table_map(0),
171
 
  found_const_table_map(0),
172
 
  outer_join(0),
173
 
  send_records(0),
174
 
  found_records(0),
175
 
  examined_rows(0),
176
 
  row_limit(0),
177
 
  select_limit(0),
178
 
  fetch_limit(HA_POS_ERROR),
179
 
  session(session_arg),
180
 
  fields_list(fields_arg), 
181
 
  join_list(NULL),
182
 
  unit(NULL),
183
 
  select_lex(NULL),
184
 
  select(NULL),
185
 
  exec_tmp_table1(NULL),
186
 
  exec_tmp_table2(NULL),
187
 
  sum_funcs(NULL),
188
 
  sum_funcs2(NULL),
189
 
  having(NULL),
190
 
  tmp_having(NULL),
191
 
  having_history(NULL),
192
 
  select_options(select_options_arg),
193
 
  result(result_arg),
194
 
  lock(session_arg->lock),
195
 
  tmp_join(NULL),
196
 
  all_fields(fields_arg),
197
 
  error(0),
198
 
  cond_equal(NULL),
199
 
  return_tab(NULL),
200
 
  ref_pointer_array(NULL),
201
 
  items0(NULL),
202
 
  items1(NULL),
203
 
  items2(NULL),
204
 
  items3(NULL),
205
 
  ref_pointer_array_size(0),
206
 
  zero_result_cause(NULL),
207
 
  sortorder(NULL),
208
 
  table_reexec(NULL),
209
 
  join_tab_reexec(NULL)
210
 
{
211
 
  select_distinct= test(select_options & SELECT_DISTINCT);
212
 
  if (&fields_list != &fields_arg) /* only copy if not same*/
213
 
    fields_list= fields_arg;
214
 
  memset(&keyuse, 0, sizeof(keyuse));
215
 
  tmp_table_param.init();
216
 
  tmp_table_param.end_write_records= HA_POS_ERROR;
217
 
  rollup.setState(Rollup::STATE_NONE);
218
 
}
219
 
 
220
 
  /** 
221
 
   * This method is currently only used when a subselect EXPLAIN is performed.
222
 
   * I pulled out the init() method and have simply reset the values to what
223
 
   * was previously in the init() method.  See the note about the hack in 
224
 
   * sql_union.cc...
225
 
   */
226
 
void Join::reset(Session *session_arg, 
227
 
                 List<Item> &fields_arg, 
228
 
                 uint64_t select_options_arg,
229
 
                 select_result *result_arg)
230
 
{
231
 
  join_tab= NULL;
232
 
  best_ref= NULL;
233
 
  map2table= NULL;
234
 
  join_tab_save= NULL;
235
 
  table= NULL;
236
 
  all_tables= NULL;
237
 
  sort_by_table= NULL;
238
 
  tables= 0;
239
 
  outer_tables= 0;
240
 
  const_tables= 0;
241
 
  send_group_parts= 0;
242
 
  sort_and_group= false;
243
 
  first_record= false;
244
 
  full_join= false;
245
 
  group= false;
246
 
  no_field_update= false;
247
 
  do_send_rows= true;
248
 
  resume_nested_loop= false;
249
 
  no_const_tables= false;
250
 
  select_distinct= false;
251
 
  group_optimized_away= false;
252
 
  simple_order= false;
253
 
  simple_group= false;
254
 
  no_order= false;
255
 
  skip_sort_order= false;
256
 
  union_part= false;
257
 
  optimized= false;
258
 
  need_tmp= false;
259
 
  hidden_group_fields= false;
260
 
  const_table_map= 0;
261
 
  found_const_table_map= 0;
262
 
  outer_join= 0;
263
 
  send_records= 0;
264
 
  found_records= 0;
265
 
  examined_rows= 0;
266
 
  row_limit= 0;
267
 
  select_limit= 0;
268
 
  fetch_limit= HA_POS_ERROR;
269
 
  session= session_arg;
270
 
  fields_list= fields_arg; 
271
 
  join_list= NULL;
272
 
  unit= NULL;
273
 
  select_lex= NULL;
274
 
  select= NULL;
275
 
  exec_tmp_table1= NULL;
276
 
  exec_tmp_table2= NULL;
277
 
  sum_funcs= NULL;
278
 
  sum_funcs2= NULL;
279
 
  having= NULL;
280
 
  tmp_having= NULL;
281
 
  having_history= NULL;
282
 
  select_options= select_options_arg;
283
 
  result= result_arg;
284
 
  lock= session_arg->lock;
285
 
  tmp_join= NULL;
286
 
  all_fields= fields_arg;
287
 
  error= 0;
288
 
  cond_equal= NULL;
289
 
  return_tab= NULL;
290
 
  ref_pointer_array= NULL;
291
 
  items0= NULL;
292
 
  items1= NULL;
293
 
  items2= NULL;
294
 
  items3= NULL;
295
 
  ref_pointer_array_size= 0;
296
 
  zero_result_cause= NULL;
297
 
  sortorder= NULL;
298
 
  table_reexec= NULL;
299
 
  join_tab_reexec= NULL;
300
 
  select_distinct= test(select_options & SELECT_DISTINCT);
301
 
  if (&fields_list != &fields_arg) /* only copy if not same*/
302
 
    fields_list= fields_arg;
303
 
  memset(&keyuse, 0, sizeof(keyuse));
304
 
  tmp_table_param.init();
305
 
  tmp_table_param.end_write_records= HA_POS_ERROR;
306
 
  rollup.setState(Rollup::STATE_NONE);
307
 
}
308
 
 
309
 
bool Join::is_top_level_join() const
310
 
{
311
 
  return (unit == &session->lex->unit && (unit->fake_select_lex == 0 ||
312
 
                                          select_lex == unit->fake_select_lex));
313
 
}
314
 
 
315
136
/**
316
137
  Prepare of whole select (including sub queries in future).
317
138
 
371
192
  for (table_ptr= select_lex->leaf_tables;
372
193
       table_ptr;
373
194
       table_ptr= table_ptr->next_leaf)
374
 
  {
375
195
    tables++;
376
 
  }
377
 
 
378
196
 
379
197
  if (setup_wild(session, fields_list, &all_fields, wild_num) ||
380
198
      select_lex->setup_ref_array(session, og_num) ||
391
209
  if (having)
392
210
  {
393
211
    nesting_map save_allow_sum_func= session->lex->allow_sum_func;
394
 
    session->setWhere("having clause");
 
212
    session->where="having clause";
395
213
    session->lex->allow_sum_func|= 1 << select_lex_arg->nest_level;
396
214
    select_lex->having_fix_field= 1;
397
215
    bool having_fix_rc= (!having->fixed &&
773
591
    return 1;
774
592
  }
775
593
  if (const_tables && !(select_options & SELECT_NO_UNLOCK))
776
 
    session->unlockSomeTables(table, const_tables);
 
594
    mysql_unlock_some_tables(session, table, const_tables);
777
595
  if (!conds && outer_join)
778
596
  {
779
597
    /* Handle the case where we have an OUTER JOIN without a WHERE */
907
725
  }
908
726
  if (group_list || tmp_table_param.sum_func_count)
909
727
  {
910
 
    if (! hidden_group_fields && rollup.getState() == Rollup::STATE_NONE)
 
728
    if (! hidden_group_fields && rollup.state == ROLLUP::STATE_NONE)
911
729
      select_distinct=0;
912
730
  }
913
731
  else if (select_distinct && tables - const_tables == 1)
971
789
  {
972
790
    Order *old_group_list;
973
791
    group_list= remove_constants(this, (old_group_list= group_list), conds,
974
 
                                 rollup.getState() == Rollup::STATE_NONE,
 
792
                                 rollup.state == ROLLUP::STATE_NONE,
975
793
                                 &simple_group);
976
794
    if (session->is_error())
977
795
    {
1163
981
 
1164
982
    tmp_table_param.hidden_field_count= (all_fields.elements -
1165
983
           fields_list.elements);
1166
 
    Order *tmp_group= (((not simple_group) or not (getDebug().test(debug::NO_KEY_GROUP))) ? group_list : (Order*) 0);
1167
 
 
 
984
    Order *tmp_group= ((!simple_group &&
 
985
                           ! (test_flags.test(TEST_NO_KEY_GROUP))) ? group_list :
 
986
                                                                     (Order*) 0);
1168
987
    /*
1169
988
      Pushing LIMIT to the temporary table creation is not applicable
1170
989
      when there is ORDER BY or GROUP BY or there is no GROUP BY, but
1350
1169
*/
1351
1170
bool Join::init_save_join_tab()
1352
1171
{
1353
 
  if (!(tmp_join= (Join*)session->getMemRoot()->allocate(sizeof(Join))))
 
1172
  if (!(tmp_join= (Join*)session->alloc(sizeof(Join))))
1354
1173
    return 1;
1355
1174
 
1356
1175
  error= 0;              // Ensure that tmp_join.error= 0
1363
1182
{
1364
1183
  if (! join_tab_save && select_lex->master_unit()->uncacheable.any())
1365
1184
  {
1366
 
    if (!(join_tab_save= (JoinTable*)session->getMemRoot()->duplicate((unsigned char*) join_tab,
 
1185
    if (!(join_tab_save= (JoinTable*)session->memdup((unsigned char*) join_tab,
1367
1186
            sizeof(JoinTable) * tables)))
1368
1187
      return 1;
1369
1188
  }
1765
1584
      if (sort_table_cond)
1766
1585
      {
1767
1586
        if (!curr_table->select)
1768
 
          if (!(curr_table->select= new optimizer::SqlSelect()))
 
1587
          if (!(curr_table->select= new optimizer::SqlSelect))
1769
1588
            return;
1770
1589
        if (!curr_table->select->cond)
1771
1590
          curr_table->select->cond= sort_table_cond;
1969
1788
    is called after all rows are sent, but before EOF packet is sent.
1970
1789
 
1971
1790
    For a simple SELECT with no subqueries this function performs a full
1972
 
    cleanup of the Join and calls unlockReadTables to free used base
 
1791
    cleanup of the Join and calls mysql_unlock_read_tables to free used base
1973
1792
    tables.
1974
1793
 
1975
1794
    If a Join is executed for a subquery or if it has a subquery, we can't
2012
1831
    for (sl= tmp_unit->first_select(); sl; sl= sl->next_select())
2013
1832
    {
2014
1833
      Item_subselect *subselect= sl->master_unit()->item;
2015
 
      bool full_local= full && (!subselect || 
2016
 
                                (subselect->is_evaluated() &&
2017
 
                                !subselect->is_uncacheable()));
 
1834
      bool full_local= full && (!subselect || subselect->is_evaluated());
2018
1835
      /*
2019
1836
        If this join is evaluated, we can fully clean it up and clean up all
2020
1837
        its underlying joins even if they are correlated -- they will not be
2043
1860
      TODO: unlock tables even if the join isn't top level select in the
2044
1861
      tree.
2045
1862
    */
2046
 
    session->unlockReadTables(lock);           // Don't free join->lock
 
1863
    mysql_unlock_read_tables(session, lock);           // Don't free join->lock
2047
1864
    lock= 0;
2048
1865
  }
2049
1866
 
2066
1883
{
2067
1884
  if (table)
2068
1885
  {
 
1886
    JoinTable *tab,*end;
2069
1887
    /*
2070
1888
      Only a sorted table may be cached.  This sorted table is always the
2071
1889
      first non const table in join->table
2075
1893
      table[const_tables]->free_io_cache();
2076
1894
      table[const_tables]->filesort_free_buffers(full);
2077
1895
    }
2078
 
  }
2079
 
 
2080
 
  if (join_tab)
2081
 
  {
2082
 
    JoinTable *tab,*end;
2083
1896
 
2084
1897
    if (full)
2085
1898
    {
2096
1909
      }
2097
1910
    }
2098
1911
  }
2099
 
 
2100
1912
  /*
2101
1913
    We are not using tables anymore
2102
1914
    Unlock all tables. We may be in an INSERT .... SELECT statement.
2140
1952
    are not re-calculated.
2141
1953
  */
2142
1954
  for (uint32_t i= join->const_tables; i < join->tables; i++)
2143
 
  {
2144
1955
    join->table[i]->mark_as_null_row();   // All fields are NULL
2145
 
  }
2146
1956
}
2147
1957
 
2148
1958
/**
2163
1973
    If we are using rollup, we need a copy of the summary functions for
2164
1974
    each level
2165
1975
  */
2166
 
  if (rollup.getState() != Rollup::STATE_NONE)
 
1976
  if (rollup.state != ROLLUP::STATE_NONE)
2167
1977
    func_count*= (send_group_parts+1);
2168
1978
 
2169
1979
  group_parts= send_group_parts;
2226
2036
         ((Item_sum *)item)->depended_from() == select_lex))
2227
2037
      *func++= (Item_sum*) item;
2228
2038
  }
2229
 
  if (before_group_by && rollup.getState() == Rollup::STATE_INITED)
 
2039
  if (before_group_by && rollup.state == ROLLUP::STATE_INITED)
2230
2040
  {
2231
 
    rollup.setState(Rollup::STATE_READY);
 
2041
    rollup.state= ROLLUP::STATE_READY;
2232
2042
    if (rollup_make_fields(field_list, send_fields, &func))
2233
 
      return true;     // Should never happen
 
2043
      return(true);     // Should never happen
2234
2044
  }
2235
 
  else if (rollup.getState() == Rollup::STATE_NONE)
 
2045
  else if (rollup.state == ROLLUP::STATE_NONE)
2236
2046
  {
2237
2047
    for (uint32_t i=0 ; i <= send_group_parts ;i++)
2238
2048
      sum_funcs_end[i]= func;
2239
2049
  }
2240
 
  else if (rollup.getState() == Rollup::STATE_READY)
 
2050
  else if (rollup.state == ROLLUP::STATE_READY)
2241
2051
    return(false);                         // Don't put end marker
2242
2052
  *func=0;          // End marker
2243
2053
  return(false);
2246
2056
/** Allocate memory needed for other rollup functions. */
2247
2057
bool Join::rollup_init()
2248
2058
{
 
2059
  uint32_t i,j;
2249
2060
  Item **ref_array;
2250
2061
 
2251
2062
  tmp_table_param.quick_group= 0; // Can't create groups in tmp table
2252
 
  rollup.setState(Rollup::STATE_INITED);
 
2063
  rollup.state= ROLLUP::STATE_INITED;
2253
2064
 
2254
2065
  /*
2255
2066
    Create pointers to the different sum function groups
2257
2068
  */
2258
2069
  tmp_table_param.group_parts= send_group_parts;
2259
2070
 
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
 
  {
 
2071
  if (!(rollup.null_items= (Item_null_result**) session->alloc((sizeof(Item*) +
 
2072
                                                sizeof(Item**) +
 
2073
                                                sizeof(List<Item>) +
 
2074
                        ref_pointer_array_size)
 
2075
                        * send_group_parts )))
2267
2076
    return 1;
2268
 
  }
2269
2077
 
2270
 
  rollup.setFields((List<Item>*) (rollup.getNullItems() + send_group_parts));
2271
 
  rollup.setRefPointerArrays((Item***) (rollup.getFields() + send_group_parts));
2272
 
  ref_array= (Item**) (rollup.getRefPointerArrays()+send_group_parts);
 
2078
  rollup.fields= (List<Item>*) (rollup.null_items + send_group_parts);
 
2079
  rollup.ref_pointer_arrays= (Item***) (rollup.fields + send_group_parts);
 
2080
  ref_array= (Item**) (rollup.ref_pointer_arrays+send_group_parts);
2273
2081
 
2274
2082
  /*
2275
2083
    Prepare space for field list for the different levels
2276
2084
    These will be filled up in rollup_make_fields()
2277
2085
  */
2278
 
  for (uint32_t i= 0 ; i < send_group_parts ; i++)
 
2086
  for (i= 0 ; i < send_group_parts ; i++)
2279
2087
  {
2280
 
    rollup.getNullItems()[i]= new (session->mem_root) Item_null_result();
2281
 
    List<Item> *rollup_fields= &rollup.getFields()[i];
 
2088
    rollup.null_items[i]= new (session->mem_root) Item_null_result();
 
2089
    List<Item> *rollup_fields= &rollup.fields[i];
2282
2090
    rollup_fields->empty();
2283
 
    rollup.getRefPointerArrays()[i]= ref_array;
 
2091
    rollup.ref_pointer_arrays[i]= ref_array;
2284
2092
    ref_array+= all_fields.elements;
2285
2093
  }
2286
 
 
2287
 
  for (uint32_t i= 0 ; i < send_group_parts; i++)
 
2094
  for (i= 0 ; i < send_group_parts; i++)
2288
2095
  {
2289
 
    for (uint32_t j= 0 ; j < fields_list.elements ; j++)
2290
 
    {
2291
 
      rollup.getFields()[i].push_back(rollup.getNullItems()[i]);
2292
 
    }
 
2096
    for (j=0 ; j < fields_list.elements ; j++)
 
2097
      rollup.fields[i].push_back(rollup.null_items[i]);
2293
2098
  }
2294
 
 
2295
2099
  List_iterator<Item> it(all_fields);
2296
2100
  Item *item;
2297
2101
  while ((item= it++))
2398
2202
    uint32_t pos= send_group_parts - level -1;
2399
2203
    bool real_fields= 0;
2400
2204
    Item *item;
2401
 
    List_iterator<Item> new_it(rollup.getFields()[pos]);
2402
 
    Item **ref_array_start= rollup.getRefPointerArrays()[pos];
 
2205
    List_iterator<Item> new_it(rollup.fields[pos]);
 
2206
    Item **ref_array_start= rollup.ref_pointer_arrays[pos];
2403
2207
    Order *start_group;
2404
2208
 
2405
2209
    /* Point to first hidden field */
2497
2301
*/
2498
2302
int Join::rollup_send_data(uint32_t idx)
2499
2303
{
2500
 
  for (uint32_t i= send_group_parts ; i-- > idx ; )
 
2304
  uint32_t i;
 
2305
  for (i= send_group_parts ; i-- > idx ; )
2501
2306
  {
2502
2307
    /* Get reference pointers to sum functions in place */
2503
 
    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i], ref_pointer_array_size);
2504
 
 
 
2308
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
 
2309
     ref_pointer_array_size);
2505
2310
    if ((!having || having->val_int()))
2506
2311
    {
2507
 
      if (send_records < unit->select_limit_cnt && do_send_rows && result->send_data(rollup.getFields()[i]))
2508
 
      {
2509
 
        return 1;
2510
 
      }
 
2312
      if (send_records < unit->select_limit_cnt && do_send_rows &&
 
2313
    result->send_data(rollup.fields[i]))
 
2314
  return 1;
2511
2315
      send_records++;
2512
2316
    }
2513
2317
  }
2514
2318
  /* Restore ref_pointer_array */
2515
2319
  set_items_ref_array(current_ref_pointer_array);
2516
 
 
2517
2320
  return 0;
2518
2321
}
2519
2322
 
2538
2341
*/
2539
2342
int Join::rollup_write_data(uint32_t idx, Table *table_arg)
2540
2343
{
2541
 
  for (uint32_t i= send_group_parts ; i-- > idx ; )
 
2344
  uint32_t i;
 
2345
  for (i= send_group_parts ; i-- > idx ; )
2542
2346
  {
2543
2347
    /* Get reference pointers to sum functions in place */
2544
 
    memcpy(ref_pointer_array, rollup.getRefPointerArrays()[i],
 
2348
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
2545
2349
           ref_pointer_array_size);
2546
2350
    if ((!having || having->val_int()))
2547
2351
    {
2548
2352
      int write_error;
2549
2353
      Item *item;
2550
 
      List_iterator_fast<Item> it(rollup.getFields()[i]);
 
2354
      List_iterator_fast<Item> it(rollup.fields[i]);
2551
2355
      while ((item= it++))
2552
2356
      {
2553
2357
        if (item->type() == Item::NULL_ITEM && item->is_result_field())
2563
2367
  }
2564
2368
  /* Restore ref_pointer_array */
2565
2369
  set_items_ref_array(current_ref_pointer_array);
2566
 
 
2567
2370
  return 0;
2568
2371
}
2569
2372
 
2659
2462
    return NESTED_LOOP_ERROR;
2660
2463
  if (error < 0)
2661
2464
    return NESTED_LOOP_NO_MORE_ROWS;
2662
 
  if (join->session->getKilled())                       // Aborted by user
 
2465
  if (join->session->killed)                    // Aborted by user
2663
2466
  {
2664
2467
    join->session->send_kill_message();
2665
2468
    return NESTED_LOOP_KILLED;
2871
2674
  info= &join_tab->read_record;
2872
2675
  do
2873
2676
  {
2874
 
    if (join->session->getKilled())
 
2677
    if (join->session->killed)
2875
2678
    {
2876
2679
      join->session->send_kill_message();
2877
2680
      return NESTED_LOOP_KILLED;
3003
2806
{
3004
2807
  Table *table= join->tmp_table;
3005
2808
 
3006
 
  if (join->session->getKilled())                       // Aborted by user
 
2809
  if (join->session->killed)                    // Aborted by user
3007
2810
  {
3008
2811
    join->session->send_kill_message();
3009
2812
    return NESTED_LOOP_KILLED;
3011
2814
  if (!end_of_records)
3012
2815
  {
3013
2816
    copy_fields(&join->tmp_table_param);
3014
 
    if (copy_funcs(join->tmp_table_param.items_to_copy, join->session))
3015
 
      return NESTED_LOOP_ERROR;
 
2817
    copy_funcs(join->tmp_table_param.items_to_copy);
3016
2818
    if (!join->having || join->having->val_int())
3017
2819
    {
3018
2820
      int error;
3050
2852
 
3051
2853
  if (end_of_records)
3052
2854
    return NESTED_LOOP_OK;
3053
 
  if (join->session->getKilled())                       // Aborted by user
 
2855
  if (join->session->killed)                    // Aborted by user
3054
2856
  {
3055
2857
    join->session->send_kill_message();
3056
2858
    return NESTED_LOOP_KILLED;
3097
2899
      memcpy(table->getInsertRecord()+key_part->offset, group->buff, 1);
3098
2900
  }
3099
2901
  init_tmptable_sum_functions(join->sum_funcs);
3100
 
  if (copy_funcs(join->tmp_table_param.items_to_copy, join->session))
3101
 
    return NESTED_LOOP_ERROR;
 
2902
  copy_funcs(join->tmp_table_param.items_to_copy);
3102
2903
  if ((error=table->cursor->insertRecord(table->getInsertRecord())))
3103
2904
  {
3104
2905
    my_error(ER_USE_SQL_BIG_RESULT, MYF(0));
3116
2917
 
3117
2918
  if (end_of_records)
3118
2919
    return NESTED_LOOP_OK;
3119
 
  if (join->session->getKilled())                       // Aborted by user
 
2920
  if (join->session->killed)                    // Aborted by user
3120
2921
  {
3121
2922
    join->session->send_kill_message();
3122
2923
    return NESTED_LOOP_KILLED;
3124
2925
 
3125
2926
  init_tmptable_sum_functions(join->sum_funcs);
3126
2927
  copy_fields(&join->tmp_table_param);          // Groups are copied twice.
3127
 
  if (copy_funcs(join->tmp_table_param.items_to_copy, join->session))
3128
 
    return NESTED_LOOP_ERROR;
 
2928
  copy_funcs(join->tmp_table_param.items_to_copy);
3129
2929
 
3130
2930
  if (!(error= table->cursor->insertRecord(table->getInsertRecord())))
3131
2931
    join->send_records++;                       // New group
3210
3010
      case REAL_RESULT:
3211
3011
        key_length+= sizeof(double);
3212
3012
        break;
3213
 
 
3214
3013
      case INT_RESULT:
3215
3014
        key_length+= sizeof(int64_t);
3216
3015
        break;
3217
 
 
3218
3016
      case DECIMAL_RESULT:
3219
 
        key_length+= class_decimal_get_binary_size(group_item->max_length -
 
3017
        key_length+= my_decimal_get_binary_size(group_item->max_length -
3220
3018
                                                (group_item->decimals ? 1 : 0),
3221
3019
                                                group_item->decimals);
3222
3020
        break;
3223
 
 
3224
3021
      case STRING_RESULT:
3225
 
        {
3226
 
          enum enum_field_types type= group_item->field_type();
 
3022
      {
 
3023
        enum enum_field_types type= group_item->field_type();
 
3024
        /*
 
3025
          As items represented as DATE/TIME fields in the group buffer
 
3026
          have STRING_RESULT result type, we increase the length
 
3027
          by 8 as maximum pack length of such fields.
 
3028
        */
 
3029
        if (type == DRIZZLE_TYPE_DATE ||
 
3030
            type == DRIZZLE_TYPE_DATETIME ||
 
3031
            type == DRIZZLE_TYPE_TIMESTAMP)
 
3032
        {
 
3033
          key_length+= 8;
 
3034
        }
 
3035
        else
 
3036
        {
3227
3037
          /*
3228
 
            As items represented as DATE/TIME fields in the group buffer
3229
 
            have STRING_RESULT result type, we increase the length
3230
 
            by 8 as maximum pack length of such fields.
 
3038
            Group strings are taken as varstrings and require an length field.
 
3039
            A field is not yet created by create_tmp_field()
 
3040
            and the sizes should match up.
3231
3041
          */
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)
3237
 
          {
3238
 
            key_length+= 8;
3239
 
          }
3240
 
          else
3241
 
          {
3242
 
            /*
3243
 
              Group strings are taken as varstrings and require an length field.
3244
 
              A field is not yet created by create_tmp_field()
3245
 
              and the sizes should match up.
3246
 
            */
3247
 
            key_length+= group_item->max_length + HA_KEY_BLOB_LENGTH;
3248
 
          }
3249
 
 
3250
 
          break;
 
3042
          key_length+= group_item->max_length + HA_KEY_BLOB_LENGTH;
3251
3043
        }
3252
 
 
3253
 
      case ROW_RESULT:
 
3044
        break;
 
3045
      }
 
3046
      default:
3254
3047
        /* This case should never be choosen */
3255
3048
        assert(0);
3256
3049
        my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR));
3257
3050
      }
3258
3051
    }
3259
 
 
3260
3052
    parts++;
3261
 
 
3262
3053
    if (group_item->maybe_null)
3263
3054
      null_parts++;
3264
3055
  }
3265
 
 
3266
3056
  join->tmp_table_param.group_length=key_length+null_parts;
3267
3057
  join->tmp_table_param.group_parts=parts;
3268
3058
  join->tmp_table_param.group_null_parts=null_parts;
3405
3195
 
3406
3196
  table_count=join->tables;
3407
3197
  if (!(join->join_tab=join_tab=
3408
 
  (JoinTable*) session->getMemRoot()->allocate(sizeof(JoinTable)*table_count)))
 
3198
  (JoinTable*) session->alloc(sizeof(JoinTable)*table_count)))
3409
3199
    return(true);
3410
3200
 
3411
 
  for (i= 0; i < table_count; i++)
3412
 
    new (join_tab+i) JoinTable();
3413
 
 
3414
3201
  join->full_join=0;
3415
3202
 
3416
3203
  used_tables= OUTER_REF_TABLE_BIT;   // Outer row is already read
4395
4182
                                             uint32_t prune_level)
4396
4183
{
4397
4184
  Session *session= join->session;
4398
 
  if (session->getKilled())  // Abort
 
4185
  if (session->killed)  // Abort
4399
4186
    return(true);
4400
4187
 
4401
4188
  /*
4563
4350
  */
4564
4351
  if (!join->table_reexec)
4565
4352
  {
4566
 
    if (!(join->table_reexec= (Table**) join->session->getMemRoot()->allocate(sizeof(Table*))))
 
4353
    if (!(join->table_reexec= (Table**) join->session->alloc(sizeof(Table*))))
4567
4354
      return(true);
4568
4355
    if (join->tmp_join)
4569
4356
      join->tmp_join->table_reexec= join->table_reexec;
4571
4358
  if (!join->join_tab_reexec)
4572
4359
  {
4573
4360
    if (!(join->join_tab_reexec=
4574
 
          (JoinTable*) join->session->getMemRoot()->allocate(sizeof(JoinTable))))
 
4361
          (JoinTable*) join->session->alloc(sizeof(JoinTable))))
4575
4362
      return(true);
4576
 
    new (join->join_tab_reexec) JoinTable();
4577
4363
    if (join->tmp_join)
4578
4364
      join->tmp_join->join_tab_reexec= join->join_tab_reexec;
4579
4365
  }
4594
4380
  join->row_limit=join->unit->select_limit_cnt;
4595
4381
  join->do_send_rows = (join->row_limit) ? 1 : 0;
4596
4382
 
 
4383
  join_tab->cache.buff=0;                       /* No caching */
4597
4384
  join_tab->table=tmp_table;
4598
4385
  join_tab->select=0;
4599
4386
  join_tab->select_cond=0;
4684
4471
      /* Ignore sj-nests: */
4685
4472
      if (!embedding->on_expr)
4686
4473
        continue;
4687
 
      NestedJoin *nested_join= embedding->getNestedJoin();
 
4474
      nested_join_st *nested_join= embedding->getNestedJoin();
4688
4475
      if (!nested_join->counter_)
4689
4476
      {
4690
4477
        /*
4802
4589
          join->full_join= 1;
4803
4590
      }
4804
4591
 
4805
 
      if (join->full_join and not session->lex->current_select->is_cross and not cond)
4806
 
      {
4807
 
        my_error(ER_CARTESIAN_JOIN_ATTEMPTED, MYF(0));
4808
 
        return 1;
4809
 
      }
4810
 
 
4811
4592
      tmp= NULL;
4812
4593
      if (cond)
4813
4594
        tmp= make_cond_for_table(cond,used_tables,current_map, 0);
4838
4619
          tab->type == AM_EQ_REF)
4839
4620
      {
4840
4621
        optimizer::SqlSelect *sel= tab->select= ((optimizer::SqlSelect*)
4841
 
            session->getMemRoot()->duplicate((unsigned char*) select,
 
4622
            session->memdup((unsigned char*) select,
4842
4623
              sizeof(*select)));
4843
4624
        if (! sel)
4844
4625
          return 1;                     // End of memory
4976
4757
                                         current_map, 0)))
4977
4758
            {
4978
4759
              tab->cache.select= (optimizer::SqlSelect*)
4979
 
                session->getMemRoot()->duplicate((unsigned char*) sel, sizeof(optimizer::SqlSelect));
 
4760
                session->memdup((unsigned char*) sel, sizeof(optimizer::SqlSelect));
4980
4761
              tab->cache.select->cond= tmp;
4981
4762
              tab->cache.select->read_tables= join->const_table_map;
4982
4763
            }
5112
4893
 
5113
4894
    if (tab->insideout_match_tab)
5114
4895
    {
5115
 
      if (! (tab->insideout_buf= (unsigned char*) join->session->getMemRoot()->allocate(tab->table->key_info
 
4896
      if (! (tab->insideout_buf= (unsigned char*) join->session->alloc(tab->table->key_info
5116
4897
                                                                       [tab->index].
5117
4898
                                                                       key_length)))
5118
4899
        return true;
5430
5211
static COND *simplify_joins(Join *join, List<TableList> *join_list, COND *conds, bool top)
5431
5212
{
5432
5213
  TableList *table;
5433
 
  NestedJoin *nested_join;
 
5214
  nested_join_st *nested_join;
5434
5215
  TableList *prev_table= 0;
5435
5216
  List_iterator<TableList> li(*join_list);
5436
5217
 
5703
5484
 
5704
5485
  table_count= join->tables;
5705
5486
  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));
 
5487
  stat_ref= (JoinTable**) join->session->alloc(sizeof(JoinTable*)*MAX_TABLES);
 
5488
  table_vector= (Table**) join->session->alloc(sizeof(Table*)*(table_count*2));
5708
5489
  if (! stat || ! stat_ref || ! table_vector)
5709
5490
    return 1;
5710
5491
 
5768
5549
      s->embedding_map.reset();
5769
5550
      do
5770
5551
      {
5771
 
        NestedJoin *nested_join= embedding->getNestedJoin();
 
5552
        nested_join_st *nested_join= embedding->getNestedJoin();
5772
5553
        s->embedding_map|= nested_join->nj_map;
5773
5554
        s->dependent|= embedding->getDepTables();
5774
5555
        embedding= embedding->getEmbedding();
5797
5578
       As we use bitmaps to represent the relation the complexity
5798
5579
       of the algorithm is O((number of tables)^2).
5799
5580
    */
5800
 
    for (i= 0; i < table_count; i++)
 
5581
    for (i= 0, s= stat ; i < table_count ; i++, s++)
5801
5582
    {
5802
 
      uint32_t j;
5803
 
      table= stat[i].table;
5804
 
 
5805
 
      if (!table->reginfo.join_tab->dependent)
5806
 
        continue;
5807
 
 
5808
 
      for (j= 0, s= stat; j < table_count; j++, s++)
 
5583
      for (uint32_t j= 0 ; j < table_count ; j++)
5809
5584
      {
 
5585
        table= stat[j].table;
5810
5586
        if (s->dependent & table->map)
5811
 
        {
5812
 
          table_map was_dependent= s->dependent;
5813
5587
          s->dependent |= table->reginfo.join_tab->dependent;
5814
 
          if (i > j && s->dependent != was_dependent)
5815
 
          {
5816
 
            i= j= 1;
5817
 
            break;
5818
 
          }
5819
 
        }
5820
5588
      }
 
5589
      if (s->dependent)
 
5590
        s->table->maybe_null= 1;
5821
5591
    }
5822
5592
    /* Catch illegal cross references for outer joins */
5823
5593
    for (i= 0, s= stat ; i < table_count ; i++, s++)
5828
5598
        my_message(ER_WRONG_OUTER_JOIN, ER(ER_WRONG_OUTER_JOIN), MYF(0));
5829
5599
        return 1;
5830
5600
      }
5831
 
      if (outer_join & s->table->map)
5832
 
        s->table->maybe_null= 1;
5833
 
 
5834
5601
      s->key_dependent= s->dependent;
5835
5602
    }
5836
5603
  }
5852
5619
    s= p_pos->getJoinTable();
5853
5620
    s->type= AM_SYSTEM;
5854
5621
    join->const_table_map|=s->table->map;
5855
 
    if ((tmp= s->joinReadConstTable(p_pos)))
 
5622
    if ((tmp= join_read_const_table(s, p_pos)))
5856
5623
    {
5857
5624
      if (tmp > 0)
5858
5625
        return 1;                       // Fatal error
5926
5693
          join->const_table_map|=table->map;
5927
5694
          set_position(join, const_count++, s, (optimizer::KeyUse*) 0);
5928
5695
          partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5929
 
          if ((tmp= s->joinReadConstTable(partial_pos)))
 
5696
          if ((tmp= join_read_const_table(s, partial_pos)))
5930
5697
          {
5931
5698
            if (tmp > 0)
5932
5699
              return 1;                 // Fatal error
5978
5745
                if (create_ref_for_key(join, s, start_keyuse, found_const_table_map))
5979
5746
                  return 1;
5980
5747
                partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);
5981
 
                if ((tmp=s->joinReadConstTable(partial_pos)))
 
5748
                if ((tmp=join_read_const_table(s, partial_pos)))
5982
5749
                {
5983
5750
                  if (tmp > 0)
5984
5751
                    return 1;                   // Fatal error
6062
5829
      s->quick=select->quick;
6063
5830
      s->needed_reg=select->needed_reg;
6064
5831
      select->quick=0;
6065
 
 
6066
5832
      if (records == 0 && s->table->reginfo.impossible_range)
6067
5833
      {
6068
5834
        /*
6102
5868
  if (join->const_tables != join->tables)
6103
5869
  {
6104
5870
    optimize_keyuse(join, keyuse_array);
6105
 
    // @note c_str() is not likely to be valid here if dtrace expects it to
6106
 
    // exist for any period of time.
6107
 
    DRIZZLE_QUERY_OPT_CHOOSE_PLAN_START(join->session->getQueryString()->c_str(), join->session->thread_id);
 
5871
    DRIZZLE_QUERY_OPT_CHOOSE_PLAN_START(join->session->query.c_str(), join->session->thread_id);
6108
5872
    bool res= choose_plan(join, all_table_map & ~join->const_table_map);
6109
5873
    DRIZZLE_QUERY_OPT_CHOOSE_PLAN_DONE(res ? 1 : 0);
6110
5874
    if (res)
6116
5880
    join->best_read= 1.0;
6117
5881
  }
6118
5882
  /* Generate an execution plan from the found optimal join order. */
6119
 
  return (join->session->getKilled() || get_best_combination(join));
 
5883
  return (join->session->killed || get_best_combination(join));
6120
5884
}
6121
5885
 
6122
5886
/**
6144
5908
  TableList *table;
6145
5909
  while ((table= li++))
6146
5910
  {
6147
 
    NestedJoin *nested_join;
 
5911
    nested_join_st *nested_join;
6148
5912
    if ((nested_join= table->getNestedJoin()))
6149
5913
    {
6150
5914
      /*
6201
5965
}
6202
5966
 
6203
5967
/**
6204
 
  Set NestedJoin::counter=0 in all nested joins in passed list.
 
5968
  Set nested_join_st::counter=0 in all nested joins in passed list.
6205
5969
 
6206
 
    Recursively set NestedJoin::counter=0 for all nested joins contained in
 
5970
    Recursively set nested_join_st::counter=0 for all nested joins contained in
6207
5971
    the passed join_list.
6208
5972
 
6209
5973
  @param join_list  List of nested joins to process. It may also contain base
6215
5979
  TableList *table;
6216
5980
  while ((table= li++))
6217
5981
  {
6218
 
    NestedJoin *nested_join;
 
5982
    nested_join_st *nested_join;
6219
5983
    if ((nested_join= table->getNestedJoin()))
6220
5984
    {
6221
5985
      nested_join->counter_= 0;
6301
6065
  Join *join= last->join;
6302
6066
  for (;last_emb != NULL; last_emb= last_emb->getEmbedding())
6303
6067
  {
6304
 
    NestedJoin *nest= last_emb->getNestedJoin();
 
6068
    nested_join_st *nest= last_emb->getNestedJoin();
6305
6069
    
6306
6070
    bool was_fully_covered= nest->is_fully_covered();
6307
6071