← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

pandora-build v0.72 - Moved remaining hard-coded tests into pandora-build
macros.
Add PANDORA_DRIZZLE_BUILD to run the extra checks that drizzle needs that 
plugins would also need to run so we can just use that macro in generated
external plugin builds.
Added support to register_plugins for external plugin building.
Renamed register_plugins.py to pandora-plugin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
19
19
  @brief
20
20
  mysql_select and join optimization
21
21
 
22
 
 
23
22
  @defgroup Query_Optimizer  Query Optimizer
24
23
  @{
25
24
*/
26
 
#include <drizzled/server_includes.h>
27
 
#include <drizzled/sql_select.h>
28
 
 
29
 
#include <mysys/my_bit.h>
30
 
#include <drizzled/drizzled_error_messages.h>
31
 
 
32
 
const char *join_type_str[]={ "UNKNOWN","system","const","eq_ref","ref",
33
 
                              "MAYBE_REF","ALL","range","index",
34
 
                              "ref_or_null","unique_subquery","index_subquery",
35
 
                              "index_merge"
 
25
#include "drizzled/server_includes.h"
 
26
 
 
27
#include <string>
 
28
#include <iostream>
 
29
#include <algorithm>
 
30
#include <vector>
 
31
 
 
32
#include "drizzled/sql_select.h" /* include join.h */
 
33
#include "drizzled/table_map_iterator.h"
 
34
 
 
35
#include "drizzled/error.h"
 
36
#include "drizzled/gettext.h"
 
37
#include "drizzled/util/test.h"
 
38
#include "drizzled/name_resolution_context_state.h"
 
39
#include "drizzled/nested_join.h"
 
40
#include "drizzled/probes.h"
 
41
#include "drizzled/show.h"
 
42
#include "drizzled/plugin/info_schema_table.h"
 
43
#include "drizzled/item/cache.h"
 
44
#include "drizzled/item/cmpfunc.h"
 
45
#include "drizzled/item/copy_string.h"
 
46
#include "drizzled/item/uint.h"
 
47
#include "drizzled/cached_item.h"
 
48
#include "drizzled/sql_base.h"
 
49
#include "drizzled/field/blob.h"
 
50
#include "drizzled/check_stack_overrun.h"
 
51
#include "drizzled/lock.h"
 
52
#include "drizzled/item/outer_ref.h"
 
53
#include "drizzled/index_hint.h"
 
54
#include "drizzled/memory/multi_malloc.h"
 
55
 
 
56
#include "drizzled/sql_union.h"
 
57
#include "drizzled/optimizer/key_field.h"
 
58
#include "drizzled/optimizer/position.h"
 
59
#include "drizzled/optimizer/sargable_param.h"
 
60
#include "drizzled/optimizer/key_use.h"
 
61
 
 
62
using namespace std;
 
63
using namespace drizzled;
 
64
 
 
65
static const string access_method_str[]=
 
66
{
 
67
  "UNKNOWN",
 
68
  "system",
 
69
  "const",
 
70
  "eq_ref",
 
71
  "ref",
 
72
  "MAYBE_REF",
 
73
  "ALL",
 
74
  "range",
 
75
  "index",
 
76
  "ref_or_null",
 
77
  "unique_subquery",
 
78
  "index_subquery",
 
79
  "index_merge"
36
80
};
37
81
 
38
 
struct st_sargable_param;
39
 
 
40
 
static void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array);
41
 
static bool make_join_statistics(JOIN *join, TABLE_LIST *leaves, COND *conds,
42
 
                                 DYNAMIC_ARRAY *keyuse);
43
 
static bool update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,
44
 
                                JOIN_TAB *join_tab,
45
 
                                uint tables, COND *conds,
46
 
                                COND_EQUAL *cond_equal,
47
 
                                table_map table_map, SELECT_LEX *select_lex,
48
 
                                st_sargable_param **sargables);
49
 
static int sort_keyuse(KEYUSE *a,KEYUSE *b);
50
 
static void set_position(JOIN *join,uint index,JOIN_TAB *table,KEYUSE *key);
51
 
static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,
52
 
                               table_map used_tables);
53
 
static bool choose_plan(JOIN *join,table_map join_tables);
54
 
 
55
 
static void best_access_path(JOIN *join, JOIN_TAB *s, THD *thd,
56
 
                             table_map remaining_tables, uint idx,
57
 
                             double record_count, double read_time);
58
 
static void optimize_straight_join(JOIN *join, table_map join_tables);
59
 
static bool greedy_search(JOIN *join, table_map remaining_tables,
60
 
                             uint depth, uint prune_level);
61
 
static bool best_extension_by_limited_search(JOIN *join,
62
 
                                             table_map remaining_tables,
63
 
                                             uint idx, double record_count,
64
 
                                             double read_time, uint depth,
65
 
                                             uint prune_level);
66
 
static uint determine_search_depth(JOIN* join);
67
 
static int join_tab_cmp(const void* ptr1, const void* ptr2);
68
 
static int join_tab_cmp_straight(const void* ptr1, const void* ptr2);
69
 
/*
70
 
  TODO: 'find_best' is here only temporarily until 'greedy_search' is
71
 
  tested and approved.
72
 
*/
73
 
static bool find_best(JOIN *join,table_map rest_tables,uint index,
74
 
                      double record_count,double read_time);
75
 
static uint cache_record_length(JOIN *join,uint index);
76
 
static double prev_record_reads(JOIN *join, uint idx, table_map found_ref);
77
 
static bool get_best_combination(JOIN *join);
78
 
static store_key *get_store_key(THD *thd,
79
 
                                KEYUSE *keyuse, table_map used_tables,
80
 
                                KEY_PART_INFO *key_part, uchar *key_buff,
81
 
                                uint maybe_null);
82
 
static bool make_simple_join(JOIN *join,TABLE *tmp_table);
83
 
static void make_outerjoin_info(JOIN *join);
84
 
static bool make_join_select(JOIN *join,SQL_SELECT *select,COND *item);
85
 
static bool make_join_readinfo(JOIN *join, uint64_t options, uint no_jbuf_after);
86
 
static bool only_eq_ref_tables(JOIN *join, ORDER *order, table_map tables);
87
 
static void update_depend_map(JOIN *join);
88
 
static void update_depend_map(JOIN *join, ORDER *order);
89
 
static ORDER *remove_const(JOIN *join,ORDER *first_order,COND *cond,
90
 
                           bool change_list, bool *simple_order);
91
 
static int return_zero_rows(JOIN *join, select_result *res,TABLE_LIST *tables,
92
 
                            List<Item> &fields, bool send_row,
93
 
                            uint64_t select_options, const char *info,
94
 
                            Item *having);
95
 
static COND *build_equal_items(THD *thd, COND *cond,
 
82
static int sort_keyuse(optimizer::KeyUse *a, optimizer::KeyUse *b);
 
83
static COND *build_equal_items(Session *session, COND *cond,
96
84
                               COND_EQUAL *inherited,
97
 
                               List<TABLE_LIST> *join_list,
 
85
                               List<TableList> *join_list,
98
86
                               COND_EQUAL **cond_equal_ref);
99
 
static COND* substitute_for_best_equal_field(COND *cond,
100
 
                                             COND_EQUAL *cond_equal,
101
 
                                             void *table_join_idx);
102
 
static COND *simplify_joins(JOIN *join, List<TABLE_LIST> *join_list,
103
 
                            COND *conds, bool top, bool in_sj);
104
 
static bool check_interleaving_with_nj(JOIN_TAB *last, JOIN_TAB *next);
105
 
static void restore_prev_nj_state(JOIN_TAB *last);
106
 
static void reset_nj_counters(List<TABLE_LIST> *join_list);
107
 
static uint build_bitmap_for_nested_joins(List<TABLE_LIST> *join_list,
108
 
                                          uint first_unused);
109
 
 
110
 
static 
111
 
void advance_sj_state(const table_map remaining_tables, const JOIN_TAB *tab);
112
 
static void restore_prev_sj_state(const table_map remaining_tables, 
113
 
                                  const JOIN_TAB *tab);
114
 
 
115
 
static COND *optimize_cond(JOIN *join, COND *conds,
116
 
                           List<TABLE_LIST> *join_list,
117
 
                           Item::cond_result *cond_value);
118
 
static bool const_expression_in_where(COND *conds,Item *item, Item **comp_item);
119
 
static bool open_tmp_table(TABLE *table);
120
 
static bool create_myisam_tmp_table(TABLE *table, KEY *keyinfo, 
121
 
                                    MI_COLUMNDEF *start_recinfo,
122
 
                                    MI_COLUMNDEF **recinfo,
123
 
                                    uint64_t options);
124
 
static int do_select(JOIN *join,List<Item> *fields,TABLE *tmp_table);
125
 
 
126
 
static enum_nested_loop_state
127
 
evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,
128
 
                     int error);
129
 
static enum_nested_loop_state
130
 
evaluate_null_complemented_join_record(JOIN *join, JOIN_TAB *join_tab);
131
 
static enum_nested_loop_state
132
 
flush_cached_records(JOIN *join, JOIN_TAB *join_tab, bool skip_last);
133
 
static enum_nested_loop_state
134
 
end_send(JOIN *join, JOIN_TAB *join_tab, bool end_of_records);
135
 
static enum_nested_loop_state
136
 
end_write(JOIN *join, JOIN_TAB *join_tab, bool end_of_records);
137
 
static enum_nested_loop_state
138
 
end_update(JOIN *join, JOIN_TAB *join_tab, bool end_of_records);
139
 
static enum_nested_loop_state
140
 
end_unique_update(JOIN *join, JOIN_TAB *join_tab, bool end_of_records);
141
 
 
142
 
static int join_read_const_table(JOIN_TAB *tab, POSITION *pos);
143
 
static int join_read_system(JOIN_TAB *tab);
144
 
static int join_read_const(JOIN_TAB *tab);
145
 
static int join_read_key(JOIN_TAB *tab);
146
 
static int join_read_always_key(JOIN_TAB *tab);
147
 
static int join_read_last_key(JOIN_TAB *tab);
148
 
static int join_no_more_records(READ_RECORD *info);
149
 
static int join_read_next(READ_RECORD *info);
150
 
static int join_read_next_different(READ_RECORD *info);
151
 
static int join_init_quick_read_record(JOIN_TAB *tab);
152
 
static int test_if_quick_select(JOIN_TAB *tab);
153
 
static int join_init_read_record(JOIN_TAB *tab);
154
 
static int join_read_first(JOIN_TAB *tab);
155
 
static int join_read_next_same(READ_RECORD *info);
156
 
static int join_read_next_same_diff(READ_RECORD *info);
157
 
static int join_read_last(JOIN_TAB *tab);
158
 
static int join_read_prev_same(READ_RECORD *info);
159
 
static int join_read_prev(READ_RECORD *info);
160
 
int join_read_always_key_or_null(JOIN_TAB *tab);
161
 
int join_read_next_same_or_null(READ_RECORD *info);
162
 
static COND *make_cond_for_table(COND *cond,table_map table,
163
 
                                 table_map used_table,
164
 
                                 bool exclude_expensive_cond);
165
 
static Item* part_of_refkey(TABLE *form,Field *field);
166
 
static bool test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,
167
 
                                    ha_rows select_limit, bool no_changes,
168
 
                                    const key_map *map);
169
 
static bool list_contains_unique_index(TABLE *table,
170
 
                          bool (*find_func) (Field *, void *), void *data);
171
 
static bool find_field_in_item_list (Field *field, void *data);
172
 
static bool find_field_in_order_list (Field *field, void *data);
173
 
static int create_sort_index(THD *thd, JOIN *join, ORDER *order,
174
 
                             ha_rows filesort_limit, ha_rows select_limit,
175
 
                             bool is_order_by);
176
 
static int remove_duplicates(JOIN *join,TABLE *entry,List<Item> &fields,
177
 
                             Item *having);
178
 
static int remove_dup_with_compare(THD *thd, TABLE *entry, Field **field,
179
 
                                   ulong offset,Item *having);
180
 
static int remove_dup_with_hash_index(THD *thd,TABLE *table,
181
 
                                      uint field_count, Field **first_field,
182
 
 
183
 
                                      ulong key_length,Item *having);
184
 
static int join_init_cache(THD *thd,JOIN_TAB *tables,uint table_count);
185
 
static ulong used_blob_length(CACHE_FIELD **ptr);
186
 
static bool store_record_in_cache(JOIN_CACHE *cache);
187
 
static void reset_cache_read(JOIN_CACHE *cache);
188
 
static void reset_cache_write(JOIN_CACHE *cache);
189
 
static void read_cached_record(JOIN_TAB *tab);
190
 
static bool cmp_buffer_with_ref(JOIN_TAB *tab);
191
 
static ORDER *create_distinct_group(THD *thd, Item **ref_pointer_array,
192
 
                                    ORDER *order, List<Item> &fields,
193
 
                                    List<Item> &all_fields,
194
 
                                    bool *all_order_by_fields_used);
195
 
static bool test_if_subpart(ORDER *a,ORDER *b);
196
 
static TABLE *get_sort_by_table(ORDER *a,ORDER *b,TABLE_LIST *tables);
197
 
static void calc_group_buffer(JOIN *join,ORDER *group);
198
 
static bool make_group_fields(JOIN *main_join, JOIN *curr_join);
199
 
static bool alloc_group_fields(JOIN *join,ORDER *group);
200
 
// Create list for using with tempory table
201
 
static bool change_to_use_tmp_fields(THD *thd, Item **ref_pointer_array,
202
 
                                     List<Item> &new_list1,
203
 
                                     List<Item> &new_list2,
204
 
                                     uint elements, List<Item> &items);
205
 
// Create list for using with tempory table
206
 
static bool change_refs_to_tmp_fields(THD *thd, Item **ref_pointer_array,
207
 
                                      List<Item> &new_list1,
208
 
                                      List<Item> &new_list2,
209
 
                                      uint elements, List<Item> &items);
210
 
static void init_tmptable_sum_functions(Item_sum **func);
211
 
static void update_tmptable_sum_func(Item_sum **func,TABLE *tmp_table);
212
 
static void copy_sum_funcs(Item_sum **func_ptr, Item_sum **end);
213
 
static bool add_ref_to_table_cond(THD *thd, JOIN_TAB *join_tab);
214
 
static bool setup_sum_funcs(THD *thd, Item_sum **func_ptr);
215
 
static bool init_sum_functions(Item_sum **func, Item_sum **end);
216
 
static bool update_sum_func(Item_sum **func);
217
 
void select_describe(JOIN *join, bool need_tmp_table,bool need_order,
218
 
                            bool distinct, const char *message=NullS);
219
 
static Item *remove_additional_cond(Item* conds);
220
 
static void add_group_and_distinct_keys(JOIN *join, JOIN_TAB *join_tab);
221
 
static bool test_if_ref(Item_field *left_item,Item *right_item);
222
 
static bool replace_where_subcondition(JOIN *join, Item *old_cond, 
223
 
                                       Item *new_cond, bool fix_fields);
 
87
 
 
88
static Item* part_of_refkey(Table *form,Field *field);
 
89
static bool cmp_buffer_with_ref(JoinTable *tab);
 
90
static void change_cond_ref_to_const(Session *session,
 
91
                                     vector<COND_CMP>& save_list,
 
92
                                     Item *and_father,
 
93
                                     Item *cond,
 
94
                                     Item *field,
 
95
                                     Item *value);
 
96
static bool copy_blobs(Field **ptr);
 
97
 
 
98
static bool eval_const_cond(COND *cond)
 
99
{
 
100
    return ((Item_func*) cond)->val_int() ? true : false;
 
101
}
224
102
 
225
103
/*
226
104
  This is used to mark equalities that were made from i-th IN-equality.
230
108
const char *subq_sj_cond_name=
231
109
  "0123456789ABCDEF0123456789abcdef0123456789ABCDEF0123456789abcdef-sj-cond";
232
110
 
233
 
static bool bitmap_covers(const table_map x, const table_map y)
 
111
static bool copy_blobs(Field **ptr)
234
112
{
235
 
  return !test(y & ~x);
 
113
  for (; *ptr ; ptr++)
 
114
  {
 
115
    if ((*ptr)->flags & BLOB_FLAG)
 
116
      if (((Field_blob *) (*ptr))->copy())
 
117
        return 1;                               // Error
 
118
  }
 
119
  return 0;
236
120
}
237
121
 
238
122
/**
239
123
  This handles SELECT with and without UNION.
240
124
*/
241
 
 
242
 
bool handle_select(THD *thd, LEX *lex, select_result *result,
243
 
                   ulong setup_tables_done_option)
 
125
bool handle_select(Session *session, LEX *lex, select_result *result,
 
126
                   uint64_t setup_tables_done_option)
244
127
{
245
128
  bool res;
246
 
  register SELECT_LEX *select_lex = &lex->select_lex;
247
 
  DRIZZLE_SELECT_START();
 
129
  register Select_Lex *select_lex= &lex->select_lex;
 
130
  DRIZZLE_SELECT_START(session->query);
248
131
 
249
 
  if (select_lex->master_unit()->is_union() || 
 
132
  if (select_lex->master_unit()->is_union() ||
250
133
      select_lex->master_unit()->fake_select_lex)
251
 
    res= mysql_union(thd, lex, result, &lex->unit, setup_tables_done_option);
 
134
    res= drizzle_union(session, lex, result, &lex->unit,
 
135
                       setup_tables_done_option);
252
136
  else
253
137
  {
254
 
    SELECT_LEX_UNIT *unit= &lex->unit;
 
138
    Select_Lex_Unit *unit= &lex->unit;
255
139
    unit->set_limit(unit->global_parameters);
256
 
    thd->thd_marker= 0;
 
140
    session->session_marker= 0;
257
141
    /*
258
142
      'options' of mysql_select will be set in JOIN, as far as JOIN for
259
 
      every PS/SP execution new, we will not need reset this flag if 
 
143
      every PS/SP execution new, we will not need reset this flag if
260
144
      setup_tables_done_option changed for next rexecution
261
145
    */
262
 
    res= mysql_select(thd, &select_lex->ref_pointer_array,
263
 
                      (TABLE_LIST*) select_lex->table_list.first,
 
146
    res= mysql_select(session, &select_lex->ref_pointer_array,
 
147
                      (TableList*) select_lex->table_list.first,
264
148
                      select_lex->with_wild, select_lex->item_list,
265
149
                      select_lex->where,
266
150
                      select_lex->order_list.elements +
267
151
                      select_lex->group_list.elements,
268
 
                      (ORDER*) select_lex->order_list.first,
269
 
                      (ORDER*) select_lex->group_list.first,
 
152
                      (order_st*) select_lex->order_list.first,
 
153
                      (order_st*) select_lex->group_list.first,
270
154
                      select_lex->having,
271
 
                      (ORDER*) lex->proc_list.first,
272
 
                      select_lex->options | thd->options |
 
155
                      select_lex->options | session->options |
273
156
                      setup_tables_done_option,
274
157
                      result, unit, select_lex);
275
158
  }
276
 
  res|= thd->is_error();
 
159
  res|= session->is_error();
277
160
  if (unlikely(res))
278
161
    result->abort();
279
162
 
280
 
  DRIZZLE_SELECT_END();
281
 
  return(res);
 
163
  DRIZZLE_SELECT_DONE(res, session->limit_found_rows);
 
164
  return res;
282
165
}
283
166
 
284
 
 
285
167
/*
286
168
  Fix fields referenced from inner selects.
287
169
 
288
170
  SYNOPSIS
289
171
    fix_inner_refs()
290
 
    thd               Thread handle
 
172
    session               Thread handle
291
173
    all_fields        List of all fields used in select
292
174
    select            Current select
293
175
    ref_pointer_array Array of references to Items used in current select
322
204
    true  an error occured
323
205
    false ok
324
206
*/
325
 
 
326
 
bool
327
 
fix_inner_refs(THD *thd, List<Item> &all_fields, SELECT_LEX *select,
328
 
                 Item **ref_pointer_array)
 
207
bool fix_inner_refs(Session *session, 
 
208
                    List<Item> &all_fields, 
 
209
                    Select_Lex *select, 
 
210
                    Item **ref_pointer_array)
329
211
{
330
212
  Item_outer_ref *ref;
331
213
  bool res= false;
385
267
    ref->outer_ref= new_ref;
386
268
    ref->ref= &ref->outer_ref;
387
269
 
388
 
    if (!ref->fixed && ref->fix_fields(thd, 0))
 
270
    if (!ref->fixed && ref->fix_fields(session, 0))
389
271
      return true;
390
 
    thd->used_tables|= item->used_tables();
 
272
    session->used_tables|= item->used_tables();
391
273
  }
392
274
  return res;
393
275
}
394
276
 
395
 
#define MAGIC_IN_WHERE_TOP_LEVEL 10
396
 
/**
397
 
  Function to setup clauses without sum functions.
398
 
*/
399
 
inline int setup_without_group(THD *thd, Item **ref_pointer_array,
400
 
                               TABLE_LIST *tables,
401
 
                               TABLE_LIST *leaves,
402
 
                               List<Item> &fields,
403
 
                               List<Item> &all_fields,
404
 
                               COND **conds,
405
 
                               ORDER *order,
406
 
                               ORDER *group, bool *hidden_group_fields)
407
 
{
408
 
  int res;
409
 
  nesting_map save_allow_sum_func=thd->lex->allow_sum_func ;
410
 
 
411
 
  thd->lex->allow_sum_func&= ~(1 << thd->lex->current_select->nest_level);
412
 
  res= setup_conds(thd, tables, leaves, conds);
413
 
 
414
 
  thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
415
 
  res= res || setup_order(thd, ref_pointer_array, tables, fields, all_fields,
416
 
                          order);
417
 
  thd->lex->allow_sum_func&= ~(1 << thd->lex->current_select->nest_level);
418
 
  res= res || setup_group(thd, ref_pointer_array, tables, fields, all_fields,
419
 
                          group, hidden_group_fields);
420
 
  thd->lex->allow_sum_func= save_allow_sum_func;
421
 
  return(res);
422
 
}
423
 
 
424
277
/*****************************************************************************
425
278
  Check fields, find best join, do the select and output fields.
426
279
  mysql_select assumes that all tables are already opened
427
280
*****************************************************************************/
428
281
 
429
 
/**
430
 
  Prepare of whole select (including sub queries in future).
431
 
 
432
 
  @todo
433
 
    Add check of calculation of GROUP functions and fields:
434
 
    SELECT COUNT(*)+table.col1 from table1;
435
 
 
436
 
  @retval
437
 
    -1   on error
438
 
  @retval
439
 
    0   on success
440
 
*/
441
 
int
442
 
JOIN::prepare(Item ***rref_pointer_array,
443
 
              TABLE_LIST *tables_init,
444
 
              uint wild_num, COND *conds_init, uint og_num,
445
 
              ORDER *order_init, ORDER *group_init,
446
 
              Item *having_init,
447
 
              ORDER *proc_param_init, SELECT_LEX *select_lex_arg,
448
 
              SELECT_LEX_UNIT *unit_arg)
449
 
{
450
 
  // to prevent double initialization on EXPLAIN
451
 
  if (optimized)
452
 
    return(0);
453
 
 
454
 
  conds= conds_init;
455
 
  order= order_init;
456
 
  group_list= group_init;
457
 
  having= having_init;
458
 
  proc_param= proc_param_init;
459
 
  tables_list= tables_init;
460
 
  select_lex= select_lex_arg;
461
 
  select_lex->join= this;
462
 
  join_list= &select_lex->top_join_list;
463
 
  union_part= unit_arg->is_union();
464
 
 
465
 
  thd->lex->current_select->is_item_list_lookup= 1;
466
 
  /*
467
 
    If we have already executed SELECT, then it have not sense to prevent
468
 
    its table from update (see unique_table())
469
 
  */
470
 
  if (thd->derived_tables_processing)
471
 
    select_lex->exclude_from_table_unique_test= true;
472
 
 
473
 
  /* Check that all tables, fields, conds and order are ok */
474
 
 
475
 
  if (!(select_options & OPTION_SETUP_TABLES_DONE) &&
476
 
      setup_tables_and_check_access(thd, &select_lex->context, join_list,
477
 
                                    tables_list, &select_lex->leaf_tables,
478
 
                                    false))
479
 
      return(-1);
480
 
 
481
 
  TABLE_LIST *table_ptr;
482
 
  for (table_ptr= select_lex->leaf_tables;
483
 
       table_ptr;
484
 
       table_ptr= table_ptr->next_leaf)
485
 
    tables++;
486
 
 
487
 
  if (setup_wild(thd, tables_list, fields_list, &all_fields, wild_num) ||
488
 
      select_lex->setup_ref_array(thd, og_num) ||
489
 
      setup_fields(thd, (*rref_pointer_array), fields_list, MARK_COLUMNS_READ,
490
 
                   &all_fields, 1) ||
491
 
      setup_without_group(thd, (*rref_pointer_array), tables_list,
492
 
                          select_lex->leaf_tables, fields_list,
493
 
                          all_fields, &conds, order, group_list,
494
 
                          &hidden_group_fields))
495
 
    return(-1);                         /* purecov: inspected */
496
 
 
497
 
  ref_pointer_array= *rref_pointer_array;
498
 
  
499
 
  if (having)
500
 
  {
501
 
    nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
502
 
    thd->where="having clause";
503
 
    thd->lex->allow_sum_func|= 1 << select_lex_arg->nest_level;
504
 
    select_lex->having_fix_field= 1;
505
 
    bool having_fix_rc= (!having->fixed &&
506
 
                         (having->fix_fields(thd, &having) ||
507
 
                          having->check_cols(1)));
508
 
    select_lex->having_fix_field= 0;
509
 
    if (having_fix_rc || thd->is_error())
510
 
      return(-1);                               /* purecov: inspected */
511
 
    thd->lex->allow_sum_func= save_allow_sum_func;
512
 
  }
513
 
 
514
 
  {
515
 
    Item_subselect *subselect;
516
 
    Item_in_subselect *in_subs= NULL;
517
 
    /*
518
 
      Are we in a subquery predicate?
519
 
      TODO: the block below will be executed for every PS execution without need.
520
 
    */
521
 
    if ((subselect= select_lex->master_unit()->item))
522
 
    {
523
 
      bool do_semijoin= !test(thd->variables.optimizer_switch &
524
 
                              OPTIMIZER_SWITCH_NO_SEMIJOIN);
525
 
      if (subselect->substype() == Item_subselect::IN_SUBS)
526
 
        in_subs= (Item_in_subselect*)subselect;
527
 
 
528
 
      /*
529
 
        Check if we're in subquery that is a candidate for flattening into a
530
 
        semi-join (which is done done in flatten_subqueries()). The
531
 
        requirements are:
532
 
          1. Subquery predicate is an IN/=ANY subq predicate
533
 
          2. Subquery is a single SELECT (not a UNION)
534
 
          3. Subquery does not have GROUP BY or ORDER BY
535
 
          4. Subquery does not use aggregate functions or HAVING
536
 
          5. Subquery predicate is at the AND-top-level of ON/WHERE clause
537
 
          6. No execution method was already chosen (by a prepared statement).
538
 
 
539
 
          (*). We are not in a subquery of a single table UPDATE/DELETE that 
540
 
               doesn't have a JOIN (TODO: We should handle this at some
541
 
               point by switching to multi-table UPDATE/DELETE)
542
 
 
543
 
          (**). We're not in a confluent table-less subquery, like
544
 
                "SELECT 1". 
545
 
      */
546
 
      if (in_subs &&                                                    // 1
547
 
          !select_lex->master_unit()->first_select()->next_select() &&  // 2
548
 
          !select_lex->group_list.elements && !order &&                 // 3
549
 
          !having && !select_lex->with_sum_func &&                      // 4
550
 
          thd->thd_marker &&                                            // 5
551
 
          select_lex->outer_select()->join &&                           // (*)
552
 
          select_lex->master_unit()->first_select()->leaf_tables &&     // (**) 
553
 
          do_semijoin &&
554
 
          in_subs->exec_method == Item_in_subselect::NOT_TRANSFORMED)   // 6
555
 
      {
556
 
        {
557
 
          if (!in_subs->left_expr->fixed &&
558
 
               in_subs->left_expr->fix_fields(thd, &in_subs->left_expr))
559
 
          {
560
 
            return(-1);
561
 
          }
562
 
          /*
563
 
            Check that the right part of the subselect contains no more than one
564
 
            column. E.g. in SELECT 1 IN (SELECT * ..) the right part is (SELECT * ...)
565
 
          */
566
 
          if (subselect->substype() == Item_subselect::IN_SUBS &&
567
 
             (select_lex->item_list.elements != 
568
 
              ((Item_in_subselect*)subselect)->left_expr->cols()))
569
 
          {
570
 
            my_error(ER_OPERAND_COLUMNS, MYF(0), ((Item_in_subselect*)subselect)->left_expr->cols());
571
 
            return(-1);
572
 
          }
573
 
        }
574
 
 
575
 
        /* Register the subquery for further processing */
576
 
        select_lex->outer_select()->join->sj_subselects.append(thd->mem_root, in_subs);
577
 
        in_subs->expr_join_nest= (TABLE_LIST*)thd->thd_marker;
578
 
      }
579
 
      else
580
 
      {
581
 
        bool do_materialize= !test(thd->variables.optimizer_switch &
582
 
                                   OPTIMIZER_SWITCH_NO_MATERIALIZATION);
583
 
        /*
584
 
          Check if the subquery predicate can be executed via materialization.
585
 
          The required conditions are:
586
 
          1. Subquery predicate is an IN/=ANY subq predicate
587
 
          2. Subquery is a single SELECT (not a UNION)
588
 
          3. Subquery is not a table-less query. In this case there is no
589
 
             point in materializing.
590
 
          4. Subquery predicate is a top-level predicate
591
 
             (this implies it is not negated)
592
 
             TODO: this is a limitation that should be lifeted once we
593
 
             implement correct NULL semantics (WL#3830)
594
 
          5. Subquery is non-correlated
595
 
             TODO:
596
 
             This is an overly restrictive condition. It can be extended to:
597
 
             (Subquery is non-correlated ||
598
 
              Subquery is correlated to any query outer to IN predicate ||
599
 
              (Subquery is correlated to the immediate outer query &&
600
 
               Subquery !contains {GROUP BY, ORDER BY [LIMIT],
601
 
               aggregate functions) && subquery predicate is not under "NOT IN"))
602
 
          6. No execution method was already chosen (by a prepared statement).
603
 
 
604
 
          (*) The subquery must be part of a SELECT statement. The current
605
 
               condition also excludes multi-table update statements.
606
 
 
607
 
          We have to determine whether we will perform subquery materialization
608
 
          before calling the IN=>EXISTS transformation, so that we know whether to
609
 
          perform the whole transformation or only that part of it which wraps
610
 
          Item_in_subselect in an Item_in_optimizer.
611
 
        */
612
 
        if (do_materialize && 
613
 
            in_subs  &&                                                   // 1
614
 
            !select_lex->master_unit()->first_select()->next_select() &&  // 2
615
 
            select_lex->master_unit()->first_select()->leaf_tables &&     // 3
616
 
            thd->lex->sql_command == SQLCOM_SELECT)                       // *
617
 
        {
618
 
          if (in_subs->is_top_level_item() &&                             // 4
619
 
              !in_subs->is_correlated &&                                  // 5
620
 
              in_subs->exec_method == Item_in_subselect::NOT_TRANSFORMED) // 6
621
 
            in_subs->exec_method= Item_in_subselect::MATERIALIZATION;
622
 
        }
623
 
 
624
 
        Item_subselect::trans_res trans_res;
625
 
        if ((trans_res= subselect->select_transformer(this)) !=
626
 
            Item_subselect::RES_OK)
627
 
        {
628
 
          return((trans_res == Item_subselect::RES_ERROR));
629
 
        }
630
 
      }
631
 
    }
632
 
  }
633
 
 
634
 
  if (order)
635
 
  {
636
 
    ORDER *ord;
637
 
    for (ord= order; ord; ord= ord->next)
638
 
    {
639
 
      Item *item= *ord->item;
640
 
      if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM)
641
 
        item->split_sum_func(thd, ref_pointer_array, all_fields);
642
 
    }
643
 
  }
644
 
 
645
 
  if (having && having->with_sum_func)
646
 
    having->split_sum_func2(thd, ref_pointer_array, all_fields,
647
 
                            &having, true);
648
 
  if (select_lex->inner_sum_func_list)
649
 
  {
650
 
    Item_sum *end=select_lex->inner_sum_func_list;
651
 
    Item_sum *item_sum= end;  
652
 
    do
653
 
    { 
654
 
      item_sum= item_sum->next;
655
 
      item_sum->split_sum_func2(thd, ref_pointer_array,
656
 
                                all_fields, item_sum->ref_by, false);
657
 
    } while (item_sum != end);
658
 
  }
659
 
 
660
 
  if (select_lex->inner_refs_list.elements &&
661
 
      fix_inner_refs(thd, all_fields, select_lex, ref_pointer_array))
662
 
    return(-1);
663
 
 
664
 
  /*
665
 
    Check if there are references to un-aggregated columns when computing 
666
 
    aggregate functions with implicit grouping (there is no GROUP BY).
667
 
 
668
 
    MODE_ONLY_FULL_GROUP_BY is enabled here by default
669
 
  */
670
 
  if (!group_list && select_lex->full_group_by_flag == (NON_AGG_FIELD_USED | SUM_FUNC_USED))
671
 
  {
672
 
    my_message(ER_MIX_OF_GROUP_FUNC_AND_FIELDS,
673
 
               ER(ER_MIX_OF_GROUP_FUNC_AND_FIELDS), MYF(0));
674
 
    return(-1);
675
 
  }
676
 
  {
677
 
    /* Caclulate the number of groups */
678
 
    send_group_parts= 0;
679
 
    for (ORDER *group_tmp= group_list ; group_tmp ; group_tmp= group_tmp->next)
680
 
      send_group_parts++;
681
 
  }
682
 
  
683
 
  if (error)
684
 
    goto err;                                   /* purecov: inspected */
685
 
 
686
 
  if (result && result->prepare(fields_list, unit_arg))
687
 
    goto err;                                   /* purecov: inspected */
688
 
 
689
 
  /* Init join struct */
690
 
  count_field_types(select_lex, &tmp_table_param, all_fields, 0);
691
 
  ref_pointer_array_size= all_fields.elements*sizeof(Item*);
692
 
  this->group= group_list != 0;
693
 
  unit= unit_arg;
694
 
 
695
 
#ifdef RESTRICTED_GROUP
696
 
  if (sum_func_count && !group_list && (func_count || field_count))
697
 
  {
698
 
    my_message(ER_WRONG_SUM_SELECT,ER(ER_WRONG_SUM_SELECT),MYF(0));
699
 
    goto err;
700
 
  }
701
 
#endif
702
 
  if (select_lex->olap == ROLLUP_TYPE && rollup_init())
703
 
    goto err;
704
 
  if (alloc_func_list())
705
 
    goto err;
706
 
 
707
 
  return(0); // All OK
708
 
 
709
 
err:
710
 
  return(-1);                           /* purecov: inspected */
711
 
}
712
 
 
713
 
 
714
 
/*
715
 
  Remove the predicates pushed down into the subquery
716
 
 
717
 
  SYNOPSIS
718
 
    JOIN::remove_subq_pushed_predicates()
719
 
      where   IN  Must be NULL
720
 
              OUT The remaining WHERE condition, or NULL
721
 
 
722
 
  DESCRIPTION
723
 
    Given that this join will be executed using (unique|index)_subquery,
724
 
    without "checking NULL", remove the predicates that were pushed down
725
 
    into the subquery.
726
 
 
727
 
    If the subquery compares scalar values, we can remove the condition that
728
 
    was wrapped into trig_cond (it will be checked when needed by the subquery
729
 
    engine)
730
 
 
731
 
    If the subquery compares row values, we need to keep the wrapped
732
 
    equalities in the WHERE clause: when the left (outer) tuple has both NULL
733
 
    and non-NULL values, we'll do a full table scan and will rely on the
734
 
    equalities corresponding to non-NULL parts of left tuple to filter out
735
 
    non-matching records.
736
 
 
737
 
    TODO: We can remove the equalities that will be guaranteed to be true by the
738
 
    fact that subquery engine will be using index lookup. This must be done only
739
 
    for cases where there are no conversion errors of significance, e.g. 257
740
 
    that is searched in a byte. But this requires homogenization of the return 
741
 
    codes of all Field*::store() methods.
742
 
*/
743
 
 
744
 
void JOIN::remove_subq_pushed_predicates(Item **where)
745
 
{
746
 
  if (conds->type() == Item::FUNC_ITEM &&
747
 
      ((Item_func *)this->conds)->functype() == Item_func::EQ_FUNC &&
748
 
      ((Item_func *)conds)->arguments()[0]->type() == Item::REF_ITEM &&
749
 
      ((Item_func *)conds)->arguments()[1]->type() == Item::FIELD_ITEM &&
750
 
      test_if_ref ((Item_field *)((Item_func *)conds)->arguments()[1],
751
 
                   ((Item_func *)conds)->arguments()[0]))
752
 
  {
753
 
    *where= 0;
754
 
    return;
755
 
  }
756
 
}
757
 
 
758
 
 
759
282
/*
760
283
  Index lookup-based subquery: save some flags for EXPLAIN output
761
284
 
768
291
  DESCRIPTION
769
292
    For index lookup-based subquery (i.e. one executed with
770
293
    subselect_uniquesubquery_engine or subselect_indexsubquery_engine),
771
 
    check its EXPLAIN output row should contain 
772
 
      "Using index" (TAB_INFO_FULL_SCAN_ON_NULL) 
 
294
    check its EXPLAIN output row should contain
 
295
      "Using index" (TAB_INFO_FULL_SCAN_ON_NULL)
773
296
      "Using Where" (TAB_INFO_USING_WHERE)
774
297
      "Full scan on NULL key" (TAB_INFO_FULL_SCAN_ON_NULL)
775
298
    and set appropriate flags in join_tab->packed_info.
776
299
*/
777
 
 
778
 
static void save_index_subquery_explain_info(JOIN_TAB *join_tab, Item* where)
 
300
void save_index_subquery_explain_info(JoinTable *join_tab, Item* where)
779
301
{
780
302
  join_tab->packed_info= TAB_INFO_HAVE_VALUE;
781
 
  if (join_tab->table->covering_keys.is_set(join_tab->ref.key))
 
303
  if (join_tab->table->covering_keys.test(join_tab->ref.key))
782
304
    join_tab->packed_info |= TAB_INFO_USING_INDEX;
783
305
  if (where)
784
306
    join_tab->packed_info |= TAB_INFO_USING_WHERE;
785
 
  for (uint i = 0; i < join_tab->ref.key_parts; i++)
 
307
  for (uint32_t i = 0; i < join_tab->ref.key_parts; i++)
786
308
  {
787
309
    if (join_tab->ref.cond_guards[i])
788
310
    {
792
314
  }
793
315
}
794
316
 
795
 
 
796
 
 
797
 
 
798
 
/*
799
 
  Check if the table's rowid is included in the temptable
800
 
 
801
 
  SYNOPSIS
802
 
    sj_table_is_included()
803
 
      join      The join
804
 
      join_tab  The table to be checked
805
 
 
806
 
  DESCRIPTION
807
 
    SemiJoinDuplicateElimination: check the table's rowid should be included
808
 
    in the temptable. This is so if
809
 
 
810
 
    1. The table is not embedded within some semi-join nest
811
 
    2. The has been pulled out of a semi-join nest, or
812
 
 
813
 
    3. The table is functionally dependent on some previous table
814
 
 
815
 
    [4. This is also true for constant tables that can't be
816
 
        NULL-complemented but this function is not called for such tables]
817
 
 
818
 
  RETURN
819
 
    true  - Include table's rowid
820
 
    false - Don't
821
 
*/
822
 
 
823
 
static bool sj_table_is_included(JOIN *join, JOIN_TAB *join_tab)
824
 
{
825
 
  if (join_tab->emb_sj_nest)
826
 
    return false;
827
 
  
828
 
  /* Check if this table is functionally dependent on the tables that
829
 
     are within the same outer join nest
830
 
  */
831
 
  TABLE_LIST *embedding= join_tab->table->pos_in_table_list->embedding;
832
 
  if (join_tab->type == JT_EQ_REF)
833
 
  {
834
 
    Table_map_iterator it(join_tab->ref.depend_map & ~PSEUDO_TABLE_BITS);
835
 
    uint idx;
836
 
    while ((idx= it.next_bit())!=Table_map_iterator::BITMAP_END)
837
 
    {
838
 
      JOIN_TAB *ref_tab= join->join_tab + idx;
839
 
      if (embedding == ref_tab->table->pos_in_table_list->embedding)
840
 
        return true;
841
 
    }
842
 
    /* Ok, functionally dependent */
843
 
    return false;
844
 
  }
845
 
  /* Not functionally dependent => need to include*/
846
 
  return true;
847
 
}
848
 
 
849
 
 
850
 
TABLE *create_duplicate_weedout_tmp_table(THD *thd, uint uniq_tuple_length_arg,
851
 
                                          SJ_TMP_TABLE *sjtbl);
852
 
 
853
 
 
854
 
/*
855
 
  Setup the strategies to eliminate semi-join duplicates.
856
 
  
857
 
  SYNOPSIS
858
 
    setup_semijoin_dups_elimination()
859
 
      join           Join to process
860
 
      options        Join options (needed to see if join buffering will be 
861
 
                     used or not)
862
 
      no_jbuf_after  Another bit of information re where join buffering will
863
 
                     be used.
864
 
 
865
 
  DESCRIPTION
866
 
    Setup the strategies to eliminate semi-join duplicates. ATM there are 3
867
 
    strategies:
868
 
 
869
 
    1. DuplicateWeedout (use of temptable to remove duplicates based on rowids
870
 
                         of row combinations)
871
 
    2. FirstMatch (pick only the 1st matching row combination of inner tables)
872
 
    3. InsideOut (scanning the sj-inner table in a way that groups duplicates
873
 
                  together and picking the 1st one)
874
 
    
875
 
    The join order has "duplicate-generating ranges", and every range is
876
 
    served by one strategy or a combination of FirstMatch with with some
877
 
    other strategy.
878
 
    
879
 
    "Duplicate-generating range" is defined as a range within the join order
880
 
    that contains all of the inner tables of a semi-join. All ranges must be
881
 
    disjoint, if tables of several semi-joins are interleaved, then the ranges
882
 
    are joined together, which is equivalent to converting
883
 
      SELECT ... WHERE oe1 IN (SELECT ie1 ...) AND oe2 IN (SELECT ie2 )
884
 
    to
885
 
      SELECT ... WHERE (oe1, oe2) IN (SELECT ie1, ie2 ... ...)
886
 
    .
887
 
 
888
 
    Applicability conditions are as follows:
889
 
 
890
 
    DuplicateWeedout strategy
891
 
    ~~~~~~~~~~~~~~~~~~~~~~~~~
892
 
 
893
 
      (ot|nt)*  [ it ((it|ot|nt)* (it|ot))]  (nt)*
894
 
      +------+  +=========================+  +---+
895
 
        (1)                 (2)               (3)
896
 
 
897
 
       (1) - Prefix of OuterTables (those that participate in 
898
 
             IN-equality and/or are correlated with subquery) and outer 
899
 
             Noncorrelated Tables.
900
 
       (2) - The handled range. The range starts with the first sj-inner
901
 
             table, and covers all sj-inner and outer tables 
902
 
             Within the range,  Inner, Outer, outer Noncorrelated tables
903
 
             may follow in any order.
904
 
       (3) - The suffix of outer Noncorrelated tables.
905
 
    
906
 
    FirstMatch strategy
907
 
    ~~~~~~~~~~~~~~~~~~~
908
 
 
909
 
      (ot|nt)*  [ it ((it|nt)* it) ]  (nt)*
910
 
      +------+  +==================+  +---+
911
 
        (1)             (2)          (3)
912
 
 
913
 
      (1) - Prefix of outer and non-correlated tables
914
 
      (2) - The handled range, which may contain only inner and
915
 
            non-correlated tables.
916
 
      (3) - The suffix of outer Noncorrelated tables.
917
 
 
918
 
    InsideOut strategy 
919
 
    ~~~~~~~~~~~~~~~~~~
920
 
 
921
 
     (ot|ct|nt) [ insideout_tbl (ot|nt|it)* it ]  (ot|nt)*
922
 
     +--------+   +===========+ +=============+   +------+
923
 
        (1)           (2)          (3)              (4)
924
 
     
925
 
      (1) - Prefix that may contain any outer tables. The prefix must contain
926
 
            all the non-trivially correlated outer tables. (non-trivially means
927
 
            that the correlation is not just through the IN-equality).
928
 
      
929
 
      (2) - Inner table for which the InsideOut scan is performed.
930
 
 
931
 
      (3) - The remainder of the duplicate-generating range. It is served by 
932
 
            application of FirstMatch strategy, with the exception that
933
 
            outer IN-correlated tables are considered to be non-correlated.
934
 
 
935
 
      (4) - THe suffix of outer and outer non-correlated tables.
936
 
 
937
 
    If several strategies are applicable, their relative priorities are:
938
 
      1. InsideOut
939
 
      2. FirstMatch 
940
 
      3. DuplicateWeedout
941
 
 
942
 
    This function walks over the join order and sets up the strategies by
943
 
    setting appropriate members in join_tab structures.
944
 
 
945
 
  RETURN
946
 
    false  OK 
947
 
    true   Out of memory error
948
 
*/
949
 
 
950
 
static
951
 
int setup_semijoin_dups_elimination(JOIN *join, uint64_t options, uint no_jbuf_after)
952
 
{
953
 
  table_map cur_map= join->const_table_map | PSEUDO_TABLE_BITS;
954
 
  struct {
955
 
    /* 
956
 
      0 - invalid (EOF marker), 
957
 
      1 - InsideOut, 
958
 
      2 - Temptable (maybe confluent),
959
 
      3 - Temptable with join buffering
960
 
    */
961
 
    uint strategy;
962
 
    uint start_idx; /* Left range bound */
963
 
    uint end_idx;   /* Right range bound */
964
 
    /* 
965
 
      For Temptable strategy: Bitmap of all outer and correlated tables from 
966
 
      all involved join nests.
967
 
    */
968
 
    table_map outer_tables;
969
 
  } dups_ranges [MAX_TABLES];
970
 
 
971
 
  TABLE_LIST *emb_insideout_nest= NULL;
972
 
  table_map emb_sj_map= 0;  /* A bitmap of sj-nests (that is, their sj-inner
973
 
                               tables) whose ranges we're in */
974
 
  table_map emb_outer_tables= 0; /* sj-outer tables for those sj-nests */
975
 
  table_map range_start_map= 0; /* table_map at current range start */
976
 
  bool dealing_with_jbuf= false; /* true <=> table within cur range uses join buf */
977
 
  int cur_range= 0;
978
 
  uint i;
979
 
 
980
 
  /*
981
 
    First pass: locate the duplicate-generating ranges and pick the strategies.
982
 
  */
983
 
  for (i=join->const_tables ; i < join->tables ; i++)
984
 
  {
985
 
    JOIN_TAB *tab=join->join_tab+i;
986
 
    TABLE *table=tab->table;
987
 
    cur_map |= table->map;
988
 
 
989
 
    if (tab->emb_sj_nest) // Encountered an sj-inner table
990
 
    {
991
 
      if (!emb_sj_map)
992
 
      {
993
 
        dups_ranges[cur_range].start_idx= i;
994
 
        range_start_map= cur_map & ~table->map;
995
 
        /*
996
 
          Remember if this is a possible start of range that is covered by
997
 
          the InsideOut strategy (the reason that it is not covered could
998
 
          be that it overlaps with anther semi-join's range. we don't
999
 
          support InsideOut for joined ranges)
1000
 
        */
1001
 
        if (join->best_positions[i].use_insideout_scan)
1002
 
          emb_insideout_nest= tab->emb_sj_nest;
1003
 
      }
1004
 
 
1005
 
      emb_sj_map |= tab->emb_sj_nest->sj_inner_tables;
1006
 
      emb_outer_tables |= tab->emb_sj_nest->nested_join->sj_depends_on;
1007
 
 
1008
 
      if (tab->emb_sj_nest != emb_insideout_nest)
1009
 
      {
1010
 
        /*
1011
 
          Two different semi-joins interleave. This cannot be handled by
1012
 
          InsideOut strategy.
1013
 
        */
1014
 
        emb_insideout_nest= NULL;
1015
 
      }
1016
 
    }
1017
 
 
1018
 
    if (emb_sj_map) /* We're in duplicate-generating range */
1019
 
    {
1020
 
      if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&
1021
 
          tab->type == JT_ALL && tab->use_quick != 2 && !tab->first_inner &&
1022
 
          i <= no_jbuf_after && !dealing_with_jbuf)
1023
 
      {
1024
 
        /*
1025
 
          This table uses join buffering, which makes use of FirstMatch or 
1026
 
          InsideOut strategies impossible for the current and (we assume) 
1027
 
          preceding duplicate-producing ranges.
1028
 
          That is, for the join order:
1029
 
 
1030
 
              x x [ x  x]  x  [x x x]  x  [x x X*  x] x
1031
 
                  |     |     |     |          | \
1032
 
                  +-----+     +-----+          |  join buffering use
1033
 
                     r1          r2         we're here
1034
 
 
1035
 
          we'll have to remove r1 and r2 and use duplicate-elimination
1036
 
          strategy that spans all the tables, starting from the very 1st
1037
 
          one.
1038
 
        */
1039
 
        dealing_with_jbuf= true;
1040
 
        emb_insideout_nest= false;
1041
 
 
1042
 
        /* 
1043
 
          Absorb all preceding duplicate-eliminating ranges. Their strategies
1044
 
          do not matter: 
1045
 
        */
1046
 
        for (int prev_range= 0; prev_range < cur_range; prev_range++)
1047
 
        {
1048
 
          dups_ranges[cur_range].outer_tables |= 
1049
 
            dups_ranges[prev_range].outer_tables;
1050
 
        }
1051
 
        dups_ranges[0].start_idx= 0; /* Will need to start from the 1st table */
1052
 
        dups_ranges[0].outer_tables= dups_ranges[cur_range].outer_tables;
1053
 
        cur_range=  0;
1054
 
      }
1055
 
 
1056
 
      /*
1057
 
        Check if we are at the end of duplicate-producing range. We are if
1058
 
 
1059
 
        1. It's an InsideOut range (which presumes all correlated tables are
1060
 
           in the prefix), and all inner tables are in the join order prefix,
1061
 
           or
1062
 
        2. It's a DuplicateElimination range (possibly covering several
1063
 
           SJ-nests), and all inner, outer, and correlated tables of all 
1064
 
           sj-nests are in the join order prefix.
1065
 
      */
1066
 
      bool end_of_range= false;
1067
 
      if (emb_insideout_nest && 
1068
 
          bitmap_covers(cur_map, emb_insideout_nest->sj_inner_tables))
1069
 
      {
1070
 
        /* Save that this range is handled with InsideOut: */
1071
 
        dups_ranges[cur_range].strategy= 1;
1072
 
        end_of_range= true;
1073
 
      }
1074
 
      else if (bitmap_covers(cur_map, emb_outer_tables | emb_sj_map))
1075
 
      {
1076
 
        /*
1077
 
          This is a complete range to be handled with either DuplicateWeedout 
1078
 
          or FirstMatch
1079
 
        */
1080
 
        dups_ranges[cur_range].strategy= dealing_with_jbuf? 3 : 2;
1081
 
        /* 
1082
 
          This will hold tables from within the range that need to be put 
1083
 
          into the join buffer before we can use the FirstMatch on its tail.
1084
 
        */
1085
 
        dups_ranges[cur_range].outer_tables= emb_outer_tables & 
1086
 
                                             ~range_start_map;
1087
 
        end_of_range= true;
1088
 
      }
1089
 
 
1090
 
      if (end_of_range)
1091
 
      {
1092
 
        dups_ranges[cur_range].end_idx= i+1;
1093
 
        emb_sj_map= emb_outer_tables= 0;
1094
 
        emb_insideout_nest= NULL;
1095
 
        dealing_with_jbuf= false;
1096
 
        dups_ranges[++cur_range].strategy= 0;
1097
 
      }
1098
 
    }
1099
 
  }
1100
 
 
1101
 
  THD *thd= join->thd;
1102
 
  SJ_TMP_TABLE **next_sjtbl_ptr= &join->sj_tmp_tables;
1103
 
  /*
1104
 
    Second pass: setup the chosen strategies    
1105
 
  */
1106
 
  for (int j= 0; j < cur_range; j++)
1107
 
  {
1108
 
    JOIN_TAB *tab=join->join_tab + dups_ranges[j].start_idx;
1109
 
    JOIN_TAB *jump_to;
1110
 
    if (dups_ranges[j].strategy == 1)  // InsideOut strategy
1111
 
    {
1112
 
      tab->insideout_match_tab= join->join_tab + dups_ranges[j].end_idx - 1;
1113
 
      jump_to= tab++;
1114
 
    }
1115
 
    else // DuplicateWeedout strategy
1116
 
    {
1117
 
      SJ_TMP_TABLE::TAB sjtabs[MAX_TABLES];
1118
 
      table_map cur_map= join->const_table_map | PSEUDO_TABLE_BITS;
1119
 
      uint jt_rowid_offset= 0; // # tuple bytes are already occupied (w/o NULL bytes)
1120
 
      uint jt_null_bits= 0;    // # null bits in tuple bytes
1121
 
      SJ_TMP_TABLE::TAB *last_tab= sjtabs;
1122
 
      uint rowid_keep_flags= JOIN_TAB::CALL_POSITION | JOIN_TAB::KEEP_ROWID;
1123
 
      JOIN_TAB *last_outer_tab= tab - 1;
1124
 
      /*
1125
 
        Walk through the range and remember
1126
 
         - tables that need their rowids to be put into temptable
1127
 
         - the last outer table
1128
 
      */
1129
 
      for (; tab < join->join_tab + dups_ranges[j].end_idx; tab++)
1130
 
      {
1131
 
        if (sj_table_is_included(join, tab))
1132
 
        {
1133
 
          last_tab->join_tab= tab;
1134
 
          last_tab->rowid_offset= jt_rowid_offset;
1135
 
          jt_rowid_offset += tab->table->file->ref_length;
1136
 
          if (tab->table->maybe_null)
1137
 
          {
1138
 
            last_tab->null_byte= jt_null_bits / 8;
1139
 
            last_tab->null_bit= jt_null_bits++;
1140
 
          }
1141
 
          last_tab++;
1142
 
          tab->table->prepare_for_position();
1143
 
          tab->rowid_keep_flags= rowid_keep_flags;
1144
 
        }
1145
 
        cur_map |= tab->table->map;
1146
 
        if (!tab->emb_sj_nest && bitmap_covers(cur_map, 
1147
 
                                               dups_ranges[j].outer_tables))
1148
 
          last_outer_tab= tab;
1149
 
      }
1150
 
 
1151
 
      if (jt_rowid_offset) /* Temptable has at least one rowid */
1152
 
      {
1153
 
        SJ_TMP_TABLE *sjtbl;
1154
 
        uint tabs_size= (last_tab - sjtabs) * sizeof(SJ_TMP_TABLE::TAB);
1155
 
        if (!(sjtbl= (SJ_TMP_TABLE*)thd->alloc(sizeof(SJ_TMP_TABLE))) ||
1156
 
            !(sjtbl->tabs= (SJ_TMP_TABLE::TAB*) thd->alloc(tabs_size)))
1157
 
          return(true);
1158
 
        memcpy(sjtbl->tabs, sjtabs, tabs_size);
1159
 
        sjtbl->tabs_end= sjtbl->tabs + (last_tab - sjtabs);
1160
 
        sjtbl->rowid_len= jt_rowid_offset;
1161
 
        sjtbl->null_bits= jt_null_bits;
1162
 
        sjtbl->null_bytes= (jt_null_bits + 7)/8;
1163
 
 
1164
 
        *next_sjtbl_ptr= sjtbl;
1165
 
        next_sjtbl_ptr= &(sjtbl->next);
1166
 
        sjtbl->next= NULL;
1167
 
 
1168
 
        sjtbl->tmp_table= 
1169
 
          create_duplicate_weedout_tmp_table(thd, 
1170
 
                                             sjtbl->rowid_len + 
1171
 
                                             sjtbl->null_bytes,
1172
 
                                             sjtbl);
1173
 
 
1174
 
        join->join_tab[dups_ranges[j].start_idx].flush_weedout_table= sjtbl;
1175
 
        join->join_tab[dups_ranges[j].end_idx - 1].check_weed_out_table= sjtbl;
1176
 
      }
1177
 
      tab= last_outer_tab + 1;
1178
 
      jump_to= last_outer_tab;
1179
 
    }
1180
 
 
1181
 
    /* Create the FirstMatch tail */
1182
 
    for (; tab < join->join_tab + dups_ranges[j].end_idx; tab++)
1183
 
    {
1184
 
      if (tab->emb_sj_nest)
1185
 
        tab->do_firstmatch= jump_to; 
1186
 
      else
1187
 
        jump_to= tab;
1188
 
    }
1189
 
  }
1190
 
  return(false);
1191
 
}
1192
 
 
1193
 
 
1194
 
static void cleanup_sj_tmp_tables(JOIN *join)
1195
 
{
1196
 
  for (SJ_TMP_TABLE *sj_tbl= join->sj_tmp_tables; sj_tbl; 
1197
 
       sj_tbl= sj_tbl->next)
1198
 
  {
1199
 
    if (sj_tbl->tmp_table)
1200
 
    {
1201
 
      free_tmp_table(join->thd, sj_tbl->tmp_table);
1202
 
    }
1203
 
  }
1204
 
  join->sj_tmp_tables= NULL;
1205
 
}
1206
 
 
1207
 
uint make_join_orderinfo(JOIN *join);
1208
 
 
1209
 
/**
1210
 
  global select optimisation.
1211
 
 
1212
 
  @note
1213
 
    error code saved in field 'error'
1214
 
 
1215
 
  @retval
1216
 
    0   success
1217
 
  @retval
1218
 
    1   error
1219
 
*/
1220
 
 
1221
 
int
1222
 
JOIN::optimize()
1223
 
{
1224
 
  // to prevent double initialization on EXPLAIN
1225
 
  if (optimized)
1226
 
    return(0);
1227
 
  optimized= 1;
1228
 
 
1229
 
  thd_proc_info(thd, "optimizing");
1230
 
  row_limit= ((select_distinct || order || group_list) ? HA_POS_ERROR :
1231
 
              unit->select_limit_cnt);
1232
 
  /* select_limit is used to decide if we are likely to scan the whole table */
1233
 
  select_limit= unit->select_limit_cnt;
1234
 
  if (having || (select_options & OPTION_FOUND_ROWS))
1235
 
    select_limit= HA_POS_ERROR;
1236
 
  do_send_rows = (unit->select_limit_cnt) ? 1 : 0;
1237
 
  // Ignore errors of execution if option IGNORE present
1238
 
  if (thd->lex->ignore)
1239
 
    thd->lex->current_select->no_error= 1;
1240
 
 
1241
 
#ifdef HAVE_REF_TO_FIELDS                       // Not done yet
1242
 
  /* Add HAVING to WHERE if possible */
1243
 
  if (having && !group_list && !sum_func_count)
1244
 
  {
1245
 
    if (!conds)
1246
 
    {
1247
 
      conds= having;
1248
 
      having= 0;
1249
 
    }
1250
 
    else if ((conds=new Item_cond_and(conds,having)))
1251
 
    {
1252
 
      /*
1253
 
        Item_cond_and can't be fixed after creation, so we do not check
1254
 
        conds->fixed
1255
 
      */
1256
 
      conds->fix_fields(thd, &conds);
1257
 
      conds->change_ref_to_fields(thd, tables_list);
1258
 
      conds->top_level_item();
1259
 
      having= 0;
1260
 
    }
1261
 
  }
1262
 
#endif
1263
 
  SELECT_LEX *sel= thd->lex->current_select;
1264
 
  if (sel->first_cond_optimization)
1265
 
  {
1266
 
    /*
1267
 
      The following code will allocate the new items in a permanent
1268
 
      MEMROOT for prepared statements and stored procedures.
1269
 
    */
1270
 
    sel->first_cond_optimization= 0;
1271
 
 
1272
 
    /* Convert all outer joins to inner joins if possible */
1273
 
    conds= simplify_joins(this, join_list, conds, true, false);
1274
 
    build_bitmap_for_nested_joins(join_list, 0);
1275
 
  }
1276
 
 
1277
 
  conds= optimize_cond(this, conds, join_list, &cond_value);   
1278
 
  if (thd->is_error())
1279
 
  {
1280
 
    error= 1;
1281
 
    return(1);
1282
 
  }
1283
 
 
1284
 
  {
1285
 
    having= optimize_cond(this, having, join_list, &having_value);
1286
 
    if (thd->is_error())
1287
 
    {
1288
 
      error= 1;
1289
 
      return(1);
1290
 
    }
1291
 
    if (select_lex->where)
1292
 
      select_lex->cond_value= cond_value;
1293
 
    if (select_lex->having)
1294
 
      select_lex->having_value= having_value;
1295
 
 
1296
 
    if (cond_value == Item::COND_FALSE || having_value == Item::COND_FALSE || 
1297
 
        (!unit->select_limit_cnt && !(select_options & OPTION_FOUND_ROWS)))
1298
 
    {                                           /* Impossible cond */
1299
 
      zero_result_cause=  having_value == Item::COND_FALSE ?
1300
 
                           "Impossible HAVING" : "Impossible WHERE";
1301
 
      error= 0;
1302
 
      return(0);
1303
 
    }
1304
 
  }
1305
 
 
1306
 
  /* Optimize count(*), min() and max() */
1307
 
  if (tables_list && tmp_table_param.sum_func_count && ! group_list)
1308
 
  {
1309
 
    int res;
1310
 
    /*
1311
 
      opt_sum_query() returns HA_ERR_KEY_NOT_FOUND if no rows match
1312
 
      to the WHERE conditions,
1313
 
      or 1 if all items were resolved,
1314
 
      or 0, or an error number HA_ERR_...
1315
 
    */
1316
 
    if ((res=opt_sum_query(select_lex->leaf_tables, all_fields, conds)))
1317
 
    {
1318
 
      if (res == HA_ERR_KEY_NOT_FOUND)
1319
 
      {
1320
 
        zero_result_cause= "No matching min/max row";
1321
 
        error=0;
1322
 
        return(0);
1323
 
      }
1324
 
      if (res > 1)
1325
 
      {
1326
 
        error= res;
1327
 
        return(1);
1328
 
      }
1329
 
      if (res < 0)
1330
 
      {
1331
 
        zero_result_cause= "No matching min/max row";
1332
 
        error=0;
1333
 
        return(0);
1334
 
      }
1335
 
      zero_result_cause= "Select tables optimized away";
1336
 
      tables_list= 0;                           // All tables resolved
1337
 
      /*
1338
 
        Extract all table-independent conditions and replace the WHERE
1339
 
        clause with them. All other conditions were computed by opt_sum_query
1340
 
        and the MIN/MAX/COUNT function(s) have been replaced by constants,
1341
 
        so there is no need to compute the whole WHERE clause again.
1342
 
        Notice that make_cond_for_table() will always succeed to remove all
1343
 
        computed conditions, because opt_sum_query() is applicable only to
1344
 
        conjunctions.
1345
 
        Preserve conditions for EXPLAIN.
1346
 
      */
1347
 
      if (conds && !(thd->lex->describe & DESCRIBE_EXTENDED))
1348
 
      {
1349
 
        COND *table_independent_conds=
1350
 
          make_cond_for_table(conds, PSEUDO_TABLE_BITS, 0, 0);
1351
 
        conds= table_independent_conds;
1352
 
      }
1353
 
    }
1354
 
  }
1355
 
  if (!tables_list)
1356
 
  {
1357
 
    error= 0;
1358
 
    return(0);
1359
 
  }
1360
 
  error= -1;                                    // Error is sent to client
1361
 
  sort_by_table= get_sort_by_table(order, group_list, select_lex->leaf_tables);
1362
 
 
1363
 
  /* Calculate how to do the join */
1364
 
  thd_proc_info(thd, "statistics");
1365
 
  if (make_join_statistics(this, select_lex->leaf_tables, conds, &keyuse) ||
1366
 
      thd->is_fatal_error)
1367
 
  {
1368
 
    return(1);
1369
 
  }
1370
 
 
1371
 
  /* Remove distinct if only const tables */
1372
 
  select_distinct= select_distinct && (const_tables != tables);
1373
 
  thd_proc_info(thd, "preparing");
1374
 
  if (result->initialize_tables(this))
1375
 
  {
1376
 
    return(1);                          // error == -1
1377
 
  }
1378
 
  if (const_table_map != found_const_table_map &&
1379
 
      !(select_options & SELECT_DESCRIBE) &&
1380
 
      (!conds ||
1381
 
       !(conds->used_tables() & RAND_TABLE_BIT) ||
1382
 
       select_lex->master_unit() == &thd->lex->unit)) // upper level SELECT
1383
 
  {
1384
 
    zero_result_cause= "no matching row in const table";
1385
 
    error= 0;
1386
 
    return(0);
1387
 
  }
1388
 
  if (!(thd->options & OPTION_BIG_SELECTS) &&
1389
 
      best_read > (double) thd->variables.max_join_size &&
1390
 
      !(select_options & SELECT_DESCRIBE))
1391
 
  {                                             /* purecov: inspected */
1392
 
    my_message(ER_TOO_BIG_SELECT, ER(ER_TOO_BIG_SELECT), MYF(0));
1393
 
    error= -1;
1394
 
    return(1);
1395
 
  }
1396
 
  if (const_tables && !thd->locked_tables &&
1397
 
      !(select_options & SELECT_NO_UNLOCK))
1398
 
    mysql_unlock_some_tables(thd, table, const_tables);
1399
 
  if (!conds && outer_join)
1400
 
  {
1401
 
    /* Handle the case where we have an OUTER JOIN without a WHERE */
1402
 
    conds=new Item_int((int64_t) 1,1);  // Always true
1403
 
  }
1404
 
  select= make_select(*table, const_table_map,
1405
 
                      const_table_map, conds, 1, &error);
1406
 
  if (error)
1407
 
  {                                             /* purecov: inspected */
1408
 
    error= -1;                                  /* purecov: inspected */
1409
 
    return(1);
1410
 
  }
1411
 
  
1412
 
  reset_nj_counters(join_list);
1413
 
  make_outerjoin_info(this);
1414
 
 
1415
 
  /*
1416
 
    Among the equal fields belonging to the same multiple equality
1417
 
    choose the one that is to be retrieved first and substitute
1418
 
    all references to these in where condition for a reference for
1419
 
    the selected field.
1420
 
  */
1421
 
  if (conds)
1422
 
  {
1423
 
    conds= substitute_for_best_equal_field(conds, cond_equal, map2table);
1424
 
    conds->update_used_tables();
1425
 
  }
1426
 
 
1427
 
  /*
1428
 
    Permorm the the optimization on fields evaluation mentioned above
1429
 
    for all on expressions.
1430
 
  */ 
1431
 
  for (JOIN_TAB *tab= join_tab + const_tables; tab < join_tab + tables ; tab++)
1432
 
  {
1433
 
    if (*tab->on_expr_ref)
1434
 
    {
1435
 
      *tab->on_expr_ref= substitute_for_best_equal_field(*tab->on_expr_ref,
1436
 
                                                         tab->cond_equal,
1437
 
                                                         map2table);
1438
 
      (*tab->on_expr_ref)->update_used_tables();
1439
 
    }
1440
 
  }
1441
 
 
1442
 
  if (conds &&!outer_join && const_table_map != found_const_table_map && 
1443
 
      (select_options & SELECT_DESCRIBE) &&
1444
 
      select_lex->master_unit() == &thd->lex->unit) // upper level SELECT
1445
 
  {
1446
 
    conds=new Item_int((int64_t) 0,1);  // Always false
1447
 
  }
1448
 
  if (make_join_select(this, select, conds))
1449
 
  {
1450
 
    zero_result_cause=
1451
 
      "Impossible WHERE noticed after reading const tables";
1452
 
    return(0);                          // error == 0
1453
 
  }
1454
 
 
1455
 
  error= -1;                                    /* if goto err */
1456
 
 
1457
 
  /* Optimize distinct away if possible */
1458
 
  {
1459
 
    ORDER *org_order= order;
1460
 
    order=remove_const(this, order,conds,1, &simple_order);
1461
 
    if (thd->is_error())
1462
 
    {
1463
 
      error= 1;
1464
 
      return(1);
1465
 
    }
1466
 
 
1467
 
    /*
1468
 
      If we are using ORDER BY NULL or ORDER BY const_expression,
1469
 
      return result in any order (even if we are using a GROUP BY)
1470
 
    */
1471
 
    if (!order && org_order)
1472
 
      skip_sort_order= 1;
1473
 
  }
1474
 
  /*
1475
 
     Check if we can optimize away GROUP BY/DISTINCT.
1476
 
     We can do that if there are no aggregate functions, the
1477
 
     fields in DISTINCT clause (if present) and/or columns in GROUP BY
1478
 
     (if present) contain direct references to all key parts of
1479
 
     an unique index (in whatever order) and if the key parts of the
1480
 
     unique index cannot contain NULLs.
1481
 
     Note that the unique keys for DISTINCT and GROUP BY should not
1482
 
     be the same (as long as they are unique).
1483
 
 
1484
 
     The FROM clause must contain a single non-constant table.
1485
 
  */
1486
 
  if (tables - const_tables == 1 && (group_list || select_distinct) &&
1487
 
      !tmp_table_param.sum_func_count &&
1488
 
      (!join_tab[const_tables].select ||
1489
 
       !join_tab[const_tables].select->quick ||
1490
 
       join_tab[const_tables].select->quick->get_type() != 
1491
 
       QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))
1492
 
  {
1493
 
    if (group_list &&
1494
 
       list_contains_unique_index(join_tab[const_tables].table,
1495
 
                                 find_field_in_order_list,
1496
 
                                 (void *) group_list))
1497
 
    {
1498
 
      /*
1499
 
        We have found that grouping can be removed since groups correspond to
1500
 
        only one row anyway, but we still have to guarantee correct result
1501
 
        order. The line below effectively rewrites the query from GROUP BY
1502
 
        <fields> to ORDER BY <fields>. There are two exceptions:
1503
 
        - if skip_sort_order is set (see above), then we can simply skip
1504
 
          GROUP BY;
1505
 
        - we can only rewrite ORDER BY if the ORDER BY fields are 'compatible'
1506
 
          with the GROUP BY ones, i.e. either one is a prefix of another.
1507
 
          We only check if the ORDER BY is a prefix of GROUP BY. In this case
1508
 
          test_if_subpart() copies the ASC/DESC attributes from the original
1509
 
          ORDER BY fields.
1510
 
          If GROUP BY is a prefix of ORDER BY, then it is safe to leave
1511
 
          'order' as is.
1512
 
       */
1513
 
      if (!order || test_if_subpart(group_list, order))
1514
 
          order= skip_sort_order ? 0 : group_list;
1515
 
      /*
1516
 
        If we have an IGNORE INDEX FOR GROUP BY(fields) clause, this must be 
1517
 
        rewritten to IGNORE INDEX FOR ORDER BY(fields).
1518
 
      */
1519
 
      join_tab->table->keys_in_use_for_order_by=
1520
 
        join_tab->table->keys_in_use_for_group_by;
1521
 
      group_list= 0;
1522
 
      group= 0;
1523
 
    }
1524
 
    if (select_distinct &&
1525
 
       list_contains_unique_index(join_tab[const_tables].table,
1526
 
                                 find_field_in_item_list,
1527
 
                                 (void *) &fields_list))
1528
 
    {
1529
 
      select_distinct= 0;
1530
 
    }
1531
 
  }
1532
 
  if (group_list || tmp_table_param.sum_func_count)
1533
 
  {
1534
 
    if (! hidden_group_fields && rollup.state == ROLLUP::STATE_NONE)
1535
 
      select_distinct=0;
1536
 
  }
1537
 
  else if (select_distinct && tables - const_tables == 1)
1538
 
  {
1539
 
    /*
1540
 
      We are only using one table. In this case we change DISTINCT to a
1541
 
      GROUP BY query if:
1542
 
      - The GROUP BY can be done through indexes (no sort) and the ORDER
1543
 
        BY only uses selected fields.
1544
 
        (In this case we can later optimize away GROUP BY and ORDER BY)
1545
 
      - We are scanning the whole table without LIMIT
1546
 
        This can happen if:
1547
 
        - We are using CALC_FOUND_ROWS
1548
 
        - We are using an ORDER BY that can't be optimized away.
1549
 
 
1550
 
      We don't want to use this optimization when we are using LIMIT
1551
 
      because in this case we can just create a temporary table that
1552
 
      holds LIMIT rows and stop when this table is full.
1553
 
    */
1554
 
    JOIN_TAB *tab= &join_tab[const_tables];
1555
 
    bool all_order_fields_used;
1556
 
    if (order)
1557
 
      skip_sort_order= test_if_skip_sort_order(tab, order, select_limit, 1, 
1558
 
        &tab->table->keys_in_use_for_order_by);
1559
 
    if ((group_list=create_distinct_group(thd, select_lex->ref_pointer_array,
1560
 
                                          order, fields_list, all_fields,
1561
 
                                          &all_order_fields_used)))
1562
 
    {
1563
 
      bool skip_group= (skip_sort_order &&
1564
 
        test_if_skip_sort_order(tab, group_list, select_limit, 1, 
1565
 
                                &tab->table->keys_in_use_for_group_by) != 0);
1566
 
      count_field_types(select_lex, &tmp_table_param, all_fields, 0);
1567
 
      if ((skip_group && all_order_fields_used) ||
1568
 
          select_limit == HA_POS_ERROR ||
1569
 
          (order && !skip_sort_order))
1570
 
      {
1571
 
        /*  Change DISTINCT to GROUP BY */
1572
 
        select_distinct= 0;
1573
 
        no_order= !order;
1574
 
        if (all_order_fields_used)
1575
 
        {
1576
 
          if (order && skip_sort_order)
1577
 
          {
1578
 
            /*
1579
 
              Force MySQL to read the table in sorted order to get result in
1580
 
              ORDER BY order.
1581
 
            */
1582
 
            tmp_table_param.quick_group=0;
1583
 
          }
1584
 
          order=0;
1585
 
        }
1586
 
        group=1;                                // For end_write_group
1587
 
      }
1588
 
      else
1589
 
        group_list= 0;
1590
 
    }
1591
 
    else if (thd->is_fatal_error)                       // End of memory
1592
 
      return(1);
1593
 
  }
1594
 
  simple_group= 0;
1595
 
  {
1596
 
    ORDER *old_group_list;
1597
 
    group_list= remove_const(this, (old_group_list= group_list), conds,
1598
 
                             rollup.state == ROLLUP::STATE_NONE,
1599
 
                             &simple_group);
1600
 
    if (thd->is_error())
1601
 
    {
1602
 
      error= 1;
1603
 
      return(1);
1604
 
    }
1605
 
    if (old_group_list && !group_list)
1606
 
      select_distinct= 0;
1607
 
  }
1608
 
  if (!group_list && group)
1609
 
  {
1610
 
    order=0;                                    // The output has only one row
1611
 
    simple_order=1;
1612
 
    select_distinct= 0;                       // No need in distinct for 1 row
1613
 
    group_optimized_away= 1;
1614
 
  }
1615
 
 
1616
 
  calc_group_buffer(this, group_list);
1617
 
  send_group_parts= tmp_table_param.group_parts; /* Save org parts */
1618
 
 
1619
 
  if (test_if_subpart(group_list, order) ||
1620
 
      (!group_list && tmp_table_param.sum_func_count))
1621
 
    order=0;
1622
 
 
1623
 
  // Can't use sort on head table if using row cache
1624
 
  if (full_join)
1625
 
  {
1626
 
    if (group_list)
1627
 
      simple_group=0;
1628
 
    if (order)
1629
 
      simple_order=0;
1630
 
  }
1631
 
 
1632
 
  /*
1633
 
    Check if we need to create a temporary table.
1634
 
    This has to be done if all tables are not already read (const tables)
1635
 
    and one of the following conditions holds:
1636
 
    - We are using DISTINCT (simple distinct's are already optimized away)
1637
 
    - We are using an ORDER BY or GROUP BY on fields not in the first table
1638
 
    - We are using different ORDER BY and GROUP BY orders
1639
 
    - The user wants us to buffer the result.
1640
 
  */
1641
 
  need_tmp= (const_tables != tables &&
1642
 
             ((select_distinct || !simple_order || !simple_group) ||
1643
 
              (group_list && order) ||
1644
 
              test(select_options & OPTION_BUFFER_RESULT)));
1645
 
 
1646
 
  uint no_jbuf_after= make_join_orderinfo(this);
1647
 
  uint64_t select_opts_for_readinfo= 
1648
 
    (select_options & (SELECT_DESCRIBE | SELECT_NO_JOIN_CACHE)) | (0);
1649
 
 
1650
 
  sj_tmp_tables= NULL;
1651
 
  if (!select_lex->sj_nests.is_empty())
1652
 
    setup_semijoin_dups_elimination(this, select_opts_for_readinfo,
1653
 
                                    no_jbuf_after);
1654
 
 
1655
 
  // No cache for MATCH == 'Don't use join buffering when we use MATCH'.
1656
 
  if (make_join_readinfo(this, select_opts_for_readinfo, no_jbuf_after))
1657
 
    return(1);
1658
 
 
1659
 
  /* Create all structures needed for materialized subquery execution. */
1660
 
  if (setup_subquery_materialization())
1661
 
    return(1);
1662
 
 
1663
 
  /*
1664
 
    is this simple IN subquery?
1665
 
  */
1666
 
  if (!group_list && !order &&
1667
 
      unit->item && unit->item->substype() == Item_subselect::IN_SUBS &&
1668
 
      tables == 1 && conds &&
1669
 
      !unit->is_union())
1670
 
  {
1671
 
    if (!having)
1672
 
    {
1673
 
      Item *where= conds;
1674
 
      if (join_tab[0].type == JT_EQ_REF &&
1675
 
          join_tab[0].ref.items[0]->name == in_left_expr_name)
1676
 
      {
1677
 
        remove_subq_pushed_predicates(&where);
1678
 
        save_index_subquery_explain_info(join_tab, where);
1679
 
        join_tab[0].type= JT_UNIQUE_SUBQUERY;
1680
 
        error= 0;
1681
 
        return(unit->item->
1682
 
                    change_engine(new
1683
 
                                  subselect_uniquesubquery_engine(thd,
1684
 
                                                                  join_tab,
1685
 
                                                                  unit->item,
1686
 
                                                                  where)));
1687
 
      }
1688
 
      else if (join_tab[0].type == JT_REF &&
1689
 
               join_tab[0].ref.items[0]->name == in_left_expr_name)
1690
 
      {
1691
 
        remove_subq_pushed_predicates(&where);
1692
 
        save_index_subquery_explain_info(join_tab, where);
1693
 
        join_tab[0].type= JT_INDEX_SUBQUERY;
1694
 
        error= 0;
1695
 
        return(unit->item->
1696
 
                    change_engine(new
1697
 
                                  subselect_indexsubquery_engine(thd,
1698
 
                                                                 join_tab,
1699
 
                                                                 unit->item,
1700
 
                                                                 where,
1701
 
                                                                 NULL,
1702
 
                                                                 0)));
1703
 
      }
1704
 
    } else if (join_tab[0].type == JT_REF_OR_NULL &&
1705
 
               join_tab[0].ref.items[0]->name == in_left_expr_name &&
1706
 
               having->name == in_having_cond)
1707
 
    {
1708
 
      join_tab[0].type= JT_INDEX_SUBQUERY;
1709
 
      error= 0;
1710
 
      conds= remove_additional_cond(conds);
1711
 
      save_index_subquery_explain_info(join_tab, conds);
1712
 
      return(unit->item->
1713
 
                  change_engine(new subselect_indexsubquery_engine(thd,
1714
 
                                                                   join_tab,
1715
 
                                                                   unit->item,
1716
 
                                                                   conds,
1717
 
                                                                   having,
1718
 
                                                                   1)));
1719
 
    }
1720
 
 
1721
 
  }
1722
 
  /*
1723
 
    Need to tell handlers that to play it safe, it should fetch all
1724
 
    columns of the primary key of the tables: this is because MySQL may
1725
 
    build row pointers for the rows, and for all columns of the primary key
1726
 
    the read set has not necessarily been set by the server code.
1727
 
  */
1728
 
  if (need_tmp || select_distinct || group_list || order)
1729
 
  {
1730
 
    for (uint i = const_tables; i < tables; i++)
1731
 
      join_tab[i].table->prepare_for_position();
1732
 
  }
1733
 
 
1734
 
  if (const_tables != tables)
1735
 
  {
1736
 
    /*
1737
 
      Because filesort always does a full table scan or a quick range scan
1738
 
      we must add the removed reference to the select for the table.
1739
 
      We only need to do this when we have a simple_order or simple_group
1740
 
      as in other cases the join is done before the sort.
1741
 
    */
1742
 
    if ((order || group_list) &&
1743
 
        (join_tab[const_tables].type != JT_ALL) &&
1744
 
        (join_tab[const_tables].type != JT_REF_OR_NULL) &&
1745
 
        ((order && simple_order) || (group_list && simple_group)))
1746
 
    {
1747
 
      if (add_ref_to_table_cond(thd,&join_tab[const_tables])) {
1748
 
        return(1);
1749
 
      }
1750
 
    }
1751
 
    
1752
 
    if (!(select_options & SELECT_BIG_RESULT) &&
1753
 
        ((group_list &&
1754
 
          (!simple_group ||
1755
 
           !test_if_skip_sort_order(&join_tab[const_tables], group_list,
1756
 
                                    unit->select_limit_cnt, 0, 
1757
 
                                    &join_tab[const_tables].table->
1758
 
                                    keys_in_use_for_group_by))) ||
1759
 
         select_distinct) &&
1760
 
        tmp_table_param.quick_group)
1761
 
    {
1762
 
      need_tmp=1; simple_order=simple_group=0;  // Force tmp table without sort
1763
 
    }
1764
 
    if (order)
1765
 
    {
1766
 
      /*
1767
 
        Force using of tmp table if sorting by a SP or UDF function due to
1768
 
        their expensive and probably non-deterministic nature.
1769
 
      */
1770
 
      for (ORDER *tmp_order= order; tmp_order ; tmp_order=tmp_order->next)
1771
 
      {
1772
 
        Item *item= *tmp_order->item;
1773
 
        if (item->is_expensive())
1774
 
        {
1775
 
          /* Force tmp table without sort */
1776
 
          need_tmp=1; simple_order=simple_group=0;
1777
 
          break;
1778
 
        }
1779
 
      }
1780
 
    }
1781
 
  }
1782
 
 
1783
 
  tmp_having= having;
1784
 
  if (select_options & SELECT_DESCRIBE)
1785
 
  {
1786
 
    error= 0;
1787
 
    return(0);
1788
 
  }
1789
 
  having= 0;
1790
 
 
1791
 
  /*
1792
 
    The loose index scan access method guarantees that all grouping or
1793
 
    duplicate row elimination (for distinct) is already performed
1794
 
    during data retrieval, and that all MIN/MAX functions are already
1795
 
    computed for each group. Thus all MIN/MAX functions should be
1796
 
    treated as regular functions, and there is no need to perform
1797
 
    grouping in the main execution loop.
1798
 
    Notice that currently loose index scan is applicable only for
1799
 
    single table queries, thus it is sufficient to test only the first
1800
 
    join_tab element of the plan for its access method.
1801
 
  */
1802
 
  if (join_tab->is_using_loose_index_scan())
1803
 
    tmp_table_param.precomputed_group_by= true;
1804
 
 
1805
 
  /* Create a tmp table if distinct or if the sort is too complicated */
1806
 
  if (need_tmp)
1807
 
  {
1808
 
    thd_proc_info(thd, "Creating tmp table");
1809
 
 
1810
 
    init_items_ref_array();
1811
 
 
1812
 
    tmp_table_param.hidden_field_count= (all_fields.elements -
1813
 
                                         fields_list.elements);
1814
 
    ORDER *tmp_group= ((!simple_group && !(test_flags & TEST_NO_KEY_GROUP)) ? group_list :
1815
 
                                                             (ORDER*) 0);
1816
 
    /*
1817
 
      Pushing LIMIT to the temporary table creation is not applicable
1818
 
      when there is ORDER BY or GROUP BY or there is no GROUP BY, but
1819
 
      there are aggregate functions, because in all these cases we need
1820
 
      all result rows.
1821
 
    */
1822
 
    ha_rows tmp_rows_limit= ((order == 0 || skip_sort_order) &&
1823
 
                             !tmp_group &&
1824
 
                             !thd->lex->current_select->with_sum_func) ?
1825
 
                            select_limit : HA_POS_ERROR;
1826
 
 
1827
 
    if (!(exec_tmp_table1=
1828
 
          create_tmp_table(thd, &tmp_table_param, all_fields,
1829
 
                           tmp_group,
1830
 
                           group_list ? 0 : select_distinct,
1831
 
                           group_list && simple_group,
1832
 
                           select_options,
1833
 
                           tmp_rows_limit,
1834
 
                           (char *) "")))
1835
 
                {
1836
 
      return(1);
1837
 
    }
1838
 
 
1839
 
    /*
1840
 
      We don't have to store rows in temp table that doesn't match HAVING if:
1841
 
      - we are sorting the table and writing complete group rows to the
1842
 
        temp table.
1843
 
      - We are using DISTINCT without resolving the distinct as a GROUP BY
1844
 
        on all columns.
1845
 
      
1846
 
      If having is not handled here, it will be checked before the row
1847
 
      is sent to the client.
1848
 
    */    
1849
 
    if (tmp_having && 
1850
 
        (sort_and_group || (exec_tmp_table1->distinct && !group_list)))
1851
 
      having= tmp_having;
1852
 
 
1853
 
    /* if group or order on first table, sort first */
1854
 
    if (group_list && simple_group)
1855
 
    {
1856
 
      thd_proc_info(thd, "Sorting for group");
1857
 
      if (create_sort_index(thd, this, group_list,
1858
 
                            HA_POS_ERROR, HA_POS_ERROR, false) ||
1859
 
          alloc_group_fields(this, group_list) ||
1860
 
          make_sum_func_list(all_fields, fields_list, 1) ||
1861
 
          setup_sum_funcs(thd, sum_funcs))
1862
 
      {
1863
 
        return(1);
1864
 
      }
1865
 
      group_list=0;
1866
 
    }
1867
 
    else
1868
 
    {
1869
 
      if (make_sum_func_list(all_fields, fields_list, 0) ||
1870
 
          setup_sum_funcs(thd, sum_funcs))
1871
 
      {
1872
 
        return(1);
1873
 
      }
1874
 
 
1875
 
      if (!group_list && ! exec_tmp_table1->distinct && order && simple_order)
1876
 
      {
1877
 
        thd_proc_info(thd, "Sorting for order");
1878
 
        if (create_sort_index(thd, this, order,
1879
 
                              HA_POS_ERROR, HA_POS_ERROR, true))
1880
 
        {
1881
 
          return(1);
1882
 
        }
1883
 
        order=0;
1884
 
      }
1885
 
    }
1886
 
    
1887
 
    /*
1888
 
      Optimize distinct when used on some of the tables
1889
 
      SELECT DISTINCT t1.a FROM t1,t2 WHERE t1.b=t2.b
1890
 
      In this case we can stop scanning t2 when we have found one t1.a
1891
 
    */
1892
 
 
1893
 
    if (exec_tmp_table1->distinct)
1894
 
    {
1895
 
      table_map used_tables= thd->used_tables;
1896
 
      JOIN_TAB *last_join_tab= join_tab+tables-1;
1897
 
      do
1898
 
      {
1899
 
        if (used_tables & last_join_tab->table->map)
1900
 
          break;
1901
 
        last_join_tab->not_used_in_distinct=1;
1902
 
      } while (last_join_tab-- != join_tab);
1903
 
      /* Optimize "select distinct b from t1 order by key_part_1 limit #" */
1904
 
      if (order && skip_sort_order)
1905
 
      {
1906
 
        /* Should always succeed */
1907
 
        if (test_if_skip_sort_order(&join_tab[const_tables],
1908
 
                                    order, unit->select_limit_cnt, 0, 
1909
 
                                    &join_tab[const_tables].table->
1910
 
                                      keys_in_use_for_order_by))
1911
 
          order=0;
1912
 
      }
1913
 
    }
1914
 
 
1915
 
    /* 
1916
 
      If this join belongs to an uncacheable subquery save 
1917
 
      the original join 
1918
 
    */
1919
 
    if (select_lex->uncacheable && !is_top_level_join() &&
1920
 
        init_save_join_tab())
1921
 
      return(-1);                         /* purecov: inspected */
1922
 
  }
1923
 
 
1924
 
  error= 0;
1925
 
  return(0);
1926
 
}
1927
 
 
1928
 
 
1929
 
/**
1930
 
  Restore values in temporary join.
1931
 
*/
1932
 
void JOIN::restore_tmp()
1933
 
{
1934
 
  memcpy(tmp_join, this, (size_t) sizeof(JOIN));
1935
 
}
1936
 
 
1937
 
 
1938
 
int
1939
 
JOIN::reinit()
1940
 
{
1941
 
  unit->offset_limit_cnt= (ha_rows)(select_lex->offset_limit ?
1942
 
                                    select_lex->offset_limit->val_uint() :
1943
 
                                    0ULL);
1944
 
 
1945
 
  first_record= 0;
1946
 
 
1947
 
  if (exec_tmp_table1)
1948
 
  {
1949
 
    exec_tmp_table1->file->extra(HA_EXTRA_RESET_STATE);
1950
 
    exec_tmp_table1->file->ha_delete_all_rows();
1951
 
    free_io_cache(exec_tmp_table1);
1952
 
    filesort_free_buffers(exec_tmp_table1,0);
1953
 
  }
1954
 
  if (exec_tmp_table2)
1955
 
  {
1956
 
    exec_tmp_table2->file->extra(HA_EXTRA_RESET_STATE);
1957
 
    exec_tmp_table2->file->ha_delete_all_rows();
1958
 
    free_io_cache(exec_tmp_table2);
1959
 
    filesort_free_buffers(exec_tmp_table2,0);
1960
 
  }
1961
 
  if (items0)
1962
 
    set_items_ref_array(items0);
1963
 
 
1964
 
  if (join_tab_save)
1965
 
    memcpy(join_tab, join_tab_save, sizeof(JOIN_TAB) * tables);
1966
 
 
1967
 
  if (tmp_join)
1968
 
    restore_tmp();
1969
 
 
1970
 
  /* Reset of sum functions */
1971
 
  if (sum_funcs)
1972
 
  {
1973
 
    Item_sum *func, **func_ptr= sum_funcs;
1974
 
    while ((func= *(func_ptr++)))
1975
 
      func->clear();
1976
 
  }
1977
 
 
1978
 
  return(0);
1979
 
}
1980
 
 
1981
 
/**
1982
 
   @brief Save the original join layout
1983
 
      
1984
 
   @details Saves the original join layout so it can be reused in 
1985
 
   re-execution and for EXPLAIN.
1986
 
             
1987
 
   @return Operation status
1988
 
   @retval 0      success.
1989
 
   @retval 1      error occurred.
1990
 
*/
1991
 
 
1992
 
bool
1993
 
JOIN::init_save_join_tab()
1994
 
{
1995
 
  if (!(tmp_join= (JOIN*)thd->alloc(sizeof(JOIN))))
1996
 
    return 1;                                  /* purecov: inspected */
1997
 
  error= 0;                                    // Ensure that tmp_join.error= 0
1998
 
  restore_tmp();
1999
 
  return 0;
2000
 
}
2001
 
 
2002
 
 
2003
 
bool
2004
 
JOIN::save_join_tab()
2005
 
{
2006
 
  if (!join_tab_save && select_lex->master_unit()->uncacheable)
2007
 
  {
2008
 
    if (!(join_tab_save= (JOIN_TAB*)thd->memdup((uchar*) join_tab,
2009
 
                                                sizeof(JOIN_TAB) * tables)))
2010
 
      return 1;
2011
 
  }
2012
 
  return 0;
2013
 
}
2014
 
 
2015
 
 
2016
 
/**
2017
 
  Exec select.
2018
 
 
2019
 
  @todo
2020
 
    Note, that create_sort_index calls test_if_skip_sort_order and may
2021
 
    finally replace sorting with index scan if there is a LIMIT clause in
2022
 
    the query.  It's never shown in EXPLAIN!
2023
 
 
2024
 
  @todo
2025
 
    When can we have here thd->net.report_error not zero?
2026
 
*/
2027
 
void
2028
 
JOIN::exec()
2029
 
{
2030
 
  List<Item> *columns_list= &fields_list;
2031
 
  int      tmp_error;
2032
 
 
2033
 
  thd_proc_info(thd, "executing");
2034
 
  error= 0;
2035
 
  (void) result->prepare2(); // Currently, this cannot fail.
2036
 
 
2037
 
  if (!tables_list && (tables || !select_lex->with_sum_func))
2038
 
  {                                           // Only test of functions
2039
 
    if (select_options & SELECT_DESCRIBE)
2040
 
      select_describe(this, false, false, false,
2041
 
                      (zero_result_cause?zero_result_cause:"No tables used"));
2042
 
    else
2043
 
    {
2044
 
      result->send_fields(*columns_list,
2045
 
                          Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
2046
 
      /*
2047
 
        We have to test for 'conds' here as the WHERE may not be constant
2048
 
        even if we don't have any tables for prepared statements or if
2049
 
        conds uses something like 'rand()'.
2050
 
      */
2051
 
      if (cond_value != Item::COND_FALSE &&
2052
 
          (!conds || conds->val_int()) &&
2053
 
          (!having || having->val_int()))
2054
 
      {
2055
 
        if (do_send_rows && result->send_data(fields_list))
2056
 
          error= 1;
2057
 
        else
2058
 
        {
2059
 
          error= (int) result->send_eof();
2060
 
          send_records= ((select_options & OPTION_FOUND_ROWS) ? 1 :
2061
 
                         thd->sent_row_count);
2062
 
        }
2063
 
      }
2064
 
      else
2065
 
      {
2066
 
        error=(int) result->send_eof();
2067
 
        send_records= 0;
2068
 
      }
2069
 
    }
2070
 
    /* Single select (without union) always returns 0 or 1 row */
2071
 
    thd->limit_found_rows= send_records;
2072
 
    thd->examined_row_count= 0;
2073
 
    return;
2074
 
  }
2075
 
  /*
2076
 
    Don't reset the found rows count if there're no tables as
2077
 
    FOUND_ROWS() may be called. Never reset the examined row count here.
2078
 
    It must be accumulated from all join iterations of all join parts.
2079
 
  */
2080
 
  if (tables)
2081
 
    thd->limit_found_rows= 0;
2082
 
 
2083
 
  if (zero_result_cause)
2084
 
  {
2085
 
    (void) return_zero_rows(this, result, select_lex->leaf_tables,
2086
 
                            *columns_list,
2087
 
                            send_row_on_empty_set(),
2088
 
                            select_options,
2089
 
                            zero_result_cause,
2090
 
                            having);
2091
 
    return;
2092
 
  }
2093
 
 
2094
 
  if ((this->select_lex->options & OPTION_SCHEMA_TABLE) &&
2095
 
      get_schema_tables_result(this, PROCESSED_BY_JOIN_EXEC))
2096
 
    return;
2097
 
 
2098
 
  if (select_options & SELECT_DESCRIBE)
2099
 
  {
2100
 
    /*
2101
 
      Check if we managed to optimize ORDER BY away and don't use temporary
2102
 
      table to resolve ORDER BY: in that case, we only may need to do
2103
 
      filesort for GROUP BY.
2104
 
    */
2105
 
    if (!order && !no_order && (!skip_sort_order || !need_tmp))
2106
 
    {
2107
 
      /*
2108
 
        Reset 'order' to 'group_list' and reinit variables describing
2109
 
        'order'
2110
 
      */
2111
 
      order= group_list;
2112
 
      simple_order= simple_group;
2113
 
      skip_sort_order= 0;
2114
 
    }
2115
 
    if (order && 
2116
 
        (order != group_list || !(select_options & SELECT_BIG_RESULT)) &&
2117
 
        (const_tables == tables ||
2118
 
         ((simple_order || skip_sort_order) &&
2119
 
          test_if_skip_sort_order(&join_tab[const_tables], order,
2120
 
                                  select_limit, 0, 
2121
 
                                  &join_tab[const_tables].table->
2122
 
                                    keys_in_use_for_query))))
2123
 
      order=0;
2124
 
    having= tmp_having;
2125
 
    select_describe(this, need_tmp,
2126
 
                    order != 0 && !skip_sort_order,
2127
 
                    select_distinct,
2128
 
                    !tables ? "No tables used" : NullS);
2129
 
    return;
2130
 
  }
2131
 
 
2132
 
  JOIN *curr_join= this;
2133
 
  List<Item> *curr_all_fields= &all_fields;
2134
 
  List<Item> *curr_fields_list= &fields_list;
2135
 
  TABLE *curr_tmp_table= 0;
2136
 
  /*
2137
 
    Initialize examined rows here because the values from all join parts
2138
 
    must be accumulated in examined_row_count. Hence every join
2139
 
    iteration must count from zero.
2140
 
  */
2141
 
  curr_join->examined_rows= 0;
2142
 
 
2143
 
  /* Create a tmp table if distinct or if the sort is too complicated */
2144
 
  if (need_tmp)
2145
 
  {
2146
 
    if (tmp_join)
2147
 
    {
2148
 
      /*
2149
 
        We are in a non cacheable sub query. Get the saved join structure
2150
 
        after optimization.
2151
 
        (curr_join may have been modified during last exection and we need
2152
 
        to reset it)
2153
 
      */
2154
 
      curr_join= tmp_join;
2155
 
    }
2156
 
    curr_tmp_table= exec_tmp_table1;
2157
 
 
2158
 
    /* Copy data to the temporary table */
2159
 
    thd_proc_info(thd, "Copying to tmp table");
2160
 
    if (!curr_join->sort_and_group &&
2161
 
        curr_join->const_tables != curr_join->tables)
2162
 
      curr_join->join_tab[curr_join->const_tables].sorted= 0;
2163
 
    if ((tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))
2164
 
    {
2165
 
      error= tmp_error;
2166
 
      return;
2167
 
    }
2168
 
    curr_tmp_table->file->info(HA_STATUS_VARIABLE);
2169
 
    
2170
 
    if (curr_join->having)
2171
 
      curr_join->having= curr_join->tmp_having= 0; // Allready done
2172
 
    
2173
 
    /* Change sum_fields reference to calculated fields in tmp_table */
2174
 
    curr_join->all_fields= *curr_all_fields;
2175
 
    if (!items1)
2176
 
    {
2177
 
      items1= items0 + all_fields.elements;
2178
 
      if (sort_and_group || curr_tmp_table->group)
2179
 
      {
2180
 
        if (change_to_use_tmp_fields(thd, items1,
2181
 
                                     tmp_fields_list1, tmp_all_fields1,
2182
 
                                     fields_list.elements, all_fields))
2183
 
          return;
2184
 
      }
2185
 
      else
2186
 
      {
2187
 
        if (change_refs_to_tmp_fields(thd, items1,
2188
 
                                      tmp_fields_list1, tmp_all_fields1,
2189
 
                                      fields_list.elements, all_fields))
2190
 
          return;
2191
 
      }
2192
 
      curr_join->tmp_all_fields1= tmp_all_fields1;
2193
 
      curr_join->tmp_fields_list1= tmp_fields_list1;
2194
 
      curr_join->items1= items1;
2195
 
    }
2196
 
    curr_all_fields= &tmp_all_fields1;
2197
 
    curr_fields_list= &tmp_fields_list1;
2198
 
    curr_join->set_items_ref_array(items1);
2199
 
    
2200
 
    if (sort_and_group || curr_tmp_table->group)
2201
 
    {
2202
 
      curr_join->tmp_table_param.field_count+= 
2203
 
        curr_join->tmp_table_param.sum_func_count+
2204
 
        curr_join->tmp_table_param.func_count;
2205
 
      curr_join->tmp_table_param.sum_func_count= 
2206
 
        curr_join->tmp_table_param.func_count= 0;
2207
 
    }
2208
 
    else
2209
 
    {
2210
 
      curr_join->tmp_table_param.field_count+= 
2211
 
        curr_join->tmp_table_param.func_count;
2212
 
      curr_join->tmp_table_param.func_count= 0;
2213
 
    }
2214
 
    
2215
 
    if (curr_tmp_table->group)
2216
 
    {                                           // Already grouped
2217
 
      if (!curr_join->order && !curr_join->no_order && !skip_sort_order)
2218
 
        curr_join->order= curr_join->group_list;  /* order by group */
2219
 
      curr_join->group_list= 0;
2220
 
    }
2221
 
    
2222
 
    /*
2223
 
      If we have different sort & group then we must sort the data by group
2224
 
      and copy it to another tmp table
2225
 
      This code is also used if we are using distinct something
2226
 
      we haven't been able to store in the temporary table yet
2227
 
      like SEC_TO_TIME(SUM(...)).
2228
 
    */
2229
 
 
2230
 
    if ((curr_join->group_list && (!test_if_subpart(curr_join->group_list, curr_join->order) || curr_join->select_distinct)) || (curr_join->select_distinct && curr_join->tmp_table_param.using_indirect_summary_function))
2231
 
    {                                   /* Must copy to another table */
2232
 
      /* Free first data from old join */
2233
 
      curr_join->join_free();
2234
 
      if (make_simple_join(curr_join, curr_tmp_table))
2235
 
        return;
2236
 
      calc_group_buffer(curr_join, group_list);
2237
 
      count_field_types(select_lex, &curr_join->tmp_table_param,
2238
 
                        curr_join->tmp_all_fields1,
2239
 
                        curr_join->select_distinct && !curr_join->group_list);
2240
 
      curr_join->tmp_table_param.hidden_field_count= 
2241
 
        (curr_join->tmp_all_fields1.elements-
2242
 
         curr_join->tmp_fields_list1.elements);
2243
 
      
2244
 
      
2245
 
      if (exec_tmp_table2)
2246
 
        curr_tmp_table= exec_tmp_table2;
2247
 
      else
2248
 
      {
2249
 
        /* group data to new table */
2250
 
 
2251
 
        /*
2252
 
          If the access method is loose index scan then all MIN/MAX
2253
 
          functions are precomputed, and should be treated as regular
2254
 
          functions. See extended comment in JOIN::exec.
2255
 
        */
2256
 
        if (curr_join->join_tab->is_using_loose_index_scan())
2257
 
          curr_join->tmp_table_param.precomputed_group_by= true;
2258
 
 
2259
 
        if (!(curr_tmp_table=
2260
 
              exec_tmp_table2= create_tmp_table(thd,
2261
 
                                                &curr_join->tmp_table_param,
2262
 
                                                *curr_all_fields,
2263
 
                                                (ORDER*) 0,
2264
 
                                                curr_join->select_distinct && 
2265
 
                                                !curr_join->group_list,
2266
 
                                                1, curr_join->select_options,
2267
 
                                                HA_POS_ERROR,
2268
 
                                                (char *) "")))
2269
 
          return;
2270
 
        curr_join->exec_tmp_table2= exec_tmp_table2;
2271
 
      }
2272
 
      if (curr_join->group_list)
2273
 
      {
2274
 
        thd_proc_info(thd, "Creating sort index");
2275
 
        if (curr_join->join_tab == join_tab && save_join_tab())
2276
 
        {
2277
 
          return;
2278
 
        }
2279
 
        if (create_sort_index(thd, curr_join, curr_join->group_list,
2280
 
                              HA_POS_ERROR, HA_POS_ERROR, false) ||
2281
 
            make_group_fields(this, curr_join))
2282
 
        {
2283
 
          return;
2284
 
        }
2285
 
        sortorder= curr_join->sortorder;
2286
 
      }
2287
 
      
2288
 
      thd_proc_info(thd, "Copying to group table");
2289
 
      tmp_error= -1;
2290
 
      if (curr_join != this)
2291
 
      {
2292
 
        if (sum_funcs2)
2293
 
        {
2294
 
          curr_join->sum_funcs= sum_funcs2;
2295
 
          curr_join->sum_funcs_end= sum_funcs_end2; 
2296
 
        }
2297
 
        else
2298
 
        {
2299
 
          curr_join->alloc_func_list();
2300
 
          sum_funcs2= curr_join->sum_funcs;
2301
 
          sum_funcs_end2= curr_join->sum_funcs_end;
2302
 
        }
2303
 
      }
2304
 
      if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list,
2305
 
                                        1, true))
2306
 
        return;
2307
 
      curr_join->group_list= 0;
2308
 
      if (!curr_join->sort_and_group &&
2309
 
          curr_join->const_tables != curr_join->tables)
2310
 
        curr_join->join_tab[curr_join->const_tables].sorted= 0;
2311
 
      if (setup_sum_funcs(curr_join->thd, curr_join->sum_funcs) ||
2312
 
          (tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))
2313
 
      {
2314
 
        error= tmp_error;
2315
 
        return;
2316
 
      }
2317
 
      end_read_record(&curr_join->join_tab->read_record);
2318
 
      curr_join->const_tables= curr_join->tables; // Mark free for cleanup()
2319
 
      curr_join->join_tab[0].table= 0;           // Table is freed
2320
 
      
2321
 
      // No sum funcs anymore
2322
 
      if (!items2)
2323
 
      {
2324
 
        items2= items1 + all_fields.elements;
2325
 
        if (change_to_use_tmp_fields(thd, items2,
2326
 
                                     tmp_fields_list2, tmp_all_fields2, 
2327
 
                                     fields_list.elements, tmp_all_fields1))
2328
 
          return;
2329
 
        curr_join->tmp_fields_list2= tmp_fields_list2;
2330
 
        curr_join->tmp_all_fields2= tmp_all_fields2;
2331
 
      }
2332
 
      curr_fields_list= &curr_join->tmp_fields_list2;
2333
 
      curr_all_fields= &curr_join->tmp_all_fields2;
2334
 
      curr_join->set_items_ref_array(items2);
2335
 
      curr_join->tmp_table_param.field_count+= 
2336
 
        curr_join->tmp_table_param.sum_func_count;
2337
 
      curr_join->tmp_table_param.sum_func_count= 0;
2338
 
    }
2339
 
    if (curr_tmp_table->distinct)
2340
 
      curr_join->select_distinct=0;             /* Each row is unique */
2341
 
    
2342
 
    curr_join->join_free();                     /* Free quick selects */
2343
 
    if (curr_join->select_distinct && ! curr_join->group_list)
2344
 
    {
2345
 
      thd_proc_info(thd, "Removing duplicates");
2346
 
      if (curr_join->tmp_having)
2347
 
        curr_join->tmp_having->update_used_tables();
2348
 
      if (remove_duplicates(curr_join, curr_tmp_table,
2349
 
                            *curr_fields_list, curr_join->tmp_having))
2350
 
        return;
2351
 
      curr_join->tmp_having=0;
2352
 
      curr_join->select_distinct=0;
2353
 
    }
2354
 
    curr_tmp_table->reginfo.lock_type= TL_UNLOCK;
2355
 
    if (make_simple_join(curr_join, curr_tmp_table))
2356
 
      return;
2357
 
    calc_group_buffer(curr_join, curr_join->group_list);
2358
 
    count_field_types(select_lex, &curr_join->tmp_table_param, 
2359
 
                      *curr_all_fields, 0);
2360
 
    
2361
 
  }
2362
 
  
2363
 
  if (curr_join->group || curr_join->tmp_table_param.sum_func_count)
2364
 
  {
2365
 
    if (make_group_fields(this, curr_join))
2366
 
    {
2367
 
      return;
2368
 
    }
2369
 
    if (!items3)
2370
 
    {
2371
 
      if (!items0)
2372
 
        init_items_ref_array();
2373
 
      items3= ref_pointer_array + (all_fields.elements*4);
2374
 
      setup_copy_fields(thd, &curr_join->tmp_table_param,
2375
 
                        items3, tmp_fields_list3, tmp_all_fields3,
2376
 
                        curr_fields_list->elements, *curr_all_fields);
2377
 
      tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;
2378
 
      tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;
2379
 
      tmp_table_param.save_copy_field_end=
2380
 
        curr_join->tmp_table_param.copy_field_end;
2381
 
      curr_join->tmp_all_fields3= tmp_all_fields3;
2382
 
      curr_join->tmp_fields_list3= tmp_fields_list3;
2383
 
    }
2384
 
    else
2385
 
    {
2386
 
      curr_join->tmp_table_param.copy_funcs= tmp_table_param.save_copy_funcs;
2387
 
      curr_join->tmp_table_param.copy_field= tmp_table_param.save_copy_field;
2388
 
      curr_join->tmp_table_param.copy_field_end=
2389
 
        tmp_table_param.save_copy_field_end;
2390
 
    }
2391
 
    curr_fields_list= &tmp_fields_list3;
2392
 
    curr_all_fields= &tmp_all_fields3;
2393
 
    curr_join->set_items_ref_array(items3);
2394
 
 
2395
 
    if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list,
2396
 
                                      1, true) || 
2397
 
        setup_sum_funcs(curr_join->thd, curr_join->sum_funcs) ||
2398
 
        thd->is_fatal_error)
2399
 
      return;
2400
 
  }
2401
 
  if (curr_join->group_list || curr_join->order)
2402
 
  {
2403
 
    thd_proc_info(thd, "Sorting result");
2404
 
    /* If we have already done the group, add HAVING to sorted table */
2405
 
    if (curr_join->tmp_having && ! curr_join->group_list && 
2406
 
        ! curr_join->sort_and_group)
2407
 
    {
2408
 
      // Some tables may have been const
2409
 
      curr_join->tmp_having->update_used_tables();
2410
 
      JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables];
2411
 
      table_map used_tables= (curr_join->const_table_map |
2412
 
                              curr_table->table->map);
2413
 
 
2414
 
      Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having,
2415
 
                                                 used_tables,
2416
 
                                                 used_tables, 0);
2417
 
      if (sort_table_cond)
2418
 
      {
2419
 
        if (!curr_table->select)
2420
 
          if (!(curr_table->select= new SQL_SELECT))
2421
 
            return;
2422
 
        if (!curr_table->select->cond)
2423
 
          curr_table->select->cond= sort_table_cond;
2424
 
        else                                    // This should never happen
2425
 
        {
2426
 
          if (!(curr_table->select->cond=
2427
 
                new Item_cond_and(curr_table->select->cond,
2428
 
                                  sort_table_cond)))
2429
 
            return;
2430
 
          /*
2431
 
            Item_cond_and do not need fix_fields for execution, its parameters
2432
 
            are fixed or do not need fix_fields, too
2433
 
          */
2434
 
          curr_table->select->cond->quick_fix_field();
2435
 
        }
2436
 
        curr_table->select_cond= curr_table->select->cond;
2437
 
        curr_table->select_cond->top_level_item();
2438
 
        curr_join->tmp_having= make_cond_for_table(curr_join->tmp_having,
2439
 
                                                   ~ (table_map) 0,
2440
 
                                                   ~used_tables, 0);
2441
 
      }
2442
 
    }
2443
 
    {
2444
 
      if (group)
2445
 
        curr_join->select_limit= HA_POS_ERROR;
2446
 
      else
2447
 
      {
2448
 
        /*
2449
 
          We can abort sorting after thd->select_limit rows if we there is no
2450
 
          WHERE clause for any tables after the sorted one.
2451
 
        */
2452
 
        JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables+1];
2453
 
        JOIN_TAB *end_table= &curr_join->join_tab[curr_join->tables];
2454
 
        for (; curr_table < end_table ; curr_table++)
2455
 
        {
2456
 
          /*
2457
 
            table->keyuse is set in the case there was an original WHERE clause
2458
 
            on the table that was optimized away.
2459
 
          */
2460
 
          if (curr_table->select_cond ||
2461
 
              (curr_table->keyuse && !curr_table->first_inner))
2462
 
          {
2463
 
            /* We have to sort all rows */
2464
 
            curr_join->select_limit= HA_POS_ERROR;
2465
 
            break;
2466
 
          }
2467
 
        }
2468
 
      }
2469
 
      if (curr_join->join_tab == join_tab && save_join_tab())
2470
 
      {
2471
 
        return;
2472
 
      }
2473
 
      /*
2474
 
        Here we sort rows for ORDER BY/GROUP BY clause, if the optimiser
2475
 
        chose FILESORT to be faster than INDEX SCAN or there is no 
2476
 
        suitable index present.
2477
 
        Note, that create_sort_index calls test_if_skip_sort_order and may
2478
 
        finally replace sorting with index scan if there is a LIMIT clause in
2479
 
        the query. XXX: it's never shown in EXPLAIN!
2480
 
        OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.
2481
 
      */
2482
 
      if (create_sort_index(thd, curr_join,
2483
 
                            curr_join->group_list ? 
2484
 
                            curr_join->group_list : curr_join->order,
2485
 
                            curr_join->select_limit,
2486
 
                            (select_options & OPTION_FOUND_ROWS ?
2487
 
                             HA_POS_ERROR : unit->select_limit_cnt),
2488
 
                            curr_join->group_list ? true : false))
2489
 
        return;
2490
 
      sortorder= curr_join->sortorder;
2491
 
      if (curr_join->const_tables != curr_join->tables &&
2492
 
          !curr_join->join_tab[curr_join->const_tables].table->sort.io_cache)
2493
 
      {
2494
 
        /*
2495
 
          If no IO cache exists for the first table then we are using an
2496
 
          INDEX SCAN and no filesort. Thus we should not remove the sorted
2497
 
          attribute on the INDEX SCAN.
2498
 
        */
2499
 
        skip_sort_order= 1;
2500
 
      }
2501
 
    }
2502
 
  }
2503
 
  /* XXX: When can we have here thd->is_error() not zero? */
2504
 
  if (thd->is_error())
2505
 
  {
2506
 
    error= thd->is_error();
2507
 
    return;
2508
 
  }
2509
 
  curr_join->having= curr_join->tmp_having;
2510
 
  curr_join->fields= curr_fields_list;
2511
 
 
2512
 
  {
2513
 
    thd_proc_info(thd, "Sending data");
2514
 
    result->send_fields(*curr_fields_list,
2515
 
                        Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);
2516
 
    error= do_select(curr_join, curr_fields_list, NULL);
2517
 
    thd->limit_found_rows= curr_join->send_records;
2518
 
  }
2519
 
 
2520
 
  /* Accumulate the counts from all join iterations of all join parts. */
2521
 
  thd->examined_row_count+= curr_join->examined_rows;
2522
 
 
2523
 
  /* 
2524
 
    With EXPLAIN EXTENDED we have to restore original ref_array
2525
 
    for a derived table which is always materialized.
2526
 
    Otherwise we would not be able to print the query  correctly.
2527
 
  */ 
2528
 
  if (items0 &&
2529
 
      (thd->lex->describe & DESCRIBE_EXTENDED) &&
2530
 
      select_lex->linkage == DERIVED_TABLE_TYPE)      
2531
 
    set_items_ref_array(items0);
2532
 
 
2533
 
  return;
2534
 
}
2535
 
 
2536
 
 
2537
 
/**
2538
 
  Clean up join.
2539
 
 
2540
 
  @return
2541
 
    Return error that hold JOIN.
2542
 
*/
2543
 
 
2544
 
int
2545
 
JOIN::destroy()
2546
 
{
2547
 
  select_lex->join= 0;
2548
 
 
2549
 
  if (tmp_join)
2550
 
  {
2551
 
    if (join_tab != tmp_join->join_tab)
2552
 
    {
2553
 
      JOIN_TAB *tab, *end;
2554
 
      for (tab= join_tab, end= tab+tables ; tab != end ; tab++)
2555
 
        tab->cleanup();
2556
 
    }
2557
 
    tmp_join->tmp_join= 0;
2558
 
    tmp_table_param.copy_field=0;
2559
 
    return(tmp_join->destroy());
2560
 
  }
2561
 
  cond_equal= 0;
2562
 
 
2563
 
  cleanup(1);
2564
 
  if (exec_tmp_table1)
2565
 
    free_tmp_table(thd, exec_tmp_table1);
2566
 
  if (exec_tmp_table2)
2567
 
    free_tmp_table(thd, exec_tmp_table2);
2568
 
  delete select;
2569
 
  delete_dynamic(&keyuse);
2570
 
  return(error);
2571
 
}
2572
 
 
2573
 
 
2574
 
 
2575
317
/**
2576
318
  An entry point to single-unit select (a select without UNION).
2577
319
 
2578
 
  @param thd                  thread handler
 
320
  @param session                  thread Cursor
2579
321
  @param rref_pointer_array   a reference to ref_pointer_array of
2580
322
                              the top-level select_lex for this query
2581
323
  @param tables               list of all tables used in this query.
2582
324
                              The tables have been pre-opened.
2583
 
  @param wild_num             number of wildcards used in the top level 
 
325
  @param wild_num             number of wildcards used in the top level
2584
326
                              select of this query.
2585
327
                              For example statement
2586
328
                              SELECT *, t1.*, catalog.t2.* FROM t0, t1, t2;
2591
333
                              for a, b and c in this list.
2592
334
  @param conds                top level item of an expression representing
2593
335
                              WHERE clause of the top level select
2594
 
  @param og_num               total number of ORDER BY and GROUP BY clauses
 
336
  @param og_num               total number of order_st BY and GROUP BY clauses
2595
337
                              arguments
2596
 
  @param order                linked list of ORDER BY agruments
 
338
  @param order                linked list of order_st BY agruments
2597
339
  @param group                linked list of GROUP BY arguments
2598
340
  @param having               top level item of HAVING expression
2599
 
  @param proc_param           list of PROCEDUREs
2600
341
  @param select_options       select options (BIG_RESULT, etc)
2601
342
  @param result               an instance of result set handling class.
2602
343
                              This object is responsible for send result
2603
344
                              set rows to the client or inserting them
2604
345
                              into a table.
2605
 
  @param select_lex           the only SELECT_LEX of this query
 
346
  @param select_lex           the only Select_Lex of this query
2606
347
  @param unit                 top-level UNIT of this query
2607
348
                              UNIT is an artificial object created by the
2608
349
                              parser for every SELECT clause.
2615
356
  @retval
2616
357
    true   an error
2617
358
*/
2618
 
 
2619
 
bool
2620
 
mysql_select(THD *thd, Item ***rref_pointer_array,
2621
 
             TABLE_LIST *tables, uint wild_num, List<Item> &fields,
2622
 
             COND *conds, uint og_num,  ORDER *order, ORDER *group,
2623
 
             Item *having, ORDER *proc_param, uint64_t select_options,
2624
 
             select_result *result, SELECT_LEX_UNIT *unit,
2625
 
             SELECT_LEX *select_lex)
 
359
bool mysql_select(Session *session,
 
360
                  Item ***rref_pointer_array,
 
361
                        TableList *tables, 
 
362
                  uint32_t wild_num, 
 
363
                  List<Item> &fields,
 
364
                        COND *conds, 
 
365
                  uint32_t og_num,  
 
366
                  order_st *order, 
 
367
                  order_st *group,
 
368
                        Item *having, 
 
369
                  uint64_t select_options,
 
370
                        select_result *result, 
 
371
                  Select_Lex_Unit *unit,
 
372
                        Select_Lex *select_lex)
2626
373
{
2627
374
  bool err;
2628
375
  bool free_join= 1;
2637
384
      creation
2638
385
    */
2639
386
    if (select_lex->linkage != DERIVED_TABLE_TYPE ||
2640
 
        (select_options & SELECT_DESCRIBE))
 
387
        (select_options & SELECT_DESCRIBE))
2641
388
    {
2642
389
      if (select_lex->linkage != GLOBAL_OPTIONS_TYPE)
2643
390
      {
2644
 
        //here is EXPLAIN of subselect or derived table
2645
 
        if (join->change_result(result))
2646
 
        {
2647
 
          return(true);
2648
 
        }
 
391
        //here is EXPLAIN of subselect or derived table
 
392
        if (join->change_result(result))
 
393
        {
 
394
          return(true);
 
395
        }
2649
396
      }
2650
397
      else
2651
398
      {
2652
399
        if ((err= join->prepare(rref_pointer_array, tables, wild_num,
2653
 
                               conds, og_num, order, group, having, proc_param,
2654
 
                               select_lex, unit)))
2655
 
        {
2656
 
          goto err;
2657
 
        }
 
400
                               conds, og_num, order, group, having, select_lex, unit)))
 
401
        {
 
402
          goto err;
 
403
        }
2658
404
      }
2659
405
    }
2660
406
    free_join= 0;
2662
408
  }
2663
409
  else
2664
410
  {
2665
 
    if (!(join= new JOIN(thd, fields, select_options, result)))
2666
 
        return(true);
2667
 
    thd_proc_info(thd, "init");
2668
 
    thd->used_tables=0;                         // Updated by setup_fields
 
411
    if (!(join= new JOIN(session, fields, select_options, result)))
 
412
      return(true);
 
413
    session->set_proc_info("init");
 
414
    session->used_tables=0;                         // Updated by setup_fields
2669
415
    if ((err= join->prepare(rref_pointer_array, tables, wild_num,
2670
 
                           conds, og_num, order, group, having, proc_param,
 
416
                           conds, og_num, order, group, having,
2671
417
                           select_lex, unit)) == true)
2672
418
    {
2673
419
      goto err;
2674
420
    }
2675
421
  }
2676
422
 
2677
 
  /* dump_TABLE_LIST_graph(select_lex, select_lex->leaf_tables); */
2678
 
  if (join->flatten_subqueries())
2679
 
  {
2680
 
    err= 1;
2681
 
    goto err;
2682
 
  }
2683
 
  /* dump_TABLE_LIST_struct(select_lex, select_lex->leaf_tables); */
2684
 
 
2685
423
  if ((err= join->optimize()))
2686
424
  {
2687
425
    goto err;                                   // 1
2688
426
  }
2689
427
 
2690
 
  if (thd->lex->describe & DESCRIBE_EXTENDED)
 
428
  if (session->lex->describe & DESCRIBE_EXTENDED)
2691
429
  {
2692
430
    join->conds_history= join->conds;
2693
431
    join->having_history= (join->having?join->having:join->tmp_having);
2694
432
  }
2695
433
 
2696
 
  if (thd->is_error())
 
434
  if (session->is_error())
2697
435
    goto err;
2698
436
 
2699
437
  join->exec();
2700
438
 
2701
 
  if (thd->lex->describe & DESCRIBE_EXTENDED)
 
439
  if (session->lex->describe & DESCRIBE_EXTENDED)
2702
440
  {
2703
441
    select_lex->where= join->conds_history;
2704
442
    select_lex->having= join->having_history;
2707
445
err:
2708
446
  if (free_join)
2709
447
  {
2710
 
    thd_proc_info(thd, "end");
 
448
    session->set_proc_info("end");
2711
449
    err|= select_lex->cleanup();
2712
 
    return(err || thd->is_error());
 
450
    return(err || session->is_error());
2713
451
  }
2714
452
  return(join->error);
2715
453
}
2716
454
 
2717
 
 
2718
 
int subq_sj_candidate_cmp(Item_in_subselect* const *el1, 
2719
 
                          Item_in_subselect* const *el2)
2720
 
{
2721
 
  return ((*el1)->sj_convert_priority < (*el2)->sj_convert_priority) ? 1 : 
2722
 
         ( ((*el1)->sj_convert_priority == (*el2)->sj_convert_priority)? 0 : -1);
2723
 
}
2724
 
 
2725
 
 
2726
 
inline Item * and_items(Item* cond, Item *item)
 
455
inline Item *and_items(Item* cond, Item *item)
2727
456
{
2728
457
  return (cond? (new Item_cond_and(cond, item)) : item);
2729
458
}
2730
459
 
2731
 
 
2732
 
static TABLE_LIST *alloc_join_nest(THD *thd)
2733
 
{
2734
 
  TABLE_LIST *tbl;
2735
 
  if (!(tbl= (TABLE_LIST*) thd->calloc(ALIGN_SIZE(sizeof(TABLE_LIST))+
2736
 
                                       sizeof(NESTED_JOIN))))
2737
 
    return NULL;
2738
 
  tbl->nested_join= (NESTED_JOIN*) ((uchar*)tbl + 
2739
 
                                    ALIGN_SIZE(sizeof(TABLE_LIST)));
2740
 
  return tbl;
2741
 
}
2742
 
 
2743
 
 
2744
 
void fix_list_after_tbl_changes(SELECT_LEX *new_parent, List<TABLE_LIST> *tlist)
2745
 
{
2746
 
  List_iterator<TABLE_LIST> it(*tlist);
2747
 
  TABLE_LIST *table;
 
460
static void fix_list_after_tbl_changes(Select_Lex *new_parent, List<TableList> *tlist)
 
461
{
 
462
  List_iterator<TableList> it(*tlist);
 
463
  TableList *table;
2748
464
  while ((table= it++))
2749
465
  {
2750
466
    if (table->on_expr)
2754
470
  }
2755
471
}
2756
472
 
2757
 
 
2758
 
/*
2759
 
  Convert a subquery predicate into a TABLE_LIST semi-join nest
2760
 
 
2761
 
  SYNOPSIS
2762
 
    convert_subq_to_sj()
2763
 
       parent_join  Parent join, the one that has subq_pred in its WHERE/ON 
2764
 
                    clause
2765
 
       subq_pred    Subquery predicate to be converted
2766
 
  
2767
 
  DESCRIPTION
2768
 
    Convert a subquery predicate into a TABLE_LIST semi-join nest. All the 
2769
 
    prerequisites are already checked, so the conversion is always successfull.
2770
 
 
2771
 
    Prepared Statements: the transformation is permanent:
2772
 
     - Changes in TABLE_LIST structures are naturally permanent
2773
 
     - Item tree changes are performed on statement MEM_ROOT:
2774
 
        = we activate statement MEM_ROOT 
2775
 
        = this function is called before the first fix_prepare_information
2776
 
          call.
2777
 
 
2778
 
    This is intended because the criteria for subquery-to-sj conversion remain
2779
 
    constant for the lifetime of the Prepared Statement.
2780
 
 
2781
 
  RETURN
2782
 
    false  OK
2783
 
    true   Out of memory error
2784
 
*/
2785
 
 
2786
 
bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)
2787
 
{
2788
 
  SELECT_LEX *parent_lex= parent_join->select_lex;
2789
 
  TABLE_LIST *emb_tbl_nest= NULL;
2790
 
  List<TABLE_LIST> *emb_join_list= &parent_lex->top_join_list;
2791
 
  THD *thd= parent_join->thd;
2792
 
 
2793
 
  /*
2794
 
    1. Find out where to put the predicate into.
2795
 
     Note: for "t1 LEFT JOIN t2" this will be t2, a leaf.
2796
 
  */
2797
 
  if ((void*)subq_pred->expr_join_nest != (void*)1)
2798
 
  {
2799
 
    if (subq_pred->expr_join_nest->nested_join)
2800
 
    {
2801
 
      /*
2802
 
        We're dealing with
2803
 
 
2804
 
          ... [LEFT] JOIN  ( ... ) ON (subquery AND whatever) ...
2805
 
 
2806
 
        The sj-nest will be inserted into the brackets nest.
2807
 
      */
2808
 
      emb_tbl_nest=  subq_pred->expr_join_nest;
2809
 
      emb_join_list= &emb_tbl_nest->nested_join->join_list;
2810
 
    }
2811
 
    else if (!subq_pred->expr_join_nest->outer_join)
2812
 
    {
2813
 
      /*
2814
 
        We're dealing with
2815
 
 
2816
 
          ... INNER JOIN tblX ON (subquery AND whatever) ...
2817
 
 
2818
 
        The sj-nest will be tblX's "sibling", i.e. another child of its
2819
 
        parent. This is ok because tblX is joined as an inner join.
2820
 
      */
2821
 
      emb_tbl_nest= subq_pred->expr_join_nest->embedding;
2822
 
      if (emb_tbl_nest)
2823
 
        emb_join_list= &emb_tbl_nest->nested_join->join_list;
2824
 
    }
2825
 
    else if (!subq_pred->expr_join_nest->nested_join)
2826
 
    {
2827
 
      TABLE_LIST *outer_tbl= subq_pred->expr_join_nest;      
2828
 
      TABLE_LIST *wrap_nest;
2829
 
      /*
2830
 
        We're dealing with
2831
 
 
2832
 
          ... LEFT JOIN tbl ON (on_expr AND subq_pred) ...
2833
 
 
2834
 
        we'll need to convert it into:
2835
 
 
2836
 
          ... LEFT JOIN ( tbl SJ (subq_tables) ) ON (on_expr AND subq_pred) ...
2837
 
                        |                      |
2838
 
                        |<----- wrap_nest ---->|
2839
 
        
2840
 
        Q:  other subqueries may be pointing to this element. What to do?
2841
 
        A1: simple solution: copy *subq_pred->expr_join_nest= *parent_nest.
2842
 
            But we'll need to fix other pointers.
2843
 
        A2: Another way: have TABLE_LIST::next_ptr so the following
2844
 
            subqueries know the table has been nested.
2845
 
        A3: changes in the TABLE_LIST::outer_join will make everything work
2846
 
            automatically.
2847
 
      */
2848
 
      if (!(wrap_nest= alloc_join_nest(parent_join->thd)))
2849
 
      {
2850
 
        return(true);
2851
 
      }
2852
 
      wrap_nest->embedding= outer_tbl->embedding;
2853
 
      wrap_nest->join_list= outer_tbl->join_list;
2854
 
      wrap_nest->alias= (char*) "(sj-wrap)";
2855
 
 
2856
 
      wrap_nest->nested_join->join_list.empty();
2857
 
      wrap_nest->nested_join->join_list.push_back(outer_tbl);
2858
 
 
2859
 
      outer_tbl->embedding= wrap_nest;
2860
 
      outer_tbl->join_list= &wrap_nest->nested_join->join_list;
2861
 
 
2862
 
      /*
2863
 
        wrap_nest will take place of outer_tbl, so move the outer join flag
2864
 
        and on_expr
2865
 
      */
2866
 
      wrap_nest->outer_join= outer_tbl->outer_join;
2867
 
      outer_tbl->outer_join= 0;
2868
 
 
2869
 
      wrap_nest->on_expr= outer_tbl->on_expr;
2870
 
      outer_tbl->on_expr= NULL;
2871
 
 
2872
 
      List_iterator<TABLE_LIST> li(*wrap_nest->join_list);
2873
 
      TABLE_LIST *tbl;
2874
 
      while ((tbl= li++))
2875
 
      {
2876
 
        if (tbl == outer_tbl)
2877
 
        {
2878
 
          li.replace(wrap_nest);
2879
 
          break;
2880
 
        }
2881
 
      }
2882
 
      /*
2883
 
        Ok now wrap_nest 'contains' outer_tbl and we're ready to add the 
2884
 
        semi-join nest into it
2885
 
      */
2886
 
      emb_join_list= &wrap_nest->nested_join->join_list;
2887
 
      emb_tbl_nest=  wrap_nest;
2888
 
    }
2889
 
  }
2890
 
 
2891
 
  TABLE_LIST *sj_nest;
2892
 
  NESTED_JOIN *nested_join;
2893
 
  if (!(sj_nest= alloc_join_nest(parent_join->thd)))
2894
 
  {
2895
 
    return(true);
2896
 
  }
2897
 
  nested_join= sj_nest->nested_join;
2898
 
 
2899
 
  sj_nest->join_list= emb_join_list;
2900
 
  sj_nest->embedding= emb_tbl_nest;
2901
 
  sj_nest->alias= (char*) "(sj-nest)";
2902
 
  /* Nests do not participate in those 'chains', so: */
2903
 
  /* sj_nest->next_leaf= sj_nest->next_local= sj_nest->next_global == NULL*/
2904
 
  emb_join_list->push_back(sj_nest);
2905
 
 
2906
 
  /* 
2907
 
    nested_join->used_tables and nested_join->not_null_tables are
2908
 
    initialized in simplify_joins().
2909
 
  */
2910
 
  
2911
 
  /* 
2912
 
    2. Walk through subquery's top list and set 'embedding' to point to the
2913
 
       sj-nest.
2914
 
  */
2915
 
  st_select_lex *subq_lex= subq_pred->unit->first_select();
2916
 
  nested_join->join_list.empty();
2917
 
  List_iterator_fast<TABLE_LIST> li(subq_lex->top_join_list);
2918
 
  TABLE_LIST *tl, *last_leaf;
2919
 
  while ((tl= li++))
2920
 
  {
2921
 
    tl->embedding= sj_nest;
2922
 
    tl->join_list= &nested_join->join_list;
2923
 
    nested_join->join_list.push_back(tl);
2924
 
  }
2925
 
  
2926
 
  /*
2927
 
    Reconnect the next_leaf chain.
2928
 
    TODO: Do we have to put subquery's tables at the end of the chain?
2929
 
          Inserting them at the beginning would be a bit faster.
2930
 
    NOTE: We actually insert them at the front! That's because the order is
2931
 
          reversed in this list.
2932
 
  */
2933
 
  for (tl= parent_lex->leaf_tables; tl->next_leaf; tl= tl->next_leaf) {};
2934
 
  tl->next_leaf= subq_lex->leaf_tables;
2935
 
  last_leaf= tl;
2936
 
 
2937
 
  /*
2938
 
    Same as above for next_local chain
2939
 
    (a theory: a next_local chain always starts with ::leaf_tables
2940
 
     because view's tables are inserted after the view)
2941
 
  */
2942
 
  for (tl= parent_lex->leaf_tables; tl->next_local; tl= tl->next_local) {};
2943
 
  tl->next_local= subq_lex->leaf_tables;
2944
 
 
2945
 
  /* A theory: no need to re-connect the next_global chain */
2946
 
 
2947
 
  /* 3. Remove the original subquery predicate from the WHERE/ON */
2948
 
 
2949
 
  // The subqueries were replaced for Item_int(1) earlier
2950
 
  subq_pred->exec_method= Item_in_subselect::SEMI_JOIN; // for subsequent executions
2951
 
  /*TODO: also reset the 'with_subselect' there. */
2952
 
 
2953
 
  /* n. Adjust the parent_join->tables counter */
2954
 
  uint table_no= parent_join->tables;
2955
 
  /* n. Walk through child's tables and adjust table->map */
2956
 
  for (tl= subq_lex->leaf_tables; tl; tl= tl->next_leaf, table_no++)
2957
 
  {
2958
 
    tl->table->tablenr= table_no;
2959
 
    tl->table->map= ((table_map)1) << table_no;
2960
 
    SELECT_LEX *old_sl= tl->select_lex;
2961
 
    tl->select_lex= parent_join->select_lex; 
2962
 
    for(TABLE_LIST *emb= tl->embedding; emb && emb->select_lex == old_sl; emb= emb->embedding)
2963
 
      emb->select_lex= parent_join->select_lex;
2964
 
  }
2965
 
  parent_join->tables += subq_lex->join->tables;
2966
 
 
2967
 
  /* 
2968
 
    Put the subquery's WHERE into semi-join's sj_on_expr
2969
 
    Add the subquery-induced equalities too.
2970
 
  */
2971
 
  SELECT_LEX *save_lex= thd->lex->current_select;
2972
 
  thd->lex->current_select=subq_lex;
2973
 
  if (!subq_pred->left_expr->fixed &&
2974
 
       subq_pred->left_expr->fix_fields(thd, &subq_pred->left_expr))
2975
 
    return(true);
2976
 
  thd->lex->current_select=save_lex;
2977
 
 
2978
 
  sj_nest->nested_join->sj_corr_tables= subq_pred->used_tables();
2979
 
  sj_nest->nested_join->sj_depends_on=  subq_pred->used_tables() |
2980
 
                                        subq_pred->left_expr->used_tables();
2981
 
  sj_nest->sj_on_expr= subq_lex->where;
2982
 
 
2983
 
  /*
2984
 
    Create the IN-equalities and inject them into semi-join's ON expression.
2985
 
    Additionally, for InsideOut strategy
2986
 
     - Record the number of IN-equalities.
2987
 
     - Create list of pointers to (oe1, ..., ieN). We'll need the list to
2988
 
       see which of the expressions are bound and which are not (for those
2989
 
       we'll produce a distinct stream of (ie_i1,...ie_ik).
2990
 
 
2991
 
       (TODO: can we just create a list of pointers and hope the expressions
2992
 
       will not substitute themselves on fix_fields()? or we need to wrap
2993
 
       them into Item_direct_view_refs and store pointers to those. The
2994
 
       pointers to Item_direct_view_refs are guaranteed to be stable as 
2995
 
       Item_direct_view_refs doesn't substitute itself with anything in 
2996
 
       Item_direct_view_ref::fix_fields.
2997
 
  */
2998
 
  sj_nest->sj_in_exprs= subq_pred->left_expr->cols();
2999
 
  sj_nest->nested_join->sj_outer_expr_list.empty();
3000
 
 
3001
 
  if (subq_pred->left_expr->cols() == 1)
3002
 
  {
3003
 
    nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr);
3004
 
 
3005
 
    Item *item_eq= new Item_func_eq(subq_pred->left_expr, 
3006
 
                                    subq_lex->ref_pointer_array[0]);
3007
 
    item_eq->name= (char*)subq_sj_cond_name;
3008
 
    sj_nest->sj_on_expr= and_items(sj_nest->sj_on_expr, item_eq);
3009
 
  }
3010
 
  else
3011
 
  {
3012
 
    for (uint i= 0; i < subq_pred->left_expr->cols(); i++)
3013
 
    {
3014
 
      nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr->
3015
 
                                                element_index(i));
3016
 
      Item *item_eq= 
3017
 
        new Item_func_eq(subq_pred->left_expr->element_index(i), 
3018
 
                         subq_lex->ref_pointer_array[i]);
3019
 
      item_eq->name= (char*)subq_sj_cond_name + (i % 64);
3020
 
      sj_nest->sj_on_expr= and_items(sj_nest->sj_on_expr, item_eq);
3021
 
    }
3022
 
  }
3023
 
  /* Fix the created equality and AND */
3024
 
  sj_nest->sj_on_expr->fix_fields(parent_join->thd, &sj_nest->sj_on_expr);
3025
 
 
3026
 
  /*
3027
 
    Walk through sj nest's WHERE and ON expressions and call
3028
 
    item->fix_table_changes() for all items.
3029
 
  */
3030
 
  sj_nest->sj_on_expr->fix_after_pullout(parent_lex, &sj_nest->sj_on_expr);
3031
 
  fix_list_after_tbl_changes(parent_lex, &sj_nest->nested_join->join_list);
3032
 
 
3033
 
 
3034
 
  /* Unlink the child select_lex so it doesn't show up in EXPLAIN: */
3035
 
  subq_lex->master_unit()->exclude_level();
3036
 
 
3037
 
  /* Inject sj_on_expr into the parent's WHERE or ON */
3038
 
  if (emb_tbl_nest)
3039
 
  {
3040
 
    emb_tbl_nest->on_expr= and_items(emb_tbl_nest->on_expr, 
3041
 
                                     sj_nest->sj_on_expr);
3042
 
    emb_tbl_nest->on_expr->fix_fields(parent_join->thd, &emb_tbl_nest->on_expr);
3043
 
  }
3044
 
  else
3045
 
  {
3046
 
    /* Inject into the WHERE */
3047
 
    parent_join->conds= and_items(parent_join->conds, sj_nest->sj_on_expr);
3048
 
    parent_join->conds->fix_fields(parent_join->thd, &parent_join->conds);
3049
 
    parent_join->select_lex->where= parent_join->conds;
3050
 
  }
3051
 
 
3052
 
  return(false);
3053
 
}
3054
 
 
3055
 
 
3056
 
/*
3057
 
  Convert candidate subquery predicates to semi-joins
3058
 
 
3059
 
  SYNOPSIS
3060
 
    JOIN::flatten_subqueries()
3061
 
 
3062
 
  DESCRIPTION
3063
 
    Convert candidate subquery predicates to semi-joins.
3064
 
 
3065
 
  RETURN 
3066
 
    false  OK
3067
 
    true   Error
3068
 
*/
3069
 
 
3070
 
bool JOIN::flatten_subqueries()
3071
 
{
3072
 
  Item_in_subselect **in_subq;
3073
 
  Item_in_subselect **in_subq_end;
3074
 
 
3075
 
  if (sj_subselects.elements() == 0)
3076
 
    return(false);
3077
 
 
3078
 
  /* 1. Fix children subqueries */
3079
 
  for (in_subq= sj_subselects.front(), in_subq_end= sj_subselects.back(); 
3080
 
       in_subq != in_subq_end; in_subq++)
3081
 
  {
3082
 
    JOIN *child_join= (*in_subq)->unit->first_select()->join;
3083
 
    child_join->outer_tables = child_join->tables;
3084
 
    if (child_join->flatten_subqueries())
3085
 
      return(true);
3086
 
    (*in_subq)->sj_convert_priority= 
3087
 
      (*in_subq)->is_correlated * MAX_TABLES + child_join->outer_tables;
3088
 
  }
3089
 
 
3090
 
  //dump_TABLE_LIST_struct(select_lex, select_lex->leaf_tables);
3091
 
  /* 
3092
 
    2. Pick which subqueries to convert:
3093
 
      sort the subquery array
3094
 
      - prefer correlated subqueries over uncorrelated;
3095
 
      - prefer subqueries that have greater number of outer tables;
3096
 
  */
3097
 
  sj_subselects.sort(subq_sj_candidate_cmp);
3098
 
  // #tables-in-parent-query + #tables-in-subquery < MAX_TABLES
3099
 
  /* Replace all subqueries to be flattened with Item_int(1) */
3100
 
  for (in_subq= sj_subselects.front(); 
3101
 
       in_subq != in_subq_end && 
3102
 
       tables + ((*in_subq)->sj_convert_priority % MAX_TABLES) < MAX_TABLES;
3103
 
       in_subq++)
3104
 
  {
3105
 
    if (replace_where_subcondition(this, *in_subq, new Item_int(1), false))
3106
 
      return(true);
3107
 
  }
3108
 
 
3109
 
  for (in_subq= sj_subselects.front(); 
3110
 
       in_subq != in_subq_end && 
3111
 
       tables + ((*in_subq)->sj_convert_priority % MAX_TABLES) < MAX_TABLES;
3112
 
       in_subq++)
3113
 
  {
3114
 
    if (convert_subq_to_sj(this, *in_subq))
3115
 
      return(true);
3116
 
  }
3117
 
 
3118
 
  /* 3. Finalize those we didn't convert */
3119
 
  for (; in_subq!= in_subq_end; in_subq++)
3120
 
  {
3121
 
    JOIN *child_join= (*in_subq)->unit->first_select()->join;
3122
 
    Item_subselect::trans_res res;
3123
 
    (*in_subq)->changed= 0;
3124
 
    (*in_subq)->fixed= 0;
3125
 
    res= (*in_subq)->select_transformer(child_join);
3126
 
    if (res == Item_subselect::RES_ERROR)
3127
 
      return(true);
3128
 
 
3129
 
    (*in_subq)->changed= 1;
3130
 
    (*in_subq)->fixed= 1;
3131
 
 
3132
 
    Item *substitute= (*in_subq)->substitution;
3133
 
    bool do_fix_fields= !(*in_subq)->substitution->fixed;
3134
 
    if (replace_where_subcondition(this, *in_subq, substitute, do_fix_fields))
3135
 
      return(true);
3136
 
 
3137
 
    //if ((*in_subq)->fix_fields(thd, (*in_subq)->ref_ptr))
3138
 
    //  return(true);
3139
 
  }
3140
 
  sj_subselects.clear();
3141
 
  return(false);
3142
 
}
3143
 
 
3144
 
 
3145
 
/**
3146
 
  Setup for execution all subqueries of a query, for which the optimizer
3147
 
  chose hash semi-join.
3148
 
 
3149
 
  @details Iterate over all subqueries of the query, and if they are under an
3150
 
  IN predicate, and the optimizer chose to compute it via hash semi-join:
3151
 
  - try to initialize all data structures needed for the materialized execution
3152
 
    of the IN predicate,
3153
 
  - if this fails, then perform the IN=>EXISTS transformation which was
3154
 
    previously blocked during JOIN::prepare.
3155
 
 
3156
 
  This method is part of the "code generation" query processing phase.
3157
 
 
3158
 
  This phase must be called after substitute_for_best_equal_field() because
3159
 
  that function may replace items with other items from a multiple equality,
3160
 
  and we need to reference the correct items in the index access method of the
3161
 
  IN predicate.
3162
 
 
3163
 
  @return Operation status
3164
 
  @retval false     success.
3165
 
  @retval true      error occurred.
3166
 
*/
3167
 
 
3168
 
bool JOIN::setup_subquery_materialization()
3169
 
{
3170
 
  for (SELECT_LEX_UNIT *un= select_lex->first_inner_unit(); un;
3171
 
       un= un->next_unit())
3172
 
  {
3173
 
    for (SELECT_LEX *sl= un->first_select(); sl; sl= sl->next_select())
3174
 
    {
3175
 
      Item_subselect *subquery_predicate= sl->master_unit()->item;
3176
 
      if (subquery_predicate &&
3177
 
          subquery_predicate->substype() == Item_subselect::IN_SUBS)
3178
 
      {
3179
 
        Item_in_subselect *in_subs= (Item_in_subselect*) subquery_predicate;
3180
 
        if (in_subs->exec_method == Item_in_subselect::MATERIALIZATION &&
3181
 
            in_subs->setup_engine())
3182
 
          return true;
3183
 
      }
3184
 
    }
3185
 
  }
3186
 
  return false;
3187
 
}
3188
 
 
3189
 
 
3190
 
/*
3191
 
  Check if table's KEYUSE elements have an eq_ref(outer_tables) candidate
3192
 
 
3193
 
  SYNOPSIS
3194
 
    find_eq_ref_candidate()
3195
 
      table             Table to be checked
3196
 
      sj_inner_tables   Bitmap of inner tables. eq_ref(inner_table) doesn't
3197
 
                        count.
3198
 
 
3199
 
  DESCRIPTION
3200
 
    Check if table's KEYUSE elements have an eq_ref(outer_tables) candidate
3201
 
 
3202
 
  TODO
3203
 
    Check again if it is feasible to factor common parts with constant table
3204
 
    search
3205
 
 
3206
 
  RETURN
3207
 
    true  - There exists an eq_ref(outer-tables) candidate
3208
 
    false - Otherwise
3209
 
*/
3210
 
 
3211
 
bool find_eq_ref_candidate(TABLE *table, table_map sj_inner_tables)
3212
 
{
3213
 
  KEYUSE *keyuse= table->reginfo.join_tab->keyuse;
3214
 
  uint key;
3215
 
 
3216
 
  if (keyuse)
3217
 
  {
3218
 
    while (1) /* For each key */
3219
 
    {
3220
 
      key= keyuse->key;
3221
 
      KEY *keyinfo= table->key_info + key;
3222
 
      key_part_map bound_parts= 0;
3223
 
      if ((keyinfo->flags & HA_NOSAME) == HA_NOSAME)
3224
 
      {
3225
 
        do  /* For all equalities on all key parts */
3226
 
        {
3227
 
          /* Check if this is "t.keypart = expr(outer_tables) */
3228
 
          if (!(keyuse->used_tables & sj_inner_tables) &&
3229
 
              !(keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL))
3230
 
          {
3231
 
            bound_parts |= 1 << keyuse->keypart;
3232
 
          }
3233
 
          keyuse++;
3234
 
        } while (keyuse->key == key && keyuse->table == table);
3235
 
 
3236
 
        if (bound_parts == PREV_BITS(uint, keyinfo->key_parts))
3237
 
          return true;
3238
 
        if (keyuse->table != table)
3239
 
          return false;
3240
 
      }
3241
 
      else
3242
 
      {
3243
 
        do
3244
 
        {
3245
 
          keyuse++;
3246
 
          if (keyuse->table != table)
3247
 
            return false;
3248
 
        }
3249
 
        while (keyuse->key == key);
3250
 
      }
3251
 
    }
3252
 
  }
3253
 
  return false;
3254
 
}
3255
 
 
3256
 
 
3257
 
/*
3258
 
  Pull tables out of semi-join nests, if possible
3259
 
 
3260
 
  SYNOPSIS
3261
 
    pull_out_semijoin_tables()
3262
 
      join  The join where to do the semi-join flattening
3263
 
 
3264
 
  DESCRIPTION
3265
 
    Try to pull tables out of semi-join nests.
3266
 
     
3267
 
    PRECONDITIONS
3268
 
    When this function is called, the join may have several semi-join nests
3269
 
    (possibly within different semi-join nests), but it is guaranteed that
3270
 
    one semi-join nest does not contain another.
3271
 
   
3272
 
    ACTION
3273
 
    A table can be pulled out of the semi-join nest if
3274
 
     - It is a constant table
3275
 
     - It is accessed 
3276
 
 
3277
 
    POSTCONDITIONS
3278
 
     * Pulled out tables have JOIN_TAB::emb_sj_nest == NULL (like the outer
3279
 
       tables)
3280
 
     * Tables that were not pulled out have JOIN_TAB::emb_sj_nest.
3281
 
     * Semi-join nests TABLE_LIST::sj_inner_tables
3282
 
 
3283
 
    This operation is (and should be) performed at each PS execution since
3284
 
    tables may become/cease to be constant across PS reexecutions.
3285
 
 
3286
 
  RETURN 
3287
 
    0 - OK
3288
 
    1 - Out of memory error
3289
 
*/
3290
 
 
3291
 
int pull_out_semijoin_tables(JOIN *join)
3292
 
{
3293
 
  TABLE_LIST *sj_nest;
3294
 
  List_iterator<TABLE_LIST> sj_list_it(join->select_lex->sj_nests);
3295
 
   
3296
 
  /* Try pulling out of the each of the semi-joins */
3297
 
  while ((sj_nest= sj_list_it++))
3298
 
  {
3299
 
    /* Action #1: Mark the constant tables to be pulled out */
3300
 
    table_map pulled_tables= 0;
3301
 
     
3302
 
    List_iterator<TABLE_LIST> child_li(sj_nest->nested_join->join_list);
3303
 
    TABLE_LIST *tbl;
3304
 
    while ((tbl= child_li++))
3305
 
    {
3306
 
      if (tbl->table)
3307
 
      {
3308
 
        tbl->table->reginfo.join_tab->emb_sj_nest= sj_nest;
3309
 
        if (tbl->table->map & join->const_table_map)
3310
 
        {
3311
 
          pulled_tables |= tbl->table->map;
3312
 
        }
3313
 
      }
3314
 
    }
3315
 
    
3316
 
    /*
3317
 
      Action #2: Find which tables we can pull out based on
3318
 
      update_ref_and_keys() data. Note that pulling one table out can allow
3319
 
      us to pull out some other tables too.
3320
 
    */
3321
 
    bool pulled_a_table;
3322
 
    do 
3323
 
    {
3324
 
      pulled_a_table= false;
3325
 
      child_li.rewind();
3326
 
      while ((tbl= child_li++))
3327
 
      {
3328
 
        if (tbl->table && !(pulled_tables & tbl->table->map))
3329
 
        {
3330
 
          if (find_eq_ref_candidate(tbl->table, 
3331
 
                                    sj_nest->nested_join->used_tables & 
3332
 
                                    ~pulled_tables))
3333
 
          {
3334
 
            pulled_a_table= true;
3335
 
            pulled_tables |= tbl->table->map;
3336
 
          }
3337
 
        }
3338
 
      }
3339
 
    } while (pulled_a_table);
3340
 
 
3341
 
    child_li.rewind();
3342
 
    if ((sj_nest)->nested_join->used_tables == pulled_tables)
3343
 
    {
3344
 
      (sj_nest)->sj_inner_tables= 0;
3345
 
      while ((tbl= child_li++))
3346
 
      {
3347
 
        if (tbl->table)
3348
 
          tbl->table->reginfo.join_tab->emb_sj_nest= NULL;
3349
 
      }
3350
 
    }
3351
 
    else
3352
 
    {
3353
 
      /* Record the bitmap of inner tables, mark the inner tables */
3354
 
      table_map inner_tables=(sj_nest)->nested_join->used_tables & 
3355
 
                             ~pulled_tables;
3356
 
      (sj_nest)->sj_inner_tables= inner_tables;
3357
 
      while ((tbl= child_li++))
3358
 
      {
3359
 
        if (tbl->table)
3360
 
        {
3361
 
          if (inner_tables & tbl->table->map)
3362
 
            tbl->table->reginfo.join_tab->emb_sj_nest= (sj_nest);
3363
 
          else
3364
 
            tbl->table->reginfo.join_tab->emb_sj_nest= NULL;
3365
 
        }
3366
 
      }
3367
 
    }
3368
 
  }
3369
 
  return(0);
3370
 
}
3371
 
 
3372
473
/*****************************************************************************
3373
 
  Create JOIN_TABS, make a guess about the table types,
 
474
  Create JoinTableS, make a guess about the table types,
3374
475
  Approximate how many records will be used in each table
3375
476
*****************************************************************************/
3376
 
 
3377
 
 
3378
 
static ha_rows get_quick_record_count(THD *thd, SQL_SELECT *select,
3379
 
                                      TABLE *table,
3380
 
                                      const key_map *keys,ha_rows limit)
 
477
ha_rows get_quick_record_count(Session *session, SQL_SELECT *select, Table *table, const key_map *keys,ha_rows limit)
3381
478
{
3382
479
  int error;
3383
 
  if (check_stack_overrun(thd, STACK_MIN_SIZE, NULL))
 
480
  if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))
3384
481
    return(0);                           // Fatal error flag is set
3385
482
  if (select)
3386
483
  {
3387
484
    select->head=table;
3388
485
    table->reginfo.impossible_range=0;
3389
 
    if ((error= select->test_quick_select(thd, *(key_map *)keys,(table_map) 0,
 
486
    if ((error= select->test_quick_select(session, *(key_map *)keys,(table_map) 0,
3390
487
                                          limit, 0, false)) == 1)
3391
488
      return(select->quick->records);
3392
489
    if (error == -1)
3398
495
  return(HA_POS_ERROR);                 /* This shouldn't happend */
3399
496
}
3400
497
 
3401
 
/*
3402
 
   This structure is used to collect info on potentially sargable
3403
 
   predicates in order to check whether they become sargable after
3404
 
   reading const tables.
3405
 
   We form a bitmap of indexes that can be used for sargable predicates.
3406
 
   Only such indexes are involved in range analysis.
3407
 
*/
3408
 
typedef struct st_sargable_param
3409
 
{
3410
 
  Field *field;              /* field against which to check sargability */
3411
 
  Item **arg_value;          /* values of potential keys for lookups     */
3412
 
  uint num_values;           /* number of values in the above array      */
3413
 
} SARGABLE_PARAM;  
3414
 
 
3415
 
/**
3416
 
  Calculate the best possible join and initialize the join structure.
3417
 
 
3418
 
  @retval
3419
 
    0   ok
3420
 
  @retval
3421
 
    1   Fatal error
3422
 
*/
3423
 
 
3424
 
static bool
3425
 
make_join_statistics(JOIN *join, TABLE_LIST *tables, COND *conds,
3426
 
                     DYNAMIC_ARRAY *keyuse_array)
3427
 
{
3428
 
  int error;
3429
 
  TABLE *table;
3430
 
  uint i,table_count,const_count,key;
3431
 
  table_map found_const_table_map, all_table_map, found_ref, refs;
3432
 
  key_map const_ref, eq_part;
3433
 
  TABLE **table_vector;
3434
 
  JOIN_TAB *stat,*stat_end,*s,**stat_ref;
3435
 
  KEYUSE *keyuse,*start_keyuse;
3436
 
  table_map outer_join=0;
3437
 
  SARGABLE_PARAM *sargables= 0;
3438
 
  JOIN_TAB *stat_vector[MAX_TABLES+1];
3439
 
 
3440
 
  table_count=join->tables;
3441
 
  stat=(JOIN_TAB*) join->thd->calloc(sizeof(JOIN_TAB)*table_count);
3442
 
  stat_ref=(JOIN_TAB**) join->thd->alloc(sizeof(JOIN_TAB*)*MAX_TABLES);
3443
 
  table_vector=(TABLE**) join->thd->alloc(sizeof(TABLE*)*(table_count*2));
3444
 
  if (!stat || !stat_ref || !table_vector)
3445
 
    return(1);                          // Eom /* purecov: inspected */
3446
 
 
3447
 
  join->best_ref=stat_vector;
3448
 
 
3449
 
  stat_end=stat+table_count;
3450
 
  found_const_table_map= all_table_map=0;
3451
 
  const_count=0;
3452
 
 
3453
 
  for (s= stat, i= 0;
3454
 
       tables;
3455
 
       s++, tables= tables->next_leaf, i++)
3456
 
  {
3457
 
    TABLE_LIST *embedding= tables->embedding;
3458
 
    stat_vector[i]=s;
3459
 
    s->keys.init();
3460
 
    s->const_keys.init();
3461
 
    s->checked_keys.init();
3462
 
    s->needed_reg.init();
3463
 
    table_vector[i]=s->table=table=tables->table;
3464
 
    table->pos_in_table_list= tables;
3465
 
    error= table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
3466
 
    if(error)
3467
 
    {
3468
 
        table->file->print_error(error, MYF(0));
3469
 
        return(1);
3470
 
    }
3471
 
    table->quick_keys.clear_all();
3472
 
    table->reginfo.join_tab=s;
3473
 
    table->reginfo.not_exists_optimize=0;
3474
 
    memset(table->const_key_parts, 0,
3475
 
           sizeof(key_part_map)*table->s->keys);
3476
 
    all_table_map|= table->map;
3477
 
    s->join=join;
3478
 
    s->info=0;                                  // For describe
3479
 
 
3480
 
    s->dependent= tables->dep_tables;
3481
 
    s->key_dependent= 0;
3482
 
    if (tables->schema_table)
3483
 
      table->file->stats.records= 2;
3484
 
    table->quick_condition_rows= table->file->stats.records;
3485
 
 
3486
 
    s->on_expr_ref= &tables->on_expr;
3487
 
    if (*s->on_expr_ref)
3488
 
    {
3489
 
      /* s is the only inner table of an outer join */
3490
 
      if (!table->file->stats.records && !embedding)
3491
 
      {                                         // Empty table
3492
 
        s->dependent= 0;                        // Ignore LEFT JOIN depend.
3493
 
        set_position(join,const_count++,s,(KEYUSE*) 0);
3494
 
        continue;
3495
 
      }
3496
 
      outer_join|= table->map;
3497
 
      s->embedding_map= 0;
3498
 
      for (;embedding; embedding= embedding->embedding)
3499
 
        s->embedding_map|= embedding->nested_join->nj_map;
3500
 
      continue;
3501
 
    }
3502
 
    if (embedding && !(embedding->sj_on_expr && ! embedding->embedding))
3503
 
    {
3504
 
      /* s belongs to a nested join, maybe to several embedded joins */
3505
 
      s->embedding_map= 0;
3506
 
      do
3507
 
      {
3508
 
        NESTED_JOIN *nested_join= embedding->nested_join;
3509
 
        s->embedding_map|=nested_join->nj_map;
3510
 
        s->dependent|= embedding->dep_tables;
3511
 
        embedding= embedding->embedding;
3512
 
        outer_join|= nested_join->used_tables;
3513
 
      }
3514
 
      while (embedding);
3515
 
      continue;
3516
 
    }
3517
 
    if ((table->s->system || table->file->stats.records <= 1) &&
3518
 
        !s->dependent &&
3519
 
        (table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) && !join->no_const_tables)
3520
 
    {
3521
 
      set_position(join,const_count++,s,(KEYUSE*) 0);
3522
 
    }
3523
 
  }
3524
 
  stat_vector[i]=0;
3525
 
  join->outer_join=outer_join;
3526
 
 
3527
 
  if (join->outer_join)
3528
 
  {
3529
 
    /* 
3530
 
       Build transitive closure for relation 'to be dependent on'.
3531
 
       This will speed up the plan search for many cases with outer joins,
3532
 
       as well as allow us to catch illegal cross references/
3533
 
       Warshall's algorithm is used to build the transitive closure.
3534
 
       As we use bitmaps to represent the relation the complexity
3535
 
       of the algorithm is O((number of tables)^2). 
3536
 
    */
3537
 
    for (i= 0, s= stat ; i < table_count ; i++, s++)
3538
 
    {
3539
 
      for (uint j= 0 ; j < table_count ; j++)
3540
 
      {
3541
 
        table= stat[j].table;
3542
 
        if (s->dependent & table->map)
3543
 
          s->dependent |= table->reginfo.join_tab->dependent;
3544
 
      }
3545
 
      if (s->dependent)
3546
 
        s->table->maybe_null= 1;
3547
 
    }
3548
 
    /* Catch illegal cross references for outer joins */
3549
 
    for (i= 0, s= stat ; i < table_count ; i++, s++)
3550
 
    {
3551
 
      if (s->dependent & s->table->map)
3552
 
      {
3553
 
        join->tables=0;                 // Don't use join->table
3554
 
        my_message(ER_WRONG_OUTER_JOIN, ER(ER_WRONG_OUTER_JOIN), MYF(0));
3555
 
        return(1);
3556
 
      }
3557
 
      s->key_dependent= s->dependent;
3558
 
    }
3559
 
  }
3560
 
 
3561
 
  if (conds || outer_join)
3562
 
    if (update_ref_and_keys(join->thd, keyuse_array, stat, join->tables,
3563
 
                            conds, join->cond_equal,
3564
 
                            ~outer_join, join->select_lex, &sargables))
3565
 
      return(1);
3566
 
 
3567
 
  /* Read tables with 0 or 1 rows (system tables) */
3568
 
  join->const_table_map= 0;
3569
 
 
3570
 
  for (POSITION *p_pos=join->positions, *p_end=p_pos+const_count;
3571
 
       p_pos < p_end ;
3572
 
       p_pos++)
3573
 
  {
3574
 
    int tmp;
3575
 
    s= p_pos->table;
3576
 
    s->type=JT_SYSTEM;
3577
 
    join->const_table_map|=s->table->map;
3578
 
    if ((tmp=join_read_const_table(s, p_pos)))
3579
 
    {
3580
 
      if (tmp > 0)
3581
 
        return(1);                      // Fatal error
3582
 
    }
3583
 
    else
3584
 
      found_const_table_map|= s->table->map;
3585
 
  }
3586
 
 
3587
 
  /* loop until no more const tables are found */
3588
 
  int ref_changed;
3589
 
  do
3590
 
  {
3591
 
  more_const_tables_found:
3592
 
    ref_changed = 0;
3593
 
    found_ref=0;
3594
 
 
3595
 
    /*
3596
 
      We only have to loop from stat_vector + const_count as
3597
 
      set_position() will move all const_tables first in stat_vector
3598
 
    */
3599
 
 
3600
 
    for (JOIN_TAB **pos=stat_vector+const_count ; (s= *pos) ; pos++)
3601
 
    {
3602
 
      table=s->table;
3603
 
 
3604
 
      /* 
3605
 
        If equi-join condition by a key is null rejecting and after a
3606
 
        substitution of a const table the key value happens to be null
3607
 
        then we can state that there are no matches for this equi-join.
3608
 
      */  
3609
 
      if ((keyuse= s->keyuse) && *s->on_expr_ref && !s->embedding_map)
3610
 
      {
3611
 
        /* 
3612
 
          When performing an outer join operation if there are no matching rows
3613
 
          for the single row of the outer table all the inner tables are to be
3614
 
          null complemented and thus considered as constant tables.
3615
 
          Here we apply this consideration to the case of outer join operations 
3616
 
          with a single inner table only because the case with nested tables
3617
 
          would require a more thorough analysis.
3618
 
          TODO. Apply single row substitution to null complemented inner tables
3619
 
          for nested outer join operations. 
3620
 
        */              
3621
 
        while (keyuse->table == table)
3622
 
        {
3623
 
          if (!(keyuse->val->used_tables() & ~join->const_table_map) &&
3624
 
              keyuse->val->is_null() && keyuse->null_rejecting)
3625
 
          {
3626
 
            s->type= JT_CONST;
3627
 
            mark_as_null_row(table);
3628
 
            found_const_table_map|= table->map;
3629
 
            join->const_table_map|= table->map;
3630
 
            set_position(join,const_count++,s,(KEYUSE*) 0);
3631
 
            goto more_const_tables_found;
3632
 
           }
3633
 
          keyuse++;
3634
 
        }
3635
 
      }
3636
 
 
3637
 
      if (s->dependent)                         // If dependent on some table
3638
 
      {
3639
 
        // All dep. must be constants
3640
 
        if (s->dependent & ~(found_const_table_map))
3641
 
          continue;
3642
 
        if (table->file->stats.records <= 1L &&
3643
 
            (table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&
3644
 
            !table->pos_in_table_list->embedding)
3645
 
        {                                       // system table
3646
 
          int tmp= 0;
3647
 
          s->type=JT_SYSTEM;
3648
 
          join->const_table_map|=table->map;
3649
 
          set_position(join,const_count++,s,(KEYUSE*) 0);
3650
 
          if ((tmp= join_read_const_table(s, join->positions+const_count-1)))
3651
 
          {
3652
 
            if (tmp > 0)
3653
 
              return(1);                        // Fatal error
3654
 
          }
3655
 
          else
3656
 
            found_const_table_map|= table->map;
3657
 
          continue;
3658
 
        }
3659
 
      }
3660
 
      /* check if table can be read by key or table only uses const refs */
3661
 
      if ((keyuse=s->keyuse))
3662
 
      {
3663
 
        s->type= JT_REF;
3664
 
        while (keyuse->table == table)
3665
 
        {
3666
 
          start_keyuse=keyuse;
3667
 
          key=keyuse->key;
3668
 
          s->keys.set_bit(key);               // QQ: remove this ?
3669
 
 
3670
 
          refs=0;
3671
 
          const_ref.clear_all();
3672
 
          eq_part.clear_all();
3673
 
          do
3674
 
          {
3675
 
            if (keyuse->val->type() != Item::NULL_ITEM && !keyuse->optimize)
3676
 
            {
3677
 
              if (!((~found_const_table_map) & keyuse->used_tables))
3678
 
                const_ref.set_bit(keyuse->keypart);
3679
 
              else
3680
 
                refs|=keyuse->used_tables;
3681
 
              eq_part.set_bit(keyuse->keypart);
3682
 
            }
3683
 
            keyuse++;
3684
 
          } while (keyuse->table == table && keyuse->key == key);
3685
 
 
3686
 
          if (eq_part.is_prefix(table->key_info[key].key_parts) &&
3687
 
              !table->pos_in_table_list->embedding)
3688
 
          {
3689
 
            if ((table->key_info[key].flags & (HA_NOSAME))
3690
 
                 == HA_NOSAME)
3691
 
            {
3692
 
              if (const_ref == eq_part)
3693
 
              {                                 // Found everything for ref.
3694
 
                int tmp;
3695
 
                ref_changed = 1;
3696
 
                s->type= JT_CONST;
3697
 
                join->const_table_map|=table->map;
3698
 
                set_position(join,const_count++,s,start_keyuse);
3699
 
                if (create_ref_for_key(join, s, start_keyuse,
3700
 
                                       found_const_table_map))
3701
 
                  return(1);
3702
 
                if ((tmp=join_read_const_table(s,
3703
 
                                               join->positions+const_count-1)))
3704
 
                {
3705
 
                  if (tmp > 0)
3706
 
                    return(1);                  // Fatal error
3707
 
                }
3708
 
                else
3709
 
                  found_const_table_map|= table->map;
3710
 
                break;
3711
 
              }
3712
 
              else
3713
 
                found_ref|= refs;      // Table is const if all refs are const
3714
 
            }
3715
 
            else if (const_ref == eq_part)
3716
 
              s->const_keys.set_bit(key);
3717
 
          }
3718
 
        }
3719
 
      }
3720
 
    }
3721
 
  } while (join->const_table_map & found_ref && ref_changed);
3722
 
 
3723
 
  /* 
3724
 
    Update info on indexes that can be used for search lookups as
3725
 
    reading const tables may has added new sargable predicates. 
3726
 
  */
3727
 
  if (const_count && sargables)
3728
 
  {
3729
 
    for( ; sargables->field ; sargables++)
3730
 
    {
3731
 
      Field *field= sargables->field;
3732
 
      JOIN_TAB *join_tab= field->table->reginfo.join_tab;
3733
 
      key_map possible_keys= field->key_start;
3734
 
      possible_keys.intersect(field->table->keys_in_use_for_query);
3735
 
      bool is_const= 1;
3736
 
      for (uint j=0; j < sargables->num_values; j++)
3737
 
        is_const&= sargables->arg_value[j]->const_item();
3738
 
      if (is_const)
3739
 
        join_tab[0].const_keys.merge(possible_keys);
3740
 
    }
3741
 
  }
3742
 
 
3743
 
  if (pull_out_semijoin_tables(join))
3744
 
    return(true);
3745
 
 
3746
 
  /* Calc how many (possible) matched records in each table */
3747
 
 
3748
 
  for (s=stat ; s < stat_end ; s++)
3749
 
  {
3750
 
    if (s->type == JT_SYSTEM || s->type == JT_CONST)
3751
 
    {
3752
 
      /* Only one matching row */
3753
 
      s->found_records=s->records=s->read_time=1; s->worst_seeks=1.0;
3754
 
      continue;
3755
 
    }
3756
 
    /* Approximate found rows and time to read them */
3757
 
    s->found_records=s->records=s->table->file->stats.records;
3758
 
    s->read_time=(ha_rows) s->table->file->scan_time();
3759
 
 
3760
 
    /*
3761
 
      Set a max range of how many seeks we can expect when using keys
3762
 
      This is can't be to high as otherwise we are likely to use
3763
 
      table scan.
3764
 
    */
3765
 
    s->worst_seeks= min((double) s->found_records / 10,
3766
 
                        (double) s->read_time*3);
3767
 
    if (s->worst_seeks < 2.0)                   // Fix for small tables
3768
 
      s->worst_seeks=2.0;
3769
 
 
3770
 
    /*
3771
 
      Add to stat->const_keys those indexes for which all group fields or
3772
 
      all select distinct fields participate in one index.
3773
 
    */
3774
 
    add_group_and_distinct_keys(join, s);
3775
 
 
3776
 
    if (!s->const_keys.is_clear_all() &&
3777
 
        !s->table->pos_in_table_list->embedding)
3778
 
    {
3779
 
      ha_rows records;
3780
 
      SQL_SELECT *select;
3781
 
      select= make_select(s->table, found_const_table_map,
3782
 
                          found_const_table_map,
3783
 
                          *s->on_expr_ref ? *s->on_expr_ref : conds,
3784
 
                          1, &error);
3785
 
      if (!select)
3786
 
        return(1);
3787
 
      records= get_quick_record_count(join->thd, select, s->table,
3788
 
                                      &s->const_keys, join->row_limit);
3789
 
      s->quick=select->quick;
3790
 
      s->needed_reg=select->needed_reg;
3791
 
      select->quick=0;
3792
 
      if (records == 0 && s->table->reginfo.impossible_range)
3793
 
      {
3794
 
        /*
3795
 
          Impossible WHERE or ON expression
3796
 
          In case of ON, we mark that the we match one empty NULL row.
3797
 
          In case of WHERE, don't set found_const_table_map to get the
3798
 
          caller to abort with a zero row result.
3799
 
        */
3800
 
        join->const_table_map|= s->table->map;
3801
 
        set_position(join,const_count++,s,(KEYUSE*) 0);
3802
 
        s->type= JT_CONST;
3803
 
        if (*s->on_expr_ref)
3804
 
        {
3805
 
          /* Generate empty row */
3806
 
          s->info= "Impossible ON condition";
3807
 
          found_const_table_map|= s->table->map;
3808
 
          s->type= JT_CONST;
3809
 
          mark_as_null_row(s->table);           // All fields are NULL
3810
 
        }
3811
 
      }
3812
 
      if (records != HA_POS_ERROR)
3813
 
      {
3814
 
        s->found_records=records;
3815
 
        s->read_time= (ha_rows) (s->quick ? s->quick->read_time : 0.0);
3816
 
      }
3817
 
      delete select;
3818
 
    }
3819
 
  }
3820
 
 
3821
 
  join->join_tab=stat;
3822
 
  join->map2table=stat_ref;
3823
 
  join->table= join->all_tables=table_vector;
3824
 
  join->const_tables=const_count;
3825
 
  join->found_const_table_map=found_const_table_map;
3826
 
 
3827
 
  /* Find an optimal join order of the non-constant tables. */
3828
 
  if (join->const_tables != join->tables)
3829
 
  {
3830
 
    optimize_keyuse(join, keyuse_array);
3831
 
    if (choose_plan(join, all_table_map & ~join->const_table_map))
3832
 
      return(true);
3833
 
  }
3834
 
  else
3835
 
  {
3836
 
    memcpy(join->best_positions, join->positions,
3837
 
           sizeof(POSITION)*join->const_tables);
3838
 
    join->best_read=1.0;
3839
 
  }
3840
 
  /* Generate an execution plan from the found optimal join order. */
3841
 
  return(join->thd->killed || get_best_combination(join));
3842
 
}
3843
 
 
3844
 
 
3845
498
/*****************************************************************************
3846
499
  Check with keys are used and with tables references with tables
3847
500
  Updates in stat:
3850
503
          keyuse     Pointer to possible keys
3851
504
*****************************************************************************/
3852
505
 
3853
 
/// Used when finding key fields
3854
 
typedef struct key_field_t {
3855
 
  Field         *field;
3856
 
  Item          *val;                   ///< May be empty if diff constant
3857
 
  uint          level;
3858
 
  uint          optimize; // KEY_OPTIMIZE_*
3859
 
  bool          eq_func;
3860
 
  /**
3861
 
    If true, the condition this struct represents will not be satisfied
3862
 
    when val IS NULL.
3863
 
  */
3864
 
  bool          null_rejecting; 
3865
 
  bool          *cond_guard; /* See KEYUSE::cond_guard */
3866
 
  uint          sj_pred_no; /* See KEYUSE::sj_pred_no */
3867
 
} KEY_FIELD;
3868
 
 
3869
 
/**
3870
 
  Merge new key definitions to old ones, remove those not used in both.
3871
 
 
3872
 
  This is called for OR between different levels.
3873
 
 
3874
 
  To be able to do 'ref_or_null' we merge a comparison of a column
3875
 
  and 'column IS NULL' to one test.  This is useful for sub select queries
3876
 
  that are internally transformed to something like:.
3877
 
 
3878
 
  @code
3879
 
  SELECT * FROM t1 WHERE t1.key=outer_ref_field or t1.key IS NULL 
3880
 
  @endcode
3881
 
 
3882
 
  KEY_FIELD::null_rejecting is processed as follows: @n
3883
 
  result has null_rejecting=true if it is set for both ORed references.
3884
 
  for example:
3885
 
  -   (t2.key = t1.field OR t2.key  =  t1.field) -> null_rejecting=true
3886
 
  -   (t2.key = t1.field OR t2.key <=> t1.field) -> null_rejecting=false
3887
 
 
3888
 
  @todo
3889
 
    The result of this is that we're missing some 'ref' accesses.
3890
 
    OptimizerTeam: Fix this
3891
 
*/
3892
 
 
3893
 
static KEY_FIELD *
3894
 
merge_key_fields(KEY_FIELD *start,KEY_FIELD *new_fields,KEY_FIELD *end,
3895
 
                 uint and_level)
3896
 
{
3897
 
  if (start == new_fields)
3898
 
    return start;                               // Impossible or
3899
 
  if (new_fields == end)
3900
 
    return start;                               // No new fields, skip all
3901
 
 
3902
 
  KEY_FIELD *first_free=new_fields;
3903
 
 
3904
 
  /* Mark all found fields in old array */
3905
 
  for (; new_fields != end ; new_fields++)
3906
 
  {
3907
 
    for (KEY_FIELD *old=start ; old != first_free ; old++)
3908
 
    {
3909
 
      if (old->field == new_fields->field)
3910
 
      {
3911
 
        /*
3912
 
          NOTE: below const_item() call really works as "!used_tables()", i.e.
3913
 
          it can return false where it is feasible to make it return true.
3914
 
          
3915
 
          The cause is as follows: Some of the tables are already known to be
3916
 
          const tables (the detection code is in make_join_statistics(),
3917
 
          above the update_ref_and_keys() call), but we didn't propagate 
3918
 
          information about this: TABLE::const_table is not set to true, and
3919
 
          Item::update_used_tables() hasn't been called for each item.
3920
 
          The result of this is that we're missing some 'ref' accesses.
3921
 
          TODO: OptimizerTeam: Fix this
3922
 
        */
3923
 
        if (!new_fields->val->const_item())
3924
 
        {
3925
 
          /*
3926
 
            If the value matches, we can use the key reference.
3927
 
            If not, we keep it until we have examined all new values
3928
 
          */
3929
 
          if (old->val->eq(new_fields->val, old->field->binary()))
3930
 
          {
3931
 
            old->level= and_level;
3932
 
            old->optimize= ((old->optimize & new_fields->optimize &
3933
 
                             KEY_OPTIMIZE_EXISTS) |
3934
 
                            ((old->optimize | new_fields->optimize) &
3935
 
                             KEY_OPTIMIZE_REF_OR_NULL));
3936
 
            old->null_rejecting= (old->null_rejecting &&
3937
 
                                  new_fields->null_rejecting);
3938
 
          }
3939
 
        }
3940
 
        else if (old->eq_func && new_fields->eq_func &&
3941
 
                 old->val->eq_by_collation(new_fields->val, 
3942
 
                                           old->field->binary(),
3943
 
                                           old->field->charset()))
3944
 
 
3945
 
        {
3946
 
          old->level= and_level;
3947
 
          old->optimize= ((old->optimize & new_fields->optimize &
3948
 
                           KEY_OPTIMIZE_EXISTS) |
3949
 
                          ((old->optimize | new_fields->optimize) &
3950
 
                           KEY_OPTIMIZE_REF_OR_NULL));
3951
 
          old->null_rejecting= (old->null_rejecting &&
3952
 
                                new_fields->null_rejecting);
3953
 
        }
3954
 
        else if (old->eq_func && new_fields->eq_func &&
3955
 
                 ((old->val->const_item() && old->val->is_null()) || 
3956
 
                  new_fields->val->is_null()))
3957
 
        {
3958
 
          /* field = expression OR field IS NULL */
3959
 
          old->level= and_level;
3960
 
          old->optimize= KEY_OPTIMIZE_REF_OR_NULL;
3961
 
          /*
3962
 
            Remember the NOT NULL value unless the value does not depend
3963
 
            on other tables.
3964
 
          */
3965
 
          if (!old->val->used_tables() && old->val->is_null())
3966
 
            old->val= new_fields->val;
3967
 
          /* The referred expression can be NULL: */ 
3968
 
          old->null_rejecting= 0;
3969
 
        }
3970
 
        else
3971
 
        {
3972
 
          /*
3973
 
            We are comparing two different const.  In this case we can't
3974
 
            use a key-lookup on this so it's better to remove the value
3975
 
            and let the range optimzier handle it
3976
 
          */
3977
 
          if (old == --first_free)              // If last item
3978
 
            break;
3979
 
          *old= *first_free;                    // Remove old value
3980
 
          old--;                                // Retry this value
3981
 
        }
3982
 
      }
3983
 
    }
3984
 
  }
3985
 
  /* Remove all not used items */
3986
 
  for (KEY_FIELD *old=start ; old != first_free ;)
3987
 
  {
3988
 
    if (old->level != and_level)
3989
 
    {                                           // Not used in all levels
3990
 
      if (old == --first_free)
3991
 
        break;
3992
 
      *old= *first_free;                        // Remove old value
3993
 
      continue;
3994
 
    }
3995
 
    old++;
3996
 
  }
3997
 
  return first_free;
3998
 
}
3999
 
 
4000
 
 
4001
 
/**
4002
 
  Add a possible key to array of possible keys if it's usable as a key
4003
 
 
4004
 
    @param key_fields      Pointer to add key, if usable
4005
 
    @param and_level       And level, to be stored in KEY_FIELD
4006
 
    @param cond            Condition predicate
4007
 
    @param field           Field used in comparision
4008
 
    @param eq_func         True if we used =, <=> or IS NULL
4009
 
    @param value           Value used for comparison with field
4010
 
    @param usable_tables   Tables which can be used for key optimization
4011
 
    @param sargables       IN/OUT Array of found sargable candidates
4012
 
 
4013
 
  @note
4014
 
    If we are doing a NOT NULL comparison on a NOT NULL field in a outer join
4015
 
    table, we store this to be able to do not exists optimization later.
4016
 
 
4017
 
  @returns
4018
 
    *key_fields is incremented if we stored a key in the array
4019
 
*/
4020
 
 
4021
 
static void
4022
 
add_key_field(KEY_FIELD **key_fields,uint and_level, Item_func *cond,
4023
 
              Field *field, bool eq_func, Item **value, uint num_values,
4024
 
              table_map usable_tables, SARGABLE_PARAM **sargables)
4025
 
{
4026
 
  uint exists_optimize= 0;
4027
 
  if (!(field->flags & PART_KEY_FLAG))
4028
 
  {
4029
 
    // Don't remove column IS NULL on a LEFT JOIN table
4030
 
    if (!eq_func || (*value)->type() != Item::NULL_ITEM ||
4031
 
        !field->table->maybe_null || field->null_ptr)
4032
 
      return;                                   // Not a key. Skip it
4033
 
    exists_optimize= KEY_OPTIMIZE_EXISTS;
4034
 
    assert(num_values == 1);
4035
 
  }
4036
 
  else
4037
 
  {
4038
 
    table_map used_tables=0;
4039
 
    bool optimizable=0;
4040
 
    for (uint i=0; i<num_values; i++)
4041
 
    {
4042
 
      used_tables|=(value[i])->used_tables();
4043
 
      if (!((value[i])->used_tables() & (field->table->map | RAND_TABLE_BIT)))
4044
 
        optimizable=1;
4045
 
    }
4046
 
    if (!optimizable)
4047
 
      return;
4048
 
    if (!(usable_tables & field->table->map))
4049
 
    {
4050
 
      if (!eq_func || (*value)->type() != Item::NULL_ITEM ||
4051
 
          !field->table->maybe_null || field->null_ptr)
4052
 
        return;                                 // Can't use left join optimize
4053
 
      exists_optimize= KEY_OPTIMIZE_EXISTS;
4054
 
    }
4055
 
    else
4056
 
    {
4057
 
      JOIN_TAB *stat=field->table->reginfo.join_tab;
4058
 
      key_map possible_keys=field->key_start;
4059
 
      possible_keys.intersect(field->table->keys_in_use_for_query);
4060
 
      stat[0].keys.merge(possible_keys);             // Add possible keys
4061
 
 
4062
 
      /*
4063
 
        Save the following cases:
4064
 
        Field op constant
4065
 
        Field LIKE constant where constant doesn't start with a wildcard
4066
 
        Field = field2 where field2 is in a different table
4067
 
        Field op formula
4068
 
        Field IS NULL
4069
 
        Field IS NOT NULL
4070
 
         Field BETWEEN ...
4071
 
         Field IN ...
4072
 
      */
4073
 
      stat[0].key_dependent|=used_tables;
4074
 
 
4075
 
      bool is_const=1;
4076
 
      for (uint i=0; i<num_values; i++)
4077
 
      {
4078
 
        if (!(is_const&= value[i]->const_item()))
4079
 
          break;
4080
 
      }
4081
 
      if (is_const)
4082
 
        stat[0].const_keys.merge(possible_keys);
4083
 
      else if (!eq_func)
4084
 
      {
4085
 
        /* 
4086
 
          Save info to be able check whether this predicate can be 
4087
 
          considered as sargable for range analisis after reading const tables.
4088
 
          We do not save info about equalities as update_const_equal_items
4089
 
          will take care of updating info on keys from sargable equalities. 
4090
 
        */
4091
 
        (*sargables)--;
4092
 
        (*sargables)->field= field;
4093
 
        (*sargables)->arg_value= value;
4094
 
        (*sargables)->num_values= num_values;
4095
 
      }
4096
 
      /*
4097
 
        We can't always use indexes when comparing a string index to a
4098
 
        number. cmp_type() is checked to allow compare of dates to numbers.
4099
 
        eq_func is NEVER true when num_values > 1
4100
 
       */
4101
 
      if (!eq_func)
4102
 
      {
4103
 
        /* 
4104
 
          Additional optimization: if we're processing
4105
 
          "t.key BETWEEN c1 AND c1" then proceed as if we were processing
4106
 
          "t.key = c1".
4107
 
          TODO: This is a very limited fix. A more generic fix is possible. 
4108
 
          There are 2 options:
4109
 
          A) Make equality propagation code be able to handle BETWEEN
4110
 
             (including cases like t1.key BETWEEN t2.key AND t3.key)
4111
 
          B) Make range optimizer to infer additional "t.key = c" equalities
4112
 
             and use them in equality propagation process (see details in
4113
 
             OptimizerKBAndTodo)
4114
 
        */
4115
 
        if ((cond->functype() != Item_func::BETWEEN) ||
4116
 
            ((Item_func_between*) cond)->negated ||
4117
 
            !value[0]->eq(value[1], field->binary()))
4118
 
          return;
4119
 
        eq_func= true;
4120
 
      }
4121
 
 
4122
 
      if (field->result_type() == STRING_RESULT)
4123
 
      {
4124
 
        if ((*value)->result_type() != STRING_RESULT)
4125
 
        {
4126
 
          if (field->cmp_type() != (*value)->result_type())
4127
 
            return;
4128
 
        }
4129
 
        else
4130
 
        {
4131
 
          /*
4132
 
            We can't use indexes if the effective collation
4133
 
            of the operation differ from the field collation.
4134
 
          */
4135
 
          if (field->cmp_type() == STRING_RESULT &&
4136
 
              ((Field_str*)field)->charset() != cond->compare_collation())
4137
 
            return;
4138
 
        }
4139
 
      }
4140
 
    }
4141
 
  }
4142
 
  /*
4143
 
    For the moment eq_func is always true. This slot is reserved for future
4144
 
    extensions where we want to remembers other things than just eq comparisons
4145
 
  */
4146
 
  assert(eq_func);
4147
 
  /* Store possible eq field */
4148
 
  (*key_fields)->field=         field;
4149
 
  (*key_fields)->eq_func=       eq_func;
4150
 
  (*key_fields)->val=           *value;
4151
 
  (*key_fields)->level=         and_level;
4152
 
  (*key_fields)->optimize=      exists_optimize;
4153
 
  /*
4154
 
    If the condition has form "tbl.keypart = othertbl.field" and 
4155
 
    othertbl.field can be NULL, there will be no matches if othertbl.field 
4156
 
    has NULL value.
4157
 
    We use null_rejecting in add_not_null_conds() to add
4158
 
    'othertbl.field IS NOT NULL' to tab->select_cond.
4159
 
  */
4160
 
  (*key_fields)->null_rejecting= ((cond->functype() == Item_func::EQ_FUNC ||
4161
 
                                   cond->functype() == Item_func::MULT_EQUAL_FUNC) &&
4162
 
                                  ((*value)->type() == Item::FIELD_ITEM) &&
4163
 
                                  ((Item_field*)*value)->field->maybe_null());
4164
 
  (*key_fields)->cond_guard= NULL;
4165
 
  (*key_fields)->sj_pred_no= (cond->name >= subq_sj_cond_name && 
4166
 
                              cond->name < subq_sj_cond_name + 64)? 
4167
 
                              cond->name - subq_sj_cond_name: UINT_MAX;
4168
 
  (*key_fields)++;
4169
 
}
4170
 
 
4171
 
/**
4172
 
  Add possible keys to array of possible keys originated from a simple
4173
 
  predicate.
4174
 
 
4175
 
    @param  key_fields     Pointer to add key, if usable
4176
 
    @param  and_level      And level, to be stored in KEY_FIELD
4177
 
    @param  cond           Condition predicate
4178
 
    @param  field          Field used in comparision
4179
 
    @param  eq_func        True if we used =, <=> or IS NULL
4180
 
    @param  value          Value used for comparison with field
4181
 
                           Is NULL for BETWEEN and IN    
4182
 
    @param  usable_tables  Tables which can be used for key optimization
4183
 
    @param  sargables      IN/OUT Array of found sargable candidates
4184
 
 
4185
 
  @note
4186
 
    If field items f1 and f2 belong to the same multiple equality and
4187
 
    a key is added for f1, the the same key is added for f2.
4188
 
 
4189
 
  @returns
4190
 
    *key_fields is incremented if we stored a key in the array
4191
 
*/
4192
 
 
4193
 
static void
4194
 
add_key_equal_fields(KEY_FIELD **key_fields, uint and_level,
4195
 
                     Item_func *cond, Item_field *field_item,
4196
 
                     bool eq_func, Item **val,
4197
 
                     uint num_values, table_map usable_tables,
4198
 
                     SARGABLE_PARAM **sargables)
4199
 
{
4200
 
  Field *field= field_item->field;
4201
 
  add_key_field(key_fields, and_level, cond, field,
4202
 
                eq_func, val, num_values, usable_tables, sargables);
4203
 
  Item_equal *item_equal= field_item->item_equal;
4204
 
  if (item_equal)
4205
 
  { 
4206
 
    /*
4207
 
      Add to the set of possible key values every substitution of
4208
 
      the field for an equal field included into item_equal
4209
 
    */
4210
 
    Item_equal_iterator it(*item_equal);
4211
 
    Item_field *item;
4212
 
    while ((item= it++))
4213
 
    {
4214
 
      if (!field->eq(item->field))
4215
 
      {
4216
 
        add_key_field(key_fields, and_level, cond, item->field,
4217
 
                      eq_func, val, num_values, usable_tables,
4218
 
                      sargables);
4219
 
      }
4220
 
    }
4221
 
  }
4222
 
}
4223
 
 
4224
 
static void
4225
 
add_key_fields(JOIN *join, KEY_FIELD **key_fields, uint *and_level,
4226
 
               COND *cond, table_map usable_tables,
4227
 
               SARGABLE_PARAM **sargables)
4228
 
{
4229
 
  if (cond->type() == Item_func::COND_ITEM)
4230
 
  {
4231
 
    List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
4232
 
    KEY_FIELD *org_key_fields= *key_fields;
4233
 
 
4234
 
    if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
4235
 
    {
4236
 
      Item *item;
4237
 
      while ((item=li++))
4238
 
        add_key_fields(join, key_fields, and_level, item, usable_tables,
4239
 
                       sargables);
4240
 
      for (; org_key_fields != *key_fields ; org_key_fields++)
4241
 
        org_key_fields->level= *and_level;
4242
 
    }
4243
 
    else
4244
 
    {
4245
 
      (*and_level)++;
4246
 
      add_key_fields(join, key_fields, and_level, li++, usable_tables,
4247
 
                     sargables);
4248
 
      Item *item;
4249
 
      while ((item=li++))
4250
 
      {
4251
 
        KEY_FIELD *start_key_fields= *key_fields;
4252
 
        (*and_level)++;
4253
 
        add_key_fields(join, key_fields, and_level, item, usable_tables,
4254
 
                       sargables);
4255
 
        *key_fields=merge_key_fields(org_key_fields,start_key_fields,
4256
 
                                     *key_fields,++(*and_level));
4257
 
      }
4258
 
    }
4259
 
    return;
4260
 
  }
4261
 
 
4262
 
  /* 
4263
 
    Subquery optimization: Conditions that are pushed down into subqueries
4264
 
    are wrapped into Item_func_trig_cond. We process the wrapped condition
4265
 
    but need to set cond_guard for KEYUSE elements generated from it.
4266
 
  */
4267
 
  {
4268
 
    if (cond->type() == Item::FUNC_ITEM &&
4269
 
        ((Item_func*)cond)->functype() == Item_func::TRIG_COND_FUNC)
4270
 
    {
4271
 
      Item *cond_arg= ((Item_func*)cond)->arguments()[0];
4272
 
      if (!join->group_list && !join->order &&
4273
 
          join->unit->item && 
4274
 
          join->unit->item->substype() == Item_subselect::IN_SUBS &&
4275
 
          !join->unit->is_union())
4276
 
      {
4277
 
        KEY_FIELD *save= *key_fields;
4278
 
        add_key_fields(join, key_fields, and_level, cond_arg, usable_tables,
4279
 
                       sargables);
4280
 
        // Indicate that this ref access candidate is for subquery lookup:
4281
 
        for (; save != *key_fields; save++)
4282
 
          save->cond_guard= ((Item_func_trig_cond*)cond)->get_trig_var();
4283
 
      }
4284
 
      return;
4285
 
    }
4286
 
  }
4287
 
 
4288
 
  /* If item is of type 'field op field/constant' add it to key_fields */
4289
 
  if (cond->type() != Item::FUNC_ITEM)
4290
 
    return;
4291
 
  Item_func *cond_func= (Item_func*) cond;
4292
 
  switch (cond_func->select_optimize()) {
4293
 
  case Item_func::OPTIMIZE_NONE:
4294
 
    break;
4295
 
  case Item_func::OPTIMIZE_KEY:
4296
 
  {
4297
 
    Item **values;
4298
 
    // BETWEEN, IN, NE
4299
 
    if (cond_func->key_item()->real_item()->type() == Item::FIELD_ITEM &&
4300
 
        !(cond_func->used_tables() & OUTER_REF_TABLE_BIT))
4301
 
    {
4302
 
      values= cond_func->arguments()+1;
4303
 
      if (cond_func->functype() == Item_func::NE_FUNC &&
4304
 
        cond_func->arguments()[1]->real_item()->type() == Item::FIELD_ITEM &&
4305
 
             !(cond_func->arguments()[0]->used_tables() & OUTER_REF_TABLE_BIT))
4306
 
        values--;
4307
 
      assert(cond_func->functype() != Item_func::IN_FUNC ||
4308
 
                  cond_func->argument_count() != 2);
4309
 
      add_key_equal_fields(key_fields, *and_level, cond_func,
4310
 
                           (Item_field*) (cond_func->key_item()->real_item()),
4311
 
                           0, values, 
4312
 
                           cond_func->argument_count()-1,
4313
 
                           usable_tables, sargables);
4314
 
    }
4315
 
    if (cond_func->functype() == Item_func::BETWEEN)
4316
 
    {
4317
 
      values= cond_func->arguments();
4318
 
      for (uint i= 1 ; i < cond_func->argument_count() ; i++)
4319
 
      {
4320
 
        Item_field *field_item;
4321
 
        if (cond_func->arguments()[i]->real_item()->type() == Item::FIELD_ITEM
4322
 
            &&
4323
 
            !(cond_func->arguments()[i]->used_tables() & OUTER_REF_TABLE_BIT))
4324
 
        {
4325
 
          field_item= (Item_field *) (cond_func->arguments()[i]->real_item());
4326
 
          add_key_equal_fields(key_fields, *and_level, cond_func,
4327
 
                               field_item, 0, values, 1, usable_tables, 
4328
 
                               sargables);
4329
 
        }
4330
 
      }  
4331
 
    }
4332
 
    break;
4333
 
  }
4334
 
  case Item_func::OPTIMIZE_OP:
4335
 
  {
4336
 
    bool equal_func=(cond_func->functype() == Item_func::EQ_FUNC ||
4337
 
                     cond_func->functype() == Item_func::EQUAL_FUNC);
4338
 
 
4339
 
    if (cond_func->arguments()[0]->real_item()->type() == Item::FIELD_ITEM &&
4340
 
        !(cond_func->arguments()[0]->used_tables() & OUTER_REF_TABLE_BIT))
4341
 
    {
4342
 
      add_key_equal_fields(key_fields, *and_level, cond_func,
4343
 
                        (Item_field*) (cond_func->arguments()[0])->real_item(),
4344
 
                           equal_func,
4345
 
                           cond_func->arguments()+1, 1, usable_tables,
4346
 
                           sargables);
4347
 
    }
4348
 
    if (cond_func->arguments()[1]->real_item()->type() == Item::FIELD_ITEM &&
4349
 
        cond_func->functype() != Item_func::LIKE_FUNC &&
4350
 
        !(cond_func->arguments()[1]->used_tables() & OUTER_REF_TABLE_BIT))
4351
 
    {
4352
 
      add_key_equal_fields(key_fields, *and_level, cond_func, 
4353
 
                       (Item_field*) (cond_func->arguments()[1])->real_item(),
4354
 
                           equal_func,
4355
 
                           cond_func->arguments(),1,usable_tables,
4356
 
                           sargables);
4357
 
    }
4358
 
    break;
4359
 
  }
4360
 
  case Item_func::OPTIMIZE_NULL:
4361
 
    /* column_name IS [NOT] NULL */
4362
 
    if (cond_func->arguments()[0]->real_item()->type() == Item::FIELD_ITEM &&
4363
 
        !(cond_func->used_tables() & OUTER_REF_TABLE_BIT))
4364
 
    {
4365
 
      Item *tmp=new Item_null;
4366
 
      if (unlikely(!tmp))                       // Should never be true
4367
 
        return;
4368
 
      add_key_equal_fields(key_fields, *and_level, cond_func,
4369
 
                    (Item_field*) (cond_func->arguments()[0])->real_item(),
4370
 
                    cond_func->functype() == Item_func::ISNULL_FUNC,
4371
 
                           &tmp, 1, usable_tables, sargables);
4372
 
    }
4373
 
    break;
4374
 
  case Item_func::OPTIMIZE_EQUAL:
4375
 
    Item_equal *item_equal= (Item_equal *) cond;
4376
 
    Item *const_item= item_equal->get_const();
4377
 
    Item_equal_iterator it(*item_equal);
4378
 
    Item_field *item;
4379
 
    if (const_item)
4380
 
    {
4381
 
      /*
4382
 
        For each field field1 from item_equal consider the equality 
4383
 
        field1=const_item as a condition allowing an index access of the table
4384
 
        with field1 by the keys value of field1.
4385
 
      */   
4386
 
      while ((item= it++))
4387
 
      {
4388
 
        add_key_field(key_fields, *and_level, cond_func, item->field,
4389
 
                      true, &const_item, 1, usable_tables, sargables);
4390
 
      }
4391
 
    }
4392
 
    else 
4393
 
    {
4394
 
      /*
4395
 
        Consider all pairs of different fields included into item_equal.
4396
 
        For each of them (field1, field1) consider the equality 
4397
 
        field1=field2 as a condition allowing an index access of the table
4398
 
        with field1 by the keys value of field2.
4399
 
      */   
4400
 
      Item_equal_iterator fi(*item_equal);
4401
 
      while ((item= fi++))
4402
 
      {
4403
 
        Field *field= item->field;
4404
 
        while ((item= it++))
4405
 
        {
4406
 
          if (!field->eq(item->field))
4407
 
          {
4408
 
            add_key_field(key_fields, *and_level, cond_func, field,
4409
 
                          true, (Item **) &item, 1, usable_tables,
4410
 
                          sargables);
4411
 
          }
4412
 
        }
4413
 
        it.rewind();
4414
 
      }
4415
 
    }
4416
 
    break;
4417
 
  }
4418
 
}
4419
506
 
4420
507
/**
4421
508
  Add all keys with uses 'field' for some keypart.
4422
509
 
4423
510
  If field->and_level != and_level then only mark key_part as const_part.
4424
511
*/
4425
 
 
4426
 
static uint
4427
 
max_part_bit(key_part_map bits)
 
512
uint32_t max_part_bit(key_part_map bits)
4428
513
{
4429
 
  uint found;
 
514
  uint32_t found;
4430
515
  for (found=0; bits & 1 ; found++,bits>>=1) ;
4431
516
  return found;
4432
517
}
4433
518
 
4434
 
static void
4435
 
add_key_part(DYNAMIC_ARRAY *keyuse_array,KEY_FIELD *key_field)
4436
 
{
4437
 
  Field *field=key_field->field;
4438
 
  TABLE *form= field->table;
4439
 
  KEYUSE keyuse;
4440
 
 
4441
 
  if (key_field->eq_func && !(key_field->optimize & KEY_OPTIMIZE_EXISTS))
4442
 
  {
4443
 
    for (uint key=0 ; key < form->s->keys ; key++)
4444
 
    {
4445
 
      if (!(form->keys_in_use_for_query.is_set(key)))
4446
 
        continue;
4447
 
 
4448
 
      uint key_parts= (uint) form->key_info[key].key_parts;
4449
 
      for (uint part=0 ; part <  key_parts ; part++)
4450
 
      {
4451
 
        if (field->eq(form->key_info[key].key_part[part].field))
4452
 
        {
4453
 
          keyuse.table= field->table;
4454
 
          keyuse.val =  key_field->val;
4455
 
          keyuse.key =  key;
4456
 
          keyuse.keypart=part;
4457
 
          keyuse.keypart_map= (key_part_map) 1 << part;
4458
 
          keyuse.used_tables=key_field->val->used_tables();
4459
 
          keyuse.optimize= key_field->optimize & KEY_OPTIMIZE_REF_OR_NULL;
4460
 
          keyuse.null_rejecting= key_field->null_rejecting;
4461
 
          keyuse.cond_guard= key_field->cond_guard;
4462
 
          keyuse.sj_pred_no= key_field->sj_pred_no;
4463
 
          VOID(insert_dynamic(keyuse_array,(uchar*) &keyuse));
4464
 
        }
4465
 
      }
4466
 
    }
4467
 
  }
4468
 
}
4469
 
 
4470
 
static int
4471
 
sort_keyuse(KEYUSE *a,KEYUSE *b)
 
519
static int sort_keyuse(optimizer::KeyUse *a, optimizer::KeyUse *b)
4472
520
{
4473
521
  int res;
4474
 
  if (a->table->tablenr != b->table->tablenr)
4475
 
    return (int) (a->table->tablenr - b->table->tablenr);
4476
 
  if (a->key != b->key)
4477
 
    return (int) (a->key - b->key);
4478
 
  if (a->keypart != b->keypart)
4479
 
    return (int) (a->keypart - b->keypart);
 
522
  if (a->getTable()->tablenr != b->getTable()->tablenr)
 
523
    return static_cast<int>((a->getTable()->tablenr - b->getTable()->tablenr));
 
524
  if (a->getKey() != b->getKey())
 
525
    return static_cast<int>((a->getKey() - b->getKey()));
 
526
  if (a->getKeypart() != b->getKeypart())
 
527
    return static_cast<int>((a->getKeypart() - b->getKeypart()));
4480
528
  // Place const values before other ones
4481
 
  if ((res= test((a->used_tables & ~OUTER_REF_TABLE_BIT)) -
4482
 
       test((b->used_tables & ~OUTER_REF_TABLE_BIT))))
 
529
  if ((res= test((a->getUsedTables() & ~OUTER_REF_TABLE_BIT)) -
 
530
       test((b->getUsedTables() & ~OUTER_REF_TABLE_BIT))))
4483
531
    return res;
4484
532
  /* Place rows that are not 'OPTIMIZE_REF_OR_NULL' first */
4485
 
  return (int) ((a->optimize & KEY_OPTIMIZE_REF_OR_NULL) -
4486
 
                (b->optimize & KEY_OPTIMIZE_REF_OR_NULL));
4487
 
}
4488
 
 
4489
 
 
4490
 
/*
4491
 
  Add to KEY_FIELD array all 'ref' access candidates within nested join.
4492
 
 
4493
 
    This function populates KEY_FIELD array with entries generated from the 
4494
 
    ON condition of the given nested join, and does the same for nested joins 
4495
 
    contained within this nested join.
4496
 
 
4497
 
  @param[in]      nested_join_table   Nested join pseudo-table to process
4498
 
  @param[in,out]  end                 End of the key field array
4499
 
  @param[in,out]  and_level           And-level
4500
 
  @param[in,out]  sargables           Array of found sargable candidates
4501
 
 
4502
 
 
4503
 
  @note
4504
 
    We can add accesses to the tables that are direct children of this nested 
4505
 
    join (1), and are not inner tables w.r.t their neighbours (2).
4506
 
    
4507
 
    Example for #1 (outer brackets pair denotes nested join this function is 
4508
 
    invoked for):
4509
 
    @code
4510
 
     ... LEFT JOIN (t1 LEFT JOIN (t2 ... ) ) ON cond
4511
 
    @endcode
4512
 
    Example for #2:
4513
 
    @code
4514
 
     ... LEFT JOIN (t1 LEFT JOIN t2 ) ON cond
4515
 
    @endcode
4516
 
    In examples 1-2 for condition cond, we can add 'ref' access candidates to 
4517
 
    t1 only.
4518
 
    Example #3:
4519
 
    @code
4520
 
     ... LEFT JOIN (t1, t2 LEFT JOIN t3 ON inner_cond) ON cond
4521
 
    @endcode
4522
 
    Here we can add 'ref' access candidates for t1 and t2, but not for t3.
4523
 
*/
4524
 
 
4525
 
static void add_key_fields_for_nj(JOIN *join, TABLE_LIST *nested_join_table,
4526
 
                                  KEY_FIELD **end, uint *and_level,
4527
 
                                  SARGABLE_PARAM **sargables)
4528
 
{
4529
 
  List_iterator<TABLE_LIST> li(nested_join_table->nested_join->join_list);
4530
 
  List_iterator<TABLE_LIST> li2(nested_join_table->nested_join->join_list);
4531
 
  bool have_another = false;
4532
 
  table_map tables= 0;
4533
 
  TABLE_LIST *table;
4534
 
  assert(nested_join_table->nested_join);
4535
 
 
4536
 
  while ((table= li++) || (have_another && (li=li2, have_another=false,
4537
 
                                            (table= li++))))
4538
 
  {
4539
 
    if (table->nested_join)
4540
 
    {
4541
 
      if (!table->on_expr)
4542
 
      {
4543
 
        /* It's a semi-join nest. Walk into it as if it wasn't a nest */
4544
 
        have_another= true;
4545
 
        li2= li;
4546
 
        li= List_iterator<TABLE_LIST>(table->nested_join->join_list); 
4547
 
      }
4548
 
      else
4549
 
        add_key_fields_for_nj(join, table, end, and_level, sargables);
4550
 
    }
4551
 
    else
4552
 
      if (!table->on_expr)
4553
 
        tables |= table->table->map;
4554
 
  }
4555
 
  if (nested_join_table->on_expr)
4556
 
    add_key_fields(join, end, and_level, nested_join_table->on_expr, tables,
4557
 
                   sargables);
 
533
  return static_cast<int>(((a->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) -
 
534
                          (b->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL)));
4558
535
}
4559
536
 
4560
537
 
4561
538
/**
4562
539
  Update keyuse array with all possible keys we can use to fetch rows.
4563
 
  
4564
 
  @param       thd 
4565
 
  @param[out]  keyuse         Put here ordered array of KEYUSE structures
 
540
 
 
541
  @param       session
 
542
  @param[out]  keyuse         Put here ordered array of KeyUse structures
4566
543
  @param       join_tab       Array in tablenr_order
4567
544
  @param       tables         Number of tables in join
4568
545
  @param       cond           WHERE condition (note that the function analyzes
4571
548
                              for which we can make ref access based the WHERE
4572
549
                              clause)
4573
550
  @param       select_lex     current SELECT
4574
 
  @param[out]  sargables      Array of found sargable candidates
4575
 
      
 
551
  @param[out]  sargables      std::vector of found sargable candidates
 
552
 
4576
553
   @retval
4577
554
     0  OK
4578
555
   @retval
4579
556
     1  Out of memory.
4580
557
*/
4581
 
 
4582
 
static bool
4583
 
update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
4584
 
                    uint tables, COND *cond,
4585
 
                    COND_EQUAL *cond_equal __attribute__((unused)),
4586
 
                    table_map normal_tables, SELECT_LEX *select_lex,
4587
 
                    SARGABLE_PARAM **sargables)
 
558
bool update_ref_and_keys(Session *session,
 
559
                         DYNAMIC_ARRAY *keyuse,
 
560
                         JoinTable *join_tab,
 
561
                         uint32_t tables,
 
562
                         COND *cond, 
 
563
                         COND_EQUAL *,
 
564
                         table_map normal_tables,
 
565
                         Select_Lex *select_lex,
 
566
                         vector<optimizer::SargableParam> &sargables)
4588
567
{
4589
568
  uint  and_level,i,found_eq_constant;
4590
 
  KEY_FIELD *key_fields, *end, *field;
4591
 
  uint sz;
4592
 
  uint m= max(select_lex->max_equal_elems,(uint32_t)1);
4593
 
  
4594
 
  /* 
4595
 
    We use the same piece of memory to store both  KEY_FIELD 
4596
 
    and SARGABLE_PARAM structure.
4597
 
    KEY_FIELD values are placed at the beginning this memory
4598
 
    while  SARGABLE_PARAM values are put at the end.
4599
 
    All predicates that are used to fill arrays of KEY_FIELD
4600
 
    and SARGABLE_PARAM structures have at most 2 arguments
4601
 
    except BETWEEN predicates that have 3 arguments and 
 
569
  optimizer::KeyField *key_fields, *end, *field;
 
570
  uint32_t sz;
 
571
  uint32_t m= max(select_lex->max_equal_elems,(uint32_t)1);
 
572
 
 
573
  /*
 
574
    All predicates that are used to fill arrays of KeyField
 
575
    and SargableParam classes have at most 2 arguments
 
576
    except BETWEEN predicates that have 3 arguments and
4602
577
    IN predicates.
4603
 
    This any predicate if it's not BETWEEN/IN can be used 
4604
 
    directly to fill at most 2 array elements, either of KEY_FIELD
4605
 
    or SARGABLE_PARAM type. For a BETWEEN predicate 3 elements
 
578
    This any predicate if it's not BETWEEN/IN can be used
 
579
    directly to fill at most 2 array elements, either of KeyField 
 
580
    or SargableParam type. For a BETWEEN predicate 3 elements
4606
581
    can be filled as this predicate is considered as
4607
582
    saragable with respect to each of its argument.
4608
583
    An IN predicate can require at most 1 element as currently
4609
584
    it is considered as sargable only for its first argument.
4610
585
    Multiple equality can add  elements that are filled after
4611
586
    substitution of field arguments by equal fields. There
4612
 
    can be not more than select_lex->max_equal_elems such 
 
587
    can be not more than select_lex->max_equal_elems such
4613
588
    substitutions.
4614
 
  */ 
4615
 
  sz= max(sizeof(KEY_FIELD),sizeof(SARGABLE_PARAM))*
4616
 
      (((thd->lex->current_select->cond_count+1)*2 +
4617
 
        thd->lex->current_select->between_count)*m+1);
4618
 
  if (!(key_fields=(KEY_FIELD*) thd->alloc(sz)))
4619
 
    return true; /* purecov: inspected */
 
589
  */
 
590
  sz= sizeof(optimizer::KeyField) *
 
591
      (((session->lex->current_select->cond_count+1) +
 
592
        session->lex->current_select->between_count)*m+1);
 
593
  if (! (key_fields= (optimizer::KeyField*) session->alloc(sz)))
 
594
    return true;
4620
595
  and_level= 0;
4621
596
  field= end= key_fields;
4622
 
  *sargables= (SARGABLE_PARAM *) key_fields + 
4623
 
                (sz - sizeof((*sargables)[0].field))/sizeof(SARGABLE_PARAM);
4624
 
  /* set a barrier for the array of SARGABLE_PARAM */
4625
 
  (*sargables)[0].field= 0; 
4626
597
 
4627
 
  if (my_init_dynamic_array(keyuse,sizeof(KEYUSE),20,64))
 
598
  if (my_init_dynamic_array(keyuse, sizeof(optimizer::KeyUse), 20, 64))
4628
599
    return true;
4629
600
  if (cond)
4630
601
  {
4631
602
    add_key_fields(join_tab->join, &end, &and_level, cond, normal_tables,
4632
603
                   sargables);
4633
 
    for (; field != end ; field++)
 
604
    for (; field != end; field++)
4634
605
    {
4635
 
      add_key_part(keyuse,field);
 
606
      add_key_part(keyuse, field);
4636
607
      /* Mark that we can optimize LEFT JOIN */
4637
 
      if (field->val->type() == Item::NULL_ITEM &&
4638
 
          !field->field->real_maybe_null())
4639
 
        field->field->table->reginfo.not_exists_optimize=1;
 
608
      if (field->getValue()->type() == Item::NULL_ITEM &&
 
609
          ! field->getField()->real_maybe_null())
 
610
      {
 
611
        field->getField()->table->reginfo.not_exists_optimize= 1;
 
612
      }
4640
613
    }
4641
614
  }
4642
 
  for (i=0 ; i < tables ; i++)
 
615
  for (i= 0; i < tables; i++)
4643
616
  {
4644
617
    /*
4645
618
      Block the creation of keys for inner tables of outer joins.
4649
622
      In the future when we introduce conditional accesses
4650
623
      for inner tables in outer joins these keys will be taken
4651
624
      into account as well.
4652
 
    */ 
 
625
    */
4653
626
    if (*join_tab[i].on_expr_ref)
4654
 
      add_key_fields(join_tab->join, &end, &and_level, 
 
627
      add_key_fields(join_tab->join, &end, &and_level,
4655
628
                     *join_tab[i].on_expr_ref,
4656
629
                     join_tab[i].table->map, sargables);
4657
630
  }
4658
631
 
4659
632
  /* Process ON conditions for the nested joins */
4660
633
  {
4661
 
    List_iterator<TABLE_LIST> li(*join_tab->join->join_list);
4662
 
    TABLE_LIST *table;
 
634
    List_iterator<TableList> li(*join_tab->join->join_list);
 
635
    TableList *table;
4663
636
    while ((table= li++))
4664
637
    {
4665
638
      if (table->nested_join)
4666
 
        add_key_fields_for_nj(join_tab->join, table, &end, &and_level, 
 
639
        add_key_fields_for_nj(join_tab->join, table, &end, &and_level,
4667
640
                              sargables);
4668
641
    }
4669
642
  }
4683
656
  */
4684
657
  if (keyuse->elements)
4685
658
  {
4686
 
    KEYUSE key_end,*prev,*save_pos,*use;
 
659
    optimizer::KeyUse key_end,*prev,*save_pos,*use;
4687
660
 
4688
 
    my_qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE),
 
661
    my_qsort(keyuse->buffer,keyuse->elements,sizeof(optimizer::KeyUse),
4689
662
          (qsort_cmp) sort_keyuse);
4690
663
 
4691
664
    memset(&key_end, 0, sizeof(key_end)); /* Add for easy testing */
4692
 
    VOID(insert_dynamic(keyuse,(uchar*) &key_end));
 
665
    insert_dynamic(keyuse,(unsigned char*) &key_end);
4693
666
 
4694
 
    use=save_pos=dynamic_element(keyuse,0,KEYUSE*);
 
667
    use= save_pos= dynamic_element(keyuse, 0, optimizer::KeyUse*);
4695
668
    prev= &key_end;
4696
 
    found_eq_constant=0;
4697
 
    for (i=0 ; i < keyuse->elements-1 ; i++,use++)
 
669
    found_eq_constant= 0;
 
670
    for (i= 0; i < keyuse->elements-1; i++, use++)
4698
671
    {
4699
 
      if (!use->used_tables && use->optimize != KEY_OPTIMIZE_REF_OR_NULL)
4700
 
        use->table->const_key_parts[use->key]|= use->keypart_map;
 
672
      if (! use->getUsedTables() && use->getOptimizeFlags() != KEY_OPTIMIZE_REF_OR_NULL)
 
673
        use->getTable()->const_key_parts[use->getKey()]|= use->getKeypartMap();
 
674
      if (use->getKey() == prev->getKey() && use->getTable() == prev->getTable())
4701
675
      {
4702
 
        if (use->key == prev->key && use->table == prev->table)
4703
 
        {
4704
 
          if (prev->keypart+1 < use->keypart || ((prev->keypart == use->keypart) && found_eq_constant))
4705
 
            continue;                           /* remove */
4706
 
        }
4707
 
        else if (use->keypart != 0)             // First found must be 0
4708
 
          continue;
 
676
        if (prev->getKeypart() + 1 < use->getKeypart() || 
 
677
            ((prev->getKeypart() == use->getKeypart()) && found_eq_constant))
 
678
          continue;                             /* remove */
4709
679
      }
 
680
      else if (use->getKeypart() != 0)          // First found must be 0
 
681
        continue;
4710
682
 
4711
683
#ifdef HAVE_purify
4712
684
      /* Valgrind complains about overlapped memcpy when save_pos==use. */
4714
686
#endif
4715
687
        *save_pos= *use;
4716
688
      prev=use;
4717
 
      found_eq_constant= !use->used_tables;
 
689
      found_eq_constant= ! use->getUsedTables();
4718
690
      /* Save ptr to first use */
4719
 
      if (!use->table->reginfo.join_tab->keyuse)
4720
 
        use->table->reginfo.join_tab->keyuse=save_pos;
4721
 
      use->table->reginfo.join_tab->checked_keys.set_bit(use->key);
 
691
      if (! use->getTable()->reginfo.join_tab->keyuse)
 
692
        use->getTable()->reginfo.join_tab->keyuse= save_pos;
 
693
      use->getTable()->reginfo.join_tab->checked_keys.set(use->getKey());
4722
694
      save_pos++;
4723
695
    }
4724
 
    i=(uint) (save_pos-(KEYUSE*) keyuse->buffer);
4725
 
    VOID(set_dynamic(keyuse,(uchar*) &key_end,i));
4726
 
    keyuse->elements=i;
 
696
    i= (uint32_t) (save_pos - (optimizer::KeyUse*) keyuse->buffer);
 
697
    set_dynamic(keyuse, (unsigned char*) &key_end, i);
 
698
    keyuse->elements= i;
4727
699
  }
4728
700
  return false;
4729
701
}
4731
703
/**
4732
704
  Update some values in keyuse for faster choose_plan() loop.
4733
705
*/
4734
 
 
4735
 
static void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array)
 
706
void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array)
4736
707
{
4737
 
  KEYUSE *end,*keyuse= dynamic_element(keyuse_array, 0, KEYUSE*);
 
708
  optimizer::KeyUse *end,*keyuse= dynamic_element(keyuse_array, 
 
709
                                                  0, 
 
710
                                                  optimizer::KeyUse*);
4738
711
 
4739
712
  for (end= keyuse+ keyuse_array->elements ; keyuse < end ; keyuse++)
4740
713
  {
4747
720
      Constant tables are ignored.
4748
721
      To avoid bad matches, we don't make ref_table_rows less than 100.
4749
722
    */
4750
 
    keyuse->ref_table_rows= ~(ha_rows) 0;       // If no ref
4751
 
    if (keyuse->used_tables &
4752
 
        (map= (keyuse->used_tables & ~join->const_table_map &
4753
 
               ~OUTER_REF_TABLE_BIT)))
 
723
    keyuse->setTableRows(~(ha_rows) 0); // If no ref
 
724
    if (keyuse->getUsedTables() & (map= (keyuse->getUsedTables() & ~join->const_table_map & ~OUTER_REF_TABLE_BIT)))
4754
725
    {
4755
 
      uint tablenr;
 
726
      uint32_t tablenr;
4756
727
      for (tablenr=0 ; ! (map & 1) ; map>>=1, tablenr++) ;
4757
728
      if (map == 1)                     // Only one table
4758
729
      {
4759
 
        TABLE *tmp_table=join->all_tables[tablenr];
4760
 
        keyuse->ref_table_rows= max(tmp_table->file->stats.records, (ha_rows)100);
 
730
        Table *tmp_table=join->all_tables[tablenr];
 
731
        keyuse->setTableRows(max(tmp_table->cursor->stats.records, (ha_rows)100));
4761
732
      }
4762
733
    }
4763
734
    /*
4764
735
      Outer reference (external field) is constant for single executing
4765
736
      of subquery
4766
737
    */
4767
 
    if (keyuse->used_tables == OUTER_REF_TABLE_BIT)
4768
 
      keyuse->ref_table_rows= 1;
 
738
    if (keyuse->getUsedTables() == OUTER_REF_TABLE_BIT)
 
739
      keyuse->setTableRows(1);
4769
740
  }
4770
741
}
4771
742
 
4787
758
  @return
4788
759
    None
4789
760
*/
4790
 
 
4791
 
static void
4792
 
add_group_and_distinct_keys(JOIN *join, JOIN_TAB *join_tab)
 
761
void add_group_and_distinct_keys(JOIN *join, JoinTable *join_tab)
4793
762
{
4794
763
  List<Item_field> indexed_fields;
4795
764
  List_iterator<Item_field> indexed_fields_it(indexed_fields);
4796
 
  ORDER      *cur_group;
 
765
  order_st      *cur_group;
4797
766
  Item_field *cur_item;
4798
767
  key_map possible_keys(0);
4799
768
 
4801
770
  { /* Collect all query fields referenced in the GROUP clause. */
4802
771
    for (cur_group= join->group_list; cur_group; cur_group= cur_group->next)
4803
772
      (*cur_group->item)->walk(&Item::collect_item_field_processor, 0,
4804
 
                               (uchar*) &indexed_fields);
 
773
                               (unsigned char*) &indexed_fields);
4805
774
  }
4806
775
  else if (join->select_distinct)
4807
776
  { /* Collect all query fields referenced in the SELECT clause. */
4810
779
    Item *item;
4811
780
    while ((item= select_items_it++))
4812
781
      item->walk(&Item::collect_item_field_processor, 0,
4813
 
                 (uchar*) &indexed_fields);
 
782
                 (unsigned char*) &indexed_fields);
4814
783
  }
4815
784
  else
4816
785
    return;
4820
789
 
4821
790
  /* Intersect the keys of all group fields. */
4822
791
  cur_item= indexed_fields_it++;
4823
 
  possible_keys.merge(cur_item->field->part_of_key);
 
792
  possible_keys|= cur_item->field->part_of_key;
4824
793
  while ((cur_item= indexed_fields_it++))
4825
794
  {
4826
 
    possible_keys.intersect(cur_item->field->part_of_key);
4827
 
  }
4828
 
 
4829
 
  if (!possible_keys.is_clear_all())
4830
 
    join_tab->const_keys.merge(possible_keys);
4831
 
}
4832
 
 
4833
 
 
4834
 
/*****************************************************************************
4835
 
  Go through all combinations of not marked tables and find the one
4836
 
  which uses least records
4837
 
*****************************************************************************/
4838
 
 
4839
 
/** Save const tables first as used tables. */
4840
 
 
4841
 
static void
4842
 
set_position(JOIN *join,uint idx,JOIN_TAB *table,KEYUSE *key)
4843
 
{
4844
 
  join->positions[idx].table= table;
4845
 
  join->positions[idx].key=key;
4846
 
  join->positions[idx].records_read=1.0;        /* This is a const table */
4847
 
  join->positions[idx].ref_depend_map= 0;
4848
 
 
4849
 
  /* Move the const table as down as possible in best_ref */
4850
 
  JOIN_TAB **pos=join->best_ref+idx+1;
4851
 
  JOIN_TAB *next=join->best_ref[idx];
4852
 
  for (;next != table ; pos++)
4853
 
  {
4854
 
    JOIN_TAB *tmp=pos[0];
4855
 
    pos[0]=next;
4856
 
    next=tmp;
4857
 
  }
4858
 
  join->best_ref[idx]=table;
4859
 
}
4860
 
 
4861
 
 
4862
 
/*
4863
 
  Given a semi-join nest, find out which of the IN-equalities are bound
4864
 
 
4865
 
  SYNOPSIS
4866
 
    get_bound_sj_equalities()
4867
 
      sj_nest           Semi-join nest
4868
 
      remaining_tables  Tables that are not yet bound
4869
 
 
4870
 
  DESCRIPTION
4871
 
    Given a semi-join nest, find out which of the IN-equalities have their
4872
 
    left part expression bound (i.e. the said expression doesn't refer to
4873
 
    any of remaining_tables and can be evaluated).
4874
 
 
4875
 
  RETURN
4876
 
    Bitmap of bound IN-equalities.
4877
 
*/
4878
 
 
4879
 
uint64_t get_bound_sj_equalities(TABLE_LIST *sj_nest, 
4880
 
                                  table_map remaining_tables)
4881
 
{
4882
 
  List_iterator<Item> li(sj_nest->nested_join->sj_outer_expr_list);
4883
 
  Item *item;
4884
 
  uint i= 0;
4885
 
  uint64_t res= 0;
4886
 
  while ((item= li++))
4887
 
  {
4888
 
    /*
4889
 
      Q: should this take into account equality propagation and how?
4890
 
      A: If e->outer_side is an Item_field, walk over the equality
4891
 
         class and see if there is an element that is bound?
4892
 
      (this is an optional feature)
4893
 
    */
4894
 
    if (!(item->used_tables() & remaining_tables))
4895
 
    {
4896
 
      res |= 1ULL < i;
4897
 
    }
4898
 
  }
4899
 
  return res;
4900
 
}
4901
 
 
4902
 
 
4903
 
/**
4904
 
  Find the best access path for an extension of a partial execution
4905
 
  plan and add this path to the plan.
4906
 
 
4907
 
  The function finds the best access path to table 's' from the passed
4908
 
  partial plan where an access path is the general term for any means to
4909
 
  access the data in 's'. An access path may use either an index or a scan,
4910
 
  whichever is cheaper. The input partial plan is passed via the array
4911
 
  'join->positions' of length 'idx'. The chosen access method for 's' and its
4912
 
  cost are stored in 'join->positions[idx]'.
4913
 
 
4914
 
  @param join             pointer to the structure providing all context info
4915
 
                          for the query
4916
 
  @param s                the table to be joined by the function
4917
 
  @param thd              thread for the connection that submitted the query
4918
 
  @param remaining_tables set of tables not included into the partial plan yet
4919
 
  @param idx              the length of the partial plan
4920
 
  @param record_count     estimate for the number of records returned by the
4921
 
                          partial plan
4922
 
  @param read_time        the cost of the partial plan
4923
 
 
4924
 
  @return
4925
 
    None
4926
 
*/
4927
 
 
4928
 
static void
4929
 
best_access_path(JOIN      *join,
4930
 
                 JOIN_TAB  *s,
4931
 
                 THD       *thd,
4932
 
                 table_map remaining_tables,
4933
 
                 uint      idx,
4934
 
                 double    record_count,
4935
 
                 double    read_time __attribute__((unused)))
4936
 
{
4937
 
  KEYUSE *best_key=         0;
4938
 
  uint best_max_key_part=   0;
4939
 
  bool found_constraint= 0;
4940
 
  double best=              DBL_MAX;
4941
 
  double best_time=         DBL_MAX;
4942
 
  double records=           DBL_MAX;
4943
 
  table_map best_ref_depends_map= 0;
4944
 
  double tmp;
4945
 
  ha_rows rec;
4946
 
  uint best_is_sj_inside_out=    0;
4947
 
 
4948
 
  if (s->keyuse)
4949
 
  {                                            /* Use key if possible */
4950
 
    TABLE *table= s->table;
4951
 
    KEYUSE *keyuse,*start_key=0;
4952
 
    double best_records= DBL_MAX;
4953
 
    uint max_key_part=0;
4954
 
    uint64_t bound_sj_equalities= 0;
4955
 
    bool try_sj_inside_out= false;
4956
 
    /*
4957
 
      Discover the bound equalites. We need to do this, if
4958
 
        1. The next table is an SJ-inner table, and
4959
 
        2. It is the first table from that semijoin, and
4960
 
        3. We're not within a semi-join range (i.e. all semi-joins either have
4961
 
           all or none of their tables in join_table_map), except
4962
 
           s->emb_sj_nest (which we've just entered).
4963
 
        3. All correlation references from this sj-nest are bound
4964
 
    */
4965
 
    if (s->emb_sj_nest &&                                                 // (1)
4966
 
        s->emb_sj_nest->sj_in_exprs < 64 && 
4967
 
        ((remaining_tables & s->emb_sj_nest->sj_inner_tables) ==           // (2)
4968
 
         s->emb_sj_nest->sj_inner_tables) &&                               // (2)
4969
 
        join->cur_emb_sj_nests == s->emb_sj_nest->sj_inner_tables &&       // (3)
4970
 
        !(remaining_tables & s->emb_sj_nest->nested_join->sj_corr_tables)) // (4)
4971
 
    {
4972
 
      /* This table is an InsideOut scan candidate */
4973
 
      bound_sj_equalities= get_bound_sj_equalities(s->emb_sj_nest, 
4974
 
                                                   remaining_tables);
4975
 
      try_sj_inside_out= true;
4976
 
    }
4977
 
 
4978
 
    /* Test how we can use keys */
4979
 
    rec= s->records/MATCHING_ROWS_IN_OTHER_TABLE;  // Assumed records/key
4980
 
    for (keyuse=s->keyuse ; keyuse->table == table ;)
4981
 
    {
4982
 
      key_part_map found_part= 0;
4983
 
      table_map found_ref= 0;
4984
 
      uint key= keyuse->key;
4985
 
      KEY *keyinfo= table->key_info+key;
4986
 
      /* Bitmap of keyparts where the ref access is over 'keypart=const': */
4987
 
      key_part_map const_part= 0;
4988
 
      /* The or-null keypart in ref-or-null access: */
4989
 
      key_part_map ref_or_null_part= 0;
4990
 
 
4991
 
      /* Calculate how many key segments of the current key we can use */
4992
 
      start_key= keyuse;
4993
 
      uint64_t handled_sj_equalities=0;
4994
 
      key_part_map sj_insideout_map= 0;
4995
 
 
4996
 
      do /* For each keypart */
4997
 
      {
4998
 
        uint keypart= keyuse->keypart;
4999
 
        table_map best_part_found_ref= 0;
5000
 
        double best_prev_record_reads= DBL_MAX;
5001
 
        
5002
 
        do /* For each way to access the keypart */
5003
 
        {
5004
 
 
5005
 
          /*
5006
 
            if 1. expression doesn't refer to forward tables
5007
 
               2. we won't get two ref-or-null's
5008
 
          */
5009
 
          if (!(remaining_tables & keyuse->used_tables) &&
5010
 
              !(ref_or_null_part && (keyuse->optimize &
5011
 
                                     KEY_OPTIMIZE_REF_OR_NULL)))
5012
 
          {
5013
 
            found_part|= keyuse->keypart_map;
5014
 
            if (!(keyuse->used_tables & ~join->const_table_map))
5015
 
              const_part|= keyuse->keypart_map;
5016
 
 
5017
 
            double tmp2= prev_record_reads(join, idx, (found_ref |
5018
 
                                                      keyuse->used_tables));
5019
 
            if (tmp2 < best_prev_record_reads)
5020
 
            {
5021
 
              best_part_found_ref= keyuse->used_tables & ~join->const_table_map;
5022
 
              best_prev_record_reads= tmp2;
5023
 
            }
5024
 
            if (rec > keyuse->ref_table_rows)
5025
 
              rec= keyuse->ref_table_rows;
5026
 
            /*
5027
 
              If there is one 'key_column IS NULL' expression, we can
5028
 
              use this ref_or_null optimisation of this field
5029
 
            */
5030
 
            if (keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL)
5031
 
              ref_or_null_part |= keyuse->keypart_map;
5032
 
          }
5033
 
 
5034
 
          if (try_sj_inside_out && keyuse->sj_pred_no != UINT_MAX)
5035
 
          {
5036
 
            if (!(remaining_tables & keyuse->used_tables))
5037
 
              bound_sj_equalities |= 1ULL << keyuse->sj_pred_no;
5038
 
            else
5039
 
            {
5040
 
              handled_sj_equalities |= 1ULL << keyuse->sj_pred_no;
5041
 
              sj_insideout_map |= ((key_part_map)1) << keyuse->keypart;
5042
 
            }
5043
 
          }
5044
 
 
5045
 
          keyuse++;
5046
 
        } while (keyuse->table == table && keyuse->key == key &&
5047
 
                 keyuse->keypart == keypart);
5048
 
        found_ref|= best_part_found_ref;
5049
 
      } while (keyuse->table == table && keyuse->key == key);
5050
 
 
5051
 
      /*
5052
 
        Assume that that each key matches a proportional part of table.
5053
 
      */
5054
 
      if (!found_part && !handled_sj_equalities)
5055
 
        continue;                               // Nothing usable found
5056
 
 
5057
 
      if (rec < MATCHING_ROWS_IN_OTHER_TABLE)
5058
 
        rec= MATCHING_ROWS_IN_OTHER_TABLE;      // Fix for small tables
5059
 
 
5060
 
      bool sj_inside_out_scan= false;
5061
 
      {
5062
 
        found_constraint= 1;
5063
 
        /*
5064
 
          Check if InsideOut scan is applicable:
5065
 
          1. All IN-equalities are either "bound" or "handled"
5066
 
          2. Index keyparts are 
5067
 
             ...
5068
 
        */
5069
 
        if (try_sj_inside_out && 
5070
 
            table->covering_keys.is_set(key) &&
5071
 
            (handled_sj_equalities | bound_sj_equalities) ==     // (1)
5072
 
            PREV_BITS(uint64_t, s->emb_sj_nest->sj_in_exprs)) // (1)
5073
 
        {
5074
 
          uint n_fixed_parts= max_part_bit(found_part);
5075
 
          if (n_fixed_parts != keyinfo->key_parts &&
5076
 
              (PREV_BITS(uint, n_fixed_parts) | sj_insideout_map) ==
5077
 
               PREV_BITS(uint, keyinfo->key_parts))
5078
 
          {
5079
 
            /*
5080
 
              Not all parts are fixed. Produce bitmap of remaining bits and
5081
 
              check if all of them are covered.
5082
 
            */
5083
 
            sj_inside_out_scan= true;
5084
 
            if (!n_fixed_parts)
5085
 
            {
5086
 
              /*
5087
 
                It's a confluent ref scan.
5088
 
 
5089
 
                That is, all found KEYUSE elements refer to IN-equalities,
5090
 
                and there is really no ref access because there is no
5091
 
                  t.keypart0 = {bound expression}
5092
 
 
5093
 
                Calculate the cost of complete loose index scan.
5094
 
              */
5095
 
              records= (double)s->table->file->stats.records;
5096
 
 
5097
 
              /* The cost is entire index scan cost (divided by 2) */
5098
 
              best_time= s->table->file->index_only_read_time(key, records);
5099
 
 
5100
 
              /* Now figure how many different keys we will get */
5101
 
              ulong rpc;
5102
 
              if ((rpc= keyinfo->rec_per_key[keyinfo->key_parts-1]))
5103
 
                records= records / rpc;
5104
 
              start_key= NULL;
5105
 
            }
5106
 
          }
5107
 
        }
5108
 
 
5109
 
        /*
5110
 
          Check if we found full key
5111
 
        */
5112
 
        if (found_part == PREV_BITS(uint,keyinfo->key_parts) &&
5113
 
            !ref_or_null_part)
5114
 
        {                                         /* use eq key */
5115
 
          max_key_part= (uint) ~0;
5116
 
          if ((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME)
5117
 
          {
5118
 
            tmp = prev_record_reads(join, idx, found_ref);
5119
 
            records=1.0;
5120
 
          }
5121
 
          else
5122
 
          {
5123
 
            if (!found_ref)
5124
 
            {                                     /* We found a const key */
5125
 
              /*
5126
 
                ReuseRangeEstimateForRef-1:
5127
 
                We get here if we've found a ref(const) (c_i are constants):
5128
 
                  "(keypart1=c1) AND ... AND (keypartN=cN)"   [ref_const_cond]
5129
 
                
5130
 
                If range optimizer was able to construct a "range" 
5131
 
                access on this index, then its condition "quick_cond" was
5132
 
                eqivalent to ref_const_cond (*), and we can re-use E(#rows)
5133
 
                from the range optimizer.
5134
 
                
5135
 
                Proof of (*): By properties of range and ref optimizers 
5136
 
                quick_cond will be equal or tighther than ref_const_cond. 
5137
 
                ref_const_cond already covers "smallest" possible interval - 
5138
 
                a singlepoint interval over all keyparts. Therefore, 
5139
 
                quick_cond is equivalent to ref_const_cond (if it was an 
5140
 
                empty interval we wouldn't have got here).
5141
 
              */
5142
 
              if (table->quick_keys.is_set(key))
5143
 
                records= (double) table->quick_rows[key];
5144
 
              else
5145
 
              {
5146
 
                /* quick_range couldn't use key! */
5147
 
                records= (double) s->records/rec;
5148
 
              }
5149
 
            }
5150
 
            else
5151
 
            {
5152
 
              if (!(records=keyinfo->rec_per_key[keyinfo->key_parts-1]))
5153
 
              {                                   /* Prefer longer keys */
5154
 
                records=
5155
 
                  ((double) s->records / (double) rec *
5156
 
                   (1.0 +
5157
 
                    ((double) (table->s->max_key_length-keyinfo->key_length) /
5158
 
                     (double) table->s->max_key_length)));
5159
 
                if (records < 2.0)
5160
 
                  records=2.0;               /* Can't be as good as a unique */
5161
 
              }
5162
 
              /*
5163
 
                ReuseRangeEstimateForRef-2:  We get here if we could not reuse
5164
 
                E(#rows) from range optimizer. Make another try:
5165
 
                
5166
 
                If range optimizer produced E(#rows) for a prefix of the ref
5167
 
                access we're considering, and that E(#rows) is lower then our
5168
 
                current estimate, make an adjustment. The criteria of when we
5169
 
                can make an adjustment is a special case of the criteria used
5170
 
                in ReuseRangeEstimateForRef-3.
5171
 
              */
5172
 
              if (table->quick_keys.is_set(key) &&
5173
 
                  const_part & (1 << table->quick_key_parts[key]) &&
5174
 
                  table->quick_n_ranges[key] == 1 &&
5175
 
                  records > (double) table->quick_rows[key])
5176
 
              {
5177
 
                records= (double) table->quick_rows[key];
5178
 
              }
5179
 
            }
5180
 
            /* Limit the number of matched rows */
5181
 
            tmp= records;
5182
 
            set_if_smaller(tmp, (double) thd->variables.max_seeks_for_key);
5183
 
            if (table->covering_keys.is_set(key))
5184
 
            {
5185
 
              /* we can use only index tree */
5186
 
              tmp= record_count * table->file->index_only_read_time(key, tmp);
5187
 
            }
5188
 
            else
5189
 
              tmp= record_count*min(tmp,s->worst_seeks);
5190
 
          }
5191
 
        }
5192
 
        else
5193
 
        {
5194
 
          /*
5195
 
            Use as much key-parts as possible and a uniq key is better
5196
 
            than a not unique key
5197
 
            Set tmp to (previous record count) * (records / combination)
5198
 
          */
5199
 
          if ((found_part & 1) &&
5200
 
              (!(table->file->index_flags(key, 0, 0) & HA_ONLY_WHOLE_INDEX) ||
5201
 
               found_part == PREV_BITS(uint,keyinfo->key_parts)))
5202
 
          {
5203
 
            max_key_part= max_part_bit(found_part);
5204
 
            /*
5205
 
              ReuseRangeEstimateForRef-3:
5206
 
              We're now considering a ref[or_null] access via
5207
 
              (t.keypart1=e1 AND ... AND t.keypartK=eK) [ OR  
5208
 
              (same-as-above but with one cond replaced 
5209
 
               with "t.keypart_i IS NULL")]  (**)
5210
 
              
5211
 
              Try re-using E(#rows) from "range" optimizer:
5212
 
              We can do so if "range" optimizer used the same intervals as
5213
 
              in (**). The intervals used by range optimizer may be not 
5214
 
              available at this point (as "range" access might have choosen to
5215
 
              create quick select over another index), so we can't compare
5216
 
              them to (**). We'll make indirect judgements instead.
5217
 
              The sufficient conditions for re-use are:
5218
 
              (C1) All e_i in (**) are constants, i.e. found_ref==false. (if
5219
 
                   this is not satisfied we have no way to know which ranges
5220
 
                   will be actually scanned by 'ref' until we execute the 
5221
 
                   join)
5222
 
              (C2) max #key parts in 'range' access == K == max_key_part (this
5223
 
                   is apparently a necessary requirement)
5224
 
 
5225
 
              We also have a property that "range optimizer produces equal or 
5226
 
              tighter set of scan intervals than ref(const) optimizer". Each
5227
 
              of the intervals in (**) are "tightest possible" intervals when 
5228
 
              one limits itself to using keyparts 1..K (which we do in #2).              
5229
 
              From here it follows that range access used either one, or
5230
 
              both of the (I1) and (I2) intervals:
5231
 
              
5232
 
               (t.keypart1=c1 AND ... AND t.keypartK=eK)  (I1) 
5233
 
               (same-as-above but with one cond replaced  
5234
 
                with "t.keypart_i IS NULL")               (I2)
5235
 
 
5236
 
              The remaining part is to exclude the situation where range
5237
 
              optimizer used one interval while we're considering
5238
 
              ref-or-null and looking for estimate for two intervals. This
5239
 
              is done by last limitation:
5240
 
 
5241
 
              (C3) "range optimizer used (have ref_or_null?2:1) intervals"
5242
 
            */
5243
 
            if (table->quick_keys.is_set(key) && !found_ref &&          //(C1)
5244
 
                table->quick_key_parts[key] == max_key_part &&          //(C2)
5245
 
                table->quick_n_ranges[key] == 1+test(ref_or_null_part)) //(C3)
5246
 
            {
5247
 
              tmp= records= (double) table->quick_rows[key];
5248
 
            }
5249
 
            else
5250
 
            {
5251
 
              /* Check if we have statistic about the distribution */
5252
 
              if ((records= keyinfo->rec_per_key[max_key_part-1]))
5253
 
              {
5254
 
                /* 
5255
 
                  Fix for the case where the index statistics is too
5256
 
                  optimistic: If 
5257
 
                  (1) We're considering ref(const) and there is quick select
5258
 
                      on the same index, 
5259
 
                  (2) and that quick select uses more keyparts (i.e. it will
5260
 
                      scan equal/smaller interval then this ref(const))
5261
 
                  (3) and E(#rows) for quick select is higher then our
5262
 
                      estimate,
5263
 
                  Then 
5264
 
                    We'll use E(#rows) from quick select.
5265
 
 
5266
 
                  Q: Why do we choose to use 'ref'? Won't quick select be
5267
 
                  cheaper in some cases ?
5268
 
                  TODO: figure this out and adjust the plan choice if needed.
5269
 
                */
5270
 
                if (!found_ref && table->quick_keys.is_set(key) &&    // (1)
5271
 
                    table->quick_key_parts[key] > max_key_part &&     // (2)
5272
 
                    records < (double)table->quick_rows[key])         // (3)
5273
 
                  records= (double)table->quick_rows[key];
5274
 
 
5275
 
                tmp= records;
5276
 
              }
5277
 
              else
5278
 
              {
5279
 
                /*
5280
 
                  Assume that the first key part matches 1% of the file
5281
 
                  and that the whole key matches 10 (duplicates) or 1
5282
 
                  (unique) records.
5283
 
                  Assume also that more key matches proportionally more
5284
 
                  records
5285
 
                  This gives the formula:
5286
 
                  records = (x * (b-a) + a*c-b)/(c-1)
5287
 
 
5288
 
                  b = records matched by whole key
5289
 
                  a = records matched by first key part (1% of all records?)
5290
 
                  c = number of key parts in key
5291
 
                  x = used key parts (1 <= x <= c)
5292
 
                */
5293
 
                double rec_per_key;
5294
 
                if (!(rec_per_key=(double)
5295
 
                      keyinfo->rec_per_key[keyinfo->key_parts-1]))
5296
 
                  rec_per_key=(double) s->records/rec+1;
5297
 
 
5298
 
                if (!s->records)
5299
 
                  tmp = 0;
5300
 
                else if (rec_per_key/(double) s->records >= 0.01)
5301
 
                  tmp = rec_per_key;
5302
 
                else
5303
 
                {
5304
 
                  double a=s->records*0.01;
5305
 
                  if (keyinfo->key_parts > 1)
5306
 
                    tmp= (max_key_part * (rec_per_key - a) +
5307
 
                          a*keyinfo->key_parts - rec_per_key)/
5308
 
                         (keyinfo->key_parts-1);
5309
 
                  else
5310
 
                    tmp= a;
5311
 
                  set_if_bigger(tmp,1.0);
5312
 
                }
5313
 
                records = (ulong) tmp;
5314
 
              }
5315
 
 
5316
 
              if (ref_or_null_part)
5317
 
              {
5318
 
                /* We need to do two key searches to find key */
5319
 
                tmp *= 2.0;
5320
 
                records *= 2.0;
5321
 
              }
5322
 
 
5323
 
              /*
5324
 
                ReuseRangeEstimateForRef-4:  We get here if we could not reuse
5325
 
                E(#rows) from range optimizer. Make another try:
5326
 
                
5327
 
                If range optimizer produced E(#rows) for a prefix of the ref 
5328
 
                access we're considering, and that E(#rows) is lower then our
5329
 
                current estimate, make the adjustment.
5330
 
 
5331
 
                The decision whether we can re-use the estimate from the range
5332
 
                optimizer is the same as in ReuseRangeEstimateForRef-3,
5333
 
                applied to first table->quick_key_parts[key] key parts.
5334
 
              */
5335
 
              if (table->quick_keys.is_set(key) &&
5336
 
                  table->quick_key_parts[key] <= max_key_part &&
5337
 
                  const_part & (1 << table->quick_key_parts[key]) &&
5338
 
                  table->quick_n_ranges[key] == 1 + test(ref_or_null_part &
5339
 
                                                         const_part) &&
5340
 
                  records > (double) table->quick_rows[key])
5341
 
              {
5342
 
                tmp= records= (double) table->quick_rows[key];
5343
 
              }
5344
 
            }
5345
 
 
5346
 
            /* Limit the number of matched rows */
5347
 
            set_if_smaller(tmp, (double) thd->variables.max_seeks_for_key);
5348
 
            if (table->covering_keys.is_set(key))
5349
 
            {
5350
 
              /* we can use only index tree */
5351
 
              tmp= record_count * table->file->index_only_read_time(key, tmp);
5352
 
            }
5353
 
            else
5354
 
              tmp= record_count * min(tmp,s->worst_seeks);
5355
 
          }
5356
 
          else
5357
 
            tmp= best_time;                    // Do nothing
5358
 
        }
5359
 
 
5360
 
        if (sj_inside_out_scan && !start_key)
5361
 
        {
5362
 
          tmp= tmp/2;
5363
 
          if (records)
5364
 
            records= records/2;
5365
 
        }
5366
 
 
5367
 
      }
5368
 
      if (tmp < best_time - records/(double) TIME_FOR_COMPARE)
5369
 
      {
5370
 
        best_time= tmp + records/(double) TIME_FOR_COMPARE;
5371
 
        best= tmp;
5372
 
        best_records= records;
5373
 
        best_key= start_key;
5374
 
        best_max_key_part= max_key_part;
5375
 
        best_ref_depends_map= found_ref;
5376
 
        best_is_sj_inside_out= sj_inside_out_scan;
5377
 
      }
5378
 
    }
5379
 
    records= best_records;
5380
 
  }
5381
 
 
5382
 
  /*
5383
 
    Don't test table scan if it can't be better.
5384
 
    Prefer key lookup if we would use the same key for scanning.
5385
 
 
5386
 
    Don't do a table scan on InnoDB tables, if we can read the used
5387
 
    parts of the row from any of the used index.
5388
 
    This is because table scans uses index and we would not win
5389
 
    anything by using a table scan.
5390
 
 
5391
 
    A word for word translation of the below if-statement in sergefp's
5392
 
    understanding: we check if we should use table scan if:
5393
 
    (1) The found 'ref' access produces more records than a table scan
5394
 
        (or index scan, or quick select), or 'ref' is more expensive than
5395
 
        any of them.
5396
 
    (2) This doesn't hold: the best way to perform table scan is to to perform
5397
 
        'range' access using index IDX, and the best way to perform 'ref' 
5398
 
        access is to use the same index IDX, with the same or more key parts.
5399
 
        (note: it is not clear how this rule is/should be extended to 
5400
 
        index_merge quick selects)
5401
 
    (3) See above note about InnoDB.
5402
 
    (4) NOT ("FORCE INDEX(...)" is used for table and there is 'ref' access
5403
 
             path, but there is no quick select)
5404
 
        If the condition in the above brackets holds, then the only possible
5405
 
        "table scan" access method is ALL/index (there is no quick select).
5406
 
        Since we have a 'ref' access path, and FORCE INDEX instructs us to
5407
 
        choose it over ALL/index, there is no need to consider a full table
5408
 
        scan.
5409
 
  */
5410
 
  if ((records >= s->found_records || best > s->read_time) &&            // (1)
5411
 
      !(s->quick && best_key && s->quick->index == best_key->key &&      // (2)
5412
 
        best_max_key_part >= s->table->quick_key_parts[best_key->key]) &&// (2)
5413
 
      !((s->table->file->ha_table_flags() & HA_TABLE_SCAN_ON_INDEX) &&   // (3)
5414
 
        ! s->table->covering_keys.is_clear_all() && best_key && !s->quick) &&// (3)
5415
 
      !(s->table->force_index && best_key && !s->quick))                 // (4)
5416
 
  {                                             // Check full join
5417
 
    ha_rows rnd_records= s->found_records;
5418
 
    /*
5419
 
      If there is a filtering condition on the table (i.e. ref analyzer found
5420
 
      at least one "table.keyXpartY= exprZ", where exprZ refers only to tables
5421
 
      preceding this table in the join order we're now considering), then 
5422
 
      assume that 25% of the rows will be filtered out by this condition.
5423
 
 
5424
 
      This heuristic is supposed to force tables used in exprZ to be before
5425
 
      this table in join order.
5426
 
    */
5427
 
    if (found_constraint)
5428
 
      rnd_records-= rnd_records/4;
5429
 
 
5430
 
    /*
5431
 
      If applicable, get a more accurate estimate. Don't use the two
5432
 
      heuristics at once.
5433
 
    */
5434
 
    if (s->table->quick_condition_rows != s->found_records)
5435
 
      rnd_records= s->table->quick_condition_rows;
5436
 
 
5437
 
    /*
5438
 
      Range optimizer never proposes a RANGE if it isn't better
5439
 
      than FULL: so if RANGE is present, it's always preferred to FULL.
5440
 
      Here we estimate its cost.
5441
 
    */
5442
 
    if (s->quick)
5443
 
    {
5444
 
      /*
5445
 
        For each record we:
5446
 
        - read record range through 'quick'
5447
 
        - skip rows which does not satisfy WHERE constraints
5448
 
        TODO: 
5449
 
        We take into account possible use of join cache for ALL/index
5450
 
        access (see first else-branch below), but we don't take it into 
5451
 
        account here for range/index_merge access. Find out why this is so.
5452
 
      */
5453
 
      tmp= record_count *
5454
 
        (s->quick->read_time +
5455
 
         (s->found_records - rnd_records)/(double) TIME_FOR_COMPARE);
5456
 
    }
5457
 
    else
5458
 
    {
5459
 
      /* Estimate cost of reading table. */
5460
 
      tmp= s->table->file->scan_time();
5461
 
      if (s->table->map & join->outer_join)     // Can't use join cache
5462
 
      {
5463
 
        /*
5464
 
          For each record we have to:
5465
 
          - read the whole table record 
5466
 
          - skip rows which does not satisfy join condition
5467
 
        */
5468
 
        tmp= record_count *
5469
 
          (tmp +
5470
 
           (s->records - rnd_records)/(double) TIME_FOR_COMPARE);
5471
 
      }
5472
 
      else
5473
 
      {
5474
 
        /* We read the table as many times as join buffer becomes full. */
5475
 
        tmp*= (1.0 + floor((double) cache_record_length(join,idx) *
5476
 
                           record_count /
5477
 
                           (double) thd->variables.join_buff_size));
5478
 
        /* 
5479
 
            We don't make full cartesian product between rows in the scanned
5480
 
           table and existing records because we skip all rows from the
5481
 
           scanned table, which does not satisfy join condition when 
5482
 
           we read the table (see flush_cached_records for details). Here we
5483
 
           take into account cost to read and skip these records.
5484
 
        */
5485
 
        tmp+= (s->records - rnd_records)/(double) TIME_FOR_COMPARE;
5486
 
      }
5487
 
    }
5488
 
 
5489
 
    /*
5490
 
      We estimate the cost of evaluating WHERE clause for found records
5491
 
      as record_count * rnd_records / TIME_FOR_COMPARE. This cost plus
5492
 
      tmp give us total cost of using TABLE SCAN
5493
 
    */
5494
 
    if (best == DBL_MAX ||
5495
 
        (tmp  + record_count/(double) TIME_FOR_COMPARE*rnd_records <
5496
 
         best + record_count/(double) TIME_FOR_COMPARE*records))
5497
 
    {
5498
 
      /*
5499
 
        If the table has a range (s->quick is set) make_join_select()
5500
 
        will ensure that this will be used
5501
 
      */
5502
 
      best= tmp;
5503
 
      records= rows2double(rnd_records);
5504
 
      best_key= 0;
5505
 
      /* range/index_merge/ALL/index access method are "independent", so: */
5506
 
      best_ref_depends_map= 0;
5507
 
      best_is_sj_inside_out= false;
5508
 
    }
5509
 
  }
5510
 
 
5511
 
  /* Update the cost information for the current partial plan */
5512
 
  join->positions[idx].records_read= records;
5513
 
  join->positions[idx].read_time=    best;
5514
 
  join->positions[idx].key=          best_key;
5515
 
  join->positions[idx].table=        s;
5516
 
  join->positions[idx].ref_depend_map= best_ref_depends_map;
5517
 
  join->positions[idx].use_insideout_scan= best_is_sj_inside_out;
5518
 
 
5519
 
  if (!best_key &&
5520
 
      idx == join->const_tables &&
5521
 
      s->table == join->sort_by_table &&
5522
 
      join->unit->select_limit_cnt >= records)
5523
 
    join->sort_by_table= (TABLE*) 1;  // Must use temporary table
5524
 
 
5525
 
  return;
5526
 
}
5527
 
 
5528
 
 
5529
 
/**
5530
 
  Selects and invokes a search strategy for an optimal query plan.
5531
 
 
5532
 
  The function checks user-configurable parameters that control the search
5533
 
  strategy for an optimal plan, selects the search method and then invokes
5534
 
  it. Each specific optimization procedure stores the final optimal plan in
5535
 
  the array 'join->best_positions', and the cost of the plan in
5536
 
  'join->best_read'.
5537
 
 
5538
 
  @param join         pointer to the structure providing all context info for
5539
 
                      the query
5540
 
  @param join_tables  set of the tables in the query
5541
 
 
5542
 
  @todo
5543
 
    'MAX_TABLES+2' denotes the old implementation of find_best before
5544
 
    the greedy version. Will be removed when greedy_search is approved.
5545
 
 
5546
 
  @retval
5547
 
    false       ok
5548
 
  @retval
5549
 
    true        Fatal error
5550
 
*/
5551
 
 
5552
 
static bool
5553
 
choose_plan(JOIN *join, table_map join_tables)
5554
 
{
5555
 
  uint search_depth= join->thd->variables.optimizer_search_depth;
5556
 
  uint prune_level=  join->thd->variables.optimizer_prune_level;
5557
 
  bool straight_join= test(join->select_options & SELECT_STRAIGHT_JOIN);
5558
 
 
5559
 
  join->cur_embedding_map= 0;
5560
 
  reset_nj_counters(join->join_list);
5561
 
  /*
5562
 
    if (SELECT_STRAIGHT_JOIN option is set)
5563
 
      reorder tables so dependent tables come after tables they depend 
5564
 
      on, otherwise keep tables in the order they were specified in the query 
5565
 
    else
5566
 
      Apply heuristic: pre-sort all access plans with respect to the number of
5567
 
      records accessed.
5568
 
  */
5569
 
  my_qsort(join->best_ref + join->const_tables,
5570
 
           join->tables - join->const_tables, sizeof(JOIN_TAB*),
5571
 
           straight_join ? join_tab_cmp_straight : join_tab_cmp);
5572
 
  join->cur_emb_sj_nests= 0;
5573
 
  if (straight_join)
5574
 
  {
5575
 
    optimize_straight_join(join, join_tables);
5576
 
  }
5577
 
  else
5578
 
  {
5579
 
    if (search_depth == MAX_TABLES+2)
5580
 
    { /*
5581
 
        TODO: 'MAX_TABLES+2' denotes the old implementation of find_best before
5582
 
        the greedy version. Will be removed when greedy_search is approved.
5583
 
      */
5584
 
      join->best_read= DBL_MAX;
5585
 
      if (find_best(join, join_tables, join->const_tables, 1.0, 0.0))
5586
 
        return(true);
5587
 
    } 
5588
 
    else
5589
 
    {
5590
 
      if (search_depth == 0)
5591
 
        /* Automatically determine a reasonable value for 'search_depth' */
5592
 
        search_depth= determine_search_depth(join);
5593
 
      if (greedy_search(join, join_tables, search_depth, prune_level))
5594
 
        return(true);
5595
 
    }
5596
 
  }
5597
 
 
5598
 
  /* 
5599
 
    Store the cost of this query into a user variable
5600
 
    Don't update last_query_cost for statements that are not "flat joins" :
5601
 
    i.e. they have subqueries, unions or call stored procedures.
5602
 
    TODO: calculate a correct cost for a query with subqueries and UNIONs.
5603
 
  */
5604
 
  if (join->thd->lex->is_single_level_stmt())
5605
 
    join->thd->status_var.last_query_cost= join->best_read;
5606
 
  return(false);
5607
 
}
5608
 
 
5609
 
 
5610
 
/**
5611
 
  Compare two JOIN_TAB objects based on the number of accessed records.
5612
 
 
5613
 
  @param ptr1 pointer to first JOIN_TAB object
5614
 
  @param ptr2 pointer to second JOIN_TAB object
 
795
    possible_keys&= cur_item->field->part_of_key;
 
796
  }
 
797
 
 
798
  if (possible_keys.any())
 
799
    join_tab->const_keys|= possible_keys;
 
800
}
 
801
 
 
802
/**
 
803
  Compare two JoinTable objects based on the number of accessed records.
 
804
 
 
805
  @param ptr1 pointer to first JoinTable object
 
806
  @param ptr2 pointer to second JoinTable object
5615
807
 
5616
808
  NOTES
5617
809
    The order relation implemented by join_tab_cmp() is not transitive,
5623
815
      a: dependent = 0x0 table->map = 0x1 found_records = 3 ptr = 0x907e6b0
5624
816
      b: dependent = 0x0 table->map = 0x2 found_records = 3 ptr = 0x907e838
5625
817
      c: dependent = 0x6 table->map = 0x10 found_records = 2 ptr = 0x907ecd0
5626
 
     
 
818
 
5627
819
  @retval
5628
820
    1  if first is bigger
5629
821
  @retval
5631
823
  @retval
5632
824
    0  if equal
5633
825
*/
5634
 
 
5635
 
static int
5636
 
join_tab_cmp(const void* ptr1, const void* ptr2)
 
826
int join_tab_cmp(const void* ptr1, const void* ptr2)
5637
827
{
5638
 
  JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;
5639
 
  JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;
 
828
  JoinTable *jt1= *(JoinTable**) ptr1;
 
829
  JoinTable *jt2= *(JoinTable**) ptr2;
5640
830
 
5641
831
  if (jt1->dependent & jt2->table->map)
5642
832
    return 1;
5643
833
  if (jt2->dependent & jt1->table->map)
5644
 
    return -1;  
 
834
    return -1;
5645
835
  if (jt1->found_records > jt2->found_records)
5646
836
    return 1;
5647
837
  if (jt1->found_records < jt2->found_records)
5648
 
    return -1; 
 
838
    return -1;
5649
839
  return jt1 > jt2 ? 1 : (jt1 < jt2 ? -1 : 0);
5650
840
}
5651
841
 
5652
 
 
5653
842
/**
5654
843
  Same as join_tab_cmp, but for use with SELECT_STRAIGHT_JOIN.
5655
844
*/
5656
 
 
5657
 
static int
5658
 
join_tab_cmp_straight(const void* ptr1, const void* ptr2)
 
845
int join_tab_cmp_straight(const void* ptr1, const void* ptr2)
5659
846
{
5660
 
  JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;
5661
 
  JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;
 
847
  JoinTable *jt1= *(JoinTable**) ptr1;
 
848
  JoinTable *jt2= *(JoinTable**) ptr2;
5662
849
 
5663
850
  if (jt1->dependent & jt2->table->map)
5664
851
    return 1;
5668
855
}
5669
856
 
5670
857
/**
5671
 
  Heuristic procedure to automatically guess a reasonable degree of
5672
 
  exhaustiveness for the greedy search procedure.
5673
 
 
5674
 
  The procedure estimates the optimization time and selects a search depth
5675
 
  big enough to result in a near-optimal QEP, that doesn't take too long to
5676
 
  find. If the number of tables in the query exceeds some constant, then
5677
 
  search_depth is set to this constant.
5678
 
 
5679
 
  @param join   pointer to the structure providing all context info for
5680
 
                the query
5681
 
 
5682
 
  @note
5683
 
    This is an extremely simplistic implementation that serves as a stub for a
5684
 
    more advanced analysis of the join. Ideally the search depth should be
5685
 
    determined by learning from previous query optimizations, because it will
5686
 
    depend on the CPU power (and other factors).
5687
 
 
5688
 
  @todo
5689
 
    this value should be determined dynamically, based on statistics:
5690
 
    uint max_tables_for_exhaustive_opt= 7;
5691
 
 
5692
 
  @todo
5693
 
    this value could be determined by some mapping of the form:
5694
 
    depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]
5695
 
 
5696
 
  @return
5697
 
    A positive integer that specifies the search depth (and thus the
5698
 
    exhaustiveness) of the depth-first search algorithm used by
5699
 
    'greedy_search'.
5700
 
*/
5701
 
 
5702
 
static uint
5703
 
determine_search_depth(JOIN *join)
5704
 
{
5705
 
  uint table_count=  join->tables - join->const_tables;
5706
 
  uint search_depth;
5707
 
  /* TODO: this value should be determined dynamically, based on statistics: */
5708
 
  uint max_tables_for_exhaustive_opt= 7;
5709
 
 
5710
 
  if (table_count <= max_tables_for_exhaustive_opt)
5711
 
    search_depth= table_count+1; // use exhaustive for small number of tables
5712
 
  else
5713
 
    /*
5714
 
      TODO: this value could be determined by some mapping of the form:
5715
 
      depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]
5716
 
    */
5717
 
    search_depth= max_tables_for_exhaustive_opt; // use greedy search
5718
 
 
5719
 
  return search_depth;
5720
 
}
5721
 
 
5722
 
 
5723
 
/**
5724
 
  Select the best ways to access the tables in a query without reordering them.
5725
 
 
5726
 
    Find the best access paths for each query table and compute their costs
5727
 
    according to their order in the array 'join->best_ref' (thus without
5728
 
    reordering the join tables). The function calls sequentially
5729
 
    'best_access_path' for each table in the query to select the best table
5730
 
    access method. The final optimal plan is stored in the array
5731
 
    'join->best_positions', and the corresponding cost in 'join->best_read'.
5732
 
 
5733
 
  @param join          pointer to the structure providing all context info for
5734
 
                       the query
5735
 
  @param join_tables   set of the tables in the query
5736
 
 
5737
 
  @note
5738
 
    This function can be applied to:
5739
 
    - queries with STRAIGHT_JOIN
5740
 
    - internally to compute the cost of an arbitrary QEP
5741
 
  @par
5742
 
    Thus 'optimize_straight_join' can be used at any stage of the query
5743
 
    optimization process to finalize a QEP as it is.
5744
 
*/
5745
 
 
5746
 
static void
5747
 
optimize_straight_join(JOIN *join, table_map join_tables)
5748
 
{
5749
 
  JOIN_TAB *s;
5750
 
  uint idx= join->const_tables;
5751
 
  double    record_count= 1.0;
5752
 
  double    read_time=    0.0;
5753
 
 
5754
 
  for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)
5755
 
  {
5756
 
    /* Find the best access method from 's' to the current partial plan */
5757
 
    advance_sj_state(join_tables, s);
5758
 
    best_access_path(join, s, join->thd, join_tables, idx,
5759
 
                     record_count, read_time);
5760
 
    /* compute the cost of the new plan extended with 's' */
5761
 
    record_count*= join->positions[idx].records_read;
5762
 
    read_time+=    join->positions[idx].read_time;
5763
 
    join_tables&= ~(s->table->map);
5764
 
    ++idx;
5765
 
  }
5766
 
 
5767
 
  read_time+= record_count / (double) TIME_FOR_COMPARE;
5768
 
  if (join->sort_by_table &&
5769
 
      join->sort_by_table != join->positions[join->const_tables].table->table)
5770
 
    read_time+= record_count;  // We have to make a temp table
5771
 
  memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);
5772
 
  join->best_read= read_time;
5773
 
}
5774
 
 
5775
 
 
5776
 
/**
5777
 
  Find a good, possibly optimal, query execution plan (QEP) by a greedy search.
5778
 
 
5779
 
    The search procedure uses a hybrid greedy/exhaustive search with controlled
5780
 
    exhaustiveness. The search is performed in N = card(remaining_tables)
5781
 
    steps. Each step evaluates how promising is each of the unoptimized tables,
5782
 
    selects the most promising table, and extends the current partial QEP with
5783
 
    that table.  Currenly the most 'promising' table is the one with least
5784
 
    expensive extension.\
5785
 
 
5786
 
    There are two extreme cases:
5787
 
    -# When (card(remaining_tables) < search_depth), the estimate finds the
5788
 
    best complete continuation of the partial QEP. This continuation can be
5789
 
    used directly as a result of the search.
5790
 
    -# When (search_depth == 1) the 'best_extension_by_limited_search'
5791
 
    consideres the extension of the current QEP with each of the remaining
5792
 
    unoptimized tables.
5793
 
 
5794
 
    All other cases are in-between these two extremes. Thus the parameter
5795
 
    'search_depth' controlls the exhaustiveness of the search. The higher the
5796
 
    value, the longer the optimizaton time and possibly the better the
5797
 
    resulting plan. The lower the value, the fewer alternative plans are
5798
 
    estimated, but the more likely to get a bad QEP.
5799
 
 
5800
 
    All intermediate and final results of the procedure are stored in 'join':
5801
 
    - join->positions     : modified for every partial QEP that is explored
5802
 
    - join->best_positions: modified for the current best complete QEP
5803
 
    - join->best_read     : modified for the current best complete QEP
5804
 
    - join->best_ref      : might be partially reordered
5805
 
 
5806
 
    The final optimal plan is stored in 'join->best_positions', and its
5807
 
    corresponding cost in 'join->best_read'.
5808
 
 
5809
 
  @note
5810
 
    The following pseudocode describes the algorithm of 'greedy_search':
5811
 
 
5812
 
    @code
5813
 
    procedure greedy_search
5814
 
    input: remaining_tables
5815
 
    output: pplan;
5816
 
    {
5817
 
      pplan = <>;
5818
 
      do {
5819
 
        (t, a) = best_extension(pplan, remaining_tables);
5820
 
        pplan = concat(pplan, (t, a));
5821
 
        remaining_tables = remaining_tables - t;
5822
 
      } while (remaining_tables != {})
5823
 
      return pplan;
5824
 
    }
5825
 
 
5826
 
  @endcode
5827
 
    where 'best_extension' is a placeholder for a procedure that selects the
5828
 
    most "promising" of all tables in 'remaining_tables'.
5829
 
    Currently this estimate is performed by calling
5830
 
    'best_extension_by_limited_search' to evaluate all extensions of the
5831
 
    current QEP of size 'search_depth', thus the complexity of 'greedy_search'
5832
 
    mainly depends on that of 'best_extension_by_limited_search'.
5833
 
 
5834
 
  @par
5835
 
    If 'best_extension()' == 'best_extension_by_limited_search()', then the
5836
 
    worst-case complexity of this algorithm is <=
5837
 
    O(N*N^search_depth/search_depth). When serch_depth >= N, then the
5838
 
    complexity of greedy_search is O(N!).
5839
 
 
5840
 
  @par
5841
 
    In the future, 'greedy_search' might be extended to support other
5842
 
    implementations of 'best_extension', e.g. some simpler quadratic procedure.
5843
 
 
5844
 
  @param join             pointer to the structure providing all context info
5845
 
                          for the query
5846
 
  @param remaining_tables set of tables not included into the partial plan yet
5847
 
  @param search_depth     controlls the exhaustiveness of the search
5848
 
  @param prune_level      the pruning heuristics that should be applied during
5849
 
                          search
5850
 
 
5851
 
  @retval
5852
 
    false       ok
5853
 
  @retval
5854
 
    true        Fatal error
5855
 
*/
5856
 
 
5857
 
static bool
5858
 
greedy_search(JOIN      *join,
5859
 
              table_map remaining_tables,
5860
 
              uint      search_depth,
5861
 
              uint      prune_level)
5862
 
{
5863
 
  double    record_count= 1.0;
5864
 
  double    read_time=    0.0;
5865
 
  uint      idx= join->const_tables; // index into 'join->best_ref'
5866
 
  uint      best_idx;
5867
 
  uint      size_remain;    // cardinality of remaining_tables
5868
 
  POSITION  best_pos;
5869
 
  JOIN_TAB  *best_table; // the next plan node to be added to the curr QEP
5870
 
 
5871
 
  /* number of tables that remain to be optimized */
5872
 
  size_remain= my_count_bits(remaining_tables);
5873
 
 
5874
 
  do {
5875
 
    /* Find the extension of the current QEP with the lowest cost */
5876
 
    join->best_read= DBL_MAX;
5877
 
    if (best_extension_by_limited_search(join, remaining_tables, idx, record_count,
5878
 
                                         read_time, search_depth, prune_level))
5879
 
      return(true);
5880
 
 
5881
 
    if (size_remain <= search_depth)
5882
 
    {
5883
 
      /*
5884
 
        'join->best_positions' contains a complete optimal extension of the
5885
 
        current partial QEP.
5886
 
      */
5887
 
      return(false);
5888
 
    }
5889
 
 
5890
 
    /* select the first table in the optimal extension as most promising */
5891
 
    best_pos= join->best_positions[idx];
5892
 
    best_table= best_pos.table;
5893
 
    /*
5894
 
      Each subsequent loop of 'best_extension_by_limited_search' uses
5895
 
      'join->positions' for cost estimates, therefore we have to update its
5896
 
      value.
5897
 
    */
5898
 
    join->positions[idx]= best_pos;
5899
 
 
5900
 
    /* find the position of 'best_table' in 'join->best_ref' */
5901
 
    best_idx= idx;
5902
 
    JOIN_TAB *pos= join->best_ref[best_idx];
5903
 
    while (pos && best_table != pos)
5904
 
      pos= join->best_ref[++best_idx];
5905
 
    assert((pos != NULL)); // should always find 'best_table'
5906
 
    /* move 'best_table' at the first free position in the array of joins */
5907
 
    swap_variables(JOIN_TAB*, join->best_ref[idx], join->best_ref[best_idx]);
5908
 
 
5909
 
    /* compute the cost of the new plan extended with 'best_table' */
5910
 
    record_count*= join->positions[idx].records_read;
5911
 
    read_time+=    join->positions[idx].read_time;
5912
 
 
5913
 
    remaining_tables&= ~(best_table->table->map);
5914
 
    --size_remain;
5915
 
    ++idx;
5916
 
  } while (true);
5917
 
}
5918
 
 
5919
 
 
5920
 
/**
5921
 
  Find a good, possibly optimal, query execution plan (QEP) by a possibly
5922
 
  exhaustive search.
5923
 
 
5924
 
    The procedure searches for the optimal ordering of the query tables in set
5925
 
    'remaining_tables' of size N, and the corresponding optimal access paths to
5926
 
    each table. The choice of a table order and an access path for each table
5927
 
    constitutes a query execution plan (QEP) that fully specifies how to
5928
 
    execute the query.
5929
 
   
5930
 
    The maximal size of the found plan is controlled by the parameter
5931
 
    'search_depth'. When search_depth == N, the resulting plan is complete and
5932
 
    can be used directly as a QEP. If search_depth < N, the found plan consists
5933
 
    of only some of the query tables. Such "partial" optimal plans are useful
5934
 
    only as input to query optimization procedures, and cannot be used directly
5935
 
    to execute a query.
5936
 
 
5937
 
    The algorithm begins with an empty partial plan stored in 'join->positions'
5938
 
    and a set of N tables - 'remaining_tables'. Each step of the algorithm
5939
 
    evaluates the cost of the partial plan extended by all access plans for
5940
 
    each of the relations in 'remaining_tables', expands the current partial
5941
 
    plan with the access plan that results in lowest cost of the expanded
5942
 
    partial plan, and removes the corresponding relation from
5943
 
    'remaining_tables'. The algorithm continues until it either constructs a
5944
 
    complete optimal plan, or constructs an optimal plartial plan with size =
5945
 
    search_depth.
5946
 
 
5947
 
    The final optimal plan is stored in 'join->best_positions'. The
5948
 
    corresponding cost of the optimal plan is in 'join->best_read'.
5949
 
 
5950
 
  @note
5951
 
    The procedure uses a recursive depth-first search where the depth of the
5952
 
    recursion (and thus the exhaustiveness of the search) is controlled by the
5953
 
    parameter 'search_depth'.
5954
 
 
5955
 
  @note
5956
 
    The pseudocode below describes the algorithm of
5957
 
    'best_extension_by_limited_search'. The worst-case complexity of this
5958
 
    algorithm is O(N*N^search_depth/search_depth). When serch_depth >= N, then
5959
 
    the complexity of greedy_search is O(N!).
5960
 
 
5961
 
    @code
5962
 
    procedure best_extension_by_limited_search(
5963
 
      pplan in,             // in, partial plan of tables-joined-so-far
5964
 
      pplan_cost,           // in, cost of pplan
5965
 
      remaining_tables,     // in, set of tables not referenced in pplan
5966
 
      best_plan_so_far,     // in/out, best plan found so far
5967
 
      best_plan_so_far_cost,// in/out, cost of best_plan_so_far
5968
 
      search_depth)         // in, maximum size of the plans being considered
5969
 
    {
5970
 
      for each table T from remaining_tables
5971
 
      {
5972
 
        // Calculate the cost of using table T as above
5973
 
        cost = complex-series-of-calculations;
5974
 
 
5975
 
        // Add the cost to the cost so far.
5976
 
        pplan_cost+= cost;
5977
 
 
5978
 
        if (pplan_cost >= best_plan_so_far_cost)
5979
 
          // pplan_cost already too great, stop search
5980
 
          continue;
5981
 
 
5982
 
        pplan= expand pplan by best_access_method;
5983
 
        remaining_tables= remaining_tables - table T;
5984
 
        if (remaining_tables is not an empty set
5985
 
            and
5986
 
            search_depth > 1)
5987
 
        {
5988
 
          best_extension_by_limited_search(pplan, pplan_cost,
5989
 
                                           remaining_tables,
5990
 
                                           best_plan_so_far,
5991
 
                                           best_plan_so_far_cost,
5992
 
                                           search_depth - 1);
5993
 
        }
5994
 
        else
5995
 
        {
5996
 
          best_plan_so_far_cost= pplan_cost;
5997
 
          best_plan_so_far= pplan;
5998
 
        }
5999
 
      }
6000
 
    }
6001
 
    @endcode
6002
 
 
6003
 
  @note
6004
 
    When 'best_extension_by_limited_search' is called for the first time,
6005
 
    'join->best_read' must be set to the largest possible value (e.g. DBL_MAX).
6006
 
    The actual implementation provides a way to optionally use pruning
6007
 
    heuristic (controlled by the parameter 'prune_level') to reduce the search
6008
 
    space by skipping some partial plans.
6009
 
 
6010
 
  @note
6011
 
    The parameter 'search_depth' provides control over the recursion
6012
 
    depth, and thus the size of the resulting optimal plan.
6013
 
 
6014
 
  @param join             pointer to the structure providing all context info
6015
 
                          for the query
6016
 
  @param remaining_tables set of tables not included into the partial plan yet
6017
 
  @param idx              length of the partial QEP in 'join->positions';
6018
 
                          since a depth-first search is used, also corresponds
6019
 
                          to the current depth of the search tree;
6020
 
                          also an index in the array 'join->best_ref';
6021
 
  @param record_count     estimate for the number of records returned by the
6022
 
                          best partial plan
6023
 
  @param read_time        the cost of the best partial plan
6024
 
  @param search_depth     maximum depth of the recursion and thus size of the
6025
 
                          found optimal plan
6026
 
                          (0 < search_depth <= join->tables+1).
6027
 
  @param prune_level      pruning heuristics that should be applied during
6028
 
                          optimization
6029
 
                          (values: 0 = EXHAUSTIVE, 1 = PRUNE_BY_TIME_OR_ROWS)
6030
 
 
6031
 
  @retval
6032
 
    false       ok
6033
 
  @retval
6034
 
    true        Fatal error
6035
 
*/
6036
 
 
6037
 
static bool
6038
 
best_extension_by_limited_search(JOIN      *join,
6039
 
                                 table_map remaining_tables,
6040
 
                                 uint      idx,
6041
 
                                 double    record_count,
6042
 
                                 double    read_time,
6043
 
                                 uint      search_depth,
6044
 
                                 uint      prune_level)
6045
 
{
6046
 
  THD *thd= join->thd;
6047
 
  if (thd->killed)  // Abort
6048
 
    return(true);
6049
 
 
6050
 
  /* 
6051
 
     'join' is a partial plan with lower cost than the best plan so far,
6052
 
     so continue expanding it further with the tables in 'remaining_tables'.
6053
 
  */
6054
 
  JOIN_TAB *s;
6055
 
  double best_record_count= DBL_MAX;
6056
 
  double best_read_time=    DBL_MAX;
6057
 
 
6058
 
  for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)
6059
 
  {
6060
 
    table_map real_table_bit= s->table->map;
6061
 
    if ((remaining_tables & real_table_bit) && 
6062
 
        !(remaining_tables & s->dependent) && 
6063
 
        (!idx || !check_interleaving_with_nj(join->positions[idx-1].table, s)))
6064
 
    {
6065
 
      double current_record_count, current_read_time;
6066
 
      advance_sj_state(remaining_tables, s);
6067
 
 
6068
 
      /*
6069
 
        psergey-insideout-todo: 
6070
 
          when best_access_path() detects it could do an InsideOut scan or 
6071
 
          some other scan, have it return an insideout scan and a flag that 
6072
 
          requests to "fork" this loop iteration. (Q: how does that behave 
6073
 
          when the depth is insufficient??)
6074
 
      */
6075
 
      /* Find the best access method from 's' to the current partial plan */
6076
 
      best_access_path(join, s, thd, remaining_tables, idx,
6077
 
                       record_count, read_time);
6078
 
      /* Compute the cost of extending the plan with 's' */
6079
 
      current_record_count= record_count * join->positions[idx].records_read;
6080
 
      current_read_time=    read_time + join->positions[idx].read_time;
6081
 
 
6082
 
      /* Expand only partial plans with lower cost than the best QEP so far */
6083
 
      if ((current_read_time +
6084
 
           current_record_count / (double) TIME_FOR_COMPARE) >= join->best_read)
6085
 
      {
6086
 
        restore_prev_nj_state(s);
6087
 
        restore_prev_sj_state(remaining_tables, s);
6088
 
        continue;
6089
 
      }
6090
 
 
6091
 
      /*
6092
 
        Prune some less promising partial plans. This heuristic may miss
6093
 
        the optimal QEPs, thus it results in a non-exhaustive search.
6094
 
      */
6095
 
      if (prune_level == 1)
6096
 
      {
6097
 
        if (best_record_count > current_record_count ||
6098
 
            best_read_time > current_read_time ||
6099
 
            (idx == join->const_tables && s->table == join->sort_by_table)) // 's' is the first table in the QEP
6100
 
        {
6101
 
          if (best_record_count >= current_record_count &&
6102
 
              best_read_time >= current_read_time &&
6103
 
              /* TODO: What is the reasoning behind this condition? */
6104
 
              (!(s->key_dependent & remaining_tables) ||
6105
 
               join->positions[idx].records_read < 2.0))
6106
 
          {
6107
 
            best_record_count= current_record_count;
6108
 
            best_read_time=    current_read_time;
6109
 
          }
6110
 
        }
6111
 
        else
6112
 
        {
6113
 
          restore_prev_nj_state(s);
6114
 
          restore_prev_sj_state(remaining_tables, s);
6115
 
          continue;
6116
 
        }
6117
 
      }
6118
 
 
6119
 
      if ( (search_depth > 1) && (remaining_tables & ~real_table_bit) )
6120
 
      { /* Recursively expand the current partial plan */
6121
 
        swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);
6122
 
        if (best_extension_by_limited_search(join,
6123
 
                                             remaining_tables & ~real_table_bit,
6124
 
                                             idx + 1,
6125
 
                                             current_record_count,
6126
 
                                             current_read_time,
6127
 
                                             search_depth - 1,
6128
 
                                             prune_level))
6129
 
          return(true);
6130
 
        swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);
6131
 
      }
6132
 
      else
6133
 
      { /*
6134
 
          'join' is either the best partial QEP with 'search_depth' relations,
6135
 
          or the best complete QEP so far, whichever is smaller.
6136
 
        */
6137
 
        current_read_time+= current_record_count / (double) TIME_FOR_COMPARE;
6138
 
        if (join->sort_by_table &&
6139
 
            join->sort_by_table !=
6140
 
            join->positions[join->const_tables].table->table)
6141
 
          /* We have to make a temp table */
6142
 
          current_read_time+= current_record_count;
6143
 
        if ((search_depth == 1) || (current_read_time < join->best_read))
6144
 
        {
6145
 
          memcpy(join->best_positions, join->positions,
6146
 
                 sizeof(POSITION) * (idx + 1));
6147
 
          join->best_read= current_read_time - 0.001;
6148
 
        }
6149
 
      }
6150
 
      restore_prev_nj_state(s);
6151
 
      restore_prev_sj_state(remaining_tables, s);
6152
 
    }
6153
 
  }
6154
 
  return(false);
6155
 
}
6156
 
 
6157
 
 
6158
 
/**
6159
 
  @todo
6160
 
  - TODO: this function is here only temporarily until 'greedy_search' is
6161
 
  tested and accepted.
6162
 
 
6163
 
  RETURN VALUES
6164
 
    false       ok
6165
 
    true        Fatal error
6166
 
*/
6167
 
static bool
6168
 
find_best(JOIN *join,table_map rest_tables,uint idx,double record_count,
6169
 
          double read_time)
6170
 
{
6171
 
  THD *thd= join->thd;
6172
 
  if (thd->killed)
6173
 
    return(true);
6174
 
  if (!rest_tables)
6175
 
  {
6176
 
    read_time+=record_count/(double) TIME_FOR_COMPARE;
6177
 
    if (join->sort_by_table &&
6178
 
        join->sort_by_table !=
6179
 
        join->positions[join->const_tables].table->table)
6180
 
      read_time+=record_count;                  // We have to make a temp table
6181
 
    if (read_time < join->best_read)
6182
 
    {
6183
 
      memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);
6184
 
      join->best_read= read_time - 0.001;
6185
 
    }
6186
 
    return(false);
6187
 
  }
6188
 
  if (read_time+record_count/(double) TIME_FOR_COMPARE >= join->best_read)
6189
 
    return(false);                                      /* Found better before */
6190
 
 
6191
 
  JOIN_TAB *s;
6192
 
  double best_record_count=DBL_MAX,best_read_time=DBL_MAX;
6193
 
  for (JOIN_TAB **pos=join->best_ref+idx ; (s=*pos) ; pos++)
6194
 
  {
6195
 
    table_map real_table_bit=s->table->map;
6196
 
    if ((rest_tables & real_table_bit) && !(rest_tables & s->dependent) &&
6197
 
        (!idx|| !check_interleaving_with_nj(join->positions[idx-1].table, s)))
6198
 
    {
6199
 
      double records, best;
6200
 
      advance_sj_state(rest_tables, s);
6201
 
      best_access_path(join, s, thd, rest_tables, idx, record_count, 
6202
 
                       read_time);
6203
 
      records= join->positions[idx].records_read;
6204
 
      best= join->positions[idx].read_time;
6205
 
      /*
6206
 
        Go to the next level only if there hasn't been a better key on
6207
 
        this level! This will cut down the search for a lot simple cases!
6208
 
      */
6209
 
      double current_record_count=record_count*records;
6210
 
      double current_read_time=read_time+best;
6211
 
      if (best_record_count > current_record_count ||
6212
 
          best_read_time > current_read_time ||
6213
 
          (idx == join->const_tables && s->table == join->sort_by_table))
6214
 
      {
6215
 
        if (best_record_count >= current_record_count &&
6216
 
            best_read_time >= current_read_time &&
6217
 
            (!(s->key_dependent & rest_tables) || records < 2.0))
6218
 
        {
6219
 
          best_record_count=current_record_count;
6220
 
          best_read_time=current_read_time;
6221
 
        }
6222
 
        swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);
6223
 
        if (find_best(join,rest_tables & ~real_table_bit,idx+1,
6224
 
                      current_record_count,current_read_time))
6225
 
          return(true);
6226
 
        swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);
6227
 
      }
6228
 
      restore_prev_nj_state(s);
6229
 
      restore_prev_sj_state(rest_tables, s);
6230
 
      if (join->select_options & SELECT_STRAIGHT_JOIN)
6231
 
        break;                          // Don't test all combinations
6232
 
    }
6233
 
  }
6234
 
  return(false);
6235
 
}
6236
 
 
6237
 
 
6238
 
/**
6239
858
  Find how much space the prevous read not const tables takes in cache.
6240
859
*/
6241
 
 
6242
 
static void calc_used_field_length(THD *thd __attribute__((unused)),
6243
 
                                   JOIN_TAB *join_tab)
 
860
void calc_used_field_length(Session *, JoinTable *join_tab)
6244
861
{
6245
 
  uint null_fields,blobs,fields,rec_length;
 
862
  uint32_t null_fields,blobs,fields,rec_length;
6246
863
  Field **f_ptr,*field;
6247
 
  MY_BITMAP *read_set= join_tab->table->read_set;;
6248
864
 
6249
865
  null_fields= blobs= fields= rec_length=0;
6250
866
  for (f_ptr=join_tab->table->field ; (field= *f_ptr) ; f_ptr++)
6251
867
  {
6252
 
    if (bitmap_is_set(read_set, field->field_index))
 
868
    if (field->isReadSet())
6253
869
    {
6254
 
      uint flags=field->flags;
 
870
      uint32_t flags=field->flags;
6255
871
      fields++;
6256
872
      rec_length+=field->pack_length();
6257
873
      if (flags & BLOB_FLAG)
6258
 
        blobs++;
 
874
        blobs++;
6259
875
      if (!(flags & NOT_NULL_FLAG))
6260
 
        null_fields++;
 
876
        null_fields++;
6261
877
    }
6262
878
  }
6263
879
  if (null_fields)
6264
 
    rec_length+=(join_tab->table->s->null_fields+7)/8;
 
880
    rec_length+=(join_tab->table->getNullFields() + 7)/8;
6265
881
  if (join_tab->table->maybe_null)
6266
882
    rec_length+=sizeof(bool);
6267
883
  if (blobs)
6268
884
  {
6269
 
    uint blob_length=(uint) (join_tab->table->file->stats.mean_rec_length-
6270
 
                             (join_tab->table->s->reclength- rec_length));
6271
 
    rec_length+=(uint) max((uint)4,blob_length);
6272
 
  }
6273
 
  join_tab->used_fields=fields;
6274
 
  join_tab->used_fieldlength=rec_length;
6275
 
  join_tab->used_blobs=blobs;
6276
 
}
6277
 
 
6278
 
 
6279
 
static uint
6280
 
cache_record_length(JOIN *join,uint idx)
6281
 
{
6282
 
  uint length=0;
6283
 
  JOIN_TAB **pos,**end;
6284
 
  THD *thd=join->thd;
6285
 
 
6286
 
  for (pos=join->best_ref+join->const_tables,end=join->best_ref+idx ;
6287
 
       pos != end ;
6288
 
       pos++)
6289
 
  {
6290
 
    JOIN_TAB *join_tab= *pos;
6291
 
    if (!join_tab->used_fieldlength)            /* Not calced yet */
6292
 
      calc_used_field_length(thd, join_tab);
6293
 
    length+=join_tab->used_fieldlength;
6294
 
  }
6295
 
  return length;
6296
 
}
6297
 
 
6298
 
 
6299
 
/*
6300
 
  Get the number of different row combinations for subset of partial join
6301
 
 
6302
 
  SYNOPSIS
6303
 
    prev_record_reads()
6304
 
      join       The join structure
6305
 
      idx        Number of tables in the partial join order (i.e. the
6306
 
                 partial join order is in join->positions[0..idx-1])
6307
 
      found_ref  Bitmap of tables for which we need to find # of distinct
6308
 
                 row combinations.
6309
 
 
6310
 
  DESCRIPTION
6311
 
    Given a partial join order (in join->positions[0..idx-1]) and a subset of
6312
 
    tables within that join order (specified in found_ref), find out how many
6313
 
    distinct row combinations of subset tables will be in the result of the
6314
 
    partial join order.
6315
 
     
6316
 
    This is used as follows: Suppose we have a table accessed with a ref-based
6317
 
    method. The ref access depends on current rows of tables in found_ref.
6318
 
    We want to count # of different ref accesses. We assume two ref accesses
6319
 
    will be different if at least one of access parameters is different.
6320
 
    Example: consider a query
6321
 
 
6322
 
    SELECT * FROM t1, t2, t3 WHERE t1.key=c1 AND t2.key=c2 AND t3.key=t1.field
6323
 
 
6324
 
    and a join order:
6325
 
      t1,  ref access on t1.key=c1
6326
 
      t2,  ref access on t2.key=c2       
6327
 
      t3,  ref access on t3.key=t1.field 
6328
 
    
6329
 
    For t1: n_ref_scans = 1, n_distinct_ref_scans = 1
6330
 
    For t2: n_ref_scans = records_read(t1), n_distinct_ref_scans=1
6331
 
    For t3: n_ref_scans = records_read(t1)*records_read(t2)
6332
 
            n_distinct_ref_scans = #records_read(t1)
6333
 
    
6334
 
    The reason for having this function (at least the latest version of it)
6335
 
    is that we need to account for buffering in join execution. 
6336
 
    
6337
 
    An edge-case example: if we have a non-first table in join accessed via
6338
 
    ref(const) or ref(param) where there is a small number of different
6339
 
    values of param, then the access will likely hit the disk cache and will
6340
 
    not require any disk seeks.
6341
 
    
6342
 
    The proper solution would be to assume an LRU disk cache of some size,
6343
 
    calculate probability of cache hits, etc. For now we just count
6344
 
    identical ref accesses as one.
6345
 
 
6346
 
  RETURN 
6347
 
    Expected number of row combinations
6348
 
*/
6349
 
 
6350
 
static double
6351
 
prev_record_reads(JOIN *join, uint idx, table_map found_ref)
6352
 
{
6353
 
  double found=1.0;
6354
 
  POSITION *pos_end= join->positions - 1;
6355
 
  for (POSITION *pos= join->positions + idx - 1; pos != pos_end; pos--)
6356
 
  {
6357
 
    if (pos->table->table->map & found_ref)
6358
 
    {
6359
 
      found_ref|= pos->ref_depend_map;
6360
 
      /* 
6361
 
        For the case of "t1 LEFT JOIN t2 ON ..." where t2 is a const table 
6362
 
        with no matching row we will get position[t2].records_read==0. 
6363
 
        Actually the size of output is one null-complemented row, therefore 
6364
 
        we will use value of 1 whenever we get records_read==0.
6365
 
 
6366
 
        Note
6367
 
        - the above case can't occur if inner part of outer join has more 
6368
 
          than one table: table with no matches will not be marked as const.
6369
 
 
6370
 
        - Ideally we should add 1 to records_read for every possible null-
6371
 
          complemented row. We're not doing it because: 1. it will require
6372
 
          non-trivial code and add overhead. 2. The value of records_read
6373
 
          is an inprecise estimate and adding 1 (or, in the worst case,
6374
 
          #max_nested_outer_joins=64-1) will not make it any more precise.
6375
 
      */
6376
 
      if (pos->records_read > DBL_EPSILON)
6377
 
        found*= pos->records_read;
6378
 
    }
6379
 
  }
6380
 
  return found;
6381
 
}
6382
 
 
 
885
    uint32_t blob_length=(uint32_t) (join_tab->table->cursor->stats.mean_rec_length-
 
886
                                     (join_tab->table->getRecordLength()- rec_length));
 
887
    rec_length+= max((uint32_t)4,blob_length);
 
888
  }
 
889
  join_tab->used_fields= fields;
 
890
  join_tab->used_fieldlength= rec_length;
 
891
  join_tab->used_blobs= blobs;
 
892
}
 
893
 
 
894
StoredKey *get_store_key(Session *session,
 
895
                         optimizer::KeyUse *keyuse,
 
896
                         table_map used_tables,
 
897
                         KEY_PART_INFO *key_part,
 
898
                         unsigned char *key_buff,
 
899
                         uint32_t maybe_null)
 
900
{
 
901
  Item_ref *key_use_val= static_cast<Item_ref *>(keyuse->getVal());
 
902
  if (! ((~used_tables) & keyuse->getUsedTables())) // if const item
 
903
  {
 
904
    return new store_key_const_item(session,
 
905
                                    key_part->field,
 
906
                                    key_buff + maybe_null,
 
907
                                    maybe_null ? key_buff : 0,
 
908
                                    key_part->length,
 
909
                                    key_use_val);
 
910
  }
 
911
  else if (key_use_val->type() == Item::FIELD_ITEM ||
 
912
           (key_use_val->type() == Item::REF_ITEM &&
 
913
            key_use_val->ref_type() == Item_ref::OUTER_REF &&
 
914
            (*(Item_ref**)((Item_ref*)key_use_val)->ref)->ref_type() == Item_ref::DIRECT_REF &&
 
915
            key_use_val->real_item()->type() == Item::FIELD_ITEM))
 
916
  {
 
917
    return new store_key_field(session,
 
918
                               key_part->field,
 
919
                               key_buff + maybe_null,
 
920
                               maybe_null ? key_buff : 0,
 
921
                               key_part->length,
 
922
                               ((Item_field*) key_use_val->real_item())->field,
 
923
                               key_use_val->full_name());
 
924
  }
 
925
  return new store_key_item(session,
 
926
                            key_part->field,
 
927
                            key_buff + maybe_null,
 
928
                            maybe_null ? key_buff : 0,
 
929
                            key_part->length,
 
930
                            key_use_val);
 
931
}
6383
932
 
6384
933
/**
6385
 
  Set up join struct according to best position.
 
934
  This function is only called for const items on fields which are keys.
 
935
 
 
936
  @return
 
937
    returns 1 if there was some conversion made when the field was stored.
6386
938
*/
6387
 
 
6388
 
static bool
6389
 
get_best_combination(JOIN *join)
6390
 
{
6391
 
  uint i,tablenr;
6392
 
  table_map used_tables;
6393
 
  JOIN_TAB *join_tab,*j;
6394
 
  KEYUSE *keyuse;
6395
 
  uint table_count;
6396
 
  THD *thd=join->thd;
6397
 
 
6398
 
  table_count=join->tables;
6399
 
  if (!(join->join_tab=join_tab=
6400
 
        (JOIN_TAB*) thd->alloc(sizeof(JOIN_TAB)*table_count)))
6401
 
    return(true);
6402
 
 
6403
 
  join->full_join=0;
6404
 
 
6405
 
  used_tables= OUTER_REF_TABLE_BIT;             // Outer row is already read
6406
 
  for (j=join_tab, tablenr=0 ; tablenr < table_count ; tablenr++,j++)
 
939
bool store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)
 
940
{
 
941
  bool error;
 
942
  Table *table= field->table;
 
943
  Session *session= table->in_use;
 
944
  ha_rows cuted_fields=session->cuted_fields;
 
945
 
 
946
  /*
 
947
    we should restore old value of count_cuted_fields because
 
948
    store_val_in_field can be called from mysql_insert
 
949
    with select_insert, which make count_cuted_fields= 1
 
950
   */
 
951
  enum_check_fields old_count_cuted_fields= session->count_cuted_fields;
 
952
  session->count_cuted_fields= check_flag;
 
953
  error= item->save_in_field(field, 1);
 
954
  session->count_cuted_fields= old_count_cuted_fields;
 
955
  return error || cuted_fields != session->cuted_fields;
 
956
}
 
957
 
 
958
inline void add_cond_and_fix(Item **e1, Item *e2)
 
959
{
 
960
  if (*e1)
6407
961
  {
6408
 
    TABLE *form;
6409
 
    *j= *join->best_positions[tablenr].table;
6410
 
    form=join->table[tablenr]=j->table;
6411
 
    used_tables|= form->map;
6412
 
    form->reginfo.join_tab=j;
6413
 
    if (!*j->on_expr_ref)
6414
 
      form->reginfo.not_exists_optimize=0;      // Only with LEFT JOIN
6415
 
    if (j->type == JT_CONST)
6416
 
      continue;                                 // Handled in make_join_stat..
6417
 
 
6418
 
    j->ref.key = -1;
6419
 
    j->ref.key_parts=0;
6420
 
 
6421
 
    if (j->type == JT_SYSTEM)
6422
 
      continue;
6423
 
    if (j->keys.is_clear_all() || !(keyuse= join->best_positions[tablenr].key))
 
962
    Item *res;
 
963
    if ((res= new Item_cond_and(*e1, e2)))
6424
964
    {
6425
 
      j->type=JT_ALL;
6426
 
      if (tablenr != join->const_tables)
6427
 
        join->full_join=1;
 
965
      *e1= res;
 
966
      res->quick_fix_field();
6428
967
    }
6429
 
    else if (create_ref_for_key(join, j, keyuse, used_tables))
6430
 
      return(true);                        // Something went wrong
6431
968
  }
6432
 
 
6433
 
  for (i=0 ; i < table_count ; i++)
6434
 
    join->map2table[join->join_tab[i].table->tablenr]=join->join_tab+i;
6435
 
  update_depend_map(join);
6436
 
  return(0);
 
969
  else
 
970
    *e1= e2;
6437
971
}
6438
972
 
6439
 
 
6440
 
static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,
6441
 
                               table_map used_tables)
 
973
bool create_ref_for_key(JOIN *join, 
 
974
                        JoinTable *j, 
 
975
                        optimizer::KeyUse *org_keyuse,
 
976
                        table_map used_tables)
6442
977
{
6443
 
  KEYUSE *keyuse=org_keyuse;
6444
 
  THD  *thd= join->thd;
6445
 
  uint keyparts,length,key;
6446
 
  TABLE *table;
6447
 
  KEY *keyinfo;
 
978
  optimizer::KeyUse *keyuse= org_keyuse;
 
979
  Session  *session= join->session;
 
980
  uint32_t keyparts;
 
981
  uint32_t length;
 
982
  uint32_t key;
 
983
  Table *table= NULL;
 
984
  KEY *keyinfo= NULL;
6448
985
 
6449
986
  /*  Use best key from find_best */
6450
 
  table=j->table;
6451
 
  key=keyuse->key;
6452
 
  keyinfo=table->key_info+key;
 
987
  table= j->table;
 
988
  key= keyuse->getKey();
 
989
  keyinfo= table->key_info + key;
6453
990
 
6454
991
  {
6455
 
    keyparts=length=0;
6456
 
    uint found_part_ref_or_null= 0;
 
992
    keyparts= length= 0;
 
993
    uint32_t found_part_ref_or_null= 0;
6457
994
    /*
6458
995
      Calculate length for the used key
6459
996
      Stop if there is a missing key part or when we find second key_part
6461
998
    */
6462
999
    do
6463
1000
    {
6464
 
      if (!(~used_tables & keyuse->used_tables))
 
1001
      if (! (~used_tables & keyuse->getUsedTables()))
6465
1002
      {
6466
 
        if (keyparts == keyuse->keypart &&
6467
 
            !(found_part_ref_or_null & keyuse->optimize))
6468
 
        {
6469
 
          keyparts++;
6470
 
          length+= keyinfo->key_part[keyuse->keypart].store_length;
6471
 
          found_part_ref_or_null|= keyuse->optimize;
6472
 
        }
 
1003
        if (keyparts == keyuse->getKeypart() &&
 
1004
            ! (found_part_ref_or_null & keyuse->getOptimizeFlags()))
 
1005
        {
 
1006
          keyparts++;
 
1007
          length+= keyinfo->key_part[keyuse->getKeypart()].store_length;
 
1008
          found_part_ref_or_null|= keyuse->getOptimizeFlags();
 
1009
        }
6473
1010
      }
6474
1011
      keyuse++;
6475
 
    } while (keyuse->table == table && keyuse->key == key);
 
1012
    } while (keyuse->getTable() == table && keyuse->getKey() == key);
6476
1013
  }
6477
1014
 
6478
1015
  /* set up fieldref */
6480
1017
  j->ref.key_parts=keyparts;
6481
1018
  j->ref.key_length=length;
6482
1019
  j->ref.key=(int) key;
6483
 
  if (!(j->ref.key_buff= (uchar*) thd->calloc(ALIGN_SIZE(length)*2)) ||
6484
 
      !(j->ref.key_copy= (store_key**) thd->alloc((sizeof(store_key*) *
6485
 
                                                   (keyparts+1)))) ||
6486
 
      !(j->ref.items=    (Item**) thd->alloc(sizeof(Item*)*keyparts)) ||
6487
 
      !(j->ref.cond_guards= (bool**) thd->alloc(sizeof(uint*)*keyparts)))
 
1020
  if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||
 
1021
      !(j->ref.key_copy= (StoredKey**) session->alloc((sizeof(StoredKey*) *
 
1022
               (keyparts+1)))) ||
 
1023
      !(j->ref.items=    (Item**) session->alloc(sizeof(Item*)*keyparts)) ||
 
1024
      !(j->ref.cond_guards= (bool**) session->alloc(sizeof(uint*)*keyparts)))
6488
1025
  {
6489
1026
    return(true);
6490
1027
  }
6494
1031
  j->ref.disable_cache= false;
6495
1032
  keyuse=org_keyuse;
6496
1033
 
6497
 
  store_key **ref_key= j->ref.key_copy;
6498
 
  uchar *key_buff=j->ref.key_buff, *null_ref_key= 0;
 
1034
  StoredKey **ref_key= j->ref.key_copy;
 
1035
  unsigned char *key_buff= j->ref.key_buff, *null_ref_key= 0;
6499
1036
  bool keyuse_uses_no_tables= true;
6500
1037
  {
6501
 
    uint i;
6502
 
    for (i=0 ; i < keyparts ; keyuse++,i++)
 
1038
    for (uint32_t i= 0; i < keyparts; keyuse++, i++)
6503
1039
    {
6504
 
      while (keyuse->keypart != i ||
6505
 
             ((~used_tables) & keyuse->used_tables))
6506
 
        keyuse++;                               /* Skip other parts */
 
1040
      while (keyuse->getKeypart() != i ||
 
1041
             ((~used_tables) & keyuse->getUsedTables()))
 
1042
        keyuse++;       /* Skip other parts */
6507
1043
 
6508
 
      uint maybe_null= test(keyinfo->key_part[i].null_bit);
6509
 
      j->ref.items[i]=keyuse->val;              // Save for cond removal
6510
 
      j->ref.cond_guards[i]= keyuse->cond_guard;
6511
 
      if (keyuse->null_rejecting) 
 
1044
      uint32_t maybe_null= test(keyinfo->key_part[i].null_bit);
 
1045
      j->ref.items[i]= keyuse->getVal();    // Save for cond removal
 
1046
      j->ref.cond_guards[i]= keyuse->getConditionalGuard();
 
1047
      if (keyuse->isNullRejected())
6512
1048
        j->ref.null_rejecting |= 1 << i;
6513
 
      keyuse_uses_no_tables= keyuse_uses_no_tables && !keyuse->used_tables;
6514
 
      if (!keyuse->used_tables &&
6515
 
          !(join->select_options & SELECT_DESCRIBE))
6516
 
      {                                 // Compare against constant
6517
 
        store_key_item tmp(thd, keyinfo->key_part[i].field,
 
1049
      keyuse_uses_no_tables= keyuse_uses_no_tables && ! keyuse->getUsedTables();
 
1050
      if (! keyuse->getUsedTables() &&  !(join->select_options & SELECT_DESCRIBE))
 
1051
      {         // Compare against constant
 
1052
        store_key_item tmp(session, keyinfo->key_part[i].field,
6518
1053
                           key_buff + maybe_null,
6519
1054
                           maybe_null ?  key_buff : 0,
6520
 
                           keyinfo->key_part[i].length, keyuse->val);
6521
 
        if (thd->is_fatal_error)
6522
 
          return(true);
6523
 
        tmp.copy();
 
1055
                           keyinfo->key_part[i].length, keyuse->getVal());
 
1056
        if (session->is_fatal_error)
 
1057
          return(true);
 
1058
        tmp.copy();
6524
1059
      }
6525
1060
      else
6526
 
        *ref_key++= get_store_key(thd,
6527
 
                                  keyuse,join->const_table_map,
6528
 
                                  &keyinfo->key_part[i],
6529
 
                                  key_buff, maybe_null);
 
1061
        *ref_key++= get_store_key(session,
 
1062
          keyuse,join->const_table_map,
 
1063
          &keyinfo->key_part[i],
 
1064
          key_buff, maybe_null);
6530
1065
      /*
6531
 
        Remember if we are going to use REF_OR_NULL
6532
 
        But only if field _really_ can be null i.e. we force JT_REF
6533
 
        instead of JT_REF_OR_NULL in case if field can't be null
 
1066
        Remember if we are going to use REF_OR_NULL
 
1067
        But only if field _really_ can be null i.e. we force AM_REF
 
1068
        instead of AM_REF_OR_NULL in case if field can't be null
6534
1069
      */
6535
 
      if ((keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)
6536
 
        null_ref_key= key_buff;
 
1070
      if ((keyuse->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)
 
1071
        null_ref_key= key_buff;
6537
1072
      key_buff+=keyinfo->key_part[i].store_length;
6538
1073
    }
6539
1074
  }
6540
 
  *ref_key=0;                           // end_marker
6541
 
  if (j->type == JT_CONST)
 
1075
  *ref_key= 0;       // end_marker
 
1076
  if (j->type == AM_CONST)
6542
1077
    j->table->const_table= 1;
6543
1078
  else if (((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) != HA_NOSAME) ||
6544
1079
           keyparts != keyinfo->key_parts || null_ref_key)
6545
1080
  {
6546
1081
    /* Must read with repeat */
6547
 
    j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;
 
1082
    j->type= null_ref_key ? AM_REF_OR_NULL : AM_REF;
6548
1083
    j->ref.null_ref_key= null_ref_key;
6549
1084
  }
6550
1085
  else if (keyuse_uses_no_tables)
6556
1091
      Here we should not mark the table as a 'const' as a field may
6557
1092
      have a 'normal' value or a NULL value.
6558
1093
    */
6559
 
    j->type=JT_CONST;
6560
 
  }
6561
 
  else
6562
 
    j->type=JT_EQ_REF;
6563
 
  return(0);
6564
 
}
6565
 
 
6566
 
 
6567
 
 
6568
 
static store_key *
6569
 
get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,
6570
 
              KEY_PART_INFO *key_part, uchar *key_buff, uint maybe_null)
6571
 
{
6572
 
  if (!((~used_tables) & keyuse->used_tables))          // if const item
6573
 
  {
6574
 
    return new store_key_const_item(thd,
6575
 
                                    key_part->field,
6576
 
                                    key_buff + maybe_null,
6577
 
                                    maybe_null ? key_buff : 0,
6578
 
                                    key_part->length,
6579
 
                                    keyuse->val);
6580
 
  }
6581
 
  else if (keyuse->val->type() == Item::FIELD_ITEM ||
6582
 
           (keyuse->val->type() == Item::REF_ITEM &&
6583
 
            ((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF &&
6584
 
            (*(Item_ref**)((Item_ref*)keyuse->val)->ref)->ref_type() ==
6585
 
             Item_ref::DIRECT_REF && 
6586
 
            keyuse->val->real_item()->type() == Item::FIELD_ITEM))
6587
 
    return new store_key_field(thd,
6588
 
                               key_part->field,
6589
 
                               key_buff + maybe_null,
6590
 
                               maybe_null ? key_buff : 0,
6591
 
                               key_part->length,
6592
 
                               ((Item_field*) keyuse->val->real_item())->field,
6593
 
                               keyuse->val->full_name());
6594
 
  return new store_key_item(thd,
6595
 
                            key_part->field,
6596
 
                            key_buff + maybe_null,
6597
 
                            maybe_null ? key_buff : 0,
6598
 
                            key_part->length,
6599
 
                            keyuse->val);
6600
 
}
6601
 
 
6602
 
/**
6603
 
  This function is only called for const items on fields which are keys.
6604
 
 
6605
 
  @return
6606
 
    returns 1 if there was some conversion made when the field was stored.
6607
 
*/
6608
 
 
6609
 
bool
6610
 
store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)
6611
 
{
6612
 
  bool error;
6613
 
  TABLE *table= field->table;
6614
 
  THD *thd= table->in_use;
6615
 
  ha_rows cuted_fields=thd->cuted_fields;
6616
 
  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,
6617
 
                                                   table->write_set);
6618
 
 
6619
 
  /*
6620
 
    we should restore old value of count_cuted_fields because
6621
 
    store_val_in_field can be called from mysql_insert 
6622
 
    with select_insert, which make count_cuted_fields= 1
6623
 
   */
6624
 
  enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;
6625
 
  thd->count_cuted_fields= check_flag;
6626
 
  error= item->save_in_field(field, 1);
6627
 
  thd->count_cuted_fields= old_count_cuted_fields;
6628
 
  dbug_tmp_restore_column_map(table->write_set, old_map);
6629
 
  return error || cuted_fields != thd->cuted_fields;
6630
 
}
6631
 
 
6632
 
 
6633
 
static bool
6634
 
make_simple_join(JOIN *join,TABLE *tmp_table)
6635
 
{
6636
 
  TABLE **tableptr;
6637
 
  JOIN_TAB *join_tab;
6638
 
 
6639
 
  /*
6640
 
    Reuse TABLE * and JOIN_TAB if already allocated by a previous call
6641
 
    to this function through JOIN::exec (may happen for sub-queries).
6642
 
  */
6643
 
  if (!join->table_reexec)
6644
 
  {
6645
 
    if (!(join->table_reexec= (TABLE**) join->thd->alloc(sizeof(TABLE*))))
6646
 
      return(true);                        /* purecov: inspected */
6647
 
    if (join->tmp_join)
6648
 
      join->tmp_join->table_reexec= join->table_reexec;
6649
 
  }
6650
 
  if (!join->join_tab_reexec)
6651
 
  {
6652
 
    if (!(join->join_tab_reexec=
6653
 
          (JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB))))
6654
 
      return(true);                        /* purecov: inspected */
6655
 
    if (join->tmp_join)
6656
 
      join->tmp_join->join_tab_reexec= join->join_tab_reexec;
6657
 
  }
6658
 
  tableptr= join->table_reexec;
6659
 
  join_tab= join->join_tab_reexec;
6660
 
 
6661
 
  join->join_tab=join_tab;
6662
 
  join->table=tableptr; tableptr[0]=tmp_table;
6663
 
  join->tables=1;
6664
 
  join->const_tables=0;
6665
 
  join->const_table_map=0;
6666
 
  join->tmp_table_param.field_count= join->tmp_table_param.sum_func_count=
6667
 
    join->tmp_table_param.func_count=0;
6668
 
  join->tmp_table_param.copy_field=join->tmp_table_param.copy_field_end=0;
6669
 
  join->first_record=join->sort_and_group=0;
6670
 
  join->send_records=(ha_rows) 0;
6671
 
  join->group=0;
6672
 
  join->row_limit=join->unit->select_limit_cnt;
6673
 
  join->do_send_rows = (join->row_limit) ? 1 : 0;
6674
 
 
6675
 
  join_tab->cache.buff=0;                       /* No caching */
6676
 
  join_tab->table=tmp_table;
6677
 
  join_tab->select=0;
6678
 
  join_tab->select_cond=0;
6679
 
  join_tab->quick=0;
6680
 
  join_tab->type= JT_ALL;                       /* Map through all records */
6681
 
  join_tab->keys.init();
6682
 
  join_tab->keys.set_all();                     /* test everything in quick */
6683
 
  join_tab->info=0;
6684
 
  join_tab->on_expr_ref=0;
6685
 
  join_tab->last_inner= 0;
6686
 
  join_tab->first_unmatched= 0;
6687
 
  join_tab->ref.key = -1;
6688
 
  join_tab->not_used_in_distinct=0;
6689
 
  join_tab->read_first_record= join_init_read_record;
6690
 
  join_tab->join=join;
6691
 
  join_tab->ref.key_parts= 0;
6692
 
  join_tab->flush_weedout_table= join_tab->check_weed_out_table= NULL;
6693
 
  join_tab->do_firstmatch= NULL;
6694
 
  memset(&join_tab->read_record, 0, sizeof(join_tab->read_record));
6695
 
  tmp_table->status=0;
6696
 
  tmp_table->null_row=0;
6697
 
  return(false);
6698
 
}
6699
 
 
6700
 
 
6701
 
inline void add_cond_and_fix(Item **e1, Item *e2)
6702
 
{
6703
 
  if (*e1)
6704
 
  {
6705
 
    Item *res;
6706
 
    if ((res= new Item_cond_and(*e1, e2)))
6707
 
    {
6708
 
      *e1= res;
6709
 
      res->quick_fix_field();
6710
 
    }
6711
 
  }
6712
 
  else
6713
 
    *e1= e2;
6714
 
}
6715
 
 
 
1094
    j->type= AM_CONST;
 
1095
  }
 
1096
  else
 
1097
    j->type= AM_EQ_REF;
 
1098
  return 0;
 
1099
}
6716
1100
 
6717
1101
/**
6718
1102
  Add to join_tab->select_cond[i] "table.field IS NOT NULL" conditions
6727
1111
    add "t1.field IS NOT NULL" to t1's table condition. @n
6728
1112
 
6729
1113
    Description of the optimization:
6730
 
    
 
1114
 
6731
1115
      We look through equalities choosen to perform ref/eq_ref access,
6732
1116
      pick equalities that have form "tbl.part_of_key = othertbl.field"
6733
1117
      (where othertbl is a non-const table and othertbl.field may be NULL)
6755
1139
      This optimization doesn't affect the choices that ref, range, or join
6756
1140
      optimizer make. This was intentional because this was added after 4.1
6757
1141
      was GA.
6758
 
      
 
1142
 
6759
1143
    Implementation overview
6760
1144
      1. update_ref_and_keys() accumulates info about null-rejecting
6761
 
         predicates in in KEY_FIELD::null_rejecting
6762
 
      1.1 add_key_part saves these to KEYUSE.
6763
 
      2. create_ref_for_key copies them to TABLE_REF.
 
1145
         predicates in in KeyField::null_rejecting
 
1146
      1.1 add_key_part saves these to KeyUse.
 
1147
      2. create_ref_for_key copies them to table_reference_st.
6764
1148
      3. add_not_null_conds adds "x IS NOT NULL" to join_tab->select_cond of
6765
 
         appropiate JOIN_TAB members.
 
1149
         appropiate JoinTable members.
6766
1150
*/
6767
 
 
6768
 
static void add_not_null_conds(JOIN *join)
 
1151
void add_not_null_conds(JOIN *join)
6769
1152
{
6770
 
  for (uint i=join->const_tables ; i < join->tables ; i++)
 
1153
  for (uint32_t i= join->const_tables; i < join->tables; i++)
6771
1154
  {
6772
 
    JOIN_TAB *tab=join->join_tab+i;
6773
 
    if ((tab->type == JT_REF || tab->type == JT_EQ_REF || 
6774
 
         tab->type == JT_REF_OR_NULL) &&
 
1155
    JoinTable *tab=join->join_tab+i;
 
1156
    if ((tab->type == AM_REF || tab->type == AM_EQ_REF ||
 
1157
         tab->type == AM_REF_OR_NULL) &&
6775
1158
        !tab->table->maybe_null)
6776
1159
    {
6777
 
      for (uint keypart= 0; keypart < tab->ref.key_parts; keypart++)
 
1160
      for (uint32_t keypart= 0; keypart < tab->ref.key_parts; keypart++)
6778
1161
      {
6779
1162
        if (tab->ref.null_rejecting & (1 << keypart))
6780
1163
        {
6782
1165
          Item *notnull;
6783
1166
          assert(item->type() == Item::FIELD_ITEM);
6784
1167
          Item_field *not_null_item= (Item_field*)item;
6785
 
          JOIN_TAB *referred_tab= not_null_item->field->table->reginfo.join_tab;
 
1168
          JoinTable *referred_tab= not_null_item->field->table->reginfo.join_tab;
6786
1169
          /*
6787
1170
            For UPDATE queries such as:
6788
1171
            UPDATE t1 SET t1.f2=(SELECT MAX(t2.f4) FROM t2 WHERE t2.f3=t1.f1);
6794
1177
            return;
6795
1178
          /*
6796
1179
            We need to do full fix_fields() call here in order to have correct
6797
 
            notnull->const_item(). This is needed e.g. by test_quick_select 
6798
 
            when it is called from make_join_select after this function is 
 
1180
            notnull->const_item(). This is needed e.g. by test_quick_select
 
1181
            when it is called from make_join_select after this function is
6799
1182
            called.
6800
1183
          */
6801
 
          if (notnull->fix_fields(join->thd, &notnull))
 
1184
          if (notnull->fix_fields(join->session, &notnull))
6802
1185
            return;
6803
1186
          add_cond_and_fix(&referred_tab->select_cond, notnull);
6804
1187
        }
6823
1206
    -  pointer to the guarded predicate, if success
6824
1207
    -  0, otherwise
6825
1208
*/
6826
 
 
6827
 
static COND*
6828
 
add_found_match_trig_cond(JOIN_TAB *tab, COND *cond, JOIN_TAB *root_tab)
 
1209
COND *add_found_match_trig_cond(JoinTable *tab, COND *cond, JoinTable *root_tab)
6829
1210
{
6830
1211
  COND *tmp;
6831
1212
  assert(cond != 0);
6841
1222
  return tmp;
6842
1223
}
6843
1224
 
6844
 
 
6845
 
/**
6846
 
  Fill in outer join related info for the execution plan structure.
6847
 
 
6848
 
    For each outer join operation left after simplification of the
6849
 
    original query the function set up the following pointers in the linear
6850
 
    structure join->join_tab representing the selected execution plan.
6851
 
    The first inner table t0 for the operation is set to refer to the last
6852
 
    inner table tk through the field t0->last_inner.
6853
 
    Any inner table ti for the operation are set to refer to the first
6854
 
    inner table ti->first_inner.
6855
 
    The first inner table t0 for the operation is set to refer to the
6856
 
    first inner table of the embedding outer join operation, if there is any,
6857
 
    through the field t0->first_upper.
6858
 
    The on expression for the outer join operation is attached to the
6859
 
    corresponding first inner table through the field t0->on_expr_ref.
6860
 
    Here ti are structures of the JOIN_TAB type.
6861
 
 
6862
 
  EXAMPLE. For the query: 
6863
 
  @code
6864
 
        SELECT * FROM t1
6865
 
                      LEFT JOIN
6866
 
                      (t2, t3 LEFT JOIN t4 ON t3.a=t4.a)
6867
 
                      ON (t1.a=t2.a AND t1.b=t3.b)
6868
 
          WHERE t1.c > 5,
6869
 
  @endcode
6870
 
 
6871
 
    given the execution plan with the table order t1,t2,t3,t4
6872
 
    is selected, the following references will be set;
6873
 
    t4->last_inner=[t4], t4->first_inner=[t4], t4->first_upper=[t2]
6874
 
    t2->last_inner=[t4], t2->first_inner=t3->first_inner=[t2],
6875
 
    on expression (t1.a=t2.a AND t1.b=t3.b) will be attached to 
6876
 
    *t2->on_expr_ref, while t3.a=t4.a will be attached to *t4->on_expr_ref.
6877
 
 
6878
 
  @param join   reference to the info fully describing the query
6879
 
 
6880
 
  @note
6881
 
    The function assumes that the simplification procedure has been
6882
 
    already applied to the join query (see simplify_joins).
6883
 
    This function can be called only after the execution plan
6884
 
    has been chosen.
6885
 
*/
6886
 
 
6887
 
static void
6888
 
make_outerjoin_info(JOIN *join)
6889
 
{
6890
 
  for (uint i=join->const_tables ; i < join->tables ; i++)
6891
 
  {
6892
 
    JOIN_TAB *tab=join->join_tab+i;
6893
 
    TABLE *table=tab->table;
6894
 
    TABLE_LIST *tbl= table->pos_in_table_list;
6895
 
    TABLE_LIST *embedding= tbl->embedding;
6896
 
 
6897
 
    if (tbl->outer_join)
6898
 
    {
6899
 
      /* 
6900
 
        Table tab is the only one inner table for outer join.
6901
 
        (Like table t4 for the table reference t3 LEFT JOIN t4 ON t3.a=t4.a
6902
 
        is in the query above.)
6903
 
      */
6904
 
      tab->last_inner= tab->first_inner= tab;
6905
 
      tab->on_expr_ref= &tbl->on_expr;
6906
 
      tab->cond_equal= tbl->cond_equal;
6907
 
      if (embedding)
6908
 
        tab->first_upper= embedding->nested_join->first_nested;
6909
 
    }    
6910
 
    for ( ; embedding ; embedding= embedding->embedding)
6911
 
    {
6912
 
      /* Ignore sj-nests: */
6913
 
      if (!embedding->on_expr)
6914
 
        continue;
6915
 
      NESTED_JOIN *nested_join= embedding->nested_join;
6916
 
      if (!nested_join->counter_)
6917
 
      {
6918
 
        /* 
6919
 
          Table tab is the first inner table for nested_join.
6920
 
          Save reference to it in the nested join structure.
6921
 
        */ 
6922
 
        nested_join->first_nested= tab;
6923
 
        tab->on_expr_ref= &embedding->on_expr;
6924
 
        tab->cond_equal= tbl->cond_equal;
6925
 
        if (embedding->embedding)
6926
 
          tab->first_upper= embedding->embedding->nested_join->first_nested;
6927
 
      }
6928
 
      if (!tab->first_inner)  
6929
 
        tab->first_inner= nested_join->first_nested;
6930
 
      if (++nested_join->counter_ < nested_join->join_list.elements)
6931
 
        break;
6932
 
      /* Table tab is the last inner table for nested join. */
6933
 
      nested_join->first_nested->last_inner= tab;
6934
 
    }
6935
 
  }
6936
 
  return;
6937
 
}
6938
 
 
6939
 
 
6940
 
static bool
6941
 
make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)
6942
 
{
6943
 
  THD *thd= join->thd;
6944
 
  if (select)
6945
 
  {
6946
 
    add_not_null_conds(join);
6947
 
    table_map used_tables;
6948
 
    if (cond)                /* Because of QUICK_GROUP_MIN_MAX_SELECT */
6949
 
    {                        /* there may be a select without a cond. */    
6950
 
      if (join->tables > 1)
6951
 
        cond->update_used_tables();             // Tablenr may have changed
6952
 
      if (join->const_tables == join->tables &&
6953
 
          thd->lex->current_select->master_unit() ==
6954
 
          &thd->lex->unit)              // not upper level SELECT
6955
 
        join->const_table_map|=RAND_TABLE_BIT;
6956
 
      {                                         // Check const tables
6957
 
        COND *const_cond=
6958
 
          make_cond_for_table(cond,
6959
 
                              join->const_table_map,
6960
 
                              (table_map) 0, 1);
6961
 
        for (JOIN_TAB *tab= join->join_tab+join->const_tables;
6962
 
             tab < join->join_tab+join->tables ; tab++)
6963
 
        {
6964
 
          if (*tab->on_expr_ref)
6965
 
          {
6966
 
            JOIN_TAB *cond_tab= tab->first_inner;
6967
 
            COND *tmp= make_cond_for_table(*tab->on_expr_ref,
6968
 
                                           join->const_table_map,
6969
 
                                           (  table_map) 0, 0);
6970
 
            if (!tmp)
6971
 
              continue;
6972
 
            tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);
6973
 
            if (!tmp)
6974
 
              return(1);
6975
 
            tmp->quick_fix_field();
6976
 
            cond_tab->select_cond= !cond_tab->select_cond ? tmp :
6977
 
                                    new Item_cond_and(cond_tab->select_cond,
6978
 
                                                      tmp);
6979
 
            if (!cond_tab->select_cond)
6980
 
              return(1);
6981
 
            cond_tab->select_cond->quick_fix_field();
6982
 
          }       
6983
 
        }
6984
 
        if (const_cond && !const_cond->val_int())
6985
 
        {
6986
 
          return(1);     // Impossible const condition
6987
 
        }
6988
 
      }
6989
 
    }
6990
 
    used_tables=((select->const_tables=join->const_table_map) |
6991
 
                 OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);
6992
 
    for (uint i=join->const_tables ; i < join->tables ; i++)
6993
 
    {
6994
 
      JOIN_TAB *tab=join->join_tab+i;
6995
 
      /*
6996
 
        first_inner is the X in queries like:
6997
 
        SELECT * FROM t1 LEFT OUTER JOIN (t2 JOIN t3) ON X
6998
 
      */
6999
 
      JOIN_TAB *first_inner_tab= tab->first_inner; 
7000
 
      table_map current_map= tab->table->map;
7001
 
      bool use_quick_range=0;
7002
 
      COND *tmp;
7003
 
 
7004
 
      /*
7005
 
        Following force including random expression in last table condition.
7006
 
        It solve problem with select like SELECT * FROM t1 WHERE rand() > 0.5
7007
 
      */
7008
 
      if (i == join->tables-1)
7009
 
        current_map|= OUTER_REF_TABLE_BIT | RAND_TABLE_BIT;
7010
 
      used_tables|=current_map;
7011
 
 
7012
 
      if (tab->type == JT_REF && tab->quick &&
7013
 
          (uint) tab->ref.key == tab->quick->index &&
7014
 
          tab->ref.key_length < tab->quick->max_used_key_length)
7015
 
      {
7016
 
        /* Range uses longer key;  Use this instead of ref on key */
7017
 
        tab->type=JT_ALL;
7018
 
        use_quick_range=1;
7019
 
        tab->use_quick=1;
7020
 
        tab->ref.key= -1;
7021
 
        tab->ref.key_parts=0;           // Don't use ref key.
7022
 
        join->best_positions[i].records_read= rows2double(tab->quick->records);
7023
 
        /* 
7024
 
          We will use join cache here : prevent sorting of the first
7025
 
          table only and sort at the end.
7026
 
        */
7027
 
        if (i != join->const_tables && join->tables > join->const_tables + 1)
7028
 
          join->full_join= 1;
7029
 
      }
7030
 
 
7031
 
      tmp= NULL;
7032
 
      if (cond)
7033
 
        tmp= make_cond_for_table(cond,used_tables,current_map, 0);
7034
 
      if (cond && !tmp && tab->quick)
7035
 
      {                                         // Outer join
7036
 
        if (tab->type != JT_ALL)
7037
 
        {
7038
 
          /*
7039
 
            Don't use the quick method
7040
 
            We come here in the case where we have 'key=constant' and
7041
 
            the test is removed by make_cond_for_table()
7042
 
          */
7043
 
          delete tab->quick;
7044
 
          tab->quick= 0;
7045
 
        }
7046
 
        else
7047
 
        {
7048
 
          /*
7049
 
            Hack to handle the case where we only refer to a table
7050
 
            in the ON part of an OUTER JOIN. In this case we want the code
7051
 
            below to check if we should use 'quick' instead.
7052
 
          */
7053
 
          tmp= new Item_int((int64_t) 1,1);     // Always true
7054
 
        }
7055
 
 
7056
 
      }
7057
 
      if (tmp || !cond || tab->type == JT_REF || tab->type == JT_REF_OR_NULL ||
7058
 
          tab->type == JT_EQ_REF)
7059
 
      {
7060
 
        SQL_SELECT *sel= tab->select= ((SQL_SELECT*)
7061
 
                                       thd->memdup((uchar*) select,
7062
 
                                                   sizeof(*select)));
7063
 
        if (!sel)
7064
 
          return(1);                    // End of memory
7065
 
        /*
7066
 
          If tab is an inner table of an outer join operation,
7067
 
          add a match guard to the pushed down predicate.
7068
 
          The guard will turn the predicate on only after
7069
 
          the first match for outer tables is encountered.
7070
 
        */        
7071
 
        if (cond && tmp)
7072
 
        {
7073
 
          /*
7074
 
            Because of QUICK_GROUP_MIN_MAX_SELECT there may be a select without
7075
 
            a cond, so neutralize the hack above.
7076
 
          */
7077
 
          if (!(tmp= add_found_match_trig_cond(first_inner_tab, tmp, 0)))
7078
 
            return(1);
7079
 
          tab->select_cond=sel->cond=tmp;
7080
 
          /* Push condition to storage engine if this is enabled
7081
 
             and the condition is not guarded */
7082
 
          tab->table->file->pushed_cond= NULL;
7083
 
          if (thd->variables.engine_condition_pushdown)
7084
 
          {
7085
 
            COND *push_cond= 
7086
 
              make_cond_for_table(tmp, current_map, current_map, 0);
7087
 
            if (push_cond)
7088
 
            {
7089
 
              /* Push condition to handler */
7090
 
              if (!tab->table->file->cond_push(push_cond))
7091
 
                tab->table->file->pushed_cond= push_cond;
7092
 
            }
7093
 
          }
7094
 
        }
7095
 
        else
7096
 
          tab->select_cond= sel->cond= NULL;
7097
 
 
7098
 
        sel->head=tab->table;
7099
 
        if (tab->quick)
7100
 
        {
7101
 
          /* Use quick key read if it's a constant and it's not used
7102
 
             with key reading */
7103
 
          if (tab->needed_reg.is_clear_all() && tab->type != JT_EQ_REF
7104
 
              && (tab->type != JT_REF || (uint) tab->ref.key == tab->quick->index))
7105
 
          {
7106
 
            sel->quick=tab->quick;              // Use value from get_quick_...
7107
 
            sel->quick_keys.clear_all();
7108
 
            sel->needed_reg.clear_all();
7109
 
          }
7110
 
          else
7111
 
          {
7112
 
            delete tab->quick;
7113
 
          }
7114
 
          tab->quick=0;
7115
 
        }
7116
 
        uint ref_key=(uint) sel->head->reginfo.join_tab->ref.key+1;
7117
 
        if (i == join->const_tables && ref_key)
7118
 
        {
7119
 
          if (!tab->const_keys.is_clear_all() &&
7120
 
              tab->table->reginfo.impossible_range)
7121
 
            return(1);
7122
 
        }
7123
 
        else if (tab->type == JT_ALL && ! use_quick_range)
7124
 
        {
7125
 
          if (!tab->const_keys.is_clear_all() &&
7126
 
              tab->table->reginfo.impossible_range)
7127
 
            return(1);                          // Impossible range
7128
 
          /*
7129
 
            We plan to scan all rows.
7130
 
            Check again if we should use an index.
7131
 
            We could have used an column from a previous table in
7132
 
            the index if we are using limit and this is the first table
7133
 
          */
7134
 
 
7135
 
          if ((cond && (!tab->keys.is_subset(tab->const_keys) && i > 0)) ||
7136
 
              (!tab->const_keys.is_clear_all() && (i == join->const_tables) && (join->unit->select_limit_cnt < join->best_positions[i].records_read) && ((join->select_options & OPTION_FOUND_ROWS) == false)))
7137
 
          {
7138
 
            /* Join with outer join condition */
7139
 
            COND *orig_cond=sel->cond;
7140
 
            sel->cond= and_conds(sel->cond, *tab->on_expr_ref);
7141
 
 
7142
 
            /*
7143
 
              We can't call sel->cond->fix_fields,
7144
 
              as it will break tab->on_expr if it's AND condition
7145
 
              (fix_fields currently removes extra AND/OR levels).
7146
 
              Yet attributes of the just built condition are not needed.
7147
 
              Thus we call sel->cond->quick_fix_field for safety.
7148
 
            */
7149
 
            if (sel->cond && !sel->cond->fixed)
7150
 
              sel->cond->quick_fix_field();
7151
 
 
7152
 
            if (sel->test_quick_select(thd, tab->keys,
7153
 
                                       used_tables & ~ current_map,
7154
 
                                       (join->select_options &
7155
 
                                        OPTION_FOUND_ROWS ?
7156
 
                                        HA_POS_ERROR :
7157
 
                                        join->unit->select_limit_cnt), 0,
7158
 
                                        false) < 0)
7159
 
            {
7160
 
              /*
7161
 
                Before reporting "Impossible WHERE" for the whole query
7162
 
                we have to check isn't it only "impossible ON" instead
7163
 
              */
7164
 
              sel->cond=orig_cond;
7165
 
              if (!*tab->on_expr_ref ||
7166
 
                  sel->test_quick_select(thd, tab->keys,
7167
 
                                         used_tables & ~ current_map,
7168
 
                                         (join->select_options &
7169
 
                                          OPTION_FOUND_ROWS ?
7170
 
                                          HA_POS_ERROR :
7171
 
                                          join->unit->select_limit_cnt),0,
7172
 
                                          false) < 0)
7173
 
                return(1);                      // Impossible WHERE
7174
 
            }
7175
 
            else
7176
 
              sel->cond=orig_cond;
7177
 
 
7178
 
            /* Fix for EXPLAIN */
7179
 
            if (sel->quick)
7180
 
              join->best_positions[i].records_read= (double)sel->quick->records;
7181
 
          }
7182
 
          else
7183
 
          {
7184
 
            sel->needed_reg=tab->needed_reg;
7185
 
            sel->quick_keys.clear_all();
7186
 
          }
7187
 
          if (!sel->quick_keys.is_subset(tab->checked_keys) ||
7188
 
              !sel->needed_reg.is_subset(tab->checked_keys))
7189
 
          {
7190
 
            tab->keys=sel->quick_keys;
7191
 
            tab->keys.merge(sel->needed_reg);
7192
 
            tab->use_quick= (!sel->needed_reg.is_clear_all() &&
7193
 
                             (select->quick_keys.is_clear_all() ||
7194
 
                              (select->quick &&
7195
 
                               (select->quick->records >= 100L)))) ?
7196
 
              2 : 1;
7197
 
            sel->read_tables= used_tables & ~current_map;
7198
 
          }
7199
 
          if (i != join->const_tables && tab->use_quick != 2)
7200
 
          {                                     /* Read with cache */
7201
 
            if (cond &&
7202
 
                (tmp=make_cond_for_table(cond,
7203
 
                                         join->const_table_map |
7204
 
                                         current_map,
7205
 
                                         current_map, 0)))
7206
 
            {
7207
 
              tab->cache.select=(SQL_SELECT*)
7208
 
                thd->memdup((uchar*) sel, sizeof(SQL_SELECT));
7209
 
              tab->cache.select->cond=tmp;
7210
 
              tab->cache.select->read_tables=join->const_table_map;
7211
 
            }
7212
 
          }
7213
 
        }
7214
 
      }
7215
 
      
7216
 
      /* 
7217
 
        Push down conditions from all on expressions.
7218
 
        Each of these conditions are guarded by a variable
7219
 
        that turns if off just before null complemented row for
7220
 
        outer joins is formed. Thus, the condition from an
7221
 
        'on expression' are guaranteed not to be checked for
7222
 
        the null complemented row.
7223
 
      */ 
7224
 
 
7225
 
      /* First push down constant conditions from on expressions */
7226
 
      for (JOIN_TAB *join_tab= join->join_tab+join->const_tables;
7227
 
           join_tab < join->join_tab+join->tables ; join_tab++)
7228
 
      {
7229
 
        if (*join_tab->on_expr_ref)
7230
 
        {
7231
 
          JOIN_TAB *cond_tab= join_tab->first_inner;
7232
 
          COND *tmp= make_cond_for_table(*join_tab->on_expr_ref,
7233
 
                                         join->const_table_map,
7234
 
                                         (table_map) 0, 0);
7235
 
          if (!tmp)
7236
 
            continue;
7237
 
          tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);
7238
 
          if (!tmp)
7239
 
            return(1);
7240
 
          tmp->quick_fix_field();
7241
 
          cond_tab->select_cond= !cond_tab->select_cond ? tmp :
7242
 
                                    new Item_cond_and(cond_tab->select_cond,tmp);
7243
 
          if (!cond_tab->select_cond)
7244
 
            return(1);
7245
 
          cond_tab->select_cond->quick_fix_field();
7246
 
        }       
7247
 
      }
7248
 
 
7249
 
      /* Push down non-constant conditions from on expressions */
7250
 
      JOIN_TAB *last_tab= tab;
7251
 
      while (first_inner_tab && first_inner_tab->last_inner == last_tab)
7252
 
      {  
7253
 
        /* 
7254
 
          Table tab is the last inner table of an outer join.
7255
 
          An on expression is always attached to it.
7256
 
        */     
7257
 
        COND *on_expr= *first_inner_tab->on_expr_ref;
7258
 
 
7259
 
        table_map used_tables2= (join->const_table_map |
7260
 
                                 OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);
7261
 
        for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)
7262
 
        {
7263
 
          current_map= tab->table->map;
7264
 
          used_tables2|= current_map;
7265
 
          COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,
7266
 
                                              current_map, 0);
7267
 
          if (tmp_cond)
7268
 
          {
7269
 
            JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;
7270
 
            /*
7271
 
              First add the guards for match variables of
7272
 
              all embedding outer join operations.
7273
 
            */
7274
 
            if (!(tmp_cond= add_found_match_trig_cond(cond_tab->first_inner,
7275
 
                                                     tmp_cond,
7276
 
                                                     first_inner_tab)))
7277
 
              return(1);
7278
 
            /* 
7279
 
              Now add the guard turning the predicate off for 
7280
 
              the null complemented row.
7281
 
            */ 
7282
 
            tmp_cond= new Item_func_trig_cond(tmp_cond,
7283
 
                                              &first_inner_tab->
7284
 
                                              not_null_compl);
7285
 
            if (tmp_cond)
7286
 
              tmp_cond->quick_fix_field();
7287
 
            /* Add the predicate to other pushed down predicates */
7288
 
            cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :
7289
 
                                  new Item_cond_and(cond_tab->select_cond,
7290
 
                                                    tmp_cond);
7291
 
            if (!cond_tab->select_cond)
7292
 
              return(1);
7293
 
            cond_tab->select_cond->quick_fix_field();
7294
 
          }              
7295
 
        }
7296
 
        first_inner_tab= first_inner_tab->first_upper;       
7297
 
      }
7298
 
    }
7299
 
  }
7300
 
  return(0);
7301
 
}
7302
 
 
7303
 
 
7304
 
/* 
 
1225
/*
7305
1226
  Check if given expression uses only table fields covered by the given index
7306
1227
 
7307
1228
  SYNOPSIS
7314
1235
  DESCRIPTION
7315
1236
    Check if given expression only uses fields covered by index #keyno in the
7316
1237
    table tbl. The expression can use any fields in any other tables.
7317
 
    
7318
 
    The expression is guaranteed not to be AND or OR - those constructs are 
 
1238
 
 
1239
    The expression is guaranteed not to be AND or OR - those constructs are
7319
1240
    handled outside of this function.
7320
1241
 
7321
1242
  RETURN
7322
1243
    true   Yes
7323
1244
    false  No
7324
1245
*/
7325
 
 
7326
 
bool uses_index_fields_only(Item *item, TABLE *tbl, uint keyno, 
7327
 
                            bool other_tbls_ok)
 
1246
static bool uses_index_fields_only(Item *item, Table *tbl, uint32_t keyno, bool other_tbls_ok)
7328
1247
{
7329
1248
  if (item->const_item())
7330
1249
    return true;
7331
1250
 
7332
 
  /* 
7333
 
    Don't push down the triggered conditions. Nested outer joins execution 
 
1251
  /*
 
1252
    Don't push down the triggered conditions. Nested outer joins execution
7334
1253
    code may need to evaluate a condition several times (both triggered and
7335
1254
    untriggered), and there is no way to put thi
7336
1255
    TODO: Consider cloning the triggered condition and using the copies for:
7337
1256
      1. push the first copy down, to have most restrictive index condition
7338
1257
         possible
7339
 
      2. Put the second copy into tab->select_cond. 
 
1258
      2. Put the second copy into tab->select_cond.
7340
1259
  */
7341
 
  if (item->type() == Item::FUNC_ITEM && 
 
1260
  if (item->type() == Item::FUNC_ITEM &&
7342
1261
      ((Item_func*)item)->functype() == Item_func::TRIG_COND_FUNC)
7343
1262
    return false;
7344
1263
 
7364
1283
    {
7365
1284
      /* This is a function, apply condition recursively to arguments */
7366
1285
      List_iterator<Item> li(*((Item_cond*)item)->argument_list());
7367
 
      Item *item;
7368
 
      while ((item=li++))
 
1286
      Item *list_item;
 
1287
      while ((list_item=li++))
7369
1288
      {
7370
1289
        if (!uses_index_fields_only(item, tbl, keyno, other_tbls_ok))
7371
1290
          return false;
7375
1294
  case Item::FIELD_ITEM:
7376
1295
    {
7377
1296
      Item_field *item_field= (Item_field*)item;
7378
 
      if (item_field->field->table != tbl) 
 
1297
      if (item_field->field->table != tbl)
7379
1298
        return true;
7380
 
      return item_field->field->part_of_key.is_set(keyno);
 
1299
      return item_field->field->part_of_key.test(keyno);
7381
1300
    }
7382
1301
  case Item::REF_ITEM:
7383
1302
    return uses_index_fields_only(item->real_item(), tbl, keyno,
7387
1306
  }
7388
1307
}
7389
1308
 
7390
 
 
7391
1309
#define ICP_COND_USES_INDEX_ONLY 10
7392
1310
 
7393
1311
/*
7402
1320
      other_tbls_ok  true <=> Fields of other non-const tables are allowed
7403
1321
 
7404
1322
  DESCRIPTION
7405
 
    Get a part of the condition that can be checked when for the given table 
 
1323
    Get a part of the condition that can be checked when for the given table
7406
1324
    we have values only of fields covered by some index. The condition may
7407
 
    refer to other tables, it is assumed that we have values of all of their 
 
1325
    refer to other tables, it is assumed that we have values of all of their
7408
1326
    fields.
7409
1327
 
7410
1328
    Example:
7411
1329
      make_cond_for_index(
7412
1330
         "cond(t1.field) AND cond(t2.key1) AND cond(t2.non_key) AND cond(t2.key2)",
7413
 
          t2, keyno(t2.key1)) 
 
1331
          t2, keyno(t2.key1))
7414
1332
      will return
7415
1333
        "cond(t1.field) AND cond(t2.key2)"
7416
1334
 
7417
1335
  RETURN
7418
1336
    Index condition, or NULL if no condition could be inferred.
7419
1337
*/
7420
 
 
7421
 
Item *make_cond_for_index(Item *cond, TABLE *table, uint keyno,
7422
 
                          bool other_tbls_ok)
 
1338
static Item *make_cond_for_index(Item *cond, Table *table, uint32_t keyno, bool other_tbls_ok)
7423
1339
{
7424
1340
  if (!cond)
7425
1341
    return NULL;
7426
1342
  if (cond->type() == Item::COND_ITEM)
7427
1343
  {
7428
 
    uint n_marked= 0;
 
1344
    uint32_t n_marked= 0;
7429
1345
    if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
7430
1346
    {
7431
1347
      Item_cond_and *new_cond=new Item_cond_and;
7432
1348
      if (!new_cond)
7433
 
        return (COND*) 0;
 
1349
        return (COND*) 0;
7434
1350
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
7435
1351
      Item *item;
7436
1352
      while ((item=li++))
7437
1353
      {
7438
 
        Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);
7439
 
        if (fix)
7440
 
          new_cond->argument_list()->push_back(fix);
 
1354
        Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);
 
1355
        if (fix)
 
1356
          new_cond->argument_list()->push_back(fix);
7441
1357
        n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);
7442
1358
      }
7443
1359
      if (n_marked ==((Item_cond*)cond)->argument_list()->elements)
7444
1360
        cond->marker= ICP_COND_USES_INDEX_ONLY;
7445
1361
      switch (new_cond->argument_list()->elements) {
7446
1362
      case 0:
7447
 
        return (COND*) 0;
 
1363
        return (COND*) 0;
7448
1364
      case 1:
7449
 
        return new_cond->argument_list()->head();
 
1365
        return new_cond->argument_list()->head();
7450
1366
      default:
7451
 
        new_cond->quick_fix_field();
7452
 
        return new_cond;
 
1367
        new_cond->quick_fix_field();
 
1368
        return new_cond;
7453
1369
      }
7454
1370
    }
7455
1371
    else /* It's OR */
7456
1372
    {
7457
1373
      Item_cond_or *new_cond=new Item_cond_or;
7458
1374
      if (!new_cond)
7459
 
        return (COND*) 0;
 
1375
        return (COND*) 0;
7460
1376
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
7461
1377
      Item *item;
7462
1378
      while ((item=li++))
7463
1379
      {
7464
 
        Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);
7465
 
        if (!fix)
7466
 
          return (COND*) 0;
7467
 
        new_cond->argument_list()->push_back(fix);
 
1380
        Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);
 
1381
        if (!fix)
 
1382
          return (COND*) 0;
 
1383
        new_cond->argument_list()->push_back(fix);
7468
1384
        n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);
7469
1385
      }
7470
1386
      if (n_marked ==((Item_cond*)cond)->argument_list()->elements)
7482
1398
}
7483
1399
 
7484
1400
 
7485
 
Item *make_cond_remainder(Item *cond, bool exclude_index)
 
1401
static Item *make_cond_remainder(Item *cond, bool exclude_index)
7486
1402
{
7487
1403
  if (exclude_index && cond->marker == ICP_COND_USES_INDEX_ONLY)
7488
1404
    return 0; /* Already checked */
7495
1411
      /* Create new top level AND item */
7496
1412
      Item_cond_and *new_cond=new Item_cond_and;
7497
1413
      if (!new_cond)
7498
 
        return (COND*) 0;
 
1414
        return (COND*) 0;
7499
1415
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
7500
1416
      Item *item;
7501
1417
      while ((item=li++))
7502
1418
      {
7503
 
        Item *fix= make_cond_remainder(item, exclude_index);
7504
 
        if (fix)
 
1419
        Item *fix= make_cond_remainder(item, exclude_index);
 
1420
        if (fix)
7505
1421
        {
7506
 
          new_cond->argument_list()->push_back(fix);
 
1422
          new_cond->argument_list()->push_back(fix);
7507
1423
          tbl_map |= fix->used_tables();
7508
1424
        }
7509
1425
      }
7510
1426
      switch (new_cond->argument_list()->elements) {
7511
1427
      case 0:
7512
 
        return (COND*) 0;
 
1428
        return (COND*) 0;
7513
1429
      case 1:
7514
 
        return new_cond->argument_list()->head();
 
1430
        return new_cond->argument_list()->head();
7515
1431
      default:
7516
 
        new_cond->quick_fix_field();
 
1432
        new_cond->quick_fix_field();
7517
1433
        ((Item_cond*)new_cond)->used_tables_cache= tbl_map;
7518
 
        return new_cond;
 
1434
        return new_cond;
7519
1435
      }
7520
1436
    }
7521
1437
    else /* It's OR */
7522
1438
    {
7523
1439
      Item_cond_or *new_cond=new Item_cond_or;
7524
1440
      if (!new_cond)
7525
 
        return (COND*) 0;
 
1441
        return (COND*) 0;
7526
1442
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
7527
1443
      Item *item;
7528
1444
      while ((item=li++))
7529
1445
      {
7530
 
        Item *fix= make_cond_remainder(item, false);
7531
 
        if (!fix)
7532
 
          return (COND*) 0;
7533
 
        new_cond->argument_list()->push_back(fix);
 
1446
        Item *fix= make_cond_remainder(item, false);
 
1447
        if (!fix)
 
1448
          return (COND*) 0;
 
1449
        new_cond->argument_list()->push_back(fix);
7534
1450
        tbl_map |= fix->used_tables();
7535
1451
      }
7536
1452
      new_cond->quick_fix_field();
7542
1458
  return cond;
7543
1459
}
7544
1460
 
7545
 
 
7546
 
/*
7547
 
  Try to extract and push the index condition
7548
 
 
7549
 
  SYNOPSIS
7550
 
    push_index_cond()
7551
 
      tab            A join tab that has tab->table->file and its condition
7552
 
                     in tab->select_cond
7553
 
      keyno          Index for which extract and push the condition
7554
 
      other_tbls_ok  true <=> Fields of other non-const tables are allowed
7555
 
 
7556
 
  DESCRIPTION
7557
 
    Try to extract and push the index condition down to table handler
7558
 
*/
7559
 
 
7560
 
static void push_index_cond(JOIN_TAB *tab, uint keyno, bool other_tbls_ok)
7561
 
{
7562
 
  Item *idx_cond;
7563
 
  if (tab->table->file->index_flags(keyno, 0, 1) & HA_DO_INDEX_COND_PUSHDOWN &&
7564
 
      tab->join->thd->variables.engine_condition_pushdown)
7565
 
  {
7566
 
    idx_cond= make_cond_for_index(tab->select_cond, tab->table, keyno,
7567
 
                                  other_tbls_ok);
7568
 
 
7569
 
    if (idx_cond)
7570
 
    {
7571
 
      tab->pre_idx_push_select_cond= tab->select_cond;
7572
 
      Item *idx_remainder_cond= 
7573
 
        tab->table->file->idx_cond_push(keyno, idx_cond);
7574
 
 
7575
 
      /*
7576
 
        Disable eq_ref's "lookup cache" if we've pushed down an index
7577
 
        condition. 
7578
 
        TODO: This check happens to work on current ICP implementations, but
7579
 
        there may exist a compliant implementation that will not work 
7580
 
        correctly with it. Sort this out when we stabilize the condition
7581
 
        pushdown APIs.
7582
 
      */
7583
 
      if (idx_remainder_cond != idx_cond)
7584
 
        tab->ref.disable_cache= true;
7585
 
 
7586
 
      Item *row_cond= make_cond_remainder(tab->select_cond, true);
7587
 
 
7588
 
      if (row_cond)
7589
 
      {
7590
 
        if (!idx_remainder_cond)
7591
 
          tab->select_cond= row_cond;
7592
 
        else
7593
 
        {
7594
 
          tab->select_cond= new Item_cond_and(row_cond, idx_remainder_cond);
7595
 
          tab->select_cond->quick_fix_field();
7596
 
          ((Item_cond_and*)tab->select_cond)->used_tables_cache= 
7597
 
            row_cond->used_tables() | idx_remainder_cond->used_tables();
7598
 
        }
7599
 
      }
7600
 
      else
7601
 
        tab->select_cond= idx_remainder_cond;
7602
 
      if (tab->select)
7603
 
      {
7604
 
        tab->select->cond= tab->select_cond;
7605
 
      }
7606
 
    }
7607
 
  }
7608
 
  return;
7609
 
}
7610
 
 
7611
 
 
7612
 
 
7613
 
    /*
7614
 
      Determine if the set is already ordered for ORDER BY, so it can 
7615
 
      disable join cache because it will change the ordering of the results.
7616
 
      Code handles sort table that is at any location (not only first after 
7617
 
      the const tables) despite the fact that it's currently prohibited.
7618
 
      We must disable join cache if the first non-const table alone is
7619
 
      ordered. If there is a temp table the ordering is done as a last
7620
 
      operation and doesn't prevent join cache usage.
7621
 
    */
7622
 
uint make_join_orderinfo(JOIN *join)
7623
 
{
7624
 
  uint i;
7625
 
  if (join->need_tmp)
7626
 
    return join->tables;
7627
 
 
7628
 
  for (i=join->const_tables ; i < join->tables ; i++)
7629
 
  {
7630
 
    JOIN_TAB *tab=join->join_tab+i;
7631
 
    TABLE *table=tab->table;
7632
 
    if ((table == join->sort_by_table && 
7633
 
         (!join->order || join->skip_sort_order)) ||
7634
 
        (join->sort_by_table == (TABLE *) 1 && i != join->const_tables))
7635
 
    {
7636
 
      break;
7637
 
    }
7638
 
  }
7639
 
  return i;
7640
 
}
7641
 
 
7642
 
 
7643
 
/*
7644
 
  Plan refinement stage: do various set ups for the executioner
7645
 
 
7646
 
  SYNOPSIS
7647
 
    make_join_readinfo()
7648
 
      join           Join being processed
7649
 
      options        Join's options (checking for SELECT_DESCRIBE, 
7650
 
                     SELECT_NO_JOIN_CACHE)
7651
 
      no_jbuf_after  Don't use join buffering after table with this number.
7652
 
 
7653
 
  DESCRIPTION
7654
 
    Plan refinement stage: do various set ups for the executioner
7655
 
      - set up use of join buffering
7656
 
      - push index conditions
7657
 
      - increment counters
7658
 
      - etc
7659
 
 
7660
 
  RETURN 
7661
 
    false - OK
7662
 
    true  - Out of memory
7663
 
*/
7664
 
 
7665
 
static bool
7666
 
make_join_readinfo(JOIN *join, uint64_t options, uint no_jbuf_after)
7667
 
{
7668
 
  uint i;
7669
 
  bool statistics= test(!(join->select_options & SELECT_DESCRIBE));
7670
 
  bool sorted= 1;
7671
 
 
7672
 
  for (i=join->const_tables ; i < join->tables ; i++)
7673
 
  {
7674
 
    JOIN_TAB *tab=join->join_tab+i;
7675
 
    TABLE *table=tab->table;
7676
 
    bool using_join_cache;
7677
 
    tab->read_record.table= table;
7678
 
    tab->read_record.file=table->file;
7679
 
    tab->next_select=sub_select;                /* normal select */
7680
 
    /* 
7681
 
      TODO: don't always instruct first table's ref/range access method to 
7682
 
      produce sorted output.
7683
 
    */
7684
 
    tab->sorted= sorted;
7685
 
    sorted= 0;                                  // only first must be sorted
7686
 
    if (tab->insideout_match_tab)
7687
 
    {
7688
 
      if (!(tab->insideout_buf= (uchar*)join->thd->alloc(tab->table->key_info
7689
 
                                                         [tab->index].
7690
 
                                                         key_length)))
7691
 
        return true;
7692
 
    }
7693
 
    switch (tab->type) {
7694
 
    case JT_SYSTEM:                             // Only happens with left join
7695
 
      table->status=STATUS_NO_RECORD;
7696
 
      tab->read_first_record= join_read_system;
7697
 
      tab->read_record.read_record= join_no_more_records;
7698
 
      break;
7699
 
    case JT_CONST:                              // Only happens with left join
7700
 
      table->status=STATUS_NO_RECORD;
7701
 
      tab->read_first_record= join_read_const;
7702
 
      tab->read_record.read_record= join_no_more_records;
7703
 
      if (table->covering_keys.is_set(tab->ref.key) &&
7704
 
          !table->no_keyread)
7705
 
      {
7706
 
        table->key_read=1;
7707
 
        table->file->extra(HA_EXTRA_KEYREAD);
7708
 
      }
7709
 
      break;
7710
 
    case JT_EQ_REF:
7711
 
      table->status=STATUS_NO_RECORD;
7712
 
      if (tab->select)
7713
 
      {
7714
 
        delete tab->select->quick;
7715
 
        tab->select->quick=0;
7716
 
      }
7717
 
      delete tab->quick;
7718
 
      tab->quick=0;
7719
 
      tab->read_first_record= join_read_key;
7720
 
      tab->read_record.read_record= join_no_more_records;
7721
 
      if (table->covering_keys.is_set(tab->ref.key) &&
7722
 
          !table->no_keyread)
7723
 
      {
7724
 
        table->key_read=1;
7725
 
        table->file->extra(HA_EXTRA_KEYREAD);
7726
 
      }
7727
 
      else
7728
 
        push_index_cond(tab, tab->ref.key, true);
7729
 
      break;
7730
 
    case JT_REF_OR_NULL:
7731
 
    case JT_REF:
7732
 
      table->status=STATUS_NO_RECORD;
7733
 
      if (tab->select)
7734
 
      {
7735
 
        delete tab->select->quick;
7736
 
        tab->select->quick=0;
7737
 
      }
7738
 
      delete tab->quick;
7739
 
      tab->quick=0;
7740
 
      if (table->covering_keys.is_set(tab->ref.key) &&
7741
 
          !table->no_keyread)
7742
 
      {
7743
 
        table->key_read=1;
7744
 
        table->file->extra(HA_EXTRA_KEYREAD);
7745
 
      }
7746
 
      else
7747
 
        push_index_cond(tab, tab->ref.key, true);
7748
 
      if (tab->type == JT_REF)
7749
 
      {
7750
 
        tab->read_first_record= join_read_always_key;
7751
 
        tab->read_record.read_record= tab->insideout_match_tab? 
7752
 
           join_read_next_same_diff : join_read_next_same;
7753
 
      }
7754
 
      else
7755
 
      {
7756
 
        tab->read_first_record= join_read_always_key_or_null;
7757
 
        tab->read_record.read_record= join_read_next_same_or_null;
7758
 
      }
7759
 
      break;
7760
 
    case JT_ALL:
7761
 
      /*
7762
 
        If previous table use cache
7763
 
        If the incoming data set is already sorted don't use cache.
7764
 
      */
7765
 
      table->status=STATUS_NO_RECORD;
7766
 
      using_join_cache= false;
7767
 
      if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&
7768
 
          tab->use_quick != 2 && !tab->first_inner && i <= no_jbuf_after &&
7769
 
          !tab->insideout_match_tab)
7770
 
      {
7771
 
        if ((options & SELECT_DESCRIBE) ||
7772
 
            !join_init_cache(join->thd,join->join_tab+join->const_tables,
7773
 
                             i-join->const_tables))
7774
 
        {
7775
 
          using_join_cache= true;
7776
 
          tab[-1].next_select=sub_select_cache; /* Patch previous */
7777
 
        }
7778
 
      }
7779
 
      /* These init changes read_record */
7780
 
      if (tab->use_quick == 2)
7781
 
      {
7782
 
        join->thd->server_status|=SERVER_QUERY_NO_GOOD_INDEX_USED;
7783
 
        tab->read_first_record= join_init_quick_read_record;
7784
 
        if (statistics)
7785
 
          status_var_increment(join->thd->status_var.select_range_check_count);
7786
 
      }
7787
 
      else
7788
 
      {
7789
 
        tab->read_first_record= join_init_read_record;
7790
 
        if (i == join->const_tables)
7791
 
        {
7792
 
          if (tab->select && tab->select->quick)
7793
 
          {
7794
 
            if (statistics)
7795
 
              status_var_increment(join->thd->status_var.select_range_count);
7796
 
          }
7797
 
          else
7798
 
          {
7799
 
            join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
7800
 
            if (statistics)
7801
 
              status_var_increment(join->thd->status_var.select_scan_count);
7802
 
          }
7803
 
        }
7804
 
        else
7805
 
        {
7806
 
          if (tab->select && tab->select->quick)
7807
 
          {
7808
 
            if (statistics)
7809
 
              status_var_increment(join->thd->status_var.select_full_range_join_count);
7810
 
          }
7811
 
          else
7812
 
          {
7813
 
            join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;
7814
 
            if (statistics)
7815
 
              status_var_increment(join->thd->status_var.select_full_join_count);
7816
 
          }
7817
 
        }
7818
 
        if (!table->no_keyread)
7819
 
        {
7820
 
          if (tab->select && tab->select->quick &&
7821
 
              tab->select->quick->index != MAX_KEY && //not index_merge
7822
 
              table->covering_keys.is_set(tab->select->quick->index))
7823
 
          {
7824
 
            table->key_read=1;
7825
 
            table->file->extra(HA_EXTRA_KEYREAD);
7826
 
          }
7827
 
          else if (!table->covering_keys.is_clear_all() &&
7828
 
                   !(tab->select && tab->select->quick))
7829
 
          {                                     // Only read index tree
7830
 
            if (!tab->insideout_match_tab)
7831
 
            {
7832
 
              /*
7833
 
                See bug #26447: "Using the clustered index for a table scan
7834
 
                is always faster than using a secondary index".
7835
 
              */
7836
 
              if (table->s->primary_key != MAX_KEY &&
7837
 
                  table->file->primary_key_is_clustered())
7838
 
                tab->index= table->s->primary_key;
7839
 
              else
7840
 
                tab->index=find_shortest_key(table, & table->covering_keys);
7841
 
            }
7842
 
            tab->read_first_record= join_read_first;
7843
 
            tab->type=JT_NEXT;          // Read with index_first / index_next
7844
 
          }
7845
 
        }
7846
 
        if (tab->select && tab->select->quick &&
7847
 
            tab->select->quick->index != MAX_KEY && ! tab->table->key_read)
7848
 
          push_index_cond(tab, tab->select->quick->index, !using_join_cache);
7849
 
      }
7850
 
      break;
7851
 
    default:
7852
 
      break;                                    /* purecov: deadcode */
7853
 
    case JT_UNKNOWN:
7854
 
    case JT_MAYBE_REF:
7855
 
      abort();                                  /* purecov: deadcode */
7856
 
    }
7857
 
  }
7858
 
  join->join_tab[join->tables-1].next_select=0; /* Set by do_select */
7859
 
  return(false);
7860
 
}
7861
 
 
7862
 
 
7863
 
/**
7864
 
  Give error if we some tables are done with a full join.
7865
 
 
7866
 
  This is used by multi_table_update and multi_table_delete when running
7867
 
  in safe mode.
7868
 
 
7869
 
  @param join           Join condition
7870
 
 
7871
 
  @retval
7872
 
    0   ok
7873
 
  @retval
7874
 
    1   Error (full join used)
7875
 
*/
7876
 
 
7877
 
bool error_if_full_join(JOIN *join)
7878
 
{
7879
 
  for (JOIN_TAB *tab=join->join_tab, *end=join->join_tab+join->tables;
7880
 
       tab < end;
7881
 
       tab++)
7882
 
  {
7883
 
    if (tab->type == JT_ALL && (!tab->select || !tab->select->quick))
7884
 
    {
7885
 
      my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
7886
 
                 ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
7887
 
      return(1);
7888
 
    }
7889
 
  }
7890
 
  return(0);
7891
 
}
7892
 
 
7893
 
 
7894
 
/**
7895
 
  cleanup JOIN_TAB.
7896
 
*/
7897
 
 
7898
 
void JOIN_TAB::cleanup()
 
1461
/**
 
1462
  cleanup JoinTable.
 
1463
*/
 
1464
void JoinTable::cleanup()
7899
1465
{
7900
1466
  delete select;
7901
1467
  select= 0;
7902
1468
  delete quick;
7903
1469
  quick= 0;
7904
 
  x_free(cache.buff);
 
1470
  if (cache.buff)
 
1471
    free(cache.buff);
7905
1472
  cache.buff= 0;
7906
1473
  limit= 0;
7907
1474
  if (table)
7909
1476
    if (table->key_read)
7910
1477
    {
7911
1478
      table->key_read= 0;
7912
 
      table->file->extra(HA_EXTRA_NO_KEYREAD);
 
1479
      table->cursor->extra(HA_EXTRA_NO_KEYREAD);
7913
1480
    }
7914
 
    table->file->ha_index_or_rnd_end();
 
1481
    table->cursor->ha_index_or_rnd_end();
7915
1482
    /*
7916
1483
      We need to reset this for next select
7917
1484
      (Tested in part_of_refkey)
7921
1488
  end_read_record(&read_record);
7922
1489
}
7923
1490
 
7924
 
 
7925
 
/**
7926
 
  Partially cleanup JOIN after it has executed: close index or rnd read
7927
 
  (table cursors), free quick selects.
7928
 
 
7929
 
    This function is called in the end of execution of a JOIN, before the used
7930
 
    tables are unlocked and closed.
7931
 
 
7932
 
    For a join that is resolved using a temporary table, the first sweep is
7933
 
    performed against actual tables and an intermediate result is inserted
7934
 
    into the temprorary table.
7935
 
    The last sweep is performed against the temporary table. Therefore,
7936
 
    the base tables and associated buffers used to fill the temporary table
7937
 
    are no longer needed, and this function is called to free them.
7938
 
 
7939
 
    For a join that is performed without a temporary table, this function
7940
 
    is called after all rows are sent, but before EOF packet is sent.
7941
 
 
7942
 
    For a simple SELECT with no subqueries this function performs a full
7943
 
    cleanup of the JOIN and calls mysql_unlock_read_tables to free used base
7944
 
    tables.
7945
 
 
7946
 
    If a JOIN is executed for a subquery or if it has a subquery, we can't
7947
 
    do the full cleanup and need to do a partial cleanup only.
7948
 
    - If a JOIN is not the top level join, we must not unlock the tables
7949
 
    because the outer select may not have been evaluated yet, and we
7950
 
    can't unlock only selected tables of a query.
7951
 
    - Additionally, if this JOIN corresponds to a correlated subquery, we
7952
 
    should not free quick selects and join buffers because they will be
7953
 
    needed for the next execution of the correlated subquery.
7954
 
    - However, if this is a JOIN for a [sub]select, which is not
7955
 
    a correlated subquery itself, but has subqueries, we can free it
7956
 
    fully and also free JOINs of all its subqueries. The exception
7957
 
    is a subquery in SELECT list, e.g: @n
7958
 
    SELECT a, (select max(b) from t1) group by c @n
7959
 
    This subquery will not be evaluated at first sweep and its value will
7960
 
    not be inserted into the temporary table. Instead, it's evaluated
7961
 
    when selecting from the temporary table. Therefore, it can't be freed
7962
 
    here even though it's not correlated.
7963
 
 
7964
 
  @todo
7965
 
    Unlock tables even if the join isn't top level select in the tree
7966
 
*/
7967
 
 
7968
 
void JOIN::join_free()
7969
 
{
7970
 
  SELECT_LEX_UNIT *tmp_unit;
7971
 
  SELECT_LEX *sl;
7972
 
  /*
7973
 
    Optimization: if not EXPLAIN and we are done with the JOIN,
7974
 
    free all tables.
7975
 
  */
7976
 
  bool full= (!select_lex->uncacheable && !thd->lex->describe);
7977
 
  bool can_unlock= full;
7978
 
 
7979
 
  cleanup(full);
7980
 
 
7981
 
  for (tmp_unit= select_lex->first_inner_unit();
7982
 
       tmp_unit;
7983
 
       tmp_unit= tmp_unit->next_unit())
7984
 
    for (sl= tmp_unit->first_select(); sl; sl= sl->next_select())
7985
 
    {
7986
 
      Item_subselect *subselect= sl->master_unit()->item;
7987
 
      bool full_local= full && (!subselect || subselect->is_evaluated());
7988
 
      /*
7989
 
        If this join is evaluated, we can fully clean it up and clean up all
7990
 
        its underlying joins even if they are correlated -- they will not be
7991
 
        used any more anyway.
7992
 
        If this join is not yet evaluated, we still must clean it up to
7993
 
        close its table cursors -- it may never get evaluated, as in case of
7994
 
        ... HAVING false OR a IN (SELECT ...))
7995
 
        but all table cursors must be closed before the unlock.
7996
 
      */
7997
 
      sl->cleanup_all_joins(full_local);
7998
 
      /* Can't unlock if at least one JOIN is still needed */
7999
 
      can_unlock= can_unlock && full_local;
8000
 
    }
8001
 
 
8002
 
  /*
8003
 
    We are not using tables anymore
8004
 
    Unlock all tables. We may be in an INSERT .... SELECT statement.
8005
 
  */
8006
 
  if (can_unlock && lock && thd->lock &&
8007
 
      !(select_options & SELECT_NO_UNLOCK) &&
8008
 
      !select_lex->subquery_in_having &&
8009
 
      (select_lex == (thd->lex->unit.fake_select_lex ?
8010
 
                      thd->lex->unit.fake_select_lex : &thd->lex->select_lex)))
8011
 
  {
8012
 
    /*
8013
 
      TODO: unlock tables even if the join isn't top level select in the
8014
 
      tree.
8015
 
    */
8016
 
    mysql_unlock_read_tables(thd, lock);           // Don't free join->lock
8017
 
    lock= 0;
8018
 
  }
8019
 
 
8020
 
  return;
8021
 
}
8022
 
 
8023
 
 
8024
 
/**
8025
 
  Free resources of given join.
8026
 
 
8027
 
  @param fill   true if we should free all resources, call with full==1
8028
 
                should be last, before it this function can be called with
8029
 
                full==0
8030
 
 
8031
 
  @note
8032
 
    With subquery this function definitely will be called several times,
8033
 
    but even for simple query it can be called several times.
8034
 
*/
8035
 
 
8036
 
void JOIN::cleanup(bool full)
8037
 
{
8038
 
  if (table)
8039
 
  {
8040
 
    JOIN_TAB *tab,*end;
8041
 
    /*
8042
 
      Only a sorted table may be cached.  This sorted table is always the
8043
 
      first non const table in join->table
8044
 
    */
8045
 
    if (tables > const_tables) // Test for not-const tables
8046
 
    {
8047
 
      free_io_cache(table[const_tables]);
8048
 
      filesort_free_buffers(table[const_tables],full);
8049
 
    }
8050
 
 
8051
 
    if (full)
8052
 
    {
8053
 
      for (tab= join_tab, end= tab+tables; tab != end; tab++)
8054
 
        tab->cleanup();
8055
 
      table= 0;
8056
 
    }
8057
 
    else
8058
 
    {
8059
 
      for (tab= join_tab, end= tab+tables; tab != end; tab++)
8060
 
      {
8061
 
        if (tab->table)
8062
 
          tab->table->file->ha_index_or_rnd_end();
8063
 
      }
8064
 
    }
8065
 
    cleanup_sj_tmp_tables(this);//
8066
 
  }
8067
 
  /*
8068
 
    We are not using tables anymore
8069
 
    Unlock all tables. We may be in an INSERT .... SELECT statement.
8070
 
  */
8071
 
  if (full)
8072
 
  {
8073
 
    if (tmp_join)
8074
 
      tmp_table_param.copy_field= 0;
8075
 
    group_fields.delete_elements();
8076
 
    /*
8077
 
      We can't call delete_elements() on copy_funcs as this will cause
8078
 
      problems in free_elements() as some of the elements are then deleted.
8079
 
    */
8080
 
    tmp_table_param.copy_funcs.empty();
8081
 
    /*
8082
 
      If we have tmp_join and 'this' JOIN is not tmp_join and
8083
 
      tmp_table_param.copy_field's  of them are equal then we have to remove
8084
 
      pointer to  tmp_table_param.copy_field from tmp_join, because it qill
8085
 
      be removed in tmp_table_param.cleanup().
8086
 
    */
8087
 
    if (tmp_join &&
8088
 
        tmp_join != this &&
8089
 
        tmp_join->tmp_table_param.copy_field ==
8090
 
        tmp_table_param.copy_field)
8091
 
    {
8092
 
      tmp_join->tmp_table_param.copy_field=
8093
 
        tmp_join->tmp_table_param.save_copy_field= 0;
8094
 
    }
8095
 
    tmp_table_param.cleanup();
8096
 
  }
8097
 
  return;
8098
 
}
8099
 
 
8100
 
 
8101
 
/**
8102
 
  Remove the following expressions from ORDER BY and GROUP BY:
 
1491
bool only_eq_ref_tables(JOIN *join,order_st *order,table_map tables)
 
1492
{
 
1493
  for (JoinTable **tab=join->map2table ; tables ; tab++, tables>>=1)
 
1494
  {
 
1495
    if (tables & 1 && !eq_ref_table(join, order, *tab))
 
1496
      return 0;
 
1497
  }
 
1498
  return 1;
 
1499
}
 
1500
 
 
1501
/**
 
1502
  Remove the following expressions from order_st BY and GROUP BY:
8103
1503
  Constant expressions @n
8104
1504
  Expression that only uses tables that are of type EQ_REF and the reference
8105
 
  is in the ORDER list or if all refereed tables are of the above type.
 
1505
  is in the order_st list or if all refereed tables are of the above type.
8106
1506
 
8107
1507
  In the following, the X field can be removed:
8108
1508
  @code
8109
 
  SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t1.a,t2.X
8110
 
  SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b ORDER BY t1.a,t3.X
 
1509
  SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t1.a,t2.X
 
1510
  SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b order_st BY t1.a,t3.X
8111
1511
  @endcode
8112
1512
 
8113
1513
  These can't be optimized:
8114
1514
  @code
8115
 
  SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.X,t1.a
8116
 
  SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b ORDER BY t1.a,t2.c
8117
 
  SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.b,t1.a
 
1515
  SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.X,t1.a
 
1516
  SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b order_st BY t1.a,t2.c
 
1517
  SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.b,t1.a
8118
1518
  @endcode
8119
1519
*/
8120
 
 
8121
 
static bool
8122
 
eq_ref_table(JOIN *join, ORDER *start_order, JOIN_TAB *tab)
 
1520
bool eq_ref_table(JOIN *join, order_st *start_order, JoinTable *tab)
8123
1521
{
8124
1522
  if (tab->cached_eq_ref_table)                 // If cached
8125
1523
    return tab->eq_ref_table;
8126
1524
  tab->cached_eq_ref_table=1;
8127
1525
  /* We can skip const tables only if not an outer table */
8128
 
  if (tab->type == JT_CONST && !tab->first_inner)
8129
 
    return (tab->eq_ref_table=1);               /* purecov: inspected */
8130
 
  if (tab->type != JT_EQ_REF || tab->table->maybe_null)
 
1526
  if (tab->type == AM_CONST && !tab->first_inner)
 
1527
    return (tab->eq_ref_table=1);
 
1528
  if (tab->type != AM_EQ_REF || tab->table->maybe_null)
8131
1529
    return (tab->eq_ref_table=0);               // We must use this
8132
1530
  Item **ref_item=tab->ref.items;
8133
1531
  Item **end=ref_item+tab->ref.key_parts;
8134
 
  uint found=0;
 
1532
  uint32_t found=0;
8135
1533
  table_map map=tab->table->map;
8136
1534
 
8137
1535
  for (; ref_item != end ; ref_item++)
8138
1536
  {
8139
1537
    if (! (*ref_item)->const_item())
8140
1538
    {                                           // Not a const ref
8141
 
      ORDER *order;
 
1539
      order_st *order;
8142
1540
      for (order=start_order ; order ; order=order->next)
8143
1541
      {
8144
 
        if ((*ref_item)->eq(order->item[0],0))
8145
 
          break;
 
1542
        if ((*ref_item)->eq(order->item[0],0))
 
1543
          break;
8146
1544
      }
8147
1545
      if (order)
8148
1546
      {
8149
 
        found++;
8150
 
        assert(!(order->used & map));
8151
 
        order->used|=map;
8152
 
        continue;                               // Used in ORDER BY
 
1547
        found++;
 
1548
        assert(!(order->used & map));
 
1549
        order->used|=map;
 
1550
        continue;                               // Used in order_st BY
8153
1551
      }
8154
1552
      if (!only_eq_ref_tables(join,start_order, (*ref_item)->used_tables()))
8155
 
        return (tab->eq_ref_table=0);
 
1553
        return (tab->eq_ref_table= 0);
8156
1554
    }
8157
1555
  }
8158
1556
  /* Check that there was no reference to table before sort order */
8164
1562
      continue;
8165
1563
    }
8166
1564
    if (start_order->depend_map & map)
8167
 
      return (tab->eq_ref_table=0);
8168
 
  }
8169
 
  return tab->eq_ref_table=1;
8170
 
}
8171
 
 
8172
 
 
8173
 
static bool
8174
 
only_eq_ref_tables(JOIN *join,ORDER *order,table_map tables)
8175
 
{
8176
 
  if (specialflag &  SPECIAL_SAFE_MODE)
8177
 
    return 0;                   // skip this optimize /* purecov: inspected */
8178
 
  for (JOIN_TAB **tab=join->map2table ; tables ; tab++, tables>>=1)
8179
 
  {
8180
 
    if (tables & 1 && !eq_ref_table(join, order, *tab))
8181
 
      return 0;
8182
 
  }
8183
 
  return 1;
8184
 
}
8185
 
 
8186
 
 
8187
 
/** Update the dependency map for the tables. */
8188
 
 
8189
 
static void update_depend_map(JOIN *join)
8190
 
{
8191
 
  JOIN_TAB *join_tab=join->join_tab, *end=join_tab+join->tables;
8192
 
 
8193
 
  for (; join_tab != end ; join_tab++)
8194
 
  {
8195
 
    TABLE_REF *ref= &join_tab->ref;
8196
 
    table_map depend_map=0;
8197
 
    Item **item=ref->items;
8198
 
    uint i;
8199
 
    for (i=0 ; i < ref->key_parts ; i++,item++)
8200
 
      depend_map|=(*item)->used_tables();
8201
 
    ref->depend_map=depend_map & ~OUTER_REF_TABLE_BIT;
8202
 
    depend_map&= ~OUTER_REF_TABLE_BIT;
8203
 
    for (JOIN_TAB **tab=join->map2table;
8204
 
         depend_map ;
8205
 
         tab++,depend_map>>=1 )
8206
 
    {
8207
 
      if (depend_map & 1)
8208
 
        ref->depend_map|=(*tab)->ref.depend_map;
8209
 
    }
8210
 
  }
8211
 
}
8212
 
 
8213
 
 
8214
 
/** Update the dependency map for the sort order. */
8215
 
 
8216
 
static void update_depend_map(JOIN *join, ORDER *order)
8217
 
{
8218
 
  for (; order ; order=order->next)
8219
 
  {
8220
 
    table_map depend_map;
8221
 
    order->item[0]->update_used_tables();
8222
 
    order->depend_map=depend_map=order->item[0]->used_tables();
8223
 
    // Not item_sum(), RAND() and no reference to table outside of sub select
8224
 
    if (!(order->depend_map & (OUTER_REF_TABLE_BIT | RAND_TABLE_BIT))
8225
 
        && !order->item[0]->with_sum_func)
8226
 
    {
8227
 
      for (JOIN_TAB **tab=join->map2table;
8228
 
           depend_map ;
8229
 
           tab++, depend_map>>=1)
8230
 
      {
8231
 
        if (depend_map & 1)
8232
 
          order->depend_map|=(*tab)->ref.depend_map;
8233
 
      }
8234
 
    }
8235
 
  }
8236
 
}
8237
 
 
8238
 
 
8239
 
/**
8240
 
  Remove all constants and check if ORDER only contains simple
8241
 
  expressions.
8242
 
 
8243
 
  simple_order is set to 1 if sort_order only uses fields from head table
8244
 
  and the head table is not a LEFT JOIN table.
8245
 
 
8246
 
  @param join                   Join handler
8247
 
  @param first_order            List of SORT or GROUP order
8248
 
  @param cond                   WHERE statement
8249
 
  @param change_list            Set to 1 if we should remove things from list.
8250
 
                               If this is not set, then only simple_order is
8251
 
                               calculated.
8252
 
  @param simple_order           Set to 1 if we are only using simple expressions
8253
 
 
8254
 
  @return
8255
 
    Returns new sort order
8256
 
*/
8257
 
 
8258
 
static ORDER *
8259
 
remove_const(JOIN *join,ORDER *first_order, COND *cond,
8260
 
             bool change_list, bool *simple_order)
8261
 
{
8262
 
  if (join->tables == join->const_tables)
8263
 
    return change_list ? 0 : first_order;               // No need to sort
8264
 
 
8265
 
  ORDER *order,**prev_ptr;
8266
 
  table_map first_table= join->join_tab[join->const_tables].table->map;
8267
 
  table_map not_const_tables= ~join->const_table_map;
8268
 
  table_map ref;
8269
 
 
8270
 
  prev_ptr= &first_order;
8271
 
  *simple_order= *join->join_tab[join->const_tables].on_expr_ref ? 0 : 1;
8272
 
 
8273
 
  /* NOTE: A variable of not_const_tables ^ first_table; breaks gcc 2.7 */
8274
 
 
8275
 
  update_depend_map(join, first_order);
8276
 
  for (order=first_order; order ; order=order->next)
8277
 
  {
8278
 
    table_map order_tables=order->item[0]->used_tables();
8279
 
    if (order->item[0]->with_sum_func)
8280
 
      *simple_order=0;                          // Must do a temp table to sort
8281
 
    else if (!(order_tables & not_const_tables))
8282
 
    {
8283
 
      if (order->item[0]->with_subselect)
8284
 
        order->item[0]->val_str(&order->item[0]->str_value);
8285
 
      continue;                                 // skip const item
8286
 
    }
8287
 
    else
8288
 
    {
8289
 
      if (order_tables & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT))
8290
 
        *simple_order=0;
8291
 
      else
8292
 
      {
8293
 
        Item *comp_item=0;
8294
 
        if (cond && const_expression_in_where(cond,order->item[0], &comp_item))
8295
 
        {
8296
 
          continue;
8297
 
        }
8298
 
        if ((ref=order_tables & (not_const_tables ^ first_table)))
8299
 
        {
8300
 
          if (!(order_tables & first_table) &&
8301
 
              only_eq_ref_tables(join,first_order, ref))
8302
 
          {
8303
 
            continue;
8304
 
          }
8305
 
          *simple_order=0;                      // Must do a temp table to sort
8306
 
        }
8307
 
      }
8308
 
    }
8309
 
    if (change_list)
8310
 
      *prev_ptr= order;                         // use this entry
8311
 
    prev_ptr= &order->next;
8312
 
  }
8313
 
  if (change_list)
8314
 
    *prev_ptr=0;
8315
 
  if (prev_ptr == &first_order)                 // Nothing to sort/group
8316
 
    *simple_order=1;
8317
 
  return(first_order);
8318
 
}
8319
 
 
8320
 
 
8321
 
static int
8322
 
return_zero_rows(JOIN *join, select_result *result,TABLE_LIST *tables,
8323
 
                 List<Item> &fields, bool send_row, uint64_t select_options,
8324
 
                 const char *info, Item *having)
8325
 
{
8326
 
  if (select_options & SELECT_DESCRIBE)
8327
 
  {
8328
 
    select_describe(join, false, false, false, info);
8329
 
    return(0);
8330
 
  }
8331
 
 
8332
 
  join->join_free();
8333
 
 
8334
 
  if (send_row)
8335
 
  {
8336
 
    for (TABLE_LIST *table= tables; table; table= table->next_leaf)
8337
 
      mark_as_null_row(table->table);           // All fields are NULL
8338
 
    if (having && having->val_int() == 0)
8339
 
      send_row=0;
8340
 
  }
8341
 
  if (!(result->send_fields(fields,
8342
 
                              Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)))
8343
 
  {
8344
 
    if (send_row)
8345
 
    {
8346
 
      List_iterator_fast<Item> it(fields);
8347
 
      Item *item;
8348
 
      while ((item= it++))
8349
 
        item->no_rows_in_result();
8350
 
      result->send_data(fields);
8351
 
    }
8352
 
    result->send_eof();                         // Should be safe
8353
 
  }
8354
 
  /* Update results for FOUND_ROWS */
8355
 
  join->thd->limit_found_rows= join->thd->examined_row_count= 0;
8356
 
  return(0);
8357
 
}
8358
 
 
8359
 
/*
8360
 
  used only in JOIN::clear
8361
 
*/
8362
 
static void clear_tables(JOIN *join)
8363
 
{
8364
 
  /* 
8365
 
    must clear only the non-const tables, as const tables
8366
 
    are not re-calculated.
8367
 
  */
8368
 
  for (uint i=join->const_tables ; i < join->tables ; i++)
8369
 
    mark_as_null_row(join->table[i]);           // All fields are NULL
8370
 
}
8371
 
 
8372
 
/*****************************************************************************
8373
 
  Make som simple condition optimization:
8374
 
  If there is a test 'field = const' change all refs to 'field' to 'const'
8375
 
  Remove all dummy tests 'item = item', 'const op const'.
8376
 
  Remove all 'item is NULL', when item can never be null!
8377
 
  item->marker should be 0 for all items on entry
8378
 
  Return in cond_value false if condition is impossible (1 = 2)
8379
 
*****************************************************************************/
8380
 
 
8381
 
class COND_CMP :public ilink {
8382
 
public:
8383
 
  static void *operator new(size_t size)
8384
 
  {
8385
 
    return (void*) sql_alloc((uint) size);
8386
 
  }
8387
 
  static void operator delete(void *ptr __attribute__((unused)),
8388
 
                              size_t size __attribute__((unused)))
8389
 
  { TRASH(ptr, size); }
8390
 
 
8391
 
  Item *and_level;
8392
 
  Item_func *cmp_func;
8393
 
  COND_CMP(Item *a,Item_func *b) :and_level(a),cmp_func(b) {}
8394
 
};
8395
 
 
8396
 
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
8397
 
template class I_List<COND_CMP>;
8398
 
template class I_List_iterator<COND_CMP>;
8399
 
#endif
8400
 
 
 
1565
      return (tab->eq_ref_table= 0);
 
1566
  }
 
1567
  return tab->eq_ref_table= 1;
 
1568
}
8401
1569
 
8402
1570
/**
8403
1571
  Find the multiple equality predicate containing a field.
8417
1585
    - Item_equal for the found multiple equality predicate if a success;
8418
1586
    - NULL otherwise.
8419
1587
*/
8420
 
 
8421
 
Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field,
8422
 
                            bool *inherited_fl)
 
1588
static Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field, bool *inherited_fl)
8423
1589
{
8424
1590
  Item_equal *item= 0;
8425
1591
  bool in_upper_level= false;
8440
1606
  return item;
8441
1607
}
8442
1608
 
8443
 
  
8444
1609
/**
8445
1610
  Check whether an equality can be used to build multiple equalities.
8446
1611
 
8467
1632
    the check_equality will be called for the following equality
8468
1633
    predicates a=b, b=c, b=2 and f=e.
8469
1634
    - For a=b it will be called with *cond_equal=(0,[]) and will transform
8470
 
      *cond_equal into (0,[Item_equal(a,b)]). 
 
1635
      *cond_equal into (0,[Item_equal(a,b)]).
8471
1636
    - For b=c it will be called with *cond_equal=(0,[Item_equal(a,b)])
8472
1637
      and will transform *cond_equal into CE=(0,[Item_equal(a,b,c)]).
8473
1638
    - For b=2 it will be called with *cond_equal=(ptr(CE),[])
8480
1645
    the Field::eq_def method) are placed to the same multiple equalities.
8481
1646
    Because of this some equality predicates are not eliminated and
8482
1647
    can be used in the constant propagation procedure.
8483
 
    We could weeken the equlity test as soon as at least one of the 
8484
 
    equal fields is to be equal to a constant. It would require a 
 
1648
    We could weeken the equlity test as soon as at least one of the
 
1649
    equal fields is to be equal to a constant. It would require a
8485
1650
    more complicated implementation: we would have to store, in
8486
1651
    general case, its own constant for each fields from the multiple
8487
1652
    equality. But at the same time it would allow us to get rid
8499
1664
    containing just field1 and field2 is added to the existing
8500
1665
    multiple equalities.
8501
1666
    If the function processes the predicate of the form field1=const,
8502
 
    it looks for a multiple equality containing field1. If found, the 
 
1667
    it looks for a multiple equality containing field1. If found, the
8503
1668
    function checks the constant of the multiple equality. If the value
8504
1669
    is unknown, it is setup to const. Otherwise the value is compared with
8505
1670
    const and the evaluation of the equality predicate is performed.
8522
1687
  @retval
8523
1688
    false   otherwise
8524
1689
*/
8525
 
 
8526
 
static bool check_simple_equality(Item *left_item, Item *right_item,
8527
 
                                  Item *item, COND_EQUAL *cond_equal)
 
1690
static bool check_simple_equality(Item *left_item,
 
1691
                                  Item *right_item,
 
1692
                                  Item *item,
 
1693
                                  COND_EQUAL *cond_equal)
8528
1694
{
8529
 
  if (left_item->type() == Item::REF_ITEM &&
8530
 
      ((Item_ref*)left_item)->ref_type() == Item_ref::VIEW_REF)
8531
 
  {
8532
 
    if (((Item_ref*)left_item)->depended_from)
8533
 
      return false;
8534
 
    left_item= left_item->real_item();
8535
 
  }
8536
 
  if (right_item->type() == Item::REF_ITEM &&
8537
 
      ((Item_ref*)right_item)->ref_type() == Item_ref::VIEW_REF)
8538
 
  {
8539
 
    if (((Item_ref*)right_item)->depended_from)
8540
 
      return false;
8541
 
    right_item= right_item->real_item();
8542
 
  }
8543
1695
  if (left_item->type() == Item::FIELD_ITEM &&
8544
1696
      right_item->type() == Item::FIELD_ITEM &&
8545
1697
      !((Item_field*)left_item)->depended_from &&
8557
1709
    bool left_copyfl, right_copyfl;
8558
1710
    Item_equal *left_item_equal=
8559
1711
               find_item_equal(cond_equal, left_field, &left_copyfl);
8560
 
    Item_equal *right_item_equal= 
 
1712
    Item_equal *right_item_equal=
8561
1713
               find_item_equal(cond_equal, right_field, &right_copyfl);
8562
1714
 
8563
1715
    /* As (NULL=NULL) != true we can't just remove the predicate f=f */
8564
1716
    if (left_field->eq(right_field)) /* f = f */
8565
 
      return (!(left_field->maybe_null() && !left_item_equal)); 
 
1717
      return (!(left_field->maybe_null() && !left_item_equal));
8566
1718
 
8567
1719
    if (left_item_equal && left_item_equal == right_item_equal)
8568
1720
    {
8569
 
      /* 
 
1721
      /*
8570
1722
        The equality predicate is inference of one of the existing
8571
1723
        multiple equalities, i.e the condition is already covered
8572
1724
        by upper level equalities
8573
1725
      */
8574
1726
       return true;
8575
1727
    }
8576
 
    
8577
 
    bool copy_item_name= test(item && item->name >= subq_sj_cond_name && 
 
1728
 
 
1729
    bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&
8578
1730
                              item->name < subq_sj_cond_name + 64);
8579
1731
    /* Copy the found multiple equalities at the current level if needed */
8580
1732
    if (left_copyfl)
8595
1747
    }
8596
1748
 
8597
1749
    if (left_item_equal)
8598
 
    { 
 
1750
    {
8599
1751
      /* left item was found in the current or one of the upper levels */
8600
1752
      if (! right_item_equal)
8601
1753
        left_item_equal->add((Item_field *) right_item);
8610
1762
      }
8611
1763
    }
8612
1764
    else
8613
 
    { 
 
1765
    {
8614
1766
      /* left item was not found neither the current nor in upper levels  */
8615
1767
      if (right_item_equal)
8616
1768
      {
8618
1770
        if (copy_item_name)
8619
1771
          right_item_equal->name = item->name;
8620
1772
      }
8621
 
      else 
 
1773
      else
8622
1774
      {
8623
1775
        /* None of the fields was found in multiple equalities */
8624
1776
        Item_equal *item_equal= new Item_equal((Item_field *) left_item,
8666
1818
          eq_item->set_cmp_func();
8667
1819
          eq_item->quick_fix_field();
8668
1820
          item= eq_item;
8669
 
        }  
 
1821
        }
8670
1822
        if ((cs != ((Item_func *) item)->compare_collation()) ||
8671
1823
            !cs->coll->propagate(cs, 0, 0))
8672
1824
          return false;
8681
1833
      }
8682
1834
      if (item_equal)
8683
1835
      {
8684
 
        /* 
 
1836
        /*
8685
1837
          The flag cond_false will be set to 1 after this, if item_equal
8686
1838
          already contains a constant and its value is  not equal to
8687
1839
          the value of const_item.
8699
1851
  return false;
8700
1852
}
8701
1853
 
8702
 
 
8703
1854
/**
8704
1855
  Convert row equalities into a conjunction of regular equalities.
8705
1856
 
8712
1863
    simple equality nor a row equality the item for this predicate is added
8713
1864
    to eq_list.
8714
1865
 
8715
 
  @param thd        thread handle
 
1866
  @param session        thread handle
8716
1867
  @param left_row   left term of the row equality to be processed
8717
1868
  @param right_row  right term of the row equality to be processed
8718
1869
  @param cond_equal multiple equalities that must hold together with the
8725
1876
  @retval
8726
1877
    false   otherwise
8727
1878
*/
8728
 
 
8729
 
static bool check_row_equality(THD *thd, Item *left_row, Item_row *right_row,
8730
 
                               COND_EQUAL *cond_equal, List<Item>* eq_list)
8731
 
{ 
8732
 
  uint n= left_row->cols();
8733
 
  for (uint i= 0 ; i < n; i++)
 
1879
static bool check_row_equality(Session *session,
 
1880
                               Item *left_row, 
 
1881
                               Item_row *right_row,
 
1882
                               COND_EQUAL *cond_equal,
 
1883
                               List<Item>* eq_list)
 
1884
{
 
1885
  uint32_t n= left_row->cols();
 
1886
  for (uint32_t i= 0 ; i < n; i++)
8734
1887
  {
8735
1888
    bool is_converted;
8736
1889
    Item *left_item= left_row->element_index(i);
8738
1891
    if (left_item->type() == Item::ROW_ITEM &&
8739
1892
        right_item->type() == Item::ROW_ITEM)
8740
1893
    {
8741
 
      is_converted= check_row_equality(thd, 
 
1894
      is_converted= check_row_equality(session,
8742
1895
                                       (Item_row *) left_item,
8743
1896
                                       (Item_row *) right_item,
8744
1897
                                       cond_equal, eq_list);
8745
1898
      if (!is_converted)
8746
 
        thd->lex->current_select->cond_count++;      
 
1899
        session->lex->current_select->cond_count++;
8747
1900
    }
8748
1901
    else
8749
 
    { 
 
1902
    {
8750
1903
      is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);
8751
 
      thd->lex->current_select->cond_count++;
8752
 
    }  
8753
 
 
 
1904
      session->lex->current_select->cond_count++;
 
1905
    }
 
1906
 
8754
1907
    if (!is_converted)
8755
1908
    {
8756
1909
      Item_func_eq *eq_item;
8764
1917
  return true;
8765
1918
}
8766
1919
 
8767
 
 
8768
1920
/**
8769
1921
  Eliminate row equalities and form multiple equalities predicates.
8770
1922
 
8779
1931
    equalities which are treated in the same way as original equality
8780
1932
    predicates.
8781
1933
 
8782
 
  @param thd        thread handle
 
1934
  @param session        thread handle
8783
1935
  @param item       predicate to process
8784
1936
  @param cond_equal multiple equalities that must hold together with the
8785
1937
                    predicate
8794
1946
           or, if the equality is neither a simple one nor a row equality,
8795
1947
           or, if the procedure fails by a fatal error.
8796
1948
*/
8797
 
 
8798
 
static bool check_equality(THD *thd, Item *item, COND_EQUAL *cond_equal,
8799
 
                           List<Item> *eq_list)
 
1949
static bool check_equality(Session *session, Item *item, COND_EQUAL *cond_equal, List<Item> *eq_list)
8800
1950
{
8801
1951
  if (item->type() == Item::FUNC_ITEM &&
8802
1952
         ((Item_func*) item)->functype() == Item_func::EQ_FUNC)
8807
1957
    if (left_item->type() == Item::ROW_ITEM &&
8808
1958
        right_item->type() == Item::ROW_ITEM)
8809
1959
    {
8810
 
      thd->lex->current_select->cond_count--;
8811
 
      return check_row_equality(thd,
 
1960
      session->lex->current_select->cond_count--;
 
1961
      return check_row_equality(session,
8812
1962
                                (Item_row *) left_item,
8813
1963
                                (Item_row *) right_item,
8814
1964
                                cond_equal, eq_list);
8815
1965
    }
8816
 
    else 
 
1966
    else
8817
1967
      return check_simple_equality(left_item, right_item, item, cond_equal);
8818
 
  } 
 
1968
  }
8819
1969
  return false;
8820
1970
}
8821
1971
 
8822
 
                          
8823
1972
/**
8824
1973
  Replace all equality predicates in a condition by multiple equality items.
8825
1974
 
8826
1975
    At each 'and' level the function detects items for equality predicates
8827
1976
    and replaced them by a set of multiple equality items of class Item_equal,
8828
 
    taking into account inherited equalities from upper levels. 
 
1977
    taking into account inherited equalities from upper levels.
8829
1978
    If an equality predicate is used not in a conjunction it's just
8830
1979
    replaced by a multiple equality predicate.
8831
1980
    For each 'and' level the function set a pointer to the inherited
8832
1981
    multiple equalities in the cond_equal field of the associated
8833
 
    object of the type Item_cond_and.   
 
1982
    object of the type Item_cond_and.
8834
1983
    The function also traverses the cond tree and and for each field reference
8835
1984
    sets a pointer to the multiple equality item containing the field, if there
8836
1985
    is any. If this multiple equality equates fields to a constant the
8837
 
    function replaces the field reference by the constant in the cases 
 
1986
    function replaces the field reference by the constant in the cases
8838
1987
    when the field is not of a string type or when the field reference is
8839
1988
    just an argument of a comparison predicate.
8840
 
    The function also determines the maximum number of members in 
 
1989
    The function also determines the maximum number of members in
8841
1990
    equality lists of each Item_cond_and object assigning it to
8842
 
    thd->lex->current_select->max_equal_elems.
 
1991
    session->lex->current_select->max_equal_elems.
8843
1992
 
8844
1993
  @note
8845
1994
    Multiple equality predicate =(f1,..fn) is equivalent to the conjuction of
8851
2000
    in a conjuction for a minimal set of multiple equality predicates.
8852
2001
    This set can be considered as a canonical representation of the
8853
2002
    sub-conjunction of the equality predicates.
8854
 
    E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by 
 
2003
    E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by
8855
2004
    (=(t1.a,t2.b,t3.c) AND t2.b>5), not by
8856
2005
    (=(t1.a,t2.b) AND =(t1.a,t3.c) AND t2.b>5);
8857
2006
    while (t1.a=t2.b AND t2.b>5 AND t3.c=t4.d) is replaced by
8862
2011
    The function performs the substitution in a recursive descent by
8863
2012
    the condtion tree, passing to the next AND level a chain of multiple
8864
2013
    equality predicates which have been built at the upper levels.
8865
 
    The Item_equal items built at the level are attached to other 
 
2014
    The Item_equal items built at the level are attached to other
8866
2015
    non-equality conjucts as a sublist. The pointer to the inherited
8867
2016
    multiple equalities is saved in the and condition object (Item_cond_and).
8868
 
    This chain allows us for any field reference occurence easyly to find a 
 
2017
    This chain allows us for any field reference occurence easyly to find a
8869
2018
    multiple equality that must be held for this occurence.
8870
2019
    For each AND level we do the following:
8871
2020
    - scan it for all equality predicate (=) items
8872
2021
    - join them into disjoint Item_equal() groups
8873
 
    - process the included OR conditions recursively to do the same for 
8874
 
      lower AND levels. 
 
2022
    - process the included OR conditions recursively to do the same for
 
2023
      lower AND levels.
8875
2024
 
8876
2025
    We need to do things in this order as lower AND levels need to know about
8877
2026
    all possible Item_equal objects in upper levels.
8878
2027
 
8879
 
  @param thd        thread handle
 
2028
  @param session        thread handle
8880
2029
  @param cond       condition(expression) where to make replacement
8881
2030
  @param inherited  path to all inherited multiple equality items
8882
2031
 
8883
2032
  @return
8884
2033
    pointer to the transformed condition
8885
2034
*/
8886
 
 
8887
 
static COND *build_equal_items_for_cond(THD *thd, COND *cond,
8888
 
                                        COND_EQUAL *inherited)
 
2035
static COND *build_equal_items_for_cond(Session *session, COND *cond, COND_EQUAL *inherited)
8889
2036
{
8890
2037
  Item_equal *item_equal;
8891
2038
  COND_EQUAL cond_equal;
8897
2044
    bool and_level= ((Item_cond*) cond)->functype() ==
8898
2045
      Item_func::COND_AND_FUNC;
8899
2046
    List<Item> *args= ((Item_cond*) cond)->argument_list();
8900
 
    
 
2047
 
8901
2048
    List_iterator<Item> li(*args);
8902
2049
    Item *item;
8903
2050
 
8906
2053
      /*
8907
2054
         Retrieve all conjucts of this level detecting the equality
8908
2055
         that are subject to substitution by multiple equality items and
8909
 
         removing each such predicate from the conjunction after having 
 
2056
         removing each such predicate from the conjunction after having
8910
2057
         found/created a multiple equality whose inference the predicate is.
8911
 
     */      
 
2058
     */
8912
2059
      while ((item= li++))
8913
2060
      {
8914
2061
        /*
8916
2063
          structure here because it's restored before each
8917
2064
          re-execution of any prepared statement/stored procedure.
8918
2065
        */
8919
 
        if (check_equality(thd, item, &cond_equal, &eq_list))
 
2066
        if (check_equality(session, item, &cond_equal, &eq_list))
8920
2067
          li.remove();
8921
2068
      }
8922
2069
 
8925
2072
      {
8926
2073
        item_equal->fix_length_and_dec();
8927
2074
        item_equal->update_used_tables();
8928
 
        set_if_bigger(thd->lex->current_select->max_equal_elems,
8929
 
                      item_equal->members());  
 
2075
        set_if_bigger(session->lex->current_select->max_equal_elems,
 
2076
                      item_equal->members());
8930
2077
      }
8931
2078
 
8932
2079
      ((Item_cond_and*)cond)->cond_equal= cond_equal;
8938
2085
    */
8939
2086
    li.rewind();
8940
2087
    while ((item= li++))
8941
 
    { 
 
2088
    {
8942
2089
      Item *new_item;
8943
 
      if ((new_item= build_equal_items_for_cond(thd, item, inherited)) != item)
 
2090
      if ((new_item= build_equal_items_for_cond(session, item, inherited)) != item)
8944
2091
      {
8945
2092
        /* This replacement happens only for standalone equalities */
8946
2093
        /*
8968
2115
      (b=5) and (a=c) are standalone equalities.
8969
2116
      In general we can't leave alone standalone eqalities:
8970
2117
      for WHERE a=b AND c=d AND (b=c OR d=5)
8971
 
      b=c is replaced by =(a,b,c,d).  
 
2118
      b=c is replaced by =(a,b,c,d).
8972
2119
     */
8973
 
    if (check_equality(thd, cond, &cond_equal, &eq_list))
 
2120
    if (check_equality(session, cond, &cond_equal, &eq_list))
8974
2121
    {
8975
2122
      int n= cond_equal.current_level.elements + eq_list.elements;
8976
2123
      if (n == 0)
8981
2128
        {
8982
2129
          item_equal->fix_length_and_dec();
8983
2130
          item_equal->update_used_tables();
8984
 
        }
 
2131
        }
8985
2132
        else
8986
2133
          item_equal= (Item_equal *) eq_list.pop();
8987
 
        set_if_bigger(thd->lex->current_select->max_equal_elems,
8988
 
                      item_equal->members());  
 
2134
        set_if_bigger(session->lex->current_select->max_equal_elems,
 
2135
                      item_equal->members());
8989
2136
        return item_equal;
8990
2137
      }
8991
2138
      else
8992
2139
      {
8993
 
        /* 
 
2140
        /*
8994
2141
          Here a new AND level must be created. It can happen only
8995
2142
          when a row equality is processed as a standalone predicate.
8996
 
        */
 
2143
        */
8997
2144
        Item_cond_and *and_cond= new Item_cond_and(eq_list);
8998
2145
        and_cond->quick_fix_field();
8999
2146
        List<Item> *args= and_cond->argument_list();
9002
2149
        {
9003
2150
          item_equal->fix_length_and_dec();
9004
2151
          item_equal->update_used_tables();
9005
 
          set_if_bigger(thd->lex->current_select->max_equal_elems,
9006
 
                        item_equal->members());  
 
2152
          set_if_bigger(session->lex->current_select->max_equal_elems,
 
2153
                        item_equal->members());
9007
2154
        }
9008
2155
        and_cond->cond_equal= cond_equal;
9009
2156
        args->concat((List<Item> *)&cond_equal.current_level);
9010
 
        
 
2157
 
9011
2158
        return and_cond;
9012
2159
      }
9013
2160
    }
9014
 
    /* 
 
2161
    /*
9015
2162
      For each field reference in cond, not from equal item predicates,
9016
2163
      set a pointer to the multiple equality it belongs to (if there is any)
9017
2164
      as soon the field is not of a string type or the field reference is
9018
 
      an argument of a comparison predicate. 
9019
 
    */ 
9020
 
    uchar *is_subst_valid= (uchar *) 1;
 
2165
      an argument of a comparison predicate.
 
2166
    */
 
2167
    unsigned char *is_subst_valid= (unsigned char *) 1;
9021
2168
    cond= cond->compile(&Item::subst_argument_checker,
9022
 
                        &is_subst_valid, 
 
2169
                        &is_subst_valid,
9023
2170
                        &Item::equal_fields_propagator,
9024
 
                        (uchar *) inherited);
 
2171
                        (unsigned char *) inherited);
9025
2172
    cond->update_used_tables();
9026
2173
  }
9027
2174
  return cond;
9028
2175
}
9029
2176
 
9030
 
 
9031
2177
/**
9032
2178
  Build multiple equalities for a condition and all on expressions that
9033
2179
  inherit these multiple equalities.
9073
2219
      SELECT * FROM (t1,t2) LEFT JOIN (t3,t4) ON t2.a=t4.a AND t3.a=t4.a
9074
2220
        WHERE t1.a=t2.a
9075
2221
    @endcode
9076
 
    that is equivalent to:   
 
2222
    that is equivalent to:
9077
2223
    @code
9078
2224
      SELECT * FROM (t2 LEFT JOIN (t3,t4)ON t2.a=t4.a AND t3.a=t4.a), t1
9079
2225
        WHERE t1.a=t2.a
9080
2226
    @endcode
9081
2227
    Thus, applying equalities from the where condition we basically
9082
2228
    can get more freedom in performing join operations.
9083
 
    Althogh we don't use this property now, it probably makes sense to use 
9084
 
    it in the future.    
9085
 
  @param thd                  Thread handler
 
2229
    Althogh we don't use this property now, it probably makes sense to use
 
2230
    it in the future.
 
2231
  @param session                      Thread Cursor
9086
2232
  @param cond                condition to build the multiple equalities for
9087
2233
  @param inherited           path to all inherited multiple equality items
9088
2234
  @param join_list           list of join tables to which the condition
9093
2239
  @return
9094
2240
    pointer to the transformed condition containing multiple equalities
9095
2241
*/
9096
 
   
9097
 
static COND *build_equal_items(THD *thd, COND *cond,
 
2242
static COND *build_equal_items(Session *session, COND *cond,
9098
2243
                               COND_EQUAL *inherited,
9099
 
                               List<TABLE_LIST> *join_list,
 
2244
                               List<TableList> *join_list,
9100
2245
                               COND_EQUAL **cond_equal_ref)
9101
2246
{
9102
2247
  COND_EQUAL *cond_equal= 0;
9103
2248
 
9104
 
  if (cond) 
 
2249
  if (cond)
9105
2250
  {
9106
 
    cond= build_equal_items_for_cond(thd, cond, inherited);
 
2251
    cond= build_equal_items_for_cond(session, cond, inherited);
9107
2252
    cond->update_used_tables();
9108
2253
    if (cond->type() == Item::COND_ITEM &&
9109
2254
        ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
9124
2269
 
9125
2270
  if (join_list)
9126
2271
  {
9127
 
    TABLE_LIST *table;
9128
 
    List_iterator<TABLE_LIST> li(*join_list);
 
2272
    TableList *table;
 
2273
    List_iterator<TableList> li(*join_list);
9129
2274
 
9130
2275
    while ((table= li++))
9131
2276
    {
9132
2277
      if (table->on_expr)
9133
2278
      {
9134
 
        List<TABLE_LIST> *nested_join_list= table->nested_join ?
 
2279
        List<TableList> *nested_join_list= table->nested_join ?
9135
2280
          &table->nested_join->join_list : NULL;
9136
2281
        /*
9137
2282
          We can modify table->on_expr because its old value will
9138
2283
          be restored before re-execution of PS/SP.
9139
2284
        */
9140
 
        table->on_expr= build_equal_items(thd, table->on_expr, inherited,
 
2285
        table->on_expr= build_equal_items(session, table->on_expr, inherited,
9141
2286
                                          nested_join_list,
9142
2287
                                          &table->cond_equal);
9143
2288
      }
9145
2290
  }
9146
2291
 
9147
2292
  return cond;
9148
 
}    
9149
 
 
 
2293
}
9150
2294
 
9151
2295
/**
9152
2296
  Compare field items by table order in the execution plan.
9153
2297
 
9154
2298
    field1 considered as better than field2 if the table containing
9155
 
    field1 is accessed earlier than the table containing field2.   
 
2299
    field1 is accessed earlier than the table containing field2.
9156
2300
    The function finds out what of two fields is better according
9157
2301
    this criteria.
9158
2302
 
9167
2311
  @retval
9168
2312
    0  otherwise
9169
2313
*/
9170
 
 
9171
2314
static int compare_fields_by_table_order(Item_field *field1,
9172
 
                                  Item_field *field2,
9173
 
                                  void *table_join_idx)
 
2315
                                         Item_field *field2,
 
2316
                                         void *table_join_idx)
9174
2317
{
9175
2318
  int cmp= 0;
9176
2319
  bool outer_ref= 0;
9177
2320
  if (field2->used_tables() & OUTER_REF_TABLE_BIT)
9178
 
  {  
 
2321
  {
9179
2322
    outer_ref= 1;
9180
2323
    cmp= -1;
9181
2324
  }
9186
2329
  }
9187
2330
  if (outer_ref)
9188
2331
    return cmp;
9189
 
  JOIN_TAB **idx= (JOIN_TAB **) table_join_idx;
 
2332
  JoinTable **idx= (JoinTable **) table_join_idx;
9190
2333
  cmp= idx[field2->field->table->tablenr]-idx[field1->field->table->tablenr];
9191
2334
  return cmp < 0 ? -1 : (cmp ? 1 : 0);
9192
2335
}
9193
2336
 
9194
 
 
9195
2337
/**
9196
2338
  Generate minimal set of simple equalities equivalent to a multiple equality.
9197
2339
 
9231
2373
    a pointer to the simple generated equality, if success.
9232
2374
    - 0, otherwise.
9233
2375
*/
9234
 
 
9235
 
static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,
9236
 
                                  Item_equal *item_equal)
 
2376
static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels, Item_equal *item_equal)
9237
2377
{
9238
2378
  List<Item> eq_list;
9239
2379
  Item_func_eq *eq_item= 0;
9240
2380
  if (((Item *) item_equal)->const_item() && !item_equal->val_int())
9241
 
    return new Item_int((int64_t) 0,1); 
 
2381
    return new Item_int((int64_t) 0,1);
9242
2382
  Item *item_const= item_equal->get_const();
9243
2383
  Item_equal_iterator it(*item_equal);
9244
2384
  Item *head;
9255
2395
    Item_equal *upper= item_field->find_item_equal(upper_levels);
9256
2396
    Item_field *item= item_field;
9257
2397
    if (upper)
9258
 
    { 
 
2398
    {
9259
2399
      if (item_const && upper->get_const())
9260
2400
        item= 0;
9261
2401
      else
9299
2439
 
9300
2440
  cond->quick_fix_field();
9301
2441
  cond->update_used_tables();
9302
 
   
 
2442
 
9303
2443
  return cond;
9304
2444
}
9305
2445
 
9306
 
 
9307
2446
/**
9308
2447
  Substitute every field reference in a condition by the best equal field
9309
2448
  and eliminate all multiple equality predicates.
9312
2451
    multiple equality predicate it sorts the field references in it
9313
2452
    according to the order of tables specified by the table_join_idx
9314
2453
    parameter. Then it eliminates the multiple equality predicate it
9315
 
    replacing it by the conjunction of simple equality predicates 
 
2454
    replacing it by the conjunction of simple equality predicates
9316
2455
    equating every field from the multiple equality to the first
9317
2456
    field in it, or to the constant, if there is any.
9318
2457
    After this the function retrieves all other conjuncted
9331
2470
  @return
9332
2471
    The transformed condition
9333
2472
*/
9334
 
 
9335
 
static COND* substitute_for_best_equal_field(COND *cond,
9336
 
                                             COND_EQUAL *cond_equal,
9337
 
                                             void *table_join_idx)
 
2473
COND* substitute_for_best_equal_field(COND *cond, COND_EQUAL *cond_equal, void *table_join_idx)
9338
2474
{
9339
2475
  Item_equal *item_equal;
9340
2476
 
9349
2485
      cond_equal= &((Item_cond_and *) cond)->cond_equal;
9350
2486
      cond_list->disjoin((List<Item> *) &cond_equal->current_level);
9351
2487
 
9352
 
      List_iterator_fast<Item_equal> it(cond_equal->current_level);      
 
2488
      List_iterator_fast<Item_equal> it(cond_equal->current_level);
9353
2489
      while ((item_equal= it++))
9354
2490
      {
9355
2491
        item_equal->sort(&compare_fields_by_table_order, table_join_idx);
9356
2492
      }
9357
2493
    }
9358
 
    
 
2494
 
9359
2495
    List_iterator<Item> li(*cond_list);
9360
2496
    Item *item;
9361
2497
    while ((item= li++))
9388
2524
      cond= new Item_int((int32_t)cond->val_bool());
9389
2525
 
9390
2526
  }
9391
 
  else if (cond->type() == Item::FUNC_ITEM && 
 
2527
  else if (cond->type() == Item::FUNC_ITEM &&
9392
2528
           ((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)
9393
2529
  {
9394
2530
    item_equal= (Item_equal *) cond;
9402
2538
  return cond;
9403
2539
}
9404
2540
 
9405
 
 
9406
2541
/**
9407
2542
  Check appearance of new constant items in multiple equalities
9408
2543
  of a condition after reading a constant table.
9415
2550
  @param cond       condition whose multiple equalities are to be checked
9416
2551
  @param table      constant table that has been read
9417
2552
*/
9418
 
 
9419
 
static void update_const_equal_items(COND *cond, JOIN_TAB *tab)
 
2553
static void update_const_equal_items(COND *cond, JoinTable *tab)
9420
2554
{
9421
2555
  if (!(cond->used_tables() & tab->table->map))
9422
2556
    return;
9423
2557
 
9424
2558
  if (cond->type() == Item::COND_ITEM)
9425
2559
  {
9426
 
    List<Item> *cond_list= ((Item_cond*) cond)->argument_list(); 
 
2560
    List<Item> *cond_list= ((Item_cond*) cond)->argument_list();
9427
2561
    List_iterator_fast<Item> li(*cond_list);
9428
2562
    Item *item;
9429
2563
    while ((item= li++))
9430
2564
      update_const_equal_items(item, tab);
9431
2565
  }
9432
 
  else if (cond->type() == Item::FUNC_ITEM && 
 
2566
  else if (cond->type() == Item::FUNC_ITEM &&
9433
2567
           ((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)
9434
2568
  {
9435
2569
    Item_equal *item_equal= (Item_equal *) cond;
9443
2577
      while ((item_field= it++))
9444
2578
      {
9445
2579
        Field *field= item_field->field;
9446
 
        JOIN_TAB *stat= field->table->reginfo.join_tab;
 
2580
        JoinTable *stat= field->table->reginfo.join_tab;
9447
2581
        key_map possible_keys= field->key_start;
9448
 
        possible_keys.intersect(field->table->keys_in_use_for_query);
9449
 
        stat[0].const_keys.merge(possible_keys);
 
2582
        possible_keys&= field->table->keys_in_use_for_query;
 
2583
        stat[0].const_keys|= possible_keys;
9450
2584
 
9451
2585
        /*
9452
 
          For each field in the multiple equality (for which we know that it 
9453
 
          is a constant) we have to find its corresponding key part, and set 
 
2586
          For each field in the multiple equality (for which we know that it
 
2587
          is a constant) we have to find its corresponding key part, and set
9454
2588
          that key part in const_key_parts.
9455
 
        */  
9456
 
        if (!possible_keys.is_clear_all())
 
2589
        */
 
2590
        if (possible_keys.any())
9457
2591
        {
9458
 
          TABLE *tab= field->table;
9459
 
          KEYUSE *use;
9460
 
          for (use= stat->keyuse; use && use->table == tab; use++)
9461
 
            if (possible_keys.is_set(use->key) && 
9462
 
                tab->key_info[use->key].key_part[use->keypart].field ==
 
2592
          Table *field_tab= field->table;
 
2593
          optimizer::KeyUse *use;
 
2594
          for (use= stat->keyuse; use && use->getTable() == field_tab; use++)
 
2595
            if (possible_keys.test(use->getKey()) &&
 
2596
                field_tab->key_info[use->getKey()].key_part[use->getKeypart()].field ==
9463
2597
                field)
9464
 
              tab->const_key_parts[use->key]|= use->keypart_map;
 
2598
              field_tab->const_key_parts[use->getKey()]|= use->getKeypartMap();
9465
2599
        }
9466
2600
      }
9467
2601
    }
9468
2602
  }
9469
2603
}
9470
2604
 
9471
 
 
9472
2605
/*
9473
2606
  change field = field to field = const for each found field = const in the
9474
2607
  and_level
9475
2608
*/
9476
 
 
9477
 
static void
9478
 
change_cond_ref_to_const(THD *thd, I_List<COND_CMP> *save_list,
9479
 
                         Item *and_father, Item *cond,
9480
 
                         Item *field, Item *value)
 
2609
static void change_cond_ref_to_const(Session *session,
 
2610
                                     vector<COND_CMP>& save_list,
 
2611
                                     Item *and_father,
 
2612
                                     Item *cond,
 
2613
                                     Item *field,
 
2614
                                     Item *value)
9481
2615
{
9482
2616
  if (cond->type() == Item::COND_ITEM)
9483
2617
  {
9484
 
    bool and_level= ((Item_cond*) cond)->functype() ==
9485
 
      Item_func::COND_AND_FUNC;
 
2618
    bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;
9486
2619
    List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
9487
2620
    Item *item;
9488
2621
    while ((item=li++))
9489
 
      change_cond_ref_to_const(thd, save_list,and_level ? cond : item, item,
9490
 
                               field, value);
 
2622
      change_cond_ref_to_const(session, save_list, and_level ? cond : item, item, field, value);
9491
2623
    return;
9492
2624
  }
9493
2625
  if (cond->eq_cmp_result() == Item::COND_OK)
9507
2639
  {
9508
2640
    Item *tmp=value->clone_item();
9509
2641
    tmp->collation.set(right_item->collation);
9510
 
    
 
2642
 
9511
2643
    if (tmp)
9512
2644
    {
9513
 
      thd->change_item_tree(args + 1, tmp);
 
2645
      session->change_item_tree(args + 1, tmp);
9514
2646
      func->update_used_tables();
9515
 
      if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)
9516
 
          && and_father != cond && !left_item->const_item())
 
2647
      if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&
 
2648
                and_father != cond && 
 
2649
          ! left_item->const_item())
9517
2650
      {
9518
 
        cond->marker=1;
9519
 
        COND_CMP *tmp2;
9520
 
        if ((tmp2=new COND_CMP(and_father,func)))
9521
 
          save_list->push_back(tmp2);
 
2651
        cond->marker=1;
 
2652
        save_list.push_back( COND_CMP(and_father, func) );
9522
2653
      }
9523
2654
      func->set_cmp_func();
9524
2655
    }
9531
2662
  {
9532
2663
    Item *tmp= value->clone_item();
9533
2664
    tmp->collation.set(left_item->collation);
9534
 
    
 
2665
 
9535
2666
    if (tmp)
9536
2667
    {
9537
 
      thd->change_item_tree(args, tmp);
 
2668
      session->change_item_tree(args, tmp);
9538
2669
      value= tmp;
9539
2670
      func->update_used_tables();
9540
 
      if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)
9541
 
          && and_father != cond && !right_item->const_item())
 
2671
      if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&
 
2672
          and_father != cond && 
 
2673
          ! right_item->const_item())
9542
2674
      {
9543
2675
        args[0]= args[1];                       // For easy check
9544
 
        thd->change_item_tree(args + 1, value);
9545
 
        cond->marker=1;
9546
 
        COND_CMP *tmp2;
9547
 
        if ((tmp2=new COND_CMP(and_father,func)))
9548
 
          save_list->push_back(tmp2);
 
2676
        session->change_item_tree(args + 1, value);
 
2677
        cond->marker=1;
 
2678
        save_list.push_back( COND_CMP(and_father, func) );
9549
2679
      }
9550
2680
      func->set_cmp_func();
9551
2681
    }
9560
2690
  @return
9561
2691
    new conditions
9562
2692
*/
9563
 
 
9564
 
static Item *remove_additional_cond(Item* conds)
 
2693
Item *remove_additional_cond(Item* conds)
9565
2694
{
9566
2695
  if (conds->name == in_additional_cond)
9567
2696
    return 0;
9584
2713
  return conds;
9585
2714
}
9586
2715
 
9587
 
static void
9588
 
propagate_cond_constants(THD *thd, I_List<COND_CMP> *save_list,
9589
 
                         COND *and_father, COND *cond)
 
2716
static void propagate_cond_constants(Session *session, 
 
2717
                                     vector<COND_CMP>& save_list, 
 
2718
                                     COND *and_father, 
 
2719
                                     COND *cond)
9590
2720
{
9591
2721
  if (cond->type() == Item::COND_ITEM)
9592
2722
  {
9593
 
    bool and_level= ((Item_cond*) cond)->functype() ==
9594
 
      Item_func::COND_AND_FUNC;
 
2723
    bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;
9595
2724
    List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
9596
2725
    Item *item;
9597
 
    I_List<COND_CMP> save;
 
2726
    vector<COND_CMP> save;
9598
2727
    while ((item=li++))
9599
2728
    {
9600
 
      propagate_cond_constants(thd, &save,and_level ? cond : item, item);
 
2729
      propagate_cond_constants(session, save, and_level ? cond : item, item);
9601
2730
    }
9602
2731
    if (and_level)
9603
 
    {                                           // Handle other found items
9604
 
      I_List_iterator<COND_CMP> cond_itr(save);
9605
 
      COND_CMP *cond_cmp;
9606
 
      while ((cond_cmp=cond_itr++))
 
2732
    {
 
2733
      // Handle other found items
 
2734
      for (vector<COND_CMP>::iterator iter= save.begin(); iter != save.end(); ++iter)
9607
2735
      {
9608
 
        Item **args= cond_cmp->cmp_func->arguments();
 
2736
        Item **args= iter->cmp_func->arguments();
9609
2737
        if (!args[0]->const_item())
9610
 
          change_cond_ref_to_const(thd, &save,cond_cmp->and_level,
9611
 
                                   cond_cmp->and_level, args[0], args[1]);
 
2738
        {
 
2739
          change_cond_ref_to_const( session, save, iter->and_level,
 
2740
                                    iter->and_level, args[0], args[1] );
 
2741
        }
9612
2742
      }
9613
2743
    }
9614
2744
  }
9615
2745
  else if (and_father != cond && !cond->marker)         // In a AND group
9616
2746
  {
9617
2747
    if (cond->type() == Item::FUNC_ITEM &&
9618
 
        (((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||
9619
 
         ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))
 
2748
        (((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||
 
2749
        ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))
9620
2750
    {
9621
2751
      Item_func_eq *func=(Item_func_eq*) cond;
9622
2752
      Item **args= func->arguments();
9625
2755
      if (!(left_const && right_const) &&
9626
2756
          args[0]->result_type() == args[1]->result_type())
9627
2757
      {
9628
 
        if (right_const)
9629
 
        {
9630
 
          resolve_const_item(thd, &args[1], args[0]);
9631
 
          func->update_used_tables();
9632
 
          change_cond_ref_to_const(thd, save_list, and_father, and_father,
9633
 
                                   args[0], args[1]);
9634
 
        }
9635
 
        else if (left_const)
9636
 
        {
9637
 
          resolve_const_item(thd, &args[0], args[1]);
9638
 
          func->update_used_tables();
9639
 
          change_cond_ref_to_const(thd, save_list, and_father, and_father,
9640
 
                                   args[1], args[0]);
9641
 
        }
9642
 
      }
9643
 
    }
9644
 
  }
9645
 
}
9646
 
 
9647
 
 
9648
 
/**
9649
 
  Simplify joins replacing outer joins by inner joins whenever it's
9650
 
  possible.
9651
 
 
9652
 
    The function, during a retrieval of join_list,  eliminates those
9653
 
    outer joins that can be converted into inner join, possibly nested.
9654
 
    It also moves the on expressions for the converted outer joins
9655
 
    and from inner joins to conds.
9656
 
    The function also calculates some attributes for nested joins:
9657
 
    - used_tables    
9658
 
    - not_null_tables
9659
 
    - dep_tables.
9660
 
    - on_expr_dep_tables
9661
 
    The first two attributes are used to test whether an outer join can
9662
 
    be substituted for an inner join. The third attribute represents the
9663
 
    relation 'to be dependent on' for tables. If table t2 is dependent
9664
 
    on table t1, then in any evaluated execution plan table access to
9665
 
    table t2 must precede access to table t2. This relation is used also
9666
 
    to check whether the query contains  invalid cross-references.
9667
 
    The forth attribute is an auxiliary one and is used to calculate
9668
 
    dep_tables.
9669
 
    As the attribute dep_tables qualifies possibles orders of tables in the
9670
 
    execution plan, the dependencies required by the straight join
9671
 
    modifiers are reflected in this attribute as well.
9672
 
    The function also removes all braces that can be removed from the join
9673
 
    expression without changing its meaning.
9674
 
 
9675
 
  @note
9676
 
    An outer join can be replaced by an inner join if the where condition
9677
 
    or the on expression for an embedding nested join contains a conjunctive
9678
 
    predicate rejecting null values for some attribute of the inner tables.
9679
 
 
9680
 
    E.g. in the query:    
9681
 
    @code
9682
 
      SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a WHERE t2.b < 5
9683
 
    @endcode
9684
 
    the predicate t2.b < 5 rejects nulls.
9685
 
    The query is converted first to:
9686
 
    @code
9687
 
      SELECT * FROM t1 INNER JOIN t2 ON t2.a=t1.a WHERE t2.b < 5
9688
 
    @endcode
9689
 
    then to the equivalent form:
9690
 
    @code
9691
 
      SELECT * FROM t1, t2 ON t2.a=t1.a WHERE t2.b < 5 AND t2.a=t1.a
9692
 
    @endcode
9693
 
 
9694
 
 
9695
 
    Similarly the following query:
9696
 
    @code
9697
 
      SELECT * from t1 LEFT JOIN (t2, t3) ON t2.a=t1.a t3.b=t1.b
9698
 
        WHERE t2.c < 5  
9699
 
    @endcode
9700
 
    is converted to:
9701
 
    @code
9702
 
      SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a t3.b=t1.b 
9703
 
 
9704
 
    @endcode
9705
 
 
9706
 
    One conversion might trigger another:
9707
 
    @code
9708
 
      SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a
9709
 
                       LEFT JOIN t3 ON t3.b=t2.b
9710
 
        WHERE t3 IS NOT NULL =>
9711
 
      SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a, t3
9712
 
        WHERE t3 IS NOT NULL AND t3.b=t2.b => 
9713
 
      SELECT * FROM t1, t2, t3
9714
 
        WHERE t3 IS NOT NULL AND t3.b=t2.b AND t2.a=t1.a
9715
 
  @endcode
9716
 
 
9717
 
    The function removes all unnecessary braces from the expression
9718
 
    produced by the conversions.
9719
 
    E.g.
9720
 
    @code
9721
 
      SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b
9722
 
    @endcode
9723
 
    finally is converted to: 
9724
 
    @code
9725
 
      SELECT * FROM t1, t2, t3 WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b
9726
 
 
9727
 
    @endcode
9728
 
 
9729
 
 
9730
 
    It also will remove braces from the following queries:
9731
 
    @code
9732
 
      SELECT * from (t1 LEFT JOIN t2 ON t2.a=t1.a) LEFT JOIN t3 ON t3.b=t2.b
9733
 
      SELECT * from (t1, (t2,t3)) WHERE t1.a=t2.a AND t2.b=t3.b.
9734
 
    @endcode
9735
 
 
9736
 
    The benefit of this simplification procedure is that it might return 
9737
 
    a query for which the optimizer can evaluate execution plan with more
9738
 
    join orders. With a left join operation the optimizer does not
9739
 
    consider any plan where one of the inner tables is before some of outer
9740
 
    tables.
9741
 
 
9742
 
  IMPLEMENTATION
9743
 
    The function is implemented by a recursive procedure.  On the recursive
9744
 
    ascent all attributes are calculated, all outer joins that can be
9745
 
    converted are replaced and then all unnecessary braces are removed.
9746
 
    As join list contains join tables in the reverse order sequential
9747
 
    elimination of outer joins does not require extra recursive calls.
9748
 
 
9749
 
  SEMI-JOIN NOTES
9750
 
    Remove all semi-joins that have are within another semi-join (i.e. have
9751
 
    an "ancestor" semi-join nest)
9752
 
 
9753
 
  EXAMPLES
9754
 
    Here is an example of a join query with invalid cross references:
9755
 
    @code
9756
 
      SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t3.a LEFT JOIN t3 ON t3.b=t1.b 
9757
 
    @endcode
9758
 
 
9759
 
  @param join        reference to the query info
9760
 
  @param join_list   list representation of the join to be converted
9761
 
  @param conds       conditions to add on expressions for converted joins
9762
 
  @param top         true <=> conds is the where condition
9763
 
 
9764
 
  @return
9765
 
    - The new condition, if success
9766
 
    - 0, otherwise
9767
 
*/
9768
 
 
9769
 
static COND *
9770
 
simplify_joins(JOIN *join, List<TABLE_LIST> *join_list, COND *conds, bool top,
9771
 
               bool in_sj)
9772
 
{
9773
 
  TABLE_LIST *table;
9774
 
  NESTED_JOIN *nested_join;
9775
 
  TABLE_LIST *prev_table= 0;
9776
 
  List_iterator<TABLE_LIST> li(*join_list);
9777
 
 
9778
 
  /* 
9779
 
    Try to simplify join operations from join_list.
9780
 
    The most outer join operation is checked for conversion first. 
9781
 
  */
9782
 
  while ((table= li++))
9783
 
  {
9784
 
    table_map used_tables;
9785
 
    table_map not_null_tables= (table_map) 0;
9786
 
 
9787
 
    if ((nested_join= table->nested_join))
9788
 
    {
9789
 
      /* 
9790
 
         If the element of join_list is a nested join apply
9791
 
         the procedure to its nested join list first.
9792
 
      */
9793
 
      if (table->on_expr)
9794
 
      {
9795
 
        Item *expr= table->on_expr;
9796
 
        /* 
9797
 
           If an on expression E is attached to the table, 
9798
 
           check all null rejected predicates in this expression.
9799
 
           If such a predicate over an attribute belonging to
9800
 
           an inner table of an embedded outer join is found,
9801
 
           the outer join is converted to an inner join and
9802
 
           the corresponding on expression is added to E. 
9803
 
        */ 
9804
 
        expr= simplify_joins(join, &nested_join->join_list,
9805
 
                             expr, false, in_sj || table->sj_on_expr);
9806
 
 
9807
 
        if (!table->prep_on_expr || expr != table->on_expr)
9808
 
        {
9809
 
          assert(expr);
9810
 
 
9811
 
          table->on_expr= expr;
9812
 
          table->prep_on_expr= expr->copy_andor_structure(join->thd);
9813
 
        }
9814
 
      }
9815
 
      nested_join->used_tables= (table_map) 0;
9816
 
      nested_join->not_null_tables=(table_map) 0;
9817
 
      conds= simplify_joins(join, &nested_join->join_list, conds, top, 
9818
 
                            in_sj || table->sj_on_expr);
9819
 
      used_tables= nested_join->used_tables;
9820
 
      not_null_tables= nested_join->not_null_tables;  
9821
 
    }
9822
 
    else
9823
 
    {
9824
 
      if (!table->prep_on_expr)
9825
 
        table->prep_on_expr= table->on_expr;
9826
 
      used_tables= table->table->map;
9827
 
      if (conds)
9828
 
        not_null_tables= conds->not_null_tables();
9829
 
    }
9830
 
      
9831
 
    if (table->embedding)
9832
 
    {
9833
 
      table->embedding->nested_join->used_tables|= used_tables;
9834
 
      table->embedding->nested_join->not_null_tables|= not_null_tables;
9835
 
    }
9836
 
 
9837
 
    if (!table->outer_join || (used_tables & not_null_tables))
9838
 
    {
9839
 
      /* 
9840
 
        For some of the inner tables there are conjunctive predicates
9841
 
        that reject nulls => the outer join can be replaced by an inner join.
9842
 
      */
9843
 
      table->outer_join= 0;
9844
 
      if (table->on_expr)
9845
 
      {
9846
 
        /* Add ON expression to the WHERE or upper-level ON condition. */
9847
 
        if (conds)
9848
 
        {
9849
 
          conds= and_conds(conds, table->on_expr);
9850
 
          conds->top_level_item();
9851
 
          /* conds is always a new item as both cond and on_expr existed */
9852
 
          assert(!conds->fixed);
9853
 
          conds->fix_fields(join->thd, &conds);
9854
 
        }
9855
 
        else
9856
 
          conds= table->on_expr; 
9857
 
        table->prep_on_expr= table->on_expr= 0;
9858
 
      }
9859
 
    }
9860
 
    
9861
 
    if (!top)
9862
 
      continue;
9863
 
 
9864
 
    /* 
9865
 
      Only inner tables of non-convertible outer joins
9866
 
      remain with on_expr.
9867
 
    */ 
9868
 
    if (table->on_expr)
9869
 
    {
9870
 
      table->dep_tables|= table->on_expr->used_tables(); 
9871
 
      if (table->embedding)
9872
 
      {
9873
 
        table->dep_tables&= ~table->embedding->nested_join->used_tables;   
9874
 
        /*
9875
 
           Embedding table depends on tables used
9876
 
           in embedded on expressions. 
9877
 
        */
9878
 
        table->embedding->on_expr_dep_tables|= table->on_expr->used_tables();
9879
 
      }
9880
 
      else
9881
 
        table->dep_tables&= ~table->table->map;
9882
 
    }
9883
 
 
9884
 
    if (prev_table)
9885
 
    {
9886
 
      /* The order of tables is reverse: prev_table follows table */
9887
 
      if (prev_table->straight)
9888
 
        prev_table->dep_tables|= used_tables;
9889
 
      if (prev_table->on_expr)
9890
 
      {
9891
 
        prev_table->dep_tables|= table->on_expr_dep_tables;
9892
 
        table_map prev_used_tables= prev_table->nested_join ?
9893
 
                                    prev_table->nested_join->used_tables :
9894
 
                                    prev_table->table->map;
9895
 
        /* 
9896
 
          If on expression contains only references to inner tables
9897
 
          we still make the inner tables dependent on the outer tables.
9898
 
          It would be enough to set dependency only on one outer table
9899
 
          for them. Yet this is really a rare case.
9900
 
        */  
9901
 
        if (!(prev_table->on_expr->used_tables() & ~prev_used_tables))
9902
 
          prev_table->dep_tables|= used_tables;
9903
 
      }
9904
 
    }
9905
 
    prev_table= table;
9906
 
  }
9907
 
    
9908
 
  /* 
9909
 
    Flatten nested joins that can be flattened.
9910
 
    no ON expression and not a semi-join => can be flattened.
9911
 
  */
9912
 
  li.rewind();
9913
 
  while ((table= li++))
9914
 
  {
9915
 
    nested_join= table->nested_join;
9916
 
    if (table->sj_on_expr && !in_sj)
9917
 
    {
9918
 
       /*
9919
 
         If this is a semi-join that is not contained within another semi-join, 
9920
 
         leave it intact (otherwise it is flattened)
9921
 
       */
9922
 
      join->select_lex->sj_nests.push_back(table);
9923
 
    }
9924
 
    else if (nested_join && !table->on_expr)
9925
 
    {
9926
 
      TABLE_LIST *tbl;
9927
 
      List_iterator<TABLE_LIST> it(nested_join->join_list);
9928
 
      while ((tbl= it++))
9929
 
      {
9930
 
        tbl->embedding= table->embedding;
9931
 
        tbl->join_list= table->join_list;
9932
 
      }      
9933
 
      li.replace(nested_join->join_list);
9934
 
    }
9935
 
  }
9936
 
  return(conds); 
9937
 
}
9938
 
 
9939
 
 
9940
 
/**
9941
 
  Assign each nested join structure a bit in nested_join_map.
9942
 
 
9943
 
    Assign each nested join structure (except "confluent" ones - those that
9944
 
    embed only one element) a bit in nested_join_map.
9945
 
 
9946
 
  @param join          Join being processed
9947
 
  @param join_list     List of tables
9948
 
  @param first_unused  Number of first unused bit in nested_join_map before the
9949
 
                       call
9950
 
 
9951
 
  @note
9952
 
    This function is called after simplify_joins(), when there are no
9953
 
    redundant nested joins, #non_confluent_nested_joins <= #tables_in_join so
9954
 
    we will not run out of bits in nested_join_map.
9955
 
 
9956
 
  @return
9957
 
    First unused bit in nested_join_map after the call.
9958
 
*/
9959
 
 
9960
 
static uint build_bitmap_for_nested_joins(List<TABLE_LIST> *join_list, 
9961
 
                                          uint first_unused)
9962
 
{
9963
 
  List_iterator<TABLE_LIST> li(*join_list);
9964
 
  TABLE_LIST *table;
9965
 
  while ((table= li++))
9966
 
  {
9967
 
    NESTED_JOIN *nested_join;
9968
 
    if ((nested_join= table->nested_join))
9969
 
    {
9970
 
      /*
9971
 
        It is guaranteed by simplify_joins() function that a nested join
9972
 
        that has only one child is either
9973
 
         - a single-table view (the child is the underlying table), or 
9974
 
         - a single-table semi-join nest
9975
 
 
9976
 
        We don't assign bits to such sj-nests because 
9977
 
        1. it is redundant (a "sequence" of one table cannot be interleaved 
9978
 
            with anything)
9979
 
        2. we could run out bits in nested_join_map otherwise.
9980
 
      */
9981
 
      if (nested_join->join_list.elements != 1)
9982
 
      {
9983
 
        /* Don't assign bits to sj-nests */
9984
 
        if (table->on_expr)
9985
 
          nested_join->nj_map= (nested_join_map) 1 << first_unused++;
9986
 
        first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,
9987
 
                                                    first_unused);
9988
 
      }
9989
 
    }
9990
 
  }
9991
 
  return(first_unused);
9992
 
}
9993
 
 
9994
 
 
9995
 
/**
9996
 
  Set NESTED_JOIN::counter=0 in all nested joins in passed list.
9997
 
 
9998
 
    Recursively set NESTED_JOIN::counter=0 for all nested joins contained in
9999
 
    the passed join_list.
10000
 
 
10001
 
  @param join_list  List of nested joins to process. It may also contain base
10002
 
                    tables which will be ignored.
10003
 
*/
10004
 
 
10005
 
static void reset_nj_counters(List<TABLE_LIST> *join_list)
10006
 
{
10007
 
  List_iterator<TABLE_LIST> li(*join_list);
10008
 
  TABLE_LIST *table;
10009
 
  while ((table= li++))
10010
 
  {
10011
 
    NESTED_JOIN *nested_join;
10012
 
    if ((nested_join= table->nested_join))
10013
 
    {
10014
 
      nested_join->counter_= 0;
10015
 
      reset_nj_counters(&nested_join->join_list);
10016
 
    }
10017
 
  }
10018
 
  return;
10019
 
}
10020
 
 
 
2758
        if (right_const)
 
2759
        {
 
2760
                resolve_const_item(session, &args[1], args[0]);
 
2761
          func->update_used_tables();
 
2762
                change_cond_ref_to_const(session, save_list, and_father, and_father,
 
2763
                                        args[0], args[1]);
 
2764
        }
 
2765
        else if (left_const)
 
2766
        {
 
2767
                resolve_const_item(session, &args[0], args[1]);
 
2768
          func->update_used_tables();
 
2769
                change_cond_ref_to_const(session, save_list, and_father, and_father,
 
2770
                                        args[1], args[0]);
 
2771
        }
 
2772
      }
 
2773
    }
 
2774
  }
 
2775
}
10021
2776
 
10022
2777
/**
10023
2778
  Check interleaving with an inner tables of an outer join for
10024
2779
  extension table.
10025
2780
 
10026
 
    Check if table next_tab can be added to current partial join order, and 
 
2781
    Check if table next_tab can be added to current partial join order, and
10027
2782
    if yes, record that it has been added.
10028
2783
 
10029
2784
    The function assumes that both current partial join order and its
10030
2785
    extension with next_tab are valid wrt table dependencies.
10031
2786
 
10032
2787
  @verbatim
10033
 
     IMPLEMENTATION 
10034
 
       LIMITATIONS ON JOIN ORDER
 
2788
     IMPLEMENTATION
 
2789
       LIMITATIONS ON JOIN order_st
10035
2790
         The nested [outer] joins executioner algorithm imposes these limitations
10036
2791
         on join order:
10037
 
         1. "Outer tables first" -  any "outer" table must be before any 
 
2792
         1. "Outer tables first" -  any "outer" table must be before any
10038
2793
             corresponding "inner" table.
10039
2794
         2. "No interleaving" - tables inside a nested join must form a continuous
10040
 
            sequence in join order (i.e. the sequence must not be interrupted by 
 
2795
            sequence in join order (i.e. the sequence must not be interrupted by
10041
2796
            tables that are outside of this nested join).
10042
2797
 
10043
2798
         #1 is checked elsewhere, this function checks #2 provided that #1 has
10044
2799
         been already checked.
10045
2800
 
10046
2801
       WHY NEED NON-INTERLEAVING
10047
 
         Consider an example: 
 
2802
         Consider an example:
10048
2803
 
10049
2804
           select * from t0 join t1 left join (t2 join t3) on cond1
10050
2805
 
10068
2823
         The limitations on join order can be rephrased as follows: for valid
10069
2824
         join order one must be able to:
10070
2825
           1. write down the used tables in the join order on one line.
10071
 
           2. for each nested join, put one '(' and one ')' on the said line        
 
2826
           2. for each nested join, put one '(' and one ')' on the said line
10072
2827
           3. write "LEFT JOIN" and "ON (...)" where appropriate
10073
2828
           4. get a query equivalent to the query we're trying to execute.
10074
2829
 
10075
2830
         Calls to check_interleaving_with_nj() are equivalent to writing the
10076
 
         above described line from left to right. 
10077
 
         A single check_interleaving_with_nj(A,B) call is equivalent to writing 
 
2831
         above described line from left to right.
 
2832
         A single check_interleaving_with_nj(A,B) call is equivalent to writing
10078
2833
         table B and appropriate brackets on condition that table A and
10079
2834
         appropriate brackets is the last what was written. Graphically the
10080
2835
         transition is as follows:
10087
2842
                                                      position.
10088
2843
 
10089
2844
         Notes about the position:
10090
 
           The caller guarantees that there is no more then one X-bracket by 
10091
 
           checking "!(remaining_tables & s->dependent)" before calling this 
 
2845
           The caller guarantees that there is no more then one X-bracket by
 
2846
           checking "!(remaining_tables & s->dependent)" before calling this
10092
2847
           function. X-bracket may have a pair in Y-bracket.
10093
2848
 
10094
2849
         When "writing" we store/update this auxilary info about the current
10095
2850
         position:
10096
2851
          1. join->cur_embedding_map - bitmap of pairs of brackets (aka nested
10097
2852
             joins) we've opened but didn't close.
10098
 
          2. {each NESTED_JOIN structure not simplified away}->counter - number
 
2853
          2. {each nested_join_st structure not simplified away}->counter - number
10099
2854
             of this nested join's children that have already been added to to
10100
2855
             the partial join order.
10101
2856
  @endverbatim
10111
2866
  @retval
10112
2867
    true   Requested join order extension not allowed.
10113
2868
*/
10114
 
 
10115
 
static bool check_interleaving_with_nj(JOIN_TAB *last_tab, JOIN_TAB *next_tab)
 
2869
bool check_interleaving_with_nj(JoinTable *last_tab, JoinTable *next_tab)
10116
2870
{
10117
 
  TABLE_LIST *next_emb= next_tab->table->pos_in_table_list->embedding;
 
2871
  TableList *next_emb= next_tab->table->pos_in_table_list->embedding;
10118
2872
  JOIN *join= last_tab->join;
10119
2873
 
10120
 
  if (join->cur_embedding_map & ~next_tab->embedding_map)
 
2874
  if ((join->cur_embedding_map & ~next_tab->embedding_map).any())
10121
2875
  {
10122
 
    /* 
 
2876
    /*
10123
2877
      next_tab is outside of the "pair of brackets" we're currently in.
10124
2878
      Cannot add it.
10125
2879
    */
10126
2880
    return true;
10127
2881
  }
10128
 
   
 
2882
 
10129
2883
  /*
10130
2884
    Do update counters for "pairs of brackets" that we've left (marked as
10131
2885
    X,Y,Z in the above picture)
10135
2889
    next_emb->nested_join->counter_++;
10136
2890
    if (next_emb->nested_join->counter_ == 1)
10137
2891
    {
10138
 
      /* 
 
2892
      /*
10139
2893
        next_emb is the first table inside a nested join we've "entered". In
10140
2894
        the picture above, we're looking at the 'X' bracket. Don't exit yet as
10141
2895
        X bracket might have Y pair bracket.
10142
2896
      */
10143
2897
      join->cur_embedding_map |= next_emb->nested_join->nj_map;
10144
2898
    }
10145
 
    
 
2899
 
10146
2900
    if (next_emb->nested_join->join_list.elements !=
10147
2901
        next_emb->nested_join->counter_)
10148
2902
      break;
10156
2910
  return false;
10157
2911
}
10158
2912
 
10159
 
 
10160
 
/**
10161
 
  Nested joins perspective: Remove the last table from the join order.
10162
 
 
10163
 
    Remove the last table from the partial join order and update the nested
10164
 
    joins counters and join->cur_embedding_map. It is ok to call this 
10165
 
    function for the first table in join order (for which 
10166
 
    check_interleaving_with_nj has not been called)
10167
 
 
10168
 
  @param last  join table to remove, it is assumed to be the last in current
10169
 
               partial join order.
10170
 
*/
10171
 
 
10172
 
static void restore_prev_nj_state(JOIN_TAB *last)
10173
 
{
10174
 
  TABLE_LIST *last_emb= last->table->pos_in_table_list->embedding;
10175
 
  JOIN *join= last->join;
10176
 
  while (last_emb)
10177
 
  {
10178
 
    if (last_emb->on_expr)
10179
 
    {
10180
 
      if (!(--last_emb->nested_join->counter_))
10181
 
        join->cur_embedding_map&= ~last_emb->nested_join->nj_map;
10182
 
      else if (last_emb->nested_join->join_list.elements-1 ==
10183
 
               last_emb->nested_join->counter_) 
10184
 
        join->cur_embedding_map|= last_emb->nested_join->nj_map;
10185
 
      else
10186
 
        break;
10187
 
    }
10188
 
    last_emb= last_emb->embedding;
10189
 
  }
10190
 
}
10191
 
 
10192
 
 
10193
 
 
10194
 
static 
10195
 
void advance_sj_state(const table_map remaining_tables, const JOIN_TAB *tab)
10196
 
{
10197
 
  TABLE_LIST *emb_sj_nest;
10198
 
  if ((emb_sj_nest= tab->emb_sj_nest))
10199
 
  {
10200
 
    tab->join->cur_emb_sj_nests |= emb_sj_nest->sj_inner_tables;
10201
 
    /* Remove the sj_nest if all of its SJ-inner tables are in cur_table_map */
10202
 
    if (!(remaining_tables & emb_sj_nest->sj_inner_tables))
10203
 
      tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;
10204
 
  }
10205
 
}
10206
 
 
10207
 
 
10208
 
/*
10209
 
  we assume remaining_tables doesnt contain @tab.
10210
 
*/
10211
 
 
10212
 
static void restore_prev_sj_state(const table_map remaining_tables, 
10213
 
                                  const JOIN_TAB *tab)
10214
 
{
10215
 
  TABLE_LIST *emb_sj_nest;
10216
 
  if ((emb_sj_nest= tab->emb_sj_nest))
10217
 
  {
10218
 
    /* If we're removing the last SJ-inner table, remove the sj-nest */
10219
 
    if ((remaining_tables & emb_sj_nest->sj_inner_tables) == 
10220
 
        (emb_sj_nest->sj_inner_tables & ~tab->table->map))
10221
 
    {
10222
 
      tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;
10223
 
    }
10224
 
  }
10225
 
}
10226
 
 
10227
 
 
10228
 
static COND *
10229
 
optimize_cond(JOIN *join, COND *conds, List<TABLE_LIST> *join_list,
10230
 
              Item::cond_result *cond_value)
10231
 
{
10232
 
  THD *thd= join->thd;
 
2913
COND *optimize_cond(JOIN *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value)
 
2914
{
 
2915
  Session *session= join->session;
10233
2916
 
10234
2917
  if (!conds)
10235
2918
    *cond_value= Item::COND_TRUE;
10236
2919
  else
10237
2920
  {
10238
 
    /* 
 
2921
    /*
10239
2922
      Build all multiple equality predicates and eliminate equality
10240
2923
      predicates that can be inferred from these multiple equalities.
10241
2924
      For each reference of a field included into a multiple equality
10242
2925
      that occurs in a function set a pointer to the multiple equality
10243
2926
      predicate. Substitute a constant instead of this field if the
10244
2927
      multiple equality contains a constant.
10245
 
    */ 
10246
 
    conds= build_equal_items(join->thd, conds, NULL, join_list,
 
2928
    */
 
2929
    conds= build_equal_items(join->session, conds, NULL, join_list,
10247
2930
                             &join->cond_equal);
10248
2931
 
10249
2932
    /* change field = field to field = const for each found field = const */
10250
 
    propagate_cond_constants(thd, (I_List<COND_CMP> *) 0, conds, conds);
 
2933
    vector<COND_CMP> temp;
 
2934
    propagate_cond_constants(session, temp, conds, conds);
10251
2935
    /*
10252
2936
      Remove all instances of item == item
10253
2937
      Remove all and-levels where CONST item != CONST item
10254
2938
    */
10255
 
    conds= remove_eq_conds(thd, conds, cond_value) ;
 
2939
    conds= remove_eq_conds(session, conds, cond_value) ;
10256
2940
  }
10257
2941
  return(conds);
10258
2942
}
10259
2943
 
10260
 
 
10261
2944
/**
10262
2945
  Remove const and eq items.
10263
2946
 
10268
2951
    - COND_TRUE   : always true ( 1 = 1 )
10269
2952
    - COND_FALSE  : always false        ( 1 = 2 )
10270
2953
*/
10271
 
 
10272
 
COND *
10273
 
remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)
 
2954
COND *remove_eq_conds(Session *session, COND *cond, Item::cond_result *cond_value)
10274
2955
{
10275
2956
  if (cond->type() == Item::COND_ITEM)
10276
2957
  {
10277
 
    bool and_level= ((Item_cond*) cond)->functype()
10278
 
      == Item_func::COND_AND_FUNC;
 
2958
    bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);
 
2959
 
10279
2960
    List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
10280
2961
    Item::cond_result tmp_cond_value;
10281
 
    bool should_fix_fields=0;
 
2962
    bool should_fix_fields= false;
10282
2963
 
10283
 
    *cond_value=Item::COND_UNDEF;
 
2964
    *cond_value= Item::COND_UNDEF;
10284
2965
    Item *item;
10285
 
    while ((item=li++))
 
2966
    while ((item= li++))
10286
2967
    {
10287
 
      Item *new_item=remove_eq_conds(thd, item, &tmp_cond_value);
10288
 
      if (!new_item)
10289
 
        li.remove();
 
2968
      Item *new_item= remove_eq_conds(session, item, &tmp_cond_value);
 
2969
      if (! new_item)
 
2970
              li.remove();
10290
2971
      else if (item != new_item)
10291
2972
      {
10292
 
        VOID(li.replace(new_item));
10293
 
        should_fix_fields=1;
 
2973
        li.replace(new_item);
 
2974
        should_fix_fields= true;
10294
2975
      }
10295
2976
      if (*cond_value == Item::COND_UNDEF)
10296
 
        *cond_value=tmp_cond_value;
10297
 
      switch (tmp_cond_value) {
10298
 
      case Item::COND_OK:                       // Not true or false
10299
 
        if (and_level || *cond_value == Item::COND_FALSE)
10300
 
          *cond_value=tmp_cond_value;
10301
 
        break;
10302
 
      case Item::COND_FALSE:
10303
 
        if (and_level)
10304
 
        {
10305
 
          *cond_value=tmp_cond_value;
10306
 
          return (COND*) 0;                     // Always false
10307
 
        }
10308
 
        break;
10309
 
      case Item::COND_TRUE:
10310
 
        if (!and_level)
10311
 
        {
10312
 
          *cond_value= tmp_cond_value;
10313
 
          return (COND*) 0;                     // Always true
10314
 
        }
10315
 
        break;
10316
 
      case Item::COND_UNDEF:                    // Impossible
10317
 
        break; /* purecov: deadcode */
 
2977
              *cond_value= tmp_cond_value;
 
2978
 
 
2979
      switch (tmp_cond_value) 
 
2980
      {
 
2981
        case Item::COND_OK:                     /* Not true or false */
 
2982
          if (and_level || (*cond_value == Item::COND_FALSE))
 
2983
            *cond_value= tmp_cond_value;
 
2984
          break;
 
2985
        case Item::COND_FALSE:
 
2986
          if (and_level)
 
2987
          {
 
2988
            *cond_value= tmp_cond_value;
 
2989
            return (COND *) NULL;                       /* Always false */
 
2990
          }
 
2991
          break;
 
2992
        case Item::COND_TRUE:
 
2993
          if (! and_level)
 
2994
          {
 
2995
            *cond_value= tmp_cond_value;
 
2996
            return (COND *) NULL;                       /* Always true */
 
2997
          }
 
2998
          break;
 
2999
        case Item::COND_UNDEF:                  /* Impossible */
 
3000
          break;
10318
3001
      }
10319
3002
    }
 
3003
 
10320
3004
    if (should_fix_fields)
10321
3005
      cond->update_used_tables();
10322
3006
 
10323
 
    if (!((Item_cond*) cond)->argument_list()->elements ||
10324
 
        *cond_value != Item::COND_OK)
10325
 
      return (COND*) 0;
 
3007
    if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)
 
3008
      return (COND*) NULL;
 
3009
 
10326
3010
    if (((Item_cond*) cond)->argument_list()->elements == 1)
10327
 
    {                                           // Remove list
 
3011
    {                                           
 
3012
      /* Argument list contains only one element, so reduce it so a single item, then remove list */
10328
3013
      item= ((Item_cond*) cond)->argument_list()->head();
10329
3014
      ((Item_cond*) cond)->argument_list()->empty();
10330
3015
      return item;
10331
3016
    }
10332
3017
  }
10333
 
  else if (cond->type() == Item::FUNC_ITEM &&
10334
 
           ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)
 
3018
  else if (cond->type() == Item::FUNC_ITEM && ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)
10335
3019
  {
10336
3020
    /*
10337
3021
      Handles this special case for some ODBC applications:
10343
3027
      SELECT * from table_name where auto_increment_column = LAST_INSERT_ID
10344
3028
    */
10345
3029
 
10346
 
    Item_func_isnull *func=(Item_func_isnull*) cond;
 
3030
    Item_func_isnull *func= (Item_func_isnull*) cond;
10347
3031
    Item **args= func->arguments();
10348
3032
    if (args[0]->type() == Item::FIELD_ITEM)
10349
3033
    {
10350
 
      Field *field=((Item_field*) args[0])->field;
10351
 
      if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&
10352
 
          (thd->options & OPTION_AUTO_IS_NULL) &&
10353
 
          (thd->first_successful_insert_id_in_prev_stmt > 0 &&
10354
 
           thd->substitute_null_with_insert_id))
 
3034
      Field *field= ((Item_field*) args[0])->field;
 
3035
      if (field->flags & AUTO_INCREMENT_FLAG 
 
3036
          && ! field->table->maybe_null 
 
3037
          && session->options & OPTION_AUTO_IS_NULL
 
3038
          && (
 
3039
            session->first_successful_insert_id_in_prev_stmt > 0 
 
3040
            && session->substitute_null_with_insert_id
 
3041
            )
 
3042
          )
10355
3043
      {
10356
 
        COND *new_cond;
10357
 
        if ((new_cond= new Item_func_eq(args[0],
10358
 
                                        new Item_int("last_insert_id()",
10359
 
                                                     thd->read_first_successful_insert_id_in_prev_stmt(),
10360
 
                                                     MY_INT64_NUM_DECIMAL_DIGITS))))
10361
 
        {
10362
 
          cond=new_cond;
 
3044
        COND *new_cond;
 
3045
        if ((new_cond= new Item_func_eq(args[0], new Item_int("last_insert_id()",
 
3046
                                                          session->read_first_successful_insert_id_in_prev_stmt(),
 
3047
                                                          MY_INT64_NUM_DECIMAL_DIGITS))))
 
3048
        {
 
3049
          cond= new_cond;
10363
3050
          /*
10364
3051
            Item_func_eq can't be fixed after creation so we do not check
10365
3052
            cond->fixed, also it do not need tables so we use 0 as second
10366
3053
            argument.
10367
3054
          */
10368
 
          cond->fix_fields(thd, &cond);
10369
 
        }
 
3055
          cond->fix_fields(session, &cond);
 
3056
        }
10370
3057
        /*
10371
3058
          IS NULL should be mapped to LAST_INSERT_ID only for first row, so
10372
3059
          clear for next row
10373
3060
        */
10374
 
        thd->substitute_null_with_insert_id= false;
 
3061
        session->substitute_null_with_insert_id= false;
10375
3062
      }
 
3063
#ifdef NOTDEFINED
10376
3064
      /* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */
10377
 
      else if (((field->type() == DRIZZLE_TYPE_NEWDATE) ||
10378
 
                (field->type() == DRIZZLE_TYPE_DATETIME)) &&
10379
 
                (field->flags & NOT_NULL_FLAG) &&
10380
 
               !field->table->maybe_null)
 
3065
      else if (
 
3066
          ((field->type() == DRIZZLE_TYPE_DATE) || (field->type() == DRIZZLE_TYPE_DATETIME)) 
 
3067
          && (field->flags & NOT_NULL_FLAG) 
 
3068
          && ! field->table->maybe_null)
10381
3069
      {
10382
 
        COND *new_cond;
10383
 
        if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))
10384
 
        {
10385
 
          cond=new_cond;
 
3070
        COND *new_cond;
 
3071
        if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))
 
3072
        {
 
3073
          cond= new_cond;
10386
3074
          /*
10387
3075
            Item_func_eq can't be fixed after creation so we do not check
10388
3076
            cond->fixed, also it do not need tables so we use 0 as second
10389
3077
            argument.
10390
3078
          */
10391
 
          cond->fix_fields(thd, &cond);
10392
 
        }
 
3079
          cond->fix_fields(session, &cond);
 
3080
        }
10393
3081
      }
 
3082
#endif /* NOTDEFINED */
10394
3083
    }
10395
3084
    if (cond->const_item())
10396
3085
    {
10397
3086
      *cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;
10398
 
      return (COND*) 0;
 
3087
      return (COND *) NULL;
10399
3088
    }
10400
3089
  }
10401
3090
  else if (cond->const_item() && !cond->is_expensive())
10411
3100
  */
10412
3101
  {
10413
3102
    *cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;
10414
 
    return (COND*) 0;
 
3103
    return (COND *) NULL;
10415
3104
  }
10416
3105
  else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)
10417
 
  {                                             // boolan compare function
 
3106
  {                                             
 
3107
    /* boolan compare function */
10418
3108
    Item *left_item=    ((Item_func*) cond)->arguments()[0];
10419
3109
    Item *right_item= ((Item_func*) cond)->arguments()[1];
10420
3110
    if (left_item->eq(right_item,1))
10421
3111
    {
10422
 
      if (!left_item->maybe_null ||
10423
 
          ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)
10424
 
        return (COND*) 0;                       // Compare of identical items
 
3112
      if (!left_item->maybe_null || ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)
 
3113
              return (COND*) NULL;                      /* Comparison of identical items */
10425
3114
    }
10426
3115
  }
10427
 
  *cond_value=Item::COND_OK;
10428
 
  return cond;                                  // Point at next and level
 
3116
  *cond_value= Item::COND_OK;
 
3117
  return cond;                                  /* Point at next and return into recursion */
10429
3118
}
10430
3119
 
10431
 
/* 
 
3120
/*
10432
3121
  Check if equality can be used in removing components of GROUP BY/DISTINCT
10433
 
  
 
3122
 
10434
3123
  SYNOPSIS
10435
3124
    test_if_equality_guarantees_uniqueness()
10436
3125
      l          the left comparison argument (a field if any)
10437
3126
      r          the right comparison argument (a const of any)
10438
 
  
10439
 
  DESCRIPTION    
10440
 
    Checks if an equality predicate can be used to take away 
10441
 
    DISTINCT/GROUP BY because it is known to be true for exactly one 
 
3127
 
 
3128
  DESCRIPTION
 
3129
    Checks if an equality predicate can be used to take away
 
3130
    DISTINCT/GROUP BY because it is known to be true for exactly one
10442
3131
    distinct value (e.g. <expr> == <const>).
10443
 
    Arguments must be of the same type because e.g. 
10444
 
    <string_field> = <int_const> may match more than 1 distinct value from 
10445
 
    the column. 
10446
 
    We must take into consideration and the optimization done for various 
 
3132
    Arguments must be of the same type because e.g.
 
3133
    <string_field> = <int_const> may match more than 1 distinct value from
 
3134
    the column.
 
3135
    We must take into consideration and the optimization done for various
10447
3136
    string constants when compared to dates etc (see Item_int_with_ref) as
10448
3137
    well as the collation of the arguments.
10449
 
  
10450
 
  RETURN VALUE  
 
3138
 
 
3139
  RETURN VALUE
10451
3140
    true    can be used
10452
3141
    false   cannot be used
10453
3142
*/
10454
 
static bool
10455
 
test_if_equality_guarantees_uniqueness(Item *l, Item *r)
 
3143
static bool test_if_equality_guarantees_uniqueness(Item *l, Item *r)
10456
3144
{
10457
3145
  return r->const_item() &&
10458
3146
    /* elements must be compared as dates */
10467
3155
/**
10468
3156
  Return true if the item is a const value in all the WHERE clause.
10469
3157
*/
10470
 
 
10471
 
static bool
10472
 
const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)
 
3158
bool const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)
10473
3159
{
10474
3160
  if (cond->type() == Item::COND_ITEM)
10475
3161
  {
10482
3168
      bool res=const_expression_in_where(item, comp_item, const_item);
10483
3169
      if (res)                                  // Is a const value
10484
3170
      {
10485
 
        if (and_level)
10486
 
          return 1;
 
3171
        if (and_level)
 
3172
          return 1;
10487
3173
      }
10488
3174
      else if (!and_level)
10489
 
        return 0;
 
3175
        return 0;
10490
3176
    }
10491
3177
    return and_level ? 0 : 1;
10492
3178
  }
10494
3180
  {                                             // boolan compare function
10495
3181
    Item_func* func= (Item_func*) cond;
10496
3182
    if (func->functype() != Item_func::EQUAL_FUNC &&
10497
 
        func->functype() != Item_func::EQ_FUNC)
 
3183
              func->functype() != Item_func::EQ_FUNC)
10498
3184
      return 0;
10499
3185
    Item *left_item=    ((Item_func*) cond)->arguments()[0];
10500
3186
    Item *right_item= ((Item_func*) cond)->arguments()[1];
10502
3188
    {
10503
3189
      if (test_if_equality_guarantees_uniqueness (left_item, right_item))
10504
3190
      {
10505
 
        if (*const_item)
10506
 
          return right_item->eq(*const_item, 1);
10507
 
        *const_item=right_item;
10508
 
        return 1;
 
3191
        if (*const_item)
 
3192
          return right_item->eq(*const_item, 1);
 
3193
        *const_item=right_item;
 
3194
        return 1;
10509
3195
      }
10510
3196
    }
10511
3197
    else if (right_item->eq(comp_item,1))
10512
3198
    {
10513
3199
      if (test_if_equality_guarantees_uniqueness (right_item, left_item))
10514
3200
      {
10515
 
        if (*const_item)
10516
 
          return left_item->eq(*const_item, 1);
10517
 
        *const_item=left_item;
10518
 
        return 1;
10519
 
      }
10520
 
    }
10521
 
  }
10522
 
  return 0;
10523
 
}
10524
 
 
10525
 
/****************************************************************************
10526
 
  Create internal temporary table
10527
 
****************************************************************************/
10528
 
 
10529
 
/**
10530
 
  Create field for temporary table from given field.
10531
 
 
10532
 
  @param thd           Thread handler
10533
 
  @param org_field    field from which new field will be created
10534
 
  @param name         New field name
10535
 
  @param table         Temporary table
10536
 
  @param item          !=NULL if item->result_field should point to new field.
10537
 
                      This is relevant for how fill_record() is going to work:
10538
 
                      If item != NULL then fill_record() will update
10539
 
                      the record in the original table.
10540
 
                      If item == NULL then fill_record() will update
10541
 
                      the temporary table
10542
 
  @param convert_blob_length   If >0 create a varstring(convert_blob_length)
10543
 
                               field instead of blob.
10544
 
 
10545
 
  @retval
10546
 
    NULL                on error
10547
 
  @retval
10548
 
    new_created field
10549
 
*/
10550
 
 
10551
 
Field *create_tmp_field_from_field(THD *thd, Field *org_field,
10552
 
                                   const char *name, TABLE *table,
10553
 
                                   Item_field *item, uint convert_blob_length)
10554
 
{
10555
 
  Field *new_field;
10556
 
 
10557
 
  /* 
10558
 
    Make sure that the blob fits into a Field_varstring which has 
10559
 
    2-byte lenght. 
10560
 
  */
10561
 
  if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&
10562
 
      (org_field->flags & BLOB_FLAG))
10563
 
    new_field= new Field_varstring(convert_blob_length,
10564
 
                                   org_field->maybe_null(),
10565
 
                                   org_field->field_name, table->s,
10566
 
                                   org_field->charset());
10567
 
  else
10568
 
    new_field= org_field->new_field(thd->mem_root, table,
10569
 
                                    table == org_field->table);
10570
 
  if (new_field)
10571
 
  {
10572
 
    new_field->init(table);
10573
 
    new_field->orig_table= org_field->orig_table;
10574
 
    if (item)
10575
 
      item->result_field= new_field;
10576
 
    else
10577
 
      new_field->field_name= name;
10578
 
    new_field->flags|= (org_field->flags & NO_DEFAULT_VALUE_FLAG);
10579
 
    if (org_field->maybe_null() || (item && item->maybe_null))
10580
 
      new_field->flags&= ~NOT_NULL_FLAG;        // Because of outer join
10581
 
    if (org_field->type() == DRIZZLE_TYPE_VARCHAR)
10582
 
      table->s->db_create_options|= HA_OPTION_PACK_RECORD;
10583
 
    else if (org_field->type() == DRIZZLE_TYPE_DOUBLE)
10584
 
      ((Field_double *) new_field)->not_fixed= true;
10585
 
  }
10586
 
  return new_field;
10587
 
}
10588
 
 
10589
 
/**
10590
 
  Create field for temporary table using type of given item.
10591
 
 
10592
 
  @param thd                   Thread handler
10593
 
  @param item                  Item to create a field for
10594
 
  @param table                 Temporary table
10595
 
  @param copy_func             If set and item is a function, store copy of
10596
 
                               item in this array
10597
 
  @param modify_item           1 if item->result_field should point to new
10598
 
                               item. This is relevent for how fill_record()
10599
 
                               is going to work:
10600
 
                               If modify_item is 1 then fill_record() will
10601
 
                               update the record in the original table.
10602
 
                               If modify_item is 0 then fill_record() will
10603
 
                               update the temporary table
10604
 
  @param convert_blob_length   If >0 create a varstring(convert_blob_length)
10605
 
                               field instead of blob.
10606
 
 
10607
 
  @retval
10608
 
    0  on error
10609
 
  @retval
10610
 
    new_created field
10611
 
*/
10612
 
 
10613
 
static Field *create_tmp_field_from_item(THD *thd __attribute__((unused)),
10614
 
                                         Item *item, TABLE *table,
10615
 
                                         Item ***copy_func, bool modify_item,
10616
 
                                         uint convert_blob_length)
10617
 
{
10618
 
  bool maybe_null= item->maybe_null;
10619
 
  Field *new_field;
10620
 
 
10621
 
  switch (item->result_type()) {
10622
 
  case REAL_RESULT:
10623
 
    new_field= new Field_double(item->max_length, maybe_null,
10624
 
                                item->name, item->decimals, true);
10625
 
    break;
10626
 
  case INT_RESULT:
10627
 
    /* 
10628
 
      Select an integer type with the minimal fit precision.
10629
 
      MY_INT32_NUM_DECIMAL_DIGITS is sign inclusive, don't consider the sign.
10630
 
      Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into 
10631
 
      Field_long : make them Field_int64_t.  
10632
 
    */
10633
 
    if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1))
10634
 
      new_field=new Field_int64_t(item->max_length, maybe_null,
10635
 
                                   item->name, item->unsigned_flag);
10636
 
    else
10637
 
      new_field=new Field_long(item->max_length, maybe_null,
10638
 
                               item->name, item->unsigned_flag);
10639
 
    break;
10640
 
  case STRING_RESULT:
10641
 
    assert(item->collation.collation);
10642
 
  
10643
 
    enum enum_field_types type;
10644
 
    /*
10645
 
      DATE/TIME fields have STRING_RESULT result type. 
10646
 
      To preserve type they needed to be handled separately.
10647
 
    */
10648
 
    if ((type= item->field_type()) == DRIZZLE_TYPE_DATETIME ||
10649
 
        type == DRIZZLE_TYPE_TIME || type == DRIZZLE_TYPE_NEWDATE ||
10650
 
        type == DRIZZLE_TYPE_TIMESTAMP)
10651
 
      new_field= item->tmp_table_field_from_field_type(table, 1);
10652
 
    /* 
10653
 
      Make sure that the blob fits into a Field_varstring which has 
10654
 
      2-byte lenght. 
10655
 
    */
10656
 
    else if (item->max_length/item->collation.collation->mbmaxlen > 255 &&
10657
 
             convert_blob_length <= Field_varstring::MAX_SIZE && 
10658
 
             convert_blob_length)
10659
 
      new_field= new Field_varstring(convert_blob_length, maybe_null,
10660
 
                                     item->name, table->s,
10661
 
                                     item->collation.collation);
10662
 
    else
10663
 
      new_field= item->make_string_field(table);
10664
 
    new_field->set_derivation(item->collation.derivation);
10665
 
    break;
10666
 
  case DECIMAL_RESULT:
10667
 
  {
10668
 
    uint8_t dec= item->decimals;
10669
 
    uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;
10670
 
    uint32_t len= item->max_length;
10671
 
 
10672
 
    /*
10673
 
      Trying to put too many digits overall in a DECIMAL(prec,dec)
10674
 
      will always throw a warning. We must limit dec to
10675
 
      DECIMAL_MAX_SCALE however to prevent an assert() later.
10676
 
    */
10677
 
 
10678
 
    if (dec > 0)
10679
 
    {
10680
 
      signed int overflow;
10681
 
 
10682
 
      dec= min(dec, (uint8_t)DECIMAL_MAX_SCALE);
10683
 
 
10684
 
      /*
10685
 
        If the value still overflows the field with the corrected dec,
10686
 
        we'll throw out decimals rather than integers. This is still
10687
 
        bad and of course throws a truncation warning.
10688
 
        +1: for decimal point
10689
 
      */
10690
 
 
10691
 
      overflow= my_decimal_precision_to_length(intg + dec, dec,
10692
 
                                               item->unsigned_flag) - len;
10693
 
 
10694
 
      if (overflow > 0)
10695
 
        dec= max(0, dec - overflow);            // too long, discard fract
10696
 
      else
10697
 
        len -= item->decimals - dec;            // corrected value fits
10698
 
    }
10699
 
 
10700
 
    new_field= new Field_new_decimal(len, maybe_null, item->name,
10701
 
                                     dec, item->unsigned_flag);
10702
 
    break;
10703
 
  }
10704
 
  case ROW_RESULT:
10705
 
  default:
10706
 
    // This case should never be choosen
10707
 
    assert(0);
10708
 
    new_field= 0;
10709
 
    break;
10710
 
  }
10711
 
  if (new_field)
10712
 
    new_field->init(table);
10713
 
    
10714
 
  if (copy_func && item->is_result_field())
10715
 
    *((*copy_func)++) = item;                   // Save for copy_funcs
10716
 
  if (modify_item)
10717
 
    item->set_result_field(new_field);
10718
 
  if (item->type() == Item::NULL_ITEM)
10719
 
    new_field->is_created_from_null_item= true;
10720
 
  return new_field;
10721
 
}
10722
 
 
10723
 
 
10724
 
/**
10725
 
  Create field for information schema table.
10726
 
 
10727
 
  @param thd            Thread handler
10728
 
  @param table          Temporary table
10729
 
  @param item           Item to create a field for
10730
 
 
10731
 
  @retval
10732
 
    0                   on error
10733
 
  @retval
10734
 
    new_created field
10735
 
*/
10736
 
 
10737
 
Field *create_tmp_field_for_schema(THD *thd __attribute__((unused)),
10738
 
                                   Item *item, TABLE *table)
10739
 
{
10740
 
  if (item->field_type() == DRIZZLE_TYPE_VARCHAR)
10741
 
  {
10742
 
    Field *field;
10743
 
    if (item->max_length > MAX_FIELD_VARCHARLENGTH)
10744
 
      field= new Field_blob(item->max_length, item->maybe_null,
10745
 
                            item->name, item->collation.collation);
10746
 
    else
10747
 
      field= new Field_varstring(item->max_length, item->maybe_null,
10748
 
                                 item->name,
10749
 
                                 table->s, item->collation.collation);
10750
 
    if (field)
10751
 
      field->init(table);
10752
 
    return field;
10753
 
  }
10754
 
  return item->tmp_table_field_from_field_type(table, 0);
10755
 
}
10756
 
 
10757
 
 
10758
 
/**
10759
 
  Create field for temporary table.
10760
 
 
10761
 
  @param thd            Thread handler
10762
 
  @param table          Temporary table
10763
 
  @param item           Item to create a field for
10764
 
  @param type           Type of item (normally item->type)
10765
 
  @param copy_func      If set and item is a function, store copy of item
10766
 
                       in this array
10767
 
  @param from_field    if field will be created using other field as example,
10768
 
                       pointer example field will be written here
10769
 
  @param default_field  If field has a default value field, store it here
10770
 
  @param group          1 if we are going to do a relative group by on result
10771
 
  @param modify_item    1 if item->result_field should point to new item.
10772
 
                       This is relevent for how fill_record() is going to
10773
 
                       work:
10774
 
                       If modify_item is 1 then fill_record() will update
10775
 
                       the record in the original table.
10776
 
                       If modify_item is 0 then fill_record() will update
10777
 
                       the temporary table
10778
 
  @param convert_blob_length If >0 create a varstring(convert_blob_length)
10779
 
                             field instead of blob.
10780
 
 
10781
 
  @retval
10782
 
    0                   on error
10783
 
  @retval
10784
 
    new_created field
10785
 
*/
10786
 
 
10787
 
Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
10788
 
                        Item ***copy_func, Field **from_field,
10789
 
                        Field **default_field,
10790
 
                        bool group, bool modify_item,
10791
 
                        bool table_cant_handle_bit_fields __attribute__((unused)),
10792
 
                        bool make_copy_field,
10793
 
                        uint convert_blob_length)
10794
 
{
10795
 
  Field *result;
10796
 
  Item::Type orig_type= type;
10797
 
  Item *orig_item= 0;
10798
 
 
10799
 
  if (type != Item::FIELD_ITEM &&
10800
 
      item->real_item()->type() == Item::FIELD_ITEM)
10801
 
  {
10802
 
    orig_item= item;
10803
 
    item= item->real_item();
10804
 
    type= Item::FIELD_ITEM;
10805
 
  }
10806
 
 
10807
 
  switch (type) {
10808
 
  case Item::SUM_FUNC_ITEM:
10809
 
  {
10810
 
    Item_sum *item_sum=(Item_sum*) item;
10811
 
    result= item_sum->create_tmp_field(group, table, convert_blob_length);
10812
 
    if (!result)
10813
 
      my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR));
10814
 
    return result;
10815
 
  }
10816
 
  case Item::FIELD_ITEM:
10817
 
  case Item::DEFAULT_VALUE_ITEM:
10818
 
  {
10819
 
    Item_field *field= (Item_field*) item;
10820
 
    bool orig_modify= modify_item;
10821
 
    if (orig_type == Item::REF_ITEM)
10822
 
      modify_item= 0;
10823
 
    /*
10824
 
      If item have to be able to store NULLs but underlaid field can't do it,
10825
 
      create_tmp_field_from_field() can't be used for tmp field creation.
10826
 
    */
10827
 
    if (field->maybe_null && !field->field->maybe_null())
10828
 
    {
10829
 
      result= create_tmp_field_from_item(thd, item, table, NULL,
10830
 
                                         modify_item, convert_blob_length);
10831
 
      *from_field= field->field;
10832
 
      if (result && modify_item)
10833
 
        field->result_field= result;
10834
 
    } 
10835
 
    else
10836
 
      result= create_tmp_field_from_field(thd, (*from_field= field->field),
10837
 
                                          orig_item ? orig_item->name :
10838
 
                                          item->name,
10839
 
                                          table,
10840
 
                                          modify_item ? field :
10841
 
                                          NULL,
10842
 
                                          convert_blob_length);
10843
 
    if (orig_type == Item::REF_ITEM && orig_modify)
10844
 
      ((Item_ref*)orig_item)->set_result_field(result);
10845
 
    if (field->field->eq_def(result))
10846
 
      *default_field= field->field;
10847
 
    return result;
10848
 
  }
10849
 
  /* Fall through */
10850
 
  case Item::FUNC_ITEM:
10851
 
    /* Fall through */
10852
 
  case Item::COND_ITEM:
10853
 
  case Item::FIELD_AVG_ITEM:
10854
 
  case Item::FIELD_STD_ITEM:
10855
 
  case Item::SUBSELECT_ITEM:
10856
 
    /* The following can only happen with 'CREATE TABLE ... SELECT' */
10857
 
  case Item::PROC_ITEM:
10858
 
  case Item::INT_ITEM:
10859
 
  case Item::REAL_ITEM:
10860
 
  case Item::DECIMAL_ITEM:
10861
 
  case Item::STRING_ITEM:
10862
 
  case Item::REF_ITEM:
10863
 
  case Item::NULL_ITEM:
10864
 
  case Item::VARBIN_ITEM:
10865
 
    if (make_copy_field)
10866
 
    {
10867
 
      assert(((Item_result_field*)item)->result_field);
10868
 
      *from_field= ((Item_result_field*)item)->result_field;
10869
 
    }
10870
 
    return create_tmp_field_from_item(thd, item, table,
10871
 
                                      (make_copy_field ? 0 : copy_func),
10872
 
                                       modify_item, convert_blob_length);
10873
 
  case Item::TYPE_HOLDER:  
10874
 
    result= ((Item_type_holder *)item)->make_field_by_type(table);
10875
 
    result->set_derivation(item->collation.derivation);
10876
 
    return result;
10877
 
  default:                                      // Dosen't have to be stored
10878
 
    return 0;
10879
 
  }
10880
 
}
10881
 
 
10882
 
/*
10883
 
  Set up column usage bitmaps for a temporary table
10884
 
 
10885
 
  IMPLEMENTATION
10886
 
    For temporary tables, we need one bitmap with all columns set and
10887
 
    a tmp_set bitmap to be used by things like filesort.
10888
 
*/
10889
 
 
10890
 
void setup_tmp_table_column_bitmaps(TABLE *table, uchar *bitmaps)
10891
 
{
10892
 
  uint field_count= table->s->fields;
10893
 
  bitmap_init(&table->def_read_set, (my_bitmap_map*) bitmaps, field_count,
10894
 
              false);
10895
 
  bitmap_init(&table->tmp_set,
10896
 
              (my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)),
10897
 
              field_count, false);
10898
 
  /* write_set and all_set are copies of read_set */
10899
 
  table->def_write_set= table->def_read_set;
10900
 
  table->s->all_set= table->def_read_set;
10901
 
  bitmap_set_all(&table->s->all_set);
10902
 
  table->default_column_bitmaps();
10903
 
}
10904
 
 
10905
 
 
10906
 
/**
10907
 
  Create a temp table according to a field list.
10908
 
 
10909
 
  Given field pointers are changed to point at tmp_table for
10910
 
  send_fields. The table object is self contained: it's
10911
 
  allocated in its own memory root, as well as Field objects
10912
 
  created for table columns.
10913
 
  This function will replace Item_sum items in 'fields' list with
10914
 
  corresponding Item_field items, pointing at the fields in the
10915
 
  temporary table, unless this was prohibited by true
10916
 
  value of argument save_sum_fields. The Item_field objects
10917
 
  are created in THD memory root.
10918
 
 
10919
 
  @param thd                  thread handle
10920
 
  @param param                a description used as input to create the table
10921
 
  @param fields               list of items that will be used to define
10922
 
                              column types of the table (also see NOTES)
10923
 
  @param group                TODO document
10924
 
  @param distinct             should table rows be distinct
10925
 
  @param save_sum_fields      see NOTES
10926
 
  @param select_options
10927
 
  @param rows_limit
10928
 
  @param table_alias          possible name of the temporary table that can
10929
 
                              be used for name resolving; can be "".
10930
 
*/
10931
 
 
10932
 
#define STRING_TOTAL_LENGTH_TO_PACK_ROWS 128
10933
 
#define AVG_STRING_LENGTH_TO_PACK_ROWS   64
10934
 
#define RATIO_TO_PACK_ROWS             2
10935
 
#define MIN_STRING_LENGTH_TO_PACK_ROWS   10
10936
 
 
10937
 
TABLE *
10938
 
create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
10939
 
                 ORDER *group, bool distinct, bool save_sum_fields,
10940
 
                 uint64_t select_options, ha_rows rows_limit,
10941
 
                 char *table_alias)
10942
 
{
10943
 
  MEM_ROOT *mem_root_save, own_root;
10944
 
  TABLE *table;
10945
 
  TABLE_SHARE *share;
10946
 
  uint  i,field_count,null_count,null_pack_length;
10947
 
  uint  copy_func_count= param->func_count;
10948
 
  uint  hidden_null_count, hidden_null_pack_length, hidden_field_count;
10949
 
  uint  blob_count,group_null_items, string_count;
10950
 
  uint  temp_pool_slot=MY_BIT_NONE;
10951
 
  uint fieldnr= 0;
10952
 
  ulong reclength, string_total_length;
10953
 
  bool  using_unique_constraint= 0;
10954
 
  bool  use_packed_rows= 0;
10955
 
  bool  not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);
10956
 
  char  *tmpname,path[FN_REFLEN];
10957
 
  uchar *pos, *group_buff, *bitmaps;
10958
 
  uchar *null_flags;
10959
 
  Field **reg_field, **from_field, **default_field;
10960
 
  uint *blob_field;
10961
 
  Copy_field *copy=0;
10962
 
  KEY *keyinfo;
10963
 
  KEY_PART_INFO *key_part_info;
10964
 
  Item **copy_func;
10965
 
  MI_COLUMNDEF *recinfo;
10966
 
  uint total_uneven_bit_length= 0;
10967
 
  bool force_copy_fields= param->force_copy_fields;
10968
 
 
10969
 
  status_var_increment(thd->status_var.created_tmp_tables);
10970
 
 
10971
 
  if (use_temp_pool && !(test_flags & TEST_KEEP_TMP_TABLES))
10972
 
    temp_pool_slot = bitmap_lock_set_next(&temp_pool);
10973
 
 
10974
 
  if (temp_pool_slot != MY_BIT_NONE) // we got a slot
10975
 
    sprintf(path, "%s_%lx_%i", tmp_file_prefix,
10976
 
            current_pid, temp_pool_slot);
10977
 
  else
10978
 
  {
10979
 
    /* if we run out of slots or we are not using tempool */
10980
 
    sprintf(path,"%s%lx_%lx_%x", tmp_file_prefix,current_pid,
10981
 
            thd->thread_id, thd->tmp_table++);
10982
 
  }
10983
 
 
10984
 
  /*
10985
 
    No need to change table name to lower case as we are only creating
10986
 
    MyISAM or HEAP tables here
10987
 
  */
10988
 
  fn_format(path, path, mysql_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);
10989
 
 
10990
 
 
10991
 
  if (group)
10992
 
  {
10993
 
    if (!param->quick_group)
10994
 
      group=0;                                  // Can't use group key
10995
 
    else for (ORDER *tmp=group ; tmp ; tmp=tmp->next)
10996
 
    {
10997
 
      /*
10998
 
        marker == 4 means two things:
10999
 
        - store NULLs in the key, and
11000
 
        - convert BIT fields to 64-bit long, needed because MEMORY tables
11001
 
          can't index BIT fields.
11002
 
      */
11003
 
      (*tmp->item)->marker= 4;
11004
 
      if ((*tmp->item)->max_length >= CONVERT_IF_BIGGER_TO_BLOB)
11005
 
        using_unique_constraint=1;
11006
 
    }
11007
 
    if (param->group_length >= MAX_BLOB_WIDTH)
11008
 
      using_unique_constraint=1;
11009
 
    if (group)
11010
 
      distinct=0;                               // Can't use distinct
11011
 
  }
11012
 
 
11013
 
  field_count=param->field_count+param->func_count+param->sum_func_count;
11014
 
  hidden_field_count=param->hidden_field_count;
11015
 
 
11016
 
  /*
11017
 
    When loose index scan is employed as access method, it already
11018
 
    computes all groups and the result of all aggregate functions. We
11019
 
    make space for the items of the aggregate function in the list of
11020
 
    functions TMP_TABLE_PARAM::items_to_copy, so that the values of
11021
 
    these items are stored in the temporary table.
11022
 
  */
11023
 
  if (param->precomputed_group_by)
11024
 
    copy_func_count+= param->sum_func_count;
11025
 
  
11026
 
  init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);
11027
 
 
11028
 
  if (!multi_alloc_root(&own_root,
11029
 
                        &table, sizeof(*table),
11030
 
                        &share, sizeof(*share),
11031
 
                        &reg_field, sizeof(Field*) * (field_count+1),
11032
 
                        &default_field, sizeof(Field*) * (field_count),
11033
 
                        &blob_field, sizeof(uint)*(field_count+1),
11034
 
                        &from_field, sizeof(Field*)*field_count,
11035
 
                        &copy_func, sizeof(*copy_func)*(copy_func_count+1),
11036
 
                        &param->keyinfo, sizeof(*param->keyinfo),
11037
 
                        &key_part_info,
11038
 
                        sizeof(*key_part_info)*(param->group_parts+1),
11039
 
                        &param->start_recinfo,
11040
 
                        sizeof(*param->recinfo)*(field_count*2+4),
11041
 
                        &tmpname, (uint) strlen(path)+1,
11042
 
                        &group_buff, (group && ! using_unique_constraint ?
11043
 
                                      param->group_length : 0),
11044
 
                        &bitmaps, bitmap_buffer_size(field_count)*2,
11045
 
                        NullS))
11046
 
  {
11047
 
    if (temp_pool_slot != MY_BIT_NONE)
11048
 
      bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
11049
 
    return(NULL);                               /* purecov: inspected */
11050
 
  }
11051
 
  /* Copy_field belongs to TMP_TABLE_PARAM, allocate it in THD mem_root */
11052
 
  if (!(param->copy_field= copy= new (thd->mem_root) Copy_field[field_count]))
11053
 
  {
11054
 
    if (temp_pool_slot != MY_BIT_NONE)
11055
 
      bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
11056
 
    free_root(&own_root, MYF(0));               /* purecov: inspected */
11057
 
    return(NULL);                               /* purecov: inspected */
11058
 
  }
11059
 
  param->items_to_copy= copy_func;
11060
 
  stpcpy(tmpname,path);
11061
 
  /* make table according to fields */
11062
 
 
11063
 
  memset(table, 0, sizeof(*table));
11064
 
  memset(reg_field, 0, sizeof(Field*)*(field_count+1));
11065
 
  memset(default_field, 0, sizeof(Field*) * (field_count));
11066
 
  memset(from_field, 0, sizeof(Field*)*field_count);
11067
 
 
11068
 
  table->mem_root= own_root;
11069
 
  mem_root_save= thd->mem_root;
11070
 
  thd->mem_root= &table->mem_root;
11071
 
 
11072
 
  table->field=reg_field;
11073
 
  table->alias= table_alias;
11074
 
  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */
11075
 
  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
11076
 
  table->map=1;
11077
 
  table->temp_pool_slot = temp_pool_slot;
11078
 
  table->copy_blobs= 1;
11079
 
  table->in_use= thd;
11080
 
  table->quick_keys.init();
11081
 
  table->covering_keys.init();
11082
 
  table->keys_in_use_for_query.init();
11083
 
 
11084
 
  table->s= share;
11085
 
  init_tmp_table_share(thd, share, "", 0, tmpname, tmpname);
11086
 
  share->blob_field= blob_field;
11087
 
  share->blob_ptr_size= portable_sizeof_char_ptr;
11088
 
  share->db_low_byte_first=1;                // True for HEAP and MyISAM
11089
 
  share->table_charset= param->table_charset;
11090
 
  share->primary_key= MAX_KEY;               // Indicate no primary key
11091
 
  share->keys_for_keyread.init();
11092
 
  share->keys_in_use.init();
11093
 
 
11094
 
  /* Calculate which type of fields we will store in the temporary table */
11095
 
 
11096
 
  reclength= string_total_length= 0;
11097
 
  blob_count= string_count= null_count= hidden_null_count= group_null_items= 0;
11098
 
  param->using_indirect_summary_function=0;
11099
 
 
11100
 
  List_iterator_fast<Item> li(fields);
11101
 
  Item *item;
11102
 
  Field **tmp_from_field=from_field;
11103
 
  while ((item=li++))
11104
 
  {
11105
 
    Item::Type type=item->type();
11106
 
    if (not_all_columns)
11107
 
    {
11108
 
      if (item->with_sum_func && type != Item::SUM_FUNC_ITEM)
11109
 
      {
11110
 
        if (item->used_tables() & OUTER_REF_TABLE_BIT)
11111
 
          item->update_used_tables();
11112
 
        if (type == Item::SUBSELECT_ITEM ||
11113
 
            (item->used_tables() & ~OUTER_REF_TABLE_BIT))
11114
 
        {
11115
 
          /*
11116
 
            Mark that the we have ignored an item that refers to a summary
11117
 
            function. We need to know this if someone is going to use
11118
 
            DISTINCT on the result.
11119
 
          */
11120
 
          param->using_indirect_summary_function=1;
11121
 
          continue;
11122
 
        }
11123
 
      }
11124
 
      if (item->const_item() && (int) hidden_field_count <= 0)
11125
 
        continue; // We don't have to store this
11126
 
    }
11127
 
    if (type == Item::SUM_FUNC_ITEM && !group && !save_sum_fields)
11128
 
    {                                           /* Can't calc group yet */
11129
 
      ((Item_sum*) item)->result_field=0;
11130
 
      for (i=0 ; i < ((Item_sum*) item)->arg_count ; i++)
11131
 
      {
11132
 
        Item **argp= ((Item_sum*) item)->args + i;
11133
 
        Item *arg= *argp;
11134
 
        if (!arg->const_item())
11135
 
        {
11136
 
          Field *new_field=
11137
 
            create_tmp_field(thd, table, arg, arg->type(), &copy_func,
11138
 
                             tmp_from_field, &default_field[fieldnr],
11139
 
                             group != 0,not_all_columns,
11140
 
                             distinct, 0,
11141
 
                             param->convert_blob_length);
11142
 
          if (!new_field)
11143
 
            goto err;                                   // Should be OOM
11144
 
          tmp_from_field++;
11145
 
          reclength+=new_field->pack_length();
11146
 
          if (new_field->flags & BLOB_FLAG)
11147
 
          {
11148
 
            *blob_field++= fieldnr;
11149
 
            blob_count++;
11150
 
          }
11151
 
          *(reg_field++)= new_field;
11152
 
          if (new_field->real_type() == DRIZZLE_TYPE_VARCHAR)
11153
 
          {
11154
 
            string_count++;
11155
 
            string_total_length+= new_field->pack_length();
11156
 
          }
11157
 
          thd->mem_root= mem_root_save;
11158
 
          thd->change_item_tree(argp, new Item_field(new_field));
11159
 
          thd->mem_root= &table->mem_root;
11160
 
          if (!(new_field->flags & NOT_NULL_FLAG))
11161
 
          {
11162
 
            null_count++;
11163
 
            /*
11164
 
              new_field->maybe_null() is still false, it will be
11165
 
              changed below. But we have to setup Item_field correctly
11166
 
            */
11167
 
            (*argp)->maybe_null=1;
11168
 
          }
11169
 
          new_field->field_index= fieldnr++;
11170
 
        }
11171
 
      }
11172
 
    }
11173
 
    else
11174
 
    {
11175
 
      /*
11176
 
        The last parameter to create_tmp_field() is a bit tricky:
11177
 
 
11178
 
        We need to set it to 0 in union, to get fill_record() to modify the
11179
 
        temporary table.
11180
 
        We need to set it to 1 on multi-table-update and in select to
11181
 
        write rows to the temporary table.
11182
 
        We here distinguish between UNION and multi-table-updates by the fact
11183
 
        that in the later case group is set to the row pointer.
11184
 
      */
11185
 
      Field *new_field= (param->schema_table) ?
11186
 
        create_tmp_field_for_schema(thd, item, table) :
11187
 
        create_tmp_field(thd, table, item, type, &copy_func,
11188
 
                         tmp_from_field, &default_field[fieldnr],
11189
 
                         group != 0,
11190
 
                         !force_copy_fields &&
11191
 
                           (not_all_columns || group !=0),
11192
 
                         /*
11193
 
                           If item->marker == 4 then we force create_tmp_field
11194
 
                           to create a 64-bit longs for BIT fields because HEAP
11195
 
                           tables can't index BIT fields directly. We do the same
11196
 
                           for distinct, as we want the distinct index to be
11197
 
                           usable in this case too.
11198
 
                         */
11199
 
                         item->marker == 4 || param->bit_fields_as_long,
11200
 
                         force_copy_fields,
11201
 
                         param->convert_blob_length);
11202
 
 
11203
 
      if (!new_field)
11204
 
      {
11205
 
        if (thd->is_fatal_error)
11206
 
          goto err;                             // Got OOM
11207
 
        continue;                               // Some kindf of const item
11208
 
      }
11209
 
      if (type == Item::SUM_FUNC_ITEM)
11210
 
        ((Item_sum *) item)->result_field= new_field;
11211
 
      tmp_from_field++;
11212
 
      reclength+=new_field->pack_length();
11213
 
      if (!(new_field->flags & NOT_NULL_FLAG))
11214
 
        null_count++;
11215
 
      if (new_field->flags & BLOB_FLAG)
11216
 
      {
11217
 
        *blob_field++= fieldnr;
11218
 
        blob_count++;
11219
 
      }
11220
 
      if (item->marker == 4 && item->maybe_null)
11221
 
      {
11222
 
        group_null_items++;
11223
 
        new_field->flags|= GROUP_FLAG;
11224
 
      }
11225
 
      new_field->field_index= fieldnr++;
11226
 
      *(reg_field++)= new_field;
11227
 
    }
11228
 
    if (!--hidden_field_count)
11229
 
    {
11230
 
      /*
11231
 
        This was the last hidden field; Remember how many hidden fields could
11232
 
        have null
11233
 
      */
11234
 
      hidden_null_count=null_count;
11235
 
      /*
11236
 
        We need to update hidden_field_count as we may have stored group
11237
 
        functions with constant arguments
11238
 
      */
11239
 
      param->hidden_field_count= fieldnr;
11240
 
      null_count= 0;
11241
 
    }
11242
 
  }
11243
 
  assert(fieldnr == (uint) (reg_field - table->field));
11244
 
  assert(field_count >= (uint) (reg_field - table->field));
11245
 
  field_count= fieldnr;
11246
 
  *reg_field= 0;
11247
 
  *blob_field= 0;                               // End marker
11248
 
  share->fields= field_count;
11249
 
 
11250
 
  /* If result table is small; use a heap */
11251
 
  /* future: storage engine selection can be made dynamic? */
11252
 
  if (blob_count || using_unique_constraint ||
11253
 
      (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
11254
 
      OPTION_BIG_TABLES || (select_options & TMP_TABLE_FORCE_MYISAM))
11255
 
  {
11256
 
    share->db_plugin= ha_lock_engine(0, myisam_hton);
11257
 
    table->file= get_new_handler(share, &table->mem_root,
11258
 
                                 share->db_type());
11259
 
    if (group &&
11260
 
        (param->group_parts > table->file->max_key_parts() ||
11261
 
         param->group_length > table->file->max_key_length()))
11262
 
      using_unique_constraint=1;
11263
 
  }
11264
 
  else
11265
 
  {
11266
 
    share->db_plugin= ha_lock_engine(0, heap_hton);
11267
 
    table->file= get_new_handler(share, &table->mem_root,
11268
 
                                 share->db_type());
11269
 
  }
11270
 
  if (!table->file)
11271
 
    goto err;
11272
 
 
11273
 
 
11274
 
  if (!using_unique_constraint)
11275
 
    reclength+= group_null_items;       // null flag is stored separately
11276
 
 
11277
 
  share->blob_fields= blob_count;
11278
 
  if (blob_count == 0)
11279
 
  {
11280
 
    /* We need to ensure that first byte is not 0 for the delete link */
11281
 
    if (param->hidden_field_count)
11282
 
      hidden_null_count++;
11283
 
    else
11284
 
      null_count++;
11285
 
  }
11286
 
  hidden_null_pack_length=(hidden_null_count+7)/8;
11287
 
  null_pack_length= (hidden_null_pack_length +
11288
 
                     (null_count + total_uneven_bit_length + 7) / 8);
11289
 
  reclength+=null_pack_length;
11290
 
  if (!reclength)
11291
 
    reclength=1;                                // Dummy select
11292
 
  /* Use packed rows if there is blobs or a lot of space to gain */
11293
 
  if (blob_count || ((string_total_length >= STRING_TOTAL_LENGTH_TO_PACK_ROWS) && (reclength / string_total_length <= RATIO_TO_PACK_ROWS || (string_total_length / string_count) >= AVG_STRING_LENGTH_TO_PACK_ROWS)))
11294
 
    use_packed_rows= 1;
11295
 
 
11296
 
  share->reclength= reclength;
11297
 
  {
11298
 
    uint alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1);
11299
 
    share->rec_buff_length= alloc_length;
11300
 
    if (!(table->record[0]= (uchar*)
11301
 
                            alloc_root(&table->mem_root, alloc_length*3)))
11302
 
      goto err;
11303
 
    table->record[1]= table->record[0]+alloc_length;
11304
 
    share->default_values= table->record[1]+alloc_length;
11305
 
  }
11306
 
  copy_func[0]=0;                               // End marker
11307
 
  param->func_count= copy_func - param->items_to_copy; 
11308
 
 
11309
 
  setup_tmp_table_column_bitmaps(table, bitmaps);
11310
 
 
11311
 
  recinfo=param->start_recinfo;
11312
 
  null_flags=(uchar*) table->record[0];
11313
 
  pos=table->record[0]+ null_pack_length;
11314
 
  if (null_pack_length)
11315
 
  {
11316
 
    memset(recinfo, 0, sizeof(*recinfo));
11317
 
    recinfo->type=FIELD_NORMAL;
11318
 
    recinfo->length=null_pack_length;
11319
 
    recinfo++;
11320
 
    memset(null_flags, 255, null_pack_length);  // Set null fields
11321
 
 
11322
 
    table->null_flags= (uchar*) table->record[0];
11323
 
    share->null_fields= null_count+ hidden_null_count;
11324
 
    share->null_bytes= null_pack_length;
11325
 
  }
11326
 
  null_count= (blob_count == 0) ? 1 : 0;
11327
 
  hidden_field_count=param->hidden_field_count;
11328
 
  for (i=0,reg_field=table->field; i < field_count; i++,reg_field++,recinfo++)
11329
 
  {
11330
 
    Field *field= *reg_field;
11331
 
    uint length;
11332
 
    memset(recinfo, 0, sizeof(*recinfo));
11333
 
 
11334
 
    if (!(field->flags & NOT_NULL_FLAG))
11335
 
    {
11336
 
      if (field->flags & GROUP_FLAG && !using_unique_constraint)
11337
 
      {
11338
 
        /*
11339
 
          We have to reserve one byte here for NULL bits,
11340
 
          as this is updated by 'end_update()'
11341
 
        */
11342
 
        *pos++=0;                               // Null is stored here
11343
 
        recinfo->length=1;
11344
 
        recinfo->type=FIELD_NORMAL;
11345
 
        recinfo++;
11346
 
        memset(recinfo, 0, sizeof(*recinfo));
11347
 
      }
11348
 
      else
11349
 
      {
11350
 
        recinfo->null_bit= 1 << (null_count & 7);
11351
 
        recinfo->null_pos= null_count/8;
11352
 
      }
11353
 
      field->move_field(pos,null_flags+null_count/8,
11354
 
                        1 << (null_count & 7));
11355
 
      null_count++;
11356
 
    }
11357
 
    else
11358
 
      field->move_field(pos,(uchar*) 0,0);
11359
 
    field->reset();
11360
 
 
11361
 
    /*
11362
 
      Test if there is a default field value. The test for ->ptr is to skip
11363
 
      'offset' fields generated by initalize_tables
11364
 
    */
11365
 
    if (default_field[i] && default_field[i]->ptr)
11366
 
    {
11367
 
      /* 
11368
 
         default_field[i] is set only in the cases  when 'field' can
11369
 
         inherit the default value that is defined for the field referred
11370
 
         by the Item_field object from which 'field' has been created.
11371
 
      */
11372
 
      my_ptrdiff_t diff;
11373
 
      Field *orig_field= default_field[i];
11374
 
      /* Get the value from default_values */
11375
 
      diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
11376
 
                            orig_field->table->record[0]);
11377
 
      orig_field->move_field_offset(diff);      // Points now at default_values
11378
 
      if (orig_field->is_real_null())
11379
 
        field->set_null();
11380
 
      else
11381
 
      {
11382
 
        field->set_notnull();
11383
 
        memcpy(field->ptr, orig_field->ptr, field->pack_length());
11384
 
      }
11385
 
      orig_field->move_field_offset(-diff);     // Back to record[0]
11386
 
    } 
11387
 
 
11388
 
    if (from_field[i])
11389
 
    {                                           /* Not a table Item */
11390
 
      copy->set(field,from_field[i],save_sum_fields);
11391
 
      copy++;
11392
 
    }
11393
 
    length=field->pack_length();
11394
 
    pos+= length;
11395
 
 
11396
 
    /* Make entry for create table */
11397
 
    recinfo->length=length;
11398
 
    if (field->flags & BLOB_FLAG)
11399
 
      recinfo->type= (int) FIELD_BLOB;
11400
 
    else
11401
 
      recinfo->type=FIELD_NORMAL;
11402
 
    if (!--hidden_field_count)
11403
 
      null_count=(null_count+7) & ~7;           // move to next byte
11404
 
 
11405
 
    // fix table name in field entry
11406
 
    field->table_name= &table->alias;
11407
 
  }
11408
 
 
11409
 
  param->copy_field_end=copy;
11410
 
  param->recinfo=recinfo;
11411
 
  store_record(table,s->default_values);        // Make empty default record
11412
 
 
11413
 
  if (thd->variables.tmp_table_size == ~ (uint64_t) 0)          // No limit
11414
 
    share->max_rows= ~(ha_rows) 0;
11415
 
  else
11416
 
    share->max_rows= (ha_rows) (((share->db_type() == heap_hton) ?
11417
 
                                 min(thd->variables.tmp_table_size,
11418
 
                                     thd->variables.max_heap_table_size) :
11419
 
                                 thd->variables.tmp_table_size) /
11420
 
                                 share->reclength);
11421
 
  set_if_bigger(share->max_rows,1);             // For dummy start options
11422
 
  /*
11423
 
    Push the LIMIT clause to the temporary table creation, so that we
11424
 
    materialize only up to 'rows_limit' records instead of all result records.
11425
 
  */
11426
 
  set_if_smaller(share->max_rows, rows_limit);
11427
 
  param->end_write_records= rows_limit;
11428
 
 
11429
 
  keyinfo= param->keyinfo;
11430
 
 
11431
 
  if (group)
11432
 
  {
11433
 
    table->group=group;                         /* Table is grouped by key */
11434
 
    param->group_buff=group_buff;
11435
 
    share->keys=1;
11436
 
    share->uniques= test(using_unique_constraint);
11437
 
    table->key_info=keyinfo;
11438
 
    keyinfo->key_part=key_part_info;
11439
 
    keyinfo->flags=HA_NOSAME;
11440
 
    keyinfo->usable_key_parts=keyinfo->key_parts= param->group_parts;
11441
 
    keyinfo->key_length=0;
11442
 
    keyinfo->rec_per_key=0;
11443
 
    keyinfo->algorithm= HA_KEY_ALG_UNDEF;
11444
 
    keyinfo->name= (char*) "group_key";
11445
 
    ORDER *cur_group= group;
11446
 
    for (; cur_group ; cur_group= cur_group->next, key_part_info++)
11447
 
    {
11448
 
      Field *field=(*cur_group->item)->get_tmp_table_field();
11449
 
      bool maybe_null=(*cur_group->item)->maybe_null;
11450
 
      key_part_info->null_bit=0;
11451
 
      key_part_info->field=  field;
11452
 
      key_part_info->offset= field->offset(table->record[0]);
11453
 
      key_part_info->length= (uint16_t) field->key_length();
11454
 
      key_part_info->type=   (uint8_t) field->key_type();
11455
 
      key_part_info->key_type =
11456
 
        ((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||
11457
 
         (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||
11458
 
         (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?
11459
 
        0 : FIELDFLAG_BINARY;
11460
 
      if (!using_unique_constraint)
11461
 
      {
11462
 
        cur_group->buff=(char*) group_buff;
11463
 
        if (!(cur_group->field= field->new_key_field(thd->mem_root,table,
11464
 
                                                     group_buff +
11465
 
                                                     test(maybe_null),
11466
 
                                                     field->null_ptr,
11467
 
                                                     field->null_bit)))
11468
 
          goto err; /* purecov: inspected */
11469
 
        if (maybe_null)
11470
 
        {
11471
 
          /*
11472
 
            To be able to group on NULL, we reserved place in group_buff
11473
 
            for the NULL flag just before the column. (see above).
11474
 
            The field data is after this flag.
11475
 
            The NULL flag is updated in 'end_update()' and 'end_write()'
11476
 
          */
11477
 
          keyinfo->flags|= HA_NULL_ARE_EQUAL;   // def. that NULL == NULL
11478
 
          key_part_info->null_bit=field->null_bit;
11479
 
          key_part_info->null_offset= (uint) (field->null_ptr -
11480
 
                                              (uchar*) table->record[0]);
11481
 
          cur_group->buff++;                        // Pointer to field data
11482
 
          group_buff++;                         // Skipp null flag
11483
 
        }
11484
 
        /* In GROUP BY 'a' and 'a ' are equal for VARCHAR fields */
11485
 
        key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL;
11486
 
        group_buff+= cur_group->field->pack_length();
11487
 
      }
11488
 
      keyinfo->key_length+=  key_part_info->length;
11489
 
    }
11490
 
  }
11491
 
 
11492
 
  if (distinct && field_count != param->hidden_field_count)
11493
 
  {
11494
 
    /*
11495
 
      Create an unique key or an unique constraint over all columns
11496
 
      that should be in the result.  In the temporary table, there are
11497
 
      'param->hidden_field_count' extra columns, whose null bits are stored
11498
 
      in the first 'hidden_null_pack_length' bytes of the row.
11499
 
    */
11500
 
    if (blob_count)
11501
 
    {
11502
 
      /*
11503
 
        Special mode for index creation in MyISAM used to support unique
11504
 
        indexes on blobs with arbitrary length. Such indexes cannot be
11505
 
        used for lookups.
11506
 
      */
11507
 
      share->uniques= 1;
11508
 
    }
11509
 
    null_pack_length-=hidden_null_pack_length;
11510
 
    keyinfo->key_parts= ((field_count-param->hidden_field_count)+
11511
 
                         (share->uniques ? test(null_pack_length) : 0));
11512
 
    table->distinct= 1;
11513
 
    share->keys= 1;
11514
 
    if (!(key_part_info= (KEY_PART_INFO*)
11515
 
          alloc_root(&table->mem_root,
11516
 
                     keyinfo->key_parts * sizeof(KEY_PART_INFO))))
11517
 
      goto err;
11518
 
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KEY_PART_INFO));
11519
 
    table->key_info=keyinfo;
11520
 
    keyinfo->key_part=key_part_info;
11521
 
    keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;
11522
 
    keyinfo->key_length=(uint16_t) reclength;
11523
 
    keyinfo->name= (char*) "distinct_key";
11524
 
    keyinfo->algorithm= HA_KEY_ALG_UNDEF;
11525
 
    keyinfo->rec_per_key=0;
11526
 
 
11527
 
    /*
11528
 
      Create an extra field to hold NULL bits so that unique indexes on
11529
 
      blobs can distinguish NULL from 0. This extra field is not needed
11530
 
      when we do not use UNIQUE indexes for blobs.
11531
 
    */
11532
 
    if (null_pack_length && share->uniques)
11533
 
    {
11534
 
      key_part_info->null_bit=0;
11535
 
      key_part_info->offset=hidden_null_pack_length;
11536
 
      key_part_info->length=null_pack_length;
11537
 
      key_part_info->field= new Field_varstring(table->record[0],
11538
 
                                                (uint32_t) key_part_info->length,
11539
 
                                                0,
11540
 
                                                (uchar*) 0,
11541
 
                                                (uint) 0,
11542
 
                                                Field::NONE,
11543
 
                                                NullS, 
11544
 
                                                table->s,
11545
 
                                                &my_charset_bin);
11546
 
      if (!key_part_info->field)
11547
 
        goto err;
11548
 
      key_part_info->field->init(table);
11549
 
      key_part_info->key_type=FIELDFLAG_BINARY;
11550
 
      key_part_info->type=    HA_KEYTYPE_BINARY;
11551
 
      key_part_info++;
11552
 
    }
11553
 
    /* Create a distinct key over the columns we are going to return */
11554
 
    for (i=param->hidden_field_count, reg_field=table->field + i ;
11555
 
         i < field_count;
11556
 
         i++, reg_field++, key_part_info++)
11557
 
    {
11558
 
      key_part_info->null_bit=0;
11559
 
      key_part_info->field=    *reg_field;
11560
 
      key_part_info->offset=   (*reg_field)->offset(table->record[0]);
11561
 
      key_part_info->length=   (uint16_t) (*reg_field)->pack_length();
11562
 
      /* TODO:
11563
 
        The below method of computing the key format length of the
11564
 
        key part is a copy/paste from opt_range.cc, and table.cc.
11565
 
        This should be factored out, e.g. as a method of Field.
11566
 
        In addition it is not clear if any of the Field::*_length
11567
 
        methods is supposed to compute the same length. If so, it
11568
 
        might be reused.
11569
 
      */
11570
 
      key_part_info->store_length= key_part_info->length;
11571
 
 
11572
 
      if ((*reg_field)->real_maybe_null())
11573
 
        key_part_info->store_length+= HA_KEY_NULL_LENGTH;
11574
 
      if ((*reg_field)->type() == DRIZZLE_TYPE_BLOB || 
11575
 
          (*reg_field)->real_type() == DRIZZLE_TYPE_VARCHAR)
11576
 
        key_part_info->store_length+= HA_KEY_BLOB_LENGTH;
11577
 
 
11578
 
      key_part_info->type=     (uint8_t) (*reg_field)->key_type();
11579
 
      key_part_info->key_type =
11580
 
        ((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||
11581
 
         (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||
11582
 
         (ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?
11583
 
        0 : FIELDFLAG_BINARY;
11584
 
    }
11585
 
  }
11586
 
 
11587
 
  if (thd->is_fatal_error)                              // If end of memory
11588
 
    goto err;                                    /* purecov: inspected */
11589
 
  share->db_record_offset= 1;
11590
 
  if (share->db_type() == myisam_hton)
11591
 
  {
11592
 
    if (create_myisam_tmp_table(table, param->keyinfo, param->start_recinfo,
11593
 
                                &param->recinfo, select_options))
11594
 
      goto err;
11595
 
  }
11596
 
  if (open_tmp_table(table))
11597
 
    goto err;
11598
 
 
11599
 
  thd->mem_root= mem_root_save;
11600
 
 
11601
 
  return(table);
11602
 
 
11603
 
err:
11604
 
  thd->mem_root= mem_root_save;
11605
 
  free_tmp_table(thd,table);                    /* purecov: inspected */
11606
 
  if (temp_pool_slot != MY_BIT_NONE)
11607
 
    bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
11608
 
  return(NULL);                         /* purecov: inspected */
11609
 
}
11610
 
 
11611
 
 
11612
 
 
11613
 
 
11614
 
/*
11615
 
  Create a temporary table to weed out duplicate rowid combinations
11616
 
 
11617
 
  SYNOPSIS
11618
 
 
11619
 
    create_duplicate_weedout_tmp_table()
11620
 
      thd
11621
 
      uniq_tuple_length_arg
11622
 
      SJ_TMP_TABLE 
11623
 
 
11624
 
  DESCRIPTION
11625
 
    Create a temporary table to weed out duplicate rowid combinations. The
11626
 
    table has a single column that is a concatenation of all rowids in the
11627
 
    combination. 
11628
 
 
11629
 
    Depending on the needed length, there are two cases:
11630
 
 
11631
 
    1. When the length of the column < max_key_length:
11632
 
 
11633
 
      CREATE TABLE tmp (col VARBINARY(n) NOT NULL, UNIQUE KEY(col));
11634
 
 
11635
 
    2. Otherwise (not a valid SQL syntax but internally supported):
11636
 
 
11637
 
      CREATE TABLE tmp (col VARBINARY NOT NULL, UNIQUE CONSTRAINT(col));
11638
 
 
11639
 
    The code in this function was produced by extraction of relevant parts
11640
 
    from create_tmp_table().
11641
 
 
11642
 
  RETURN
11643
 
    created table
11644
 
    NULL on error
11645
 
*/
11646
 
 
11647
 
TABLE *create_duplicate_weedout_tmp_table(THD *thd, 
11648
 
                                          uint uniq_tuple_length_arg,
11649
 
                                          SJ_TMP_TABLE *sjtbl)
11650
 
{
11651
 
  MEM_ROOT *mem_root_save, own_root;
11652
 
  TABLE *table;
11653
 
  TABLE_SHARE *share;
11654
 
  uint  temp_pool_slot=MY_BIT_NONE;
11655
 
  char  *tmpname,path[FN_REFLEN];
11656
 
  Field **reg_field;
11657
 
  KEY_PART_INFO *key_part_info;
11658
 
  KEY *keyinfo;
11659
 
  uchar *group_buff;
11660
 
  uchar *bitmaps;
11661
 
  uint *blob_field;
11662
 
  MI_COLUMNDEF *recinfo, *start_recinfo;
11663
 
  bool using_unique_constraint=false;
11664
 
  Field *field, *key_field;
11665
 
  uint blob_count, null_pack_length, null_count;
11666
 
  uchar *null_flags;
11667
 
  uchar *pos;
11668
 
  
11669
 
  /*
11670
 
    STEP 1: Get temporary table name
11671
 
  */
11672
 
  statistic_increment(thd->status_var.created_tmp_tables, &LOCK_status);
11673
 
  if (use_temp_pool && !(test_flags & TEST_KEEP_TMP_TABLES))
11674
 
    temp_pool_slot = bitmap_lock_set_next(&temp_pool);
11675
 
 
11676
 
  if (temp_pool_slot != MY_BIT_NONE) // we got a slot
11677
 
    sprintf(path, "%s_%lx_%i", tmp_file_prefix,
11678
 
            current_pid, temp_pool_slot);
11679
 
  else
11680
 
  {
11681
 
    /* if we run out of slots or we are not using tempool */
11682
 
    sprintf(path,"%s%lx_%lx_%x", tmp_file_prefix,current_pid,
11683
 
            thd->thread_id, thd->tmp_table++);
11684
 
  }
11685
 
  fn_format(path, path, mysql_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);
11686
 
 
11687
 
  /* STEP 2: Figure if we'll be using a key or blob+constraint */
11688
 
  if (uniq_tuple_length_arg >= CONVERT_IF_BIGGER_TO_BLOB)
11689
 
    using_unique_constraint= true;
11690
 
 
11691
 
  /* STEP 3: Allocate memory for temptable description */
11692
 
  init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);
11693
 
  if (!multi_alloc_root(&own_root,
11694
 
                        &table, sizeof(*table),
11695
 
                        &share, sizeof(*share),
11696
 
                        &reg_field, sizeof(Field*) * (1+1),
11697
 
                        &blob_field, sizeof(uint)*2,
11698
 
                        &keyinfo, sizeof(*keyinfo),
11699
 
                        &key_part_info, sizeof(*key_part_info) * 2,
11700
 
                        &start_recinfo,
11701
 
                        sizeof(*recinfo)*(1*2+4),
11702
 
                        &tmpname, (uint) strlen(path)+1,
11703
 
                        &group_buff, (!using_unique_constraint ?
11704
 
                                      uniq_tuple_length_arg : 0),
11705
 
                        &bitmaps, bitmap_buffer_size(1)*2,
11706
 
                        NullS))
11707
 
  {
11708
 
    if (temp_pool_slot != MY_BIT_NONE)
11709
 
      bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
11710
 
    return(NULL);
11711
 
  }
11712
 
  stpcpy(tmpname,path);
11713
 
  
11714
 
 
11715
 
  /* STEP 4: Create TABLE description */
11716
 
  memset(table, 0, sizeof(*table));
11717
 
  memset(reg_field, 0, sizeof(Field*)*2);
11718
 
 
11719
 
  table->mem_root= own_root;
11720
 
  mem_root_save= thd->mem_root;
11721
 
  thd->mem_root= &table->mem_root;
11722
 
 
11723
 
  table->field=reg_field;
11724
 
  table->alias= "weedout-tmp";
11725
 
  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */
11726
 
  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
11727
 
  table->map=1;
11728
 
  table->temp_pool_slot = temp_pool_slot;
11729
 
  table->copy_blobs= 1;
11730
 
  table->in_use= thd;
11731
 
  table->quick_keys.init();
11732
 
  table->covering_keys.init();
11733
 
  table->keys_in_use_for_query.init();
11734
 
 
11735
 
  table->s= share;
11736
 
  init_tmp_table_share(thd, share, "", 0, tmpname, tmpname);
11737
 
  share->blob_field= blob_field;
11738
 
  share->blob_ptr_size= portable_sizeof_char_ptr;
11739
 
  share->db_low_byte_first=1;                // True for HEAP and MyISAM
11740
 
  share->table_charset= NULL;
11741
 
  share->primary_key= MAX_KEY;               // Indicate no primary key
11742
 
  share->keys_for_keyread.init();
11743
 
  share->keys_in_use.init();
11744
 
 
11745
 
  blob_count= 0;
11746
 
 
11747
 
  /* Create the field */
11748
 
  {
11749
 
    /*
11750
 
      For the sake of uniformity, always use Field_varstring.
11751
 
    */
11752
 
    field= new Field_varstring(uniq_tuple_length_arg, false, "rowids", share,
11753
 
                               &my_charset_bin);
11754
 
    if (!field)
11755
 
      return(0);
11756
 
    field->table= table;
11757
 
    field->key_start.init(0);
11758
 
    field->part_of_key.init(0);
11759
 
    field->part_of_sortkey.init(0);
11760
 
    field->unireg_check= Field::NONE;
11761
 
    field->flags= (NOT_NULL_FLAG | BINARY_FLAG | NO_DEFAULT_VALUE_FLAG);
11762
 
    field->reset_fields();
11763
 
    field->init(table);
11764
 
    field->orig_table= NULL;
11765
 
     
11766
 
    field->field_index= 0;
11767
 
    
11768
 
    *(reg_field++)= field;
11769
 
    *blob_field= 0;
11770
 
    *reg_field= 0;
11771
 
 
11772
 
    share->fields= 1;
11773
 
    share->blob_fields= 0;
11774
 
  }
11775
 
 
11776
 
  uint reclength= field->pack_length();
11777
 
  if (using_unique_constraint)
11778
 
  { 
11779
 
    share->db_plugin= ha_lock_engine(0, myisam_hton);
11780
 
    table->file= get_new_handler(share, &table->mem_root,
11781
 
                                 share->db_type());
11782
 
    assert(uniq_tuple_length_arg <= table->file->max_key_length());
11783
 
  }
11784
 
  else
11785
 
  {
11786
 
    share->db_plugin= ha_lock_engine(0, heap_hton);
11787
 
    table->file= get_new_handler(share, &table->mem_root,
11788
 
                                 share->db_type());
11789
 
  }
11790
 
  if (!table->file)
11791
 
    goto err;
11792
 
 
11793
 
  null_count=1;
11794
 
  
11795
 
  null_pack_length= 1;
11796
 
  reclength += null_pack_length;
11797
 
 
11798
 
  share->reclength= reclength;
11799
 
  {
11800
 
    uint alloc_length=ALIGN_SIZE(share->reclength + MI_UNIQUE_HASH_LENGTH+1);
11801
 
    share->rec_buff_length= alloc_length;
11802
 
    if (!(table->record[0]= (uchar*)
11803
 
                            alloc_root(&table->mem_root, alloc_length*3)))
11804
 
      goto err;
11805
 
    table->record[1]= table->record[0]+alloc_length;
11806
 
    share->default_values= table->record[1]+alloc_length;
11807
 
  }
11808
 
  setup_tmp_table_column_bitmaps(table, bitmaps);
11809
 
 
11810
 
  recinfo= start_recinfo;
11811
 
  null_flags=(uchar*) table->record[0];
11812
 
  pos=table->record[0]+ null_pack_length;
11813
 
  if (null_pack_length)
11814
 
  {
11815
 
    memset(recinfo, 0, sizeof(*recinfo));
11816
 
    recinfo->type=FIELD_NORMAL;
11817
 
    recinfo->length=null_pack_length;
11818
 
    recinfo++;
11819
 
    memset(null_flags, 255, null_pack_length);  // Set null fields
11820
 
 
11821
 
    table->null_flags= (uchar*) table->record[0];
11822
 
    share->null_fields= null_count;
11823
 
    share->null_bytes= null_pack_length;
11824
 
  }
11825
 
  null_count=1;
11826
 
 
11827
 
  {
11828
 
    //Field *field= *reg_field;
11829
 
    uint length;
11830
 
    memset(recinfo, 0, sizeof(*recinfo));
11831
 
    field->move_field(pos,(uchar*) 0,0);
11832
 
 
11833
 
    field->reset();
11834
 
    /*
11835
 
      Test if there is a default field value. The test for ->ptr is to skip
11836
 
      'offset' fields generated by initalize_tables
11837
 
    */
11838
 
    // Initialize the table field:
11839
 
    memset(field->ptr, 0, field->pack_length());
11840
 
 
11841
 
    length=field->pack_length();
11842
 
    pos+= length;
11843
 
 
11844
 
    /* Make entry for create table */
11845
 
    recinfo->length=length;
11846
 
    if (field->flags & BLOB_FLAG)
11847
 
      recinfo->type= (int) FIELD_BLOB;
11848
 
    else
11849
 
      recinfo->type=FIELD_NORMAL;
11850
 
 
11851
 
    field->table_name= &table->alias;
11852
 
  }
11853
 
 
11854
 
  //param->recinfo=recinfo;
11855
 
  //store_record(table,s->default_values);        // Make empty default record
11856
 
 
11857
 
  if (thd->variables.tmp_table_size == ~ (uint64_t) 0)          // No limit
11858
 
    share->max_rows= ~(ha_rows) 0;
11859
 
  else
11860
 
    share->max_rows= (ha_rows) (((share->db_type() == heap_hton) ?
11861
 
                                 min(thd->variables.tmp_table_size,
11862
 
                                     thd->variables.max_heap_table_size) :
11863
 
                                 thd->variables.tmp_table_size) /
11864
 
                                 share->reclength);
11865
 
  set_if_bigger(share->max_rows,1);             // For dummy start options
11866
 
 
11867
 
 
11868
 
  //// keyinfo= param->keyinfo;
11869
 
  if (true)
11870
 
  {
11871
 
    share->keys=1;
11872
 
    share->uniques= test(using_unique_constraint);
11873
 
    table->key_info=keyinfo;
11874
 
    keyinfo->key_part=key_part_info;
11875
 
    keyinfo->flags=HA_NOSAME;
11876
 
    keyinfo->usable_key_parts= keyinfo->key_parts= 1;
11877
 
    keyinfo->key_length=0;
11878
 
    keyinfo->rec_per_key=0;
11879
 
    keyinfo->algorithm= HA_KEY_ALG_UNDEF;
11880
 
    keyinfo->name= (char*) "weedout_key";
11881
 
    {
11882
 
      key_part_info->null_bit=0;
11883
 
      key_part_info->field=  field;
11884
 
      key_part_info->offset= field->offset(table->record[0]);
11885
 
      key_part_info->length= (uint16_t) field->key_length();
11886
 
      key_part_info->type=   (uint8_t) field->key_type();
11887
 
      key_part_info->key_type = FIELDFLAG_BINARY;
11888
 
      if (!using_unique_constraint)
11889
 
      {
11890
 
        if (!(key_field= field->new_key_field(thd->mem_root, table,
11891
 
                                              group_buff,
11892
 
                                              field->null_ptr,
11893
 
                                              field->null_bit)))
11894
 
          goto err;
11895
 
        key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL; //todo need this?
11896
 
      }
11897
 
      keyinfo->key_length+=  key_part_info->length;
11898
 
    }
11899
 
  }
11900
 
 
11901
 
  if (thd->is_fatal_error)                              // If end of memory
11902
 
    goto err;
11903
 
  share->db_record_offset= 1;
11904
 
  if (share->db_type() == myisam_hton)
11905
 
  {
11906
 
    recinfo++;
11907
 
    if (create_myisam_tmp_table(table, keyinfo, start_recinfo, &recinfo, 0))
11908
 
      goto err;
11909
 
  }
11910
 
  sjtbl->start_recinfo= start_recinfo;
11911
 
  sjtbl->recinfo=       recinfo;
11912
 
  if (open_tmp_table(table))
11913
 
    goto err;
11914
 
 
11915
 
  thd->mem_root= mem_root_save;
11916
 
  return(table);
11917
 
 
11918
 
err:
11919
 
  thd->mem_root= mem_root_save;
11920
 
  free_tmp_table(thd,table);                    /* purecov: inspected */
11921
 
  if (temp_pool_slot != MY_BIT_NONE)
11922
 
    bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
11923
 
  return(NULL);                         /* purecov: inspected */
11924
 
}
11925
 
 
11926
 
/****************************************************************************/
11927
 
 
11928
 
/**
11929
 
  Create a reduced TABLE object with properly set up Field list from a
11930
 
  list of field definitions.
11931
 
 
11932
 
    The created table doesn't have a table handler associated with
11933
 
    it, has no keys, no group/distinct, no copy_funcs array.
11934
 
    The sole purpose of this TABLE object is to use the power of Field
11935
 
    class to read/write data to/from table->record[0]. Then one can store
11936
 
    the record in any container (RB tree, hash, etc).
11937
 
    The table is created in THD mem_root, so are the table's fields.
11938
 
    Consequently, if you don't BLOB fields, you don't need to free it.
11939
 
 
11940
 
  @param thd         connection handle
11941
 
  @param field_list  list of column definitions
11942
 
 
11943
 
  @return
11944
 
    0 if out of memory, TABLE object in case of success
11945
 
*/
11946
 
 
11947
 
TABLE *create_virtual_tmp_table(THD *thd, List<Create_field> &field_list)
11948
 
{
11949
 
  uint field_count= field_list.elements;
11950
 
  uint blob_count= 0;
11951
 
  Field **field;
11952
 
  Create_field *cdef;                           /* column definition */
11953
 
  uint record_length= 0;
11954
 
  uint null_count= 0;                 /* number of columns which may be null */
11955
 
  uint null_pack_length;              /* NULL representation array length */
11956
 
  uint *blob_field;
11957
 
  uchar *bitmaps;
11958
 
  TABLE *table;
11959
 
  TABLE_SHARE *share;
11960
 
 
11961
 
  if (!multi_alloc_root(thd->mem_root,
11962
 
                        &table, sizeof(*table),
11963
 
                        &share, sizeof(*share),
11964
 
                        &field, (field_count + 1) * sizeof(Field*),
11965
 
                        &blob_field, (field_count+1) *sizeof(uint),
11966
 
                        &bitmaps, bitmap_buffer_size(field_count)*2,
11967
 
                        NullS))
11968
 
    return 0;
11969
 
 
11970
 
  memset(table, 0, sizeof(*table));
11971
 
  memset(share, 0, sizeof(*share));
11972
 
  table->field= field;
11973
 
  table->s= share;
11974
 
  share->blob_field= blob_field;
11975
 
  share->fields= field_count;
11976
 
  share->blob_ptr_size= portable_sizeof_char_ptr;
11977
 
  setup_tmp_table_column_bitmaps(table, bitmaps);
11978
 
 
11979
 
  /* Create all fields and calculate the total length of record */
11980
 
  List_iterator_fast<Create_field> it(field_list);
11981
 
  while ((cdef= it++))
11982
 
  {
11983
 
    *field= make_field(share, 0, cdef->length,
11984
 
                       (uchar*) (f_maybe_null(cdef->pack_flag) ? "" : 0),
11985
 
                       f_maybe_null(cdef->pack_flag) ? 1 : 0,
11986
 
                       cdef->pack_flag, cdef->sql_type, cdef->charset,
11987
 
                       cdef->unireg_check,
11988
 
                       cdef->interval, cdef->field_name);
11989
 
    if (!*field)
11990
 
      goto error;
11991
 
    (*field)->init(table);
11992
 
    record_length+= (*field)->pack_length();
11993
 
    if (! ((*field)->flags & NOT_NULL_FLAG))
11994
 
      null_count++;
11995
 
 
11996
 
    if ((*field)->flags & BLOB_FLAG)
11997
 
      share->blob_field[blob_count++]= (uint) (field - table->field);
11998
 
 
11999
 
    field++;
12000
 
  }
12001
 
  *field= NULL;                             /* mark the end of the list */
12002
 
  share->blob_field[blob_count]= 0;            /* mark the end of the list */
12003
 
  share->blob_fields= blob_count;
12004
 
 
12005
 
  null_pack_length= (null_count + 7)/8;
12006
 
  share->reclength= record_length + null_pack_length;
12007
 
  share->rec_buff_length= ALIGN_SIZE(share->reclength + 1);
12008
 
  table->record[0]= (uchar*) thd->alloc(share->rec_buff_length);
12009
 
  if (!table->record[0])
12010
 
    goto error;
12011
 
 
12012
 
  if (null_pack_length)
12013
 
  {
12014
 
    table->null_flags= (uchar*) table->record[0];
12015
 
    share->null_fields= null_count;
12016
 
    share->null_bytes= null_pack_length;
12017
 
  }
12018
 
 
12019
 
  table->in_use= thd;           /* field->reset() may access table->in_use */
12020
 
  {
12021
 
    /* Set up field pointers */
12022
 
    uchar *null_pos= table->record[0];
12023
 
    uchar *field_pos= null_pos + share->null_bytes;
12024
 
    uint null_bit= 1;
12025
 
 
12026
 
    for (field= table->field; *field; ++field)
12027
 
    {
12028
 
      Field *cur_field= *field;
12029
 
      if ((cur_field->flags & NOT_NULL_FLAG))
12030
 
        cur_field->move_field(field_pos);
12031
 
      else
12032
 
      {
12033
 
        cur_field->move_field(field_pos, (uchar*) null_pos, null_bit);
12034
 
        null_bit<<= 1;
12035
 
        if (null_bit == (1 << 8))
12036
 
        {
12037
 
          ++null_pos;
12038
 
          null_bit= 1;
12039
 
        }
12040
 
      }
12041
 
      cur_field->reset();
12042
 
 
12043
 
      field_pos+= cur_field->pack_length();
12044
 
    }
12045
 
  }
12046
 
  return table;
12047
 
error:
12048
 
  for (field= table->field; *field; ++field)
12049
 
    delete *field;                         /* just invokes field destructor */
12050
 
  return 0;
12051
 
}
12052
 
 
12053
 
 
12054
 
static bool open_tmp_table(TABLE *table)
12055
 
{
12056
 
  int error;
12057
 
  if ((error=table->file->ha_open(table, table->s->table_name.str,O_RDWR,
12058
 
                                  HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))
12059
 
  {
12060
 
    table->file->print_error(error,MYF(0)); /* purecov: inspected */
12061
 
    table->db_stat=0;
12062
 
    return(1);
12063
 
  }
12064
 
  (void) table->file->extra(HA_EXTRA_QUICK);            /* Faster */
12065
 
  return(0);
12066
 
}
12067
 
 
12068
 
 
12069
 
/*
12070
 
  Create MyISAM temporary table
12071
 
 
12072
 
  SYNOPSIS
12073
 
    create_myisam_tmp_table()
12074
 
      table           Table object that descrimes the table to be created
12075
 
      keyinfo         Description of the index (there is always one index)
12076
 
      start_recinfo   MyISAM's column descriptions
12077
 
      recinfo INOUT   End of MyISAM's column descriptions
12078
 
      options         Option bits
12079
 
   
12080
 
  DESCRIPTION
12081
 
    Create a MyISAM temporary table according to passed description. The is
12082
 
    assumed to have one unique index or constraint.
12083
 
 
12084
 
    The passed array or MI_COLUMNDEF structures must have this form:
12085
 
 
12086
 
      1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte
12087
 
         when there are many nullable columns)
12088
 
      2. Table columns
12089
 
      3. One free MI_COLUMNDEF element (*recinfo points here)
12090
 
   
12091
 
    This function may use the free element to create hash column for unique
12092
 
    constraint.
12093
 
 
12094
 
   RETURN
12095
 
     false - OK
12096
 
     true  - Error
12097
 
*/
12098
 
 
12099
 
static bool create_myisam_tmp_table(TABLE *table, KEY *keyinfo, 
12100
 
                                    MI_COLUMNDEF *start_recinfo,
12101
 
                                    MI_COLUMNDEF **recinfo, 
12102
 
                                    uint64_t options)
12103
 
{
12104
 
  int error;
12105
 
  MI_KEYDEF keydef;
12106
 
  MI_UNIQUEDEF uniquedef;
12107
 
  TABLE_SHARE *share= table->s;
12108
 
 
12109
 
  if (share->keys)
12110
 
  {                                             // Get keys for ni_create
12111
 
    bool using_unique_constraint=0;
12112
 
    HA_KEYSEG *seg= (HA_KEYSEG*) alloc_root(&table->mem_root,
12113
 
                                            sizeof(*seg) * keyinfo->key_parts);
12114
 
    if (!seg)
12115
 
      goto err;
12116
 
 
12117
 
    memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
12118
 
    if (keyinfo->key_length >= table->file->max_key_length() ||
12119
 
        keyinfo->key_parts > table->file->max_key_parts() ||
12120
 
        share->uniques)
12121
 
    {
12122
 
      /* Can't create a key; Make a unique constraint instead of a key */
12123
 
      share->keys=    0;
12124
 
      share->uniques= 1;
12125
 
      using_unique_constraint=1;
12126
 
      memset(&uniquedef, 0, sizeof(uniquedef));
12127
 
      uniquedef.keysegs=keyinfo->key_parts;
12128
 
      uniquedef.seg=seg;
12129
 
      uniquedef.null_are_equal=1;
12130
 
 
12131
 
      /* Create extra column for hash value */
12132
 
      memset(*recinfo, 0, sizeof(**recinfo));
12133
 
      (*recinfo)->type= FIELD_CHECK;
12134
 
      (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
12135
 
      (*recinfo)++;
12136
 
      share->reclength+=MI_UNIQUE_HASH_LENGTH;
12137
 
    }
12138
 
    else
12139
 
    {
12140
 
      /* Create an unique key */
12141
 
      memset(&keydef, 0, sizeof(keydef));
12142
 
      keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
12143
 
      keydef.keysegs=  keyinfo->key_parts;
12144
 
      keydef.seg= seg;
12145
 
    }
12146
 
    for (uint i=0; i < keyinfo->key_parts ; i++,seg++)
12147
 
    {
12148
 
      Field *field=keyinfo->key_part[i].field;
12149
 
      seg->flag=     0;
12150
 
      seg->language= field->charset()->number;
12151
 
      seg->length=   keyinfo->key_part[i].length;
12152
 
      seg->start=    keyinfo->key_part[i].offset;
12153
 
      if (field->flags & BLOB_FLAG)
12154
 
      {
12155
 
        seg->type=
12156
 
        ((keyinfo->key_part[i].key_type & FIELDFLAG_BINARY) ?
12157
 
         HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);
12158
 
        seg->bit_start= (uint8_t)(field->pack_length() - share->blob_ptr_size);
12159
 
        seg->flag= HA_BLOB_PART;
12160
 
        seg->length=0;                  // Whole blob in unique constraint
12161
 
      }
12162
 
      else
12163
 
      {
12164
 
        seg->type= keyinfo->key_part[i].type;
12165
 
      }
12166
 
      if (!(field->flags & NOT_NULL_FLAG))
12167
 
      {
12168
 
        seg->null_bit= field->null_bit;
12169
 
        seg->null_pos= (uint) (field->null_ptr - (uchar*) table->record[0]);
12170
 
        /*
12171
 
          We are using a GROUP BY on something that contains NULL
12172
 
          In this case we have to tell MyISAM that two NULL should
12173
 
          on INSERT be regarded at the same value
12174
 
        */
12175
 
        if (!using_unique_constraint)
12176
 
          keydef.flag|= HA_NULL_ARE_EQUAL;
12177
 
      }
12178
 
    }
12179
 
  }
12180
 
  MI_CREATE_INFO create_info;
12181
 
  memset(&create_info, 0, sizeof(create_info));
12182
 
 
12183
 
  if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
12184
 
      OPTION_BIG_TABLES)
12185
 
    create_info.data_file_length= ~(uint64_t) 0;
12186
 
 
12187
 
  if ((error=mi_create(share->table_name.str, share->keys, &keydef,
12188
 
                       (uint) (*recinfo-start_recinfo),
12189
 
                       start_recinfo,
12190
 
                       share->uniques, &uniquedef,
12191
 
                       &create_info,
12192
 
                       HA_CREATE_TMP_TABLE)))
12193
 
  {
12194
 
    table->file->print_error(error,MYF(0));     /* purecov: inspected */
12195
 
    table->db_stat=0;
12196
 
    goto err;
12197
 
  }
12198
 
  status_var_increment(table->in_use->status_var.created_tmp_disk_tables);
12199
 
  share->db_record_offset= 1;
12200
 
  return(0);
12201
 
 err:
12202
 
  return(1);
12203
 
}
12204
 
 
12205
 
 
12206
 
void
12207
 
free_tmp_table(THD *thd, TABLE *entry)
12208
 
{
12209
 
  MEM_ROOT own_root= entry->mem_root;
12210
 
  const char *save_proc_info;
12211
 
 
12212
 
  save_proc_info=thd->proc_info;
12213
 
  thd_proc_info(thd, "removing tmp table");
12214
 
 
12215
 
  if (entry->file)
12216
 
  {
12217
 
    if (entry->db_stat)
12218
 
      entry->file->ha_drop_table(entry->s->table_name.str);
12219
 
    else
12220
 
      entry->file->ha_delete_table(entry->s->table_name.str);
12221
 
    delete entry->file;
12222
 
  }
12223
 
 
12224
 
  /* free blobs */
12225
 
  for (Field **ptr=entry->field ; *ptr ; ptr++)
12226
 
    (*ptr)->free();
12227
 
  free_io_cache(entry);
12228
 
 
12229
 
  if (entry->temp_pool_slot != MY_BIT_NONE)
12230
 
    bitmap_lock_clear_bit(&temp_pool, entry->temp_pool_slot);
12231
 
 
12232
 
  plugin_unlock(0, entry->s->db_plugin);
12233
 
 
12234
 
  free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
12235
 
  thd_proc_info(thd, save_proc_info);
12236
 
 
12237
 
  return;
12238
 
}
12239
 
 
12240
 
/**
12241
 
  If a HEAP table gets full, create a MyISAM table and copy all rows
12242
 
  to this.
12243
 
*/
12244
 
 
12245
 
bool create_myisam_from_heap(THD *thd, TABLE *table,
12246
 
                             MI_COLUMNDEF *start_recinfo,
12247
 
                             MI_COLUMNDEF **recinfo, 
12248
 
                             int error, bool ignore_last_dupp_key_error)
12249
 
{
12250
 
  TABLE new_table;
12251
 
  TABLE_SHARE share;
12252
 
  const char *save_proc_info;
12253
 
  int write_err;
12254
 
 
12255
 
  if (table->s->db_type() != heap_hton || 
12256
 
      error != HA_ERR_RECORD_FILE_FULL)
12257
 
  {
12258
 
    table->file->print_error(error,MYF(0));
12259
 
    return(1);
12260
 
  }
12261
 
  new_table= *table;
12262
 
  share= *table->s;
12263
 
  new_table.s= &share;
12264
 
  new_table.s->db_plugin= ha_lock_engine(thd, myisam_hton);
12265
 
  if (!(new_table.file= get_new_handler(&share, &new_table.mem_root,
12266
 
                                        new_table.s->db_type())))
12267
 
    return(1);                          // End of memory
12268
 
 
12269
 
  save_proc_info=thd->proc_info;
12270
 
  thd_proc_info(thd, "converting HEAP to MyISAM");
12271
 
 
12272
 
  if (create_myisam_tmp_table(&new_table, table->key_info, start_recinfo,
12273
 
                              recinfo, thd->lex->select_lex.options | 
12274
 
                                               thd->options))
12275
 
    goto err2;
12276
 
  if (open_tmp_table(&new_table))
12277
 
    goto err1;
12278
 
  if (table->file->indexes_are_disabled())
12279
 
    new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);
12280
 
  table->file->ha_index_or_rnd_end();
12281
 
  table->file->ha_rnd_init(1);
12282
 
  if (table->no_rows)
12283
 
  {
12284
 
    new_table.file->extra(HA_EXTRA_NO_ROWS);
12285
 
    new_table.no_rows=1;
12286
 
  }
12287
 
 
12288
 
#ifdef TO_BE_DONE_LATER_IN_4_1
12289
 
  /*
12290
 
    To use start_bulk_insert() (which is new in 4.1) we need to find
12291
 
    all places where a corresponding end_bulk_insert() should be put.
12292
 
  */
12293
 
  table->file->info(HA_STATUS_VARIABLE); /* update table->file->stats.records */
12294
 
  new_table.file->ha_start_bulk_insert(table->file->stats.records);
12295
 
#else
12296
 
  /* HA_EXTRA_WRITE_CACHE can stay until close, no need to disable it */
12297
 
  new_table.file->extra(HA_EXTRA_WRITE_CACHE);
12298
 
#endif
12299
 
 
12300
 
  /*
12301
 
    copy all old rows from heap table to MyISAM table
12302
 
    This is the only code that uses record[1] to read/write but this
12303
 
    is safe as this is a temporary MyISAM table without timestamp/autoincrement.
12304
 
  */
12305
 
  while (!table->file->rnd_next(new_table.record[1]))
12306
 
  {
12307
 
    write_err= new_table.file->ha_write_row(new_table.record[1]);
12308
 
    if (write_err)
12309
 
      goto err;
12310
 
  }
12311
 
  /* copy row that filled HEAP table */
12312
 
  if ((write_err=new_table.file->ha_write_row(table->record[0])))
12313
 
  {
12314
 
    if (new_table.file->is_fatal_error(write_err, HA_CHECK_DUP) ||
12315
 
        !ignore_last_dupp_key_error)
12316
 
      goto err;
12317
 
  }
12318
 
 
12319
 
  /* remove heap table and change to use myisam table */
12320
 
  (void) table->file->ha_rnd_end();
12321
 
  (void) table->file->close();                  // This deletes the table !
12322
 
  delete table->file;
12323
 
  table->file=0;
12324
 
  plugin_unlock(0, table->s->db_plugin);
12325
 
  share.db_plugin= my_plugin_lock(0, &share.db_plugin);
12326
 
  new_table.s= table->s;                       // Keep old share
12327
 
  *table= new_table;
12328
 
  *table->s= share;
12329
 
  
12330
 
  table->file->change_table_ptr(table, table->s);
12331
 
  table->use_all_columns();
12332
 
  if (save_proc_info)
12333
 
  {
12334
 
    const char *new_proc_info=
12335
 
      (!strcmp(save_proc_info,"Copying to tmp table") ?
12336
 
      "Copying to tmp table on disk" : save_proc_info);
12337
 
    thd_proc_info(thd, new_proc_info);
12338
 
  }
12339
 
  return(0);
12340
 
 
12341
 
 err:
12342
 
  table->file->print_error(write_err, MYF(0));
12343
 
  (void) table->file->ha_rnd_end();
12344
 
  (void) new_table.file->close();
12345
 
 err1:
12346
 
  new_table.file->ha_delete_table(new_table.s->table_name.str);
12347
 
 err2:
12348
 
  delete new_table.file;
12349
 
  thd_proc_info(thd, save_proc_info);
12350
 
  table->mem_root= new_table.mem_root;
12351
 
  return(1);
12352
 
}
12353
 
 
 
3201
        if (*const_item)
 
3202
          return left_item->eq(*const_item, 1);
 
3203
        *const_item=left_item;
 
3204
        return 1;
 
3205
      }
 
3206
    }
 
3207
  }
 
3208
  return 0;
 
3209
}
12354
3210
 
12355
3211
/**
12356
3212
  @details
12363
3219
  @return
12364
3220
    end_select function to use. This function can't fail.
12365
3221
*/
12366
 
 
12367
3222
Next_select_func setup_end_select_func(JOIN *join)
12368
3223
{
12369
 
  TABLE *table= join->tmp_table;
12370
 
  TMP_TABLE_PARAM *tmp_tbl= &join->tmp_table_param;
 
3224
  Table *table= join->tmp_table;
 
3225
  Tmp_Table_Param *tmp_tbl= &join->tmp_table_param;
12371
3226
  Next_select_func end_select;
12372
3227
 
12373
3228
  /* Set up select_end */
12374
3229
  if (table)
12375
3230
  {
12376
 
    if (table->group && tmp_tbl->sum_func_count && 
 
3231
    if (table->group && tmp_tbl->sum_func_count &&
12377
3232
        !tmp_tbl->precomputed_group_by)
12378
3233
    {
12379
3234
      if (table->s->keys)
12380
3235
      {
12381
 
        end_select=end_update;
 
3236
        end_select= end_update;
12382
3237
      }
12383
3238
      else
12384
3239
      {
12385
 
        end_select=end_unique_update;
 
3240
        end_select= end_unique_update;
12386
3241
      }
12387
3242
    }
12388
3243
    else if (join->sort_and_group && !tmp_tbl->precomputed_group_by)
12397
3252
        /*
12398
3253
          A preceding call to create_tmp_table in the case when loose
12399
3254
          index scan is used guarantees that
12400
 
          TMP_TABLE_PARAM::items_to_copy has enough space for the group
 
3255
          Tmp_Table_Param::items_to_copy has enough space for the group
12401
3256
          by functions. It is OK here to use memcpy since we copy
12402
3257
          Item_sum pointers into an array of Item pointers.
12403
3258
        */
12419
3274
  return end_select;
12420
3275
}
12421
3276
 
12422
 
 
12423
3277
/**
12424
3278
  Make a join of all tables and write it on socket or to table.
12425
3279
 
12430
3284
  @retval
12431
3285
    -1  if error should be sent
12432
3286
*/
12433
 
 
12434
 
static int
12435
 
do_select(JOIN *join,List<Item> *fields,TABLE *table)
 
3287
int do_select(JOIN *join, List<Item> *fields, Table *table)
12436
3288
{
12437
3289
  int rc= 0;
12438
3290
  enum_nested_loop_state error= NESTED_LOOP_OK;
12439
 
  JOIN_TAB *join_tab= NULL;
12440
 
  
 
3291
  JoinTable *join_tab= NULL;
 
3292
 
12441
3293
  join->tmp_table= table;                       /* Save for easy recursion */
12442
3294
  join->fields= fields;
12443
3295
 
12444
3296
  if (table)
12445
3297
  {
12446
 
    VOID(table->file->extra(HA_EXTRA_WRITE_CACHE));
12447
 
    empty_record(table);
 
3298
    table->cursor->extra(HA_EXTRA_WRITE_CACHE);
 
3299
    table->emptyRecord();
12448
3300
    if (table->group && join->tmp_table_param.sum_func_count &&
12449
 
        table->s->keys && !table->file->inited)
12450
 
      table->file->ha_index_init(0, 0);
 
3301
        table->s->keys && !table->cursor->inited)
 
3302
      table->cursor->ha_index_init(0, 0);
12451
3303
  }
12452
3304
  /* Set up select_end */
12453
3305
  Next_select_func end_select= setup_end_select_func(join);
12468
3320
    {
12469
3321
      error= (*end_select)(join, 0, 0);
12470
3322
      if (error == NESTED_LOOP_OK || error == NESTED_LOOP_QUERY_LIMIT)
12471
 
        error= (*end_select)(join, 0, 1);
 
3323
              error= (*end_select)(join, 0, 1);
12472
3324
 
12473
3325
      /*
12474
3326
        If we don't go through evaluate_join_record(), do the counting
12476
3328
        so we don't touch it here.
12477
3329
      */
12478
3330
      join->examined_rows++;
12479
 
      join->thd->row_count++;
 
3331
      join->session->row_count++;
12480
3332
      assert(join->examined_rows <= 1);
12481
3333
    }
12482
3334
    else if (join->send_row_on_empty_set())
12506
3358
    if (!table)                                 // If sending data to client
12507
3359
    {
12508
3360
      /*
12509
 
        The following will unlock all cursors if the command wasn't an
12510
 
        update command
 
3361
        The following will unlock all cursors if the command wasn't an
 
3362
        update command
12511
3363
      */
12512
3364
      join->join_free();                        // Unlock all cursors
12513
3365
      if (join->result->send_eof())
12514
 
        rc= 1;                                  // Don't send error
 
3366
        rc= 1;                                  // Don't send error
12515
3367
    }
12516
3368
  }
12517
3369
  else
12519
3371
  if (table)
12520
3372
  {
12521
3373
    int tmp, new_errno= 0;
12522
 
    if ((tmp=table->file->extra(HA_EXTRA_NO_CACHE)))
 
3374
    if ((tmp=table->cursor->extra(HA_EXTRA_NO_CACHE)))
12523
3375
    {
12524
3376
      new_errno= tmp;
12525
3377
    }
12526
 
    if ((tmp=table->file->ha_index_or_rnd_end()))
 
3378
    if ((tmp=table->cursor->ha_index_or_rnd_end()))
12527
3379
    {
12528
3380
      new_errno= tmp;
12529
3381
    }
12530
3382
    if (new_errno)
12531
 
      table->file->print_error(new_errno,MYF(0));
 
3383
      table->cursor->print_error(new_errno,MYF(0));
12532
3384
  }
12533
 
  return(join->thd->is_error() ? -1 : rc);
 
3385
  return(join->session->is_error() ? -1 : rc);
12534
3386
}
12535
3387
 
12536
 
 
12537
 
enum_nested_loop_state
12538
 
sub_select_cache(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)
 
3388
enum_nested_loop_state sub_select_cache(JOIN *join, JoinTable *join_tab, bool end_of_records)
12539
3389
{
12540
3390
  enum_nested_loop_state rc;
12541
3391
 
12546
3396
      rc= sub_select(join,join_tab,end_of_records);
12547
3397
    return rc;
12548
3398
  }
12549
 
  if (join->thd->killed)                // If aborted by user
 
3399
  if (join->session->killed)            // If aborted by user
12550
3400
  {
12551
 
    join->thd->send_kill_message();
12552
 
    return NESTED_LOOP_KILLED;                   /* purecov: inspected */
 
3401
    join->session->send_kill_message();
 
3402
    return NESTED_LOOP_KILLED;
12553
3403
  }
12554
3404
  if (join_tab->use_quick != 2 || test_if_quick_select(join_tab) <= 0)
12555
3405
  {
12556
 
    if (!store_record_in_cache(&join_tab->cache))
 
3406
    if (! store_record_in_cache(&join_tab->cache))
12557
3407
      return NESTED_LOOP_OK;                     // There is more room in cache
12558
3408
    return flush_cached_records(join,join_tab,false);
12559
3409
  }
12566
3416
/**
12567
3417
  Retrieve records ends with a given beginning from the result of a join.
12568
3418
 
12569
 
    For a given partial join record consisting of records from the tables 
 
3419
    For a given partial join record consisting of records from the tables
12570
3420
    preceding the table join_tab in the execution plan, the function
12571
3421
    retrieves all matching full records from the result set and
12572
 
    send them to the result set stream. 
 
3422
    send them to the result set stream.
12573
3423
 
12574
3424
  @note
12575
3425
    The function effectively implements the  final (n-k) nested loops
12609
3459
    first row with t3.a=t1.a has been encountered.
12610
3460
    Thus, the second predicate P2 is supplied with a guarded value that are
12611
3461
    stored in the field 'found' of the first inner table for the outer join
12612
 
    (table t2). When the first row with t3.a=t1.a for the  current row 
 
3462
    (table t2). When the first row with t3.a=t1.a for the  current row
12613
3463
    of table t1  appears, the value becomes true. For now on the predicate
12614
3464
    is evaluated immediately after the row of table t2 has been read.
12615
3465
    When the first row with t3.a=t1.a has been encountered all
12617
3467
    Only when all of them are true the row is sent to the output stream.
12618
3468
    If not, the function returns to the lowest nest level that has a false
12619
3469
    attached condition.
12620
 
    The predicates from on expressions are also pushed down. If in the 
 
3470
    The predicates from on expressions are also pushed down. If in the
12621
3471
    the above example the on expression were (t3.a=t1.a AND t2.a=t1.a),
12622
3472
    then t1.a=t2.a would be pushed down to table t2, and without any
12623
3473
    guard.
12627
3477
    is complemented by nulls  for t2 and t3. Then the pushed down predicates
12628
3478
    are checked for the composed row almost in the same way as it had
12629
3479
    been done for the first row with a match. The only difference is
12630
 
    the predicates from on expressions are not checked. 
 
3480
    the predicates from on expressions are not checked.
12631
3481
 
12632
3482
  @par
12633
3483
  @b IMPLEMENTATION
12643
3493
    and a pointer to a guarding boolean variable.
12644
3494
    When the value of the guard variable is true the value of the object
12645
3495
    is the same as the value of the predicate, otherwise it's just returns
12646
 
    true. 
12647
 
    To carry out a return to a nested loop level of join table t the pointer 
 
3496
    true.
 
3497
    To carry out a return to a nested loop level of join table t the pointer
12648
3498
    to t is remembered in the field 'return_tab' of the join structure.
12649
3499
    Consider the following query:
12650
3500
    @code
12661
3511
    t5.a=t3.a is found, the pushed down predicate t4.b=2 OR t4.b IS NULL
12662
3512
    becomes 'activated', as well the predicate t4.a=t2.a. But
12663
3513
    the predicate (t2.b=5 OR t2.b IS NULL) can not be checked until
12664
 
    t4.a=t2.a becomes true. 
 
3514
    t4.a=t2.a becomes true.
12665
3515
    In order not to re-evaluate the predicates that were already evaluated
12666
3516
    as attached pushed down predicates, a pointer to the the first
12667
3517
    most inner unmatched table is maintained in join_tab->first_unmatched.
12668
3518
    Thus, when the first row from t5 with t5.a=t3.a is found
12669
 
    this pointer for t5 is changed from t4 to t2.             
 
3519
    this pointer for t5 is changed from t4 to t2.
12670
3520
 
12671
3521
    @par
12672
3522
    @b STRUCTURE @b NOTES
12677
3527
  @param join      pointer to the structure providing all context info for
12678
3528
                   the query
12679
3529
  @param join_tab  the first next table of the execution plan to be retrieved
12680
 
  @param end_records  true when we need to perform final steps of retrival   
 
3530
  @param end_records  true when we need to perform final steps of retrival
12681
3531
 
12682
3532
  @return
12683
3533
    return one of enum_nested_loop_state, except NESTED_LOOP_NO_MORE_ROWS.
12684
3534
*/
12685
 
int do_sj_reset(SJ_TMP_TABLE *sj_tbl);
12686
 
 
12687
 
enum_nested_loop_state
12688
 
sub_select(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)
 
3535
enum_nested_loop_state sub_select(JOIN *join, JoinTable *join_tab, bool end_of_records)
12689
3536
{
12690
3537
  join_tab->table->null_row=0;
12691
3538
  if (end_of_records)
12695
3542
  enum_nested_loop_state rc;
12696
3543
  READ_RECORD *info= &join_tab->read_record;
12697
3544
 
12698
 
  if (join_tab->flush_weedout_table)
12699
 
  {
12700
 
    do_sj_reset(join_tab->flush_weedout_table);
12701
 
  }
12702
 
 
12703
3545
  if (join->resume_nested_loop)
12704
3546
  {
12705
3547
    /* If not the last table, plunge down the nested loop */
12726
3568
      /* Set first_unmatched for the last inner table of this group */
12727
3569
      join_tab->last_inner->first_unmatched= join_tab;
12728
3570
    }
12729
 
    join->thd->row_count= 0;
 
3571
    join->session->row_count= 0;
12730
3572
 
12731
3573
    error= (*join_tab->read_first_record)(join_tab);
12732
3574
    rc= evaluate_join_record(join, join_tab, error);
12733
3575
  }
12734
 
  
12735
 
  /* 
12736
 
    Note: psergey has added the 2nd part of the following condition; the 
 
3576
 
 
3577
  /*
 
3578
    Note: psergey has added the 2nd part of the following condition; the
12737
3579
    change should probably be made in 5.1, too.
12738
3580
  */
12739
3581
  while (rc == NESTED_LOOP_OK && join->return_tab >= join_tab)
12751
3593
  return rc;
12752
3594
}
12753
3595
 
12754
 
 
12755
 
 
12756
 
 
12757
 
/*
12758
 
  SemiJoinDuplicateElimination: Weed out duplicate row combinations
12759
 
 
12760
 
  SYNPOSIS
12761
 
    do_sj_dups_weedout()
12762
 
      
12763
 
  RETURN
12764
 
    -1  Error
12765
 
    1   The row combination is a duplicate (discard it)
12766
 
    0   The row combination is not a duplicate (continue)
12767
 
*/
12768
 
 
12769
 
int do_sj_dups_weedout(THD *thd, SJ_TMP_TABLE *sjtbl) 
12770
 
{
12771
 
  int error;
12772
 
  SJ_TMP_TABLE::TAB *tab= sjtbl->tabs;
12773
 
  SJ_TMP_TABLE::TAB *tab_end= sjtbl->tabs_end;
12774
 
  uchar *ptr= sjtbl->tmp_table->record[0] + 1;
12775
 
  uchar *nulls_ptr= ptr;
12776
 
  
12777
 
  /* Put the the rowids tuple into table->record[0]: */
12778
 
 
12779
 
  // 1. Store the length 
12780
 
  if (((Field_varstring*)(sjtbl->tmp_table->field[0]))->length_bytes == 1)
12781
 
  {
12782
 
    *ptr= (uchar)(sjtbl->rowid_len + sjtbl->null_bytes);
12783
 
    ptr++;
12784
 
  }
12785
 
  else
12786
 
  {
12787
 
    int2store(ptr, sjtbl->rowid_len + sjtbl->null_bytes);
12788
 
    ptr += 2;
12789
 
  }
12790
 
 
12791
 
  // 2. Zero the null bytes 
12792
 
  if (sjtbl->null_bytes)
12793
 
  {
12794
 
    memset(ptr, 0, sjtbl->null_bytes);
12795
 
    ptr += sjtbl->null_bytes; 
12796
 
  }
12797
 
 
12798
 
  // 3. Put the rowids
12799
 
  for (uint i=0; tab != tab_end; tab++, i++)
12800
 
  {
12801
 
    handler *h= tab->join_tab->table->file;
12802
 
    if (tab->join_tab->table->maybe_null && tab->join_tab->table->null_row)
12803
 
    {
12804
 
      /* It's a NULL-complemented row */
12805
 
      *(nulls_ptr + tab->null_byte) |= tab->null_bit;
12806
 
      memset(ptr + tab->rowid_offset, 0, h->ref_length);
12807
 
    }
12808
 
    else
12809
 
    {
12810
 
      /* Copy the rowid value */
12811
 
      if (tab->join_tab->rowid_keep_flags & JOIN_TAB::CALL_POSITION)
12812
 
        h->position(tab->join_tab->table->record[0]);
12813
 
      memcpy(ptr + tab->rowid_offset, h->ref, h->ref_length);
12814
 
    }
12815
 
  }
12816
 
 
12817
 
  error= sjtbl->tmp_table->file->ha_write_row(sjtbl->tmp_table->record[0]);
12818
 
  if (error)
12819
 
  {
12820
 
    /* create_myisam_from_heap will generate error if needed */
12821
 
    if (sjtbl->tmp_table->file->is_fatal_error(error, HA_CHECK_DUP) &&
12822
 
        create_myisam_from_heap(thd, sjtbl->tmp_table, sjtbl->start_recinfo, 
12823
 
                                &sjtbl->recinfo, error, 1))
12824
 
      return -1;
12825
 
    //return (error == HA_ERR_FOUND_DUPP_KEY || error== HA_ERR_FOUND_DUPP_UNIQUE) ? 1: -1;
12826
 
    return 1;
12827
 
  }
12828
 
  return 0;
12829
 
}
12830
 
 
12831
 
 
12832
 
/*
12833
 
  SemiJoinDuplicateElimination: Reset the temporary table
12834
 
*/
12835
 
 
12836
 
int do_sj_reset(SJ_TMP_TABLE *sj_tbl)
12837
 
{
12838
 
  if (sj_tbl->tmp_table)
12839
 
    return sj_tbl->tmp_table->file->ha_delete_all_rows();
12840
 
  return 0;
12841
 
}
12842
 
 
12843
 
/*
12844
 
  Process one record of the nested loop join.
12845
 
 
12846
 
    This function will evaluate parts of WHERE/ON clauses that are
12847
 
    applicable to the partial record on hand and in case of success
12848
 
    submit this record to the next level of the nested loop.
12849
 
*/
12850
 
 
12851
 
static enum_nested_loop_state
12852
 
evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,
12853
 
                     int error)
12854
 
{
12855
 
  bool not_used_in_distinct=join_tab->not_used_in_distinct;
12856
 
  ha_rows found_records=join->found_records;
12857
 
  COND *select_cond= join_tab->select_cond;
12858
 
 
12859
 
  if (error > 0 || (join->thd->is_error()))     // Fatal error
12860
 
    return NESTED_LOOP_ERROR;
12861
 
  if (error < 0)
12862
 
    return NESTED_LOOP_NO_MORE_ROWS;
12863
 
  if (join->thd->killed)                        // Aborted by user
12864
 
  {
12865
 
    join->thd->send_kill_message();
12866
 
    return NESTED_LOOP_KILLED;               /* purecov: inspected */
12867
 
  }
12868
 
  if (!select_cond || select_cond->val_int())
12869
 
  {
12870
 
    /*
12871
 
      There is no select condition or the attached pushed down
12872
 
      condition is true => a match is found.
12873
 
    */
12874
 
    bool found= 1;
12875
 
    while (join_tab->first_unmatched && found)
12876
 
    {
12877
 
      /*
12878
 
        The while condition is always false if join_tab is not
12879
 
        the last inner join table of an outer join operation.
12880
 
      */
12881
 
      JOIN_TAB *first_unmatched= join_tab->first_unmatched;
12882
 
      /*
12883
 
        Mark that a match for current outer table is found.
12884
 
        This activates push down conditional predicates attached
12885
 
        to the all inner tables of the outer join.
12886
 
      */
12887
 
      first_unmatched->found= 1;
12888
 
      for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)
12889
 
      {
12890
 
        if (tab->table->reginfo.not_exists_optimize)
12891
 
          return NESTED_LOOP_NO_MORE_ROWS;
12892
 
        /* Check all predicates that has just been activated. */
12893
 
        /*
12894
 
          Actually all predicates non-guarded by first_unmatched->found
12895
 
          will be re-evaluated again. It could be fixed, but, probably,
12896
 
          it's not worth doing now.
12897
 
        */
12898
 
        if (tab->select_cond && !tab->select_cond->val_int())
12899
 
        {
12900
 
          /* The condition attached to table tab is false */
12901
 
          if (tab == join_tab)
12902
 
            found= 0;
12903
 
          else
12904
 
          {
12905
 
            /*
12906
 
              Set a return point if rejected predicate is attached
12907
 
              not to the last table of the current nest level.
12908
 
            */
12909
 
            join->return_tab= tab;
12910
 
            return NESTED_LOOP_OK;
12911
 
          }
12912
 
        }
12913
 
      }
12914
 
      /*
12915
 
        Check whether join_tab is not the last inner table
12916
 
        for another embedding outer join.
12917
 
      */
12918
 
      if ((first_unmatched= first_unmatched->first_upper) &&
12919
 
          first_unmatched->last_inner != join_tab)
12920
 
        first_unmatched= 0;
12921
 
      join_tab->first_unmatched= first_unmatched;
12922
 
    }
12923
 
 
12924
 
    JOIN_TAB *return_tab= join->return_tab;
12925
 
    join_tab->found_match= true;
12926
 
    if (join_tab->check_weed_out_table)
12927
 
    {
12928
 
      int res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table);
12929
 
      if (res == -1)
12930
 
        return NESTED_LOOP_ERROR;
12931
 
      if (res == 1)
12932
 
        return NESTED_LOOP_OK;
12933
 
    }
12934
 
    else if (join_tab->do_firstmatch)
12935
 
    {
12936
 
      /* 
12937
 
        We should return to the join_tab->do_firstmatch after we have 
12938
 
        enumerated all the suffixes for current prefix row combination
12939
 
      */
12940
 
      return_tab= join_tab->do_firstmatch;
12941
 
    }
12942
 
 
12943
 
    /*
12944
 
      It was not just a return to lower loop level when one
12945
 
      of the newly activated predicates is evaluated as false
12946
 
      (See above join->return_tab= tab).
12947
 
    */
12948
 
    join->examined_rows++;
12949
 
    join->thd->row_count++;
12950
 
 
12951
 
    if (found)
12952
 
    {
12953
 
      enum enum_nested_loop_state rc;
12954
 
      /* A match from join_tab is found for the current partial join. */
12955
 
      rc= (*join_tab->next_select)(join, join_tab+1, 0);
12956
 
      if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)
12957
 
        return rc;
12958
 
      if (return_tab < join->return_tab)
12959
 
        join->return_tab= return_tab;
12960
 
 
12961
 
      if (join->return_tab < join_tab)
12962
 
        return NESTED_LOOP_OK;
12963
 
      /*
12964
 
        Test if this was a SELECT DISTINCT query on a table that
12965
 
        was not in the field list;  In this case we can abort if
12966
 
        we found a row, as no new rows can be added to the result.
12967
 
      */
12968
 
      if (not_used_in_distinct && found_records != join->found_records)
12969
 
        return NESTED_LOOP_NO_MORE_ROWS;
12970
 
    }
12971
 
    else
12972
 
      join_tab->read_record.file->unlock_row();
12973
 
  }
12974
 
  else
12975
 
  {
12976
 
    /*
12977
 
      The condition pushed down to the table join_tab rejects all rows
12978
 
      with the beginning coinciding with the current partial join.
12979
 
    */
12980
 
    join->examined_rows++;
12981
 
    join->thd->row_count++;
12982
 
    join_tab->read_record.file->unlock_row();
12983
 
  }
12984
 
  return NESTED_LOOP_OK;
12985
 
}
12986
 
 
12987
 
 
12988
 
/**
12989
 
 
12990
 
  @details
12991
 
    Construct a NULL complimented partial join record and feed it to the next
12992
 
    level of the nested loop. This function is used in case we have
12993
 
    an OUTER join and no matching record was found.
12994
 
*/
12995
 
 
12996
 
static enum_nested_loop_state
12997
 
evaluate_null_complemented_join_record(JOIN *join, JOIN_TAB *join_tab)
12998
 
{
12999
 
  /*
13000
 
    The table join_tab is the first inner table of a outer join operation
13001
 
    and no matches has been found for the current outer row.
13002
 
  */
13003
 
  JOIN_TAB *last_inner_tab= join_tab->last_inner;
13004
 
  /* Cache variables for faster loop */
13005
 
  COND *select_cond;
13006
 
  for ( ; join_tab <= last_inner_tab ; join_tab++)
13007
 
  {
13008
 
    /* Change the the values of guard predicate variables. */
13009
 
    join_tab->found= 1;
13010
 
    join_tab->not_null_compl= 0;
13011
 
    /* The outer row is complemented by nulls for each inner tables */
13012
 
    restore_record(join_tab->table,s->default_values);  // Make empty record
13013
 
    mark_as_null_row(join_tab->table);       // For group by without error
13014
 
    select_cond= join_tab->select_cond;
13015
 
    /* Check all attached conditions for inner table rows. */
13016
 
    if (select_cond && !select_cond->val_int())
13017
 
      return NESTED_LOOP_OK;
13018
 
  }
13019
 
  join_tab--;
13020
 
  /*
13021
 
    The row complemented by nulls might be the first row
13022
 
    of embedding outer joins.
13023
 
    If so, perform the same actions as in the code
13024
 
    for the first regular outer join row above.
13025
 
  */
13026
 
  for ( ; ; )
13027
 
  {
13028
 
    JOIN_TAB *first_unmatched= join_tab->first_unmatched;
13029
 
    if ((first_unmatched= first_unmatched->first_upper) &&
13030
 
        first_unmatched->last_inner != join_tab)
13031
 
      first_unmatched= 0;
13032
 
    join_tab->first_unmatched= first_unmatched;
13033
 
    if (!first_unmatched)
13034
 
      break;
13035
 
    first_unmatched->found= 1;
13036
 
    for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)
13037
 
    {
13038
 
      if (tab->select_cond && !tab->select_cond->val_int())
13039
 
      {
13040
 
        join->return_tab= tab;
13041
 
        return NESTED_LOOP_OK;
13042
 
      }
13043
 
    }
13044
 
  }
13045
 
  /*
13046
 
    The row complemented by nulls satisfies all conditions
13047
 
    attached to inner tables.
13048
 
    Send the row complemented by nulls to be joined with the
13049
 
    remaining tables.
13050
 
  */
13051
 
  return (*join_tab->next_select)(join, join_tab+1, 0);
13052
 
}
13053
 
 
13054
 
 
13055
 
static enum_nested_loop_state
13056
 
flush_cached_records(JOIN *join,JOIN_TAB *join_tab,bool skip_last)
13057
 
{
13058
 
  enum_nested_loop_state rc= NESTED_LOOP_OK;
13059
 
  int error;
13060
 
  READ_RECORD *info;
13061
 
 
13062
 
  join_tab->table->null_row= 0;
13063
 
  if (!join_tab->cache.records)
13064
 
    return NESTED_LOOP_OK;                      /* Nothing to do */
13065
 
  if (skip_last)
13066
 
    (void) store_record_in_cache(&join_tab->cache); // Must save this for later
13067
 
  if (join_tab->use_quick == 2)
13068
 
  {
13069
 
    if (join_tab->select->quick)
13070
 
    {                                   /* Used quick select last. reset it */
13071
 
      delete join_tab->select->quick;
13072
 
      join_tab->select->quick=0;
13073
 
    }
13074
 
  }
13075
 
 /* read through all records */
13076
 
  if ((error=join_init_read_record(join_tab)))
13077
 
  {
13078
 
    reset_cache_write(&join_tab->cache);
13079
 
    return error < 0 ? NESTED_LOOP_NO_MORE_ROWS: NESTED_LOOP_ERROR;
13080
 
  }
13081
 
 
13082
 
  for (JOIN_TAB *tmp=join->join_tab; tmp != join_tab ; tmp++)
13083
 
  {
13084
 
    tmp->status=tmp->table->status;
13085
 
    tmp->table->status=0;
13086
 
  }
13087
 
 
13088
 
  info= &join_tab->read_record;
13089
 
  do
13090
 
  {
13091
 
    if (join->thd->killed)
13092
 
    {
13093
 
      join->thd->send_kill_message();
13094
 
      return NESTED_LOOP_KILLED; // Aborted by user /* purecov: inspected */
13095
 
    }
13096
 
    SQL_SELECT *select=join_tab->select;
13097
 
    if (rc == NESTED_LOOP_OK &&
13098
 
        (!join_tab->cache.select || !join_tab->cache.select->skip_record()))
13099
 
    {
13100
 
      uint i;
13101
 
      reset_cache_read(&join_tab->cache);
13102
 
      for (i=(join_tab->cache.records- (skip_last ? 1 : 0)) ; i-- > 0 ;)
13103
 
      {
13104
 
        read_cached_record(join_tab);
13105
 
        if (!select || !select->skip_record())
13106
 
        {
13107
 
          int res= 0;
13108
 
          if (!join_tab->check_weed_out_table || 
13109
 
              !(res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table)))
13110
 
          {
13111
 
            rc= (join_tab->next_select)(join,join_tab+1,0);
13112
 
            if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)
13113
 
            {
13114
 
              reset_cache_write(&join_tab->cache);
13115
 
              return rc;
13116
 
            }
13117
 
          }
13118
 
          if (res == -1)
13119
 
            return NESTED_LOOP_ERROR;
13120
 
        }
13121
 
      }
13122
 
    }
13123
 
  } while (!(error=info->read_record(info)));
13124
 
 
13125
 
  if (skip_last)
13126
 
    read_cached_record(join_tab);               // Restore current record
13127
 
  reset_cache_write(&join_tab->cache);
13128
 
  if (error > 0)                                // Fatal error
13129
 
    return NESTED_LOOP_ERROR;                   /* purecov: inspected */
13130
 
  for (JOIN_TAB *tmp2=join->join_tab; tmp2 != join_tab ; tmp2++)
13131
 
    tmp2->table->status=tmp2->status;
13132
 
  return NESTED_LOOP_OK;
13133
 
}
13134
 
 
13135
 
 
13136
 
/*****************************************************************************
13137
 
  The different ways to read a record
13138
 
  Returns -1 if row was not found, 0 if row was found and 1 on errors
13139
 
*****************************************************************************/
13140
 
 
13141
 
/** Help function when we get some an error from the table handler. */
13142
 
 
13143
 
int report_error(TABLE *table, int error)
13144
 
{
13145
 
  if (error == HA_ERR_END_OF_FILE || error == HA_ERR_KEY_NOT_FOUND)
13146
 
  {
13147
 
    table->status= STATUS_GARBAGE;
13148
 
    return -1;                                  // key not found; ok
13149
 
  }
13150
 
  /*
13151
 
    Locking reads can legally return also these errors, do not
13152
 
    print them to the .err log
13153
 
  */
13154
 
  if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT)
13155
 
    sql_print_error("Got error %d when reading table '%s'",
13156
 
                    error, table->s->path.str);
13157
 
  table->file->print_error(error,MYF(0));
13158
 
  return 1;
13159
 
}
13160
 
 
13161
 
 
13162
 
int safe_index_read(JOIN_TAB *tab)
13163
 
{
13164
 
  int error;
13165
 
  TABLE *table= tab->table;
13166
 
  if ((error=table->file->index_read_map(table->record[0],
 
3596
int safe_index_read(JoinTable *tab)
 
3597
{
 
3598
  int error;
 
3599
  Table *table= tab->table;
 
3600
  if ((error=table->cursor->index_read_map(table->record[0],
13167
3601
                                         tab->ref.key_buff,
13168
3602
                                         make_prev_keypart_map(tab->ref.key_parts),
13169
3603
                                         HA_READ_KEY_EXACT)))
13170
 
    return report_error(table, error);
 
3604
    return table->report_error(error);
13171
3605
  return 0;
13172
3606
}
13173
3607
 
13174
 
 
13175
 
static int
13176
 
join_read_const_table(JOIN_TAB *tab, POSITION *pos)
 
3608
int join_read_const_table(JoinTable *tab, optimizer::Position *pos)
13177
3609
{
13178
3610
  int error;
13179
 
  TABLE *table=tab->table;
 
3611
  Table *table=tab->table;
13180
3612
  table->const_table=1;
13181
3613
  table->null_row=0;
13182
3614
  table->status=STATUS_NO_RECORD;
13183
 
  
13184
 
  if (tab->type == JT_SYSTEM)
 
3615
 
 
3616
  if (tab->type == AM_SYSTEM)
13185
3617
  {
13186
3618
    if ((error=join_read_system(tab)))
13187
3619
    {                                           // Info for DESCRIBE
13188
3620
      tab->info="const row not found";
13189
3621
      /* Mark for EXPLAIN that the row was not found */
13190
 
      pos->records_read=0.0;
13191
 
      pos->ref_depend_map= 0;
13192
 
      if (!table->maybe_null || error > 0)
13193
 
        return(error);
 
3622
      pos->setFanout(0.0);
 
3623
      pos->clearRefDependMap();
 
3624
      if (! table->maybe_null || error > 0)
 
3625
        return(error);
13194
3626
    }
13195
3627
  }
13196
3628
  else
13197
3629
  {
13198
 
    if (!table->key_read && table->covering_keys.is_set(tab->ref.key) &&
13199
 
        !table->no_keyread &&
13200
 
        (int) table->reginfo.lock_type <= (int) TL_READ_HIGH_PRIORITY)
 
3630
    if (! table->key_read && 
 
3631
        table->covering_keys.test(tab->ref.key) && 
 
3632
        ! table->no_keyread &&
 
3633
        (int) table->reginfo.lock_type <= (int) TL_READ_WITH_SHARED_LOCKS)
13201
3634
    {
13202
3635
      table->key_read=1;
13203
 
      table->file->extra(HA_EXTRA_KEYREAD);
 
3636
      table->cursor->extra(HA_EXTRA_KEYREAD);
13204
3637
      tab->index= tab->ref.key;
13205
3638
    }
13206
3639
    error=join_read_const(tab);
13207
3640
    if (table->key_read)
13208
3641
    {
13209
3642
      table->key_read=0;
13210
 
      table->file->extra(HA_EXTRA_NO_KEYREAD);
 
3643
      table->cursor->extra(HA_EXTRA_NO_KEYREAD);
13211
3644
    }
13212
3645
    if (error)
13213
3646
    {
13214
3647
      tab->info="unique row not found";
13215
3648
      /* Mark for EXPLAIN that the row was not found */
13216
 
      pos->records_read=0.0;
13217
 
      pos->ref_depend_map= 0;
 
3649
      pos->setFanout(0.0);
 
3650
      pos->clearRefDependMap();
13218
3651
      if (!table->maybe_null || error > 0)
13219
 
        return(error);
 
3652
        return(error);
13220
3653
    }
13221
3654
  }
13222
3655
  if (*tab->on_expr_ref && !table->null_row)
13223
3656
  {
13224
3657
    if ((table->null_row= test((*tab->on_expr_ref)->val_int() == 0)))
13225
 
      mark_as_null_row(table);  
 
3658
      table->mark_as_null_row();
13226
3659
  }
13227
3660
  if (!table->null_row)
13228
3661
    table->maybe_null=0;
13231
3664
  JOIN *join= tab->join;
13232
3665
  if (join->conds)
13233
3666
    update_const_equal_items(join->conds, tab);
13234
 
  TABLE_LIST *tbl;
 
3667
  TableList *tbl;
13235
3668
  for (tbl= join->select_lex->leaf_tables; tbl; tbl= tbl->next_leaf)
13236
3669
  {
13237
 
    TABLE_LIST *embedded;
13238
 
    TABLE_LIST *embedding= tbl;
 
3670
    TableList *embedded;
 
3671
    TableList *embedding= tbl;
13239
3672
    do
13240
3673
    {
13241
3674
      embedded= embedding;
13250
3683
  return(0);
13251
3684
}
13252
3685
 
13253
 
 
13254
 
static int
13255
 
join_read_system(JOIN_TAB *tab)
 
3686
int join_read_system(JoinTable *tab)
13256
3687
{
13257
 
  TABLE *table= tab->table;
 
3688
  Table *table= tab->table;
13258
3689
  int error;
13259
3690
  if (table->status & STATUS_GARBAGE)           // If first read
13260
3691
  {
13261
 
    if ((error=table->file->read_first_row(table->record[0],
 
3692
    if ((error=table->cursor->read_first_row(table->record[0],
13262
3693
                                           table->s->primary_key)))
13263
3694
    {
13264
3695
      if (error != HA_ERR_END_OF_FILE)
13265
 
        return report_error(table, error);
13266
 
      mark_as_null_row(tab->table);
13267
 
      empty_record(table);                      // Make empty record
 
3696
        return table->report_error(error);
 
3697
      tab->table->mark_as_null_row();
 
3698
      table->emptyRecord();                     // Make empty record
13268
3699
      return -1;
13269
3700
    }
13270
 
    store_record(table,record[1]);
 
3701
    table->storeRecord();
13271
3702
  }
13272
3703
  else if (!table->status)                      // Only happens with left join
13273
 
    restore_record(table,record[1]);                    // restore old record
 
3704
    table->restoreRecord();                     // restore old record
13274
3705
  table->null_row=0;
13275
3706
  return table->status ? -1 : 0;
13276
3707
}
13277
3708
 
13278
 
 
13279
3709
/**
13280
3710
  Read a (constant) table when there is at most one matching row.
13281
3711
 
13288
3718
  @retval
13289
3719
    1   Got an error (other than row not found) during read
13290
3720
*/
13291
 
 
13292
 
static int
13293
 
join_read_const(JOIN_TAB *tab)
 
3721
int join_read_const(JoinTable *tab)
13294
3722
{
13295
3723
  int error;
13296
 
  TABLE *table= tab->table;
 
3724
  Table *table= tab->table;
13297
3725
  if (table->status & STATUS_GARBAGE)           // If first read
13298
3726
  {
13299
3727
    table->status= 0;
13300
 
    if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))
13301
 
      error=HA_ERR_KEY_NOT_FOUND;
 
3728
    if (cp_buffer_from_ref(tab->join->session, &tab->ref))
 
3729
      error= HA_ERR_KEY_NOT_FOUND;
13302
3730
    else
13303
3731
    {
13304
 
      error=table->file->index_read_idx_map(table->record[0],tab->ref.key,
13305
 
                                            (uchar*) tab->ref.key_buff,
 
3732
      error=table->cursor->index_read_idx_map(table->record[0],tab->ref.key,
 
3733
                                            (unsigned char*) tab->ref.key_buff,
13306
3734
                                            make_prev_keypart_map(tab->ref.key_parts),
13307
3735
                                            HA_READ_KEY_EXACT);
13308
3736
    }
13309
3737
    if (error)
13310
3738
    {
13311
3739
      table->status= STATUS_NOT_FOUND;
13312
 
      mark_as_null_row(tab->table);
13313
 
      empty_record(table);
 
3740
      tab->table->mark_as_null_row();
 
3741
      table->emptyRecord();
13314
3742
      if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
13315
 
        return report_error(table, error);
 
3743
        return table->report_error(error);
13316
3744
      return -1;
13317
3745
    }
13318
 
    store_record(table,record[1]);
 
3746
    table->storeRecord();
13319
3747
  }
13320
3748
  else if (!(table->status & ~STATUS_NULL_ROW)) // Only happens with left join
13321
3749
  {
13322
3750
    table->status=0;
13323
 
    restore_record(table,record[1]);                    // restore old record
 
3751
    table->restoreRecord();                     // restore old record
13324
3752
  }
13325
3753
  table->null_row=0;
13326
3754
  return table->status ? -1 : 0;
13327
3755
}
13328
3756
 
13329
 
 
13330
3757
/*
13331
3758
  eq_ref access method implementation: "read_first" function
13332
3759
 
13333
3760
  SYNOPSIS
13334
3761
    join_read_key()
13335
 
      tab  JOIN_TAB of the accessed table
 
3762
      tab  JoinTable of the accessed table
13336
3763
 
13337
3764
  DESCRIPTION
13338
3765
    This is "read_fist" function for the "ref" access method. The difference
13340
3767
 
13341
3768
  RETURN
13342
3769
    0  - Ok
13343
 
   -1  - Row not found 
 
3770
   -1  - Row not found
13344
3771
    1  - Error
13345
3772
*/
13346
 
 
13347
 
static int
13348
 
join_read_key(JOIN_TAB *tab)
 
3773
int join_read_key(JoinTable *tab)
13349
3774
{
13350
3775
  int error;
13351
 
  TABLE *table= tab->table;
 
3776
  Table *table= tab->table;
13352
3777
 
13353
 
  if (!table->file->inited)
 
3778
  if (!table->cursor->inited)
13354
3779
  {
13355
 
    table->file->ha_index_init(tab->ref.key, tab->sorted);
 
3780
    table->cursor->ha_index_init(tab->ref.key, tab->sorted);
13356
3781
  }
13357
3782
 
13358
3783
  /* TODO: Why don't we do "Late NULLs Filtering" here? */
13364
3789
      table->status=STATUS_NOT_FOUND;
13365
3790
      return -1;
13366
3791
    }
13367
 
    error=table->file->index_read_map(table->record[0],
 
3792
    error=table->cursor->index_read_map(table->record[0],
13368
3793
                                      tab->ref.key_buff,
13369
3794
                                      make_prev_keypart_map(tab->ref.key_parts),
13370
3795
                                      HA_READ_KEY_EXACT);
13371
3796
    if (error && error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
13372
 
      return report_error(table, error);
 
3797
      return table->report_error(error);
13373
3798
  }
13374
3799
  table->null_row=0;
13375
3800
  return table->status ? -1 : 0;
13376
3801
}
13377
3802
 
13378
 
 
13379
3803
/*
13380
3804
  ref access method implementation: "read_first" function
13381
3805
 
13382
3806
  SYNOPSIS
13383
3807
    join_read_always_key()
13384
 
      tab  JOIN_TAB of the accessed table
 
3808
      tab  JoinTable of the accessed table
13385
3809
 
13386
3810
  DESCRIPTION
13387
 
    This is "read_fist" function for the "ref" access method.
13388
 
   
 
3811
    This is "read_first" function for the "ref" access method.
 
3812
 
13389
3813
    The functon must leave the index initialized when it returns.
13390
3814
    ref_or_null access implementation depends on that.
13391
3815
 
13392
3816
  RETURN
13393
3817
    0  - Ok
13394
 
   -1  - Row not found 
 
3818
   -1  - Row not found
13395
3819
    1  - Error
13396
3820
*/
13397
 
 
13398
 
static int
13399
 
join_read_always_key(JOIN_TAB *tab)
 
3821
int join_read_always_key(JoinTable *tab)
13400
3822
{
13401
3823
  int error;
13402
 
  TABLE *table= tab->table;
 
3824
  Table *table= tab->table;
13403
3825
 
13404
3826
  /* Initialize the index first */
13405
 
  if (!table->file->inited)
13406
 
    table->file->ha_index_init(tab->ref.key, tab->sorted);
13407
 
 
 
3827
  if (!table->cursor->inited)
 
3828
    table->cursor->ha_index_init(tab->ref.key, tab->sorted);
 
3829
 
13408
3830
  /* Perform "Late NULLs Filtering" (see internals manual for explanations) */
13409
 
  for (uint i= 0 ; i < tab->ref.key_parts ; i++)
 
3831
  for (uint32_t i= 0 ; i < tab->ref.key_parts ; i++)
13410
3832
  {
13411
3833
    if ((tab->ref.null_rejecting & 1 << i) && tab->ref.items[i]->is_null())
13412
3834
        return -1;
13413
3835
  }
13414
3836
 
13415
 
  if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))
 
3837
  if (cp_buffer_from_ref(tab->join->session, &tab->ref))
13416
3838
    return -1;
13417
 
  if ((error=table->file->index_read_map(table->record[0],
 
3839
  if ((error=table->cursor->index_read_map(table->record[0],
13418
3840
                                         tab->ref.key_buff,
13419
3841
                                         make_prev_keypart_map(tab->ref.key_parts),
13420
3842
                                         HA_READ_KEY_EXACT)))
13421
3843
  {
13422
3844
    if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
13423
 
      return report_error(table, error);
13424
 
    return -1; /* purecov: inspected */
 
3845
      return table->report_error(error);
 
3846
    return -1;
13425
3847
  }
 
3848
 
13426
3849
  return 0;
13427
3850
}
13428
3851
 
13429
 
 
13430
3852
/**
13431
 
  This function is used when optimizing away ORDER BY in 
13432
 
  SELECT * FROM t1 WHERE a=1 ORDER BY a DESC,b DESC.
 
3853
  This function is used when optimizing away order_st BY in
 
3854
  SELECT * FROM t1 WHERE a=1 order_st BY a DESC,b DESC.
13433
3855
*/
13434
 
  
13435
 
static int
13436
 
join_read_last_key(JOIN_TAB *tab)
 
3856
int join_read_last_key(JoinTable *tab)
13437
3857
{
13438
3858
  int error;
13439
 
  TABLE *table= tab->table;
 
3859
  Table *table= tab->table;
13440
3860
 
13441
 
  if (!table->file->inited)
13442
 
    table->file->ha_index_init(tab->ref.key, tab->sorted);
13443
 
  if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))
 
3861
  if (!table->cursor->inited)
 
3862
    table->cursor->ha_index_init(tab->ref.key, tab->sorted);
 
3863
  if (cp_buffer_from_ref(tab->join->session, &tab->ref))
13444
3864
    return -1;
13445
 
  if ((error=table->file->index_read_last_map(table->record[0],
 
3865
  if ((error=table->cursor->index_read_last_map(table->record[0],
13446
3866
                                              tab->ref.key_buff,
13447
3867
                                              make_prev_keypart_map(tab->ref.key_parts))))
13448
3868
  {
13449
3869
    if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
13450
 
      return report_error(table, error);
13451
 
    return -1; /* purecov: inspected */
 
3870
      return table->report_error(error);
 
3871
    return -1;
13452
3872
  }
13453
3873
  return 0;
13454
3874
}
13455
3875
 
13456
 
 
13457
 
        /* ARGSUSED */
13458
 
static int
13459
 
join_no_more_records(READ_RECORD *info __attribute__((unused)))
 
3876
int join_no_more_records(READ_RECORD *)
13460
3877
{
13461
3878
  return -1;
13462
3879
}
13463
3880
 
13464
 
static int
13465
 
join_read_next_same_diff(READ_RECORD *info)
 
3881
int join_read_next_same_diff(READ_RECORD *info)
13466
3882
{
13467
 
  TABLE *table= info->table;
13468
 
  JOIN_TAB *tab=table->reginfo.join_tab;
 
3883
  Table *table= info->table;
 
3884
  JoinTable *tab=table->reginfo.join_tab;
13469
3885
  if (tab->insideout_match_tab->found_match)
13470
3886
  {
13471
3887
    KEY *key= tab->table->key_info + tab->index;
13472
 
    do 
 
3888
    do
13473
3889
    {
13474
3890
      int error;
13475
3891
      /* Save index tuple from record to the buffer */
13476
3892
      key_copy(tab->insideout_buf, info->record, key, 0);
13477
3893
 
13478
 
      if ((error=table->file->index_next_same(table->record[0],
 
3894
      if ((error=table->cursor->index_next_same(table->record[0],
13479
3895
                                              tab->ref.key_buff,
13480
3896
                                              tab->ref.key_length)))
13481
3897
      {
13482
3898
        if (error != HA_ERR_END_OF_FILE)
13483
 
          return report_error(table, error);
 
3899
          return table->report_error(error);
13484
3900
        table->status= STATUS_GARBAGE;
13485
3901
        return -1;
13486
3902
      }
13487
 
    } while (!key_cmp(tab->table->key_info[tab->index].key_part, 
 
3903
    } while (!key_cmp(tab->table->key_info[tab->index].key_part,
13488
3904
                      tab->insideout_buf, key->key_length));
13489
3905
    tab->insideout_match_tab->found_match= 0;
13490
3906
    return 0;
13493
3909
    return join_read_next_same(info);
13494
3910
}
13495
3911
 
13496
 
static int
13497
 
join_read_next_same(READ_RECORD *info)
 
3912
int join_read_next_same(READ_RECORD *info)
13498
3913
{
13499
3914
  int error;
13500
 
  TABLE *table= info->table;
13501
 
  JOIN_TAB *tab=table->reginfo.join_tab;
 
3915
  Table *table= info->table;
 
3916
  JoinTable *tab=table->reginfo.join_tab;
13502
3917
 
13503
 
  if ((error=table->file->index_next_same(table->record[0],
 
3918
  if ((error=table->cursor->index_next_same(table->record[0],
13504
3919
                                          tab->ref.key_buff,
13505
3920
                                          tab->ref.key_length)))
13506
3921
  {
13507
3922
    if (error != HA_ERR_END_OF_FILE)
13508
 
      return report_error(table, error);
 
3923
      return table->report_error(error);
13509
3924
    table->status= STATUS_GARBAGE;
13510
3925
    return -1;
13511
3926
  }
 
3927
 
13512
3928
  return 0;
13513
3929
}
13514
3930
 
13515
 
 
13516
 
static int
13517
 
join_read_prev_same(READ_RECORD *info)
 
3931
int join_read_prev_same(READ_RECORD *info)
13518
3932
{
13519
3933
  int error;
13520
 
  TABLE *table= info->table;
13521
 
  JOIN_TAB *tab=table->reginfo.join_tab;
 
3934
  Table *table= info->table;
 
3935
  JoinTable *tab=table->reginfo.join_tab;
13522
3936
 
13523
 
  if ((error=table->file->index_prev(table->record[0])))
13524
 
    return report_error(table, error);
 
3937
  if ((error=table->cursor->index_prev(table->record[0])))
 
3938
    return table->report_error(error);
13525
3939
  if (key_cmp_if_same(table, tab->ref.key_buff, tab->ref.key,
13526
3940
                      tab->ref.key_length))
13527
3941
  {
13531
3945
  return error;
13532
3946
}
13533
3947
 
13534
 
 
13535
 
static int
13536
 
join_init_quick_read_record(JOIN_TAB *tab)
 
3948
int join_init_quick_read_record(JoinTable *tab)
13537
3949
{
13538
3950
  if (test_if_quick_select(tab) == -1)
13539
3951
    return -1;                                  /* No possible records */
13540
3952
  return join_init_read_record(tab);
13541
3953
}
13542
3954
 
13543
 
 
13544
3955
int rr_sequential(READ_RECORD *info);
13545
 
int init_read_record_seq(JOIN_TAB *tab)
 
3956
int init_read_record_seq(JoinTable *tab)
13546
3957
{
13547
3958
  tab->read_record.read_record= rr_sequential;
13548
 
  if (tab->read_record.file->ha_rnd_init(1))
 
3959
  if (tab->read_record.cursor->ha_rnd_init(1))
13549
3960
    return 1;
13550
3961
  return (*tab->read_record.read_record)(&tab->read_record);
13551
3962
}
13552
3963
 
13553
 
static int
13554
 
test_if_quick_select(JOIN_TAB *tab)
 
3964
int test_if_quick_select(JoinTable *tab)
13555
3965
{
13556
3966
  delete tab->select->quick;
13557
 
  tab->select->quick=0;
13558
 
  return tab->select->test_quick_select(tab->join->thd, tab->keys,
13559
 
                                        (table_map) 0, HA_POS_ERROR, 0,
13560
 
                                        false);
 
3967
  tab->select->quick= 0;
 
3968
  return tab->select->test_quick_select(tab->join->session, tab->keys,
 
3969
                                        (table_map) 0, HA_POS_ERROR, 0, false);
13561
3970
}
13562
3971
 
13563
 
 
13564
 
static int
13565
 
join_init_read_record(JOIN_TAB *tab)
 
3972
int join_init_read_record(JoinTable *tab)
13566
3973
{
13567
3974
  if (tab->select && tab->select->quick && tab->select->quick->reset())
13568
3975
    return 1;
13569
 
  init_read_record(&tab->read_record, tab->join->thd, tab->table,
 
3976
  init_read_record(&tab->read_record, tab->join->session, tab->table,
13570
3977
                   tab->select,1,1);
13571
3978
  return (*tab->read_record.read_record)(&tab->read_record);
13572
3979
}
13573
3980
 
13574
 
 
13575
 
static int
13576
 
join_read_first(JOIN_TAB *tab)
 
3981
int join_read_first(JoinTable *tab)
13577
3982
{
13578
3983
  int error;
13579
 
  TABLE *table=tab->table;
13580
 
  if (!table->key_read && table->covering_keys.is_set(tab->index) &&
 
3984
  Table *table=tab->table;
 
3985
  if (!table->key_read && table->covering_keys.test(tab->index) &&
13581
3986
      !table->no_keyread)
13582
3987
  {
13583
3988
    table->key_read=1;
13584
 
    table->file->extra(HA_EXTRA_KEYREAD);
 
3989
    table->cursor->extra(HA_EXTRA_KEYREAD);
13585
3990
  }
13586
3991
  tab->table->status=0;
13587
3992
  tab->read_record.table=table;
13588
 
  tab->read_record.file=table->file;
 
3993
  tab->read_record.cursor=table->cursor;
13589
3994
  tab->read_record.index=tab->index;
13590
3995
  tab->read_record.record=table->record[0];
13591
3996
  if (tab->insideout_match_tab)
13600
4005
    tab->read_record.do_insideout_scan= 0;
13601
4006
  }
13602
4007
 
13603
 
  if (!table->file->inited)
13604
 
    table->file->ha_index_init(tab->index, tab->sorted);
13605
 
  if ((error=tab->table->file->index_first(tab->table->record[0])))
 
4008
  if (!table->cursor->inited)
 
4009
    table->cursor->ha_index_init(tab->index, tab->sorted);
 
4010
  if ((error=tab->table->cursor->index_first(tab->table->record[0])))
13606
4011
  {
13607
4012
    if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
13608
 
      report_error(table, error);
 
4013
      table->report_error(error);
13609
4014
    return -1;
13610
4015
  }
 
4016
 
13611
4017
  return 0;
13612
4018
}
13613
4019
 
13614
 
 
13615
 
static int
13616
 
join_read_next_different(READ_RECORD *info)
 
4020
int join_read_next_different(READ_RECORD *info)
13617
4021
{
13618
 
  JOIN_TAB *tab= info->do_insideout_scan;
 
4022
  JoinTable *tab= info->do_insideout_scan;
13619
4023
  if (tab->insideout_match_tab->found_match)
13620
4024
  {
13621
4025
    KEY *key= tab->table->key_info + tab->index;
13622
 
    do 
 
4026
    do
13623
4027
    {
13624
4028
      int error;
13625
4029
      /* Save index tuple from record to the buffer */
13626
4030
      key_copy(tab->insideout_buf, info->record, key, 0);
13627
4031
 
13628
 
      if ((error=info->file->index_next(info->record)))
13629
 
        return report_error(info->table, error);
13630
 
      
13631
 
    } while (!key_cmp(tab->table->key_info[tab->index].key_part, 
 
4032
      if ((error=info->cursor->index_next(info->record)))
 
4033
        return info->table->report_error(error);
 
4034
    } while (!key_cmp(tab->table->key_info[tab->index].key_part,
13632
4035
                      tab->insideout_buf, key->key_length));
13633
4036
    tab->insideout_match_tab->found_match= 0;
13634
4037
    return 0;
13637
4040
    return join_read_next(info);
13638
4041
}
13639
4042
 
13640
 
 
13641
 
static int
13642
 
join_read_next(READ_RECORD *info)
 
4043
int join_read_next(READ_RECORD *info)
13643
4044
{
13644
4045
  int error;
13645
 
  if ((error=info->file->index_next(info->record)))
13646
 
    return report_error(info->table, error);
 
4046
  if ((error=info->cursor->index_next(info->record)))
 
4047
    return info->table->report_error(error);
13647
4048
  return 0;
13648
4049
}
13649
4050
 
13650
 
 
13651
 
static int
13652
 
join_read_last(JOIN_TAB *tab)
 
4051
int join_read_last(JoinTable *tab)
13653
4052
{
13654
 
  TABLE *table=tab->table;
 
4053
  Table *table=tab->table;
13655
4054
  int error;
13656
 
  if (!table->key_read && table->covering_keys.is_set(tab->index) &&
 
4055
  if (!table->key_read && table->covering_keys.test(tab->index) &&
13657
4056
      !table->no_keyread)
13658
4057
  {
13659
4058
    table->key_read=1;
13660
 
    table->file->extra(HA_EXTRA_KEYREAD);
 
4059
    table->cursor->extra(HA_EXTRA_KEYREAD);
13661
4060
  }
13662
4061
  tab->table->status=0;
13663
4062
  tab->read_record.read_record=join_read_prev;
13664
4063
  tab->read_record.table=table;
13665
 
  tab->read_record.file=table->file;
 
4064
  tab->read_record.cursor=table->cursor;
13666
4065
  tab->read_record.index=tab->index;
13667
4066
  tab->read_record.record=table->record[0];
13668
 
  if (!table->file->inited)
13669
 
    table->file->ha_index_init(tab->index, 1);
13670
 
  if ((error= tab->table->file->index_last(tab->table->record[0])))
13671
 
    return report_error(table, error);
 
4067
  if (!table->cursor->inited)
 
4068
    table->cursor->ha_index_init(tab->index, 1);
 
4069
  if ((error= tab->table->cursor->index_last(tab->table->record[0])))
 
4070
    return table->report_error(error);
 
4071
 
13672
4072
  return 0;
13673
4073
}
13674
4074
 
13675
 
 
13676
 
static int
13677
 
join_read_prev(READ_RECORD *info)
 
4075
int join_read_prev(READ_RECORD *info)
13678
4076
{
13679
4077
  int error;
13680
 
  if ((error= info->file->index_prev(info->record)))
13681
 
    return report_error(info->table, error);
 
4078
  if ((error= info->cursor->index_prev(info->record)))
 
4079
    return info->table->report_error(error);
 
4080
 
13682
4081
  return 0;
13683
4082
}
13684
4083
 
13685
4084
/**
13686
4085
  Reading of key with key reference and one part that may be NULL.
13687
4086
*/
13688
 
 
13689
 
int
13690
 
join_read_always_key_or_null(JOIN_TAB *tab)
 
4087
int join_read_always_key_or_null(JoinTable *tab)
13691
4088
{
13692
4089
  int res;
13693
4090
 
13701
4098
  return safe_index_read(tab);
13702
4099
}
13703
4100
 
13704
 
 
13705
 
int
13706
 
join_read_next_same_or_null(READ_RECORD *info)
 
4101
int join_read_next_same_or_null(READ_RECORD *info)
13707
4102
{
13708
4103
  int error;
13709
4104
  if ((error= join_read_next_same(info)) >= 0)
13710
4105
    return error;
13711
 
  JOIN_TAB *tab= info->table->reginfo.join_tab;
 
4106
  JoinTable *tab= info->table->reginfo.join_tab;
13712
4107
 
13713
4108
  /* Test if we have already done a read after null key */
13714
4109
  if (*tab->ref.null_ref_key)
13717
4112
  return safe_index_read(tab);                  // then read null keys
13718
4113
}
13719
4114
 
13720
 
 
13721
 
/*****************************************************************************
13722
 
  DESCRIPTION
13723
 
    Functions that end one nested loop iteration. Different functions
13724
 
    are used to support GROUP BY clause and to redirect records
13725
 
    to a table (e.g. in case of SELECT into a temporary table) or to the
13726
 
    network client.
13727
 
 
13728
 
  RETURN VALUES
13729
 
    NESTED_LOOP_OK           - the record has been successfully handled
13730
 
    NESTED_LOOP_ERROR        - a fatal error (like table corruption)
13731
 
                               was detected
13732
 
    NESTED_LOOP_KILLED       - thread shutdown was requested while processing
13733
 
                               the record
13734
 
    NESTED_LOOP_QUERY_LIMIT  - the record has been successfully handled;
13735
 
                               additionally, the nested loop produced the
13736
 
                               number of rows specified in the LIMIT clause
13737
 
                               for the query
13738
 
    NESTED_LOOP_CURSOR_LIMIT - the record has been successfully handled;
13739
 
                               additionally, there is a cursor and the nested
13740
 
                               loop algorithm produced the number of rows
13741
 
                               that is specified for current cursor fetch
13742
 
                               operation.
13743
 
   All return values except NESTED_LOOP_OK abort the nested loop.
13744
 
*****************************************************************************/
13745
 
 
13746
 
/* ARGSUSED */
13747
 
static enum_nested_loop_state
13748
 
end_send(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
13749
 
         bool end_of_records)
13750
 
{
13751
 
  if (!end_of_records)
13752
 
  {
13753
 
    int error;
13754
 
    if (join->having && join->having->val_int() == 0)
13755
 
      return(NESTED_LOOP_OK);               // Didn't match having
13756
 
    error=0;
13757
 
    if (join->do_send_rows)
13758
 
      error=join->result->send_data(*join->fields);
13759
 
    if (error)
13760
 
      return(NESTED_LOOP_ERROR); /* purecov: inspected */
13761
 
    if (++join->send_records >= join->unit->select_limit_cnt &&
13762
 
        join->do_send_rows)
13763
 
    {
13764
 
      if (join->select_options & OPTION_FOUND_ROWS)
13765
 
      {
13766
 
        JOIN_TAB *jt=join->join_tab;
13767
 
        if ((join->tables == 1) && !join->tmp_table && !join->sort_and_group
13768
 
            && !join->send_group_parts && !join->having && !jt->select_cond &&
13769
 
            !(jt->select && jt->select->quick) &&
13770
 
            (jt->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&
13771
 
            (jt->ref.key < 0))
13772
 
        {
13773
 
          /* Join over all rows in table;  Return number of found rows */
13774
 
          TABLE *table=jt->table;
13775
 
 
13776
 
          join->select_options ^= OPTION_FOUND_ROWS;
13777
 
          if (table->sort.record_pointers ||
13778
 
              (table->sort.io_cache && my_b_inited(table->sort.io_cache)))
13779
 
          {
13780
 
            /* Using filesort */
13781
 
            join->send_records= table->sort.found_records;
13782
 
          }
13783
 
          else
13784
 
          {
13785
 
            table->file->info(HA_STATUS_VARIABLE);
13786
 
            join->send_records= table->file->stats.records;
13787
 
          }
13788
 
        }
13789
 
        else 
13790
 
        {
13791
 
          join->do_send_rows= 0;
13792
 
          if (join->unit->fake_select_lex)
13793
 
            join->unit->fake_select_lex->select_limit= 0;
13794
 
          return(NESTED_LOOP_OK);
13795
 
        }
13796
 
      }
13797
 
      return(NESTED_LOOP_QUERY_LIMIT);      // Abort nicely
13798
 
    }
13799
 
    else if (join->send_records >= join->fetch_limit)
13800
 
    {
13801
 
      /*
13802
 
        There is a server side cursor and all rows for
13803
 
        this fetch request are sent.
13804
 
      */
13805
 
      return(NESTED_LOOP_CURSOR_LIMIT);
13806
 
    }
13807
 
  }
13808
 
 
13809
 
  return(NESTED_LOOP_OK);
13810
 
}
13811
 
 
13812
 
 
13813
 
        /* ARGSUSED */
13814
 
enum_nested_loop_state
13815
 
end_send_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
13816
 
               bool end_of_records)
 
4115
enum_nested_loop_state end_send_group(JOIN *join, JoinTable *, bool end_of_records)
13817
4116
{
13818
4117
  int idx= -1;
13819
4118
  enum_nested_loop_state ok_code= NESTED_LOOP_OK;
13821
4120
  if (!join->first_record || end_of_records ||
13822
4121
      (idx=test_if_item_cache_changed(join->group_fields)) >= 0)
13823
4122
  {
13824
 
    if (join->first_record || 
 
4123
    if (join->first_record ||
13825
4124
        (end_of_records && !join->group && !join->group_optimized_away))
13826
4125
    {
13827
4126
      if (idx < (int) join->send_group_parts)
13828
4127
      {
13829
 
        int error=0;
13830
 
        {
13831
 
          if (!join->first_record)
13832
 
          {
13833
 
            List_iterator_fast<Item> it(*join->fields);
13834
 
            Item *item;
13835
 
            /* No matching rows for group function */
13836
 
            join->clear();
 
4128
        int error=0;
 
4129
        {
 
4130
          if (!join->first_record)
 
4131
          {
 
4132
                  List_iterator_fast<Item> it(*join->fields);
 
4133
                  Item *item;
 
4134
            /* No matching rows for group function */
 
4135
            join->clear();
13837
4136
 
13838
4137
            while ((item= it++))
13839
4138
              item->no_rows_in_result();
13840
 
          }
13841
 
          if (join->having && join->having->val_int() == 0)
13842
 
            error= -1;                          // Didn't satisfy having
13843
 
          else
13844
 
          {
13845
 
            if (join->do_send_rows)
13846
 
              error=join->result->send_data(*join->fields) ? 1 : 0;
13847
 
            join->send_records++;
13848
 
          }
13849
 
          if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)
13850
 
          {
13851
 
            if (join->rollup_send_data((uint) (idx+1)))
13852
 
              error= 1;
13853
 
          }
13854
 
        }
13855
 
        if (error > 0)
13856
 
          return(NESTED_LOOP_ERROR);        /* purecov: inspected */
13857
 
        if (end_of_records)
13858
 
          return(NESTED_LOOP_OK);
13859
 
        if (join->send_records >= join->unit->select_limit_cnt &&
13860
 
            join->do_send_rows)
13861
 
        {
13862
 
          if (!(join->select_options & OPTION_FOUND_ROWS))
13863
 
            return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely
13864
 
          join->do_send_rows=0;
13865
 
          join->unit->select_limit_cnt = HA_POS_ERROR;
 
4139
          }
 
4140
          if (join->having && join->having->val_int() == 0)
 
4141
            error= -1;                          // Didn't satisfy having
 
4142
          else
 
4143
          {
 
4144
            if (join->do_send_rows)
 
4145
              error=join->result->send_data(*join->fields) ? 1 : 0;
 
4146
            join->send_records++;
 
4147
          }
 
4148
          if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)
 
4149
          {
 
4150
            if (join->rollup_send_data((uint32_t) (idx+1)))
 
4151
              error= 1;
 
4152
          }
 
4153
        }
 
4154
        if (error > 0)
 
4155
          return(NESTED_LOOP_ERROR);
 
4156
        if (end_of_records)
 
4157
          return(NESTED_LOOP_OK);
 
4158
        if (join->send_records >= join->unit->select_limit_cnt &&
 
4159
            join->do_send_rows)
 
4160
        {
 
4161
          if (!(join->select_options & OPTION_FOUND_ROWS))
 
4162
            return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely
 
4163
          join->do_send_rows=0;
 
4164
          join->unit->select_limit_cnt = HA_POS_ERROR;
13866
4165
        }
13867
4166
        else if (join->send_records >= join->fetch_limit)
13868
4167
        {
13881
4180
    else
13882
4181
    {
13883
4182
      if (end_of_records)
13884
 
        return(NESTED_LOOP_OK);
 
4183
        return(NESTED_LOOP_OK);
13885
4184
      join->first_record=1;
13886
 
      VOID(test_if_item_cache_changed(join->group_fields));
 
4185
      test_if_item_cache_changed(join->group_fields);
13887
4186
    }
13888
4187
    if (idx < (int) join->send_group_parts)
13889
4188
    {
13893
4192
      */
13894
4193
      copy_fields(&join->tmp_table_param);
13895
4194
      if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))
13896
 
        return(NESTED_LOOP_ERROR);
 
4195
        return(NESTED_LOOP_ERROR);
13897
4196
      return(ok_code);
13898
4197
    }
13899
4198
  }
13902
4201
  return(NESTED_LOOP_OK);
13903
4202
}
13904
4203
 
13905
 
 
13906
 
        /* ARGSUSED */
13907
 
enum_nested_loop_state
13908
 
end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
13909
 
          bool end_of_records)
13910
 
{
13911
 
  TABLE *table=join->tmp_table;
13912
 
 
13913
 
  if (join->thd->killed)                        // Aborted by user
13914
 
  {
13915
 
    join->thd->send_kill_message();
13916
 
    return(NESTED_LOOP_KILLED);             /* purecov: inspected */
13917
 
  }
13918
 
  if (!end_of_records)
13919
 
  {
13920
 
    copy_fields(&join->tmp_table_param);
13921
 
    copy_funcs(join->tmp_table_param.items_to_copy);
13922
 
#ifdef TO_BE_DELETED
13923
 
    if (!table->uniques)                        // If not unique handling
13924
 
    {
13925
 
      /* Copy null values from group to row */
13926
 
      ORDER   *group;
13927
 
      for (group=table->group ; group ; group=group->next)
13928
 
      {
13929
 
        Item *item= *group->item;
13930
 
        if (item->maybe_null)
13931
 
        {
13932
 
          Field *field=item->get_tmp_table_field();
13933
 
          field->ptr[-1]= (uchar) (field->is_null() ? 1 : 0);
13934
 
        }
13935
 
      }
13936
 
    }
13937
 
#endif
13938
 
    if (!join->having || join->having->val_int())
13939
 
    {
13940
 
      int error;
13941
 
      join->found_records++;
13942
 
      if ((error=table->file->ha_write_row(table->record[0])))
13943
 
      {
13944
 
        if (!table->file->is_fatal_error(error, HA_CHECK_DUP))
13945
 
          goto end;
13946
 
        if (create_myisam_from_heap(join->thd, table,
13947
 
                                    join->tmp_table_param.start_recinfo,
13948
 
                                    &join->tmp_table_param.recinfo,
13949
 
                                    error, 1))
13950
 
          return(NESTED_LOOP_ERROR);        // Not a table_is_full error
13951
 
        table->s->uniques=0;                    // To ensure rows are the same
13952
 
      }
13953
 
      if (++join->send_records >= join->tmp_table_param.end_write_records &&
13954
 
          join->do_send_rows)
13955
 
      {
13956
 
        if (!(join->select_options & OPTION_FOUND_ROWS))
13957
 
          return(NESTED_LOOP_QUERY_LIMIT);
13958
 
        join->do_send_rows=0;
13959
 
        join->unit->select_limit_cnt = HA_POS_ERROR;
13960
 
        return(NESTED_LOOP_OK);
13961
 
      }
13962
 
    }
13963
 
  }
13964
 
end:
13965
 
  return(NESTED_LOOP_OK);
13966
 
}
13967
 
 
13968
 
/* ARGSUSED */
13969
 
/** Group by searching after group record and updating it if possible. */
13970
 
 
13971
 
static enum_nested_loop_state
13972
 
end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
13973
 
           bool end_of_records)
13974
 
{
13975
 
  TABLE *table=join->tmp_table;
13976
 
  ORDER   *group;
13977
 
  int     error;
13978
 
 
13979
 
  if (end_of_records)
13980
 
    return(NESTED_LOOP_OK);
13981
 
  if (join->thd->killed)                        // Aborted by user
13982
 
  {
13983
 
    join->thd->send_kill_message();
13984
 
    return(NESTED_LOOP_KILLED);             /* purecov: inspected */
13985
 
  }
13986
 
 
13987
 
  join->found_records++;
13988
 
  copy_fields(&join->tmp_table_param);          // Groups are copied twice.
13989
 
  /* Make a key of group index */
13990
 
  for (group=table->group ; group ; group=group->next)
13991
 
  {
13992
 
    Item *item= *group->item;
13993
 
    item->save_org_in_field(group->field);
13994
 
    /* Store in the used key if the field was 0 */
13995
 
    if (item->maybe_null)
13996
 
      group->buff[-1]= (char) group->field->is_null();
13997
 
  }
13998
 
  if (!table->file->index_read_map(table->record[1],
13999
 
                                   join->tmp_table_param.group_buff,
14000
 
                                   HA_WHOLE_KEY,
14001
 
                                   HA_READ_KEY_EXACT))
14002
 
  {                                             /* Update old record */
14003
 
    restore_record(table,record[1]);
14004
 
    update_tmptable_sum_func(join->sum_funcs,table);
14005
 
    if ((error=table->file->ha_update_row(table->record[1],
14006
 
                                          table->record[0])))
14007
 
    {
14008
 
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
14009
 
      return(NESTED_LOOP_ERROR);            /* purecov: inspected */
14010
 
    }
14011
 
    return(NESTED_LOOP_OK);
14012
 
  }
14013
 
 
14014
 
  /*
14015
 
    Copy null bits from group key to table
14016
 
    We can't copy all data as the key may have different format
14017
 
    as the row data (for example as with VARCHAR keys)
14018
 
  */
14019
 
  KEY_PART_INFO *key_part;
14020
 
  for (group=table->group,key_part=table->key_info[0].key_part;
14021
 
       group ;
14022
 
       group=group->next,key_part++)
14023
 
  {
14024
 
    if (key_part->null_bit)
14025
 
      memcpy(table->record[0]+key_part->offset, group->buff, 1);
14026
 
  }
14027
 
  init_tmptable_sum_functions(join->sum_funcs);
14028
 
  copy_funcs(join->tmp_table_param.items_to_copy);
14029
 
  if ((error=table->file->ha_write_row(table->record[0])))
14030
 
  {
14031
 
    if (create_myisam_from_heap(join->thd, table,
14032
 
                                join->tmp_table_param.start_recinfo,
14033
 
                                &join->tmp_table_param.recinfo,
14034
 
                                error, 0))
14035
 
      return(NESTED_LOOP_ERROR);            // Not a table_is_full error
14036
 
    /* Change method to update rows */
14037
 
    table->file->ha_index_init(0, 0);
14038
 
    join->join_tab[join->tables-1].next_select=end_unique_update;
14039
 
  }
14040
 
  join->send_records++;
14041
 
  return(NESTED_LOOP_OK);
14042
 
}
14043
 
 
14044
 
 
14045
 
/** Like end_update, but this is done with unique constraints instead of keys.  */
14046
 
 
14047
 
static enum_nested_loop_state
14048
 
end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
14049
 
                  bool end_of_records)
14050
 
{
14051
 
  TABLE *table=join->tmp_table;
14052
 
  int     error;
14053
 
 
14054
 
  if (end_of_records)
14055
 
    return(NESTED_LOOP_OK);
14056
 
  if (join->thd->killed)                        // Aborted by user
14057
 
  {
14058
 
    join->thd->send_kill_message();
14059
 
    return(NESTED_LOOP_KILLED);             /* purecov: inspected */
14060
 
  }
14061
 
 
14062
 
  init_tmptable_sum_functions(join->sum_funcs);
14063
 
  copy_fields(&join->tmp_table_param);          // Groups are copied twice.
14064
 
  copy_funcs(join->tmp_table_param.items_to_copy);
14065
 
 
14066
 
  if (!(error=table->file->ha_write_row(table->record[0])))
14067
 
    join->send_records++;                       // New group
14068
 
  else
14069
 
  {
14070
 
    if ((int) table->file->get_dup_key(error) < 0)
14071
 
    {
14072
 
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
14073
 
      return(NESTED_LOOP_ERROR);            /* purecov: inspected */
14074
 
    }
14075
 
    if (table->file->rnd_pos(table->record[1],table->file->dup_ref))
14076
 
    {
14077
 
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
14078
 
      return(NESTED_LOOP_ERROR);            /* purecov: inspected */
14079
 
    }
14080
 
    restore_record(table,record[1]);
14081
 
    update_tmptable_sum_func(join->sum_funcs,table);
14082
 
    if ((error=table->file->ha_update_row(table->record[1],
14083
 
                                          table->record[0])))
14084
 
    {
14085
 
      table->file->print_error(error,MYF(0));   /* purecov: inspected */
14086
 
      return(NESTED_LOOP_ERROR);            /* purecov: inspected */
14087
 
    }
14088
 
  }
14089
 
  return(NESTED_LOOP_OK);
14090
 
}
14091
 
 
14092
 
 
14093
 
        /* ARGSUSED */
14094
 
enum_nested_loop_state
14095
 
end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
14096
 
                bool end_of_records)
14097
 
{
14098
 
  TABLE *table=join->tmp_table;
 
4204
enum_nested_loop_state end_write_group(JOIN *join, JoinTable *, bool end_of_records)
 
4205
{
 
4206
  Table *table=join->tmp_table;
14099
4207
  int     idx= -1;
14100
4208
 
14101
 
  if (join->thd->killed)
 
4209
  if (join->session->killed)
14102
4210
  {                                             // Aborted by user
14103
 
    join->thd->send_kill_message();
14104
 
    return(NESTED_LOOP_KILLED);             /* purecov: inspected */
 
4211
    join->session->send_kill_message();
 
4212
    return NESTED_LOOP_KILLED;
14105
4213
  }
14106
4214
  if (!join->first_record || end_of_records ||
14107
4215
      (idx=test_if_item_cache_changed(join->group_fields)) >= 0)
14111
4219
      int send_group_parts= join->send_group_parts;
14112
4220
      if (idx < send_group_parts)
14113
4221
      {
14114
 
        if (!join->first_record)
14115
 
        {
14116
 
          /* No matching rows for group function */
14117
 
          join->clear();
14118
 
        }
14119
 
        copy_sum_funcs(join->sum_funcs,
14120
 
                       join->sum_funcs_end[send_group_parts]);
14121
 
        if (!join->having || join->having->val_int())
14122
 
        {
14123
 
          int error= table->file->ha_write_row(table->record[0]);
14124
 
          if (error && create_myisam_from_heap(join->thd, table,
14125
 
                                               join->tmp_table_param.start_recinfo,
 
4222
        if (!join->first_record)
 
4223
        {
 
4224
          /* No matching rows for group function */
 
4225
          join->clear();
 
4226
        }
 
4227
        copy_sum_funcs(join->sum_funcs, join->sum_funcs_end[send_group_parts]);
 
4228
        if (!join->having || join->having->val_int())
 
4229
        {
 
4230
          int error= table->cursor->ha_write_row(table->record[0]);
 
4231
          if (error && create_myisam_from_heap(join->session, table,
 
4232
                                              join->tmp_table_param.start_recinfo,
14126
4233
                                                &join->tmp_table_param.recinfo,
14127
 
                                               error, 0))
14128
 
            return(NESTED_LOOP_ERROR);
 
4234
                                              error, 0))
 
4235
          return NESTED_LOOP_ERROR;
14129
4236
        }
14130
4237
        if (join->rollup.state != ROLLUP::STATE_NONE)
14131
 
        {
14132
 
          if (join->rollup_write_data((uint) (idx+1), table))
14133
 
            return(NESTED_LOOP_ERROR);
14134
 
        }
14135
 
        if (end_of_records)
14136
 
          return(NESTED_LOOP_OK);
 
4238
        {
 
4239
          if (join->rollup_write_data((uint32_t) (idx+1), table))
 
4240
            return NESTED_LOOP_ERROR;
 
4241
        }
 
4242
        if (end_of_records)
 
4243
          return NESTED_LOOP_OK;
14137
4244
      }
14138
4245
    }
14139
4246
    else
14140
4247
    {
14141
4248
      if (end_of_records)
14142
 
        return(NESTED_LOOP_OK);
 
4249
        return NESTED_LOOP_OK;
14143
4250
      join->first_record=1;
14144
 
      VOID(test_if_item_cache_changed(join->group_fields));
 
4251
      test_if_item_cache_changed(join->group_fields);
14145
4252
    }
14146
4253
    if (idx < (int) join->send_group_parts)
14147
4254
    {
14148
4255
      copy_fields(&join->tmp_table_param);
14149
4256
      copy_funcs(join->tmp_table_param.items_to_copy);
14150
4257
      if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))
14151
 
        return(NESTED_LOOP_ERROR);
14152
 
      return(NESTED_LOOP_OK);
 
4258
        return NESTED_LOOP_ERROR;
 
4259
      return NESTED_LOOP_OK;
14153
4260
    }
14154
4261
  }
14155
4262
  if (update_sum_func(join->sum_funcs))
14156
 
    return(NESTED_LOOP_ERROR);
14157
 
  return(NESTED_LOOP_OK);
 
4263
    return NESTED_LOOP_ERROR;
 
4264
  return NESTED_LOOP_OK;
14158
4265
}
14159
4266
 
14160
 
 
14161
4267
/*****************************************************************************
14162
4268
  Remove calculation with tables that aren't yet read. Remove also tests
14163
4269
  against fields that are read through key where the table is not a
14170
4276
  @return
14171
4277
    1 if right_item is used removable reference key on left_item
14172
4278
*/
14173
 
 
14174
 
static bool test_if_ref(Item_field *left_item,Item *right_item)
 
4279
bool test_if_ref(Item_field *left_item,Item *right_item)
14175
4280
{
14176
4281
  Field *field=left_item->field;
14177
4282
  // No need to change const test. We also have to keep tests on LEFT JOIN
14182
4287
    {
14183
4288
      right_item= right_item->real_item();
14184
4289
      if (right_item->type() == Item::FIELD_ITEM)
14185
 
        return (field->eq_def(((Item_field *) right_item)->field));
 
4290
        return (field->eq_def(((Item_field *) right_item)->field));
14186
4291
      /* remove equalities injected by IN->EXISTS transformation */
14187
4292
      else if (right_item->type() == Item::CACHE_ITEM)
14188
4293
        return ((Item_cache *)right_item)->eq_def (field);
14189
4294
      if (right_item->const_item() && !(right_item->is_null()))
14190
4295
      {
14191
 
        /*
14192
 
          We can remove binary fields and numerical fields except float,
14193
 
          as float comparison isn't 100 % secure
14194
 
          We have to keep normal strings to be able to check for end spaces
 
4296
        /*
 
4297
          We can remove binary fields and numerical fields except float,
 
4298
          as float comparison isn't 100 % secure
 
4299
          We have to keep normal strings to be able to check for end spaces
14195
4300
 
14196
 
          sergefp: the above seems to be too restrictive. Counterexample:
14197
 
            create table t100 (v varchar(10), key(v)) default charset=latin1;
14198
 
            insert into t100 values ('a'),('a ');
14199
 
            explain select * from t100 where v='a';
14200
 
          The EXPLAIN shows 'using Where'. Running the query returns both
14201
 
          rows, so it seems there are no problems with endspace in the most
14202
 
          frequent case?
14203
 
        */
14204
 
        if (field->binary() &&
14205
 
            field->real_type() != DRIZZLE_TYPE_VARCHAR &&
14206
 
            field->decimals() == 0)
14207
 
        {
14208
 
          return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);
14209
 
        }
 
4301
                sergefp: the above seems to be too restrictive. Counterexample:
 
4302
                  create table t100 (v varchar(10), key(v)) default charset=latin1;
 
4303
                  insert into t100 values ('a'),('a ');
 
4304
                  explain select * from t100 where v='a';
 
4305
                The EXPLAIN shows 'using Where'. Running the query returns both
 
4306
                rows, so it seems there are no problems with endspace in the most
 
4307
                frequent case?
 
4308
        */
 
4309
        if (field->binary() &&
 
4310
            field->real_type() != DRIZZLE_TYPE_VARCHAR &&
 
4311
            field->decimals() == 0)
 
4312
        {
 
4313
          return ! store_val_in_field(field, right_item, CHECK_FIELD_WARN);
 
4314
        }
14210
4315
      }
14211
4316
    }
14212
4317
  }
14213
 
  return 0;                                     // keep test
14214
 
}
14215
 
 
14216
 
/**
14217
 
   @brief Replaces an expression destructively inside the expression tree of
14218
 
   the WHERE clase.
14219
 
 
14220
 
   @note Because of current requirements for semijoin flattening, we do not
14221
 
   need to recurse here, hence this function will only examine the top-level
14222
 
   AND conditions. (see JOIN::prepare, comment above the line 
14223
 
   'if (do_materialize)'
14224
 
   
14225
 
   @param join The top-level query.
14226
 
   @param old_cond The expression to be replaced.
14227
 
   @param new_cond The expression to be substituted.
14228
 
   @param do_fix_fields If true, Item::fix_fields(THD*, Item**) is called for
14229
 
   the new expression.
14230
 
   @return <code>true</code> if there was an error, <code>false</code> if
14231
 
   successful.
14232
 
*/
14233
 
static bool replace_where_subcondition(JOIN *join, Item *old_cond, 
14234
 
                                       Item *new_cond, bool do_fix_fields)
14235
 
{
14236
 
  if (join->conds == old_cond) {
14237
 
    join->conds= new_cond;
14238
 
    if (do_fix_fields)
14239
 
      new_cond->fix_fields(join->thd, &join->conds);
14240
 
    return false;
14241
 
  }
14242
 
  
14243
 
  if (join->conds->type() == Item::COND_ITEM) {
14244
 
    List_iterator<Item> li(*((Item_cond*)join->conds)->argument_list());
14245
 
    Item *item;
14246
 
    while ((item= li++))
14247
 
      if (item == old_cond) 
14248
 
      {
14249
 
        li.replace(new_cond);
14250
 
        if (do_fix_fields)
14251
 
          new_cond->fix_fields(join->thd, li.ref());
14252
 
        return false;
14253
 
      }
14254
 
  }
14255
 
 
14256
 
  return true;
 
4318
  return 0;
14257
4319
}
14258
4320
 
14259
4321
/*
14260
4322
  Extract a condition that can be checked after reading given table
14261
 
  
 
4323
 
14262
4324
  SYNOPSIS
14263
4325
    make_cond_for_table()
14264
4326
      cond         Condition to analyze
14265
4327
      tables       Tables for which "current field values" are available
14266
 
      used_table   Table that we're extracting the condition for (may 
 
4328
      used_table   Table that we're extracting the condition for (may
14267
4329
                   also include PSEUDO_TABLE_BITS
14268
4330
 
14269
4331
  DESCRIPTION
14273
4335
 
14274
4336
    The function assumes that
14275
4337
      - Constant parts of the condition has already been checked.
14276
 
      - Condition that could be checked for tables in 'tables' has already 
 
4338
      - Condition that could be checked for tables in 'tables' has already
14277
4339
        been checked.
14278
 
        
 
4340
 
14279
4341
    The function takes into account that some parts of the condition are
14280
4342
    guaranteed to be true by employed 'ref' access methods (the code that
14281
4343
    does this is located at the end, search down for "EQ_FUNC").
14282
4344
 
14283
4345
 
14284
 
  SEE ALSO 
 
4346
  SEE ALSO
14285
4347
    make_cond_for_info_schema uses similar algorithm
14286
4348
 
14287
4349
  RETURN
14288
4350
    Extracted condition
14289
4351
*/
14290
 
 
14291
 
static COND *
14292
 
make_cond_for_table(COND *cond, table_map tables, table_map used_table,
14293
 
                    bool exclude_expensive_cond)
 
4352
COND *make_cond_for_table(COND *cond, table_map tables, table_map used_table, bool exclude_expensive_cond)
14294
4353
{
14295
4354
  if (used_table && !(cond->used_tables() & used_table) &&
14296
 
      /*
14297
 
        Exclude constant conditions not checked at optimization time if
14298
 
        the table we are pushing conditions to is the first one.
14299
 
        As a result, such conditions are not considered as already checked
14300
 
        and will be checked at execution time, attached to the first table.
14301
 
      */
14302
 
      !((used_table & 1) && cond->is_expensive()))
 
4355
    /*
 
4356
      Exclude constant conditions not checked at optimization time if
 
4357
      the table we are pushing conditions to is the first one.
 
4358
      As a result, such conditions are not considered as already checked
 
4359
      and will be checked at execution time, attached to the first table.
 
4360
    */
 
4361
    !((used_table & 1) && cond->is_expensive()))
14303
4362
    return (COND*) 0;                           // Already checked
14304
4363
  if (cond->type() == Item::COND_ITEM)
14305
4364
  {
14308
4367
      /* Create new top level AND item */
14309
4368
      Item_cond_and *new_cond=new Item_cond_and;
14310
4369
      if (!new_cond)
14311
 
        return (COND*) 0;                       // OOM /* purecov: inspected */
 
4370
        return (COND*) 0;
14312
4371
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
14313
4372
      Item *item;
14314
4373
      while ((item=li++))
14315
4374
      {
14316
 
        Item *fix=make_cond_for_table(item,tables,used_table,
14317
 
                                      exclude_expensive_cond);
14318
 
        if (fix)
14319
 
          new_cond->argument_list()->push_back(fix);
 
4375
        Item *fix= make_cond_for_table(item,tables,used_table,
 
4376
                                            exclude_expensive_cond);
 
4377
        if (fix)
 
4378
          new_cond->argument_list()->push_back(fix);
14320
4379
      }
14321
 
      switch (new_cond->argument_list()->elements) {
14322
 
      case 0:
14323
 
        return (COND*) 0;                       // Always true
14324
 
      case 1:
14325
 
        return new_cond->argument_list()->head();
14326
 
      default:
14327
 
        /*
14328
 
          Item_cond_and do not need fix_fields for execution, its parameters
14329
 
          are fixed or do not need fix_fields, too
14330
 
        */
14331
 
        new_cond->quick_fix_field();
14332
 
        new_cond->used_tables_cache=
14333
 
          ((Item_cond_and*) cond)->used_tables_cache &
14334
 
          tables;
14335
 
        return new_cond;
 
4380
      switch (new_cond->argument_list()->elements) 
 
4381
      {
 
4382
        case 0:
 
4383
          return (COND*) 0;                     // Always true
 
4384
        case 1:
 
4385
          return new_cond->argument_list()->head();
 
4386
        default:
 
4387
          /*
 
4388
            Item_cond_and do not need fix_fields for execution, its parameters
 
4389
            are fixed or do not need fix_fields, too
 
4390
          */
 
4391
          new_cond->quick_fix_field();
 
4392
          new_cond->used_tables_cache= ((Item_cond_and*) cond)->used_tables_cache & tables;
 
4393
          return new_cond;
14336
4394
      }
14337
4395
    }
14338
4396
    else
14339
4397
    {                                           // Or list
14340
4398
      Item_cond_or *new_cond=new Item_cond_or;
14341
4399
      if (!new_cond)
14342
 
        return (COND*) 0;                       // OOM /* purecov: inspected */
 
4400
        return (COND*) 0;
14343
4401
      List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
14344
4402
      Item *item;
14345
4403
      while ((item=li++))
14346
4404
      {
14347
 
        Item *fix=make_cond_for_table(item,tables,0L, exclude_expensive_cond);
14348
 
        if (!fix)
14349
 
          return (COND*) 0;                     // Always true
14350
 
        new_cond->argument_list()->push_back(fix);
 
4405
        Item *fix= make_cond_for_table(item,tables,0L, exclude_expensive_cond);
 
4406
        if (!fix)
 
4407
          return (COND*) 0;                     // Always true
 
4408
        new_cond->argument_list()->push_back(fix);
14351
4409
      }
14352
4410
      /*
14353
 
        Item_cond_and do not need fix_fields for execution, its parameters
14354
 
        are fixed or do not need fix_fields, too
 
4411
        Item_cond_and do not need fix_fields for execution, its parameters
 
4412
        are fixed or do not need fix_fields, too
14355
4413
      */
14356
4414
      new_cond->quick_fix_field();
14357
4415
      new_cond->used_tables_cache= ((Item_cond_or*) cond)->used_tables_cache;
14376
4434
  if (cond->marker == 2 || cond->eq_cmp_result() == Item::COND_OK)
14377
4435
    return cond;                                // Not boolean op
14378
4436
 
14379
 
  /* 
 
4437
  /*
14380
4438
    Remove equalities that are guaranteed to be true by use of 'ref' access
14381
4439
    method
14382
4440
  */
14384
4442
  {
14385
4443
    Item *left_item=    ((Item_func*) cond)->arguments()[0];
14386
4444
    Item *right_item= ((Item_func*) cond)->arguments()[1];
14387
 
    if (left_item->type() == Item::FIELD_ITEM &&
14388
 
        test_if_ref((Item_field*) left_item,right_item))
 
4445
    if (left_item->type() == Item::FIELD_ITEM && test_if_ref((Item_field*) left_item,right_item))
14389
4446
    {
14390
4447
      cond->marker=3;                   // Checked when read
14391
4448
      return (COND*) 0;
14392
4449
    }
14393
 
    if (right_item->type() == Item::FIELD_ITEM &&
14394
 
        test_if_ref((Item_field*) right_item,left_item))
 
4450
    if (right_item->type() == Item::FIELD_ITEM &&       test_if_ref((Item_field*) right_item,left_item))
14395
4451
    {
14396
4452
      cond->marker=3;                   // Checked when read
14397
4453
      return (COND*) 0;
14401
4457
  return cond;
14402
4458
}
14403
4459
 
14404
 
 
14405
 
static Item *
14406
 
part_of_refkey(TABLE *table,Field *field)
 
4460
static Item *part_of_refkey(Table *table,Field *field)
14407
4461
{
14408
4462
  if (!table->reginfo.join_tab)
14409
4463
    return (Item*) 0;             // field from outer non-select (UPDATE,...)
14410
4464
 
14411
 
  uint ref_parts=table->reginfo.join_tab->ref.key_parts;
 
4465
  uint32_t ref_parts=table->reginfo.join_tab->ref.key_parts;
14412
4466
  if (ref_parts)
14413
4467
  {
14414
4468
    KEY_PART_INFO *key_part=
14415
4469
      table->key_info[table->reginfo.join_tab->ref.key].key_part;
14416
 
    uint part;
 
4470
    uint32_t part;
14417
4471
 
14418
4472
    for (part=0 ; part < ref_parts ; part++)
14419
4473
    {
14429
4483
  return (Item*) 0;
14430
4484
}
14431
4485
 
14432
 
 
14433
4486
/**
14434
 
  Test if one can use the key to resolve ORDER BY.
 
4487
  Test if one can use the key to resolve order_st BY.
14435
4488
 
14436
4489
  @param order                 Sort order
14437
4490
  @param table                 Table to sort
14450
4503
  @retval
14451
4504
    -1   Reverse key can be used
14452
4505
*/
14453
 
 
14454
 
static int test_if_order_by_key(ORDER *order, TABLE *table, uint idx,
14455
 
                                uint *used_key_parts)
 
4506
static int test_if_order_by_key(order_st *order, Table *table, uint32_t idx, uint32_t *used_key_parts)
14456
4507
{
14457
 
  KEY_PART_INFO *key_part,*key_part_end;
14458
 
  key_part=table->key_info[idx].key_part;
14459
 
  key_part_end=key_part+table->key_info[idx].key_parts;
 
4508
  KEY_PART_INFO *key_part= NULL;
 
4509
  KEY_PART_INFO *key_part_end= NULL;
 
4510
  key_part= table->key_info[idx].key_part;
 
4511
  key_part_end= key_part + table->key_info[idx].key_parts;
14460
4512
  key_part_map const_key_parts=table->const_key_parts[idx];
14461
 
  int reverse=0;
 
4513
  int reverse= 0;
14462
4514
  bool on_primary_key= false;
14463
4515
 
14464
4516
  for (; order ; order=order->next, const_key_parts>>=1)
14468
4520
 
14469
4521
    /*
14470
4522
      Skip key parts that are constants in the WHERE clause.
14471
 
      These are already skipped in the ORDER BY by const_expression_in_where()
 
4523
      These are already skipped in the order_st BY by const_expression_in_where()
14472
4524
    */
14473
4525
    for (; const_key_parts & 1 ; const_key_parts>>= 1)
14474
 
      key_part++; 
 
4526
      key_part++;
14475
4527
 
14476
4528
    if (key_part == key_part_end)
14477
4529
    {
14478
 
      /* 
 
4530
      /*
14479
4531
        We are at the end of the key. Check if the engine has the primary
14480
4532
        key as a suffix to the secondary keys. If it has continue to check
14481
4533
        the primary key as a suffix.
14482
4534
      */
14483
4535
      if (!on_primary_key &&
14484
 
          (table->file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
 
4536
          (table->cursor->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
14485
4537
          table->s->primary_key != MAX_KEY)
14486
4538
      {
14487
4539
        on_primary_key= true;
14490
4542
        const_key_parts=table->const_key_parts[table->s->primary_key];
14491
4543
 
14492
4544
        for (; const_key_parts & 1 ; const_key_parts>>= 1)
14493
 
          key_part++; 
 
4545
          key_part++;
14494
4546
        /*
14495
4547
         The primary and secondary key parts were all const (i.e. there's
14496
4548
         one row).  The sorting doesn't matter.
14514
4566
    key_part++;
14515
4567
  }
14516
4568
  *used_key_parts= on_primary_key ? table->key_info[idx].key_parts :
14517
 
    (uint) (key_part - table->key_info[idx].key_part);
14518
 
  if (reverse == -1 && !(table->file->index_flags(idx, *used_key_parts-1, 1) &
 
4569
    (uint32_t) (key_part - table->key_info[idx].key_part);
 
4570
  if (reverse == -1 && !(table->cursor->index_flags(idx, *used_key_parts-1, 1) &
14519
4571
                         HA_READ_PREV))
14520
4572
    reverse= 0;                                 // Index can't be used
14521
4573
  return(reverse);
14522
4574
}
14523
4575
 
14524
 
 
14525
 
uint find_shortest_key(TABLE *table, const key_map *usable_keys)
14526
 
{
14527
 
  uint min_length= (uint) ~0;
14528
 
  uint best= MAX_KEY;
14529
 
  if (!usable_keys->is_clear_all())
14530
 
  {
14531
 
    for (uint nr=0; nr < table->s->keys ; nr++)
14532
 
    {
14533
 
      if (usable_keys->is_set(nr))
14534
 
      {
14535
 
        if (table->key_info[nr].key_length < min_length)
14536
 
        {
14537
 
          min_length=table->key_info[nr].key_length;
14538
 
          best=nr;
14539
 
        }
14540
 
      }
14541
 
    }
14542
 
  }
14543
 
  return best;
14544
 
}
14545
 
 
14546
4576
/**
14547
4577
  Test if a second key is the subkey of the first one.
14548
4578
 
14558
4588
  @retval
14559
4589
    0   no sub key
14560
4590
*/
14561
 
 
14562
 
inline bool 
14563
 
is_subkey(KEY_PART_INFO *key_part, KEY_PART_INFO *ref_key_part,
14564
 
          KEY_PART_INFO *ref_key_part_end)
 
4591
inline bool is_subkey(KEY_PART_INFO *key_part,
 
4592
                      KEY_PART_INFO *ref_key_part,
 
4593
                      KEY_PART_INFO *ref_key_part_end)
14565
4594
{
14566
4595
  for (; ref_key_part < ref_key_part_end; key_part++, ref_key_part++)
14567
 
    if (!key_part->field->eq(ref_key_part->field))
 
4596
    if (! key_part->field->eq(ref_key_part->field))
14568
4597
      return 0;
14569
4598
  return 1;
14570
4599
}
14580
4609
    - MAX_KEY                   If we can't use other key
14581
4610
    - the number of found key   Otherwise
14582
4611
*/
14583
 
 
14584
 
static uint
14585
 
test_if_subkey(ORDER *order, TABLE *table, uint ref, uint ref_key_parts,
14586
 
               const key_map *usable_keys)
 
4612
static uint32_t test_if_subkey(order_st *order,
 
4613
                               Table *table,
 
4614
                               uint32_t ref,
 
4615
                               uint32_t ref_key_parts,
 
4616
                               const key_map *usable_keys)
14587
4617
{
14588
 
  uint nr;
14589
 
  uint min_length= (uint) ~0;
14590
 
  uint best= MAX_KEY;
14591
 
  uint not_used;
 
4618
  uint32_t nr;
 
4619
  uint32_t min_length= UINT32_MAX;
 
4620
  uint32_t best= MAX_KEY;
 
4621
  uint32_t not_used;
14592
4622
  KEY_PART_INFO *ref_key_part= table->key_info[ref].key_part;
14593
4623
  KEY_PART_INFO *ref_key_part_end= ref_key_part + ref_key_parts;
14594
4624
 
14595
4625
  for (nr= 0 ; nr < table->s->keys ; nr++)
14596
4626
  {
14597
 
    if (usable_keys->is_set(nr) &&
 
4627
    if (usable_keys->test(nr) &&
14598
4628
        table->key_info[nr].key_length < min_length &&
14599
4629
        table->key_info[nr].key_parts >= ref_key_parts &&
14600
4630
        is_subkey(table->key_info[nr].key_part, ref_key_part,
14608
4638
  return best;
14609
4639
}
14610
4640
 
14611
 
 
14612
4641
/**
14613
4642
  Check if GROUP BY/DISTINCT can be optimized away because the set is
14614
4643
  already known to be distinct.
14627
4656
    of the table are referenced by a list : either the select list
14628
4657
    through find_field_in_item_list or GROUP BY list through
14629
4658
    find_field_in_order_list.
14630
 
    If the above holds and the key parts cannot contain NULLs then we 
 
4659
    If the above holds and the key parts cannot contain NULLs then we
14631
4660
    can safely remove the GROUP BY/DISTINCT,
14632
4661
    as no result set can be more distinct than an unique key.
14633
4662
 
14640
4669
  @retval
14641
4670
    0                    not found.
14642
4671
*/
14643
 
 
14644
 
static bool
14645
 
list_contains_unique_index(TABLE *table,
14646
 
                          bool (*find_func) (Field *, void *), void *data)
 
4672
bool list_contains_unique_index(Table *table, bool (*find_func) (Field *, void *), void *data)
14647
4673
{
14648
 
  for (uint keynr= 0; keynr < table->s->keys; keynr++)
 
4674
  for (uint32_t keynr= 0; keynr < table->s->keys; keynr++)
14649
4675
  {
14650
4676
    if (keynr == table->s->primary_key ||
14651
4677
         (table->key_info[keynr].flags & HA_NOSAME))
14652
4678
    {
14653
4679
      KEY *keyinfo= table->key_info + keynr;
14654
 
      KEY_PART_INFO *key_part, *key_part_end;
 
4680
      KEY_PART_INFO *key_part= NULL;
 
4681
      KEY_PART_INFO *key_part_end= NULL;
14655
4682
 
14656
4683
      for (key_part=keyinfo->key_part,
14657
4684
           key_part_end=key_part+ keyinfo->key_parts;
14658
4685
           key_part < key_part_end;
14659
4686
           key_part++)
14660
4687
      {
14661
 
        if (key_part->field->maybe_null() || 
14662
 
            !find_func(key_part->field, data))
 
4688
        if (key_part->field->maybe_null() ||
 
4689
            ! find_func(key_part->field, data))
14663
4690
          break;
14664
4691
      }
14665
4692
      if (key_part == key_part_end)
14669
4696
  return 0;
14670
4697
}
14671
4698
 
14672
 
 
14673
4699
/**
14674
4700
  Helper function for list_contains_unique_index.
14675
 
  Find a field reference in a list of ORDER structures.
 
4701
  Find a field reference in a list of order_st structures.
14676
4702
  Finds a direct reference of the Field in the list.
14677
4703
 
14678
4704
  @param field                The field to search for.
14679
 
  @param data                 ORDER *.The list to search in
 
4705
  @param data                 order_st *.The list to search in
14680
4706
 
14681
4707
  @retval
14682
4708
    1                    found
14683
4709
  @retval
14684
4710
    0                    not found.
14685
4711
*/
14686
 
 
14687
 
static bool
14688
 
find_field_in_order_list (Field *field, void *data)
 
4712
bool find_field_in_order_list (Field *field, void *data)
14689
4713
{
14690
 
  ORDER *group= (ORDER *) data;
 
4714
  order_st *group= (order_st *) data;
14691
4715
  bool part_found= 0;
14692
 
  for (ORDER *tmp_group= group; tmp_group; tmp_group=tmp_group->next)
 
4716
  for (order_st *tmp_group= group; tmp_group; tmp_group=tmp_group->next)
14693
4717
  {
14694
4718
    Item *item= (*tmp_group->item)->real_item();
14695
4719
    if (item->type() == Item::FIELD_ITEM &&
14702
4726
  return part_found;
14703
4727
}
14704
4728
 
14705
 
 
14706
4729
/**
14707
4730
  Helper function for list_contains_unique_index.
14708
4731
  Find a field reference in a dynamic list of Items.
14716
4739
  @retval
14717
4740
    0                    not found.
14718
4741
*/
14719
 
 
14720
 
static bool
14721
 
find_field_in_item_list (Field *field, void *data)
 
4742
bool find_field_in_item_list (Field *field, void *data)
14722
4743
{
14723
4744
  List<Item> *fields= (List<Item> *) data;
14724
4745
  bool part_found= 0;
14737
4758
  return part_found;
14738
4759
}
14739
4760
 
14740
 
 
14741
4761
/**
14742
 
  Test if we can skip the ORDER BY by using an index.
 
4762
  Test if we can skip the order_st BY by using an index.
14743
4763
 
14744
4764
  SYNOPSIS
14745
4765
    test_if_skip_sort_order()
14749
4769
      no_changes
14750
4770
      map
14751
4771
 
14752
 
  If we can use an index, the JOIN_TAB / tab->select struct
 
4772
  If we can use an index, the JoinTable / tab->select struct
14753
4773
  is changed to use the index.
14754
4774
 
14755
4775
  The index must cover all fields in <order>, or it will not be considered.
14756
4776
 
14757
4777
  @todo
14758
 
    - sergeyp: Results of all index merge selects actually are ordered 
 
4778
    - sergeyp: Results of all index merge selects actually are ordered
14759
4779
    by clustered PK values.
14760
4780
 
14761
4781
  @retval
14763
4783
  @retval
14764
4784
    1    We can use an index.
14765
4785
*/
14766
 
 
14767
 
static bool
14768
 
test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit,
14769
 
                        bool no_changes, const key_map *map)
 
4786
bool test_if_skip_sort_order(JoinTable *tab, order_st *order, ha_rows select_limit, bool no_changes, const key_map *map)
14770
4787
{
14771
 
  int ref_key;
14772
 
  uint ref_key_parts;
 
4788
  int32_t ref_key;
 
4789
  uint32_t ref_key_parts;
14773
4790
  int order_direction;
14774
 
  uint used_key_parts;
14775
 
  TABLE *table=tab->table;
 
4791
  uint32_t used_key_parts;
 
4792
  Table *table=tab->table;
14776
4793
  SQL_SELECT *select=tab->select;
14777
4794
  key_map usable_keys;
14778
4795
  QUICK_SELECT_I *save_quick= 0;
14779
4796
 
14780
4797
  /*
14781
 
    Keys disabled by ALTER TABLE ... DISABLE KEYS should have already
 
4798
    Keys disabled by ALTER Table ... DISABLE KEYS should have already
14782
4799
    been taken into account.
14783
4800
  */
14784
4801
  usable_keys= *map;
14785
4802
 
14786
 
  for (ORDER *tmp_order=order; tmp_order ; tmp_order=tmp_order->next)
 
4803
  for (order_st *tmp_order=order; tmp_order ; tmp_order=tmp_order->next)
14787
4804
  {
14788
4805
    Item *item= (*tmp_order->item)->real_item();
14789
4806
    if (item->type() != Item::FIELD_ITEM)
14790
4807
    {
14791
 
      usable_keys.clear_all();
 
4808
      usable_keys.reset();
14792
4809
      return(0);
14793
4810
    }
14794
 
    usable_keys.intersect(((Item_field*) item)->field->part_of_sortkey);
14795
 
    if (usable_keys.is_clear_all())
 
4811
    usable_keys&= ((Item_field*) item)->field->part_of_sortkey;
 
4812
    if (usable_keys.none())
14796
4813
      return(0);                                        // No usable keys
14797
4814
  }
14798
4815
 
14802
4819
  {
14803
4820
    ref_key=       tab->ref.key;
14804
4821
    ref_key_parts= tab->ref.key_parts;
14805
 
    if (tab->type == JT_REF_OR_NULL)
 
4822
    if (tab->type == AM_REF_OR_NULL)
14806
4823
      return(0);
14807
4824
  }
14808
4825
  else if (select && select->quick)             // Range found by opt_range
14809
4826
  {
14810
4827
    int quick_type= select->quick->get_type();
14811
4828
    save_quick= select->quick;
14812
 
    /* 
14813
 
      assume results are not ordered when index merge is used 
14814
 
      TODO: sergeyp: Results of all index merge selects actually are ordered 
 
4829
    /*
 
4830
      assume results are not ordered when index merge is used
 
4831
      TODO: sergeyp: Results of all index merge selects actually are ordered
14815
4832
      by clustered PK values.
14816
4833
    */
14817
 
  
14818
 
    if (quick_type == QUICK_SELECT_I::QS_TYPE_INDEX_MERGE || 
14819
 
        quick_type == QUICK_SELECT_I::QS_TYPE_ROR_UNION || 
 
4834
 
 
4835
    if (quick_type == QUICK_SELECT_I::QS_TYPE_INDEX_MERGE ||
 
4836
        quick_type == QUICK_SELECT_I::QS_TYPE_ROR_UNION ||
14820
4837
        quick_type == QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT)
14821
4838
      return(0);
14822
4839
    ref_key=       select->quick->index;
14828
4845
    /*
14829
4846
      We come here when there is a REF key.
14830
4847
    */
14831
 
    if (!usable_keys.is_set(ref_key))
 
4848
    if (! usable_keys.test(ref_key))
14832
4849
    {
14833
4850
      /*
14834
 
        We come here when ref_key is not among usable_keys
 
4851
        We come here when ref_key is not among usable_keys
14835
4852
      */
14836
 
      uint new_ref_key;
 
4853
      uint32_t new_ref_key;
14837
4854
      /*
14838
 
        If using index only read, only consider other possible index only
14839
 
        keys
 
4855
        If using index only read, only consider other possible index only
 
4856
        keys
14840
4857
      */
14841
 
      if (table->covering_keys.is_set(ref_key))
14842
 
        usable_keys.intersect(table->covering_keys);
 
4858
      if (table->covering_keys.test(ref_key))
 
4859
        usable_keys&= table->covering_keys;
14843
4860
      if (tab->pre_idx_push_select_cond)
14844
4861
        tab->select_cond= tab->select->cond= tab->pre_idx_push_select_cond;
14845
4862
      if ((new_ref_key= test_if_subkey(order, table, ref_key, ref_key_parts,
14846
4863
                                       &usable_keys)) < MAX_KEY)
14847
4864
      {
14848
 
        /* Found key that can be used to retrieve data in sorted order */
14849
 
        if (tab->ref.key >= 0)
14850
 
        {
 
4865
        /* Found key that can be used to retrieve data in sorted order */
 
4866
        if (tab->ref.key >= 0)
 
4867
        {
14851
4868
          /*
14852
 
            We'll use ref access method on key new_ref_key. In general case 
 
4869
            We'll use ref access method on key new_ref_key. In general case
14853
4870
            the index search tuple for new_ref_key will be different (e.g.
14854
4871
            when one index is defined as (part1, part2, ...) and another as
14855
 
            (part1, part2(N), ...) and the WHERE clause contains 
14856
 
            "part1 = const1 AND part2=const2". 
 
4872
            (part1, part2(N), ...) and the WHERE clause contains
 
4873
            "part1 = const1 AND part2=const2".
14857
4874
            So we build tab->ref from scratch here.
14858
4875
          */
14859
 
          KEYUSE *keyuse= tab->keyuse;
14860
 
          while (keyuse->key != new_ref_key && keyuse->table == tab->table)
 
4876
          optimizer::KeyUse *keyuse= tab->keyuse;
 
4877
          while (keyuse->getKey() != new_ref_key && keyuse->getTable() == tab->table)
14861
4878
            keyuse++;
14862
4879
 
14863
 
          if (create_ref_for_key(tab->join, tab, keyuse, 
 
4880
          if (create_ref_for_key(tab->join, tab, keyuse,
14864
4881
                                 tab->join->const_table_map))
14865
4882
            return(0);
14866
 
        }
14867
 
        else
14868
 
        {
 
4883
        }
 
4884
        else
 
4885
        {
14869
4886
          /*
14870
4887
            The range optimizer constructed QUICK_RANGE for ref_key, and
14871
4888
            we want to use instead new_ref_key as the index. We can't
14875
4892
            parameres are set correctly by the range optimizer.
14876
4893
           */
14877
4894
          key_map new_ref_key_map;
14878
 
          new_ref_key_map.clear_all();  // Force the creation of quick select
14879
 
          new_ref_key_map.set_bit(new_ref_key); // only for new_ref_key.
 
4895
          new_ref_key_map.reset();  // Force the creation of quick select
 
4896
          new_ref_key_map.set(new_ref_key); // only for new_ref_key.
14880
4897
 
14881
 
          if (select->test_quick_select(tab->join->thd, new_ref_key_map, 0,
 
4898
          if (select->test_quick_select(tab->join->session, new_ref_key_map, 0,
14882
4899
                                        (tab->join->select_options &
14883
4900
                                         OPTION_FOUND_ROWS) ?
14884
4901
                                        HA_POS_ERROR :
14886
4903
                                        true) <=
14887
4904
              0)
14888
4905
            return(0);
14889
 
        }
 
4906
        }
14890
4907
        ref_key= new_ref_key;
14891
4908
      }
14892
4909
    }
14893
4910
    /* Check if we get the rows in requested sorted order by using the key */
14894
 
    if (usable_keys.is_set(ref_key) &&
 
4911
    if (usable_keys.test(ref_key) &&
14895
4912
        (order_direction= test_if_order_by_key(order,table,ref_key,
14896
4913
                                               &used_key_parts)))
14897
4914
      goto check_reverse_order;
14901
4918
      Check whether there is an index compatible with the given order
14902
4919
      usage of which is cheaper than usage of the ref_key index (ref_key>=0)
14903
4920
      or a table scan.
14904
 
      It may be the case if ORDER/GROUP BY is used with LIMIT.
 
4921
      It may be the case if order_st/GROUP BY is used with LIMIT.
14905
4922
    */
14906
 
    uint nr;
 
4923
    uint32_t nr;
14907
4924
    key_map keys;
14908
 
    uint best_key_parts= 0;
 
4925
    uint32_t best_key_parts= 0;
14909
4926
    int best_key_direction= 0;
14910
4927
    ha_rows best_records= 0;
14911
4928
    double read_time;
14913
4930
    bool is_best_covering= false;
14914
4931
    double fanout= 1;
14915
4932
    JOIN *join= tab->join;
14916
 
    uint tablenr= tab - join->join_tab;
14917
 
    ha_rows table_records= table->file->stats.records;
 
4933
    uint32_t tablenr= tab - join->join_tab;
 
4934
    ha_rows table_records= table->cursor->stats.records;
14918
4935
    bool group= join->group && order == join->group_list;
 
4936
    optimizer::Position cur_pos;
14919
4937
 
14920
4938
    /*
14921
4939
      If not used with LIMIT, only use keys if the whole query can be
14924
4942
    */
14925
4943
    if (select_limit >= table_records)
14926
4944
    {
14927
 
      /* 
14928
 
        filesort() and join cache are usually faster than reading in 
 
4945
      /*
 
4946
        filesort() and join cache are usually faster than reading in
14929
4947
        index order and not using join cache
14930
4948
        */
14931
 
      if (tab->type == JT_ALL && tab->join->tables > tab->join->const_tables + 1)
 
4949
      if (tab->type == AM_ALL && tab->join->tables > tab->join->const_tables + 1)
14932
4950
        return(0);
14933
 
      keys= *table->file->keys_to_use_for_scanning();
14934
 
      keys.merge(table->covering_keys);
 
4951
      keys= *table->cursor->keys_to_use_for_scanning();
 
4952
      keys|= table->covering_keys;
14935
4953
 
14936
4954
      /*
14937
 
        We are adding here also the index specified in FORCE INDEX clause, 
14938
 
        if any.
14939
 
        This is to allow users to use index in ORDER BY.
 
4955
        We are adding here also the index specified in FORCE INDEX clause,
 
4956
        if any.
 
4957
        This is to allow users to use index in order_st BY.
14940
4958
      */
14941
 
      if (table->force_index) 
14942
 
        keys.merge(group ? table->keys_in_use_for_group_by :
14943
 
                           table->keys_in_use_for_order_by);
14944
 
      keys.intersect(usable_keys);
 
4959
      if (table->force_index)
 
4960
        keys|= (group ? table->keys_in_use_for_group_by :
 
4961
                                table->keys_in_use_for_order_by);
 
4962
      keys&= usable_keys;
14945
4963
    }
14946
4964
    else
14947
4965
      keys= usable_keys;
14948
4966
 
14949
 
    read_time= join->best_positions[tablenr].read_time;
14950
 
    for (uint i= tablenr+1; i < join->tables; i++)
14951
 
      fanout*= join->best_positions[i].records_read; // fanout is always >= 1
 
4967
    cur_pos= join->getPosFromOptimalPlan(tablenr);
 
4968
    read_time= cur_pos.getCost();
 
4969
    for (uint32_t i= tablenr+1; i < join->tables; i++)
 
4970
    {
 
4971
      cur_pos= join->getPosFromOptimalPlan(i);
 
4972
      fanout*= cur_pos.getFanout(); // fanout is always >= 1
 
4973
    }
14952
4974
 
14953
4975
    for (nr=0; nr < table->s->keys ; nr++)
14954
4976
    {
14955
4977
      int direction;
14956
 
      if (keys.is_set(nr) &&
 
4978
      if (keys.test(nr) &&
14957
4979
          (direction= test_if_order_by_key(order, table, nr, &used_key_parts)))
14958
4980
      {
14959
 
        bool is_covering= table->covering_keys.is_set(nr) || (nr == table->s->primary_key && table->file->primary_key_is_clustered());
14960
 
        
14961
 
        /* 
14962
 
          Don't use an index scan with ORDER BY without limit.
 
4981
        bool is_covering= table->covering_keys.test(nr) || (nr == table->s->primary_key && table->cursor->primary_key_is_clustered());
 
4982
 
 
4983
        /*
 
4984
          Don't use an index scan with order_st BY without limit.
14963
4985
          For GROUP BY without limit always use index scan
14964
 
          if there is a suitable index. 
 
4986
          if there is a suitable index.
14965
4987
          Why we hold to this asymmetry hardly can be explained
14966
4988
          rationally. It's easy to demonstrate that using
14967
4989
          temporary table + filesort could be cheaper for grouping
14968
4990
          queries too.
14969
 
        */ 
 
4991
        */
14970
4992
        if (is_covering ||
14971
 
            select_limit != HA_POS_ERROR || 
 
4993
            select_limit != HA_POS_ERROR ||
14972
4994
            (ref_key < 0 && (group || table->force_index)))
14973
 
        { 
 
4995
        {
14974
4996
          double rec_per_key;
14975
4997
          double index_scan_time;
14976
4998
          KEY *keyinfo= tab->table->key_info+nr;
14979
5001
          if (group)
14980
5002
          {
14981
5003
            rec_per_key= keyinfo->rec_per_key[used_key_parts-1];
14982
 
            set_if_bigger(rec_per_key, 1);
 
5004
            set_if_bigger(rec_per_key, 1.0);
14983
5005
            /*
14984
5006
              With a grouping query each group containing on average
14985
5007
              rec_per_key records produces only one row that will
14986
5008
              be included into the result set.
14987
 
            */  
 
5009
            */
14988
5010
            if (select_limit > table_records/rec_per_key)
14989
5011
                select_limit= table_records;
14990
5012
            else
14991
5013
              select_limit= (ha_rows) (select_limit*rec_per_key);
14992
5014
          }
14993
 
          /* 
 
5015
          /*
14994
5016
            If tab=tk is not the last joined table tn then to get first
14995
5017
            L records from the result set we can expect to retrieve
14996
5018
            only L/fanout(tk,tn) where fanout(tk,tn) says how many
14999
5021
            So the estimate for L/fanout(tk,tn) will be too optimistic
15000
5022
            and as result we'll choose an index scan when using ref/range
15001
5023
            access + filesort will be cheaper.
15002
 
          */
 
5024
          */
15003
5025
          select_limit= (ha_rows) (select_limit < fanout ?
15004
5026
                                   1 : select_limit/fanout);
15005
5027
          /*
15006
5028
            We assume that each of the tested indexes is not correlated
15007
5029
            with ref_key. Thus, to select first N records we have to scan
15008
 
            N/selectivity(ref_key) index entries. 
 
5030
            N/selectivity(ref_key) index entries.
15009
5031
            selectivity(ref_key) = #scanned_records/#table_records =
15010
5032
            table->quick_condition_rows/table_records.
15011
5033
            In any case we can't select more than #table_records.
15012
 
            N/(table->quick_condition_rows/table_records) > table_records 
 
5034
            N/(table->quick_condition_rows/table_records) > table_records
15013
5035
            <=> N > table->quick_condition_rows.
15014
 
          */ 
 
5036
          */
15015
5037
          if (select_limit > table->quick_condition_rows)
15016
5038
            select_limit= table_records;
15017
5039
          else
15019
5041
                                     (double) table_records /
15020
5042
                                      table->quick_condition_rows);
15021
5043
          rec_per_key= keyinfo->rec_per_key[keyinfo->key_parts-1];
15022
 
          set_if_bigger(rec_per_key, 1);
 
5044
          set_if_bigger(rec_per_key, 1.0);
15023
5045
          /*
15024
5046
            Here we take into account the fact that rows are
15025
5047
            accessed in sequences rec_per_key records in each.
15026
5048
            Rows in such a sequence are supposed to be ordered
15027
5049
            by rowid/primary key. When reading the data
15028
5050
            in a sequence we'll touch not more pages than the
15029
 
            table file contains.
 
5051
            table cursor contains.
15030
5052
            TODO. Use the formula for a disk sweep sequential access
15031
 
            to calculate the cost of accessing data rows for one 
 
5053
            to calculate the cost of accessing data rows for one
15032
5054
            index entry.
15033
 
          */
 
5055
          */
15034
5056
          index_scan_time= select_limit/rec_per_key *
15035
 
                           min(rec_per_key, table->file->scan_time());
 
5057
                           min(rec_per_key, table->cursor->scan_time());
15036
5058
          if (is_covering || (ref_key < 0 && (group || table->force_index)) ||
15037
5059
              index_scan_time < read_time)
15038
5060
          {
15039
5061
            ha_rows quick_records= table_records;
15040
5062
            if (is_best_covering && !is_covering)
15041
5063
              continue;
15042
 
            if (table->quick_keys.is_set(nr))
 
5064
            if (table->quick_keys.test(nr))
15043
5065
              quick_records= table->quick_rows[nr];
15044
5066
            if (best_key < 0 ||
15045
5067
                (select_limit <= min(quick_records,best_records) ?
15050
5072
              best_key_parts= keyinfo->key_parts;
15051
5073
              best_records= quick_records;
15052
5074
              is_best_covering= is_covering;
15053
 
              best_key_direction= direction; 
 
5075
              best_key_direction= direction;
15054
5076
            }
15055
 
          }   
15056
 
        }      
 
5077
          }
 
5078
        }
15057
5079
      }
15058
5080
    }
15059
5081
    if (best_key >= 0)
15060
5082
    {
15061
5083
      bool quick_created= false;
15062
 
      if (table->quick_keys.is_set(best_key) && best_key != ref_key)
 
5084
      if (table->quick_keys.test(best_key) && best_key != ref_key)
15063
5085
      {
15064
 
        key_map map;
15065
 
        map.clear_all();       // Force the creation of quick select
15066
 
        map.set_bit(best_key); // only best_key.
15067
 
        quick_created=         
15068
 
          select->test_quick_select(join->thd, map, 0,
 
5086
        key_map test_map;
 
5087
        test_map.reset();       // Force the creation of quick select
 
5088
        test_map.set(best_key); // only best_key.
 
5089
        quick_created=
 
5090
          select->test_quick_select(join->session, test_map, 0,
15069
5091
                                    join->select_options & OPTION_FOUND_ROWS ?
15070
5092
                                    HA_POS_ERROR :
15071
5093
                                    join->unit->select_limit_cnt,
15074
5096
      if (!no_changes)
15075
5097
      {
15076
5098
        if (!quick_created)
15077
 
        {
 
5099
        {
15078
5100
          tab->index= best_key;
15079
5101
          tab->read_first_record= best_key_direction > 0 ?
15080
5102
                                  join_read_first:join_read_last;
15081
 
          tab->type=JT_NEXT;           // Read with index_first(), index_next()
 
5103
          tab->type= AM_NEXT;           // Read with index_first(), index_next()
15082
5104
          if (select && select->quick)
15083
5105
          {
15084
5106
            delete select->quick;
15085
5107
            select->quick= 0;
15086
5108
          }
15087
 
          if (table->covering_keys.is_set(best_key))
 
5109
          if (table->covering_keys.test(best_key))
15088
5110
          {
15089
5111
            table->key_read=1;
15090
 
            table->file->extra(HA_EXTRA_KEYREAD);
 
5112
            table->cursor->extra(HA_EXTRA_KEYREAD);
15091
5113
          }
15092
 
          table->file->ha_index_or_rnd_end();
 
5114
          table->cursor->ha_index_or_rnd_end();
15093
5115
          if (join->select_options & SELECT_DESCRIBE)
15094
5116
          {
15095
5117
            tab->ref.key= -1;
15096
5118
            tab->ref.key_parts= 0;
15097
 
            if (select_limit < table_records) 
 
5119
            if (select_limit < table_records)
15098
5120
              tab->limit= select_limit;
15099
5121
          }
15100
5122
        }
15101
 
        else if (tab->type != JT_ALL)
 
5123
        else if (tab->type != AM_ALL)
15102
5124
        {
15103
5125
          /*
15104
5126
            We're about to use a quick access to the table.
15106
5128
            method is actually used.
15107
5129
          */
15108
5130
          assert(tab->select->quick);
15109
 
          tab->type=JT_ALL;
 
5131
          tab->type= AM_ALL;
15110
5132
          tab->use_quick=1;
15111
5133
          tab->ref.key= -1;
15112
5134
          tab->ref.key_parts=0;         // Don't use ref key.
15113
5135
          tab->read_first_record= join_init_read_record;
15114
 
          /*
15115
 
            TODO: update the number of records in join->best_positions[tablenr]
15116
 
          */
15117
5136
        }
15118
5137
      }
15119
5138
      used_key_parts= best_key_parts;
15120
5139
      order_direction= best_key_direction;
15121
5140
    }
15122
5141
    else
15123
 
      return(0); 
15124
 
  } 
 
5142
      return(0);
 
5143
  }
15125
5144
 
15126
 
check_reverse_order:                  
15127
 
  if (order_direction == -1)            // If ORDER BY ... DESC
 
5145
check_reverse_order:
 
5146
  if (order_direction == -1)            // If order_st BY ... DESC
15128
5147
  {
15129
5148
    if (select && select->quick)
15130
5149
    {
15131
5150
      /*
15132
 
        Don't reverse the sort order, if it's already done.
 
5151
        Don't reverse the sort order, if it's already done.
15133
5152
        (In some cases test_if_order_by_key() can be called multiple times
15134
5153
      */
15135
5154
      if (!select->quick->reverse_sorted())
15146
5165
          select->quick= save_quick;
15147
5166
          return(0);                   // Use filesort
15148
5167
        }
15149
 
            
15150
 
        /* ORDER BY range_key DESC */
15151
 
        tmp= new QUICK_SELECT_DESC((QUICK_RANGE_SELECT*)(select->quick),
15152
 
                                    used_key_parts, &error);
15153
 
        if (!tmp || error)
15154
 
        {
15155
 
          delete tmp;
15156
 
          select->quick= save_quick;
15157
 
          tab->limit= 0;
15158
 
          return(0);            // Reverse sort not supported
15159
 
        }
15160
 
        select->quick=tmp;
 
5168
 
 
5169
        /* order_st BY range_key DESC */
 
5170
        tmp= new QUICK_SELECT_DESC((QUICK_RANGE_SELECT*)(select->quick),
 
5171
                                          used_key_parts, &error);
 
5172
        if (!tmp || error)
 
5173
        {
 
5174
          delete tmp;
 
5175
                select->quick= save_quick;
 
5176
                tab->limit= 0;
 
5177
          return(0);            // Reverse sort not supported
 
5178
        }
 
5179
        select->quick=tmp;
15161
5180
      }
15162
5181
    }
15163
 
    else if (tab->type != JT_NEXT && 
 
5182
    else if (tab->type != AM_NEXT &&
15164
5183
             tab->ref.key >= 0 && tab->ref.key_parts <= used_key_parts)
15165
5184
    {
15166
5185
      /*
15167
 
        SELECT * FROM t1 WHERE a=1 ORDER BY a DESC,b DESC
 
5186
        SELECT * FROM t1 WHERE a=1 order_st BY a DESC,b DESC
15168
5187
 
15169
 
        Use a traversal function that starts by reading the last row
15170
 
        with key part (A) and then traverse the index backwards.
 
5188
        Use a traversal function that starts by reading the last row
 
5189
        with key part (A) and then traverse the index backwards.
15171
5190
      */
15172
5191
      tab->read_first_record= join_read_last_key;
15173
5192
      tab->read_record.read_record= join_read_prev_same;
15178
5197
  return(1);
15179
5198
}
15180
5199
 
15181
 
 
15182
5200
/*
15183
5201
  If not selecting by given key, create an index how records should be read
15184
5202
 
15185
5203
  SYNOPSIS
15186
5204
   create_sort_index()
15187
 
     thd                Thread handler
 
5205
     session            Thread Cursor
15188
5206
     tab                Table to sort (in join structure)
15189
5207
     order              How table should be sorted
15190
5208
     filesort_limit     Max number of rows that needs to be sorted
15191
5209
     select_limit       Max number of rows in final output
15192
5210
                        Used to decide if we should use index or not
15193
 
     is_order_by        true if we are sorting on ORDER BY, false if GROUP BY
15194
 
                        Used to decide if we should use index or not     
 
5211
     is_order_by        true if we are sorting on order_st BY, false if GROUP BY
 
5212
                        Used to decide if we should use index or not
15195
5213
 
15196
5214
 
15197
5215
  IMPLEMENTATION
15198
5216
   - If there is an index that can be used, 'tab' is modified to use
15199
5217
     this index.
15200
 
   - If no index, create with filesort() an index file that can be used to
 
5218
   - If no index, create with filesort() an index cursor that can be used to
15201
5219
     retrieve rows in order (should be done with 'read_record').
15202
5220
     The sorted data is stored in tab->table and will be freed when calling
15203
 
     free_io_cache(tab->table).
 
5221
     tab->table->free_io_cache().
15204
5222
 
15205
5223
  RETURN VALUES
15206
5224
    0           ok
15207
5225
    -1          Some fatal error
15208
5226
    1           No records
15209
5227
*/
15210
 
 
15211
 
static int
15212
 
create_sort_index(THD *thd, JOIN *join, ORDER *order,
15213
 
                  ha_rows filesort_limit, ha_rows select_limit,
15214
 
                  bool is_order_by)
 
5228
int create_sort_index(Session *session, JOIN *join, order_st *order, ha_rows filesort_limit, ha_rows select_limit, bool is_order_by)
15215
5229
{
15216
 
  uint length= 0;
 
5230
  uint32_t length= 0;
15217
5231
  ha_rows examined_rows;
15218
 
  TABLE *table;
 
5232
  Table *table;
15219
5233
  SQL_SELECT *select;
15220
 
  JOIN_TAB *tab;
 
5234
  JoinTable *tab;
15221
5235
 
15222
5236
  if (join->tables == join->const_tables)
15223
5237
    return(0);                          // One row, no need to sort
15231
5245
    is going to be used as it is applied now only for one table queries
15232
5246
    with covering indexes.
15233
5247
  */
15234
 
  if ((order != join->group_list || 
 
5248
  if ((order != join->group_list ||
15235
5249
       !(join->select_options & SELECT_BIG_RESULT) ||
15236
5250
       (select && select->quick && (select->quick->get_type() == QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))) &&
15237
 
      test_if_skip_sort_order(tab,order,select_limit,0, 
 
5251
      test_if_skip_sort_order(tab,order,select_limit,0,
15238
5252
                              is_order_by ?  &table->keys_in_use_for_order_by :
15239
5253
                              &table->keys_in_use_for_group_by))
15240
5254
    return(0);
15241
 
  for (ORDER *ord= join->order; ord; ord= ord->next)
 
5255
  for (order_st *ord= join->order; ord; ord= ord->next)
15242
5256
    length++;
15243
 
  if (!(join->sortorder= 
 
5257
  if (!(join->sortorder=
15244
5258
        make_unireg_sortorder(order, &length, join->sortorder)))
15245
 
    goto err;                           /* purecov: inspected */
 
5259
    goto err;
15246
5260
 
15247
 
  table->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
15248
 
                                             MYF(MY_WME | MY_ZEROFILL));
 
5261
  table->sort.io_cache= new IO_CACHE;
 
5262
  memset(table->sort.io_cache, 0, sizeof(IO_CACHE));
15249
5263
  table->status=0;                              // May be wrong if quick_select
15250
5264
 
15251
5265
  // If table has a range, move it to select
15255
5269
    {
15256
5270
      select->quick=tab->quick;
15257
5271
      tab->quick=0;
15258
 
      /* 
 
5272
      /*
15259
5273
        We can only use 'Only index' if quick key is same as ref_key
15260
5274
        and in index_merge 'Only index' cannot be used
15261
5275
      */
15262
 
      if (table->key_read && ((uint) tab->ref.key != select->quick->index))
 
5276
      if (table->key_read && ((uint32_t) tab->ref.key != select->quick->index))
15263
5277
      {
15264
 
        table->key_read=0;
15265
 
        table->file->extra(HA_EXTRA_NO_KEYREAD);
 
5278
        table->key_read=0;
 
5279
        table->cursor->extra(HA_EXTRA_NO_KEYREAD);
15266
5280
      }
15267
5281
    }
15268
5282
    else
15269
5283
    {
15270
5284
      /*
15271
 
        We have a ref on a const;  Change this to a range that filesort
15272
 
        can use.
15273
 
        For impossible ranges (like when doing a lookup on NULL on a NOT NULL
15274
 
        field, quick will contain an empty record set.
 
5285
        We have a ref on a const;  Change this to a range that filesort
 
5286
        can use.
 
5287
        For impossible ranges (like when doing a lookup on NULL on a NOT NULL
 
5288
        field, quick will contain an empty record set.
15275
5289
      */
15276
 
      if (!(select->quick= (get_quick_select_for_ref(thd, table, &tab->ref, 
 
5290
      if (!(select->quick= (get_quick_select_for_ref(session, table, &tab->ref,
15277
5291
                                                     tab->found_records))))
15278
 
        goto err;
 
5292
        goto err;
15279
5293
    }
15280
5294
  }
15281
5295
 
15285
5299
    goto err;
15286
5300
 
15287
5301
  if (table->s->tmp_table)
15288
 
    table->file->info(HA_STATUS_VARIABLE);      // Get record count
15289
 
  table->sort.found_records=filesort(thd, table,join->sortorder, length,
 
5302
    table->cursor->info(HA_STATUS_VARIABLE);    // Get record count
 
5303
  table->sort.found_records=filesort(session, table,join->sortorder, length,
15290
5304
                                     select, filesort_limit, 0,
15291
5305
                                     &examined_rows);
15292
5306
  tab->records= table->sort.found_records;      // For SQL_CALC_ROWS
15298
5312
  tab->select_cond=0;
15299
5313
  tab->last_inner= 0;
15300
5314
  tab->first_unmatched= 0;
15301
 
  tab->type=JT_ALL;                             // Read with normal read_record
 
5315
  tab->type= AM_ALL;                            // Read with normal read_record
15302
5316
  tab->read_first_record= join_init_read_record;
15303
5317
  tab->join->examined_rows+=examined_rows;
15304
5318
  if (table->key_read)                          // Restore if we used indexes
15305
5319
  {
15306
5320
    table->key_read=0;
15307
 
    table->file->extra(HA_EXTRA_NO_KEYREAD);
 
5321
    table->cursor->extra(HA_EXTRA_NO_KEYREAD);
15308
5322
  }
15309
5323
  return(table->sort.found_records == HA_POS_ERROR);
15310
5324
err:
15311
5325
  return(-1);
15312
5326
}
15313
5327
 
15314
 
/*****************************************************************************
15315
 
  Remove duplicates from tmp table
15316
 
  This should be recoded to add a unique index to the table and remove
15317
 
  duplicates
15318
 
  Table is a locked single thread table
15319
 
  fields is the number of fields to check (from the end)
15320
 
*****************************************************************************/
15321
 
 
15322
 
static bool compare_record(TABLE *table, Field **ptr)
15323
 
{
15324
 
  for (; *ptr ; ptr++)
15325
 
  {
15326
 
    if ((*ptr)->cmp_offset(table->s->rec_buff_length))
15327
 
      return 1;
15328
 
  }
15329
 
  return 0;
15330
 
}
15331
 
 
15332
 
static bool copy_blobs(Field **ptr)
15333
 
{
15334
 
  for (; *ptr ; ptr++)
15335
 
  {
15336
 
    if ((*ptr)->flags & BLOB_FLAG)
15337
 
      if (((Field_blob *) (*ptr))->copy())
15338
 
        return 1;                               // Error
15339
 
  }
15340
 
  return 0;
15341
 
}
15342
 
 
15343
 
static void free_blobs(Field **ptr)
15344
 
{
15345
 
  for (; *ptr ; ptr++)
15346
 
  {
15347
 
    if ((*ptr)->flags & BLOB_FLAG)
15348
 
      ((Field_blob *) (*ptr))->free();
15349
 
  }
15350
 
}
15351
 
 
15352
 
 
15353
 
static int
15354
 
remove_duplicates(JOIN *join, TABLE *entry,List<Item> &fields, Item *having)
15355
 
{
15356
 
  int error;
15357
 
  ulong reclength,offset;
15358
 
  uint field_count;
15359
 
  THD *thd= join->thd;
15360
 
 
15361
 
  entry->reginfo.lock_type=TL_WRITE;
15362
 
 
15363
 
  /* Calculate how many saved fields there is in list */
15364
 
  field_count=0;
15365
 
  List_iterator<Item> it(fields);
15366
 
  Item *item;
15367
 
  while ((item=it++))
15368
 
  {
15369
 
    if (item->get_tmp_table_field() && ! item->const_item())
15370
 
      field_count++;
15371
 
  }
15372
 
 
15373
 
  if (!field_count && !(join->select_options & OPTION_FOUND_ROWS) && !having) 
15374
 
  {                    // only const items with no OPTION_FOUND_ROWS
15375
 
    join->unit->select_limit_cnt= 1;            // Only send first row
15376
 
    return(0);
15377
 
  }
15378
 
  Field **first_field=entry->field+entry->s->fields - field_count;
15379
 
  offset= (field_count ? 
15380
 
           entry->field[entry->s->fields - field_count]->
15381
 
           offset(entry->record[0]) : 0);
15382
 
  reclength=entry->s->reclength-offset;
15383
 
 
15384
 
  free_io_cache(entry);                         // Safety
15385
 
  entry->file->info(HA_STATUS_VARIABLE);
15386
 
  if (entry->s->db_type() == heap_hton ||
15387
 
      (!entry->s->blob_fields &&
15388
 
       ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->file->stats.records <
15389
 
        thd->variables.sortbuff_size)))
15390
 
    error=remove_dup_with_hash_index(join->thd, entry,
15391
 
                                     field_count, first_field,
15392
 
                                     reclength, having);
15393
 
  else
15394
 
    error=remove_dup_with_compare(join->thd, entry, first_field, offset,
15395
 
                                  having);
15396
 
 
15397
 
  free_blobs(first_field);
15398
 
  return(error);
15399
 
}
15400
 
 
15401
 
 
15402
 
static int remove_dup_with_compare(THD *thd, TABLE *table, Field **first_field,
15403
 
                                   ulong offset, Item *having)
15404
 
{
15405
 
  handler *file=table->file;
 
5328
int remove_dup_with_compare(Session *session, Table *table, Field **first_field, uint32_t offset, Item *having)
 
5329
{
 
5330
  Cursor *cursor=table->cursor;
15406
5331
  char *org_record,*new_record;
15407
 
  uchar *record;
 
5332
  unsigned char *record;
15408
5333
  int error;
15409
 
  ulong reclength= table->s->reclength-offset;
 
5334
  uint32_t reclength= table->s->reclength-offset;
15410
5335
 
15411
5336
  org_record=(char*) (record=table->record[0])+offset;
15412
5337
  new_record=(char*) table->record[1]+offset;
15413
5338
 
15414
 
  file->ha_rnd_init(1);
15415
 
  error=file->rnd_next(record);
 
5339
  cursor->ha_rnd_init(1);
 
5340
  error=cursor->rnd_next(record);
15416
5341
  for (;;)
15417
5342
  {
15418
 
    if (thd->killed)
 
5343
    if (session->killed)
15419
5344
    {
15420
 
      thd->send_kill_message();
 
5345
      session->send_kill_message();
15421
5346
      error=0;
15422
5347
      goto err;
15423
5348
    }
15424
5349
    if (error)
15425
5350
    {
15426
5351
      if (error == HA_ERR_RECORD_DELETED)
15427
 
        continue;
 
5352
        continue;
15428
5353
      if (error == HA_ERR_END_OF_FILE)
15429
 
        break;
 
5354
        break;
15430
5355
      goto err;
15431
5356
    }
15432
5357
    if (having && !having->val_int())
15433
5358
    {
15434
 
      if ((error=file->ha_delete_row(record)))
15435
 
        goto err;
15436
 
      error=file->rnd_next(record);
 
5359
      if ((error=cursor->ha_delete_row(record)))
 
5360
        goto err;
 
5361
      error=cursor->rnd_next(record);
15437
5362
      continue;
15438
5363
    }
15439
5364
    if (copy_blobs(first_field))
15444
5369
    }
15445
5370
    memcpy(new_record,org_record,reclength);
15446
5371
 
15447
 
    /* Read through rest of file and mark duplicated rows deleted */
 
5372
    /* Read through rest of cursor and mark duplicated rows deleted */
15448
5373
    bool found=0;
15449
5374
    for (;;)
15450
5375
    {
15451
 
      if ((error=file->rnd_next(record)))
 
5376
      if ((error=cursor->rnd_next(record)))
15452
5377
      {
15453
 
        if (error == HA_ERR_RECORD_DELETED)
15454
 
          continue;
15455
 
        if (error == HA_ERR_END_OF_FILE)
15456
 
          break;
15457
 
        goto err;
 
5378
        if (error == HA_ERR_RECORD_DELETED)
 
5379
          continue;
 
5380
        if (error == HA_ERR_END_OF_FILE)
 
5381
          break;
 
5382
        goto err;
15458
5383
      }
15459
 
      if (compare_record(table, first_field) == 0)
 
5384
      if (table->compare_record(first_field) == 0)
15460
5385
      {
15461
 
        if ((error=file->ha_delete_row(record)))
15462
 
          goto err;
 
5386
        if ((error=cursor->ha_delete_row(record)))
 
5387
          goto err;
15463
5388
      }
15464
5389
      else if (!found)
15465
5390
      {
15466
 
        found=1;
15467
 
        file->position(record); // Remember position
 
5391
        found= 1;
 
5392
        cursor->position(record);       // Remember position
15468
5393
      }
15469
5394
    }
15470
5395
    if (!found)
15471
 
      break;                                    // End of file
 
5396
      break;                                    // End of cursor
15472
5397
    /* Restart search on next row */
15473
 
    error=file->restart_rnd_next(record,file->ref);
 
5398
    error=cursor->restart_rnd_next(record,cursor->ref);
15474
5399
  }
15475
5400
 
15476
 
  file->extra(HA_EXTRA_NO_CACHE);
 
5401
  cursor->extra(HA_EXTRA_NO_CACHE);
15477
5402
  return(0);
15478
5403
err:
15479
 
  file->extra(HA_EXTRA_NO_CACHE);
 
5404
  cursor->extra(HA_EXTRA_NO_CACHE);
15480
5405
  if (error)
15481
 
    file->print_error(error,MYF(0));
 
5406
    cursor->print_error(error,MYF(0));
15482
5407
  return(1);
15483
5408
}
15484
5409
 
15485
 
 
15486
5410
/**
15487
5411
  Generate a hash index for each row to quickly find duplicate rows.
15488
5412
 
15489
5413
  @note
15490
5414
    Note that this will not work on tables with blobs!
15491
5415
*/
15492
 
 
15493
 
static int remove_dup_with_hash_index(THD *thd, TABLE *table,
15494
 
                                      uint field_count,
15495
 
                                      Field **first_field,
15496
 
                                      ulong key_length,
15497
 
                                      Item *having)
 
5416
int remove_dup_with_hash_index(Session *session, 
 
5417
                               Table *table,
 
5418
                               uint32_t field_count,
 
5419
                               Field **first_field,
 
5420
                               uint32_t key_length,
 
5421
                               Item *having)
15498
5422
{
15499
 
  uchar *key_buffer, *key_pos, *record=table->record[0];
 
5423
  unsigned char *key_buffer, *key_pos, *record=table->record[0];
15500
5424
  int error;
15501
 
  handler *file= table->file;
15502
 
  ulong extra_length= ALIGN_SIZE(key_length)-key_length;
15503
 
  uint *field_lengths,*field_length;
 
5425
  Cursor *cursor= table->cursor;
 
5426
  uint32_t extra_length= ALIGN_SIZE(key_length)-key_length;
 
5427
  uint32_t *field_lengths,*field_length;
15504
5428
  HASH hash;
15505
5429
 
15506
 
  if (!my_multi_malloc(MYF(MY_WME),
 
5430
  if (! memory::multi_malloc(false,
15507
5431
                       &key_buffer,
15508
 
                       (uint) ((key_length + extra_length) *
15509
 
                               (long) file->stats.records),
 
5432
                       (uint32_t) ((key_length + extra_length) *
 
5433
                               (long) cursor->stats.records),
15510
5434
                       &field_lengths,
15511
 
                       (uint) (field_count*sizeof(*field_lengths)),
15512
 
                       NullS))
 
5435
                       (uint32_t) (field_count*sizeof(*field_lengths)),
 
5436
                       NULL))
15513
5437
    return(1);
15514
5438
 
15515
5439
  {
15516
5440
    Field **ptr;
15517
 
    ulong total_length= 0;
 
5441
    uint32_t total_length= 0;
15518
5442
    for (ptr= first_field, field_length=field_lengths ; *ptr ; ptr++)
15519
5443
    {
15520
 
      uint length= (*ptr)->sort_length();
 
5444
      uint32_t length= (*ptr)->sort_length();
15521
5445
      (*field_length++)= length;
15522
5446
      total_length+= length;
15523
5447
    }
15526
5450
    extra_length= ALIGN_SIZE(key_length)-key_length;
15527
5451
  }
15528
5452
 
15529
 
  if (hash_init(&hash, &my_charset_bin, (uint) file->stats.records, 0, 
 
5453
  if (hash_init(&hash, &my_charset_bin, (uint32_t) cursor->stats.records, 0,
15530
5454
                key_length, (hash_get_key) 0, 0, 0))
15531
5455
  {
15532
 
    my_free((char*) key_buffer,MYF(0));
 
5456
    free((char*) key_buffer);
15533
5457
    return(1);
15534
5458
  }
15535
5459
 
15536
 
  file->ha_rnd_init(1);
 
5460
  cursor->ha_rnd_init(1);
15537
5461
  key_pos=key_buffer;
15538
5462
  for (;;)
15539
5463
  {
15540
 
    uchar *org_key_pos;
15541
 
    if (thd->killed)
 
5464
    unsigned char *org_key_pos;
 
5465
    if (session->killed)
15542
5466
    {
15543
 
      thd->send_kill_message();
 
5467
      session->send_kill_message();
15544
5468
      error=0;
15545
5469
      goto err;
15546
5470
    }
15547
 
    if ((error=file->rnd_next(record)))
 
5471
    if ((error=cursor->rnd_next(record)))
15548
5472
    {
15549
5473
      if (error == HA_ERR_RECORD_DELETED)
15550
 
        continue;
 
5474
        continue;
15551
5475
      if (error == HA_ERR_END_OF_FILE)
15552
 
        break;
 
5476
        break;
15553
5477
      goto err;
15554
5478
    }
15555
5479
    if (having && !having->val_int())
15556
5480
    {
15557
 
      if ((error=file->ha_delete_row(record)))
15558
 
        goto err;
 
5481
      if ((error=cursor->ha_delete_row(record)))
 
5482
        goto err;
15559
5483
      continue;
15560
5484
    }
15561
5485
 
15571
5495
    if (hash_search(&hash, org_key_pos, key_length))
15572
5496
    {
15573
5497
      /* Duplicated found ; Remove the row */
15574
 
      if ((error=file->ha_delete_row(record)))
15575
 
        goto err;
 
5498
      if ((error=cursor->ha_delete_row(record)))
 
5499
        goto err;
15576
5500
    }
15577
5501
    else
15578
5502
      (void) my_hash_insert(&hash, org_key_pos);
15579
5503
    key_pos+=extra_length;
15580
5504
  }
15581
 
  my_free((char*) key_buffer,MYF(0));
 
5505
  free((char*) key_buffer);
15582
5506
  hash_free(&hash);
15583
 
  file->extra(HA_EXTRA_NO_CACHE);
15584
 
  (void) file->ha_rnd_end();
 
5507
  cursor->extra(HA_EXTRA_NO_CACHE);
 
5508
  (void) cursor->ha_rnd_end();
15585
5509
  return(0);
15586
5510
 
15587
5511
err:
15588
 
  my_free((char*) key_buffer,MYF(0));
 
5512
  free((char*) key_buffer);
15589
5513
  hash_free(&hash);
15590
 
  file->extra(HA_EXTRA_NO_CACHE);
15591
 
  (void) file->ha_rnd_end();
 
5514
  cursor->extra(HA_EXTRA_NO_CACHE);
 
5515
  (void) cursor->ha_rnd_end();
15592
5516
  if (error)
15593
 
    file->print_error(error,MYF(0));
 
5517
    cursor->print_error(error,MYF(0));
15594
5518
  return(1);
15595
5519
}
15596
5520
 
15597
 
 
15598
 
SORT_FIELD *make_unireg_sortorder(ORDER *order, uint *length,
15599
 
                                  SORT_FIELD *sortorder)
 
5521
SORT_FIELD *make_unireg_sortorder(order_st *order, uint32_t *length, SORT_FIELD *sortorder)
15600
5522
{
15601
 
  uint count;
 
5523
  uint32_t count;
15602
5524
  SORT_FIELD *sort,*pos;
15603
5525
 
15604
5526
  count=0;
15605
 
  for (ORDER *tmp = order; tmp; tmp=tmp->next)
 
5527
  for (order_st *tmp = order; tmp; tmp=tmp->next)
15606
5528
    count++;
15607
5529
  if (!sortorder)
15608
5530
    sortorder= (SORT_FIELD*) sql_alloc(sizeof(SORT_FIELD) *
15632
5554
  return(sort);
15633
5555
}
15634
5556
 
15635
 
 
15636
 
/*****************************************************************************
15637
 
  Fill join cache with packed records
15638
 
  Records are stored in tab->cache.buffer and last record in
15639
 
  last record is stored with pointers to blobs to support very big
15640
 
  records
15641
 
******************************************************************************/
15642
 
 
15643
 
static int
15644
 
join_init_cache(THD *thd,JOIN_TAB *tables,uint table_count)
15645
 
{
15646
 
  register unsigned int i;
15647
 
  unsigned int length, blobs;
15648
 
  size_t size;
15649
 
  CACHE_FIELD *copy,**blob_ptr;
15650
 
  JOIN_CACHE  *cache;
15651
 
  JOIN_TAB *join_tab;
15652
 
 
15653
 
  cache= &tables[table_count].cache;
15654
 
  cache->fields=blobs=0;
15655
 
 
15656
 
  join_tab=tables;
15657
 
  for (i=0 ; i < table_count ; i++,join_tab++)
15658
 
  {
15659
 
    if (!join_tab->used_fieldlength)            /* Not calced yet */
15660
 
      calc_used_field_length(thd, join_tab);
15661
 
    cache->fields+=join_tab->used_fields;
15662
 
    blobs+=join_tab->used_blobs;
15663
 
 
15664
 
    /* SemiJoinDuplicateElimination: reserve space for rowid */
15665
 
    if (join_tab->rowid_keep_flags & JOIN_TAB::KEEP_ROWID)
15666
 
    {
15667
 
      cache->fields++;
15668
 
      join_tab->used_fieldlength += join_tab->table->file->ref_length;
15669
 
    }
15670
 
  }
15671
 
  if (!(cache->field=(CACHE_FIELD*)
15672
 
        sql_alloc(sizeof(CACHE_FIELD)*(cache->fields+table_count*2)+(blobs+1)*
15673
 
 
15674
 
                  sizeof(CACHE_FIELD*))))
15675
 
  {
15676
 
    my_free((uchar*) cache->buff,MYF(0));               /* purecov: inspected */
15677
 
    cache->buff=0;                              /* purecov: inspected */
15678
 
    return(1);                          /* purecov: inspected */
15679
 
  }
15680
 
  copy=cache->field;
15681
 
  blob_ptr=cache->blob_ptr=(CACHE_FIELD**)
15682
 
    (cache->field+cache->fields+table_count*2);
15683
 
 
15684
 
  length=0;
15685
 
  for (i=0 ; i < table_count ; i++)
15686
 
  {
15687
 
    uint null_fields=0,used_fields;
15688
 
    Field **f_ptr,*field;
15689
 
    MY_BITMAP *read_set= tables[i].table->read_set;
15690
 
    for (f_ptr=tables[i].table->field,used_fields=tables[i].used_fields ;
15691
 
         used_fields ;
15692
 
         f_ptr++)
15693
 
    {
15694
 
      field= *f_ptr;
15695
 
      if (bitmap_is_set(read_set, field->field_index))
15696
 
      {
15697
 
        used_fields--;
15698
 
        length+=field->fill_cache_field(copy);
15699
 
        if (copy->blob_field)
15700
 
          (*blob_ptr++)=copy;
15701
 
        if (field->maybe_null())
15702
 
          null_fields++;
15703
 
        copy->get_rowid= NULL;
15704
 
        copy++;
15705
 
      }
15706
 
    }
15707
 
    /* Copy null bits from table */
15708
 
    if (null_fields && tables[i].table->s->null_fields)
15709
 
    {                                           /* must copy null bits */
15710
 
      copy->str= tables[i].table->null_flags;
15711
 
      copy->length= tables[i].table->s->null_bytes;
15712
 
      copy->strip=0;
15713
 
      copy->blob_field=0;
15714
 
      copy->get_rowid= NULL;
15715
 
      length+=copy->length;
15716
 
      copy++;
15717
 
      cache->fields++;
15718
 
    }
15719
 
    /* If outer join table, copy null_row flag */
15720
 
    if (tables[i].table->maybe_null)
15721
 
    {
15722
 
      copy->str= (uchar*) &tables[i].table->null_row;
15723
 
      copy->length=sizeof(tables[i].table->null_row);
15724
 
      copy->strip=0;
15725
 
      copy->blob_field=0;
15726
 
      copy->get_rowid= NULL;
15727
 
      length+=copy->length;
15728
 
      copy++;
15729
 
      cache->fields++;
15730
 
    }
15731
 
    /* SemiJoinDuplicateElimination: Allocate space for rowid if needed */
15732
 
    if (tables[i].rowid_keep_flags & JOIN_TAB::KEEP_ROWID)
15733
 
    {
15734
 
      copy->str= tables[i].table->file->ref;
15735
 
      copy->length= tables[i].table->file->ref_length;
15736
 
      copy->strip=0;
15737
 
      copy->blob_field=0;
15738
 
      copy->get_rowid= NULL;
15739
 
      if (tables[i].rowid_keep_flags & JOIN_TAB::CALL_POSITION)
15740
 
      {
15741
 
        /* We will need to call h->position(): */
15742
 
        copy->get_rowid= tables[i].table;
15743
 
        /* And those after us won't have to: */
15744
 
        tables[i].rowid_keep_flags &=  ~((int)JOIN_TAB::CALL_POSITION);
15745
 
      }
15746
 
      copy++;
15747
 
    }
15748
 
  }
15749
 
 
15750
 
  cache->length=length+blobs*sizeof(char*);
15751
 
  cache->blobs=blobs;
15752
 
  *blob_ptr=0;                                  /* End sequentel */
15753
 
  size=max(thd->variables.join_buff_size, (ulong)cache->length);
15754
 
  if (!(cache->buff=(uchar*) my_malloc(size,MYF(0))))
15755
 
    return(1);                          /* Don't use cache */ /* purecov: inspected */
15756
 
  cache->end=cache->buff+size;
15757
 
  reset_cache_write(cache);
15758
 
  return(0);
15759
 
}
15760
 
 
15761
 
 
15762
 
static ulong
15763
 
used_blob_length(CACHE_FIELD **ptr)
15764
 
{
15765
 
  uint length,blob_length;
15766
 
  for (length=0 ; *ptr ; ptr++)
15767
 
  {
15768
 
    (*ptr)->blob_length=blob_length=(*ptr)->blob_field->get_length();
15769
 
    length+=blob_length;
15770
 
    (*ptr)->blob_field->get_ptr(&(*ptr)->str);
15771
 
  }
15772
 
  return length;
15773
 
}
15774
 
 
15775
 
 
15776
 
static bool
15777
 
store_record_in_cache(JOIN_CACHE *cache)
15778
 
{
15779
 
  uint length;
15780
 
  uchar *pos;
15781
 
  CACHE_FIELD *copy,*end_field;
15782
 
  bool last_record;
15783
 
 
15784
 
  pos=cache->pos;
15785
 
  end_field=cache->field+cache->fields;
15786
 
 
15787
 
  length=cache->length;
15788
 
  if (cache->blobs)
15789
 
    length+=used_blob_length(cache->blob_ptr);
15790
 
  if ((last_record= (length + cache->length > (size_t) (cache->end - pos))))
15791
 
    cache->ptr_record=cache->records;
15792
 
  /*
15793
 
    There is room in cache. Put record there
15794
 
  */
15795
 
  cache->records++;
15796
 
  for (copy=cache->field ; copy < end_field; copy++)
15797
 
  {
15798
 
    if (copy->blob_field)
15799
 
    {
15800
 
      if (last_record)
15801
 
      {
15802
 
        copy->blob_field->get_image(pos, copy->length+sizeof(char*), 
15803
 
                                    copy->blob_field->charset());
15804
 
        pos+=copy->length+sizeof(char*);
15805
 
      }
15806
 
      else
15807
 
      {
15808
 
        copy->blob_field->get_image(pos, copy->length, // blob length
15809
 
                                    copy->blob_field->charset());
15810
 
        memcpy(pos+copy->length,copy->str,copy->blob_length);  // Blob data
15811
 
        pos+=copy->length+copy->blob_length;
15812
 
      }
15813
 
    }
15814
 
    else
15815
 
    {
15816
 
      // SemiJoinDuplicateElimination: Get the rowid into table->ref:
15817
 
      if (copy->get_rowid)
15818
 
        copy->get_rowid->file->position(copy->get_rowid->record[0]);
15819
 
 
15820
 
      if (copy->strip)
15821
 
      {
15822
 
        uchar *str,*end;
15823
 
        for (str=copy->str,end= str+copy->length;
15824
 
             end > str && end[-1] == ' ' ;
15825
 
             end--) ;
15826
 
        length=(uint) (end-str);
15827
 
        memcpy(pos+2, str, length);
15828
 
        int2store(pos, length);
15829
 
        pos+= length+2;
15830
 
      }
15831
 
      else
15832
 
      {
15833
 
        memcpy(pos,copy->str,copy->length);
15834
 
        pos+=copy->length;
15835
 
      }
15836
 
    }
15837
 
  }
15838
 
  cache->pos=pos;
15839
 
  return last_record || (size_t) (cache->end - pos) < cache->length;
15840
 
}
15841
 
 
15842
 
 
15843
 
static void
15844
 
reset_cache_read(JOIN_CACHE *cache)
15845
 
{
15846
 
  cache->record_nr=0;
15847
 
  cache->pos=cache->buff;
15848
 
}
15849
 
 
15850
 
 
15851
 
static void reset_cache_write(JOIN_CACHE *cache)
15852
 
{
15853
 
  reset_cache_read(cache);
15854
 
  cache->records= 0;
15855
 
  cache->ptr_record= (uint) ~0;
15856
 
}
15857
 
 
15858
 
 
15859
 
static void
15860
 
read_cached_record(JOIN_TAB *tab)
15861
 
{
15862
 
  uchar *pos;
15863
 
  uint length;
15864
 
  bool last_record;
15865
 
  CACHE_FIELD *copy,*end_field;
15866
 
 
15867
 
  last_record=tab->cache.record_nr++ == tab->cache.ptr_record;
15868
 
  pos=tab->cache.pos;
15869
 
  for (copy=tab->cache.field,end_field=copy+tab->cache.fields ;
15870
 
       copy < end_field;
15871
 
       copy++)
15872
 
  {
15873
 
    if (copy->blob_field)
15874
 
    {
15875
 
      if (last_record)
15876
 
      {
15877
 
        copy->blob_field->set_image(pos, copy->length+sizeof(char*),
15878
 
                                    copy->blob_field->charset());
15879
 
        pos+=copy->length+sizeof(char*);
15880
 
      }
15881
 
      else
15882
 
      {
15883
 
        copy->blob_field->set_ptr(pos, pos+copy->length);
15884
 
        pos+=copy->length+copy->blob_field->get_length();
15885
 
      }
15886
 
    }
15887
 
    else
15888
 
    {
15889
 
      if (copy->strip)
15890
 
      {
15891
 
        length= uint2korr(pos);
15892
 
        memcpy(copy->str, pos+2, length);
15893
 
        memset(copy->str+length, ' ', copy->length-length);
15894
 
        pos+= 2 + length;
15895
 
      }
15896
 
      else
15897
 
      {
15898
 
        memcpy(copy->str,pos,copy->length);
15899
 
        pos+=copy->length;
15900
 
      }
15901
 
    }
15902
 
  }
15903
 
  tab->cache.pos=pos;
15904
 
  return;
15905
 
}
15906
 
 
15907
 
 
15908
5557
/*
15909
5558
  eq_ref: Create the lookup key and check if it is the same as saved key
15910
5559
 
15911
5560
  SYNOPSIS
15912
5561
    cmp_buffer_with_ref()
15913
5562
      tab  Join tab of the accessed table
15914
 
 
15915
 
  DESCRIPTION 
15916
 
    Used by eq_ref access method: create the index lookup key and check if 
 
5563
 
 
5564
  DESCRIPTION
 
5565
    Used by eq_ref access method: create the index lookup key and check if
15917
5566
    we've used this key at previous lookup (If yes, we don't need to repeat
15918
5567
    the lookup - the record has been already fetched)
15919
5568
 
15920
 
  RETURN 
 
5569
  RETURN
15921
5570
    true   No cached record for the key, or failed to create the key (due to
15922
5571
           out-of-domain error)
15923
 
    false  The created key is the same as the previous one (and the record 
 
5572
    false  The created key is the same as the previous one (and the record
15924
5573
           is already in table->record)
15925
5574
*/
15926
 
 
15927
 
static bool
15928
 
cmp_buffer_with_ref(JOIN_TAB *tab)
 
5575
static bool cmp_buffer_with_ref(JoinTable *tab)
15929
5576
{
15930
5577
  bool no_prev_key;
15931
5578
  if (!tab->ref.disable_cache)
15936
5583
      memcpy(tab->ref.key_buff2, tab->ref.key_buff, tab->ref.key_length);
15937
5584
    }
15938
5585
  }
15939
 
  else 
 
5586
  else
15940
5587
    no_prev_key= true;
15941
 
  if ((tab->ref.key_err= cp_buffer_from_ref(tab->join->thd, tab->table,
15942
 
                                            &tab->ref)) ||
 
5588
  if ((tab->ref.key_err= cp_buffer_from_ref(tab->join->session, &tab->ref)) ||
15943
5589
      no_prev_key)
15944
5590
    return 1;
15945
5591
  return memcmp(tab->ref.key_buff2, tab->ref.key_buff, tab->ref.key_length)
15946
5592
    != 0;
15947
5593
}
15948
5594
 
15949
 
 
15950
 
bool
15951
 
cp_buffer_from_ref(THD *thd, TABLE *table, TABLE_REF *ref)
 
5595
bool cp_buffer_from_ref(Session *session, table_reference_st *ref)
15952
5596
{
15953
 
  enum enum_check_fields save_count_cuted_fields= thd->count_cuted_fields;
15954
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
15955
 
  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
 
5597
  enum enum_check_fields save_count_cuted_fields= session->count_cuted_fields;
 
5598
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
15956
5599
  bool result= 0;
15957
5600
 
15958
 
  for (store_key **copy=ref->key_copy ; *copy ; copy++)
 
5601
  for (StoredKey **copy=ref->key_copy ; *copy ; copy++)
15959
5602
  {
15960
5603
    if ((*copy)->copy() & 1)
15961
5604
    {
15963
5606
      break;
15964
5607
    }
15965
5608
  }
15966
 
  thd->count_cuted_fields= save_count_cuted_fields;
15967
 
  dbug_tmp_restore_column_map(table->write_set, old_map);
 
5609
  session->count_cuted_fields= save_count_cuted_fields;
15968
5610
  return result;
15969
5611
}
15970
5612
 
15971
 
 
15972
5613
/*****************************************************************************
15973
5614
  Group and order functions
15974
5615
*****************************************************************************/
15975
5616
 
15976
5617
/**
15977
 
  Resolve an ORDER BY or GROUP BY column reference.
 
5618
  Resolve an order_st BY or GROUP BY column reference.
15978
5619
 
15979
 
  Given a column reference (represented by 'order') from a GROUP BY or ORDER
 
5620
  Given a column reference (represented by 'order') from a GROUP BY or order_st
15980
5621
  BY clause, find the actual column it represents. If the column being
15981
5622
  resolved is from the GROUP BY clause, the procedure searches the SELECT
15982
5623
  list 'fields' and the columns in the FROM list 'tables'. If 'order' is from
15983
 
  the ORDER BY clause, only the SELECT list is being searched.
 
5624
  the order_st BY clause, only the SELECT list is being searched.
15984
5625
 
15985
5626
  If 'order' is resolved to an Item, then order->item is set to the found
15986
5627
  Item. If there is no item for the found column (that is, it was resolved
15989
5630
 
15990
5631
  ref_pointer_array and all_fields are updated.
15991
5632
 
15992
 
  @param[in] thd                     Pointer to current thread structure
 
5633
  @param[in] session                 Pointer to current thread structure
15993
5634
  @param[in,out] ref_pointer_array  All select, group and order by fields
15994
5635
  @param[in] tables                 List of tables to search in (usually
15995
5636
    FROM clause)
15998
5639
    SELECT list)
15999
5640
  @param[in,out] all_fields         All select, group and order by fields
16000
5641
  @param[in] is_group_field         True if order is a GROUP field, false if
16001
 
    ORDER by field
 
5642
    order_st by field
16002
5643
 
16003
5644
  @retval
16004
5645
    false if OK
16005
5646
  @retval
16006
5647
    true  if error occurred
16007
5648
*/
16008
 
 
16009
 
static bool
16010
 
find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
16011
 
                   ORDER *order, List<Item> &fields, List<Item> &all_fields,
16012
 
                   bool is_group_field)
 
5649
static bool find_order_in_list(Session *session, 
 
5650
                               Item **ref_pointer_array, 
 
5651
                               TableList *tables,
 
5652
                               order_st *order,
 
5653
                               List<Item> &fields,
 
5654
                               List<Item> &all_fields,
 
5655
                               bool is_group_field)
16013
5656
{
16014
 
  Item *order_item= *order->item; /* The item from the GROUP/ORDER caluse. */
 
5657
  Item *order_item= *order->item; /* The item from the GROUP/order_st caluse. */
16015
5658
  Item::Type order_item_type;
16016
5659
  Item **select_item; /* The corresponding item from the SELECT clause. */
16017
5660
  Field *from_field;  /* The corresponding field from the FROM clause. */
16018
 
  uint counter;
 
5661
  uint32_t counter;
16019
5662
  enum_resolution_type resolution;
16020
5663
 
16021
5664
  /*
16024
5667
  */
16025
5668
  if (order_item->type() == Item::INT_ITEM && order_item->basic_const_item())
16026
5669
  {                                             /* Order by position */
16027
 
    uint count= (uint) order_item->val_int();
 
5670
    uint32_t count= (uint32_t) order_item->val_int();
16028
5671
    if (!count || count > fields.elements)
16029
5672
    {
16030
5673
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
16031
 
               order_item->full_name(), thd->where);
 
5674
               order_item->full_name(), session->where);
16032
5675
      return true;
16033
5676
    }
16034
5677
    order->item= ref_pointer_array + count - 1;
16037
5680
    order->counter_used= 1;
16038
5681
    return false;
16039
5682
  }
16040
 
  /* Lookup the current GROUP/ORDER field in the SELECT clause. */
 
5683
  /* Lookup the current GROUP/order_st field in the SELECT clause. */
16041
5684
  select_item= find_item_in_list(order_item, fields, &counter,
16042
5685
                                 REPORT_EXCEPT_NOT_FOUND, &resolution);
16043
5686
  if (!select_item)
16054
5697
      for this name (in case if we would perform lookup in all tables).
16055
5698
    */
16056
5699
    if (resolution == RESOLVED_BEHIND_ALIAS && !order_item->fixed &&
16057
 
        order_item->fix_fields(thd, order->item))
 
5700
        order_item->fix_fields(session, order->item))
16058
5701
      return true;
16059
5702
 
16060
5703
    /* Lookup the current GROUP field in the FROM clause. */
16063
5706
    if ((is_group_field && order_item_type == Item::FIELD_ITEM) ||
16064
5707
        order_item_type == Item::REF_ITEM)
16065
5708
    {
16066
 
      from_field= find_field_in_tables(thd, (Item_ident*) order_item, tables,
16067
 
                                       NULL, &view_ref, IGNORE_ERRORS, true,
16068
 
                                       false);
 
5709
      from_field= find_field_in_tables(session, (Item_ident*) order_item, tables,
 
5710
                                       NULL, &view_ref, IGNORE_ERRORS, false);
16069
5711
      if (!from_field)
16070
5712
        from_field= (Field*) not_found_field;
16071
5713
    }
16103
5745
        warning so the user knows that the field from the FROM clause
16104
5746
        overshadows the column reference from the SELECT list.
16105
5747
      */
16106
 
      push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
 
5748
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
16107
5749
                          ER(ER_NON_UNIQ_ERROR),
16108
5750
                          ((Item_ident*) order_item)->field_name,
16109
 
                          current_thd->where);
 
5751
                          current_session->where);
16110
5752
    }
16111
5753
  }
16112
5754
 
16123
5765
    arguments for which fix_fields already was called.
16124
5766
  */
16125
5767
  if (!order_item->fixed &&
16126
 
      (order_item->fix_fields(thd, order->item) ||
 
5768
      (order_item->fix_fields(session, order->item) ||
16127
5769
       (order_item= *order->item)->check_cols(1) ||
16128
 
       thd->is_fatal_error))
 
5770
       session->is_fatal_error))
16129
5771
    return true; /* Wrong field. */
16130
5772
 
16131
 
  uint el= all_fields.elements;
 
5773
  uint32_t el= all_fields.elements;
16132
5774
  all_fields.push_front(order_item); /* Add new field to field list. */
16133
5775
  ref_pointer_array[el]= order_item;
16134
5776
  order->item= ref_pointer_array + el;
16135
5777
  return false;
16136
5778
}
16137
5779
 
16138
 
 
16139
5780
/**
16140
5781
  Change order to point at item in select list.
16141
5782
 
16142
5783
  If item isn't a number and doesn't exits in the select list, add it the
16143
5784
  the field list.
16144
5785
*/
16145
 
 
16146
 
int setup_order(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
16147
 
                List<Item> &fields, List<Item> &all_fields, ORDER *order)
 
5786
int setup_order(Session *session,
 
5787
                Item **ref_pointer_array,
 
5788
                TableList *tables,
 
5789
                            List<Item> &fields,
 
5790
                List<Item> &all_fields,
 
5791
                order_st *order)
16148
5792
{
16149
 
  thd->where="order clause";
 
5793
  session->where="order clause";
16150
5794
  for (; order; order=order->next)
16151
5795
  {
16152
 
    if (find_order_in_list(thd, ref_pointer_array, tables, order, fields,
 
5796
    if (find_order_in_list(session, ref_pointer_array, tables, order, fields,
16153
5797
                           all_fields, false))
16154
5798
      return 1;
16155
5799
  }
16156
5800
  return 0;
16157
5801
}
16158
5802
 
16159
 
 
16160
5803
/**
16161
5804
  Intitialize the GROUP BY list.
16162
5805
 
16163
 
  @param thd                    Thread handler
 
5806
  @param session                        Thread Cursor
16164
5807
  @param ref_pointer_array      We store references to all fields that was
16165
5808
                               not in 'fields' here.
16166
5809
  @param fields         All fields in the select part. Any item in
16182
5825
  @retval
16183
5826
    1  error (probably out of memory)
16184
5827
*/
16185
 
 
16186
 
int
16187
 
setup_group(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
16188
 
            List<Item> &fields, List<Item> &all_fields, ORDER *order,
16189
 
            bool *hidden_group_fields)
 
5828
int setup_group(Session *session,
 
5829
                Item **ref_pointer_array,
 
5830
                TableList *tables,
 
5831
                      List<Item> &fields,
 
5832
                List<Item> &all_fields,
 
5833
                order_st *order,
 
5834
                      bool *hidden_group_fields)
16190
5835
{
16191
5836
  *hidden_group_fields=0;
16192
 
  ORDER *ord;
 
5837
  order_st *ord;
16193
5838
 
16194
5839
  if (!order)
16195
5840
    return 0;                           /* Everything is ok */
16196
5841
 
16197
 
  uint org_fields=all_fields.elements;
 
5842
  uint32_t org_fields=all_fields.elements;
16198
5843
 
16199
 
  thd->where="group statement";
 
5844
  session->where="group statement";
16200
5845
  for (ord= order; ord; ord= ord->next)
16201
5846
  {
16202
 
    if (find_order_in_list(thd, ref_pointer_array, tables, ord, fields,
 
5847
    if (find_order_in_list(session, ref_pointer_array, tables, ord, fields,
16203
5848
                           all_fields, true))
16204
5849
      return 1;
16205
5850
    (*ord->item)->marker= UNDEF_POS;            /* Mark found */
16230
5875
    Item_field *field;
16231
5876
    int cur_pos_in_select_list= 0;
16232
5877
    List_iterator<Item> li(fields);
16233
 
    List_iterator<Item_field> naf_it(thd->lex->current_select->non_agg_fields);
 
5878
    List_iterator<Item_field> naf_it(session->lex->current_select->non_agg_fields);
16234
5879
 
16235
5880
    field= naf_it++;
16236
5881
    while (field && (item=li++))
16279
5924
  Try to use the fields in the order given by 'order' to allow one to
16280
5925
  optimize away 'order by'.
16281
5926
*/
16282
 
 
16283
 
static ORDER *
16284
 
create_distinct_group(THD *thd, Item **ref_pointer_array,
16285
 
                      ORDER *order_list, List<Item> &fields,
16286
 
                      List<Item> &all_fields __attribute__((unused)),
16287
 
                      bool *all_order_by_fields_used)
 
5927
order_st *create_distinct_group(Session *session,
 
5928
                                Item **ref_pointer_array,
 
5929
                                order_st *order_list,
 
5930
                                List<Item> &fields,
 
5931
                                List<Item> &,
 
5932
                                bool *all_order_by_fields_used)
16288
5933
{
16289
5934
  List_iterator<Item> li(fields);
16290
5935
  Item *item;
16291
 
  ORDER *order,*group,**prev;
 
5936
  order_st *order,*group,**prev;
16292
5937
 
16293
5938
  *all_order_by_fields_used= 1;
16294
5939
  while ((item=li++))
16299
5944
  {
16300
5945
    if (order->in_field_list)
16301
5946
    {
16302
 
      ORDER *ord=(ORDER*) thd->memdup((char*) order,sizeof(ORDER));
 
5947
      order_st *ord=(order_st*) session->memdup((char*) order,sizeof(order_st));
16303
5948
      if (!ord)
16304
 
        return 0;
 
5949
        return 0;
16305
5950
      *prev=ord;
16306
5951
      prev= &ord->next;
16307
5952
      (*ord->item)->marker=1;
16315
5960
  {
16316
5961
    if (!item->const_item() && !item->with_sum_func && !item->marker)
16317
5962
    {
16318
 
      /* 
16319
 
        Don't put duplicate columns from the SELECT list into the 
 
5963
      /*
 
5964
        Don't put duplicate columns from the SELECT list into the
16320
5965
        GROUP BY list.
16321
5966
      */
16322
 
      ORDER *ord_iter;
 
5967
      order_st *ord_iter;
16323
5968
      for (ord_iter= group; ord_iter; ord_iter= ord_iter->next)
16324
5969
        if ((*ord_iter->item)->eq(item, 1))
16325
5970
          goto next_item;
16326
 
      
16327
 
      ORDER *ord=(ORDER*) thd->calloc(sizeof(ORDER));
 
5971
 
 
5972
      order_st *ord=(order_st*) session->calloc(sizeof(order_st));
16328
5973
      if (!ord)
16329
 
        return 0;
 
5974
        return 0;
16330
5975
 
16331
5976
      /*
16332
5977
        We have here only field_list (not all_field_list), so we can use
16345
5990
  return group;
16346
5991
}
16347
5992
 
16348
 
 
16349
5993
/**
16350
5994
  Update join with count of the different type of fields.
16351
5995
*/
16352
 
 
16353
 
void
16354
 
count_field_types(SELECT_LEX *select_lex, TMP_TABLE_PARAM *param, 
16355
 
                  List<Item> &fields, bool reset_with_sum_func)
 
5996
void count_field_types(Select_Lex *select_lex, Tmp_Table_Param *param, List<Item> &fields, bool reset_with_sum_func)
16356
5997
{
16357
5998
  List_iterator<Item> li(fields);
16358
5999
  Item *field;
16369
6010
    {
16370
6011
      if (! field->const_item())
16371
6012
      {
16372
 
        Item_sum *sum_item=(Item_sum*) field->real_item();
 
6013
        Item_sum *sum_item=(Item_sum*) field->real_item();
16373
6014
        if (!sum_item->depended_from() ||
16374
6015
            sum_item->depended_from() == select_lex)
16375
6016
        {
16377
6018
            param->quick_group=0;                       // UDF SUM function
16378
6019
          param->sum_func_count++;
16379
6020
 
16380
 
          for (uint i=0 ; i < sum_item->arg_count ; i++)
 
6021
          for (uint32_t i=0 ; i < sum_item->arg_count ; i++)
16381
6022
          {
16382
6023
            if (sum_item->args[0]->real_item()->type() == Item::FIELD_ITEM)
16383
6024
              param->field_count++;
16392
6033
    {
16393
6034
      param->func_count++;
16394
6035
      if (reset_with_sum_func)
16395
 
        field->with_sum_func=0;
16396
 
    }
16397
 
  }
16398
 
}
16399
 
 
16400
 
 
16401
 
/**
16402
 
  Return 1 if second is a subpart of first argument.
16403
 
 
16404
 
  If first parts has different direction, change it to second part
16405
 
  (group is sorted like order)
16406
 
*/
16407
 
 
16408
 
static bool
16409
 
test_if_subpart(ORDER *a,ORDER *b)
16410
 
{
16411
 
  for (; a && b; a=a->next,b=b->next)
16412
 
  {
16413
 
    if ((*a->item)->eq(*b->item,1))
16414
 
      a->asc=b->asc;
16415
 
    else
16416
 
      return 0;
16417
 
  }
16418
 
  return test(!b);
16419
 
}
16420
 
 
16421
 
/**
16422
 
  Return table number if there is only one table in sort order
16423
 
  and group and order is compatible, else return 0.
16424
 
*/
16425
 
 
16426
 
static TABLE *
16427
 
get_sort_by_table(ORDER *a,ORDER *b,TABLE_LIST *tables)
16428
 
{
16429
 
  table_map map= (table_map) 0;
16430
 
 
16431
 
  if (!a)
16432
 
    a=b;                                        // Only one need to be given
16433
 
  else if (!b)
16434
 
    b=a;
16435
 
 
16436
 
  for (; a && b; a=a->next,b=b->next)
16437
 
  {
16438
 
    if (!(*a->item)->eq(*b->item,1))
16439
 
      return(0);
16440
 
    map|=a->item[0]->used_tables();
16441
 
  }
16442
 
  if (!map || (map & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT)))
16443
 
    return(0);
16444
 
 
16445
 
  for (; !(map & tables->table->map); tables= tables->next_leaf) {};
16446
 
  if (map != tables->table->map)
16447
 
    return(0);                          // More than one table
16448
 
  return(tables->table);
16449
 
}
16450
 
 
16451
 
 
16452
 
/**
16453
 
  calc how big buffer we need for comparing group entries.
16454
 
*/
16455
 
 
16456
 
static void
16457
 
calc_group_buffer(JOIN *join,ORDER *group)
16458
 
{
16459
 
  uint key_length=0, parts=0, null_parts=0;
16460
 
 
16461
 
  if (group)
16462
 
    join->group= 1;
16463
 
  for (; group ; group=group->next)
16464
 
  {
16465
 
    Item *group_item= *group->item;
16466
 
    Field *field= group_item->get_tmp_table_field();
16467
 
    if (field)
16468
 
    {
16469
 
      enum_field_types type;
16470
 
      if ((type= field->type()) == DRIZZLE_TYPE_BLOB)
16471
 
        key_length+=MAX_BLOB_WIDTH;             // Can't be used as a key
16472
 
      else if (type == DRIZZLE_TYPE_VARCHAR)
16473
 
        key_length+= field->field_length + HA_KEY_BLOB_LENGTH;
16474
 
      else
16475
 
        key_length+= field->pack_length();
16476
 
    }
16477
 
    else
16478
 
    { 
16479
 
      switch (group_item->result_type()) {
16480
 
      case REAL_RESULT:
16481
 
        key_length+= sizeof(double);
16482
 
        break;
16483
 
      case INT_RESULT:
16484
 
        key_length+= sizeof(int64_t);
16485
 
        break;
16486
 
      case DECIMAL_RESULT:
16487
 
        key_length+= my_decimal_get_binary_size(group_item->max_length - 
16488
 
                                                (group_item->decimals ? 1 : 0),
16489
 
                                                group_item->decimals);
16490
 
        break;
16491
 
      case STRING_RESULT:
16492
 
      {
16493
 
        enum enum_field_types type= group_item->field_type();
16494
 
        /*
16495
 
          As items represented as DATE/TIME fields in the group buffer
16496
 
          have STRING_RESULT result type, we increase the length 
16497
 
          by 8 as maximum pack length of such fields.
16498
 
        */
16499
 
        if (type == DRIZZLE_TYPE_TIME ||
16500
 
            type == DRIZZLE_TYPE_NEWDATE ||
16501
 
            type == DRIZZLE_TYPE_DATETIME ||
16502
 
            type == DRIZZLE_TYPE_TIMESTAMP)
16503
 
        {
16504
 
          key_length+= 8;
16505
 
        }
16506
 
        else
16507
 
        {
16508
 
          /*
16509
 
            Group strings are taken as varstrings and require an length field.
16510
 
            A field is not yet created by create_tmp_field()
16511
 
            and the sizes should match up.
16512
 
          */
16513
 
          key_length+= group_item->max_length + HA_KEY_BLOB_LENGTH;
16514
 
        }
16515
 
        break;
16516
 
      }
16517
 
      default:
16518
 
        /* This case should never be choosen */
16519
 
        assert(0);
16520
 
        my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR));
16521
 
      }
16522
 
    }
16523
 
    parts++;
16524
 
    if (group_item->maybe_null)
16525
 
      null_parts++;
16526
 
  }
16527
 
  join->tmp_table_param.group_length=key_length+null_parts;
16528
 
  join->tmp_table_param.group_parts=parts;
16529
 
  join->tmp_table_param.group_null_parts=null_parts;
16530
 
}
16531
 
 
16532
 
 
16533
 
/**
16534
 
  allocate group fields or take prepared (cached).
16535
 
 
16536
 
  @param main_join   join of current select
16537
 
  @param curr_join   current join (join of current select or temporary copy
16538
 
                     of it)
16539
 
 
16540
 
  @retval
16541
 
    0   ok
16542
 
  @retval
16543
 
    1   failed
16544
 
*/
16545
 
 
16546
 
static bool
16547
 
make_group_fields(JOIN *main_join, JOIN *curr_join)
16548
 
{
16549
 
  if (main_join->group_fields_cache.elements)
16550
 
  {
16551
 
    curr_join->group_fields= main_join->group_fields_cache;
16552
 
    curr_join->sort_and_group= 1;
16553
 
  }
16554
 
  else
16555
 
  {
16556
 
    if (alloc_group_fields(curr_join, curr_join->group_list))
16557
 
      return (1);
16558
 
    main_join->group_fields_cache= curr_join->group_fields;
16559
 
  }
16560
 
  return (0);
16561
 
}
16562
 
 
16563
 
 
16564
 
/**
16565
 
  Get a list of buffers for saveing last group.
16566
 
 
16567
 
  Groups are saved in reverse order for easyer check loop.
16568
 
*/
16569
 
 
16570
 
static bool
16571
 
alloc_group_fields(JOIN *join,ORDER *group)
16572
 
{
16573
 
  if (group)
16574
 
  {
16575
 
    for (; group ; group=group->next)
16576
 
    {
16577
 
      Cached_item *tmp=new_Cached_item(join->thd, *group->item, false);
16578
 
      if (!tmp || join->group_fields.push_front(tmp))
16579
 
        return true;
16580
 
    }
16581
 
  }
16582
 
  join->sort_and_group=1;                       /* Mark for do_select */
16583
 
  return false;
16584
 
}
16585
 
 
 
6036
        field->with_sum_func=0;
 
6037
    }
 
6038
  }
 
6039
}
16586
6040
 
16587
6041
/*
16588
6042
  Test if a single-row cache of items changed, and update the cache.
16590
6044
  @details Test if a list of items that typically represents a result
16591
6045
  row has changed. If the value of some item changed, update the cached
16592
6046
  value for this item.
16593
 
  
 
6047
 
16594
6048
  @param list list of <item, cached_value> pairs stored as Cached_item.
16595
6049
 
16596
6050
  @return -1 if no item changed
16597
6051
  @return index of the first item that changed
16598
6052
*/
16599
 
 
16600
6053
int test_if_item_cache_changed(List<Cached_item> &list)
16601
6054
{
16602
6055
  List_iterator<Cached_item> li(list);
16611
6064
  return(idx);
16612
6065
}
16613
6066
 
16614
 
 
16615
6067
/**
16616
6068
  Setup copy_fields to save fields at start of new group.
16617
6069
 
16621
6073
  Change old item_field to use a new field with points at saved fieldvalue
16622
6074
  This function is only called before use of send_fields.
16623
6075
 
16624
 
  @param thd                   THD pointer
 
6076
  @param session                   Session pointer
16625
6077
  @param param                 temporary table parameters
16626
6078
  @param ref_pointer_array     array of pointers to top elements of filed list
16627
6079
  @param res_selected_fields   new list of items of select item list
16640
6092
  @retval
16641
6093
    !=0   error
16642
6094
*/
16643
 
 
16644
 
bool
16645
 
setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
16646
 
                  Item **ref_pointer_array,
16647
 
                  List<Item> &res_selected_fields, List<Item> &res_all_fields,
16648
 
                  uint elements, List<Item> &all_fields)
 
6095
bool setup_copy_fields(Session *session,
 
6096
                       Tmp_Table_Param *param,
 
6097
                       Item **ref_pointer_array,
 
6098
                       List<Item> &res_selected_fields,
 
6099
                       List<Item> &res_all_fields,
 
6100
                       uint32_t elements,
 
6101
                       List<Item> &all_fields)
16649
6102
{
16650
6103
  Item *pos;
16651
6104
  List_iterator_fast<Item> li(all_fields);
16652
 
  Copy_field *copy= NULL;
 
6105
  CopyField *copy= NULL;
16653
6106
  res_selected_fields.empty();
16654
6107
  res_all_fields.empty();
16655
6108
  List_iterator_fast<Item> itr(res_all_fields);
16656
6109
  List<Item> extra_funcs;
16657
 
  uint i, border= all_fields.elements - elements;
 
6110
  uint32_t i, border= all_fields.elements - elements;
16658
6111
 
16659
 
  if (param->field_count && 
16660
 
      !(copy=param->copy_field= new Copy_field[param->field_count]))
 
6112
  if (param->field_count &&
 
6113
      !(copy=param->copy_field= new CopyField[param->field_count]))
16661
6114
    goto err2;
16662
6115
 
16663
6116
  param->copy_funcs.empty();
16664
6117
  for (i= 0; (pos= li++); i++)
16665
6118
  {
16666
6119
    Field *field;
16667
 
    uchar *tmp;
 
6120
    unsigned char *tmp;
16668
6121
    Item *real_pos= pos->real_item();
16669
6122
    if (real_pos->type() == Item::FIELD_ITEM)
16670
6123
    {
16671
6124
      Item_field *item;
16672
 
      if (!(item= new Item_field(thd, ((Item_field*) real_pos))))
16673
 
        goto err;
 
6125
      if (!(item= new Item_field(session, ((Item_field*) real_pos))))
 
6126
        goto err;
16674
6127
      if (pos->type() == Item::REF_ITEM)
16675
6128
      {
16676
6129
        /* preserve the names of the ref when dereferncing */
16682
6135
      pos= item;
16683
6136
      if (item->field->flags & BLOB_FLAG)
16684
6137
      {
16685
 
        if (!(pos= new Item_copy_string(pos)))
16686
 
          goto err;
16687
 
       /*
16688
 
         Item_copy_string::copy for function can call 
16689
 
         Item_copy_string::val_int for blob via Item_ref.
16690
 
         But if Item_copy_string::copy for blob isn't called before,
16691
 
         it's value will be wrong
16692
 
         so let's insert Item_copy_string for blobs in the beginning of 
16693
 
         copy_funcs
16694
 
         (to see full test case look at having.test, BUG #4358) 
16695
 
       */
16696
 
        if (param->copy_funcs.push_front(pos))
16697
 
          goto err;
 
6138
        if (!(pos= new Item_copy_string(pos)))
 
6139
          goto err;
 
6140
            /*
 
6141
              Item_copy_string::copy for function can call
 
6142
              Item_copy_string::val_int for blob via Item_ref.
 
6143
              But if Item_copy_string::copy for blob isn't called before,
 
6144
              it's value will be wrong
 
6145
              so let's insert Item_copy_string for blobs in the beginning of
 
6146
              copy_funcs
 
6147
              (to see full test case look at having.test, BUG #4358)
 
6148
            */
 
6149
        if (param->copy_funcs.push_front(pos))
 
6150
          goto err;
16698
6151
      }
16699
6152
      else
16700
6153
      {
16701
 
        /* 
16702
 
           set up save buffer and change result_field to point at 
16703
 
           saved value
16704
 
        */
16705
 
        field= item->field;
16706
 
        item->result_field=field->new_field(thd->mem_root,field->table, 1);
16707
6154
        /*
16708
 
          We need to allocate one extra byte for null handling and
16709
 
          another extra byte to not get warnings from purify in
16710
 
          Field_varstring::val_int
 
6155
          set up save buffer and change result_field to point at
 
6156
          saved value
16711
6157
        */
16712
 
        if (!(tmp= (uchar*) sql_alloc(field->pack_length()+2)))
16713
 
          goto err;
 
6158
        field= item->field;
 
6159
        item->result_field=field->new_field(session->mem_root,field->table, 1);
 
6160
              /*
 
6161
                We need to allocate one extra byte for null handling and
 
6162
                another extra byte to not get warnings from purify in
 
6163
                Field_varstring::val_int
 
6164
              */
 
6165
        if (!(tmp= (unsigned char*) sql_alloc(field->pack_length()+2)))
 
6166
          goto err;
16714
6167
        if (copy)
16715
6168
        {
16716
6169
          copy->set(tmp, item->result_field);
16730
6183
    {                                           // Save for send fields
16731
6184
      pos= real_pos;
16732
6185
      /* TODO:
16733
 
         In most cases this result will be sent to the user.
16734
 
         This should be changed to use copy_int or copy_real depending
16735
 
         on how the value is to be used: In some cases this may be an
16736
 
         argument in a group function, like: IF(ISNULL(col),0,COUNT(*))
 
6186
        In most cases this result will be sent to the user.
 
6187
        This should be changed to use copy_int or copy_real depending
 
6188
        on how the value is to be used: In some cases this may be an
 
6189
        argument in a group function, like: IF(ISNULL(col),0,COUNT(*))
16737
6190
      */
16738
6191
      if (!(pos=new Item_copy_string(pos)))
16739
 
        goto err;
16740
 
      if (i < border)                           // HAVING, ORDER and GROUP BY
 
6192
        goto err;
 
6193
      if (i < border)                           // HAVING, order_st and GROUP BY
16741
6194
      {
16742
6195
        if (extra_funcs.push_back(pos))
16743
6196
          goto err;
16744
6197
      }
16745
6198
      else if (param->copy_funcs.push_back(pos))
16746
 
        goto err;
 
6199
        goto err;
16747
6200
    }
16748
6201
    res_all_fields.push_back(pos);
16749
6202
    ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
16755
6208
    itr++;
16756
6209
  itr.sublist(res_selected_fields, elements);
16757
6210
  /*
16758
 
    Put elements from HAVING, ORDER BY and GROUP BY last to ensure that any
 
6211
    Put elements from HAVING, order_st BY and GROUP BY last to ensure that any
16759
6212
    reference used in these will resolve to a item that is already calculated
16760
6213
  */
16761
6214
  param->copy_funcs.concat(&extra_funcs);
16762
6215
 
16763
6216
  return(0);
16764
6217
 
16765
 
 err:
 
6218
err:
16766
6219
  if (copy)
16767
6220
    delete [] param->copy_field;                        // This is never 0
16768
6221
  param->copy_field=0;
16770
6223
  return(true);
16771
6224
}
16772
6225
 
16773
 
 
16774
6226
/**
16775
6227
  Make a copy of all simple SELECT'ed items.
16776
6228
 
16777
6229
  This is done at the start of a new group so that we can retrieve
16778
6230
  these later when the group changes.
16779
6231
*/
16780
 
 
16781
 
void
16782
 
copy_fields(TMP_TABLE_PARAM *param)
 
6232
void copy_fields(Tmp_Table_Param *param)
16783
6233
{
16784
 
  Copy_field *ptr=param->copy_field;
16785
 
  Copy_field *end=param->copy_field_end;
 
6234
  CopyField *ptr= param->copy_field;
 
6235
  CopyField *end= param->copy_field_end;
16786
6236
 
16787
6237
  for (; ptr != end; ptr++)
16788
6238
    (*ptr->do_copy)(ptr);
16793
6243
    item->copy();
16794
6244
}
16795
6245
 
16796
 
 
16797
 
/**
16798
 
  Make an array of pointers to sum_functions to speed up
16799
 
  sum_func calculation.
16800
 
 
16801
 
  @retval
16802
 
    0   ok
16803
 
  @retval
16804
 
    1   Error
16805
 
*/
16806
 
 
16807
 
bool JOIN::alloc_func_list()
16808
 
{
16809
 
  uint func_count, group_parts;
16810
 
 
16811
 
  func_count= tmp_table_param.sum_func_count;
16812
 
  /*
16813
 
    If we are using rollup, we need a copy of the summary functions for
16814
 
    each level
16815
 
  */
16816
 
  if (rollup.state != ROLLUP::STATE_NONE)
16817
 
    func_count*= (send_group_parts+1);
16818
 
 
16819
 
  group_parts= send_group_parts;
16820
 
  /*
16821
 
    If distinct, reserve memory for possible
16822
 
    disctinct->group_by optimization
16823
 
  */
16824
 
  if (select_distinct)
16825
 
  {
16826
 
    group_parts+= fields_list.elements;
16827
 
    /*
16828
 
      If the ORDER clause is specified then it's possible that
16829
 
      it also will be optimized, so reserve space for it too
16830
 
    */
16831
 
    if (order)
16832
 
    {
16833
 
      ORDER *ord;
16834
 
      for (ord= order; ord; ord= ord->next)
16835
 
        group_parts++;
16836
 
    }
16837
 
  }
16838
 
 
16839
 
  /* This must use calloc() as rollup_make_fields depends on this */
16840
 
  sum_funcs= (Item_sum**) thd->calloc(sizeof(Item_sum**) * (func_count+1) +
16841
 
                                      sizeof(Item_sum***) * (group_parts+1));
16842
 
  sum_funcs_end= (Item_sum***) (sum_funcs+func_count+1);
16843
 
  return(sum_funcs == 0);
16844
 
}
16845
 
 
16846
 
 
16847
 
/**
16848
 
  Initialize 'sum_funcs' array with all Item_sum objects.
16849
 
 
16850
 
  @param field_list        All items
16851
 
  @param send_fields       Items in select list
16852
 
  @param before_group_by   Set to 1 if this is called before GROUP BY handling
16853
 
  @param recompute         Set to true if sum_funcs must be recomputed
16854
 
 
16855
 
  @retval
16856
 
    0  ok
16857
 
  @retval
16858
 
    1  error
16859
 
*/
16860
 
 
16861
 
bool JOIN::make_sum_func_list(List<Item> &field_list, List<Item> &send_fields,
16862
 
                              bool before_group_by, bool recompute)
16863
 
{
16864
 
  List_iterator_fast<Item> it(field_list);
16865
 
  Item_sum **func;
16866
 
  Item *item;
16867
 
 
16868
 
  if (*sum_funcs && !recompute)
16869
 
    return(false); /* We have already initialized sum_funcs. */
16870
 
 
16871
 
  func= sum_funcs;
16872
 
  while ((item=it++))
16873
 
  {
16874
 
    if (item->type() == Item::SUM_FUNC_ITEM && !item->const_item() &&
16875
 
        (!((Item_sum*) item)->depended_from() ||
16876
 
         ((Item_sum *)item)->depended_from() == select_lex))
16877
 
      *func++= (Item_sum*) item;
16878
 
  }
16879
 
  if (before_group_by && rollup.state == ROLLUP::STATE_INITED)
16880
 
  {
16881
 
    rollup.state= ROLLUP::STATE_READY;
16882
 
    if (rollup_make_fields(field_list, send_fields, &func))
16883
 
      return(true);                     // Should never happen
16884
 
  }
16885
 
  else if (rollup.state == ROLLUP::STATE_NONE)
16886
 
  {
16887
 
    for (uint i=0 ; i <= send_group_parts ;i++)
16888
 
      sum_funcs_end[i]= func;
16889
 
  }
16890
 
  else if (rollup.state == ROLLUP::STATE_READY)
16891
 
    return(false);                         // Don't put end marker
16892
 
  *func=0;                                      // End marker
16893
 
  return(false);
16894
 
}
16895
 
 
16896
 
 
16897
6246
/**
16898
6247
  Change all funcs and sum_funcs to fields in tmp table, and create
16899
6248
  new list of all items.
16900
6249
 
16901
 
  @param thd                   THD pointer
 
6250
  @param session                   Session pointer
16902
6251
  @param ref_pointer_array     array of pointers to top elements of filed list
16903
6252
  @param res_selected_fields   new list of items of select item list
16904
6253
  @param res_all_fields        new list of all items
16910
6259
  @retval
16911
6260
    !=0   error
16912
6261
*/
16913
 
 
16914
 
static bool
16915
 
change_to_use_tmp_fields(THD *thd, Item **ref_pointer_array,
16916
 
                         List<Item> &res_selected_fields,
16917
 
                         List<Item> &res_all_fields,
16918
 
                         uint elements, List<Item> &all_fields)
 
6262
bool change_to_use_tmp_fields(Session *session,
 
6263
                              Item **ref_pointer_array,
 
6264
                                                List<Item> &res_selected_fields,
 
6265
                                                List<Item> &res_all_fields,
 
6266
                                                uint32_t elements,
 
6267
                              List<Item> &all_fields)
16919
6268
{
16920
6269
  List_iterator_fast<Item> it(all_fields);
16921
6270
  Item *item_field,*item;
16923
6272
  res_selected_fields.empty();
16924
6273
  res_all_fields.empty();
16925
6274
 
16926
 
  uint i, border= all_fields.elements - elements;
 
6275
  uint32_t i, border= all_fields.elements - elements;
16927
6276
  for (i= 0; (item= it++); i++)
16928
6277
  {
16929
6278
    Field *field;
16936
6285
    {
16937
6286
      if (item->type() == Item::FIELD_ITEM)
16938
6287
      {
16939
 
        item_field= item->get_tmp_table_item(thd);
 
6288
        item_field= item->get_tmp_table_item(session);
16940
6289
      }
16941
6290
      else if ((field= item->get_tmp_table_field()))
16942
6291
      {
16943
 
        if (item->type() == Item::SUM_FUNC_ITEM && field->table->group)
16944
 
          item_field= ((Item_sum*) item)->result_item(field);
16945
 
        else
16946
 
          item_field= (Item*) new Item_field(field);
16947
 
        if (!item_field)
16948
 
          return(true);                    // Fatal error
 
6292
        if (item->type() == Item::SUM_FUNC_ITEM && field->table->group)
 
6293
          item_field= ((Item_sum*) item)->result_item(field);
 
6294
        else
 
6295
          item_field= (Item*) new Item_field(field);
 
6296
        if (!item_field)
 
6297
          return(true);                    // Fatal error
16949
6298
 
16950
6299
        if (item->real_item()->type() != Item::FIELD_ITEM)
16951
6300
          field->orig_table= 0;
16952
 
        item_field->name= item->name;
 
6301
        item_field->name= item->name;
16953
6302
        if (item->type() == Item::REF_ITEM)
16954
6303
        {
16955
6304
          Item_field *ifield= (Item_field *) item_field;
16959
6308
        }
16960
6309
      }
16961
6310
      else
16962
 
        item_field= item;
 
6311
        item_field= item;
16963
6312
    }
16964
6313
    res_all_fields.push_back(item_field);
16965
6314
    ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
16973
6322
  return(false);
16974
6323
}
16975
6324
 
16976
 
 
16977
6325
/**
16978
6326
  Change all sum_func refs to fields to point at fields in tmp table.
16979
6327
  Change all funcs to be fields in tmp table.
16980
6328
 
16981
 
  @param thd                   THD pointer
 
6329
  @param session                   Session pointer
16982
6330
  @param ref_pointer_array     array of pointers to top elements of filed list
16983
6331
  @param res_selected_fields   new list of items of select item list
16984
6332
  @param res_all_fields        new list of all items
16990
6338
  @retval
16991
6339
    1   error
16992
6340
*/
16993
 
 
16994
 
static bool
16995
 
change_refs_to_tmp_fields(THD *thd, Item **ref_pointer_array,
16996
 
                          List<Item> &res_selected_fields,
16997
 
                          List<Item> &res_all_fields, uint elements,
16998
 
                          List<Item> &all_fields)
 
6341
bool change_refs_to_tmp_fields(Session *session,
 
6342
                               Item **ref_pointer_array,
 
6343
                               List<Item> &res_selected_fields,
 
6344
                               List<Item> &res_all_fields,
 
6345
                               uint32_t elements,
 
6346
                                                 List<Item> &all_fields)
16999
6347
{
17000
6348
  List_iterator_fast<Item> it(all_fields);
17001
6349
  Item *item, *new_item;
17002
6350
  res_selected_fields.empty();
17003
6351
  res_all_fields.empty();
17004
6352
 
17005
 
  uint i, border= all_fields.elements - elements;
 
6353
  uint32_t i, border= all_fields.elements - elements;
17006
6354
  for (i= 0; (item= it++); i++)
17007
6355
  {
17008
 
    res_all_fields.push_back(new_item= item->get_tmp_table_item(thd));
 
6356
    res_all_fields.push_back(new_item= item->get_tmp_table_item(session));
17009
6357
    ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
17010
6358
      new_item;
17011
6359
  }
17015
6363
    itr++;
17016
6364
  itr.sublist(res_selected_fields, elements);
17017
6365
 
17018
 
  return thd->is_fatal_error;
 
6366
  return session->is_fatal_error;
17019
6367
}
17020
6368
 
17021
 
 
17022
 
 
17023
6369
/******************************************************************************
17024
6370
  Code for calculating functions
17025
6371
******************************************************************************/
17026
6372
 
17027
 
 
17028
6373
/**
17029
6374
  Call ::setup for all sum functions.
17030
6375
 
17031
 
  @param thd           thread handler
 
6376
  @param session           thread Cursor
17032
6377
  @param func_ptr      sum function list
17033
6378
 
17034
6379
  @retval
17036
6381
  @retval
17037
6382
    true   error
17038
6383
*/
17039
 
 
17040
 
static bool setup_sum_funcs(THD *thd, Item_sum **func_ptr)
 
6384
bool setup_sum_funcs(Session *session, Item_sum **func_ptr)
17041
6385
{
17042
6386
  Item_sum *func;
17043
6387
  while ((func= *(func_ptr++)))
17044
6388
  {
17045
 
    if (func->setup(thd))
 
6389
    if (func->setup(session))
17046
6390
      return(true);
17047
6391
  }
17048
6392
  return(false);
17049
6393
}
17050
6394
 
17051
 
 
17052
 
static void
17053
 
init_tmptable_sum_functions(Item_sum **func_ptr)
 
6395
void init_tmptable_sum_functions(Item_sum **func_ptr)
17054
6396
{
17055
6397
  Item_sum *func;
17056
6398
  while ((func= *(func_ptr++)))
17057
6399
    func->reset_field();
17058
6400
}
17059
6401
 
17060
 
 
17061
6402
/** Update record 0 in tmp_table from record 1. */
17062
 
 
17063
 
static void
17064
 
update_tmptable_sum_func(Item_sum **func_ptr,
17065
 
                         TABLE *tmp_table __attribute__((unused)))
 
6403
void update_tmptable_sum_func(Item_sum **func_ptr, Table *)
17066
6404
{
17067
6405
  Item_sum *func;
17068
6406
  while ((func= *(func_ptr++)))
17069
6407
    func->update_field();
17070
6408
}
17071
6409
 
17072
 
 
17073
6410
/** Copy result of sum functions to record in tmp_table. */
17074
 
 
17075
 
static void
17076
 
copy_sum_funcs(Item_sum **func_ptr, Item_sum **end_ptr)
 
6411
void copy_sum_funcs(Item_sum **func_ptr, Item_sum **end_ptr)
17077
6412
{
17078
6413
  for (; func_ptr != end_ptr ; func_ptr++)
17079
6414
    (void) (*func_ptr)->save_in_result_field(1);
17080
6415
  return;
17081
6416
}
17082
6417
 
17083
 
 
17084
 
static bool
17085
 
init_sum_functions(Item_sum **func_ptr, Item_sum **end_ptr)
 
6418
bool init_sum_functions(Item_sum **func_ptr, Item_sum **end_ptr)
17086
6419
{
17087
6420
  for (; func_ptr != end_ptr ;func_ptr++)
17088
6421
  {
17098
6431
  return 0;
17099
6432
}
17100
6433
 
17101
 
 
17102
 
static bool
17103
 
update_sum_func(Item_sum **func_ptr)
 
6434
bool update_sum_func(Item_sum **func_ptr)
17104
6435
{
17105
6436
  Item_sum *func;
17106
6437
  for (; (func= (Item_sum*) *func_ptr) ; func_ptr++)
17110
6441
}
17111
6442
 
17112
6443
/** Copy result of functions to record in tmp_table. */
17113
 
 
17114
 
void
17115
 
copy_funcs(Item **func_ptr)
 
6444
void copy_funcs(Item **func_ptr)
17116
6445
{
17117
6446
  Item *func;
17118
6447
  for (; (func = *func_ptr) ; func_ptr++)
17119
6448
    func->save_in_result_field(1);
17120
6449
}
17121
6450
 
17122
 
 
17123
 
/**
17124
 
  Create a condition for a const reference and add this to the
17125
 
  currenct select for the table.
17126
 
*/
17127
 
 
17128
 
static bool add_ref_to_table_cond(THD *thd, JOIN_TAB *join_tab)
17129
 
{
17130
 
  if (!join_tab->ref.key_parts)
17131
 
    return(false);
17132
 
 
17133
 
  Item_cond_and *cond=new Item_cond_and();
17134
 
  TABLE *table=join_tab->table;
17135
 
  int error;
17136
 
  if (!cond)
17137
 
    return(true);
17138
 
 
17139
 
  for (uint i=0 ; i < join_tab->ref.key_parts ; i++)
17140
 
  {
17141
 
    Field *field=table->field[table->key_info[join_tab->ref.key].key_part[i].
17142
 
                              fieldnr-1];
17143
 
    Item *value=join_tab->ref.items[i];
17144
 
    cond->add(new Item_func_equal(new Item_field(field), value));
17145
 
  }
17146
 
  if (thd->is_fatal_error)
17147
 
    return(true);
17148
 
 
17149
 
  if (!cond->fixed)
17150
 
    cond->fix_fields(thd, (Item**)&cond);
17151
 
  if (join_tab->select)
17152
 
  {
17153
 
    error=(int) cond->add(join_tab->select->cond);
17154
 
    join_tab->select_cond=join_tab->select->cond=cond;
17155
 
  }
17156
 
  else if ((join_tab->select= make_select(join_tab->table, 0, 0, cond, 0,
17157
 
                                          &error)))
17158
 
    join_tab->select_cond=cond;
17159
 
 
17160
 
  return(error ? true : false);
17161
 
}
17162
 
 
17163
 
 
17164
6451
/**
17165
6452
  Free joins of subselect of this select.
17166
6453
 
17167
 
  @param thd      THD pointer
17168
 
  @param select   pointer to st_select_lex which subselects joins we will free
 
6454
  @param session      Session pointer
 
6455
  @param select   pointer to Select_Lex which subselects joins we will free
17169
6456
*/
17170
 
 
17171
 
void free_underlaid_joins(THD *thd __attribute__((unused)),
17172
 
                          SELECT_LEX *select)
 
6457
void free_underlaid_joins(Session *, Select_Lex *select)
17173
6458
{
17174
 
  for (SELECT_LEX_UNIT *unit= select->first_inner_unit();
 
6459
  for (Select_Lex_Unit *unit= select->first_inner_unit();
17175
6460
       unit;
17176
6461
       unit= unit->next_unit())
17177
6462
    unit->cleanup();
17193
6478
  @b EXAMPLES
17194
6479
    @code
17195
6480
      SELECT a+1 FROM t1 GROUP BY a WITH ROLLUP
17196
 
      SELECT SUM(a)+a FROM t1 GROUP BY a WITH ROLLUP 
 
6481
      SELECT SUM(a)+a FROM t1 GROUP BY a WITH ROLLUP
17197
6482
  @endcode
17198
6483
 
17199
6484
  @b IMPLEMENTATION
17206
6491
    This substitution is needed GROUP BY queries with ROLLUP if
17207
6492
    SELECT list contains expressions over group by attributes.
17208
6493
 
17209
 
  @param thd                  reference to the context
 
6494
  @param session                  reference to the context
17210
6495
  @param expr                 expression to make replacement
17211
6496
  @param group_list           list of references to group by items
17212
6497
  @param changed        out:  returns 1 if item contains a replaced field item
17213
6498
 
17214
6499
  @todo
17215
6500
    - TODO: Some functions are not null-preserving. For those functions
17216
 
    updating of the maybe_null attribute is an overkill. 
 
6501
    updating of the maybe_null attribute is an overkill.
17217
6502
 
17218
6503
  @retval
17219
6504
    0   if ok
17220
6505
  @retval
17221
6506
    1   on error
17222
6507
*/
17223
 
 
17224
 
static bool change_group_ref(THD *thd, Item_func *expr, ORDER *group_list,
17225
 
                             bool *changed)
 
6508
bool change_group_ref(Session *session, Item_func *expr, order_st *group_list, bool *changed)
17226
6509
{
17227
6510
  if (expr->arg_count)
17228
6511
  {
17229
 
    Name_resolution_context *context= &thd->lex->current_select->context;
 
6512
    Name_resolution_context *context= &session->lex->current_select->context;
17230
6513
    Item **arg,**arg_end;
17231
6514
    bool arg_changed= false;
17232
6515
    for (arg= expr->arguments(),
17236
6519
      Item *item= *arg;
17237
6520
      if (item->type() == Item::FIELD_ITEM || item->type() == Item::REF_ITEM)
17238
6521
      {
17239
 
        ORDER *group_tmp;
 
6522
        order_st *group_tmp;
17240
6523
        for (group_tmp= group_list; group_tmp; group_tmp= group_tmp->next)
17241
6524
        {
17242
6525
          if (item->eq(*group_tmp->item,0))
17245
6528
            if (!(new_item= new Item_ref(context, group_tmp->item, 0,
17246
6529
                                        item->name)))
17247
6530
              return 1;                                 // fatal_error is set
17248
 
            thd->change_item_tree(arg, new_item);
 
6531
            session->change_item_tree(arg, new_item);
17249
6532
            arg_changed= true;
17250
6533
          }
17251
6534
        }
17252
6535
      }
17253
6536
      else if (item->type() == Item::FUNC_ITEM)
17254
6537
      {
17255
 
        if (change_group_ref(thd, (Item_func *) item, group_list, &arg_changed))
 
6538
        if (change_group_ref(session, (Item_func *) item, group_list, &arg_changed))
17256
6539
          return 1;
17257
6540
      }
17258
6541
    }
17265
6548
  return 0;
17266
6549
}
17267
6550
 
17268
 
 
17269
 
/** Allocate memory needed for other rollup functions. */
17270
 
 
17271
 
bool JOIN::rollup_init()
17272
 
{
17273
 
  uint i,j;
17274
 
  Item **ref_array;
17275
 
 
17276
 
  tmp_table_param.quick_group= 0;       // Can't create groups in tmp table
17277
 
  rollup.state= ROLLUP::STATE_INITED;
17278
 
 
17279
 
  /*
17280
 
    Create pointers to the different sum function groups
17281
 
    These are updated by rollup_make_fields()
17282
 
  */
17283
 
  tmp_table_param.group_parts= send_group_parts;
17284
 
 
17285
 
  if (!(rollup.null_items= (Item_null_result**) thd->alloc((sizeof(Item*) +
17286
 
                                                sizeof(Item**) +
17287
 
                                                sizeof(List<Item>) +
17288
 
                                                ref_pointer_array_size)
17289
 
                                                * send_group_parts )))
17290
 
    return 1;
17291
 
  
17292
 
  rollup.fields= (List<Item>*) (rollup.null_items + send_group_parts);
17293
 
  rollup.ref_pointer_arrays= (Item***) (rollup.fields + send_group_parts);
17294
 
  ref_array= (Item**) (rollup.ref_pointer_arrays+send_group_parts);
17295
 
 
17296
 
  /*
17297
 
    Prepare space for field list for the different levels
17298
 
    These will be filled up in rollup_make_fields()
17299
 
  */
17300
 
  for (i= 0 ; i < send_group_parts ; i++)
17301
 
  {
17302
 
    rollup.null_items[i]= new (thd->mem_root) Item_null_result();
17303
 
    List<Item> *rollup_fields= &rollup.fields[i];
17304
 
    rollup_fields->empty();
17305
 
    rollup.ref_pointer_arrays[i]= ref_array;
17306
 
    ref_array+= all_fields.elements;
17307
 
  }
17308
 
  for (i= 0 ; i < send_group_parts; i++)
17309
 
  {
17310
 
    for (j=0 ; j < fields_list.elements ; j++)
17311
 
      rollup.fields[i].push_back(rollup.null_items[i]);
17312
 
  }
17313
 
  List_iterator<Item> it(all_fields);
17314
 
  Item *item;
17315
 
  while ((item= it++))
17316
 
  {
17317
 
    ORDER *group_tmp;
17318
 
    bool found_in_group= 0;
17319
 
 
17320
 
    for (group_tmp= group_list; group_tmp; group_tmp= group_tmp->next)
17321
 
    {
17322
 
      if (*group_tmp->item == item)
17323
 
      {
17324
 
        item->maybe_null= 1;
17325
 
        found_in_group= 1;
17326
 
        if (item->const_item())
17327
 
        {
17328
 
          /*
17329
 
            For ROLLUP queries each constant item referenced in GROUP BY list
17330
 
            is wrapped up into an Item_func object yielding the same value
17331
 
            as the constant item. The objects of the wrapper class are never
17332
 
            considered as constant items and besides they inherit all
17333
 
            properties of the Item_result_field class.
17334
 
            This wrapping allows us to ensure writing constant items
17335
 
            into temporary tables whenever the result of the ROLLUP
17336
 
            operation has to be written into a temporary table, e.g. when
17337
 
            ROLLUP is used together with DISTINCT in the SELECT list.
17338
 
            Usually when creating temporary tables for a intermidiate
17339
 
            result we do not include fields for constant expressions.
17340
 
          */           
17341
 
          Item* new_item= new Item_func_rollup_const(item);
17342
 
          if (!new_item)
17343
 
            return 1;
17344
 
          new_item->fix_fields(thd, (Item **) 0);
17345
 
          thd->change_item_tree(it.ref(), new_item);
17346
 
          for (ORDER *tmp= group_tmp; tmp; tmp= tmp->next)
17347
 
          { 
17348
 
            if (*tmp->item == item)
17349
 
              thd->change_item_tree(tmp->item, new_item);
17350
 
          }
17351
 
        }
17352
 
      }
17353
 
    }
17354
 
    if (item->type() == Item::FUNC_ITEM && !found_in_group)
17355
 
    {
17356
 
      bool changed= false;
17357
 
      if (change_group_ref(thd, (Item_func *) item, group_list, &changed))
17358
 
        return 1;
17359
 
      /*
17360
 
        We have to prevent creation of a field in a temporary table for
17361
 
        an expression that contains GROUP BY attributes.
17362
 
        Marking the expression item as 'with_sum_func' will ensure this.
17363
 
      */ 
17364
 
      if (changed)
17365
 
        item->with_sum_func= 1;
17366
 
    }
17367
 
  }
17368
 
  return 0;
17369
 
}
17370
 
  
17371
 
 
17372
 
/**
17373
 
  Fill up rollup structures with pointers to fields to use.
17374
 
 
17375
 
  Creates copies of item_sum items for each sum level.
17376
 
 
17377
 
  @param fields_arg             List of all fields (hidden and real ones)
17378
 
  @param sel_fields             Pointer to selected fields
17379
 
  @param func                   Store here a pointer to all fields
17380
 
 
17381
 
  @retval
17382
 
    0   if ok;
17383
 
    In this case func is pointing to next not used element.
17384
 
  @retval
17385
 
    1    on error
17386
 
*/
17387
 
 
17388
 
bool JOIN::rollup_make_fields(List<Item> &fields_arg, List<Item> &sel_fields,
17389
 
                              Item_sum ***func)
17390
 
{
17391
 
  List_iterator_fast<Item> it(fields_arg);
17392
 
  Item *first_field= sel_fields.head();
17393
 
  uint level;
17394
 
 
17395
 
  /*
17396
 
    Create field lists for the different levels
17397
 
 
17398
 
    The idea here is to have a separate field list for each rollup level to
17399
 
    avoid all runtime checks of which columns should be NULL.
17400
 
 
17401
 
    The list is stored in reverse order to get sum function in such an order
17402
 
    in func that it makes it easy to reset them with init_sum_functions()
17403
 
 
17404
 
    Assuming:  SELECT a, b, c SUM(b) FROM t1 GROUP BY a,b WITH ROLLUP
17405
 
 
17406
 
    rollup.fields[0] will contain list where a,b,c is NULL
17407
 
    rollup.fields[1] will contain list where b,c is NULL
17408
 
    ...
17409
 
    rollup.ref_pointer_array[#] points to fields for rollup.fields[#]
17410
 
    ...
17411
 
    sum_funcs_end[0] points to all sum functions
17412
 
    sum_funcs_end[1] points to all sum functions, except grand totals
17413
 
    ...
17414
 
  */
17415
 
 
17416
 
  for (level=0 ; level < send_group_parts ; level++)
17417
 
  {
17418
 
    uint i;
17419
 
    uint pos= send_group_parts - level -1;
17420
 
    bool real_fields= 0;
17421
 
    Item *item;
17422
 
    List_iterator<Item> new_it(rollup.fields[pos]);
17423
 
    Item **ref_array_start= rollup.ref_pointer_arrays[pos];
17424
 
    ORDER *start_group;
17425
 
 
17426
 
    /* Point to first hidden field */
17427
 
    Item **ref_array= ref_array_start + fields_arg.elements-1;
17428
 
 
17429
 
    /* Remember where the sum functions ends for the previous level */
17430
 
    sum_funcs_end[pos+1]= *func;
17431
 
 
17432
 
    /* Find the start of the group for this level */
17433
 
    for (i= 0, start_group= group_list ;
17434
 
         i++ < pos ;
17435
 
         start_group= start_group->next)
17436
 
      ;
17437
 
 
17438
 
    it.rewind();
17439
 
    while ((item= it++))
17440
 
    {
17441
 
      if (item == first_field)
17442
 
      {
17443
 
        real_fields= 1;                         // End of hidden fields
17444
 
        ref_array= ref_array_start;
17445
 
      }
17446
 
 
17447
 
      if (item->type() == Item::SUM_FUNC_ITEM && !item->const_item() &&
17448
 
          (!((Item_sum*) item)->depended_from() ||
17449
 
           ((Item_sum *)item)->depended_from() == select_lex))
17450
 
          
17451
 
      {
17452
 
        /*
17453
 
          This is a top level summary function that must be replaced with
17454
 
          a sum function that is reset for this level.
17455
 
 
17456
 
          NOTE: This code creates an object which is not that nice in a
17457
 
          sub select.  Fortunately it's not common to have rollup in
17458
 
          sub selects.
17459
 
        */
17460
 
        item= item->copy_or_same(thd);
17461
 
        ((Item_sum*) item)->make_unique();
17462
 
        *(*func)= (Item_sum*) item;
17463
 
        (*func)++;
17464
 
      }
17465
 
      else 
17466
 
      {
17467
 
        /* Check if this is something that is part of this group by */
17468
 
        ORDER *group_tmp;
17469
 
        for (group_tmp= start_group, i= pos ;
17470
 
             group_tmp ; group_tmp= group_tmp->next, i++)
17471
 
        {
17472
 
          if (*group_tmp->item == item)
17473
 
          {
17474
 
            /*
17475
 
              This is an element that is used by the GROUP BY and should be
17476
 
              set to NULL in this level
17477
 
            */
17478
 
            Item_null_result *null_item= new (thd->mem_root) Item_null_result();
17479
 
            if (!null_item)
17480
 
              return 1;
17481
 
            item->maybe_null= 1;                // Value will be null sometimes
17482
 
            null_item->result_field= item->get_tmp_table_field();
17483
 
            item= null_item;
17484
 
            break;
17485
 
          }
17486
 
        }
17487
 
      }
17488
 
      *ref_array= item;
17489
 
      if (real_fields)
17490
 
      {
17491
 
        (void) new_it++;                        // Point to next item
17492
 
        new_it.replace(item);                   // Replace previous
17493
 
        ref_array++;
17494
 
      }
17495
 
      else
17496
 
        ref_array--;
17497
 
    }
17498
 
  }
17499
 
  sum_funcs_end[0]= *func;                      // Point to last function
17500
 
  return 0;
17501
 
}
17502
 
 
17503
 
/**
17504
 
  Send all rollup levels higher than the current one to the client.
17505
 
 
17506
 
  @b SAMPLE
17507
 
    @code
17508
 
      SELECT a, b, c SUM(b) FROM t1 GROUP BY a,b WITH ROLLUP
17509
 
  @endcode
17510
 
 
17511
 
  @param idx            Level we are on:
17512
 
                        - 0 = Total sum level
17513
 
                        - 1 = First group changed  (a)
17514
 
                        - 2 = Second group changed (a,b)
17515
 
 
17516
 
  @retval
17517
 
    0   ok
17518
 
  @retval
17519
 
    1   If send_data_failed()
17520
 
*/
17521
 
 
17522
 
int JOIN::rollup_send_data(uint idx)
17523
 
{
17524
 
  uint i;
17525
 
  for (i= send_group_parts ; i-- > idx ; )
17526
 
  {
17527
 
    /* Get reference pointers to sum functions in place */
17528
 
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
17529
 
           ref_pointer_array_size);
17530
 
    if ((!having || having->val_int()))
17531
 
    {
17532
 
      if (send_records < unit->select_limit_cnt && do_send_rows &&
17533
 
          result->send_data(rollup.fields[i]))
17534
 
        return 1;
17535
 
      send_records++;
17536
 
    }
17537
 
  }
17538
 
  /* Restore ref_pointer_array */
17539
 
  set_items_ref_array(current_ref_pointer_array);
17540
 
  return 0;
17541
 
}
17542
 
 
17543
 
/**
17544
 
  Write all rollup levels higher than the current one to a temp table.
17545
 
 
17546
 
  @b SAMPLE
17547
 
    @code
17548
 
      SELECT a, b, SUM(c) FROM t1 GROUP BY a,b WITH ROLLUP
17549
 
  @endcode
17550
 
 
17551
 
  @param idx                 Level we are on:
17552
 
                               - 0 = Total sum level
17553
 
                               - 1 = First group changed  (a)
17554
 
                               - 2 = Second group changed (a,b)
17555
 
  @param table               reference to temp table
17556
 
 
17557
 
  @retval
17558
 
    0   ok
17559
 
  @retval
17560
 
    1   if write_data_failed()
17561
 
*/
17562
 
 
17563
 
int JOIN::rollup_write_data(uint idx, TABLE *table_arg)
17564
 
{
17565
 
  uint i;
17566
 
  for (i= send_group_parts ; i-- > idx ; )
17567
 
  {
17568
 
    /* Get reference pointers to sum functions in place */
17569
 
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
17570
 
           ref_pointer_array_size);
17571
 
    if ((!having || having->val_int()))
17572
 
    {
17573
 
      int write_error;
17574
 
      Item *item;
17575
 
      List_iterator_fast<Item> it(rollup.fields[i]);
17576
 
      while ((item= it++))
17577
 
      {
17578
 
        if (item->type() == Item::NULL_ITEM && item->is_result_field())
17579
 
          item->save_in_result_field(1);
17580
 
      }
17581
 
      copy_sum_funcs(sum_funcs_end[i+1], sum_funcs_end[i]);
17582
 
      if ((write_error= table_arg->file->ha_write_row(table_arg->record[0])))
17583
 
      {
17584
 
        if (create_myisam_from_heap(thd, table_arg, 
17585
 
                                    tmp_table_param.start_recinfo,
17586
 
                                    &tmp_table_param.recinfo,
17587
 
                                    write_error, 0))
17588
 
          return 1;                  
17589
 
      }
17590
 
    }
17591
 
  }
17592
 
  /* Restore ref_pointer_array */
17593
 
  set_items_ref_array(current_ref_pointer_array);
17594
 
  return 0;
17595
 
}
17596
 
 
17597
 
/**
17598
 
  clear results if there are not rows found for group
17599
 
  (end_send_group/end_write_group)
17600
 
*/
17601
 
 
17602
 
void JOIN::clear()
17603
 
{
17604
 
  clear_tables(this);
17605
 
  copy_fields(&tmp_table_param);
17606
 
 
17607
 
  if (sum_funcs)
17608
 
  {
17609
 
    Item_sum *func, **func_ptr= sum_funcs;
17610
 
    while ((func= *(func_ptr++)))
17611
 
      func->clear();
17612
 
  }
17613
 
}
17614
 
 
17615
6551
/**
17616
6552
  EXPLAIN handling.
17617
6553
 
17618
6554
  Send a description about what how the select will be done to stdout.
17619
6555
*/
17620
 
 
17621
6556
void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
17622
6557
                     bool distinct,const char *message)
17623
6558
{
17624
6559
  List<Item> field_list;
17625
6560
  List<Item> item_list;
17626
 
  THD *thd=join->thd;
 
6561
  Session *session=join->session;
17627
6562
  select_result *result=join->result;
17628
6563
  Item *item_null= new Item_null();
17629
6564
  const CHARSET_INFO * const cs= system_charset_info;
17630
6565
  int quick_type;
17631
6566
  /* Don't log this into the slow query log */
17632
 
  thd->server_status&= ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
 
6567
  session->server_status&= ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
17633
6568
  join->unit->offset_limit_cnt= 0;
17634
6569
 
17635
 
  /* 
 
6570
  /*
17636
6571
    NOTE: the number/types of items pushed into item_list must be in sync with
17637
 
    EXPLAIN column types as they're "defined" in THD::send_explain_fields()
 
6572
    EXPLAIN column types as they're "defined" in Session::send_explain_fields()
17638
6573
  */
17639
6574
  if (message)
17640
6575
  {
17642
6577
                                     join->select_lex->select_number));
17643
6578
    item_list.push_back(new Item_string(join->select_lex->type,
17644
6579
                                        strlen(join->select_lex->type), cs));
17645
 
    for (uint i=0 ; i < 7; i++)
17646
 
      item_list.push_back(item_null);
17647
 
    if (join->thd->lex->describe & DESCRIBE_EXTENDED)
17648
 
      item_list.push_back(item_null);
17649
 
  
 
6580
    for (uint32_t i=0 ; i < 7; i++)
 
6581
      item_list.push_back(item_null);
 
6582
    if (join->session->lex->describe & DESCRIBE_EXTENDED)
 
6583
      item_list.push_back(item_null);
 
6584
 
17650
6585
    item_list.push_back(new Item_string(message,strlen(message),cs));
17651
6586
    if (result->send_data(item_list))
17652
6587
      join->error= 1;
17653
6588
  }
17654
6589
  else if (join->select_lex == join->unit->fake_select_lex)
17655
6590
  {
17656
 
    /* 
 
6591
    /*
17657
6592
      here we assume that the query will return at least two rows, so we
17658
6593
      show "filesort" in EXPLAIN. Of course, sometimes we'll be wrong
17659
6594
      and no filesort will be actually done, but executing all selects in
17670
6605
                                        cs));
17671
6606
    /* table */
17672
6607
    {
17673
 
      SELECT_LEX *sl= join->unit->first_select();
17674
 
      uint len= 6, lastop= 0;
 
6608
      Select_Lex *sl= join->unit->first_select();
 
6609
      uint32_t len= 6, lastop= 0;
17675
6610
      memcpy(table_name_buffer, STRING_WITH_LEN("<union"));
17676
6611
      for (; sl && len + lastop + 5 < NAME_LEN; sl= sl->next_select())
17677
6612
      {
17692
6627
      item_list.push_back(new Item_string(table_name_buffer, len, cs));
17693
6628
    }
17694
6629
    /* type */
17695
 
    item_list.push_back(new Item_string(join_type_str[JT_ALL],
17696
 
                                          strlen(join_type_str[JT_ALL]),
17697
 
                                          cs));
 
6630
    item_list.push_back(new Item_string(access_method_str[AM_ALL].c_str(),
 
6631
                                        access_method_str[AM_ALL].length(),
 
6632
                                        cs));
17698
6633
    /* possible_keys */
17699
6634
    item_list.push_back(item_null);
17700
6635
    /* key*/
17704
6639
    /* ref */
17705
6640
    item_list.push_back(item_null);
17706
6641
    /* in_rows */
17707
 
    if (join->thd->lex->describe & DESCRIBE_EXTENDED)
 
6642
    if (join->session->lex->describe & DESCRIBE_EXTENDED)
17708
6643
      item_list.push_back(item_null);
17709
6644
    /* rows */
17710
6645
    item_list.push_back(item_null);
17721
6656
  else
17722
6657
  {
17723
6658
    table_map used_tables=0;
17724
 
    for (uint i=0 ; i < join->tables ; i++)
 
6659
    for (uint32_t i=0 ; i < join->tables ; i++)
17725
6660
    {
17726
 
      JOIN_TAB *tab=join->join_tab+i;
17727
 
      TABLE *table=tab->table;
17728
 
      TABLE_LIST *table_list= tab->table->pos_in_table_list;
17729
 
      char buff[512]; 
 
6661
      JoinTable *tab=join->join_tab+i;
 
6662
      Table *table=tab->table;
 
6663
      TableList *table_list= tab->table->pos_in_table_list;
 
6664
      char buff[512];
17730
6665
      char buff1[512], buff2[512], buff3[512];
17731
6666
      char keylen_str_buf[64];
17732
6667
      String extra(buff, sizeof(buff),cs);
17748
6683
      item_list.push_back(new Item_string(join->select_lex->type,
17749
6684
                                          strlen(join->select_lex->type),
17750
6685
                                          cs));
17751
 
      if (tab->type == JT_ALL && tab->select && tab->select->quick)
 
6686
      if (tab->type == AM_ALL && tab->select && tab->select->quick)
17752
6687
      {
17753
6688
        quick_type= tab->select->quick->get_type();
17754
6689
        if ((quick_type == QUICK_SELECT_I::QS_TYPE_INDEX_MERGE) ||
17755
6690
            (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT) ||
17756
6691
            (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_UNION))
17757
 
          tab->type = JT_INDEX_MERGE;
 
6692
          tab->type = AM_INDEX_MERGE;
17758
6693
        else
17759
 
          tab->type = JT_RANGE;
 
6694
          tab->type = AM_RANGE;
17760
6695
      }
17761
6696
      /* table */
17762
6697
      if (table->derived_select_number)
17769
6704
      }
17770
6705
      else
17771
6706
      {
17772
 
        TABLE_LIST *real_table= table->pos_in_table_list; 
 
6707
        TableList *real_table= table->pos_in_table_list;
17773
6708
        item_list.push_back(new Item_string(real_table->alias,
17774
6709
                                            strlen(real_table->alias),
17775
6710
                                            cs));
17776
6711
      }
17777
6712
      /* "type" column */
17778
 
      item_list.push_back(new Item_string(join_type_str[tab->type],
17779
 
                                          strlen(join_type_str[tab->type]),
 
6713
      item_list.push_back(new Item_string(access_method_str[tab->type].c_str(),
 
6714
                                          access_method_str[tab->type].length(),
17780
6715
                                          cs));
17781
6716
      /* Build "possible_keys" value and add it to item_list */
17782
 
      if (!tab->keys.is_clear_all())
 
6717
      if (tab->keys.any())
17783
6718
      {
17784
 
        uint j;
 
6719
        uint32_t j;
17785
6720
        for (j=0 ; j < table->s->keys ; j++)
17786
6721
        {
17787
 
          if (tab->keys.is_set(j))
 
6722
          if (tab->keys.test(j))
17788
6723
          {
17789
6724
            if (tmp1.length())
17790
6725
              tmp1.append(',');
17791
 
            tmp1.append(table->key_info[j].name, 
 
6726
            tmp1.append(table->key_info[j].name,
17792
6727
                        strlen(table->key_info[j].name),
17793
6728
                        system_charset_info);
17794
6729
          }
17803
6738
      if (tab->ref.key_parts)
17804
6739
      {
17805
6740
        KEY *key_info=table->key_info+ tab->ref.key;
17806
 
        register uint length;
 
6741
        register uint32_t length;
17807
6742
        item_list.push_back(new Item_string(key_info->name,
17808
6743
                                            strlen(key_info->name),
17809
6744
                                            system_charset_info));
17810
 
        length= int64_t2str(tab->ref.key_length, keylen_str_buf, 10) - 
 
6745
        length= int64_t2str(tab->ref.key_length, keylen_str_buf, 10) -
17811
6746
                keylen_str_buf;
17812
6747
        item_list.push_back(new Item_string(keylen_str_buf, length,
17813
6748
                                            system_charset_info));
17814
 
        for (store_key **ref=tab->ref.key_copy ; *ref ; ref++)
 
6749
        for (StoredKey **ref=tab->ref.key_copy ; *ref ; ref++)
17815
6750
        {
17816
6751
          if (tmp2.length())
17817
6752
            tmp2.append(',');
17820
6755
        }
17821
6756
        item_list.push_back(new Item_string(tmp2.ptr(),tmp2.length(),cs));
17822
6757
      }
17823
 
      else if (tab->type == JT_NEXT)
 
6758
      else if (tab->type == AM_NEXT)
17824
6759
      {
17825
6760
        KEY *key_info=table->key_info+ tab->index;
17826
 
        register uint length;
 
6761
        register uint32_t length;
17827
6762
        item_list.push_back(new Item_string(key_info->name,
17828
6763
                                            strlen(key_info->name),cs));
17829
 
        length= int64_t2str(key_info->key_length, keylen_str_buf, 10) - 
 
6764
        length= int64_t2str(key_info->key_length, keylen_str_buf, 10) -
17830
6765
                keylen_str_buf;
17831
 
        item_list.push_back(new Item_string(keylen_str_buf, 
 
6766
        item_list.push_back(new Item_string(keylen_str_buf,
17832
6767
                                            length,
17833
6768
                                            system_charset_info));
17834
6769
        item_list.push_back(item_null);
17842
6777
      }
17843
6778
      else
17844
6779
      {
17845
 
        if (table_list->schema_table &&
17846
 
            table_list->schema_table->i_s_requested_object & OPTIMIZE_I_S_TABLE)
 
6780
        if (table_list->schema_table && 
 
6781
            table_list->schema_table->getRequestedObject() & OPTIMIZE_I_S_TABLE)
17847
6782
        {
17848
 
          const char *tmp_buff;
17849
 
          int f_idx;
17850
6783
          if (table_list->has_db_lookup_value)
17851
6784
          {
17852
 
            f_idx= table_list->schema_table->idx_field1;
17853
 
            tmp_buff= table_list->schema_table->fields_info[f_idx].field_name;
17854
 
            tmp2.append(tmp_buff, strlen(tmp_buff), cs);
17855
 
          }          
 
6785
            int f_idx= table_list->schema_table->getFirstColumnIndex();
 
6786
            const string &tmp_buff= table_list->schema_table->getColumnName(f_idx);
 
6787
            tmp2.append(tmp_buff.c_str(), tmp_buff.length(), cs);
 
6788
          }
17856
6789
          if (table_list->has_table_lookup_value)
17857
6790
          {
17858
6791
            if (table_list->has_db_lookup_value)
17859
6792
              tmp2.append(',');
17860
 
            f_idx= table_list->schema_table->idx_field2;
17861
 
            tmp_buff= table_list->schema_table->fields_info[f_idx].field_name;
17862
 
            tmp2.append(tmp_buff, strlen(tmp_buff), cs);
 
6793
            int f_idx= table_list->schema_table->getSecondColumnIndex();
 
6794
            const string &tmp_buff= table_list->schema_table->getColumnName(f_idx);
 
6795
            tmp2.append(tmp_buff.c_str(), tmp_buff.length(), cs);
17863
6796
          }
17864
6797
          if (tmp2.length())
17865
6798
            item_list.push_back(new Item_string(tmp2.ptr(),tmp2.length(),cs));
17871
6804
        item_list.push_back(item_null);
17872
6805
        item_list.push_back(item_null);
17873
6806
      }
17874
 
      
 
6807
 
17875
6808
      /* Add "rows" field to item_list. */
17876
6809
      if (table_list->schema_table)
17877
6810
      {
17878
6811
        /* in_rows */
17879
 
        if (join->thd->lex->describe & DESCRIBE_EXTENDED)
 
6812
        if (join->session->lex->describe & DESCRIBE_EXTENDED)
17880
6813
          item_list.push_back(item_null);
17881
6814
        /* rows */
17882
6815
        item_list.push_back(item_null);
17886
6819
        double examined_rows;
17887
6820
        if (tab->select && tab->select->quick)
17888
6821
          examined_rows= rows2double(tab->select->quick->records);
17889
 
        else if (tab->type == JT_NEXT || tab->type == JT_ALL)
17890
 
          examined_rows= rows2double(tab->limit ? tab->limit : 
17891
 
                                     tab->table->file->records());
 
6822
        else if (tab->type == AM_NEXT || tab->type == AM_ALL)
 
6823
          examined_rows= rows2double(tab->limit ? tab->limit :
 
6824
                                     tab->table->cursor->records());
17892
6825
        else
17893
 
          examined_rows= join->best_positions[i].records_read; 
17894
 
 
17895
 
        item_list.push_back(new Item_int((int64_t) (uint64_t) examined_rows, 
 
6826
        {
 
6827
          optimizer::Position cur_pos= join->getPosFromOptimalPlan(i);
 
6828
          examined_rows= cur_pos.getFanout();
 
6829
        }
 
6830
 
 
6831
        item_list.push_back(new Item_int((int64_t) (uint64_t) examined_rows,
17896
6832
                                         MY_INT64_NUM_DECIMAL_DIGITS));
17897
6833
 
17898
6834
        /* Add "filtered" field to item_list. */
17899
 
        if (join->thd->lex->describe & DESCRIBE_EXTENDED)
 
6835
        if (join->session->lex->describe & DESCRIBE_EXTENDED)
17900
6836
        {
17901
 
          float f= 0.0; 
 
6837
          float f= 0.0;
17902
6838
          if (examined_rows)
17903
 
            f= (float) (100.0 * join->best_positions[i].records_read /
 
6839
          {
 
6840
            optimizer::Position cur_pos= join->getPosFromOptimalPlan(i);
 
6841
            f= (float) (100.0 * cur_pos.getFanout() /
17904
6842
                        examined_rows);
 
6843
          }
17905
6844
          item_list.push_back(new Item_float(f, 2));
17906
6845
        }
17907
6846
      }
17908
6847
 
17909
6848
      /* Build "Extra" field and add it to item_list. */
17910
6849
      bool key_read=table->key_read;
17911
 
      if ((tab->type == JT_NEXT || tab->type == JT_CONST) &&
17912
 
          table->covering_keys.is_set(tab->index))
 
6850
      if ((tab->type == AM_NEXT || tab->type == AM_CONST) &&
 
6851
          table->covering_keys.test(tab->index))
17913
6852
        key_read=1;
17914
6853
      if (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT &&
17915
6854
          !((QUICK_ROR_INTERSECT_SELECT*)tab->select->quick)->need_to_fetch_row)
17916
6855
        key_read=1;
17917
 
        
 
6856
 
17918
6857
      if (tab->info)
17919
6858
        item_list.push_back(new Item_string(tab->info,strlen(tab->info),cs));
17920
6859
      else if (tab->packed_info & TAB_INFO_HAVE_VALUE)
17937
6876
      }
17938
6877
      else
17939
6878
      {
17940
 
        uint keyno= MAX_KEY;
 
6879
        uint32_t keyno= MAX_KEY;
17941
6880
        if (tab->ref.key_parts)
17942
6881
          keyno= tab->ref.key;
17943
6882
        else if (tab->select && tab->select->quick)
17944
6883
          keyno = tab->select->quick->index;
17945
6884
 
17946
 
        if (keyno != MAX_KEY && keyno == table->file->pushed_idx_cond_keyno &&
17947
 
            table->file->pushed_idx_cond)
17948
 
          extra.append(STRING_WITH_LEN("; Using index condition"));
17949
 
 
17950
 
        if (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_UNION || 
 
6885
        if (quick_type == QUICK_SELECT_I::QS_TYPE_ROR_UNION ||
17951
6886
            quick_type == QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT ||
17952
6887
            quick_type == QUICK_SELECT_I::QS_TYPE_INDEX_MERGE)
17953
6888
        {
17958
6893
        {
17959
6894
          if (tab->use_quick == 2)
17960
6895
          {
17961
 
            /* 4 bits per 1 hex digit + terminating '\0' */
17962
 
            char buf[MAX_KEY / 4 + 1];
 
6896
            /*
 
6897
             * To print out the bitset in tab->keys, we go through
 
6898
             * it 32 bits at a time. We need to do this to ensure
 
6899
             * that the to_ulong() method will not throw an
 
6900
             * out_of_range exception at runtime which would happen
 
6901
             * if the bitset we were working with was larger than 64
 
6902
             * bits on a 64-bit platform (for example).
 
6903
             */
 
6904
            stringstream s, w;
 
6905
            string str;
 
6906
            w << tab->keys;
 
6907
            w >> str;
 
6908
            for (uint32_t pos= 0; pos < tab->keys.size(); pos+= 32)
 
6909
            {
 
6910
              bitset<32> tmp(str, pos, 32);
 
6911
              if (tmp.any())
 
6912
                s << uppercase << hex << tmp.to_ulong();
 
6913
            }
17963
6914
            extra.append(STRING_WITH_LEN("; Range checked for each "
17964
6915
                                         "record (index map: 0x"));
17965
 
            extra.append(tab->keys.print(buf));
 
6916
            extra.append(s.str().c_str());
17966
6917
            extra.append(')');
17967
6918
          }
17968
6919
          else if (tab->select->cond)
17969
6920
          {
17970
 
            const COND *pushed_cond= tab->table->file->pushed_cond;
17971
 
 
17972
 
            if (thd->variables.engine_condition_pushdown && pushed_cond)
17973
 
            {
17974
 
              extra.append(STRING_WITH_LEN("; Using where with pushed "
17975
 
                                           "condition"));
17976
 
              if (thd->lex->describe & DESCRIBE_EXTENDED)
17977
 
              {
17978
 
                extra.append(STRING_WITH_LEN(": "));
17979
 
                ((COND *)pushed_cond)->print(&extra, QT_ORDINARY);
17980
 
              }
17981
 
            }
17982
 
            else
17983
 
              extra.append(STRING_WITH_LEN("; Using where"));
 
6921
            extra.append(STRING_WITH_LEN("; Using where"));
17984
6922
          }
17985
6923
        }
17986
6924
        if (key_read)
17992
6930
        }
17993
6931
        if (table->reginfo.not_exists_optimize)
17994
6932
          extra.append(STRING_WITH_LEN("; Not exists"));
17995
 
          
17996
 
        if (quick_type == QUICK_SELECT_I::QS_TYPE_RANGE &&
17997
 
            !(((QUICK_RANGE_SELECT*)(tab->select->quick))->mrr_flags &
17998
 
             HA_MRR_USE_DEFAULT_IMPL))
17999
 
        {
18000
 
          extra.append(STRING_WITH_LEN("; Using MRR"));
18001
 
        }
18002
6933
 
18003
6934
        if (table_list->schema_table &&
18004
 
            table_list->schema_table->i_s_requested_object & OPTIMIZE_I_S_TABLE)
 
6935
            table_list->schema_table->getRequestedObject() & OPTIMIZE_I_S_TABLE)
18005
6936
        {
18006
6937
          if (!table_list->table_open_method)
18007
6938
            extra.append(STRING_WITH_LEN("; Skip_open_table"));
18028
6959
          need_order=0;
18029
6960
          extra.append(STRING_WITH_LEN("; Using filesort"));
18030
6961
        }
18031
 
        if (distinct & test_all_bits(used_tables,thd->used_tables))
 
6962
        if (distinct & test_all_bits(used_tables,session->used_tables))
18032
6963
          extra.append(STRING_WITH_LEN("; Distinct"));
18033
6964
 
18034
6965
        if (tab->insideout_match_tab)
18036
6967
          extra.append(STRING_WITH_LEN("; LooseScan"));
18037
6968
        }
18038
6969
 
18039
 
        if (tab->flush_weedout_table)
18040
 
          extra.append(STRING_WITH_LEN("; Start temporary"));
18041
 
        else if (tab->check_weed_out_table)
18042
 
          extra.append(STRING_WITH_LEN("; End temporary"));
18043
 
        else if (tab->do_firstmatch)
18044
 
        {
18045
 
          extra.append(STRING_WITH_LEN("; FirstMatch("));
18046
 
          TABLE *prev_table=tab->do_firstmatch->table;
18047
 
          if (prev_table->derived_select_number)
18048
 
          {
18049
 
            char namebuf[NAME_LEN];
18050
 
            /* Derived table name generation */
18051
 
            int len= snprintf(namebuf, sizeof(namebuf)-1,
18052
 
                              "<derived%u>",
18053
 
                              prev_table->derived_select_number);
18054
 
            extra.append(namebuf, len);
18055
 
          }
18056
 
          else
18057
 
            extra.append(prev_table->pos_in_table_list->alias);
18058
 
          extra.append(STRING_WITH_LEN(")"));
18059
 
        }
18060
 
 
18061
 
        for (uint part= 0; part < tab->ref.key_parts; part++)
 
6970
        for (uint32_t part= 0; part < tab->ref.key_parts; part++)
18062
6971
        {
18063
6972
          if (tab->ref.cond_guards[part])
18064
6973
          {
18086
6995
        join->error= 1;
18087
6996
    }
18088
6997
  }
18089
 
  for (SELECT_LEX_UNIT *unit= join->select_lex->first_inner_unit();
 
6998
  for (Select_Lex_Unit *unit= join->select_lex->first_inner_unit();
18090
6999
       unit;
18091
7000
       unit= unit->next_unit())
18092
7001
  {
18093
 
    if (mysql_explain_union(thd, unit, result))
 
7002
    if (mysql_explain_union(session, unit, result))
18094
7003
      return;
18095
7004
  }
18096
7005
  return;
18097
7006
}
18098
7007
 
18099
 
 
18100
 
bool mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit, select_result *result)
 
7008
bool mysql_explain_union(Session *session, Select_Lex_Unit *unit, select_result *result)
18101
7009
{
18102
 
  bool res= 0;
18103
 
  SELECT_LEX *first= unit->first_select();
 
7010
  bool res= false;
 
7011
  Select_Lex *first= unit->first_select();
18104
7012
 
18105
 
  for (SELECT_LEX *sl= first;
 
7013
  for (Select_Lex *sl= first;
18106
7014
       sl;
18107
7015
       sl= sl->next_select())
18108
7016
  {
18109
7017
    // drop UNCACHEABLE_EXPLAIN, because it is for internal usage only
18110
7018
    uint8_t uncacheable= (sl->uncacheable & ~UNCACHEABLE_EXPLAIN);
18111
 
    sl->type= (((&thd->lex->select_lex)==sl)?
18112
 
               (sl->first_inner_unit() || sl->next_select() ? 
 
7019
    sl->type= (((&session->lex->select_lex)==sl)?
 
7020
               (sl->first_inner_unit() || sl->next_select() ?
18113
7021
                "PRIMARY" : "SIMPLE"):
18114
7022
               ((sl == first)?
18115
7023
                ((sl->linkage == DERIVED_TABLE_TYPE) ?
18129
7037
    unit->fake_select_lex->select_number= UINT_MAX; // jost for initialization
18130
7038
    unit->fake_select_lex->type= "UNION RESULT";
18131
7039
    unit->fake_select_lex->options|= SELECT_DESCRIBE;
18132
 
    if (!(res= unit->prepare(thd, result, SELECT_NO_UNLOCK | SELECT_DESCRIBE)))
 
7040
    if (!(res= unit->prepare(session, result, SELECT_NO_UNLOCK | SELECT_DESCRIBE)))
18133
7041
      res= unit->exec();
18134
7042
    res|= unit->cleanup();
18135
7043
  }
18136
7044
  else
18137
7045
  {
18138
 
    thd->lex->current_select= first;
 
7046
    session->lex->current_select= first;
18139
7047
    unit->set_limit(unit->global_parameters);
18140
 
    res= mysql_select(thd, &first->ref_pointer_array,
18141
 
                        (TABLE_LIST*) first->table_list.first,
 
7048
    res= mysql_select(session, &first->ref_pointer_array,
 
7049
                        (TableList*) first->table_list.first,
18142
7050
                        first->with_wild, first->item_list,
18143
7051
                        first->where,
18144
7052
                        first->order_list.elements +
18145
7053
                        first->group_list.elements,
18146
 
                        (ORDER*) first->order_list.first,
18147
 
                        (ORDER*) first->group_list.first,
 
7054
                        (order_st*) first->order_list.first,
 
7055
                        (order_st*) first->group_list.first,
18148
7056
                        first->having,
18149
 
                        (ORDER*) thd->lex->proc_list.first,
18150
 
                        first->options | thd->options | SELECT_DESCRIBE,
 
7057
                        first->options | session->options | SELECT_DESCRIBE,
18151
7058
                        result, unit, first);
18152
7059
  }
18153
 
  return(res || thd->is_error());
 
7060
  return(res || session->is_error());
18154
7061
}
18155
7062
 
18156
 
 
18157
 
static void print_table_array(THD *thd, String *str, TABLE_LIST **table, 
18158
 
                              TABLE_LIST **end)
 
7063
static void print_table_array(Session *session, String *str, TableList **table,
 
7064
                              TableList **end)
18159
7065
{
18160
 
  (*table)->print(thd, str, QT_ORDINARY);
 
7066
  (*table)->print(session, str, QT_ORDINARY);
18161
7067
 
18162
 
  for (TABLE_LIST **tbl= table + 1; tbl < end; tbl++)
 
7068
  for (TableList **tbl= table + 1; tbl < end; tbl++)
18163
7069
  {
18164
 
    TABLE_LIST *curr= *tbl;
 
7070
    TableList *curr= *tbl;
18165
7071
    if (curr->outer_join)
18166
7072
    {
18167
7073
      /* MySQL converts right to left joins */
18169
7075
    }
18170
7076
    else if (curr->straight)
18171
7077
      str->append(STRING_WITH_LEN(" straight_join "));
18172
 
    else if (curr->sj_inner_tables)
18173
 
      str->append(STRING_WITH_LEN(" semi join "));
18174
7078
    else
18175
7079
      str->append(STRING_WITH_LEN(" join "));
18176
 
    curr->print(thd, str, QT_ORDINARY);
 
7080
    curr->print(session, str, QT_ORDINARY);
18177
7081
    if (curr->on_expr)
18178
7082
    {
18179
7083
      str->append(STRING_WITH_LEN(" on("));
18183
7087
  }
18184
7088
}
18185
7089
 
18186
 
 
18187
7090
/**
18188
7091
  Print joins from the FROM clause.
18189
 
  @param thd     thread handler
 
7092
  @param session     thread Cursor
18190
7093
  @param str     string where table should be printed
18191
7094
  @param tables  list of tables in join
18192
7095
  @query_type    type of the query is being generated
18193
7096
*/
18194
 
 
18195
 
static void print_join(THD *thd,
18196
 
                       String *str,
18197
 
                       List<TABLE_LIST> *tables,
18198
 
                       enum_query_type query_type __attribute__((unused)))
 
7097
void print_join(Session *session, String *str,
 
7098
                List<TableList> *tables, enum_query_type)
18199
7099
{
18200
7100
  /* List is reversed => we should reverse it before using */
18201
 
  List_iterator_fast<TABLE_LIST> ti(*tables);
18202
 
  TABLE_LIST **table= (TABLE_LIST **)thd->alloc(sizeof(TABLE_LIST*) *
 
7101
  List_iterator_fast<TableList> ti(*tables);
 
7102
  TableList **table= (TableList **)session->alloc(sizeof(TableList*) *
18203
7103
                                                tables->elements);
18204
7104
  if (table == 0)
18205
7105
    return;  // out of memory
18206
7106
 
18207
 
  for (TABLE_LIST **t= table + (tables->elements - 1); t >= table; t--)
 
7107
  for (TableList **t= table + (tables->elements - 1); t >= table; t--)
18208
7108
    *t= ti++;
18209
 
  
18210
 
  /* 
18211
 
    If the first table is a semi-join nest, swap it with something that is
18212
 
    not a semi-join nest.
18213
 
  */
18214
 
  if ((*table)->sj_inner_tables)
18215
 
  {
18216
 
    TABLE_LIST **end= table + tables->elements;
18217
 
    for (TABLE_LIST **t2= table; t2!=end; t2++)
18218
 
    {
18219
 
      if (!(*t2)->sj_inner_tables)
18220
 
      {
18221
 
        TABLE_LIST *tmp= *t2;
18222
 
        *t2= *table;
18223
 
        *table= tmp;
18224
 
        break;
18225
 
      }
18226
 
    }
18227
 
  }
18228
7109
  assert(tables->elements >= 1);
18229
 
  print_table_array(thd, str, table, table + tables->elements);
18230
 
}
18231
 
 
18232
 
 
18233
 
/**
18234
 
  @brief Print an index hint
18235
 
 
18236
 
  @details Prints out the USE|FORCE|IGNORE index hint.
18237
 
 
18238
 
  @param      thd         the current thread
18239
 
  @param[out] str         appends the index hint here
18240
 
  @param      hint        what the hint is (as string : "USE INDEX"|
18241
 
                          "FORCE INDEX"|"IGNORE INDEX")
18242
 
  @param      hint_length the length of the string in 'hint'
18243
 
  @param      indexes     a list of index names for the hint
18244
 
*/
18245
 
 
18246
 
void 
18247
 
Index_hint::print(THD *thd, String *str)
18248
 
{
18249
 
  switch (type)
18250
 
  {
18251
 
    case INDEX_HINT_IGNORE: str->append(STRING_WITH_LEN("IGNORE INDEX")); break;
18252
 
    case INDEX_HINT_USE:    str->append(STRING_WITH_LEN("USE INDEX")); break;
18253
 
    case INDEX_HINT_FORCE:  str->append(STRING_WITH_LEN("FORCE INDEX")); break;
18254
 
  }
18255
 
  str->append (STRING_WITH_LEN(" ("));
18256
 
  if (key_name.length)
18257
 
  {
18258
 
    if (thd && !my_strnncoll(system_charset_info,
18259
 
                             (const uchar *)key_name.str, key_name.length, 
18260
 
                             (const uchar *)primary_key_name, 
18261
 
                             strlen(primary_key_name)))
18262
 
      str->append(primary_key_name);
18263
 
    else
18264
 
      append_identifier(thd, str, key_name.str, key_name.length);
18265
 
  }
18266
 
  str->append(')');
18267
 
}
18268
 
 
18269
 
 
18270
 
/**
18271
 
  Print table as it should be in join list.
18272
 
 
18273
 
  @param str   string where table should be printed
18274
 
*/
18275
 
 
18276
 
void TABLE_LIST::print(THD *thd, String *str, enum_query_type query_type)
18277
 
{
18278
 
  if (nested_join)
18279
 
  {
18280
 
    str->append('(');
18281
 
    print_join(thd, str, &nested_join->join_list, query_type);
18282
 
    str->append(')');
18283
 
  }
18284
 
  else
18285
 
  {
18286
 
    const char *cmp_name;                         // Name to compare with alias
18287
 
    if (derived)
18288
 
    {
18289
 
      // A derived table
18290
 
      str->append('(');
18291
 
      derived->print(str, query_type);
18292
 
      str->append(')');
18293
 
      cmp_name= "";                               // Force printing of alias
18294
 
    }
18295
 
    else
18296
 
    {
18297
 
      // A normal table
18298
 
      {
18299
 
        append_identifier(thd, str, db, db_length);
18300
 
        str->append('.');
18301
 
      }
18302
 
      if (schema_table)
18303
 
      {
18304
 
        append_identifier(thd, str, schema_table_name,
18305
 
                          strlen(schema_table_name));
18306
 
        cmp_name= schema_table_name;
18307
 
      }
18308
 
      else
18309
 
      {
18310
 
        append_identifier(thd, str, table_name, table_name_length);
18311
 
        cmp_name= table_name;
18312
 
      }
18313
 
    }
18314
 
    if (my_strcasecmp(table_alias_charset, cmp_name, alias))
18315
 
    {
18316
 
      char t_alias_buff[MAX_ALIAS_NAME];
18317
 
      const char *t_alias= alias;
18318
 
 
18319
 
      str->append(' ');
18320
 
      if (lower_case_table_names== 1)
18321
 
      {
18322
 
        if (alias && alias[0])
18323
 
        {
18324
 
          stpcpy(t_alias_buff, alias);
18325
 
          my_casedn_str(files_charset_info, t_alias_buff);
18326
 
          t_alias= t_alias_buff;
18327
 
        }
18328
 
      }
18329
 
 
18330
 
      append_identifier(thd, str, t_alias, strlen(t_alias));
18331
 
    }
18332
 
 
18333
 
    if (index_hints)
18334
 
    {
18335
 
      List_iterator<Index_hint> it(*index_hints);
18336
 
      Index_hint *hint;
18337
 
 
18338
 
      while ((hint= it++))
18339
 
      {
18340
 
        str->append (STRING_WITH_LEN(" "));
18341
 
        hint->print (thd, str);
18342
 
      }
18343
 
    }
18344
 
  }
18345
 
}
18346
 
 
18347
 
 
18348
 
void st_select_lex::print(THD *thd, String *str, enum_query_type query_type)
18349
 
{
18350
 
  /* QQ: thd may not be set for sub queries, but this should be fixed */
18351
 
  if (!thd)
18352
 
    thd= current_thd;
 
7110
  print_table_array(session, str, table, table + tables->elements);
 
7111
}
 
7112
 
 
7113
void Select_Lex::print(Session *session, String *str, enum_query_type query_type)
 
7114
{
 
7115
  /* QQ: session may not be set for sub queries, but this should be fixed */
 
7116
  if (!session)
 
7117
    session= current_session;
18353
7118
 
18354
7119
  str->append(STRING_WITH_LEN("select "));
18355
7120
 
18356
7121
  /* First add options */
18357
7122
  if (options & SELECT_STRAIGHT_JOIN)
18358
7123
    str->append(STRING_WITH_LEN("straight_join "));
18359
 
  if ((thd->lex->lock_option == TL_READ_HIGH_PRIORITY) &&
18360
 
      (this == &thd->lex->select_lex))
18361
 
    str->append(STRING_WITH_LEN("high_priority "));
18362
7124
  if (options & SELECT_DISTINCT)
18363
7125
    str->append(STRING_WITH_LEN("distinct "));
18364
7126
  if (options & SELECT_SMALL_RESULT)
18391
7153
  {
18392
7154
    str->append(STRING_WITH_LEN(" from "));
18393
7155
    /* go through join tree */
18394
 
    print_join(thd, str, &top_join_list, query_type);
 
7156
    print_join(session, str, &top_join_list, query_type);
18395
7157
  }
18396
7158
  else if (where)
18397
7159
  {
18398
7160
    /*
18399
 
      "SELECT 1 FROM DUAL WHERE 2" should not be printed as 
 
7161
      "SELECT 1 FROM DUAL WHERE 2" should not be printed as
18400
7162
      "SELECT 1 WHERE 2": the 1st syntax is valid, but the 2nd is not.
18401
7163
    */
18402
7164
    str->append(STRING_WITH_LEN(" from DUAL "));
18419
7181
  if (group_list.elements)
18420
7182
  {
18421
7183
    str->append(STRING_WITH_LEN(" group by "));
18422
 
    print_order(str, (ORDER *) group_list.first, query_type);
 
7184
    print_order(str, (order_st *) group_list.first, query_type);
18423
7185
    switch (olap)
18424
7186
    {
18425
7187
      case CUBE_TYPE:
18450
7212
  if (order_list.elements)
18451
7213
  {
18452
7214
    str->append(STRING_WITH_LEN(" order by "));
18453
 
    print_order(str, (ORDER *) order_list.first, query_type);
 
7215
    print_order(str, (order_st *) order_list.first, query_type);
18454
7216
  }
18455
7217
 
18456
7218
  // limit
18457
 
  print_limit(thd, str, query_type);
 
7219
  print_limit(session, str, query_type);
18458
7220
 
18459
7221
  // PROCEDURE unsupported here
18460
7222
}
18461
7223
 
18462
 
 
18463
 
/**
18464
 
  change select_result object of JOIN.
18465
 
 
18466
 
  @param res            new select_result object
18467
 
 
18468
 
  @retval
18469
 
    false   OK
18470
 
  @retval
18471
 
    true    error
18472
 
*/
18473
 
 
18474
 
bool JOIN::change_result(select_result *res)
18475
 
{
18476
 
  result= res;
18477
 
  if (result->prepare(fields_list, select_lex->master_unit()) ||
18478
 
                     result->prepare2())
18479
 
  {
18480
 
    return(true);
18481
 
  }
18482
 
  return(false);
18483
 
}
18484
 
 
18485
7224
/**
18486
7225
  @} (end of group Query_Optimizer)
18487
7226
*/