MySQL 8.4.3
Source Code Documentation
sql_executor.h
Go to the documentation of this file.
1#ifndef SQL_EXECUTOR_INCLUDED
2#define SQL_EXECUTOR_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_executor.h
29 Classes for query execution.
30*/
31
32#include <sys/types.h>
33#include <string>
34#include <vector>
35
36#include "my_alloc.h"
37#include "my_inttypes.h"
38#include "my_table_map.h"
39#include "sql/sql_lex.h"
40#include "sql/sql_opt_exec_shared.h" // QEP_shared_owner
41#include "sql/table.h"
42#include "sql/temp_table_param.h" // Temp_table_param
43
44class Cached_item;
45class Field;
46class Field_longlong;
47class Filesort;
48class Item;
49class Item_sum;
50class JOIN;
51class JOIN_TAB;
52class KEY;
54class QEP_TAB;
55class RowIterator;
56class THD;
57template <class T>
58class mem_root_deque;
59
60struct AccessPath;
61struct POSITION;
62template <class T>
63class List;
64template <typename Element_type>
65class Mem_root_array;
66
67/*
68 Array of pointers to tables whose rowids compose the temporary table
69 record.
70*/
74 ushort null_byte;
76};
77
78/*
79 Temporary table used by semi-join DuplicateElimination strategy
80
81 This consists of the temptable itself and data needed to put records
82 into it. The table's DDL is as follows:
83
84 CREATE TABLE tmptable (col VARCHAR(n) BINARY, PRIMARY KEY(col));
85
86 where the primary key can be replaced with unique constraint if n exceeds
87 the limit (as it is always done for query execution-time temptables).
88
89 The record value is a concatenation of rowids of tables from the join we're
90 executing. If a join table is on the inner side of the outer join, we
91 assume that its rowid can be NULL and provide means to store this rowid in
92 the tuple.
93*/
94
96 public:
100
101 /*
102 is_confluent==true means this is a special case where the temptable record
103 has zero length (and presence of a unique key means that the temptable can
104 have either 0 or 1 records).
105 In this case we don't create the physical temptable but instead record
106 its state in SJ_TMP_TABLE::have_confluent_record.
107 */
109
110 /*
111 When is_confluent==true: the contents of the table (whether it has the
112 record or not).
113 */
115
116 /* table record parameters */
120
121 /* The temporary table itself (NULL means not created yet) */
123
124 /* Pointer to next table (next->start_idx > this->end_idx) */
126 /* Calc hash instead of too long key */
128};
129
130/**
131 Executor structure for the materialized semi-join info, which contains
132 - Description of expressions selected from subquery
133 - The sj-materialization temporary table
134*/
136 public:
139 : sj_nest(sj_nest),
144 table_param(),
145 table(nullptr) {}
147 Table_ref *const sj_nest; ///< Semi-join nest for this materialization
148 const bool is_scan; ///< true if executing a scan, false if lookup
149 const uint table_count; ///< Number of tables in the sj-nest
150 const uint mat_table_index; ///< Index in join_tab for materialized table
151 const uint inner_table_index; ///< Index in join_tab for first inner table
152 Temp_table_param table_param; ///< The temptable and its related info
153 TABLE *table; ///< Reference to temporary table
154};
155
157
158[[nodiscard]] bool copy_fields(Temp_table_param *param, const THD *thd,
159 bool reverse_copy = false);
160
161enum Copy_func_type : int {
162 /**
163 In non-windowing step, copies functions
164 */
166 /**
167 In windowing step, copies framing window function, including
168 all grouping aggregates, e.g. SUM, AVG and FIRST_VALUE, LAST_VALUE.
169 */
171 /**
172 In windowing step, copies non framing window function, e.g.
173 ROW_NUMBER, RANK, DENSE_RANK, except those that are two_pass cf.
174 copy_two_pass_window_functions which are treated separately.
175 */
177 /**
178 In windowing step, copies window functions that need frame cardinality,
179 that is we need to read all rows of a partition before we can compute the
180 wf's value for the the first row in the partition.
181 */
183 /**
184 In windowing step, copies framing window functions that read only one row
185 per frame.
186 */
188 /**
189 In first windowing step, copies non-window functions which do not rely on
190 window functions, i.e. those that have Item::has_wf() == false.
191 */
193 /**
194 In final windowing step, copies all non-wf functions. Must be called after
195 all wfs have been evaluated, as non-wf functions may reference wf,
196 e.g. 1+RANK.
197 */
199 /**
200 Copies all window functions.
201 */
203 /**
204 Copies Item_field only (typically because other functions might depend
205 on those fields).
206 */
208};
209
210bool copy_funcs(Temp_table_param *, const THD *thd,
212
213/**
214 Copy the lookup key into the table ref's key buffer.
215
216 @param thd pointer to the THD object
217 @param table the table to read
218 @param ref information about the index lookup key
219
220 @retval false ref key copied successfully
221 @retval true error detected during copying of key
222*/
224
225/** Help function when we get some an error from the table handler. */
227
229
230int do_sj_dups_weedout(THD *thd, SJ_TMP_TABLE *sjtbl);
232
233// Create list for using with temporary table
235 Ref_item_array ref_item_array,
236 mem_root_deque<Item *> *res_fields,
237 size_t added_non_hidden_fields,
238 bool windowing = false);
239// Create list for using with temporary table
241 THD *thd, Query_block *select,
242 Ref_item_array ref_item_array,
243 mem_root_deque<Item *> *res_fields,
244 size_t added_non_hidden_fields);
245bool prepare_sum_aggregators(Item_sum **func_ptr, bool need_distinct);
246bool setup_sum_funcs(THD *thd, Item_sum **func_ptr);
247bool make_group_fields(JOIN *main_join, JOIN *curr_join);
250ulonglong calc_field_hash(const Field *field, ulonglong *hash);
253
254class QEP_TAB : public QEP_shared_owner {
255 public:
264 rematerialize(false),
270 m_keyread_optim(false),
271 m_reversed_access(false),
273
274 /// Initializes the object from a JOIN_TAB
275 void init(JOIN_TAB *jt);
276 // Cleans up.
277 void cleanup();
278
279 // Getters and setters
280
283 bool keyread_optim() const { return m_keyread_optim; }
286 }
287 bool reversed_access() const { return m_reversed_access; }
288 void set_reversed_access(bool arg) { m_reversed_access = arg; }
289
290 void set_table(TABLE *t) {
291 m_qs->set_table(t);
292 if (t) t->reginfo.qep_tab = this;
293 }
294
295 /// @returns semijoin strategy for this table.
296 uint get_sj_strategy() const;
297
298 /// Return true if join_tab should perform a FirstMatch action
299 bool do_firstmatch() const { return firstmatch_return != NO_PLAN_IDX; }
300
301 /// Return true if join_tab should perform a LooseScan action
302 bool do_loosescan() const { return loosescan_key_len; }
303
304 /// Return true if join_tab starts a Duplicate Weedout action
305 bool starts_weedout() const { return flush_weedout_table; }
306
307 /// Return true if join_tab finishes a Duplicate Weedout action
308 bool finishes_weedout() const { return check_weed_out_table; }
309
310 /**
311 A helper function that allocates appropriate join cache object and
312 sets next_query_block function of previous tab.
313 */
314 void init_join_cache(JOIN_TAB *join_tab);
315
316 /**
317 @returns query block id for an inner table of materialized semi-join, and
318 0 for all other tables.
319 @note implementation is not efficient (loops over all tables) - use this
320 function only in EXPLAIN.
321 */
322 uint sjm_query_block_id() const;
323
324 /// @returns whether this is doing QS_DYNAMIC_RANGE
325 bool dynamic_range() const {
326 if (!position()) return false; // tmp table
327 return using_dynamic_range;
328 }
329
330 bool use_order() const; ///< Use ordering provided by chosen index?
331
332 /**
333 Construct an access path for reading from this table in the query,
334 using the access method that has been determined previously
335 (e.g., table scan, ref access, optional sort afterwards, etc.).
336 */
338 void push_index_cond(const JOIN_TAB *join_tab, uint keyno,
339 Opt_trace_object *trace_obj);
340
341 /// @return the index used for a table in a QEP
342 uint effective_index() const;
343
344 bool pfs_batch_update(const JOIN *join) const;
345
346 public:
347 /// Pointer to table reference
349
350 /* Variables for semi-join duplicate elimination */
353
354 /*
355 If set, means we should stop join enumeration after we've got the first
356 match and return to the specified join tab. May be PRE_FIRST_PLAN_IDX
357 which means stopping join execution after the first match.
358 */
360
361 /*
362 Length of key tuple (depends on #keyparts used) to use for loose scan.
363 If zero, means that loosescan is not used.
364 */
366
367 /*
368 If doing a LooseScan, this QEP is the first (i.e. "driving")
369 QEP_TAB, and match_tab points to the last QEP_TAB handled by the strategy.
370 match_tab->found_match should be checked to see if the current value group
371 had a match.
372 */
374
375 /// Dependent table functions have to be materialized on each new scan
377
383 };
386
387 /** true <=> remove duplicates on this table. */
389
390 // If we have a query of the type SELECT DISTINCT t1.* FROM t1 JOIN t2
391 // ON ..., (ie., we join in one or more tables that we don't actually
392 // read any columns from), we can stop scanning t2 as soon as we see the
393 // first row. This pattern seems to be a workaround for lack of semijoins
394 // in older versions of MySQL.
396
397 /** HAVING condition for checking prior saving a record into tmp table*/
399
400 // Operation between the previous QEP_TAB and this one.
402 // Regular nested loop.
404
405 // Aggregate (GROUP BY).
407
408 // Various temporary table operations, used at the end of the join.
413
414 // Block-nested loop (rewritten to hash join).
416
417 // Batch key access.
418 OT_BKA
420
421 /* Tmp table info */
423
424 /* Sorting related info */
426
427 /**
428 If we pushed a global ORDER BY down onto this first table, that ORDER BY
429 list will be preserved here.
430 */
432
433 /**
434 Slice number of the ref items array to switch to before reading rows from
435 this table.
436 */
438
439 /// Condition as it was set by the optimizer, used for EXPLAIN.
440 /// m_condition may be overwritten at a later stage.
442
443 /**
444 True if only index is going to be read for this table. This is the
445 optimizer's decision.
446 */
448
449 /**
450 True if reversed scan is used. This is the optimizer's decision.
451 */
453
454 /**
455 Maps of all lateral derived tables which should be refreshed when
456 execution reads a new row from this table.
457 @note that if a LDT depends on t1 and t2, and t2 is after t1 in the plan,
458 then only t2::lateral_derived_tables_depend_on_me gets the map of the
459 LDT, for efficiency (less useless calls to QEP_TAB::refresh_lateral())
460 and clarity in EXPLAIN.
461 */
463
465
466 QEP_TAB(const QEP_TAB &); // not defined
467 QEP_TAB &operator=(const QEP_TAB &); // not defined
468};
469
470bool set_record_buffer(TABLE *table, double expected_rows_to_fetch);
472void update_tmptable_sum_func(Item_sum **func_ptr, TABLE *tmp_table);
473bool has_rollup_result(Item *item);
474bool is_rollup_group_wrapper(const Item *item);
476
477/*
478 If a condition cannot be applied right away, for instance because it is a
479 WHERE condition and we're on the right side of an outer join, we have to
480 return it up so that it can be applied on a higher recursion level.
481 This structure represents such a condition.
482 */
485 int table_index_to_attach_to; // -1 means “on the last possible outer join”.
486};
487
488/**
489 Cache invalidator iterators we need to apply, but cannot yet due to outer
490 joins. As soon as “table_index_to_invalidate” is visible in our current join
491 nest (which means there could no longer be NULL-complemented rows we could
492 forget), we can and must output this invalidator and remove it from the array.
493 */
495 /**
496 The table whose every (post-join) row invalidates one or more derived
497 lateral tables.
498 */
501};
502
509
510/**
511 Create an AND conjunction of all given items. If there are no items, returns
512 nullptr. If there's only one item, returns that item.
513 */
515
518 const std::vector<Item *> &conditions, THD *thd);
519
520void SplitConditions(Item *condition, QEP_TAB *current_table,
521 std::vector<Item *> *predicates_below_join,
522 std::vector<PendingCondition> *predicates_above_join,
523 std::vector<PendingCondition> *join_conditions,
524 plan_idx semi_join_table_idx, qep_tab_map left_tables);
525
526/**
527 For a MATERIALIZE access path, move any non-basic iterators (e.g. sorts and
528 filters) from table_path to above the path, for easier EXPLAIN and generally
529 simpler structure. Note the assert in CreateIteratorFromAccessPath() that we
530 succeeded. (ALTERNATIVE counts as a basic iterator in this regard.)
531
532 We do this by finding the second-bottommost access path, and inserting our
533 materialize node as its child. The bottommost one becomes the actual table
534 access path.
535
536 If a ZERO_ROWS access path is materialized, we simply replace the MATERIALIZE
537 path with the ZERO_ROWS path, since there is nothing to materialize.
538 @param thd The current thread.
539 @param path the MATERIALIZE path.
540 @param query_block The query block in which 'path' belongs.
541 @returns The new root of the set of AccessPaths formed by 'path' and its
542 descendants.
543 */
545 const Query_block &query_block);
546
548 THD *thd, Table_ref *table_ref, TABLE *table, bool rematerialize,
549 Mem_root_array<const AccessPath *> *invalidators, bool need_rowid,
550 AccessPath *table_path);
551
552void ConvertItemsToCopy(const mem_root_deque<Item *> &items, Field **fields,
553 Temp_table_param *param);
554std::string RefToString(const Index_lookup &ref, const KEY &key,
555 bool include_nulls);
556
558
559/**
560 Split AND conditions into their constituent parts, recursively.
561 Conditions that are not AND conditions are appended unchanged onto
562 condition_parts. E.g. if you have ((a AND b) AND c), condition_parts
563 will contain [a, b, c], plus whatever it contained before the call.
564 */
565bool ExtractConditions(Item *condition,
566 Mem_root_array<Item *> *condition_parts);
567
569 AccessPath *range_scan,
570 Table_ref *table_ref, POSITION *position,
571 bool count_examined_rows);
572
573/**
574 Creates an iterator for the given table, then calls Init() on the resulting
575 iterator. Unlike create_table_iterator(), this can create iterators for sort
576 buffer results (which are set in the TABLE object during query execution).
577 Returns nullptr on failure.
578 */
580 THD *thd, TABLE *table, AccessPath *range_scan, Table_ref *table_ref,
581 POSITION *position, bool ignore_not_found_rows, bool count_examined_rows);
582
583/**
584 A short form for when there's no range scan, recursive CTEs or cost
585 information; just a unique_result or a simple table scan. Normally, you should
586 prefer just instantiating an iterator yourself -- this is for legacy use only.
587 */
589 THD *thd, TABLE *table, bool ignore_not_found_rows,
590 bool count_examined_rows) {
591 return init_table_iterator(thd, table, nullptr, nullptr, nullptr,
592 ignore_not_found_rows, count_examined_rows);
593}
594
595AccessPath *ConnectJoins(plan_idx upper_first_idx, plan_idx first_idx,
596 plan_idx last_idx, QEP_TAB *qep_tabs, THD *thd,
597 CallingContext calling_context,
598 std::vector<PendingCondition> *pending_conditions,
599 std::vector<PendingInvalidator> *pending_invalidators,
600 std::vector<PendingCondition> *pending_join_conditions,
601 qep_tab_map *unhandled_duplicates,
602 table_map *conditions_depend_on_outer_tables);
603
604#endif /* SQL_EXECUTOR_INCLUDED */
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:251
This is used for segregating rows in groups (e.g.
Definition: item.h:6541
Definition: field.h:2402
Definition: field.h:575
Sorting related info.
Definition: filesort.h:52
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
Query optimization plan node.
Definition: sql_select.h:602
Definition: sql_optimizer.h:133
Definition: key.h:113
Definition: sql_list.h:467
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:426
A JSON object (unordered set of key/value pairs).
Definition: opt_trace.h:802
Definition: sql_executor.h:254
uint loosescan_key_len
Definition: sql_executor.h:365
bool dynamic_range() const
Definition: sql_executor.h:325
Setup_func materialize_table
Definition: sql_executor.h:384
void set_reversed_access(bool arg)
Definition: sql_executor.h:288
Item * m_condition_optim
Condition as it was set by the optimizer, used for EXPLAIN.
Definition: sql_executor.h:441
bool rematerialize
Dependent table functions have to be materialized on each new scan.
Definition: sql_executor.h:376
bool keyread_optim() const
Definition: sql_executor.h:283
Filesort * filesort
Definition: sql_executor.h:425
bool reversed_access() const
Definition: sql_executor.h:287
void set_table(TABLE *t)
Definition: sql_executor.h:290
uint ref_item_slice
Slice number of the ref items array to switch to before reading rows from this table.
Definition: sql_executor.h:437
bool m_reversed_access
True if reversed scan is used.
Definition: sql_executor.h:452
qep_tab_map lateral_derived_tables_depend_on_me
Maps of all lateral derived tables which should be refreshed when execution reads a new row from this...
Definition: sql_executor.h:462
bool needs_duplicate_removal
true <=> remove duplicates on this table.
Definition: sql_executor.h:388
plan_idx firstmatch_return
Definition: sql_executor.h:359
enum QEP_TAB::enum_op_type op_type
bool do_firstmatch() const
Return true if join_tab should perform a FirstMatch action.
Definition: sql_executor.h:299
ORDER * filesort_pushed_order
If we pushed a global ORDER BY down onto this first table, that ORDER BY list will be preserved here.
Definition: sql_executor.h:431
Setup_func
Definition: sql_executor.h:378
@ NO_SETUP
Definition: sql_executor.h:379
@ MATERIALIZE_TABLE_FUNCTION
Definition: sql_executor.h:380
@ MATERIALIZE_SEMIJOIN
Definition: sql_executor.h:382
@ MATERIALIZE_DERIVED
Definition: sql_executor.h:381
QEP_TAB()
Definition: sql_executor.h:256
Item * condition_optim() const
Definition: sql_executor.h:281
QEP_TAB & operator=(const QEP_TAB &)
bool not_used_in_distinct
Definition: sql_executor.h:395
bool starts_weedout() const
Return true if join_tab starts a Duplicate Weedout action.
Definition: sql_executor.h:305
bool m_keyread_optim
True if only index is going to be read for this table.
Definition: sql_executor.h:447
bool using_dynamic_range
Definition: sql_executor.h:385
bool finishes_weedout() const
Return true if join_tab finishes a Duplicate Weedout action.
Definition: sql_executor.h:308
bool do_loosescan() const
Return true if join_tab should perform a LooseScan action.
Definition: sql_executor.h:302
Item * having
HAVING condition for checking prior saving a record into tmp table.
Definition: sql_executor.h:398
SJ_TMP_TABLE * flush_weedout_table
Definition: sql_executor.h:351
Temp_table_param * tmp_table_param
Definition: sql_executor.h:422
void set_condition_optim()
Definition: sql_executor.h:282
plan_idx match_tab
Definition: sql_executor.h:373
Table_ref * table_ref
Pointer to table reference.
Definition: sql_executor.h:348
SJ_TMP_TABLE * check_weed_out_table
Definition: sql_executor.h:352
enum_op_type
Definition: sql_executor.h:401
@ OT_MATERIALIZE
Definition: sql_executor.h:409
@ OT_BKA
Definition: sql_executor.h:418
@ OT_AGGREGATE_INTO_TMP_TABLE
Definition: sql_executor.h:411
@ OT_AGGREGATE
Definition: sql_executor.h:406
@ OT_BNL
Definition: sql_executor.h:415
@ OT_AGGREGATE_THEN_MATERIALIZE
Definition: sql_executor.h:410
@ OT_WINDOWING_FUNCTION
Definition: sql_executor.h:412
@ OT_NONE
Definition: sql_executor.h:403
Mem_root_array< const AccessPath * > * invalidators
Definition: sql_executor.h:464
QEP_TAB(const QEP_TAB &)
void set_keyread_optim()
Definition: sql_executor.h:284
Owner of a QEP_shared; parent of JOIN_TAB and QEP_TAB.
Definition: sql_opt_exec_shared.h:478
JOIN * join() const
Definition: sql_opt_exec_shared.h:491
TABLE * table() const
Definition: sql_opt_exec_shared.h:504
QEP_shared * m_qs
Definition: sql_opt_exec_shared.h:574
Item * condition() const
Definition: sql_opt_exec_shared.h:526
POSITION * position() const
Definition: sql_opt_exec_shared.h:505
void set_table(TABLE *t)
Definition: sql_opt_exec_shared.h:277
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1163
A context for reading through a single table using a chosen access method: index read,...
Definition: row_iterator.h:82
Definition: sql_executor.h:95
uint rowid_len
Definition: sql_executor.h:119
TABLE * tmp_table
Definition: sql_executor.h:122
SJ_TMP_TABLE_TAB * tabs
Definition: sql_executor.h:98
SJ_TMP_TABLE * next
Definition: sql_executor.h:125
uint null_bits
Definition: sql_executor.h:117
SJ_TMP_TABLE_TAB * tabs_end
Definition: sql_executor.h:99
bool have_confluent_row
Definition: sql_executor.h:114
SJ_TMP_TABLE()
Definition: sql_executor.h:97
uint null_bytes
Definition: sql_executor.h:118
bool is_confluent
Definition: sql_executor.h:108
Field_longlong * hash_field
Definition: sql_executor.h:127
Executor structure for the materialized semi-join info, which contains.
Definition: sql_executor.h:135
const bool is_scan
true if executing a scan, false if lookup
Definition: sql_executor.h:148
TABLE * table
Reference to temporary table.
Definition: sql_executor.h:153
Table_ref *const sj_nest
Semi-join nest for this materialization.
Definition: sql_executor.h:147
const uint inner_table_index
Index in join_tab for first inner table.
Definition: sql_executor.h:151
const uint mat_table_index
Index in join_tab for materialized table.
Definition: sql_executor.h:150
Temp_table_param table_param
The temptable and its related info.
Definition: sql_executor.h:152
~Semijoin_mat_exec()=default
const uint table_count
Number of tables in the sj-nest.
Definition: sql_executor.h:149
Semijoin_mat_exec(Table_ref *sj_nest, bool is_scan, uint table_count, uint mat_table_index, uint inner_table_index)
Definition: sql_executor.h:137
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Definition: table.h:2864
Object containing parameters used when creating and using temporary tables.
Definition: temp_table_param.h:95
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
Item * unwrap_rollup_group(Item *item)
Definition: sql_executor.cc:373
void init_tmptable_sum_functions(Item_sum **func_ptr)
Definition: sql_executor.cc:433
bool pfs_batch_update(const JOIN *join) const
Definition: sql_executor.cc:4737
ulonglong calc_row_hash(TABLE *table)
Generate hash for unique_constraint for all visible fields of a table.
Definition: sql_executor.cc:4098
bool setup_sum_funcs(THD *thd, Item_sum **func_ptr)
Call setup() for all sum functions.
Definition: sql_executor.cc:424
bool copy_funcs(Temp_table_param *, const THD *thd, Copy_func_type type=CFT_ALL)
Copy result of functions to record in tmp_table.
Definition: sql_executor.cc:465
bool has_rollup_result(Item *item)
Checks if an item has a ROLLUP NULL which needs to be written to temp table.
Definition: sql_executor.cc:343
int join_read_const_table(JOIN_TAB *tab, POSITION *pos)
Reads content of constant table.
Definition: sql_executor.cc:3571
bool construct_lookup(THD *thd, TABLE *table, Index_lookup *ref)
Copy the lookup key into the table ref's key buffer.
Definition: sql_executor.cc:4153
int do_sj_dups_weedout(THD *thd, SJ_TMP_TABLE *sjtbl)
SemiJoinDuplicateElimination: Weed out duplicate row combinations.
Definition: sql_executor.cc:3474
int report_handler_error(TABLE *table, int error)
Help function when we get some an error from the table handler.
Definition: sql_executor.cc:3544
void setup_tmptable_write_func(QEP_TAB *tab, Opt_trace_object *trace)
Setup write_func of QEP_tmp_table object.
Definition: sql_executor.cc:554
int update_item_cache_if_changed(List< Cached_item > &list)
Definition: sql_executor.cc:4235
AccessPath * access_path()
Construct an access path for reading from this table in the query, using the access method that has b...
Definition: sql_executor.cc:3788
int read_const(TABLE *table, Index_lookup *ref)
Definition: sql_executor.cc:3702
bool use_order() const
Use ordering provided by chosen index?
Definition: sql_executor.cc:3762
AccessPath * GetAccessPathForDerivedTable(THD *thd, Table_ref *table_ref, TABLE *table, bool rematerialize, Mem_root_array< const AccessPath * > *invalidators, bool need_rowid, AccessPath *table_path)
Definition: sql_executor.cc:1696
bool is_rollup_group_wrapper(const Item *item)
Definition: sql_executor.cc:367
bool change_to_use_tmp_fields_except_sums(mem_root_deque< Item * > *fields, THD *thd, Query_block *select, Ref_item_array ref_item_array, mem_root_deque< Item * > *res_fields, size_t added_non_hidden_fields)
Change all sum_func refs to fields to point at fields in tmp table.
Definition: sql_executor.cc:4509
bool make_group_fields(JOIN *main_join, JOIN *curr_join)
allocate group fields or take prepared (cached).
Definition: sql_executor.cc:4193
bool change_to_use_tmp_fields(mem_root_deque< Item * > *fields, THD *thd, Ref_item_array ref_item_array, mem_root_deque< Item * > *res_fields, size_t added_non_hidden_fields, bool windowing=false)
Change all funcs and sum_funcs to fields in tmp table, and create new list of all items.
Definition: sql_executor.cc:4352
bool check_unique_fields(TABLE *table)
Check whether a row is already present in the tmp table.
Definition: sql_executor.cc:4125
void update_tmptable_sum_func(Item_sum **func_ptr, TABLE *tmp_table)
Update record 0 in tmp_table from record 1.
Definition: sql_executor.cc:441
bool table_rec_cmp(TABLE *table)
Compare GROUP BY in from tmp table's record[0] and record[1].
Definition: sql_executor.cc:4014
std::string RefToString(const Index_lookup &ref, const KEY &key, bool include_nulls)
Definition: sql_executor.cc:166
Item * CreateConjunction(List< Item > *items)
Create an AND conjunction of all given items.
Definition: sql_executor.cc:787
bool set_record_buffer(TABLE *table, double expected_rows_to_fetch)
Allocate a data buffer that the storage engine can use for fetching batches of records.
Definition: sql_executor.cc:690
AccessPath * MoveCompositeIteratorsFromTablePath(THD *thd, AccessPath *path, const Query_block &query_block)
For a MATERIALIZE access path, move any non-basic iterators (e.g.
Definition: sql_executor.cc:1589
bool copy_fields(Temp_table_param *param, const THD *thd, bool reverse_copy=false)
Make a copy of all simple SELECT'ed fields.
Definition: sql_executor.cc:4282
void ConvertItemsToCopy(const mem_root_deque< Item * > &items, Field **fields, Temp_table_param *param)
For historical reasons, derived table materialization and temporary table materialization didn't spec...
Definition: sql_executor.cc:979
bool ExtractConditions(Item *condition, Mem_root_array< Item * > *condition_parts)
Split AND conditions into their constituent parts, recursively.
Definition: sql_executor.cc:759
ulonglong calc_field_hash(const Field *field, ulonglong *hash)
Generate hash for a field.
Definition: sql_executor.cc:4032
bool prepare_sum_aggregators(Item_sum **func_ptr, bool need_distinct)
Definition: sql_executor.cc:398
void init(JOIN_TAB *jt)
Initializes the object from a JOIN_TAB.
Definition: sql_optimizer.cc:1355
void init_join_cache(JOIN_TAB *join_tab)
A helper function that allocates appropriate join cache object and sets next_query_block function of ...
Definition: sql_select.cc:3281
void push_index_cond(const JOIN_TAB *join_tab, uint keyno, Opt_trace_object *trace_obj)
Try to extract and push the index condition down to table handler.
Definition: sql_select.cc:2951
void cleanup()
Definition: sql_select.cc:3552
uint sjm_query_block_id() const
Definition: sql_select.cc:3608
uint effective_index() const
Return the index used for a table in a QEP.
Definition: sql_optimizer.cc:1382
uint get_sj_strategy() const
Definition: sql_optimizer.cc:1362
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
std::unique_ptr< T, Destroy_only< T > > unique_ptr_destroy_only
std::unique_ptr, but only destroying.
Definition: my_alloc.h:477
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:56
unsigned char uchar
Definition: my_inttypes.h:52
uint64_t table_map
Definition: my_table_map.h:30
uint64_t qep_tab_map
Definition: my_table_map.h:32
void error(const char *format,...)
static char * path
Definition: mysqldump.cc:149
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
PT & ref(PT *tp)
Definition: tablespace_impl.cc:359
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2879
required string key
Definition: replication_asynchronous_connection_failover.proto:60
required string type
Definition: replication_group_member_actions.proto:34
AccessPath * ConnectJoins(plan_idx upper_first_idx, plan_idx first_idx, plan_idx last_idx, QEP_TAB *qep_tabs, THD *thd, CallingContext calling_context, std::vector< PendingCondition > *pending_conditions, std::vector< PendingInvalidator > *pending_invalidators, std::vector< PendingCondition > *pending_join_conditions, qep_tab_map *unhandled_duplicates, table_map *conditions_depend_on_outer_tables)
bool MaterializeIsDoingDeduplication(TABLE *table)
(end of group Query_Executor)
Definition: sql_executor.cc:4755
AccessPath * create_table_access_path(THD *thd, TABLE *table, AccessPath *range_scan, Table_ref *table_ref, POSITION *position, bool count_examined_rows)
create_table_access_path is used to scan by using a number of different methods.
Definition: sql_executor.cc:4825
unique_ptr_destroy_only< RowIterator > PossiblyAttachFilterIterator(unique_ptr_destroy_only< RowIterator > iterator, const std::vector< Item * > &conditions, THD *thd)
void SplitConditions(Item *condition, QEP_TAB *current_table, std::vector< Item * > *predicates_below_join, std::vector< PendingCondition > *predicates_above_join, std::vector< PendingCondition > *join_conditions, plan_idx semi_join_table_idx, qep_tab_map left_tables)
CallingContext
Definition: sql_executor.h:503
@ DIRECTLY_UNDER_OUTER_JOIN
Definition: sql_executor.h:506
@ TOP_LEVEL
Definition: sql_executor.h:504
@ DIRECTLY_UNDER_WEEDOUT
Definition: sql_executor.h:507
@ DIRECTLY_UNDER_SEMIJOIN
Definition: sql_executor.h:505
unique_ptr_destroy_only< RowIterator > init_table_iterator(THD *thd, TABLE *table, AccessPath *range_scan, Table_ref *table_ref, POSITION *position, bool ignore_not_found_rows, bool count_examined_rows)
Creates an iterator for the given table, then calls Init() on the resulting iterator.
Definition: sql_executor.cc:4845
Copy_func_type
Definition: sql_executor.h:161
@ CFT_HAS_NO_WF
In first windowing step, copies non-window functions which do not rely on window functions,...
Definition: sql_executor.h:192
@ CFT_WF_NON_FRAMING
In windowing step, copies non framing window function, e.g.
Definition: sql_executor.h:176
@ CFT_WF_NEEDS_PARTITION_CARDINALITY
In windowing step, copies window functions that need frame cardinality, that is we need to read all r...
Definition: sql_executor.h:182
@ CFT_WF_FRAMING
In windowing step, copies framing window function, including all grouping aggregates,...
Definition: sql_executor.h:170
@ CFT_ALL
In non-windowing step, copies functions.
Definition: sql_executor.h:165
@ CFT_FIELDS
Copies Item_field only (typically because other functions might depend on those fields).
Definition: sql_executor.h:207
@ CFT_HAS_WF
In final windowing step, copies all non-wf functions.
Definition: sql_executor.h:198
@ CFT_WF_USES_ONLY_ONE_ROW
In windowing step, copies framing window functions that read only one row per frame.
Definition: sql_executor.h:187
@ CFT_WF
Copies all window functions.
Definition: sql_executor.h:202
Common types of the Optimizer, used by optimization and execution.
@ REF_SLICE_SAVED_BASE
The slice with pointers to columns of table(s), ie., the actual Items.
Definition: sql_opt_exec_shared.h:638
int plan_idx
This represents the index of a JOIN_TAB/QEP_TAB in an array.
Definition: sql_opt_exec_shared.h:54
#define NO_PLAN_IDX
undefined index
Definition: sql_opt_exec_shared.h:55
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:213
Structure used for index-based lookups.
Definition: sql_opt_exec_shared.h:67
Definition: table.h:286
A position of table within a join order.
Definition: sql_select.h:355
Definition: sql_executor.h:483
Item * cond
Definition: sql_executor.h:484
int table_index_to_attach_to
Definition: sql_executor.h:485
Cache invalidator iterators we need to apply, but cannot yet due to outer joins.
Definition: sql_executor.h:494
QEP_TAB * qep_tab
The table whose every (post-join) row invalidates one or more derived lateral tables.
Definition: sql_executor.h:499
plan_idx table_index_to_invalidate
Definition: sql_executor.h:500
Definition: sql_executor.h:71
QEP_TAB * qep_tab
Definition: sql_executor.h:72
ushort null_byte
Definition: sql_executor.h:74
uchar null_bit
Definition: sql_executor.h:75
uint rowid_offset
Definition: sql_executor.h:73
Definition: table.h:1406
class QEP_TAB * qep_tab
Definition: table.h:1888
bool key_read
If set, the optimizer has found that row retrieval should access index tree only.
Definition: table.h:1813
struct TABLE::@187 reginfo