MySQL 8.4.3
Source Code Documentation
sql_optimizer.h
Go to the documentation of this file.
1#ifndef SQL_OPTIMIZER_INCLUDED
2#define SQL_OPTIMIZER_INCLUDED
3
4/* Copyright (c) 2000, 2024, Oracle and/or its affiliates.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License, version 2.0,
8 as published by the Free Software Foundation.
9
10 This program is designed to work with certain software (including
11 but not limited to OpenSSL) that is licensed under separate terms,
12 as designated in a particular file or component or in included license
13 documentation. The authors of MySQL hereby grant you an additional
14 permission to link the program and your derivative works with the
15 separately licensed software that they have either included with
16 the program or referenced in the documentation.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License, version 2.0, for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
26
27/**
28 @file sql/sql_optimizer.h
29 Classes used for query optimizations.
30*/
31
32#include <sys/types.h>
33
34#include <cstring>
35#include <memory>
36#include <utility>
37
38#include "field_types.h"
39#include "my_alloc.h"
40#include "my_base.h"
41#include "my_dbug.h"
42#include "my_table_map.h"
43#include "sql/field.h"
44#include "sql/item.h"
46#include "sql/mem_root_array.h"
47#include "sql/opt_explain_format.h" // Explain_sort_clause
48#include "sql/sql_executor.h"
49#include "sql/sql_lex.h"
50#include "sql/sql_list.h"
52#include "sql/sql_select.h" // Key_use
53#include "sql/table.h"
55
56enum class Subquery_strategy : int;
57class COND_EQUAL;
58class Item_subselect;
59class Item_sum;
61class THD;
62class Window;
63struct AccessPath;
64struct MYSQL_LOCK;
65
66class Item_equal;
67template <class T>
68class mem_root_deque;
69
70// Key_use has a trivial destructor, no need to run it from Mem_root_array.
72
74
75/*
76 This structure is used to collect info on potentially sargable
77 predicates in order to check whether they become sargable after
78 reading const tables.
79 We form a bitmap of indexes that can be used for sargable predicates.
80 Only such indexes are involved in range analysis.
81*/
82
84 Field *field; /* field against which to check sargability */
85 Item **arg_value; /* values of potential keys for lookups */
86 uint num_values; /* number of values in the above array */
87};
88
89/**
90 Wrapper for ORDER* pointer to trace origins of ORDER list
91
92 As far as ORDER is just a head object of ORDER expression
93 chain, we need some wrapper object to associate flags with
94 the whole ORDER list.
95*/
97 public:
98 ORDER *order; ///< ORDER expression that we are wrapping with this class
99 Explain_sort_clause src; ///< origin of order list
100
101 private:
102 int flags; ///< bitmap of Explain_sort_property
103 // Status of const condition removal from the ORDER Expression
105
106 public:
108
110 bool const_optimized_arg = false)
111 : order(order_arg),
112 src(src_arg),
113 flags(order_arg ? ESP_EXISTS : ESP_none),
114 m_const_optimized(const_optimized_arg) {}
115
116 bool empty() const { return order == nullptr; }
117
118 void clean() {
119 order = nullptr;
120 src = ESC_none;
121 flags = ESP_none;
122 m_const_optimized = false;
123 }
124
125 int get_flags() const {
126 assert(order);
127 return flags;
128 }
129
130 bool is_const_optimized() const { return m_const_optimized; }
131};
132
133class JOIN {
134 public:
135 JOIN(THD *thd_arg, Query_block *select);
136 JOIN(const JOIN &rhs) = delete;
137 JOIN &operator=(const JOIN &rhs) = delete;
138
139 /// Query expression referring this query block
142 }
143
144 /// Query block that is optimized and executed using this JOIN
146 /// Thread handler
147 THD *const thd;
148
149 /**
150 Optimal query execution plan. Initialized with a tentative plan in
151 JOIN::make_join_plan() and later replaced with the optimal plan in
152 get_best_combination().
153 */
155 /// Array of QEP_TABs
156 QEP_TAB *qep_tab{nullptr};
157
158 /**
159 Array of plan operators representing the current (partial) best
160 plan. The array is allocated in JOIN::make_join_plan() and is valid only
161 inside this function. Initially (*best_ref[i]) == join_tab[i].
162 The optimizer reorders best_ref.
163 */
164 JOIN_TAB **best_ref{nullptr};
165 /// mapping between table indexes and JOIN_TABs
166 JOIN_TAB **map2table{nullptr};
167 /*
168 The table which has an index that allows to produce the required ordering.
169 A special value of 0x1 means that the ordering will be produced by
170 passing 1st non-const table to filesort(). NULL means no such table exists.
171 */
173
174 // Temporary tables that need to be cleaned up after the query.
175 // Only used for the hypergraph optimizer; the non-hypergraph optimizer
176 // uses QEP_TABs to hold the list of tables (including temporary tables).
179
180 // Allocated on the MEM_ROOT, but can hold some objects
181 // that allocate on the heap and thus need destruction.
183 };
186
187 // Similarly, filesorts that need to be cleaned up after the query.
188 // Only used for the hypergraph optimizer, for the same reason as above.
190
191 /**
192 Before plan has been created, "tables" denote number of input tables in the
193 query block and "primary_tables" is equal to "tables".
194 After plan has been created (after JOIN::get_best_combination()),
195 the JOIN_TAB objects are enumerated as follows:
196 - "tables" gives the total number of allocated JOIN_TAB objects
197 - "primary_tables" gives the number of input tables, including
198 materialized temporary tables from semi-join operation.
199 - "const_tables" are those tables among primary_tables that are detected
200 to be constant.
201 - "tmp_tables" is 0, 1 or 2 (more if windows) and counts the maximum
202 possible number of intermediate tables in post-processing (ie sorting and
203 duplicate removal).
204 Later, tmp_tables will be adjusted to the correct number of
205 intermediate tables, @see JOIN::make_tmp_tables_info.
206 - The remaining tables (ie. tables - primary_tables - tmp_tables) are
207 input tables to materialized semi-join operations.
208 The tables are ordered as follows in the join_tab array:
209 1. const primary table
210 2. non-const primary tables
211 3. intermediate sort/group tables
212 4. possible holes in array
213 5. semi-joined tables used with materialization strategy
214 */
215 uint tables{0}; ///< Total number of tables in query block
216 uint primary_tables{0}; ///< Number of primary input tables in query block
217 uint const_tables{0}; ///< Number of primary tables deemed constant
218 uint tmp_tables{0}; ///< Number of temporary tables used by query
220 /**
221 Indicates that the data will be aggregated (typically GROUP BY),
222 _and_ that it is already processed in an order that is compatible with
223 the grouping in use (e.g. because we are scanning along an index,
224 or because an earlier step sorted the data in a group-compatible order).
225
226 Note that this flag changes value at multiple points during optimization;
227 if it's set when a temporary table is created, this means we aggregate
228 into said temporary table (end_write_group is chosen instead of end_write),
229 but if it's set later, it means that we can aggregate as we go,
230 just before sending the data to the client (end_send_group is chosen
231 instead of end_send).
232
233 @see make_group_fields, alloc_group_fields, JOIN::exec
234 */
236 /// If query contains GROUP BY clause
238 /// If true, send produced rows using query_result
239 bool do_send_rows{true};
240 /// Set of tables contained in query
242 table_map const_table_map; ///< Set of tables found to be const
243 /**
244 Const tables which are either:
245 - not empty
246 - empty but inner to a LEFT JOIN, thus "considered" not empty for the
247 rest of execution (a NULL-complemented row will be used).
248 */
250 /**
251 This is the bitmap of all tables which are dependencies of
252 lateral derived tables which are not (yet) part of the partial
253 plan. (The value is a logical 'or' of zero or more
254 Table_ref.map() values.)
255
256 When we are building the join order, there is a partial plan (an
257 ordered sequence of JOIN_TABs), and an unordered set of JOIN_TABs
258 not yet added to the plan. Due to backtracking, the partial plan
259 may both grow and shrink. When we add a new table to the plan, we
260 may wish to set up join buffering, so that rows from the preceding
261 table are buffered. If any of the remaining tables are derived
262 tables that depends on any of the predecessors of the table we
263 are adding (i.e. a lateral dependency), join buffering would be
264 inefficient. (@see setup_join_buffering() for a detailed
265 explanation of why this is so.)
266
267 For this reason we need to maintain this table_map of lateral
268 dependencies of tables not yet in the plan. Whenever we add a new
269 table to the plan, we update the map by calling
270 Optimize_table_order::recalculate_lateral_deps_incrementally().
271 And when we remove a table, we restore the previous map value
272 using a Tabel_map_restorer object.
273
274 As an example, assume that we join four tables, t1, t2, t3 and
275 d1, where d1 is a derived table that depends on t1:
276
277 SELECT * FROM t1 JOIN t2 ON t1.a=t2.b JOIN t3 ON t2.c=t3.d
278 JOIN LATERAL (SELECT DISTINCT e AS x FROM t4 WHERE t4.f=t1.c)
279 AS d1 ON t3.e=d1.x;
280
281 Now, if our partial plan is t1->t2, the map (of lateral
282 dependencies of the remaining tables) will contain t1.
283 This tells us that we should not use join buffering when joining t1
284 with t2. But if the partial plan is t1->d2->t2, the map will be
285 empty. We may thus use join buffering when joining d2 with t2.
286 */
288
289 /* Number of records produced after join + group operation */
294 // m_select_limit is used to decide if we are likely to scan the whole table.
296 /**
297 Used to fetch no more than given amount of rows per one
298 fetch operation of server side cursor.
299 The value is checked in end_send and end_send_group in fashion, similar
300 to offset_limit_cnt:
301 - fetch_limit= HA_POS_ERROR if there is no cursor.
302 - when we open a cursor, we set fetch_limit to 0,
303 - on each fetch iteration we add num_rows to fetch to fetch_limit
304 */
306
307 /**
308 This is the result of join optimization.
309
310 @note This is a scratch array, not used after get_best_combination().
311 */
313
314 /******* Join optimization state members start *******/
315
316 /* Current join optimization state */
318
319 /* We also maintain a stack of join optimization states in * join->positions[]
320 */
321 /******* Join optimization state members end *******/
322
323 /// A hook that secondary storage engines can use to override the executor
324 /// completely.
327
328 /**
329 The cost of best complete join plan found so far during optimization,
330 after optimization phase - cost of picked join order (not taking into
331 account the changes made by test_if_skip_sort_order(). Exception: Single
332 table query cost is updated after access change in
333 test_if_skip_sort_order()).
334 */
335 double best_read{0.0};
336 /**
337 The estimated row count of the plan with best read time (see above).
338 */
340 /// Expected cost of filesort.
341 double sort_cost{0.0};
342 /// Expected cost of windowing;
343 double windowing_cost{0.0};
347
348 // For destroying fields otherwise owned by RemoveDuplicatesIterator.
350
351 Item_sum **sum_funcs{nullptr};
352 /**
353 Describes a temporary table.
354 Each tmp table has its own tmp_table_param.
355 The one here is transiently used as a model by create_intermediate_table(),
356 to build the tmp table's own tmp_table_param.
357 */
360
361 enum class RollupState { NONE, INITED, READY };
363 bool implicit_grouping; ///< True if aggregated but no GROUP BY
364
365 /**
366 At construction time, set if SELECT DISTINCT. May be reset to false
367 later, when we set up a temporary table operation that deduplicates for us.
368 */
370
371 /**
372 If we have the GROUP BY statement in the query,
373 but the group_list was emptied by optimizer, this
374 flag is true.
375 It happens when fields in the GROUP BY are from
376 constant table
377 */
379
380 /*
381 simple_xxxxx is set if ORDER/GROUP BY doesn't include any references
382 to other tables than the first non-constant table in the JOIN.
383 It's also set if ORDER/GROUP BY is empty.
384 Used for deciding for or against using a temporary table to compute
385 GROUP/ORDER BY.
386 */
387 bool simple_order{false};
388 bool simple_group{false};
389
390 /*
391 m_ordered_index_usage is set if an ordered index access
392 should be used instead of a filesort when computing
393 ORDER/GROUP BY.
394 */
395 enum {
396 ORDERED_INDEX_VOID, // No ordered index avail.
397 ORDERED_INDEX_GROUP_BY, // Use index for GROUP BY
398 ORDERED_INDEX_ORDER_BY // Use index for ORDER BY
399 } m_ordered_index_usage{ORDERED_INDEX_VOID};
400
401 /**
402 Is set if we have a GROUP BY and we have ORDER BY on a constant or when
403 sorting isn't required.
404 */
405 bool skip_sort_order{false};
406
407 /**
408 If true we need a temporary table on the result set before any
409 windowing steps, e.g. for DISTINCT or we have a query ORDER BY.
410 See details in JOIN::optimize
411 */
413
414 /// If JOIN has lateral derived tables (is set at start of planning)
415 bool has_lateral{false};
416
417 /// Used and updated by JOIN::make_join_plan() and optimize_keyuse()
419
420 /**
421 Array of pointers to lists of expressions.
422 Each list represents the SELECT list at a certain stage of execution,
423 and also contains necessary extras: expressions added for ORDER BY,
424 GROUP BY, window clauses, underlying items of split items.
425 This array is only used when the query makes use of tmp tables: after
426 writing to tmp table (e.g. for GROUP BY), if this write also does a
427 function's calculation (e.g. of SUM), after the write the function's value
428 is in a column of the tmp table. If a SELECT list expression is the SUM,
429 and we now want to read that materialized SUM and send it forward, a new
430 expression (Item_field type instead of Item_sum), is needed. The new
431 expressions are listed in JOIN::tmp_fields_list[x]; 'x' is a number
432 (REF_SLICE_).
433 @see JOIN::make_tmp_tables_info()
434 */
436
437 int error{0}; ///< set in optimize(), exec(), prepare_result()
438
439 /**
440 Incremented each time clear_hash_tables() is run, signaling to
441 HashJoinIterators that they cannot keep their hash tables anymore
442 (since outer references may have changed).
443 */
445
446 /**
447 ORDER BY and GROUP BY lists, to transform with prepare,optimize and exec
448 */
450
451 // Used so that AggregateIterator knows which items to signal when the rollup
452 // level changes. Obviously only used in the presence of rollup.
457
458 /**
459 Any window definitions
460 */
462
463 /**
464 True if a window requires a certain order of rows, which implies that any
465 order of rows coming out of the pre-window join will be disturbed.
466 */
467 bool m_windows_sort{false};
468
469 /// If we have set up tmp tables for windowing, @see make_tmp_tables_info
470 bool m_windowing_steps{false};
471
472 /**
473 Buffer to gather GROUP BY, ORDER BY and DISTINCT QEP details for EXPLAIN
474 */
476
477 /**
478 JOIN::having_cond is initially equal to query_block->having_cond, but may
479 later be changed by optimizations performed by JOIN.
480 The relationship between the JOIN::having_cond condition and the
481 associated variable query_block->having_value is so that
482 having_value can be:
483 - COND_UNDEF if a having clause was not specified in the query or
484 if it has not been optimized yet
485 - COND_TRUE if the having clause is always true, in which case
486 JOIN::having_cond is set to NULL.
487 - COND_FALSE if the having clause is impossible, in which case
488 JOIN::having_cond is set to NULL
489 - COND_OK otherwise, meaning that the having clause needs to be
490 further evaluated
491 All of the above also applies to the where_cond/query_block->cond_value
492 pair.
493 */
494 /**
495 Optimized WHERE clause item tree (valid for one single execution).
496 Used in JOIN execution if no tables. Otherwise, attached in pieces to
497 JOIN_TABs and then not used in JOIN execution.
498 Printed by EXPLAIN EXTENDED.
499 Initialized by Query_block::get_optimizable_conditions().
500 */
502 /**
503 Optimized HAVING clause item tree (valid for one single execution).
504 Used in JOIN execution, as last "row filtering" step. With one exception:
505 may be pushed to the JOIN_TABs of temporary tables used in DISTINCT /
506 GROUP BY (see JOIN::make_tmp_tables_info()); in that case having_cond is
507 set to NULL, but is first saved to having_for_explain so that EXPLAIN
508 EXTENDED can still print it.
509 Initialized by Query_block::get_optimizable_conditions().
510 */
512 Item *having_for_explain; ///< Saved optimized HAVING for EXPLAIN
513 /**
514 Pointer set to query_block->get_table_list() at the start of
515 optimization. May be changed (to NULL) only if optimize_aggregated_query()
516 optimizes tables away.
517 */
520 /*
521 Join tab to return to. Points to an element of join->join_tab array, or to
522 join->join_tab[-1].
523 This is used at execution stage to shortcut join enumeration. Currently
524 shortcutting is done to handle outer joins or handle semi-joins with
525 FirstMatch strategy.
526 */
528
529 /**
530 ref_items is an array of 4+ slices, each containing an array of Item
531 pointers. ref_items is used in different phases of query execution.
532 - slice 0 is initially the same as Query_block::base_ref_items, ie it is
533 the set of items referencing fields from base tables. During optimization
534 and execution it may be temporarily overwritten by slice 1-3.
535 - slice 1 is a representation of the used items when being read from
536 the first temporary table.
537 - slice 2 is a representation of the used items when being read from
538 the second temporary table.
539 - slice 3 is a copy of the original slice 0. It is created if
540 slice overwriting is necessary, and it is used to restore
541 original values in slice 0 after having been overwritten.
542 - slices 4 -> N are used by windowing: all the window's out tmp tables,
543
544 Two windows: 4: window 1's out table
545 5: window 2's out table
546
547 and so on.
548
549 Slice 0 is allocated for the lifetime of a statement, whereas slices 1-3
550 are associated with a single optimization. The size of slice 0 determines
551 the slice size used when allocating the other slices.
552 */
554 nullptr}; // cardinality: REF_SLICE_SAVED_BASE + 1 + #windows*2
555
556 /**
557 The slice currently stored in ref_items[0].
558 Used to restore the base ref_items slice from the "save" slice after it
559 has been overwritten by another slice (1-3).
560 */
562
563 /**
564 Used only if this query block is recursive. Contains count of
565 all executions of this recursive query block, since the last
566 this->reset().
567 */
569
570 /**
571 <> NULL if optimization has determined that execution will produce an
572 empty result before aggregation, contains a textual explanation on why
573 result is empty. Implicitly grouped queries may still produce an
574 aggregation row.
575 @todo - suggest to set to "Preparation determined that query is empty"
576 when Query_block::is_empty_query() is true.
577 */
578 const char *zero_result_cause{nullptr};
579
580 /**
581 True if, at this stage of processing, subquery materialization is allowed
582 for children subqueries of this JOIN (those in the SELECT list, in WHERE,
583 etc). If false, and we have to evaluate a subquery at this stage, then we
584 must choose EXISTS.
585 */
587 /**
588 True if plan search is allowed to use references to expressions outer to
589 this JOIN (for example may set up a 'ref' access looking up an outer
590 expression in the index, etc).
591 */
592 bool allow_outer_refs{false};
593
594 /* Temporary tables used to weed-out semi-join duplicates */
597 /* end of allocation caching storage */
598
599 /** Exec time only: true <=> current group has been sent */
600 bool group_sent{false};
601 /// If true, calculate found rows for this query block
602 bool calc_found_rows{false};
603
604 /**
605 This will force tmp table to NOT use index + update for group
606 operation as it'll cause [de]serialization for each json aggregated
607 value and is very ineffective (times worse).
608 Server should use filesort, or tmp table + filesort to resolve GROUP BY
609 with JSON aggregate functions.
610 */
612
613 /// True if plan is const, ie it will return zero or one rows.
614 bool plan_is_const() const { return const_tables == primary_tables; }
615
616 /**
617 True if plan contains one non-const primary table (ie not including
618 tables taking part in semi-join materialization).
619 */
621
622 /**
623 Returns true if any of the items in JOIN::fields contains a call to the
624 full-text search function MATCH, which is not wrapped in an aggregation
625 function.
626 */
627 bool contains_non_aggregated_fts() const;
628
629 bool optimize(bool finalize_access_paths);
630 void reset();
631 bool prepare_result();
632 void destroy();
633 bool alloc_func_list();
635 bool before_group_by, bool recompute = false);
636
637 /**
638 Overwrites one slice of ref_items with the contents of another slice.
639 In the normal case, dst and src have the same size().
640 However: the rollup slices may have smaller size than slice_sz.
641 */
642 void copy_ref_item_slice(uint dst_slice, uint src_slice) {
643 copy_ref_item_slice(ref_items[dst_slice], ref_items[src_slice]);
644 }
646 assert(dst_arr.size() >= src_arr.size());
647 void *dest = dst_arr.array();
648 const void *src = src_arr.array();
649 if (!src_arr.is_null())
650 memcpy(dest, src, src_arr.size() * src_arr.element_size());
651 }
652
653 /**
654 Allocate a ref_item slice, assume that slice size is in ref_items[0]
655
656 @param thd_arg thread handler
657 @param sliceno The slice number to allocate in JOIN::ref_items
658
659 @returns false if success, true if error
660 */
661 bool alloc_ref_item_slice(THD *thd_arg, int sliceno);
662
663 /**
664 Overwrite the base slice of ref_items with the slice supplied as argument.
665
666 @param sliceno number to overwrite the base slice with, must be 1-4 or
667 4 + windowno.
668 */
669 void set_ref_item_slice(uint sliceno) {
670 assert((int)sliceno >= 1);
671 if (current_ref_item_slice != sliceno) {
673 DBUG_PRINT("info", ("JOIN %p ref slice %u -> %u", this,
674 current_ref_item_slice, sliceno));
675 current_ref_item_slice = sliceno;
676 }
677 }
678
679 /// @note do also consider Switch_ref_item_slice
681
682 /**
683 Returns the clone of fields_list which is appropriate for evaluating
684 expressions at the current stage of execution; which stage is denoted by
685 the value of current_ref_item_slice.
686 */
688
689 bool optimize_rollup();
691 /**
692 Release memory and, if possible, the open tables held by this execution
693 plan (and nested plans). It's used to release some tables before
694 the end of execution in order to increase concurrency and reduce
695 memory consumption.
696 */
697 void join_free();
698 /** Cleanup this JOIN. Not a full cleanup. reusable? */
699 void cleanup();
700
701 bool clear_fields(table_map *save_nullinfo);
702 void restore_fields(table_map save_nullinfo);
703
704 private:
705 /**
706 Return whether the caller should send a row even if the join
707 produced no rows if:
708 - there is an aggregate function (sum_func_count!=0), and
709 - the query is not grouped, and
710 - a possible HAVING clause evaluates to TRUE.
711
712 @note: if there is a having clause, it must be evaluated before
713 returning the row.
714 */
719 }
720
721 public:
725 bool attach_join_conditions(plan_idx last_tab);
726
727 private:
728 bool attach_join_condition_to_nest(plan_idx first_inner, plan_idx last_tab,
729 Item *join_cond, bool is_sj_mat_cond);
730
731 public:
734 bool sort_before_group);
738 table_map plan_tables, uint idx) const;
739 bool clear_sj_tmp_tables();
742
744 /// State of execution plan. Currently used only for EXPLAIN
746 NO_PLAN, ///< No plan is ready yet
747 ZERO_RESULT, ///< Zero result cause is set
748 NO_TABLES, ///< Plan has no tables
749 PLAN_READY ///< Plan is ready
750 };
751 /// See enum_plan_state
753 bool is_optimized() const { return optimized; }
754 void set_optimized() { optimized = true; }
755 bool is_executed() const { return executed; }
756 void set_executed() { executed = true; }
757
758 /**
759 Retrieve the cost model object to be used for this join.
760
761 @return Cost model object for the join
762 */
763
764 const Cost_model_server *cost_model() const;
765
766 /**
767 Check if FTS index only access is possible
768 */
769 bool fts_index_access(JOIN_TAB *tab);
770
772 /**
773 Propagate dependencies between tables due to outer join relations.
774
775 @returns false if success, true if error
776 */
778
779 /**
780 Handle offloading of query parts to the underlying engines, when
781 such is supported by their implementation.
782
783 @returns false if success, true if error
784 */
785 bool push_to_engines();
786
789
790 /**
791 If this query block was planned twice, once with and once without conditions
792 added by in2exists, changes the root access path to the one without
793 in2exists. If not (ie., there were never any such conditions in the first
794 place), does nothing.
795 */
797
798 /**
799 In the case of rollup (only): After the base slice list was made, we may
800 have modified the field list to add rollup group items and sum switchers,
801 but there may be Items with refs that refer to the base slice. This function
802 refreshes the base slice (and its copy, REF_SLICE_SAVED_BASE) with a fresh
803 copy of the list from “fields”.
804
805 When we get rid of slices entirely, we can get rid of this, too.
806 */
807 void refresh_base_slice();
808
809 /**
810 Whether this query block needs finalization (see
811 FinalizePlanForQueryBlock()) before it can be actually used.
812 This only happens when using the hypergraph join optimizer.
813 */
814 bool needs_finalize{false};
815
816 private:
817 bool optimized{false}; ///< flag to avoid double optimization in EXPLAIN
818
819 /**
820 Set by exec(), reset by reset(). Note that this needs to be set
821 _during_ the query (not only when it's done executing), or the
822 dynamic range optimizer will not understand which tables have been
823 read.
824 */
825 bool executed{false};
826
827 /// Final execution plan state. Currently used only for EXPLAIN
829
830 public:
831 /*
832 When join->select_count is set, tables will not be optimized away.
833 The call to records() will be delayed until the execution phase and
834 the counting will be done on an index of Optimizer's choice.
835 The index will be decided in find_shortest_key(), called from
836 optimize_aggregated_query().
837 */
838 bool select_count{false};
839
840 private:
841 /**
842 Create a temporary table to be used for processing DISTINCT/ORDER
843 BY/GROUP BY.
844
845 @note Will modify JOIN object wrt sort/group attributes
846
847 @param tab the JOIN_TAB object to attach created table to
848 @param tmp_table_fields List of items that will be used to define
849 column types of the table.
850 @param tmp_table_group Group key to use for temporary table, empty if none.
851 @param save_sum_fields If true, do not replace Item_sum items in
852 @c tmp_fields list with Item_field items referring
853 to fields in temporary table.
854
855 @returns false on success, true on failure
856 */
858 const mem_root_deque<Item *> &tmp_table_fields,
859 ORDER_with_src &tmp_table_group,
860 bool save_sum_fields);
861
862 /**
863 Optimize distinct when used on a subset of the tables.
864
865 E.g.,: SELECT DISTINCT t1.a FROM t1,t2 WHERE t1.b=t2.b
866 In this case we can stop scanning t2 when we have found one t1.a
867 */
868 void optimize_distinct();
869
870 /**
871 Function sets FT hints, initializes FT handlers and
872 checks if FT index can be used as covered.
873 */
874 bool optimize_fts_query();
875
876 /**
877 Checks if the chosen plan suffers from a problem related to full-text search
878 and streaming aggregation, which is likely to cause wrong results or make
879 the query misbehave in other ways, and raises an error if so. Only to be
880 called for queries with full-text search and GROUP BY WITH ROLLUP.
881
882 If there are calls to MATCH in the SELECT list (including the hidden
883 elements lifted there from other clauses), and they are not inside an
884 aggregate function, the results of the MATCH clause need to be materialized
885 before streaming aggregation is performed. The hypergraph optimizer adds a
886 materialization step before aggregation if needed (see
887 CreateStreamingAggregationPath()), but the old optimizer only does that for
888 implicitly grouped queries. For explicitly grouped queries, it instead
889 disables streaming aggregation for the queries that would need a
890 materialization step to work correctly (see JOIN::test_skip_sort()).
891
892 For explicitly grouped queries WITH ROLLUP, however, streaming aggregation
893 is currently the only alternative. In many cases it still works correctly
894 because an intermediate materialization step has been added for some other
895 reason, typically for a sort. For now, in those cases where a
896 materialization step has not been added, we raise an error instead of going
897 ahead with an invalid execution plan.
898
899 @return true if an error was raised.
900 */
901 bool check_access_path_with_fts() const;
902
904 /**
905 Initialize key dependencies for join tables.
906
907 TODO figure out necessity of this method. Current test
908 suite passed without this initialization.
909 */
911 JOIN_TAB *const tab_end = join_tab + tables;
912 for (JOIN_TAB *tab = join_tab; tab < tab_end; tab++)
913 tab->key_dependent = tab->dependent;
914 }
915
916 private:
917 void set_prefix_tables();
918 void cleanup_item_list(const mem_root_deque<Item *> &items) const;
920 bool make_join_plan();
921 bool init_planner_arrays();
925 bool estimate_rowcount();
926 void optimize_keyuse();
927 void set_semijoin_info();
928 /**
929 An utility function - apply heuristics and optimize access methods to tables.
930 @note Side effect - this function could set 'Impossible WHERE' zero
931 result.
932 */
934 void update_depend_map();
936 /**
937 Fill in outer join related info for the execution plan structure.
938
939 For each outer join operation left after simplification of the
940 original query the function set up the following pointers in the linear
941 structure join->join_tab representing the selected execution plan.
942 The first inner table t0 for the operation is set to refer to the last
943 inner table tk through the field t0->last_inner.
944 Any inner table ti for the operation are set to refer to the first
945 inner table ti->first_inner.
946 The first inner table t0 for the operation is set to refer to the
947 first inner table of the embedding outer join operation, if there is any,
948 through the field t0->first_upper.
949 The on expression for the outer join operation is attached to the
950 corresponding first inner table through the field t0->on_expr_ref.
951 Here ti are structures of the JOIN_TAB type.
952
953 EXAMPLE. For the query:
954 @code
955 SELECT * FROM t1
956 LEFT JOIN
957 (t2, t3 LEFT JOIN t4 ON t3.a=t4.a)
958 ON (t1.a=t2.a AND t1.b=t3.b)
959 WHERE t1.c > 5,
960 @endcode
961
962 given the execution plan with the table order t1,t2,t3,t4
963 is selected, the following references will be set;
964 t4->last_inner=[t4], t4->first_inner=[t4], t4->first_upper=[t2]
965 t2->last_inner=[t4], t2->first_inner=t3->first_inner=[t2],
966 on expression (t1.a=t2.a AND t1.b=t3.b) will be attached to
967 *t2->on_expr_ref, while t3.a=t4.a will be attached to *t4->on_expr_ref.
968
969 @note
970 The function assumes that the simplification procedure has been
971 already applied to the join query (see simplify_joins).
972 This function can be called only after the execution plan
973 has been chosen.
974 */
975 void make_outerjoin_info();
976
977 /**
978 Initialize ref access for all tables that use it.
979
980 @return False if success, True if error
981
982 @note We cannot setup fields used for ref access before we have sorted
983 the items within multiple equalities according to the final order of
984 the tables involved in the join operation. Currently, this occurs in
985 @see substitute_for_best_equal_field().
986 */
987 bool init_ref_access();
988 bool alloc_qep(uint n);
989 void unplug_join_tabs();
990 bool setup_semijoin_materialized_table(JOIN_TAB *tab, uint tableno,
991 POSITION *inner_pos,
992 POSITION *sjm_pos);
993
994 bool add_having_as_tmp_table_cond(uint curr_tmp_table);
996 void set_plan_state(enum_plan_state plan_state_arg);
998 ORDER *remove_const(ORDER *first_order, Item *cond, bool change_list,
999 bool *simple_order, bool group_by);
1000
1001 /**
1002 Check whether this is a subquery that can be evaluated by index look-ups.
1003 If so, change subquery engine to subselect_indexsubquery_engine.
1004
1005 @retval 1 engine was changed
1006 @retval 0 engine wasn't changed
1007 @retval -1 OOM or other error
1008 */
1010
1011 /**
1012 Optimize DISTINCT, GROUP BY, ORDER BY clauses
1013
1014 @retval false ok
1015 @retval true an error occurred
1016 */
1018
1019 /**
1020 Test if an index could be used to replace filesort for ORDER BY/GROUP BY
1021
1022 @details
1023 Investigate whether we may use an ordered index as part of either
1024 DISTINCT, GROUP BY or ORDER BY execution. An ordered index may be
1025 used for only the first of any of these terms to be executed. This
1026 is reflected in the order which we check for test_if_skip_sort_order()
1027 below. However we do not check for DISTINCT here, as it would have
1028 been transformed to a GROUP BY at this stage if it is a candidate for
1029 ordered index optimization.
1030 If a decision was made to use an ordered index, the availability
1031 if such an access path is stored in 'm_ordered_index_usage' for later
1032 use by 'execute' or 'explain'
1033 */
1034 void test_skip_sort();
1035
1037
1038 /**
1039 Convert the executor structures to a set of access paths, storing
1040 the result in m_root_access_path.
1041 */
1042 void create_access_paths();
1043
1044 public:
1045 /**
1046 Create access paths with the knowledge that there are going to be zero rows
1047 coming from tables (before aggregation); typically because we know that
1048 all of them would be filtered away by WHERE (e.g. SELECT * FROM t1
1049 WHERE 1=2). This will normally yield no output rows, but if we have implicit
1050 aggregation, it might yield a single one.
1051 */
1053
1054 private:
1056
1057 /** @{ Helpers for create_access_paths. */
1061 /** @} */
1062
1063 /**
1064 An access path you can read from to get all records for this query
1065 (after you create an iterator from it).
1066 */
1068
1069 /**
1070 If this query block contains conditions synthesized during IN-to-EXISTS
1071 conversion: A second query plan with all such conditions removed.
1072 See comments in JOIN::optimize().
1073 */
1075};
1076
1077/**
1078 Use this in a function which depends on best_ref listing tables in the
1079 final join order. If 'tables==0', one is not expected to consult best_ref
1080 cells, and best_ref may not even have been allocated.
1081*/
1082#define ASSERT_BEST_REF_IN_JOIN_ORDER(join) \
1083 do { \
1084 assert((join)->tables == 0 || ((join)->best_ref && !(join)->join_tab)); \
1085 } while (0)
1086
1087/**
1088 RAII class to ease the temporary switching to a different slice of
1089 the ref item array.
1090*/
1093 uint saved;
1094
1095 public:
1096 Switch_ref_item_slice(JOIN *join_arg, uint new_v)
1097 : join(join_arg), saved(join->get_ref_item_slice()) {
1098 if (!join->ref_items[new_v].is_null()) join->set_ref_item_slice(new_v);
1099 }
1101};
1102
1103bool uses_index_fields_only(Item *item, TABLE *tbl, uint keyno,
1104 bool other_tbls_ok);
1105bool remove_eq_conds(THD *thd, Item *cond, Item **retcond,
1106 Item::cond_result *cond_value);
1107bool optimize_cond(THD *thd, Item **conds, COND_EQUAL **cond_equal,
1108 mem_root_deque<Table_ref *> *join_list,
1109 Item::cond_result *cond_value);
1111 COND_EQUAL *cond_equal,
1112 JOIN_TAB **table_join_idx);
1116 THD *thd, uint keyparts, Item_field **fields,
1117 const mem_root_deque<Item *> &outer_exprs);
1118Item_field *get_best_field(Item_field *item_field, COND_EQUAL *cond_equal);
1119Item *make_cond_for_table(THD *thd, Item *cond, table_map tables,
1120 table_map used_table, bool exclude_expensive_cond);
1122 uint first_unused);
1123
1124/**
1125 Create an order list that consists of all non-const fields and items.
1126 This is usable for e.g. converting DISTINCT into GROUP or ORDER BY.
1127 Is ref_item_array is non-null (is_null() returns false), the items
1128 will point into the slice given by it. Otherwise, it points directly
1129 into *fields (this is the only reason why fields is not const).
1130
1131 Try to put the items in "order_list" first, to allow one to optimize away
1132 a later ORDER BY.
1133 */
1135 ORDER *order_list,
1136 mem_root_deque<Item *> *fields,
1137 bool skip_aggregates,
1138 bool convert_bit_fields_to_long,
1139 bool *all_order_by_fields_used);
1140
1141/**
1142 Returns true if arguments are a temporal Field having no date,
1143 part and a temporal expression having a date part.
1144 @param f Field
1145 @param v Expression
1146 */
1147inline bool field_time_cmp_date(const Field *f, const Item *v) {
1148 const enum_field_types ft = f->type();
1149 return is_temporal_type(ft) && !is_temporal_type_with_date(ft) &&
1151}
1152
1153bool substitute_gc(THD *thd, Query_block *query_block, Item *where_cond,
1154 ORDER *group_list, ORDER *order);
1155
1156/**
1157 This class restores a table_map object to its original value
1158 when '*this' is destroyed.
1159 */
1161 /** The location to be restored.*/
1163 /** The original value to restore.*/
1165
1166 public:
1167 /**
1168 Constructor.
1169 @param map The table map that we wish to restore.
1170 */
1173
1174 // This class is not intended to be copied.
1177
1180 void assert_unchanged() const { assert(*m_location == m_saved_value); }
1181};
1182
1183/**
1184 Estimates how many times a subquery will be executed as part of a
1185 query execution. If it is a cacheable subquery, the estimate tells
1186 how many times the subquery will be executed if it is not cached.
1187
1188 @param[in] subquery the Item that represents the subquery
1189 @param[in,out] trace optimizer trace context
1190
1191 @return the number of times the subquery is expected to be executed
1192*/
1193double calculate_subquery_executions(const Item_subselect *subquery,
1194 Opt_trace_context *trace);
1195
1196extern const char *antijoin_null_cond;
1197
1198/**
1199 Checks if an Item, which is constant for execution, can be evaluated during
1200 optimization. It cannot be evaluated if it contains a subquery and the
1201 OPTION_NO_SUBQUERY_DURING_OPTIMIZATION query option is active.
1202
1203 @param item the Item to check
1204 @param select the query block that contains the Item
1205 @return false if this Item contains a subquery and subqueries cannot be
1206 evaluated during optimization, or true otherwise
1207*/
1208bool evaluate_during_optimization(const Item *item, const Query_block *select);
1209
1210/**
1211 Find the multiple equality predicate containing a field.
1212
1213 The function retrieves the multiple equalities accessed through
1214 the cond_equal structure from current level and up looking for
1215 an equality containing a field. It stops retrieval as soon as the equality
1216 is found and set up inherited_fl to true if it's found on upper levels.
1217
1218 @param cond_equal multiple equalities to search in
1219 @param item_field field to look for
1220 @param[out] inherited_fl set up to true if multiple equality is found
1221 on upper levels (not on current level of
1222 cond_equal)
1223
1224 @return
1225 - Item_equal for the found multiple equality predicate if a success;
1226 - nullptr otherwise.
1227*/
1229 const Item_field *item_field, bool *inherited_fl);
1230
1231/**
1232 Find an artificial cap for ref access. This is mostly a crutch to mitigate
1233 that we don't estimate the cache effects of ref accesses properly
1234 (ie., normally, if we do many, they will hit cache instead of being
1235 separate seeks). Given to find_cost_for_ref().
1236 */
1237double find_worst_seeks(const TABLE *table, double num_rows,
1238 double table_scan_cost);
1239
1240/**
1241 Whether a ref lookup of “right_item” on “field” will give an exact
1242 comparison in all cases, ie., one can remove any further checks on
1243 field = right_item. If not, there may be false positives, and one
1244 needs to keep the comparison after the ref lookup.
1245
1246 @param thd thread handler
1247 @param field field that is looked up through an index
1248 @param right_item value used to perform look up
1249 @param can_evaluate whether the function is allowed to evaluate right_item
1250 (if true, right_item must be const-for-execution)
1251 @param[out] subsumes true if an exact comparison can be done, false otherwise
1252
1253 @returns false if success, true if error
1254 */
1255bool ref_lookup_subsumes_comparison(THD *thd, Field *field, Item *right_item,
1256 bool can_evaluate, bool *subsumes);
1257
1258/**
1259 Checks if we need to create iterators for this query. We usually have to. The
1260 exception is if a secondary engine is used, and that engine will offload the
1261 query execution to an external executor using #JOIN::override_executor_func.
1262 In this case, the external executor will use its own execution structures and
1263 we don't need to bother with creating the iterators needed by the MySQL
1264 executor.
1265 */
1266bool IteratorsAreNeeded(const THD *thd, AccessPath *root_path);
1267
1268/**
1269 Estimates the number of base table row accesses that will be performed when
1270 executing a query using the given plan.
1271
1272 @param path The access path representing the plan.
1273 @param num_evaluations The number of times this path is expected to be
1274 evaluated during a single execution of the query.
1275 @param limit The maximum number of rows expected to be read from this path.
1276 @return An estimate of the number of row accesses.
1277 */
1278double EstimateRowAccesses(const AccessPath *path, double num_evaluations,
1279 double limit);
1280
1281/**
1282 Returns true if "item" can be used as a hash join condition between the tables
1283 given by "left_side" and "right_side". This is used to determine whether an
1284 equijoin condition needs to be attached as an "extra" condition.
1285
1286 It can be used as a hash join condition if the item on one side of the
1287 equality references some table in left_side and none in right_side, and the
1288 other side of the equality references some table in right_side and none in
1289 left_side.
1290
1291 @param item An equality that is a candidate for joining the left side tables
1292 with the right side tables.
1293 @param left_side The tables on the left side of the join.
1294 @param right_side The tables on the right side of the join.
1295
1296 @retval true If the equality can be used as a hash join condition.
1297 @retval false If the equality must be added as an extra condition to be
1298 evaluated after the join.
1299*/
1300bool IsHashEquijoinCondition(const Item_eq_base *item, table_map left_side,
1301 table_map right_side);
1302
1303#endif /* SQL_OPTIMIZER_INCLUDED */
bool is_null() const
Definition: sql_array.h:157
Element_type * array() const
Definition: sql_array.h:165
size_t size() const
Definition: sql_array.h:154
size_t element_size() const
Definition: sql_array.h:153
Definition: item_cmpfunc.h:2727
API for getting cost estimates for server operations that are not directly related to a table object.
Definition: opt_costmodel.h:54
Definition: opt_explain_format.h:451
Definition: field.h:575
virtual enum_field_types type() const =0
Base class for the equality comparison operators = and <=>.
Definition: item_cmpfunc.h:991
Definition: item_cmpfunc.h:2587
Definition: item.h:4344
Base class that is common to all subqueries and subquery predicates.
Definition: item_subselect.h:80
Class Item_sum is the base class used for special expressions that SQL calls 'set functions'.
Definition: item_sum.h:399
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:936
bool is_temporal_with_date() const
Definition: item.h:3266
cond_result
Definition: item.h:998
@ COND_FALSE
Definition: item.h:998
Query optimization plan node.
Definition: sql_select.h:602
Definition: sql_optimizer.h:133
const Cost_model_server * cost_model() const
Retrieve the cost model object to be used for this join.
Definition: sql_optimizer.cc:11455
bool skip_sort_order
Is set if we have a GROUP BY and we have ORDER BY on a constant or when sorting isn't required.
Definition: sql_optimizer.h:405
Table_ref * tables_list
Pointer set to query_block->get_table_list() at the start of optimization.
Definition: sql_optimizer.h:518
bool attach_join_condition_to_nest(plan_idx first_inner, plan_idx last_tab, Item *join_cond, bool is_sj_mat_cond)
Helper for JOIN::attach_join_conditions().
Definition: sql_optimizer.cc:8716
void set_root_access_path(AccessPath *path)
Definition: sql_optimizer.h:788
bool calc_found_rows
If true, calculate found rows for this query block.
Definition: sql_optimizer.h:602
bool plan_is_single_table()
True if plan contains one non-const primary table (ie not including tables taking part in semi-join m...
Definition: sql_optimizer.h:620
void mark_const_table(JOIN_TAB *table, Key_use *key)
Move const tables first in the position array.
Definition: sql_optimizer.cc:8547
JOIN_TAB * join_tab
Optimal query execution plan.
Definition: sql_optimizer.h:154
ha_rows fetch_limit
Used to fetch no more than given amount of rows per one fetch operation of server side cursor.
Definition: sql_optimizer.h:305
Item_sum ** sum_funcs
Definition: sql_optimizer.h:351
List< Cached_item > group_fields
Definition: sql_optimizer.h:345
bool m_windows_sort
True if a window requires a certain order of rows, which implies that any order of rows coming out of...
Definition: sql_optimizer.h:467
MYSQL_LOCK * lock
Definition: sql_optimizer.h:359
bool executed
Set by exec(), reset by reset().
Definition: sql_optimizer.h:825
QEP_TAB * qep_tab
Array of QEP_TABs.
Definition: sql_optimizer.h:156
bool send_row_on_empty_set() const
Return whether the caller should send a row even if the join produced no rows if:
Definition: sql_optimizer.h:715
ha_rows found_records
Definition: sql_optimizer.h:291
uint recursive_iteration_count
Used only if this query block is recursive.
Definition: sql_optimizer.h:568
void copy_ref_item_slice(Ref_item_array dst_arr, Ref_item_array src_arr)
Definition: sql_optimizer.h:645
bool child_subquery_can_materialize
True if, at this stage of processing, subquery materialization is allowed for children subqueries of ...
Definition: sql_optimizer.h:586
Prealloced_array< Item_rollup_group_item *, 4 > rollup_group_items
Definition: sql_optimizer.h:453
COND_EQUAL * cond_equal
Definition: sql_optimizer.h:519
JOIN_TAB ** map2table
mapping between table indexes and JOIN_TABs
Definition: sql_optimizer.h:166
ha_rows m_select_limit
Definition: sql_optimizer.h:295
POSITION * positions
Definition: sql_optimizer.h:317
uint current_ref_item_slice
The slice currently stored in ref_items[0].
Definition: sql_optimizer.h:561
bool is_executed() const
Definition: sql_optimizer.h:755
uint tables
Before plan has been created, "tables" denote number of input tables in the query block and "primary_...
Definition: sql_optimizer.h:215
bool has_lateral
If JOIN has lateral derived tables (is set at start of planning)
Definition: sql_optimizer.h:415
bool need_tmp_before_win
If true we need a temporary table on the result set before any windowing steps, e....
Definition: sql_optimizer.h:412
Prealloced_array< Item_rollup_sum_switcher *, 4 > rollup_sums
Definition: sql_optimizer.h:455
uint tmp_tables
Number of temporary tables used by query.
Definition: sql_optimizer.h:218
int error
set in optimize(), exec(), prepare_result()
Definition: sql_optimizer.h:437
bool plan_is_const() const
True if plan is const, ie it will return zero or one rows.
Definition: sql_optimizer.h:614
table_map const_table_map
Set of tables found to be const.
Definition: sql_optimizer.h:242
Prealloced_array< TemporaryTableToCleanup, 1 > temp_tables
Definition: sql_optimizer.h:184
Query_block *const query_block
Query block that is optimized and executed using this JOIN.
Definition: sql_optimizer.h:145
bool select_distinct
At construction time, set if SELECT DISTINCT.
Definition: sql_optimizer.h:369
RollupState
Definition: sql_optimizer.h:361
List< TABLE > sj_tmp_tables
Definition: sql_optimizer.h:595
table_map found_const_table_map
Const tables which are either:
Definition: sql_optimizer.h:249
bool simple_order
Definition: sql_optimizer.h:387
void set_executed()
Definition: sql_optimizer.h:756
List< Window > m_windows
Any window definitions.
Definition: sql_optimizer.h:461
Explain_format_flags explain_flags
Buffer to gather GROUP BY, ORDER BY and DISTINCT QEP details for EXPLAIN.
Definition: sql_optimizer.h:475
mem_root_deque< Item * > * tmp_fields
Array of pointers to lists of expressions.
Definition: sql_optimizer.h:435
uint const_tables
Number of primary tables deemed constant.
Definition: sql_optimizer.h:217
Prealloced_array< Filesort *, 1 > filesorts_to_cleanup
Definition: sql_optimizer.h:189
ha_rows examined_rows
Definition: sql_optimizer.h:292
ha_rows row_limit
Definition: sql_optimizer.h:293
bool allow_outer_refs
True if plan search is allowed to use references to expressions outer to this JOIN (for example may s...
Definition: sql_optimizer.h:592
JOIN_TAB ** best_ref
Array of plan operators representing the current (partial) best plan.
Definition: sql_optimizer.h:164
Item * having_for_explain
Saved optimized HAVING for EXPLAIN.
Definition: sql_optimizer.h:512
RollupState rollup_state
Definition: sql_optimizer.h:362
AccessPath * root_access_path() const
Definition: sql_optimizer.h:787
ha_rows send_records
Definition: sql_optimizer.h:290
Override_executor_func override_executor_func
Definition: sql_optimizer.h:326
plan_idx return_tab
Definition: sql_optimizer.h:527
enum_plan_state plan_state
Final execution plan state. Currently used only for EXPLAIN.
Definition: sql_optimizer.h:828
Item * having_cond
Optimized HAVING clause item tree (valid for one single execution).
Definition: sql_optimizer.h:511
void make_outerjoin_info()
Fill in outer join related info for the execution plan structure.
Definition: sql_optimizer.cc:8576
mem_root_deque< Item * > * fields
Definition: sql_optimizer.h:344
@ ORDERED_INDEX_GROUP_BY
Definition: sql_optimizer.h:397
@ ORDERED_INDEX_VOID
Definition: sql_optimizer.h:396
@ ORDERED_INDEX_ORDER_BY
Definition: sql_optimizer.h:398
Temp_table_param tmp_table_param
Describes a temporary table.
Definition: sql_optimizer.h:358
bool select_count
Definition: sql_optimizer.h:838
bool m_windowing_steps
If we have set up tmp tables for windowing,.
Definition: sql_optimizer.h:470
bool finalize_table_conditions(THD *thd)
Remove redundant predicates and cache constant expressions.
Definition: sql_optimizer.cc:9231
bool fts_index_access(JOIN_TAB *tab)
Check if FTS index only access is possible.
Definition: sql_optimizer.cc:10964
void optimize_keyuse()
Update some values in keyuse for faster choose_table_order() loop.
Definition: sql_optimizer.cc:10866
bool with_json_agg
This will force tmp table to NOT use index + update for group operation as it'll cause [de]serializat...
Definition: sql_optimizer.h:611
uint send_group_parts
Definition: sql_optimizer.h:219
AccessPath * m_root_access_path_no_in2exists
If this query block contains conditions synthesized during IN-to-EXISTS conversion: A second query pl...
Definition: sql_optimizer.h:1074
ORDER_with_src group_list
Definition: sql_optimizer.h:449
double sort_cost
Expected cost of filesort.
Definition: sql_optimizer.h:341
bool generate_derived_keys()
Add keys to derived tables'/views' result tables in a list.
Definition: sql_optimizer.cc:9310
bool optimize_fts_query()
Function sets FT hints, initializes FT handlers and checks if FT index can be used as covered.
Definition: sql_optimizer.cc:10905
enum_plan_state
State of execution plan. Currently used only for EXPLAIN.
Definition: sql_optimizer.h:745
@ NO_TABLES
Plan has no tables.
Definition: sql_optimizer.h:748
@ NO_PLAN
No plan is ready yet.
Definition: sql_optimizer.h:746
@ ZERO_RESULT
Zero result cause is set.
Definition: sql_optimizer.h:747
@ PLAN_READY
Plan is ready.
Definition: sql_optimizer.h:749
Key_use_array keyuse_array
Used and updated by JOIN::make_join_plan() and optimize_keyuse()
Definition: sql_optimizer.h:418
bool group_sent
Exec time only: true <=> current group has been sent.
Definition: sql_optimizer.h:600
bool needs_finalize
Whether this query block needs finalization (see FinalizePlanForQueryBlock()) before it can be actual...
Definition: sql_optimizer.h:814
void init_key_dependencies()
Initialize key dependencies for join tables.
Definition: sql_optimizer.h:910
void set_ref_item_slice(uint sliceno)
Overwrite the base slice of ref_items with the slice supplied as argument.
Definition: sql_optimizer.h:669
List< Cached_item > group_fields_cache
Definition: sql_optimizer.h:346
bool contains_non_aggregated_fts() const
Returns true if any of the items in JOIN::fields contains a call to the full-text search function MAT...
Definition: sql_optimizer.cc:10998
bool streaming_aggregation
Indicates that the data will be aggregated (typically GROUP BY), and that it is already processed in ...
Definition: sql_optimizer.h:235
void set_optimized()
Definition: sql_optimizer.h:754
uint primary_tables
Number of primary input tables in query block.
Definition: sql_optimizer.h:216
bool optimize_rollup()
Optimize rollup specification.
Definition: sql_optimizer.cc:11412
THD *const thd
Thread handler.
Definition: sql_optimizer.h:147
table_map all_table_map
Set of tables contained in query.
Definition: sql_optimizer.h:241
bool attach_join_conditions(plan_idx last_tab)
Attach outer join conditions to generated table conditions in an optimal way.
Definition: sql_optimizer.cc:8827
bool decide_subquery_strategy()
Decides between EXISTS and materialization; performs last steps to set up the chosen strategy.
Definition: sql_optimizer.cc:11126
List< Semijoin_mat_exec > sjm_exec_list
Definition: sql_optimizer.h:596
JOIN(const JOIN &rhs)=delete
TABLE * sort_by_table
Definition: sql_optimizer.h:172
Ref_item_array * ref_items
ref_items is an array of 4+ slices, each containing an array of Item pointers.
Definition: sql_optimizer.h:553
bool do_send_rows
If true, send produced rows using query_result.
Definition: sql_optimizer.h:239
double windowing_cost
Expected cost of windowing;.
Definition: sql_optimizer.h:343
enum_plan_state get_plan_state() const
See enum_plan_state.
Definition: sql_optimizer.h:752
JOIN & operator=(const JOIN &rhs)=delete
ORDER_with_src order
ORDER BY and GROUP BY lists, to transform with prepare,optimize and exec.
Definition: sql_optimizer.h:449
bool group_optimized_away
If we have the GROUP BY statement in the query, but the group_list was emptied by optimizer,...
Definition: sql_optimizer.h:378
double best_read
The cost of best complete join plan found so far during optimization, after optimization phase - cost...
Definition: sql_optimizer.h:335
ORDER * remove_const(ORDER *first_order, Item *cond, bool change_list, bool *simple_order, bool group_by)
Remove all constants and check if ORDER only contains simple expressions.
Definition: sql_optimizer.cc:10241
bool implicit_grouping
True if aggregated but no GROUP BY.
Definition: sql_optimizer.h:363
POSITION * best_positions
This is the result of join optimization.
Definition: sql_optimizer.h:312
void finalize_derived_keys()
For each materialized derived table/view, informs every TABLE of the key it will (not) use,...
Definition: sql_optimizer.cc:9330
bool optimized
flag to avoid double optimization in EXPLAIN
Definition: sql_optimizer.h:817
bool compare_costs_of_subquery_strategies(Subquery_strategy *method)
Tells what is the cheapest between IN->EXISTS and subquery materialization, in terms of cost,...
Definition: sql_optimizer.cc:11187
bool is_optimized() const
Definition: sql_optimizer.h:753
enum JOIN::@184 ORDERED_INDEX_VOID
const char * zero_result_cause
<> NULL if optimization has determined that execution will produce an empty result before aggregation...
Definition: sql_optimizer.h:578
Query_expression * query_expression() const
Query expression referring this query block.
Definition: sql_optimizer.h:140
mem_root_deque< Item * > * get_current_fields()
Returns the clone of fields_list which is appropriate for evaluating expressions at the current stage...
Definition: sql_optimizer.cc:11449
bool(*)(JOIN *, Query_result *) Override_executor_func
A hook that secondary storage engines can use to override the executor completely.
Definition: sql_optimizer.h:325
void clear_hash_tables()
Definition: sql_optimizer.h:741
uint get_ref_item_slice() const
Definition: sql_optimizer.h:680
List< Cached_item > semijoin_deduplication_fields
Definition: sql_optimizer.h:349
bool grouped
If query contains GROUP BY clause.
Definition: sql_optimizer.h:237
void refine_best_rowcount()
Refine the best_rowcount estimation based on what happens after tables have been joined: LIMIT and ty...
Definition: sql_optimizer.cc:11423
AccessPath * m_root_access_path
An access path you can read from to get all records for this query (after you create an iterator from...
Definition: sql_optimizer.h:1067
ha_rows best_rowcount
The estimated row count of the plan with best read time (see above).
Definition: sql_optimizer.h:339
Item * where_cond
JOIN::having_cond is initially equal to query_block->having_cond, but may later be changed by optimiz...
Definition: sql_optimizer.h:501
bool simple_group
Definition: sql_optimizer.h:388
uint64_t hash_table_generation
Incremented each time clear_hash_tables() is run, signaling to HashJoinIterators that they cannot kee...
Definition: sql_optimizer.h:444
table_map deps_of_remaining_lateral_derived_tables
This is the bitmap of all tables which are dependencies of lateral derived tables which are not (yet)...
Definition: sql_optimizer.h:287
void copy_ref_item_slice(uint dst_slice, uint src_slice)
Overwrites one slice of ref_items with the contents of another slice.
Definition: sql_optimizer.h:642
A Key_use represents an equality predicate of the form (table.column = val), where the column is inde...
Definition: sql_select.h:177
Definition: sql_list.h:467
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:426
Wrapper for ORDER* pointer to trace origins of ORDER list.
Definition: sql_optimizer.h:96
bool empty() const
Definition: sql_optimizer.h:116
bool is_const_optimized() const
Definition: sql_optimizer.h:130
ORDER_with_src(ORDER *order_arg, Explain_sort_clause src_arg, bool const_optimized_arg=false)
Definition: sql_optimizer.h:109
int get_flags() const
Definition: sql_optimizer.h:125
bool m_const_optimized
Definition: sql_optimizer.h:104
void clean()
Definition: sql_optimizer.h:118
ORDER * order
ORDER expression that we are wrapping with this class.
Definition: sql_optimizer.h:98
ORDER_with_src()
Definition: sql_optimizer.h:107
Explain_sort_clause src
origin of order list
Definition: sql_optimizer.h:99
int flags
bitmap of Explain_sort_property
Definition: sql_optimizer.h:102
A per-session context which is always available at any point of execution, because in practice it's a...
Definition: opt_trace_context.h:93
A typesafe replacement for DYNAMIC_ARRAY.
Definition: prealloced_array.h:71
Definition: sql_executor.h:254
enum_op_type
Definition: sql_executor.h:401
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1163
Item::cond_result having_value
Definition: sql_lex.h:2061
Query_expression * master_query_expression() const
Definition: sql_lex.h:1257
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:626
Definition: query_result.h:58
RAII class to ease the temporary switching to a different slice of the ref item array.
Definition: sql_optimizer.h:1091
Switch_ref_item_slice(JOIN *join_arg, uint new_v)
Definition: sql_optimizer.h:1096
uint saved
Definition: sql_optimizer.h:1093
JOIN * join
Definition: sql_optimizer.h:1092
~Switch_ref_item_slice()
Definition: sql_optimizer.h:1100
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
This class restores a table_map object to its original value when '*this' is destroyed.
Definition: sql_optimizer.h:1160
Table_map_restorer(table_map *map)
Constructor.
Definition: sql_optimizer.h:1171
Table_map_restorer & operator=(const Table_map_restorer &)=delete
table_map *const m_location
The location to be restored.
Definition: sql_optimizer.h:1162
~Table_map_restorer()
Definition: sql_optimizer.h:1178
const table_map m_saved_value
The original value to restore.
Definition: sql_optimizer.h:1164
void restore()
Definition: sql_optimizer.h:1179
void assert_unchanged() const
Definition: sql_optimizer.h:1180
Table_map_restorer(const Table_map_restorer &)=delete
Definition: table.h:2864
Object containing parameters used when creating and using temporary tables.
Definition: temp_table_param.h:95
uint sum_func_count
Number of fields in the query that have aggregate functions.
Definition: temp_table_param.h:132
Represents the (explicit) window of a SQL 2003 section 7.11 <window clause>, or the implicit (inlined...
Definition: window.h:110
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
bool is_temporal_type(enum_field_types type)
Tests if field type is temporal, i.e.
Definition: field_common_properties.h:115
bool is_temporal_type_with_date(enum_field_types type)
Tests if field type is temporal and has date part, i.e.
Definition: field_common_properties.h:156
This file contains the field type.
enum_field_types
Column types for MySQL Note: Keep include/mysql/components/services/bits/stored_program_bits....
Definition: field_types.h:55
void optimize_distinct()
Optimize distinct when used on a subset of the tables.
Definition: sql_executor.cc:381
AccessPath * create_root_access_path_for_join()
Definition: sql_executor.cc:3066
AccessPath * attach_access_paths_for_having_and_limit(AccessPath *path) const
Definition: sql_executor.cc:3409
AccessPath * attach_access_path_for_update_or_delete(AccessPath *path) const
Definition: sql_executor.cc:3000
void restore_fields(table_map save_nullinfo)
Restore all result fields for all tables specified in save_nullinfo.
Definition: sql_executor.cc:4720
bool create_intermediate_table(QEP_TAB *tab, const mem_root_deque< Item * > &tmp_table_fields, ORDER_with_src &tmp_table_group, bool save_sum_fields)
Create a temporary table to be used for processing DISTINCT/ORDER BY/GROUP BY.
Definition: sql_executor.cc:214
QEP_TAB::enum_op_type get_end_select_func()
Definition: sql_executor.cc:609
void create_access_paths()
Convert the executor structures to a set of access paths, storing the result in m_root_access_path.
Definition: sql_executor.cc:3037
void create_access_paths_for_index_subquery()
Definition: sql_executor.cc:3433
bool clear_fields(table_map *save_nullinfo)
Set all column values from all input tables to NULL.
Definition: sql_executor.cc:4697
bool clear_corr_derived_tmp_tables()
Empties all correlated materialized derived tables.
Definition: sql_select.cc:1815
Item_equal * find_item_equal(COND_EQUAL *cond_equal, const Item_field *item_field, bool *inherited_fl)
Find the multiple equality predicate containing a field.
Definition: sql_optimizer.cc:3755
bool alloc_func_list()
Make an array of pointers to sum_functions to speed up sum_func calculation.
Definition: sql_select.cc:4103
Item_field * get_best_field(Item_field *item_field, COND_EQUAL *cond_equal)
Get the best field substitution for a given field.
Definition: sql_optimizer.cc:3788
void update_sargable_from_const(SARGABLE_PARAM *sargables)
Update info on indexes that can be used for search lookups as reading const tables may has added new ...
Definition: sql_optimizer.cc:5903
bool add_sorting_to_table(uint idx, ORDER_with_src *order, bool sort_before_group)
Add Filesort object to the given table to sort if with filesort.
Definition: sql_select.cc:5017
bool clear_sj_tmp_tables()
Remove all rows from all temp tables used by NL-semijoin runtime.
Definition: sql_select.cc:1805
bool alloc_qep(uint n)
Definition: sql_optimizer.cc:1343
void change_to_access_path_without_in2exists()
If this query block was planned twice, once with and once without conditions added by in2exists,...
Definition: sql_optimizer.cc:1142
void unplug_join_tabs()
Definition: sql_select.cc:4989
bool push_to_engines()
Handle offloading of query parts to the underlying engines, when such is supported by their implement...
Definition: sql_optimizer.cc:1178
bool make_tmp_tables_info()
Init tmp tables usage info.
Definition: sql_select.cc:4386
bool make_join_plan()
Calculate best possible join order and initialize the join structure.
Definition: sql_optimizer.cc:5351
void set_semijoin_embedding()
Set semi-join embedding join nest pointers.
Definition: sql_optimizer.cc:6076
bool optimize_distinct_group_order()
Optimize DISTINCT, GROUP BY, ORDER BY clauses.
Definition: sql_optimizer.cc:1490
JOIN(THD *thd_arg, Query_block *select)
Definition: sql_optimizer.cc:168
table_map calculate_deps_of_remaining_lateral_derived_tables(table_map plan_tables, uint idx) const
Finds the dependencies of the remaining lateral derived tables.
Definition: sql_optimizer.cc:3340
void set_prefix_tables()
Assign set of available (prefix) tables to all tables in query block.
Definition: sql_optimizer.cc:5244
void cleanup()
Cleanup this JOIN.
Definition: sql_select.cc:3750
bool uses_index_fields_only(Item *item, TABLE *tbl, uint keyno, bool other_tbls_ok)
Check if given expression only uses fields covered by index keyno in the table tbl.
Definition: sql_optimizer.cc:6556
void test_skip_sort()
Test if an index could be used to replace filesort for ORDER BY/GROUP BY.
Definition: sql_optimizer.cc:1676
bool propagate_dependencies()
Propagate dependencies between tables due to outer join relations.
Definition: sql_optimizer.cc:5600
void adjust_access_methods()
An utility function - apply heuristics and optimize access methods to tables.
Definition: sql_optimizer.cc:2989
bool estimate_rowcount()
Estimate the number of matched rows for each joined table.
Definition: sql_optimizer.cc:5941
bool prune_table_partitions()
Prune partitions for all tables of a join (query block).
Definition: sql_optimizer.cc:2838
uint build_bitmap_for_nested_joins(mem_root_deque< Table_ref * > *join_list, uint first_unused)
Assign each nested join structure a bit in nested_join_map.
Definition: sql_optimizer.cc:5069
void refresh_base_slice()
In the case of rollup (only): After the base slice list was made, we may have modified the field list...
Definition: sql_select.cc:4964
AccessPath * create_access_paths_for_zero_rows() const
Create access paths with the knowledge that there are going to be zero rows coming from tables (befor...
Definition: sql_optimizer.cc:1148
bool alloc_ref_item_slice(THD *thd_arg, int sliceno)
Allocate a ref_item slice, assume that slice size is in ref_items[0].
Definition: sql_optimizer.cc:208
bool setup_semijoin_materialized_table(JOIN_TAB *tab, uint tableno, POSITION *inner_pos, POSITION *sjm_pos)
Setup the materialized table for a semi-join nest.
Definition: sql_select.cc:3127
void join_free()
Release memory and, if possible, the open tables held by this execution plan (and nested plans).
Definition: sql_select.cc:3682
bool make_sum_func_list(const mem_root_deque< Item * > &fields, bool before_group_by, bool recompute=false)
Initialize 'sum_funcs' array with all Item_sum objects.
Definition: sql_select.cc:4151
bool extract_func_dependent_tables()
Extract const tables based on functional dependencies.
Definition: sql_optimizer.cc:5745
bool init_planner_arrays()
Initialize scratch arrays for the join order optimization.
Definition: sql_optimizer.cc:5481
bool substitute_gc(THD *thd, Query_block *query_block, Item *where_cond, ORDER *group_list, ORDER *order)
Substitute all expressions in the WHERE condition and ORDER/GROUP lists that match generated columns ...
Definition: sql_optimizer.cc:1224
void set_semijoin_info()
Set the first_sj_inner_tab and last_sj_inner_tab fields for all tables inside the semijoin nests of t...
Definition: sql_select.cc:2259
bool prepare_result()
Prepare join result.
Definition: sql_select.cc:1901
void destroy()
Clean up and destroy join object.
Definition: sql_select.cc:1919
bool add_having_as_tmp_table_cond(uint curr_tmp_table)
Add having condition as a filter condition, which is applied when reading from the temp table.
Definition: sql_select.cc:4230
Item * substitute_for_best_equal_field(THD *thd, Item *cond, COND_EQUAL *cond_equal, JOIN_TAB **table_join_idx)
Substitute every field reference in a condition by the best equal field and eliminate all multiple eq...
Definition: sql_optimizer.cc:4816
double find_worst_seeks(const TABLE *table, double num_rows, double table_scan_cost)
Find an artificial cap for ref access.
Definition: sql_optimizer.cc:5919
const char * antijoin_null_cond
Definition: sql_optimizer.cc:125
bool alloc_indirection_slices()
Definition: sql_optimizer.cc:218
void reset()
Reset the state of this join object so that it is ready for a new execution.
Definition: sql_select.cc:1836
bool optimize(bool finalize_access_paths)
Optimizes one query block into a query execution plan (QEP.)
Definition: sql_optimizer.cc:362
bool init_ref_access()
Initialize ref access for all tables that use it.
Definition: sql_select.cc:2236
bool get_best_combination()
Set up JOIN_TAB structs according to the picked join order in best_positions.
Definition: sql_optimizer.cc:3109
bool extract_const_tables()
Extract const tables based on row counts.
Definition: sql_optimizer.cc:5651
bool update_equalities_for_sjm()
Update equalities and keyuse references after semi-join materialization strategy is chosen.
Definition: sql_optimizer.cc:5180
void set_plan_state(enum_plan_state plan_state_arg)
Sets the plan's state of the JOIN.
Definition: sql_optimizer.cc:1315
bool check_access_path_with_fts() const
Checks if the chosen plan suffers from a problem related to full-text search and streaming aggregatio...
Definition: sql_optimizer.cc:258
void cleanup_item_list(const mem_root_deque< Item * > &items) const
Definition: sql_select.cc:2017
int replace_index_subquery()
Check whether this is a subquery that can be evaluated by index look-ups.
Definition: sql_optimizer.cc:1423
void update_depend_map()
Update the dependency map for the tables.
Definition: sql_optimizer.cc:5111
Subquery_strategy
Classes that represent predicates over table subqueries: [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL.
Definition: item_subselect.h:406
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
This file includes constants used by all storage engines.
my_off_t ha_rows
Definition: my_base.h:1141
#define HA_POS_ERROR
Definition: my_base.h:1143
#define DBUG_PRINT(keyword, arglist)
Definition: my_dbug.h:181
uint64_t table_map
Definition: my_table_map.h:30
static char * path
Definition: mysqldump.cc:149
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
std::string join(const detail::range auto &rng, std::string_view delim)
join elements of a range into a string separated by a delimiter.
Definition: string.h:74
std::map< Key, Value, Compare, ut::allocator< std::pair< const Key, Value > > > map
Specialization of map which uses ut_allocator.
Definition: ut0new.h:2893
EXPLAIN FORMAT=<format> <command>.
Explain_sort_clause
Enumeration of ORDER BY, GROUP BY and DISTINCT clauses for array indexing.
Definition: opt_explain_format.h:428
@ ESC_none
Definition: opt_explain_format.h:429
@ ESP_EXISTS
Original query has this clause.
Definition: opt_explain_format.h:444
@ ESP_none
Definition: opt_explain_format.h:443
required string key
Definition: replication_asynchronous_connection_failover.proto:60
Classes for query execution.
Common types of the Optimizer, used by optimization and execution.
@ REF_SLICE_ACTIVE
The slice which is used during evaluation of expressions; Item_ref::ref points there.
Definition: sql_opt_exec_shared.h:621
int plan_idx
This represents the index of a JOIN_TAB/QEP_TAB in an array.
Definition: sql_opt_exec_shared.h:54
bool evaluate_during_optimization(const Item *item, const Query_block *select)
Checks if an Item, which is constant for execution, can be evaluated during optimization.
Definition: sql_optimizer.cc:11494
bool IsHashEquijoinCondition(const Item_eq_base *item, table_map left_side, table_map right_side)
Returns true if "item" can be used as a hash join condition between the tables given by "left_side" a...
Definition: sql_optimizer.cc:11797
Item * make_cond_for_table(THD *thd, Item *cond, table_map tables, table_map used_table, bool exclude_expensive_cond)
Extract a condition that can be checked after reading given table.
Definition: sql_optimizer.cc:9546
double calculate_subquery_executions(const Item_subselect *subquery, Opt_trace_context *trace)
Estimates how many times a subquery will be executed as part of a query execution.
Definition: sql_optimizer.cc:11297
Key_use_array * create_keyuse_for_table(THD *thd, uint keyparts, Item_field **fields, const mem_root_deque< Item * > &outer_exprs)
Create a keyuse array for a table with a primary key.
Definition: sql_optimizer.cc:8510
double EstimateRowAccesses(const AccessPath *path, double num_evaluations, double limit)
Estimates the number of base table row accesses that will be performed when executing a query using t...
Definition: sql_optimizer.cc:11637
ORDER * create_order_from_distinct(THD *thd, Ref_item_array ref_item_array, ORDER *order_list, mem_root_deque< Item * > *fields, bool skip_aggregates, bool convert_bit_fields_to_long, bool *all_order_by_fields_used)
Create an order list that consists of all non-const fields and items.
Definition: sql_optimizer.cc:10753
bool field_time_cmp_date(const Field *f, const Item *v)
Returns true if arguments are a temporal Field having no date, part and a temporal expression having ...
Definition: sql_optimizer.h:1147
bool is_indexed_agg_distinct(JOIN *join, mem_root_deque< Item_field * > *out_args)
Check for the presence of AGGFN(DISTINCT a) queries that may be subject to loose index scan.
Definition: sql_optimizer.cc:8091
bool IteratorsAreNeeded(const THD *thd, AccessPath *root_path)
Checks if we need to create iterators for this query.
Definition: sql_optimizer.cc:11528
bool optimize_cond(THD *thd, Item **conds, COND_EQUAL **cond_equal, mem_root_deque< Table_ref * > *join_list, Item::cond_result *cond_value)
Optimize conditions by.
Definition: sql_optimizer.cc:10390
bool remove_eq_conds(THD *thd, Item *cond, Item **retcond, Item::cond_result *cond_value)
Removes const and eq items.
Definition: sql_optimizer.cc:10506
bool ref_lookup_subsumes_comparison(THD *thd, Field *field, Item *right_item, bool can_evaluate, bool *subsumes)
Whether a ref lookup of “right_item” on “field” will give an exact comparison in all cases,...
Definition: sql_optimizer.cc:8954
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:213
Definition: sql_optimizer.h:177
Temp_table_param * temp_table_param
Definition: sql_optimizer.h:182
TABLE * table
Definition: sql_optimizer.h:178
Definition: lock.h:39
Definition: table.h:286
A position of table within a join order.
Definition: sql_select.h:355
Definition: sql_optimizer.h:83
Item ** arg_value
Definition: sql_optimizer.h:85
Field * field
Definition: sql_optimizer.h:84
uint num_values
Definition: sql_optimizer.h:86
Definition: table.h:1406
#define PSI_NOT_INSTRUMENTED
Definition: validate_password_imp.cc:42
int n
Definition: xcom_base.cc:509