MySQL 8.3.0
Source Code Documentation
item_subselect.h
Go to the documentation of this file.
1#ifndef ITEM_SUBSELECT_INCLUDED
2#define ITEM_SUBSELECT_INCLUDED
3
4/* Copyright (c) 2002, 2023, 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 also distributed 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 included with MySQL.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License, version 2.0, for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
25
26/// Implements classes that represent subqueries and predicates containing
27/// table subqueries.
28
29#include <assert.h>
30#include <sys/types.h>
31
32#include <cstddef>
33#include <memory> // unique_ptr
34#include <vector>
35
36#include "field_types.h" // enum_field_types
37#include "my_alloc.h" // Destroy_only
38
39#include "my_inttypes.h"
40#include "my_table_map.h"
41#include "my_time.h"
43#include "mysql_time.h"
44#include "sql/comp_creator.h"
45#include "sql/enum_query_type.h"
46#include "sql/item.h" // Item_result_field
47#include "sql/iterators/row_iterator.h" // IWYU pragma: keep
48#include "sql/parse_location.h" // POS
50#include "sql/sql_const.h"
52#include "template_utils.h"
53
54class Comp_creator;
55class Field;
58class JOIN;
59class Json_wrapper;
60class PT_subquery;
64class Query_block;
66class String;
67class THD;
69class my_decimal;
71struct AccessPath;
72class Table_ref;
73
74template <class T>
75class List;
76
77/// Base class that is common to all subqueries and subquery predicates
78
81
82 public:
84
85 /**
86 If !=NO_PLAN_IDX: this Item is in the condition attached to the JOIN_TAB
87 having this index in the parent JOIN.
88 */
90
91 // For EXPLAIN.
94
95 // For EXPLAIN. Only valid if engine_type() == HASH_SJ_ENGINE.
96 const TABLE *get_table() const;
97 const Index_lookup &index_lookup() const;
99
100 void create_iterators(THD *thd);
101 virtual AccessPath *root_access_path() const { return nullptr; }
102
104 SCALAR_SUBQUERY, ///< Scalar or row subquery
105 EXISTS_SUBQUERY, ///< [NOT] EXISTS subquery predicate
106 IN_SUBQUERY, ///< [NOT] IN subquery predicate
107 ALL_SUBQUERY, ///< comp-op ALL quantified comparison predicate
108 ANY_SUBQUERY ///< comp-op ANY quantified comparison predicate
109 };
110
111 /// Accumulate used tables
115 }
116
117 virtual Subquery_type subquery_type() const = 0;
118
119 /**
120 @returns whether this subquery is a single column scalar subquery.
121 (Note that scalar and row subqueries are both represented as
122 scalar subqueries, this function can be used to distinguish them)
123 */
124 virtual bool is_single_column_scalar_subquery() const { return false; }
125
126 void cleanup() override;
127 /**
128 Reset state after a single execution of a subquery, useful when a
129 dependent subquery must be evaluated multiple times for varying values
130 of the outer references.
131 This is a lighter cleanup procedure than the one provided by cleanup().
132 */
133 virtual void reset() {
134 m_value_assigned = false;
135 null_value = true;
136 }
137 bool is_value_assigned() const { return m_value_assigned; }
140 enum Type type() const override;
141 bool is_null() override { return update_null_value() || null_value; }
142 bool fix_fields(THD *thd, Item **ref) override;
143 void fix_after_pullout(Query_block *parent_query_block,
144 Query_block *removed_query_block) override;
145 virtual bool exec(THD *thd);
146 table_map used_tables() const override { return m_used_tables_cache; }
147 table_map not_null_tables() const override { return 0; }
148 /// @returns used tables for subquery (excluding any left-hand expression)
150 Item *get_tmp_table_item(THD *thd) override;
151 void update_used_tables() override;
152 void print(const THD *thd, String *str,
153 enum_query_type query_type) const override;
154
157 }
158
159 /*
160 True if this subquery has been already evaluated. Implemented only for
161 single select and union subqueries only.
162 */
163 bool is_evaluated() const;
164 bool is_uncacheable() const;
165
166 /**
167 Used by max/min subquery to initialize value presence registration
168 mechanism. Engine calls this function before re-execution of subquery.
169 */
170 virtual void reset_has_values() {}
171 /**
172 @returns the "place" where this subquery is located in the simply
173 containing query block.
174 */
176
177 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
178 bool explain_subquery_checker(uchar **arg) override;
179 bool inform_item_in_cond_of_tab(uchar *arg) override;
180 bool clean_up_after_removal(uchar *arg) override;
181
182 const char *func_name() const override {
183 assert(0);
184 return "subquery";
185 }
186
189 pointer_cast<Check_function_as_value_generator_parameters *>(args);
190 func_arg->err_code = func_arg->get_unnamed_function_error_code();
191 return true;
192 }
193
194 /// argument used by walk method collect_scalar_subqueries ("css")
196 ///< accumulated all subq (or aggregates) found
197 std::vector<Item_subselect *> list;
200 bool contains(Query_expression *candidate) {
201 for (auto sq : list) {
202 if (sq->m_query_expr == candidate) return true;
203 }
204 return false;
205 }
206 };
207
208 bool collect_subqueries(uchar *) override;
209 Item *replace_item_field(uchar *arg) override;
210 Item *replace_item_view_ref(uchar *arg) override;
211
212 protected:
214 explicit Item_subselect(const POS &pos) : super(pos) { set_subquery(); }
215 /**
216 Bind this subquery object with the supplied query expression.
217 As part of transformations, this function may re-bind the subquery to
218 a different query expression.
219
220 @param qe supplied query expression
221 */
222 void bind(Query_expression *qe);
223
224 /// The query expression of the subquery
225 Query_expression *m_query_expr{nullptr}; // Actual value set in construction
226
227 /// The query result object associated with the query expression
229
230 /// Only relevant for Item_in_subselect; optimized structure used for
231 /// execution in place of running the entire subquery.
233
234 /// cache of used tables
236 /// cache of used tables from subquery only (not including LHS of IN subquery)
238
239 /// allowed number of columns (1 for scalar subqueries)
240 uint m_max_columns{0}; // Irrelevant value, actually set during construction
241 /// where subquery is placed
243
244 private:
245 bool subq_opt_away_processor(uchar *arg) override;
246
247 /// Accumulate properties from underlying query expression
249 /// Accumulate properties from underlying query block
251 /// Accumulate properties from a selected expression within a query block.
252 void accumulate_expression(Item *item);
253 /// Accumulate properties from a condition or GROUP/ORDER within a query
254 /// block.
255 void accumulate_condition(Item *item);
256
257 /// True if value has been assigned to subquery
258 bool m_value_assigned{false};
259 /**
260 Whether or not execution of this subquery has been traced by
261 optimizer tracing already. If optimizer trace option
262 REPEATED_SUBSELECT is disabled, this is used to disable tracing
263 after the first one.
264 */
265 bool m_traced_before{false};
266};
267
268/// Class that represents scalar subquery and row subquery
269
271 public:
274
275 bool fix_fields(THD *thd, Item **ref) override;
276 void cleanup() override;
277 Subquery_type subquery_type() const override { return SCALAR_SUBQUERY; }
278 bool create_row(const mem_root_deque<Item *> &item_list, Item_cache **row,
279 bool possibly_empty);
280
281 bool is_single_column_scalar_subquery() const override;
282
283 void reset() override;
284 void store(uint i, Item *item);
285 double val_real() override;
286 longlong val_int() override;
287 String *val_str(String *) override;
288 my_decimal *val_decimal(my_decimal *) override;
289 bool val_json(Json_wrapper *result) override;
290 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
291 bool get_time(MYSQL_TIME *ltime) override;
292 bool val_bool() override;
293 enum Item_result result_type() const override;
294 bool resolve_type(THD *) override;
295
296 /*
297 Mark the subquery as having no rows.
298 If there are aggregate functions (in the outer query),
299 we need to generate a NULL row. @c return_zero_rows().
300 */
301 void no_rows_in_result() override;
302
303 uint cols() const override;
304
305 /**
306 @note that this returns the i-th element of the SELECT list.
307 To check for nullability, look at this->is_nullable() and not
308 element_index[i]->is_nullable(), since the selected expressions are
309 always NULL if the subquery is empty.
310 */
311 Item *element_index(uint i) override { return m_row[i]; }
312 Item **addr(uint i) override { return pointer_cast<Item **>(m_row) + i; }
313 bool check_cols(uint c) override;
314 bool null_inside() override;
315 void bring_value() override;
316
317 bool collect_scalar_subqueries(uchar *) override;
318 virtual bool is_maxmin() const { return false; }
319
320 /**
321 Argument for walk method replace_scalar_subquery
322 */
324 Item_singlerow_subselect *m_target; ///< subquery to be replaced with field
325 Field *m_field; ///< the replacement field
326 Query_block *m_outer_query_block; ///< The transformed query block.
327 Query_block *m_inner_query_block; ///< The immediately surrounding query
328 ///< block. This will be the transformed
329 ///< block or a subquery of it
330 bool m_add_coalesce{false};
332 Query_block *select, bool add_coalesce)
333 : m_target(target),
334 m_field(field),
335 m_outer_query_block(select),
336 m_inner_query_block(select),
337 m_add_coalesce(add_coalesce) {}
338 };
339
340 Item *replace_scalar_subquery(uchar *arge) override;
341 /**
342 This method is used to implement a special case of semantic tree
343 rewriting, mandated by a SQL:2003 exception in the specification.
344 The only caller of this method is handle_sql2003_note184_exception(),
345 see the code there for more details.
346 Note that this method breaks the object internal integrity, by
347 removing it's association with the corresponding Query_block,
348 making this object orphan from the parse tree.
349 No other method, beside the destructor, should be called on this
350 object, as it is now invalid.
351 @return the Query_block structure that was given in the constructor.
352 */
354 std::optional<ContainedSubquery> get_contained_subquery(
355 const Query_block *outer_query_block) override;
357
358 private:
359 /// Value cache of a scalar subquery
361 /**
362 Value cache for a row or scalar subquery. In case of a scalar subquery,
363 m_row points directly at m_value. In case of a row subquery, m_row
364 is an array of pointers to individual Item_cache objects.
365 */
366 Item_cache **m_row{nullptr};
367 bool m_no_rows{false}; ///< @c no_rows_in_result
368};
369
370/* used in static ALL/ANY optimization */
372 public:
373 /**
374 Create an Item for use in transformation of quantified comparison
375 predicates that can be evaluated using MAX or MIN aggregation.
376
377 @param parent The quantified comparison predicate that is transformed.
378 @param query_block The query block representing the inner part of the subq.
379 @param max_arg Whether the aggregation is for MAX or MIN.
380 */
382 bool max_arg);
383 void print(const THD *thd, String *str,
384 enum_query_type query_type) const override;
385 void cleanup() override;
386 bool has_values() const { return m_has_values; }
387 void register_value() { m_has_values = true; }
388 void reset_has_values() override { m_has_values = false; }
389 bool is_maxmin() const override { return true; }
390
391 private:
392 bool m_max; ///< True if performing MAX, false if MIN
393 bool m_has_values{false}; ///< Set if we have found at least one row
394};
395
396/// Classes that represent predicates over table subqueries:
397/// [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL
398
399/**
400 Strategy which will be used to handle this subquery: flattening to a
401 semi-join, conversion to a derived table, rewrite of IN to EXISTS...
402 Sometimes the strategy is first only a candidate, then the real decision
403 happens in a second phase. Other times the first decision is final.
404 */
405enum class Subquery_strategy : int {
406 /// Nothing decided yet
408 /// Candidate for rewriting IN(subquery) to EXISTS, or subquery
409 /// materialization
411 /// Candidate for semi-join flattening
413 /// Candidate for rewriting to joined derived table
415 /// Semi-join flattening
416 SEMIJOIN,
417 /// Rewrite to joined derived table
419 /// Evaluate as EXISTS subquery (possibly after rewriting from another type)
421 /// Subquery materialization (HASH_SJ_ENGINE)
423 /// Subquery has been deleted, probably because it was always false
424 DELETED,
425};
426
429
430 public:
431 /**
432 Create an Item that represents an EXISTS subquery predicate, or any
433 quantified comparison predicate that uses the same base class.
434
435 @param query_block First query block of query expression representing
436 the contained subquery.
437 */
438 explicit Item_exists_subselect(Query_block *query_block);
439
441
442 explicit Item_exists_subselect(const POS &pos) : super(pos) {}
443
444 // The left-hand expression of the subquery predicate. Unused with EXISTS
445 Item *left_expr{nullptr};
446
447 /// Priority of this predicate in the convert-to-semi-join-nest process.
449 /// Execution strategy chosen for this Item
451 /// Used by the transformation to derived table
453
454 /**
455 Used by subquery optimizations to keep track about where this subquery
456 predicate is located, and whether it is a candidate for transformation.
457 (Table_ref*) 1 - the predicate is an AND-part of the WHERE
458 join nest pointer - the predicate is an AND-part of ON expression
459 of a join nest
460 NULL - for all other locations. It also means that the
461 predicate is not a candidate for transformation.
462 See also THD::emb_on_expr_nest.
463
464 As for the second case above (the join nest pointer), note that this value
465 may change if scalar subqueries are transformed to derived tables,
466 cf. transform_scalar_subqueries_to_join_with_derived, due to the need to
467 build new join nests. The change is performed in Query_block::nest_derived.
468 */
470
472
473 /*
474 Transform subquery predicate to a form that can be executed, e.g.
475 as an EXISTS subquery, or a MAX or MIN aggregation on the subquery.
476
477 This is a virtual function that has implementations for EXISTS, IN
478 and quantified comparison subquery predicates.
479
480 @param thd Thread handle
481 @param[out] transformed Points to transformed representation of the object
482 if unchanged: No transformation was performed
483
484 @returns false if success, true if error
485 */
486 virtual bool transformer(THD *thd, Item **transformed);
487
488 Subquery_type subquery_type() const override { return EXISTS_SUBQUERY; }
489 bool is_bool_func() const override { return true; }
490 void reset() override {
492 m_value = false;
493 }
494
495 enum Item_result result_type() const override { return INT_RESULT; }
496 /*
497 The item is
498 ([NOT] IN/EXISTS) [ IS [NOT] TRUE|FALSE ]
499 */
501 bool with_is_op() const {
502 switch (value_transform) {
503 case BOOL_IS_TRUE:
504 case BOOL_IS_FALSE:
505 case BOOL_NOT_TRUE:
506 case BOOL_NOT_FALSE:
507 return true;
508 default:
509 return false;
510 }
511 }
512 /// True if the IS TRUE/FALSE wasn't explicit in the query
513 bool implicit_is_op = false;
514 Item *truth_transformer(THD *, enum Bool_test test) override;
515 bool translate(bool &null_v, bool v);
516 void apply_is_true() override {
517 const bool had_is = with_is_op();
519 if (!had_is && value_transform == BOOL_IS_TRUE)
520 implicit_is_op = true; // needn't be written by EXPLAIN
521 }
522 /// True if the Item has decided that it can do antijoin
523 bool can_do_aj = false;
525 bool fix_fields(THD *thd, Item **ref) override;
526 longlong val_int() override;
527 double val_real() override;
528 String *val_str(String *) override;
529 my_decimal *val_decimal(my_decimal *) override;
530 bool val_bool() override;
531 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override {
532 return get_date_from_int(ltime, fuzzydate);
533 }
534 bool get_time(MYSQL_TIME *ltime) override { return get_time_from_int(ltime); }
535 bool resolve_type(THD *thd) override;
536 void print(const THD *thd, String *str,
537 enum_query_type query_type) const override;
538
540
541 protected:
542 bool is_semijoin_candidate(THD *thd);
543 bool is_derived_candidate(THD *thd);
544
545 /// value of this item (boolean: exists/not-exists)
546 bool m_value{false};
547
548 /**
549 True if naked IN is allowed to exchange FALSE for UNKNOWN.
550 Because this is about the naked IN, there is no public ignore_unknown(),
551 intentionally, so that callers don't get it wrong.
552 */
553 bool abort_on_null{false};
554};
555
556/**
557 Representation of IN subquery predicates of the form
558 "left_expr IN (SELECT ...)".
559
560 @details
561 This class has:
562 - A "subquery execution engine" (as a subclass of Item_subselect) that allows
563 it to evaluate subqueries. (and this class participates in execution by
564 having m_was_null variable where part of execution result is stored.
565 - Transformation methods (todo: more on this).
566
567 This class is not used directly, it is "wrapped" into Item_in_optimizer
568 which provides some small bits of subquery evaluation.
569*/
570
573
574 public:
576 Item_in_subselect(const POS &pos, Item *left_expr,
577 PT_subquery *pt_subquery_arg);
578
580
581 bool do_itemize(Parse_context *pc, Item **res) override;
582
583 void cleanup() override;
584 Subquery_type subquery_type() const override { return IN_SUBQUERY; }
585
586 void reset() override {
587 m_value = false;
588 null_value = false;
589 m_was_null = false;
590 }
591 bool transformer(THD *thd, Item **transformed) override;
593 Item **transformed);
595 Item **transformed);
596 bool row_value_transformer(THD *thd, Item **transformed);
598 Comp_creator *func);
600 Item_in_optimizer *optimizer);
601 bool subquery_allows_materialization(THD *thd, Query_block *query_block,
602 const Query_block *outer);
603 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
605 Item *compile(Item_analyzer analyzer, uchar **arg_p,
606 Item_transformer transformer, uchar *arg_t) override;
607
608 bool exec(THD *thd) override;
609 longlong val_int() override;
610 double val_real() override;
611 String *val_str(String *) override;
612 my_decimal *val_decimal(my_decimal *) override;
613 bool val_bool() override;
614 bool test_limit();
615 void print(const THD *thd, String *str,
616 enum_query_type query_type) const override;
617 void fix_after_pullout(Query_block *parent_query_block,
618 Query_block *removed_query_block) override;
619 void update_used_tables() override;
620 bool init_left_expr_cache(THD *thd);
621
622 /**
623 Once the decision to use IN->EXISTS has been taken, performs some last
624 steps of this transformation.
625 */
626 bool finalize_exists_transform(THD *thd, Query_block *select);
627 /**
628 Once the decision to use materialization has been taken, performs some
629 last steps of this transformation.
630 */
632 AccessPath *root_access_path() const override;
633 std::optional<ContainedSubquery> get_contained_subquery(
634 const Query_block *outer_query_block) override;
635
637 return m_in2exists_info != nullptr && m_in2exists_info->added_to_where;
638 }
639
640 /// Is reliable only if IN->EXISTS has been done.
642 return m_in2exists_info->dependent_before;
643 }
644
645 bool *get_cond_guard(int i) const {
646 return m_pushed_cond_guards != nullptr ? m_pushed_cond_guards + i : nullptr;
647 }
648 void set_cond_guard_var(int i, bool v) const {
649 if (m_pushed_cond_guards != nullptr) m_pushed_cond_guards[i] = v;
650 }
651
654 friend class Item_in_optimizer;
657
658 /// Used to trigger on/off conditions that were pushed down to subquery
659 bool *m_pushed_cond_guards{nullptr};
660
661 /// Point on NOT/NOP before ALL/SOME subquery
663
664 protected:
665 /**
666 Cache of the left operand of the subquery predicate. Allocated in the
667 runtime memory root, for each execution, thus need not be freed.
668 */
670
671 /// Whether m_left_expr_cache holds a value
673
674 /// The need for expr cache may be optimized away, @sa init_left_expr_cache.
675 bool need_expr_cache{true};
676
677 private:
678 bool mark_as_outer(Item *left_row, size_t col);
679
680 /**
681 In the case of
682
683 x COMP_OP (SELECT1 UNION SELECT2 ...)
684
685 - the subquery transformation is done on SELECT1; this requires wrapping
686 'x' with more Item layers, and injecting that in a condition in SELECT1.
687
688 - the same transformation is done on SELECT2; but the wrapped 'x' doesn't
689 need to be created again, the one created for SELECT1 could be reused
690
691 - to achieve this, the wrapped 'x' is stored in member
692 'm_injected_left_expr' when it is created for SELECT1, and is later
693 reused for SELECT2.
694
695 This will refer to a cached value which is reevaluated once for each
696 candidate row, cf. setup in #single_value_transformer.
697 */
699
700 bool m_was_null{false};
701
702 /**
703 This bundles several pieces of information useful when doing the
704 IN->EXISTS transform. If this transform has not been done, pointer is
705 NULL.
706 */
708 /**
709 True: if IN->EXISTS has been done and has added a condition to the
710 subquery's WHERE clause.
711 */
713 /**
714 True: if subquery was dependent (correlated) before IN->EXISTS
715 was done.
716 */
718 /**
719 True: if subquery was dependent (correlated) after IN->EXISTS
720 was done.
721 */
723 } * m_in2exists_info{nullptr};
724
726
727 bool val_bool_naked();
728};
729
730/**
731 Class that represents a quantified comparison predicate.
732
733 expression comp-op ANY ( subquery )
734 expression comp-op ALL ( subquery )
735
736 Note that the special cases = ANY (aka IN) and <> ALL (aka NOT IN)
737 are handled by the base class Item_in_subselect.
738*/
740 public:
742 Query_block *select, bool all);
743
744 Subquery_type subquery_type() const override {
746 }
747 bool transformer(THD *thd, Item **transformed) override;
748 void print(const THD *thd, String *str,
749 enum_query_type query_type) const override;
750
753 bool m_all;
754};
755
756/**
757 A subquery execution engine that evaluates the subquery by doing index
758 lookups in a single table's index.
759
760 This engine is used to resolve subqueries in forms
761
762 outer_expr IN (SELECT tbl.key FROM tbl WHERE subq_where)
763
764 or, row-based:
765
766 (oe1, .. oeN) IN (SELECT key_part1, ... key_partK
767 FROM tbl WHERE subqwhere)
768
769 i.e. the subquery is a single table SELECT without GROUP BY, aggregate
770 functions, etc.
771*/
773 protected:
774 Query_result_union *result = nullptr; /* results storage class */
775 /// Table which is read, using one of eq_ref, ref, ref_or_null.
776 TABLE *table{nullptr};
780 Item *m_cond; ///< The WHERE condition of the subquery
781 ulonglong m_hash; ///< Hash value calculated by RefIterator, when needed.
782 /*
783 The "having" clause. This clause (further referred to as "artificial
784 having") was inserted by subquery transformation code. It contains
785 Item(s) that have a side-effect: they record whether the subquery has
786 produced a row with NULL certain components. We need to use it for cases
787 like
788 (oe1, oe2) IN (SELECT t.key, t.no_key FROM t1)
789 where we do index lookup on t.key=oe1 but need also to check if there
790 was a row such that t.no_key IS NULL.
791 */
793
794 Item_in_subselect *item; /* item that uses this engine */
795
796 public:
798
800 const Index_lookup &ref,
801 enum join_type join_type,
803 Item *having)
804 : table(table),
806 ref(ref),
808 m_cond(where),
809 m_having(having),
810 item(subs) {}
812 virtual bool exec(THD *thd);
813 virtual void print(const THD *thd, String *str, enum_query_type query_type);
815 virtual void cleanup() {}
816 virtual void create_iterators(THD *) {}
817};
818
819/*
820 This function is actually defined in sql_parse.cc, but it depends on
821 chooser_compare_func_creator defined in this file.
822 */
825 Query_block *select);
826
827/**
828 Compute an IN predicate via a hash semi-join. The subquery is materialized
829 during the first evaluation of the IN predicate. The IN predicate is executed
830 via the functionality inherited from subselect_indexsubquery_engine.
831*/
832
834 private:
835 /* true if the subquery was materialized into a temp table. */
837 // true if we know for sure that there are zero rows in the table.
838 // Set only after is_materialized is true.
839 bool has_zero_rows = false;
840 /**
841 Existence of inner NULLs in materialized table:
842 By design, other values than IRRELEVANT_OR_FALSE are possible only if the
843 subquery has only one inner expression.
844 */
846 /// none, or they don't matter
848 /// they matter, and we don't know yet if they exists
850 /// they matter, and we know there exists at least one.
851 NEX_TRUE = 2
852 };
857
858 /// Saved result object, must be restored after use
860
861 public:
863 Query_expression *query_expr)
865 in_predicate, nullptr, nullptr),
866 is_materialized(false),
867 m_query_expr(query_expr) {}
868 ~subselect_hash_sj_engine() override;
869
870 bool setup(THD *thd, const mem_root_deque<Item *> &tmp_columns);
871 void cleanup() override;
872 bool exec(THD *thd) override;
873 void print(const THD *thd, String *str, enum_query_type query_type) override;
874 enum_engine_type engine_type() const override { return HASH_SJ_ENGINE; }
875
876 TABLE *get_table() const { return table; }
877 const Index_lookup &index_lookup() const { return ref; }
878 enum join_type get_join_type() const { return type; }
880 void create_iterators(THD *thd) override;
881};
882
883/**
884 Removes every predicate injected by IN->EXISTS.
885
886 This function is different from others:
887 - it wants to remove all traces of IN->EXISTS (for
888 materialization)
889 - remove_subq_pushed_predicates() and remove_additional_cond() want to
890 remove only the conditions of IN->EXISTS which index lookup already
891 satisfies (they are just an optimization).
892
893 If there are no in2exists conditions, it will return the exact same
894 pointer. If it returns a new Item, the old Item is left alone, so it
895 can be reused in other settings.
896
897 @param conds Condition; may be nullptr.
898 @returns new condition
899 */
901
902/// @returns whether the item is a quantified comparison predicate
904
905#endif /* ITEM_SUBSELECT_INCLUDED */
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:250
Abstract factory interface for creating comparison predicates.
Definition: item_cmpfunc.h:524
Definition: field.h:574
Class that represents a quantified comparison predicate.
Definition: item_subselect.h:739
Item_allany_subselect(Item *left_expr, chooser_compare_func_creator fc, Query_block *select, bool all)
Definition: item_subselect.cc:1450
bool transformer(THD *thd, Item **transformed) override
Definition: item_subselect.cc:2916
bool m_all
Definition: item_subselect.h:753
Subquery_type subquery_type() const override
Definition: item_subselect.h:744
Comp_creator * m_func
Definition: item_subselect.h:752
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:2926
chooser_compare_func_creator m_func_creator
Definition: item_subselect.h:751
Definition: item.h:6830
Definition: item_subselect.h:427
enum_condition_context outer_condition_context
Used by the transformation to derived table.
Definition: item_subselect.h:452
bool is_semijoin_candidate(THD *thd)
Definition: item_subselect.cc:1506
void apply_is_true() override
Apply the IS TRUE truth property, meaning that an UNKNOWN result and a FALSE result are treated the s...
Definition: item_subselect.h:516
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1467
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.h:531
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1715
bool m_value
value of this item (boolean: exists/not-exists)
Definition: item_subselect.h:546
Item_exists_subselect()
Definition: item_subselect.h:440
double val_real() override
Definition: item_subselect.cc:1701
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.h:534
bool implicit_is_op
True if the IS TRUE/FALSE wasn't explicit in the query.
Definition: item_subselect.h:513
Item * truth_transformer(THD *, enum Bool_test test) override
Informs an item that it is wrapped in a truth test, in case it wants to transforms itself to implemen...
Definition: item_subselect.cc:1378
longlong val_int() override
Definition: item_subselect.cc:1703
Subquery_strategy strategy
Execution strategy chosen for this Item.
Definition: item_subselect.h:450
Item * left_expr
Definition: item_subselect.h:445
bool val_bool() override
Definition: item_subselect.cc:1739
int sj_convert_priority
Priority of this predicate in the convert-to-semi-join-nest process.
Definition: item_subselect.h:448
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:490
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1320
bool abort_on_null
True if naked IN is allowed to exchange FALSE for UNKNOWN.
Definition: item_subselect.h:553
virtual bool transformer(THD *thd, Item **transformed)
Definition: item_subselect.cc:1489
bool is_derived_candidate(THD *thd)
Definition: item_subselect.cc:1597
bool can_do_aj
True if the Item has decided that it can do antijoin.
Definition: item_subselect.h:523
bool with_is_op() const
Definition: item_subselect.h:501
bool fix_fields(THD *thd, Item **ref) override
An object of class Item_in_subselect is always substituted with another object of class Item_in_optim...
Definition: item_subselect.cc:2655
enum Bool_test value_transform
Definition: item_subselect.h:500
void notify_removal() override
Called when an item has been removed, can be used to notify external objects about the removal,...
Definition: item_subselect.h:471
Subquery_type subquery_type() const override
Definition: item_subselect.h:488
Item_subselect super
Definition: item_subselect.h:428
bool translate(bool &null_v, bool v)
Translates the value of the naked EXISTS to a value taking into account the optional NULL and IS [NOT...
Definition: item_subselect.cc:1341
bool is_bool_func() const override
Definition: item_subselect.h:489
Table_ref * embedding_join_nest
Used by subquery optimizations to keep track about where this subquery predicate is located,...
Definition: item_subselect.h:469
bool choose_semijoin_or_antijoin()
Helper for is_semijoin_candidate() and is_derived_candidate().
Definition: item_subselect.cc:1664
Item_exists_subselect(const POS &pos)
Definition: item_subselect.h:442
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1732
enum Item_result result_type() const override
Definition: item_subselect.h:495
Definition: item_cmpfunc.h:919
Definition: item_cmpfunc.h:491
Representation of IN subquery predicates of the form "left_expr IN (SELECT ...)".
Definition: item_subselect.h:571
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:2725
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1792
Item * compile(Item_analyzer analyzer, uchar **arg_p, Item_transformer transformer, uchar *arg_t) override
Perform a generic "compilation" of the Item tree, ie transform the Item tree by adding zero or more I...
Definition: item_subselect.cc:768
double val_real() override
Definition: item_subselect.cc:1750
struct Item_in_subselect::In2exists_info nullptr
bool m_left_expr_cache_filled
Whether m_left_expr_cache holds a value.
Definition: item_subselect.h:672
bool single_value_transformer(THD *thd, Comp_creator *func, Item **transformed)
Transform a single-column IN/ALL/ANY subquery predicate.
Definition: item_subselect.cc:1828
void set_cond_guard_var(int i, bool v) const
Definition: item_subselect.h:648
bool row_value_transformer(THD *thd, Item **transformed)
Transform a multi-column IN/ALL/ANY subquery predicate.
Definition: item_subselect.cc:2257
std::optional< ContainedSubquery > get_contained_subquery(const Query_block *outer_query_block) override
If this item represents a IN/ALL/ANY/comparison_operator subquery, return that (along with data on ho...
Definition: item_subselect.cc:2783
Item_func_not_all * m_upper_item
Point on NOT/NOP before ALL/SOME subquery.
Definition: item_subselect.h:662
bool need_expr_cache
The need for expr cache may be optimized away,.
Definition: item_subselect.h:675
bool finalize_materialization_transform(THD *thd, JOIN *join)
Once the decision to use materialization has been taken, performs some last steps of this transformat...
Definition: item_subselect.cc:479
bool do_itemize(Parse_context *pc, Item **res) override
The core function that does the actual itemization.
Definition: item_subselect.cc:1437
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:2613
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:586
List< Cached_item > * m_left_expr_cache
Cache of the left operand of the subquery predicate.
Definition: item_subselect.h:669
bool mark_as_outer(Item *left_row, size_t col)
Decide whether to mark the injected left expression "outer" relative to the subquery.
Definition: item_subselect.cc:431
Item * transform(Item_transformer transformer, uchar *arg) override
Perform a generic transformation of the Item tree, by adding zero or more additional Item objects to ...
Definition: item_subselect.cc:761
bool * m_pushed_cond_guards
Used to trigger on/off conditions that were pushed down to subquery.
Definition: item_subselect.h:659
bool dependent_before_in2exists() const
Is reliable only if IN->EXISTS has been done.
Definition: item_subselect.h:641
AccessPath * root_access_path() const override
Definition: item_subselect.cc:570
PT_subquery * pt_subselect
Definition: item_subselect.h:725
longlong val_int() override
Definition: item_subselect.cc:1757
bool * get_cond_guard(int i) const
Definition: item_subselect.h:645
bool row_value_in_to_exists_transformer(THD *thd, Query_block *select, Item_in_optimizer *optimizer)
Transform a (possibly non-correlated) IN subquery into a correlated EXISTS.
Definition: item_subselect.cc:2322
bool finalize_exists_transform(THD *thd, Query_block *select)
Once the decision to use IN->EXISTS has been taken, performs some last steps of this transformation.
Definition: item_subselect.cc:438
bool val_bool() override
Definition: item_subselect.cc:1771
bool m_was_null
Definition: item_subselect.h:700
bool init_left_expr_cache(THD *thd)
Initialize the cache of the left operand of the IN predicate.
Definition: item_subselect.cc:2750
bool quantified_comp_transformer(THD *thd, Comp_creator *func, Item **transformed)
Perform transformation of quantified comparison predicates (ie.
Definition: item_subselect.cc:2532
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:538
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1764
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_subselect.cc:2732
bool in2exists_added_to_where() const
Definition: item_subselect.h:636
bool walk(Item_processor processor, enum_walk walk, uchar *arg) override
Traverses a tree of Items in prefix and/or postfix order.
Definition: item_subselect.cc:755
Item_exists_subselect super
Definition: item_subselect.h:572
Subquery_type subquery_type() const override
Definition: item_subselect.h:584
bool single_value_in_to_exists_transformer(THD *thd, Query_block *select, Comp_creator *func)
Transform an IN predicate into EXISTS via predicate injection.
Definition: item_subselect.cc:2049
bool test_limit()
Definition: item_subselect.cc:1409
Item_in_subselect()
Definition: item_subselect.h:579
bool val_bool_naked()
Definition: item_subselect.cc:1778
Item_ref * m_injected_left_expr
In the case of.
Definition: item_subselect.h:698
bool exec(THD *thd) override
Definition: item_subselect.cc:784
bool transformer(THD *thd, Item **transformed) override
Definition: item_subselect.cc:2516
Definition: item_cmpfunc.h:2316
Definition: item_subselect.h:371
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1108
bool m_has_values
Set if we have found at least one row.
Definition: item_subselect.h:393
bool is_maxmin() const override
Definition: item_subselect.h:389
bool m_max
True if performing MAX, false if MIN.
Definition: item_subselect.h:392
void reset_has_values() override
Used by max/min subquery to initialize value presence registration mechanism.
Definition: item_subselect.h:388
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:1101
bool has_values() const
Definition: item_subselect.h:386
void register_value()
Definition: item_subselect.h:387
Item_maxmin_subselect(Item_subselect *parent, Query_block *query_block, bool max_arg)
Create an Item for use in transformation of quantified comparison predicates that can be evaluated us...
Definition: item_subselect.cc:1085
Definition: item.h:6315
Definition: item.h:5886
Item with result field.
Definition: item.h:5809
Class that represents scalar subquery and row subquery.
Definition: item_subselect.h:270
Item * replace_scalar_subquery(uchar *arge) override
When walking the item tree seeing an Item_singlerow_subselect matching a target, replace it with a su...
Definition: item_subselect.cc:3015
enum Item_result result_type() const override
Definition: item_subselect.cc:1128
void store(uint i, Item *item)
Definition: item_subselect.cc:1119
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:397
bool null_inside() override
Definition: item_subselect.cc:1182
Item ** addr(uint i) override
Definition: item_subselect.h:312
double val_real() override
Definition: item_subselect.cc:1196
bool resolve_type(THD *) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1133
void no_rows_in_result() override
Definition: item_subselect.cc:1165
bool val_json(Json_wrapper *result) override
Get a JSON value from an Item.
Definition: item_subselect.cc:1241
Item_cache ** m_row
Value cache for a row or scalar subquery.
Definition: item_subselect.h:366
bool m_no_rows
no_rows_in_result
Definition: item_subselect.h:367
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.cc:1114
Subquery_type subquery_type() const override
Definition: item_subselect.h:277
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.cc:1252
std::optional< ContainedSubquery > get_contained_subquery(const Query_block *outer_query_block) override
If this item represents a IN/ALL/ANY/comparison_operator subquery, return that (along with data on ho...
Definition: item_subselect.cc:3054
longlong val_int() override
Definition: item_subselect.cc:1207
uint cols() const override
Definition: item_subselect.cc:3265
virtual bool is_maxmin() const
Definition: item_subselect.h:318
bool is_single_column_scalar_subquery() const override
Definition: item_subselect.cc:1124
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:329
Item * element_index(uint i) override
Definition: item_subselect.h:311
Item_singlerow_subselect()
Definition: item_subselect.h:273
Query_block * invalidate_and_restore_query_block()
This method is used to implement a special case of semantic tree rewriting, mandated by a SQL:2003 ex...
Definition: item_subselect.cc:900
bool collect_scalar_subqueries(uchar *) override
Definition: item_subselect.cc:2940
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.cc:1264
String * val_str(String *) override
Definition: item_subselect.cc:1218
bool val_bool() override
Definition: item_subselect.cc:1275
void bring_value() override
Definition: item_subselect.cc:1189
bool create_row(const mem_root_deque< Item * > &item_list, Item_cache **row, bool possibly_empty)
Makes storage for the output values for a scalar or row subquery and calculates their data and column...
Definition: item_subselect.cc:3171
bool check_cols(uint c) override
Definition: item_subselect.cc:1174
my_decimal * val_decimal(my_decimal *) override
Definition: item_subselect.cc:1229
Item_cache * m_value
Value cache of a scalar subquery.
Definition: item_subselect.h:360
Base class that is common to all subqueries and subquery predicates.
Definition: item_subselect.h:79
subselect_indexsubquery_engine * indexsubquery_engine
Only relevant for Item_in_subselect; optimized structure used for execution in place of running the e...
Definition: item_subselect.h:232
Item * replace_item_view_ref(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:3155
void set_value_assigned()
Definition: item_subselect.h:138
bool clean_up_after_removal(uchar *arg) override
Clean up after removing the subquery from the item tree.
Definition: item_subselect.cc:2876
bool is_evaluated() const
Definition: item_subselect.cc:2922
enum_parsing_context m_parsing_place
where subquery is placed
Definition: item_subselect.h:242
bool collect_subqueries(uchar *) override
Definition: item_subselect.cc:2909
table_map used_tables() const override
Definition: item_subselect.h:146
void accumulate_expression(Item *item)
Accumulate properties from a selected expression within a query block.
Definition: item_subselect.cc:263
void accumulate_used_tables(table_map add_tables)
Accumulate used tables.
Definition: item_subselect.h:112
Query_expression * m_query_expr
The query expression of the subquery.
Definition: item_subselect.h:225
virtual Subquery_type subquery_type() const =0
bool check_function_as_value_generator(uchar *args) override
Check if this item is allowed for a virtual column or inside a default expression.
Definition: item_subselect.h:187
table_map subquery_used_tables() const
Definition: item_subselect.h:149
bool is_uncacheable() const
Definition: item_subselect.cc:3270
void accumulate_properties()
Accumulate properties from underlying query expression.
Definition: item_subselect.cc:199
virtual bool exec(THD *thd)
Definition: item_subselect.cc:661
Query_expression * query_expr() const
Definition: item_subselect.h:83
enum_engine_type
Definition: item_subselect.h:92
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:92
@ HASH_SJ_ENGINE
Definition: item_subselect.h:92
@ OTHER_ENGINE
Definition: item_subselect.h:92
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:860
Subquery_type
Definition: item_subselect.h:103
@ ALL_SUBQUERY
comp-op ALL quantified comparison predicate
Definition: item_subselect.h:107
@ IN_SUBQUERY
[NOT] IN subquery predicate
Definition: item_subselect.h:106
@ SCALAR_SUBQUERY
Scalar or row subquery.
Definition: item_subselect.h:104
@ ANY_SUBQUERY
comp-op ANY quantified comparison predicate
Definition: item_subselect.h:108
@ EXISTS_SUBQUERY
[NOT] EXISTS subquery predicate
Definition: item_subselect.h:105
bool explain_subquery_checker(uchar **arg) override
Register subquery to the table where it is used within a condition.
Definition: item_subselect.cc:654
bool m_value_assigned
True if value has been assigned to subquery.
Definition: item_subselect.h:258
Item * get_tmp_table_item(THD *thd) override
If an Item is materialized in a temporary table, a different Item may have to be used in the part of ...
Definition: item_subselect.cc:839
enum_parsing_context place()
Definition: item_subselect.h:175
virtual void reset()
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:133
Item * replace_item_field(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:3145
join_type get_join_type() const
Definition: item_subselect.cc:309
int in_cond_of_tab
If !=NO_PLAN_IDX: this Item is in the condition attached to the JOIN_TAB having this index in the par...
Definition: item_subselect.h:89
void accumulate_condition(Item *item)
Accumulate properties from a condition or GROUP/ORDER within a query block.
Definition: item_subselect.cc:274
virtual AccessPath * root_access_path() const
Definition: item_subselect.h:101
void create_iterators(THD *thd)
Definition: item_subselect.cc:279
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:314
Query_result_interceptor * m_query_result
The query result object associated with the query expression.
Definition: item_subselect.h:228
table_map m_subquery_used_tables
cache of used tables from subquery only (not including LHS of IN subquery)
Definition: item_subselect.h:237
const TABLE * get_table() const
Definition: item_subselect.cc:299
enum Type type() const override
Definition: item_subselect.cc:837
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:591
void set_indexsubquery_engine(subselect_indexsubquery_engine *eng)
Definition: item_subselect.h:155
const char * func_name() const override
Definition: item_subselect.h:182
void bind(Query_expression *qe)
Bind this subquery object with the supplied query expression.
Definition: item_subselect.cc:143
void reset_value_assigned()
Definition: item_subselect.h:139
table_map not_null_tables() const override
Return table map of tables that can't be NULL tables (tables that are used in a context where if they...
Definition: item_subselect.h:147
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_subselect.cc:851
bool walk(Item_processor processor, enum_walk walk, uchar *arg) override
Traverses a tree of Items in prefix and/or postfix order.
Definition: item_subselect.cc:633
Item_subselect()
Definition: item_subselect.h:213
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_subselect.h:141
const Index_lookup & index_lookup() const
Definition: item_subselect.cc:304
enum_engine_type engine_type() const
Definition: item_subselect.cc:285
bool is_value_assigned() const
Definition: item_subselect.h:137
Item_result_field super
Definition: item_subselect.h:80
bool m_traced_before
Whether or not execution of this subquery has been traced by optimizer tracing already.
Definition: item_subselect.h:265
bool inform_item_in_cond_of_tab(uchar *arg) override
Tells an Item that it is in the condition of a JOIN_TAB of a query block.
Definition: item_subselect.cc:2848
virtual void reset_has_values()
Used by max/min subquery to initialize value presence registration mechanism.
Definition: item_subselect.h:170
bool subq_opt_away_processor(uchar *arg) override
Mark the subquery as optimized away, for EXPLAIN.
Definition: item_subselect.cc:2860
uint m_max_columns
allowed number of columns (1 for scalar subqueries)
Definition: item_subselect.h:240
virtual bool is_single_column_scalar_subquery() const
Definition: item_subselect.h:124
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:735
Item_subselect(const POS &pos)
Definition: item_subselect.h:214
table_map m_used_tables_cache
cache of used tables
Definition: item_subselect.h:235
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:933
void set_subquery()
Set the "has subquery" property.
Definition: item.h:3381
bool null_value
True if item is null.
Definition: item.h:3652
Type
Definition: item.h:968
Bool_test
< Modifier for result transformation
Definition: item.h:1016
@ BOOL_NOT_FALSE
Definition: item.h:1020
@ BOOL_NOT_TRUE
Definition: item.h:1019
@ BOOL_IS_TRUE
Definition: item.h:1016
@ BOOL_IS_FALSE
Definition: item.h:1017
@ BOOL_IDENTITY
Definition: item.h:1022
bool get_date_from_int(MYSQL_TIME *ltime, my_time_flags_t flags)
Convert val_int() to date in MYSQL_TIME.
Definition: item.cc:1631
bool update_null_value()
Make sure the null_value member has a correct value.
Definition: item.cc:7605
bool get_time_from_int(MYSQL_TIME *ltime)
Convert val_int() to time in MYSQL_TIME.
Definition: item.cc:1718
Definition: sql_optimizer.h:132
Abstraction for accessing JSON values irrespective of whether they are (started out as) binary JSON v...
Definition: json_dom.h:1161
Definition: sql_list.h:434
Definition: parse_tree_nodes.h:1749
Base class for parse tree nodes (excluding the Parse_tree_root hierarchy)
Definition: parse_tree_node_base.h:230
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1161
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:624
Definition: item_subselect.cc:1286
Definition: query_result.h:180
Query result class for scalar and row subqueries.
Definition: item_subselect.cc:106
Base class for result from a subquery.
Definition: query_result.h:311
Definition: sql_union.h:39
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:166
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:35
Definition: table.h:2853
Object containing parameters used when creating and using temporary tables.
Definition: temp_table_param.h:94
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:110
my_decimal class limits 'decimal_t' type to what we need in MySQL.
Definition: my_decimal.h:94
Compute an IN predicate via a hash semi-join.
Definition: item_subselect.h:833
void create_iterators(THD *thd) override
Definition: item_subselect.cc:3509
void print(const THD *thd, String *str, enum_query_type query_type) override
Print the state of this engine into a string for debugging and views.
Definition: item_subselect.cc:3742
nulls_exist
Existence of inner NULLs in materialized table: By design, other values than IRRELEVANT_OR_FALSE are ...
Definition: item_subselect.h:845
@ NEX_TRUE
they matter, and we know there exists at least one.
Definition: item_subselect.h:851
@ NEX_UNKNOWN
they matter, and we don't know yet if they exists
Definition: item_subselect.h:849
@ NEX_IRRELEVANT_OR_FALSE
none, or they don't matter
Definition: item_subselect.h:847
void cleanup() override
Cleanup performed after each execution.
Definition: item_subselect.cc:3587
unique_ptr_destroy_only< RowIterator > m_iterator
Definition: item_subselect.h:855
subselect_hash_sj_engine(Item_in_subselect *in_predicate, Query_expression *query_expr)
Definition: item_subselect.h:862
TABLE * get_table() const
Definition: item_subselect.h:876
~subselect_hash_sj_engine() override
Definition: item_subselect.cc:3576
Query_result_interceptor * saved_result
Saved result object, must be restored after use.
Definition: item_subselect.h:859
enum nulls_exist mat_table_has_nulls
Definition: item_subselect.h:853
bool is_materialized
Definition: item_subselect.h:836
Query_expression *const m_query_expr
Definition: item_subselect.h:854
bool has_zero_rows
Definition: item_subselect.h:839
const Index_lookup & index_lookup() const
Definition: item_subselect.h:877
bool exec(THD *thd) override
Execute a subquery IN predicate via materialization.
Definition: item_subselect.cc:3622
enum_engine_type engine_type() const override
Definition: item_subselect.h:874
AccessPath * root_access_path() const
Definition: item_subselect.h:879
bool setup(THD *thd, const mem_root_deque< Item * > &tmp_columns)
Create all structures needed for subquery execution using hash semijoin.
Definition: item_subselect.cc:3338
enum join_type get_join_type() const
Definition: item_subselect.h:878
AccessPath * m_root_access_path
Definition: item_subselect.h:856
A subquery execution engine that evaluates the subquery by doing index lookups in a single table's in...
Definition: item_subselect.h:772
Item * m_cond
The WHERE condition of the subquery.
Definition: item_subselect.h:780
TABLE * table
Table which is read, using one of eq_ref, ref, ref_or_null.
Definition: item_subselect.h:776
virtual ~subselect_indexsubquery_engine()=default
virtual void cleanup()
Definition: item_subselect.h:815
virtual bool exec(THD *thd)
Definition: item_subselect.cc:3254
virtual void print(const THD *thd, String *str, enum_query_type query_type)
Definition: item_subselect.cc:3274
virtual void create_iterators(THD *)
Definition: item_subselect.h:816
Item * m_having
Definition: item_subselect.h:792
join_type type
Definition: item_subselect.h:779
enum_engine_type
Definition: item_subselect.h:797
@ HASH_SJ_ENGINE
Definition: item_subselect.h:797
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:797
Index_lookup ref
Definition: item_subselect.h:778
subselect_indexsubquery_engine(TABLE *table, Table_ref *table_ref, const Index_lookup &ref, enum join_type join_type, Item_in_subselect *subs, Item *where, Item *having)
Definition: item_subselect.h:799
ulonglong m_hash
Hash value calculated by RefIterator, when needed.
Definition: item_subselect.h:781
virtual enum_engine_type engine_type() const
Definition: item_subselect.h:814
Item_in_subselect * item
Definition: item_subselect.h:794
Table_ref * table_ref
Definition: item_subselect.h:777
Comp_creator *(*)(bool invert) chooser_compare_func_creator
Convenience typedef for a function that returns factories for Item comparators (ie....
Definition: comp_creator.h:38
static int cmp(Bigint *a, Bigint *b)
Definition: dtoa.cc:1059
enum_query_type
Query type constants (usable as bitmap flags).
Definition: enum_query_type.h:30
This file contains the field type.
bool subquery_allows_materialization(THD *thd, Query_block *query_block, const Query_block *outer)
Check if the subquery predicate can be executed via materialization.
Definition: sql_resolver.cc:1038
Item * all_any_subquery_creator(Item *left_expr, chooser_compare_func_creator cmp, bool all, Query_block *select)
Construct ALL/ANY/SOME subquery Item.
Definition: sql_parse.cc:6627
bool(Item::* Item_analyzer)(uchar **argp)
Definition: item.h:715
Item *(Item::* Item_transformer)(uchar *arg)
Type for transformers used by Item::transform and Item::compile.
Definition: item.h:724
Item * remove_in2exists_conds(Item *conds)
Removes every predicate injected by IN->EXISTS.
Definition: item_subselect.cc:463
Subquery_strategy
Classes that represent predicates over table subqueries: [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL.
Definition: item_subselect.h:405
@ CANDIDATE_FOR_SEMIJOIN
Candidate for semi-join flattening.
@ UNSPECIFIED
Nothing decided yet.
@ SUBQ_EXISTS
Evaluate as EXISTS subquery (possibly after rewriting from another type)
@ DERIVED_TABLE
Rewrite to joined derived table.
@ DELETED
Subquery has been deleted, probably because it was always false.
@ CANDIDATE_FOR_IN2EXISTS_OR_MAT
Candidate for rewriting IN(subquery) to EXISTS, or subquery materialization.
@ SEMIJOIN
Semi-join flattening.
@ SUBQ_MATERIALIZATION
Subquery materialization (HASH_SJ_ENGINE)
@ CANDIDATE_FOR_DERIVED_TABLE
Candidate for rewriting to joined derived table.
bool is_quantified_comp_predicate(Item *item)
Definition: item_subselect.cc:2815
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:476
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
unsigned char uchar
Definition: my_inttypes.h:51
long long int longlong
Definition: my_inttypes.h:54
uint64_t table_map
Definition: my_table_map.h:29
Interface for low level time utilities.
unsigned int my_time_flags_t
Flags to str_to_datetime and number_to_datetime.
Definition: my_time.h:93
Time declarations shared between the server and client API: you should not add anything to this heade...
static char * where
Definition: mysqldump.cc:151
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1065
PT & ref(PT *tp)
Definition: tablespace_impl.cc:358
std::string join(Container cont, const std::string &delim)
join elements of an container into a string separated by a delimiter.
Definition: string.h:150
int add_tables(PFS_engine_table_share_proxy **, unsigned int) noexcept
Definition: pfs_plugin_table_v1_all_empty.cc:32
enum_parsing_context
Names for different query parse tree parts.
Definition: parse_tree_node_base.h:60
@ CTX_NONE
Empty value.
Definition: parse_tree_node_base.h:61
File containing constants that can be used throughout the server.
enum_walk
Enumeration for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:287
bool(Item::*)(unsigned char *) Item_processor
Processor type for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:305
enum_condition_context
Enumeration for Query_block::condition_context.
Definition: sql_const.h:311
Common types of the Optimizer, used by optimization and execution.
join_type
Definition: sql_opt_exec_shared.h:185
@ JT_UNKNOWN
Definition: sql_opt_exec_shared.h:187
#define NO_PLAN_IDX
undefined index
Definition: sql_opt_exec_shared.h:54
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:212
Struct used to pass around arguments to/from check_function_as_value_generator.
Definition: item.h:490
int err_code
the error code found during check(if any)
Definition: item.h:497
int get_unnamed_function_error_code() const
Return the correct error code, based on whether or not if we are checking for disallowed functions in...
Definition: item.h:509
Structure used for index-based lookups.
Definition: sql_opt_exec_shared.h:66
This bundles several pieces of information useful when doing the IN->EXISTS transform.
Definition: item_subselect.h:707
bool added_to_where
True: if IN->EXISTS has been done and has added a condition to the subquery's WHERE clause.
Definition: item_subselect.h:712
bool dependent_before
True: if subquery was dependent (correlated) before IN->EXISTS was done.
Definition: item_subselect.h:717
bool dependent_after
True: if subquery was dependent (correlated) after IN->EXISTS was done.
Definition: item_subselect.h:722
Argument for walk method replace_scalar_subquery.
Definition: item_subselect.h:323
Query_block * m_outer_query_block
The transformed query block.
Definition: item_subselect.h:326
Field * m_field
the replacement field
Definition: item_subselect.h:325
Query_block * m_inner_query_block
The immediately surrounding query.
Definition: item_subselect.h:327
bool m_add_coalesce
Definition: item_subselect.h:330
Item_singlerow_subselect * m_target
subquery to be replaced with field
Definition: item_subselect.h:324
Scalar_subquery_replacement(Item_singlerow_subselect *target, Field *field, Query_block *select, bool add_coalesce)
Definition: item_subselect.h:331
argument used by walk method collect_scalar_subqueries ("css")
Definition: item_subselect.h:195
Collect_subq_info(Query_block *owner)
Definition: item_subselect.h:199
Query_block * m_query_block
Definition: item_subselect.h:198
std::vector< Item_subselect * > list
< accumulated all subq (or aggregates) found
Definition: item_subselect.h:197
bool contains(Query_expression *candidate)
Definition: item_subselect.h:200
Definition: mysql_time.h:81
Bison "location" class.
Definition: parse_location.h:42
Environment data for the contextualization phase.
Definition: parse_tree_node_base.h:419
Definition: table.h:1403
Definition: result.h:29
Item_result
Type of the user defined function return slot and arguments.
Definition: udf_registration_types.h:38
@ INT_RESULT
double
Definition: udf_registration_types.h:42
static int all(site_def const *s, node_no node)
Definition: xcom_transport.cc:881