MySQL  8.0.25
Source Code Documentation
sql_opt_exec_shared.h
Go to the documentation of this file.
1 /* Copyright (c) 2014, 2021, Oracle and/or its affiliates.
2 
3  This program is free software; you can redistribute it and/or modify
4  it under the terms of the GNU General Public License, version 2.0,
5  as published by the Free Software Foundation.
6 
7  This program is also distributed with certain software (including
8  but not limited to OpenSSL) that is licensed under separate terms,
9  as designated in a particular file or component or in included license
10  documentation. The authors of MySQL hereby grant you an additional
11  permission to link the program and your derivative works with the
12  separately licensed software that they have included with MySQL.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License, version 2.0, for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program; if not, write to the Free Software
21  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22 
23 /**
24  @file sql/sql_opt_exec_shared.h
25  Common types of the Optimizer, used by optimization and execution.
26 */
27 
28 #ifndef SQL_OPT_EXEC_SHARED_INCLUDED
29 #define SQL_OPT_EXEC_SHARED_INCLUDED
30 
31 #include <assert.h>
32 #include "my_base.h"
33 
34 #include "sql/item.h"
35 
36 class JOIN;
37 class Item_func_match;
38 class store_key;
39 struct POSITION;
40 class QUICK_SELECT_I;
41 
42 /**
43  This represents the index of a JOIN_TAB/QEP_TAB in an array. "plan_idx":
44  "Plan Table Index". It is signed, because:
45  - firstmatch_return may be PRE_FIRST_PLAN_IDX (it can happen that the first
46  table of the plan uses FirstMatch: SELECT ... WHERE literal IN (SELECT
47  ...)).
48  - it must hold the invalid value NO_PLAN_IDX (which means "no
49  JOIN_TAB/QEP_TAB", equivalent of NULL pointer); this invalid value must
50  itself be different from PRE_FIRST_PLAN_IDX, to distinguish "FirstMatch to
51  before-first-table" (firstmatch_return==PRE_FIRST_PLAN_IDX) from "No
52  FirstMatch" (firstmatch_return==NO_PLAN_IDX).
53 */
54 typedef int8 plan_idx;
55 #define NO_PLAN_IDX (-2) ///< undefined index
56 #define PRE_FIRST_PLAN_IDX \
57  (-1) ///< right before the first (first's index is 0)
58 
59 struct TABLE_REF {
60  bool key_err;
61  uint key_parts; ///< num of ...
62  uint key_length; ///< length of key_buff
63  int key; ///< key no
64  uchar *key_buff; ///< value to look for with key
65  uchar *key_buff2; ///< key_buff+key_length
66  /**
67  Used to store the value from each keypart field. These values are
68  used for ref access. If key_copy[key_part] == NULL it means that
69  the value is constant and does not need to be reevaluated
70  */
72  Item **items; ///< val()'s for each keypart
73  /*
74  Array of pointers to trigger variables. Some/all of the pointers may be
75  NULL. The ref access can be used iff
76 
77  for each used key part i, (!cond_guards[i] || *cond_guards[i])
78 
79  This array is used by subquery code. The subquery code may inject
80  triggered conditions, i.e. conditions that can be 'switched off'. A ref
81  access created from such condition is not valid when at least one of the
82  underlying conditions is switched off (see subquery code for more details).
83  If a table in a subquery has this it means that the table access
84  will switch from ref access to table scan when the outer query
85  produces a NULL value to be checked for in the subquery. This will
86  be used by NOT IN subqueries and IN subqueries which need to distinguish
87  NULL and FALSE, where ignore_unknown() is false.
88  */
89  bool **cond_guards;
90  /**
91  @code (null_rejecting & (1<<i)) @endcode means the condition is '=' and no
92  matching rows will be produced if items[i] IS NULL (see
93  add_not_null_conds())
94  */
96  table_map depend_map; ///< Table depends on these tables.
97  /*
98  NULL byte position in the key_buf (if set, the key is taken to be NULL);
99  normally points to the first byte in the buffer. Used for REF_OR_NULL
100  lookups.
101  */
103  /*
104  The number of times the record associated with this key was used
105  in the join.
106  */
108 
109  /*
110  true <=> disable the "cache" as doing lookup with the same key value may
111  produce different results (because of Index Condition Pushdown)
112  */
114 
115  /*
116  If non-nullptr, all the fields are hashed together through functions
117  in store_key (with the result being put into this field), as opposed to
118  being matched against individual fields in the associated KEY's key parts.
119  */
121 
123  : key_err(true),
124  key_parts(0),
125  key_length(0),
126  key(-1),
127  key_buff(nullptr),
129  key_copy(nullptr),
130  items(nullptr),
132  null_rejecting(0),
133  depend_map(0),
135  use_count(0),
136  disable_cache(false) {}
137 
138  /**
139  @returns whether the reference contains NULL values which could never give
140  a match.
141  */
142  bool impossible_null_ref() const {
143  if (null_rejecting == 0) return false;
144  for (uint i = 0; i < key_parts; i++) {
145  if ((null_rejecting & 1 << i) && items[i]->is_nullable() &&
146  items[i]->is_null()) {
147  return true;
148  }
149  }
150  return false;
151  }
152 
153  /**
154  Check if there are triggered/guarded conditions that might be
155  'switched off' by the subquery code when executing 'Full scan on
156  NULL key' subqueries.
157 
158  @return true if there are guarded conditions, false otherwise
159  */
160 
161  bool has_guarded_conds() const {
162  assert(key_parts == 0 || cond_guards != nullptr);
163 
164  for (uint i = 0; i < key_parts; i++) {
165  if (cond_guards[i]) return true;
166  }
167  return false;
168  }
169 };
170 
171 struct CACHE_FIELD;
172 class QEP_operation;
173 class Filesort;
174 class Semijoin_mat_exec;
175 
176 /*
177  The structs which holds the join connections and join states
178 */
179 enum join_type {
180  /* Initial state. Access type has not yet been decided for the table */
182  /* Table has exactly one row */
184  /*
185  Table has at most one matching row. Values read
186  from this row can be treated as constants. Example:
187  "WHERE table.pk = 3"
188  */
190  /*
191  '=' operator is used on unique index. At most one
192  row is read for each combination of rows from
193  preceding tables
194  */
196  /*
197  '=' operator is used on non-unique index
198  */
200  /*
201  Full table scan.
202  */
204  /*
205  Range scan.
206  */
208  /*
209  Like table scan, but scans index leaves instead of
210  the table
211  */
213  /* Fulltext index is used */
215  /*
216  Like ref, but with extra search for NULL values.
217  E.g. used for "WHERE col = ... OR col IS NULL"
218  */
220  /*
221  Do multiple range scans over one table and combine
222  the results into one. The merge can be used to
223  produce unions and intersections
224  */
226 };
227 
228 /// Holds members common to JOIN_TAB and QEP_TAB.
229 class QEP_shared {
230  public:
232  : m_join(nullptr),
234  m_table(nullptr),
242  m_ref(),
243  m_index(0),
246  m_keys(),
247  m_records(0),
248  m_quick(nullptr),
250  added_tables_map(0),
252  m_skip_records_in_range(false) {}
253 
254  /*
255  Simple getters and setters. They are public. However, this object is
256  protected in QEP_shared_owner, so only that class and its children
257  (JOIN_TAB, QEP_TAB) can access the getters and setters.
258  */
259 
260  JOIN *join() const { return m_join; }
261  void set_join(JOIN *j) { m_join = j; }
262  plan_idx idx() const {
263  assert(m_idx >= 0); // Index must be valid
264  return m_idx;
265  }
266  void set_idx(plan_idx i) {
267  assert(m_idx == NO_PLAN_IDX); // Index should not change in lifetime
268  m_idx = i;
269  }
270  TABLE *table() const { return m_table; }
271  void set_table(TABLE *t) { m_table = t; }
272  POSITION *position() const { return m_position; }
286  TABLE_REF &ref() { return m_ref; }
287  uint index() const { return m_index; }
288  void set_index(uint i) { m_index = i; }
289  enum join_type type() const { return m_type; }
290  void set_type(enum join_type t) { m_type = t; }
291  Item *condition() const { return m_condition; }
292  void set_condition(Item *c) { m_condition = c; }
295  }
298  }
299  Key_map &keys() { return m_keys; }
300  ha_rows records() const { return m_records; }
302  QUICK_SELECT_I *quick() const { return m_quick; }
306  Item_func_match *ft_func() const { return m_ft_func; }
308 
309  // More elaborate functions:
310 
311  /**
312  Set available tables for a table in a join plan.
313 
314  @param prefix_tables_arg Set of tables available for this plan
315  @param prev_tables_arg Set of tables available for previous table, used to
316  calculate set of tables added for this table.
317  */
318  void set_prefix_tables(table_map prefix_tables_arg,
319  table_map prev_tables_arg) {
320  prefix_tables_map = prefix_tables_arg;
321  added_tables_map = prefix_tables_arg & ~prev_tables_arg;
322  }
323 
324  /**
325  Add an available set of tables for a table in a join plan.
326 
327  @param tables Set of tables added for this table in plan.
328  */
330  prefix_tables_map |= tables;
331  added_tables_map |= tables;
332  }
333 
335 
337  return m_first_inner != NO_PLAN_IDX;
338  }
341  }
343  return m_first_inner == m_idx && m_last_inner == m_idx;
344  }
345 
348  }
349 
351 
352  private:
354 
355  /**
356  Index of structure in array:
357  - NO_PLAN_IDX if before get_best_combination()
358  - index of pointer to this JOIN_TAB, in JOIN::best_ref array
359  - index of this QEP_TAB, in JOIN::qep array.
360  */
362 
363  /// Corresponding table. Might be an internal temporary one.
365 
366  /// Points into best_positions array. Includes cost info.
368 
369  /*
370  semijoin-related members.
371  */
372 
373  /**
374  Struct needed for materialization of semi-join. Set for a materialized
375  temporary table, and NULL for all other join_tabs (except when
376  materialization is in progress, @see join_materialize_semijoin()).
377  */
379 
380  /**
381  Boundaries of semijoin inner tables around this table. Valid only once
382  final QEP has been chosen. Depending on the strategy, they may define an
383  interval (all tables inside are inner of a semijoin) or
384  not. last_sj_inner is not set for Duplicates Weedout.
385  */
387 
388  /*
389  outer-join-related members.
390  */
391  plan_idx m_first_inner; ///< first inner table for including outer join
392  plan_idx m_last_inner; ///< last table table for embedding outer join
393  plan_idx m_first_upper; ///< first inner table for embedding outer join
394 
395  /**
396  Used to do index-based look up based on a key value.
397  Used when we read constant tables, in misc optimization (like
398  remove_const()), and in execution.
399  */
401 
402  /// ID of index used for index scan or semijoin LooseScan
404 
405  /// Type of chosen access method (scan, etc).
406  enum join_type m_type;
407 
408  /**
409  Table condition, ie condition to be evaluated for a row from this table.
410  Notice that the condition may refer to rows from previous tables in the
411  join prefix, as well as outer tables.
412  */
414 
415  /**
416  Whether the condition in m_condition is evaluated in front of a sort,
417  so that it does not need to be evaluated again (unless it is outer to
418  an inner join; see the relevant comments in SortingIterator::Init().
419 
420  Note that m_condition remains non-nullptr in this case, for purposes
421  of the (non-tree) EXPLAIN and for filesort to build up its read maps.
422  */
424 
425  /**
426  All keys with can be used.
427  Used by add_key_field() (optimization time) and execution of dynamic
428  range (DynamicRangeIterator), and EXPLAIN.
429  */
431 
432  /**
433  Either number of rows in the table or 1 for const table.
434  Used in optimization, and also in execution for FOUND_ROWS().
435  */
437 
438  /**
439  Non-NULL if quick-select used.
440  Filled in optimization, used in execution to find rows, and in EXPLAIN.
441  */
443 
444  /*
445  Maps below are shared because of dynamic range: in execution, it needs to
446  know the prefix tables, to find the possible QUICK methods.
447  */
448 
449  /**
450  The set of all tables available in the join prefix for this table,
451  including the table handled by this JOIN_TAB.
452  */
454  /**
455  The set of tables added for this table, compared to the previous table
456  in the join prefix.
457  */
459 
460  /** FT function */
462 
463  /**
464  Set if index dive can be skipped for this query.
465  See comments for check_skip_records_in_range_qualification.
466  */
468 };
469 
470 /// Owner of a QEP_shared; parent of JOIN_TAB and QEP_TAB.
472  public:
474 
475  /// Instructs to share the QEP_shared with another owner
476  void share_qs(QEP_shared_owner *other) { other->set_qs(m_qs); }
477  void set_qs(QEP_shared *q) {
478  assert(!m_qs);
479  m_qs = q;
480  }
481 
482  // Getters/setters forwarding to QEP_shared:
483 
484  JOIN *join() const { return m_qs ? m_qs->join() : nullptr; }
485  void set_join(JOIN *j) { return m_qs->set_join(j); }
486 
487  // NOTE: This index (and the associated map) is not the same as
488  // table_ref's index, which is the index in the original FROM list
489  // (before optimization).
490  plan_idx idx() const { return m_qs->idx(); }
491  void set_idx(plan_idx i) { return m_qs->set_idx(i); }
492  qep_tab_map idx_map() const { return qep_tab_map{1} << m_qs->idx(); }
493 
494  TABLE *table() const { return m_qs->table(); }
495  POSITION *position() const { return m_qs->position(); }
496  void set_position(POSITION *p) { return m_qs->set_position(p); }
499  return m_qs->set_sj_mat_exec(s);
500  }
502  plan_idx last_sj_inner() const { return m_qs->last_sj_inner(); }
503  plan_idx first_inner() const { return m_qs->first_inner(); }
504  plan_idx last_inner() const { return m_qs->last_inner(); }
505  plan_idx first_upper() const { return m_qs->first_upper(); }
507  void set_last_inner(plan_idx i) { return m_qs->set_last_inner(i); }
511  TABLE_REF &ref() const { return m_qs->ref(); }
512  uint index() const { return m_qs->index(); }
513  void set_index(uint i) { return m_qs->set_index(i); }
514  enum join_type type() const { return m_qs->type(); }
515  void set_type(enum join_type t) { return m_qs->set_type(t); }
516  Item *condition() const { return m_qs->condition(); }
517  void set_condition(Item *to) { return m_qs->set_condition(to); }
520  }
523  }
524  Key_map &keys() const { return m_qs->keys(); }
525  ha_rows records() const { return m_qs->records(); }
526  void set_records(ha_rows r) { return m_qs->set_records(r); }
527  QUICK_SELECT_I *quick() const { return m_qs->quick(); }
528  void set_quick(QUICK_SELECT_I *q) { return m_qs->set_quick(q); }
529  table_map prefix_tables() const { return m_qs->prefix_tables(); }
530  table_map added_tables() const { return m_qs->added_tables(); }
531  Item_func_match *ft_func() const { return m_qs->ft_func(); }
532  void set_ft_func(Item_func_match *f) { return m_qs->set_ft_func(f); }
534  return m_qs->set_prefix_tables(prefix_tables, prev_tables);
535  }
537  return m_qs->add_prefix_tables(tables);
538  }
541  }
544  }
547  }
550  }
551 
552  bool has_guarded_conds() const { return ref().has_guarded_conds(); }
553  bool and_with_condition(Item *tmp_cond);
554 
557  }
558 
560 
561  void qs_cleanup();
562 
563  protected:
564  QEP_shared *m_qs; // qs stands for Qep_Shared
565 };
566 
567 /**
568  Symbolic slice numbers into JOIN's arrays ref_items, tmp_fields and
569  tmp_all_fields
570 
571  See also the comments on JOIN::ref_items.
572 */
573 enum {
574  /**
575  The slice which is used during evaluation of expressions; Item_ref::ref
576  points there. This is the only slice that is not allocated on the heap;
577  it always points to query_block->base_ref_items.
578 
579  If we have a simple query (no temporary tables or GROUP BY needed),
580  this slice always contains the base slice, i.e., the actual Items used
581  in the original query.
582 
583  However, if we have temporary tables, there are cases where we need to
584  swap out those Items, because they refer to Fields that are no longer in
585  use. As a simple case, consider
586 
587  SELECT REVERSE(t1), COUNT(*) FROM t1 GROUP BY REVERSE(t1);
588 
589  Assuming no index on t1, this will require creating a temporary table
590  consisting only of REVERSE(t1), and then sorting it before grouping.
591  During execution of the query creating the temporary table, we will
592  have an Item_func_reverse pointing to a Field for t1, and the result of
593  this will be stored in the temporary table "tmp". However, when reading
594  from "tmp", it would be wrong to use that Item_func_reverse, as the Field
595  no longer exists. Thus, we create a slice (in REF_SLICE_TMP1) with new Item
596  pointers, where Item_func_reverse is replaced by an Item_field that reads
597  from the right field in the temporary table. Similar logic applies for
598  windowing functions etc.; see below.
599 
600  In such cases, the pointers in this slice are _overwritten_ (using memcpy)
601  by e.g. REF_SLICE_TMP1 for as long as we read from the temporary table.
602  Switch_ref_item_slice provides an encapsulation of the overwriting,
603  and the optimizer stores a copy of the original Item pointers in the
604  REF_SLICE_SAVED_BASE slice so that it is possible to copy them back
605  when we are done.
606 
607  @todo It would probably be better to store the active slice index in
608  current_thd and do the indirection in Item_ref_* instead of copying the
609  slices around.
610  */
612  /**
613  The slice with pointers to columns of 1st group-order-distinct tmp
614  table
615  */
617  /**
618  The slice with pointers to columns of 2nd group-order-distinct tmp
619  table
620  */
622  /**
623  The slice with pointers to columns of table(s), ie., the actual Items.
624  Only used for queries involving temporary tables or the likes; for simple
625  queries, they always live in REF_SLICE_ACTIVE, so we don't need a copy
626  here. See REF_SLICE_ACTIVE for more discussion.
627  */
629  /**
630  The slice with pointers to columns of 1st tmp table of windowing
631  */
633 };
634 
635 #endif // SQL_OPT_EXEC_SHARED_INCLUDED
Definition: sql_bitmap.h:137
Sorting related info.
Definition: filesort.h:51
Definition: item_func.h:3432
Definition: item.h:776
Definition: sql_optimizer.h:125
Owner of a QEP_shared; parent of JOIN_TAB and QEP_TAB.
Definition: sql_opt_exec_shared.h:471
void set_first_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:506
void set_position(POSITION *p)
Definition: sql_opt_exec_shared.h:496
Item * condition() const
Definition: sql_opt_exec_shared.h:516
void set_prefix_tables(table_map prefix_tables, table_map prev_tables)
Definition: sql_opt_exec_shared.h:533
void set_type(enum join_type t)
Definition: sql_opt_exec_shared.h:515
QEP_shared * m_qs
Definition: sql_opt_exec_shared.h:564
bool is_single_inner_for_outer_join() const
Definition: sql_opt_exec_shared.h:548
plan_idx first_upper() const
Definition: sql_opt_exec_shared.h:505
void set_condition(Item *to)
Definition: sql_opt_exec_shared.h:517
qep_tab_map idx_map() const
Definition: sql_opt_exec_shared.h:492
plan_idx first_sj_inner() const
Definition: sql_opt_exec_shared.h:501
bool is_first_inner_for_outer_join() const
Definition: sql_opt_exec_shared.h:545
void set_quick(QUICK_SELECT_I *q)
Definition: sql_opt_exec_shared.h:528
bool is_single_inner_of_semi_join() const
Definition: sql_opt_exec_shared.h:539
JOIN * join() const
Definition: sql_opt_exec_shared.h:484
QUICK_SELECT_I * quick() const
Definition: sql_opt_exec_shared.h:527
void set_skip_records_in_range(bool skip_records_in_range)
Definition: sql_opt_exec_shared.h:555
void set_first_sj_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:508
uint index() const
Definition: sql_opt_exec_shared.h:512
TABLE_REF & ref() const
Definition: sql_opt_exec_shared.h:511
void set_qs(QEP_shared *q)
Definition: sql_opt_exec_shared.h:477
Key_map & keys() const
Definition: sql_opt_exec_shared.h:524
plan_idx first_inner() const
Definition: sql_opt_exec_shared.h:503
Item_func_match * ft_func() const
Definition: sql_opt_exec_shared.h:531
bool is_inner_table_of_outer_join() const
Definition: sql_opt_exec_shared.h:542
void set_last_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:507
void set_ft_func(Item_func_match *f)
Definition: sql_opt_exec_shared.h:532
void set_first_upper(plan_idx i)
Definition: sql_opt_exec_shared.h:510
void set_records(ha_rows r)
Definition: sql_opt_exec_shared.h:526
ha_rows records() const
Definition: sql_opt_exec_shared.h:525
table_map prefix_tables() const
Definition: sql_opt_exec_shared.h:529
bool has_guarded_conds() const
Definition: sql_opt_exec_shared.h:552
QEP_shared_owner()
Definition: sql_opt_exec_shared.h:473
POSITION * position() const
Definition: sql_opt_exec_shared.h:495
void set_join(JOIN *j)
Definition: sql_opt_exec_shared.h:485
bool skip_records_in_range() const
Definition: sql_opt_exec_shared.h:559
bool condition_is_pushed_to_sort() const
Definition: sql_opt_exec_shared.h:518
void mark_condition_as_pushed_to_sort()
Definition: sql_opt_exec_shared.h:521
Semijoin_mat_exec * sj_mat_exec() const
Definition: sql_opt_exec_shared.h:497
enum join_type type() const
Definition: sql_opt_exec_shared.h:514
void share_qs(QEP_shared_owner *other)
Instructs to share the QEP_shared with another owner.
Definition: sql_opt_exec_shared.h:476
plan_idx last_inner() const
Definition: sql_opt_exec_shared.h:504
plan_idx idx() const
Definition: sql_opt_exec_shared.h:490
void add_prefix_tables(table_map tables)
Definition: sql_opt_exec_shared.h:536
void set_idx(plan_idx i)
Definition: sql_opt_exec_shared.h:491
void set_index(uint i)
Definition: sql_opt_exec_shared.h:513
TABLE * table() const
Definition: sql_opt_exec_shared.h:494
void set_sj_mat_exec(Semijoin_mat_exec *s)
Definition: sql_opt_exec_shared.h:498
table_map added_tables() const
Definition: sql_opt_exec_shared.h:530
plan_idx last_sj_inner() const
Definition: sql_opt_exec_shared.h:502
void set_last_sj_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:509
Holds members common to JOIN_TAB and QEP_TAB.
Definition: sql_opt_exec_shared.h:229
bool m_skip_records_in_range
Set if index dive can be skipped for this query.
Definition: sql_opt_exec_shared.h:467
table_map added_tables() const
Definition: sql_opt_exec_shared.h:305
void set_join(JOIN *j)
Definition: sql_opt_exec_shared.h:261
plan_idx m_first_sj_inner
Boundaries of semijoin inner tables around this table.
Definition: sql_opt_exec_shared.h:386
Key_map & keys()
Definition: sql_opt_exec_shared.h:299
QEP_shared()
Definition: sql_opt_exec_shared.h:231
JOIN * m_join
Definition: sql_opt_exec_shared.h:353
bool is_first_inner_for_outer_join() const
Definition: sql_opt_exec_shared.h:334
Item_func_match * m_ft_func
FT function.
Definition: sql_opt_exec_shared.h:461
TABLE * table() const
Definition: sql_opt_exec_shared.h:270
TABLE_REF & ref()
Definition: sql_opt_exec_shared.h:286
bool is_single_inner_of_outer_join() const
Definition: sql_opt_exec_shared.h:342
plan_idx m_idx
Index of structure in array:
Definition: sql_opt_exec_shared.h:361
void set_last_sj_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:282
void set_first_sj_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:281
plan_idx m_last_inner
last table table for embedding outer join
Definition: sql_opt_exec_shared.h:392
plan_idx first_inner()
Definition: sql_opt_exec_shared.h:278
TABLE_REF m_ref
Used to do index-based look up based on a key value.
Definition: sql_opt_exec_shared.h:400
bool is_single_inner_of_semi_join() const
Definition: sql_opt_exec_shared.h:339
void set_position(POSITION *p)
Definition: sql_opt_exec_shared.h:273
void add_prefix_tables(table_map tables)
Add an available set of tables for a table in a join plan.
Definition: sql_opt_exec_shared.h:329
bool is_inner_table_of_outer_join() const
Definition: sql_opt_exec_shared.h:336
bool condition_is_pushed_to_sort() const
Definition: sql_opt_exec_shared.h:293
plan_idx first_sj_inner()
Definition: sql_opt_exec_shared.h:276
void set_ft_func(Item_func_match *f)
Definition: sql_opt_exec_shared.h:307
Semijoin_mat_exec * m_sj_mat_exec
Struct needed for materialization of semi-join.
Definition: sql_opt_exec_shared.h:378
plan_idx m_first_upper
first inner table for embedding outer join
Definition: sql_opt_exec_shared.h:393
table_map prefix_tables_map
The set of all tables available in the join prefix for this table, including the table handled by thi...
Definition: sql_opt_exec_shared.h:453
bool m_condition_is_pushed_to_sort
Whether the condition in m_condition is evaluated in front of a sort, so that it does not need to be ...
Definition: sql_opt_exec_shared.h:423
Item_func_match * ft_func() const
Definition: sql_opt_exec_shared.h:306
Item * condition() const
Definition: sql_opt_exec_shared.h:291
plan_idx m_last_sj_inner
Definition: sql_opt_exec_shared.h:386
Item * m_condition
Table condition, ie condition to be evaluated for a row from this table.
Definition: sql_opt_exec_shared.h:413
void set_first_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:279
Semijoin_mat_exec * sj_mat_exec() const
Definition: sql_opt_exec_shared.h:274
void set_index(uint i)
Definition: sql_opt_exec_shared.h:288
Key_map m_keys
All keys with can be used.
Definition: sql_opt_exec_shared.h:430
uint index() const
Definition: sql_opt_exec_shared.h:287
ha_rows records() const
Definition: sql_opt_exec_shared.h:300
TABLE * m_table
Corresponding table. Might be an internal temporary one.
Definition: sql_opt_exec_shared.h:364
void set_type(enum join_type t)
Definition: sql_opt_exec_shared.h:290
uint m_index
ID of index used for index scan or semijoin LooseScan.
Definition: sql_opt_exec_shared.h:403
void mark_condition_as_pushed_to_sort()
Definition: sql_opt_exec_shared.h:296
QUICK_SELECT_I * m_quick
Non-NULL if quick-select used.
Definition: sql_opt_exec_shared.h:442
ha_rows m_records
Either number of rows in the table or 1 for const table.
Definition: sql_opt_exec_shared.h:436
POSITION * m_position
Points into best_positions array. Includes cost info.
Definition: sql_opt_exec_shared.h:367
QUICK_SELECT_I * quick() const
Definition: sql_opt_exec_shared.h:302
enum join_type type() const
Definition: sql_opt_exec_shared.h:289
void set_condition(Item *c)
Definition: sql_opt_exec_shared.h:292
plan_idx m_first_inner
first inner table for including outer join
Definition: sql_opt_exec_shared.h:391
void set_prefix_tables(table_map prefix_tables_arg, table_map prev_tables_arg)
Set available tables for a table in a join plan.
Definition: sql_opt_exec_shared.h:318
JOIN * join() const
Definition: sql_opt_exec_shared.h:260
table_map added_tables_map
The set of tables added for this table, compared to the previous table in the join prefix.
Definition: sql_opt_exec_shared.h:458
table_map prefix_tables() const
Definition: sql_opt_exec_shared.h:304
enum join_type m_type
Type of chosen access method (scan, etc).
Definition: sql_opt_exec_shared.h:406
plan_idx idx() const
Definition: sql_opt_exec_shared.h:262
void set_records(ha_rows r)
Definition: sql_opt_exec_shared.h:301
plan_idx last_inner()
Definition: sql_opt_exec_shared.h:284
void set_first_upper(plan_idx i)
Definition: sql_opt_exec_shared.h:283
void set_quick(QUICK_SELECT_I *q)
Definition: sql_opt_exec_shared.h:303
plan_idx last_sj_inner()
Definition: sql_opt_exec_shared.h:277
void set_idx(plan_idx i)
Definition: sql_opt_exec_shared.h:266
POSITION * position() const
Definition: sql_opt_exec_shared.h:272
bool skip_records_in_range() const
Definition: sql_opt_exec_shared.h:350
void set_table(TABLE *t)
Definition: sql_opt_exec_shared.h:271
plan_idx first_upper()
Definition: sql_opt_exec_shared.h:285
void set_sj_mat_exec(Semijoin_mat_exec *s)
Definition: sql_opt_exec_shared.h:275
void set_skip_records_in_range(bool skip_records_in_range)
Definition: sql_opt_exec_shared.h:346
void set_last_inner(plan_idx i)
Definition: sql_opt_exec_shared.h:280
Definition: opt_range.h:230
Executor structure for the materialized semi-join info, which contains.
Definition: sql_executor.h:142
class to copying an field/item to a key struct
Definition: sql_select.h:792
const char * p
Definition: ctype-mb.cc:1236
Dialog Client Authentication nullptr
Definition: dialog.cc:353
bool and_with_condition(Item *tmp_cond)
Extend join_tab->cond by AND'ing add_cond to it.
Definition: sql_select.cc:3467
void qs_cleanup()
Definition: sql_select.cc:3428
This file includes constants used by all storage engines.
ulong key_part_map
Definition: my_base.h:1004
my_off_t ha_rows
Definition: my_base.h:1136
unsigned long long int ulonglong
Definition: my_inttypes.h:55
unsigned char uchar
Definition: my_inttypes.h:51
int8_t int8
Definition: my_inttypes.h:61
uint64_t table_map
Definition: my_table_map.h:29
uint64_t qep_tab_map
Definition: my_table_map.h:31
const mysql_service_registry_t * r
Definition: pfs_example_plugin_employee.cc:85
join_type
Definition: sql_opt_exec_shared.h:179
@ JT_RANGE
Definition: sql_opt_exec_shared.h:207
@ JT_EQ_REF
Definition: sql_opt_exec_shared.h:195
@ JT_INDEX_SCAN
Definition: sql_opt_exec_shared.h:212
@ JT_FT
Definition: sql_opt_exec_shared.h:214
@ JT_SYSTEM
Definition: sql_opt_exec_shared.h:183
@ JT_REF_OR_NULL
Definition: sql_opt_exec_shared.h:219
@ JT_REF
Definition: sql_opt_exec_shared.h:199
@ JT_CONST
Definition: sql_opt_exec_shared.h:189
@ JT_INDEX_MERGE
Definition: sql_opt_exec_shared.h:225
@ JT_UNKNOWN
Definition: sql_opt_exec_shared.h:181
@ JT_ALL
Definition: sql_opt_exec_shared.h:203
@ REF_SLICE_WIN_1
The slice with pointers to columns of 1st tmp table of windowing.
Definition: sql_opt_exec_shared.h:632
@ REF_SLICE_ACTIVE
The slice which is used during evaluation of expressions; Item_ref::ref points there.
Definition: sql_opt_exec_shared.h:611
@ REF_SLICE_TMP2
The slice with pointers to columns of 2nd group-order-distinct tmp table.
Definition: sql_opt_exec_shared.h:621
@ REF_SLICE_SAVED_BASE
The slice with pointers to columns of table(s), ie., the actual Items.
Definition: sql_opt_exec_shared.h:628
@ REF_SLICE_TMP1
The slice with pointers to columns of 1st group-order-distinct tmp table.
Definition: sql_opt_exec_shared.h:616
#define NO_PLAN_IDX
undefined index
Definition: sql_opt_exec_shared.h:55
int8 plan_idx
This represents the index of a JOIN_TAB/QEP_TAB in an array.
Definition: sql_opt_exec_shared.h:40
A position of table within a join order.
Definition: sql_select.h:345
Definition: sql_opt_exec_shared.h:59
uchar * null_ref_key
Definition: sql_opt_exec_shared.h:102
bool has_guarded_conds() const
Check if there are triggered/guarded conditions that might be 'switched off' by the subquery code whe...
Definition: sql_opt_exec_shared.h:161
uint key_parts
num of ...
Definition: sql_opt_exec_shared.h:61
int key
key no
Definition: sql_opt_exec_shared.h:63
TABLE_REF()
Definition: sql_opt_exec_shared.h:122
store_key ** key_copy
Used to store the value from each keypart field.
Definition: sql_opt_exec_shared.h:71
uint key_length
length of key_buff
Definition: sql_opt_exec_shared.h:62
bool impossible_null_ref() const
Definition: sql_opt_exec_shared.h:142
ulonglong * keypart_hash
Definition: sql_opt_exec_shared.h:120
uchar * key_buff2
key_buff+key_length
Definition: sql_opt_exec_shared.h:65
bool ** cond_guards
Definition: sql_opt_exec_shared.h:89
bool key_err
Definition: sql_opt_exec_shared.h:60
bool disable_cache
Definition: sql_opt_exec_shared.h:113
table_map depend_map
Table depends on these tables.
Definition: sql_opt_exec_shared.h:96
uchar * key_buff
value to look for with key
Definition: sql_opt_exec_shared.h:64
ha_rows use_count
Definition: sql_opt_exec_shared.h:107
key_part_map null_rejecting
Definition: sql_opt_exec_shared.h:95
Item ** items
val()'s for each keypart
Definition: sql_opt_exec_shared.h:72
Definition: table.h:1389
unsigned int uint
Definition: uca-dump.cc:29
synode_no q[FIFO_SIZE]
Definition: xcom_base.cc:3018