MySQL 8.0.32
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, 2022, 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/* subselect Item */
27
28#include <assert.h>
29#include <sys/types.h>
30
31#include <cstddef>
32#include <memory> // unique_ptr
33#include <vector>
34
35#include "field_types.h" // enum_field_types
36#include "my_alloc.h" // Destroy_only
37
38#include "my_inttypes.h"
39#include "my_table_map.h"
40#include "my_time.h"
42#include "mysql_time.h"
43#include "sql/comp_creator.h"
44#include "sql/enum_query_type.h"
45#include "sql/item.h" // Item_result_field
46#include "sql/iterators/row_iterator.h" // IWYU pragma: keep
47#include "sql/parse_location.h" // POS
49#include "sql/sql_const.h"
51#include "template_utils.h"
52
53class Comp_creator;
54class Field;
57class JOIN;
58class Json_wrapper;
59class PT_subquery;
63class Query_block;
65class String;
67class THD;
69class my_decimal;
71struct AccessPath;
72class Table_ref;
73
74template <class T>
75class List;
76
77/* base class for subselects */
78
81
82 private:
83 bool value_assigned; /* value already assigned to subselect */
84 /**
85 Whether or not execution of this subselect has been traced by
86 optimizer tracing already. If optimizer trace option
87 REPEATED_SUBSELECT is disabled, this is used to disable tracing
88 after the first one.
89 */
91
92 public:
93 /*
94 Used inside Item_subselect::fix_fields() according to this scenario:
95 > Item_subselect::fix_fields
96 > subquery->prepare
97 > query_block->prepare
98 (Here we realize we need to do the rewrite and set
99 substitution= some new Item, eg. Item_in_optimizer )
100 < query_block->prepare
101 < subquery->prepare
102 *ref= substitution;
103 < Item_subselect::fix_fields
104 */
106
107 /* unit of subquery */
109 /**
110 If !=NO_PLAN_IDX: this Item is in the condition attached to the JOIN_TAB
111 having this index in the parent JOIN.
112 */
114
115 // For EXPLAIN.
118
119 // For EXPLAIN. Only valid if engine_type() == HASH_SJ_ENGINE.
120 const TABLE *get_table() const;
121 const Index_lookup &index_lookup() const;
122 join_type get_join_type() const;
123
124 void create_iterators(THD *thd);
125 virtual AccessPath *root_access_path() const { return nullptr; }
126
127 protected:
128 /*
129 We need this method, because some compilers do not allow 'this'
130 pointer in constructor initialization list, but we need to pass a pointer
131 to subselect Item class to Query_result_interceptor's constructor.
132 */
134
135 // The inner part of the subquery.
137
138 // Only relevant for Item_in_subselect; optimized structure used for
139 // execution in place of running the entire subquery.
141
142 /* cache of used external tables */
144 /* allowed number of columns (1 for single value subqueries) */
146 /* where subquery is placed */
148 /* work with 'substitution' */
150
151 public:
152 /* subquery is transformed */
154
163 };
164
166 explicit Item_subselect(const POS &pos);
167
168 private:
169 /// Accumulate properties from underlying query expression
171 /// Accumulate properties from underlying query block
173 /// Accumulate properties from a selected expression within a query block.
174 void accumulate_expression(Item *item);
175 /// Accumulate properties from a condition or GROUP/ORDER within a query
176 /// block.
177 void accumulate_condition(Item *item);
178
179 public:
180 /// Accumulate used tables
182 used_tables_cache |= add_tables;
183 }
184
185 virtual subs_type substype() const { return UNKNOWN_SUBS; }
186
187 void cleanup() override;
188 virtual void reset() { null_value = true; }
189 virtual trans_res select_transformer(THD *thd, Query_block *select) = 0;
190 bool assigned() const { return value_assigned; }
191 void assigned(bool a) { value_assigned = a; }
192 enum Type type() const override;
193 bool is_null() override { return update_null_value() || null_value; }
194 bool fix_fields(THD *thd, Item **ref) override;
195 void fix_after_pullout(Query_block *parent_query_block,
196 Query_block *removed_query_block) override;
197 virtual bool exec(THD *thd);
198 bool resolve_type(THD *) override;
199 table_map used_tables() const override { return used_tables_cache; }
200 table_map not_null_tables() const override { return 0; }
201 Item *get_tmp_table_item(THD *thd) override;
202 void update_used_tables() override;
203 void print(const THD *thd, String *str,
204 enum_query_type query_type) const override;
205
208 }
209
210 /*
211 True if this subquery has been already evaluated. Implemented only for
212 single select and union subqueries only.
213 */
214 bool is_evaluated() const;
215 bool is_uncacheable() const;
216
217 /*
218 Used by max/min subquery to initialize value presence registration
219 mechanism. Engine call this method before rexecution query.
220 */
221 virtual void reset_value_registration() {}
223 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
224 bool explain_subquery_checker(uchar **arg) override;
225 bool inform_item_in_cond_of_tab(uchar *arg) override;
226 bool clean_up_after_removal(uchar *arg) override;
227
228 const char *func_name() const override {
229 assert(0);
230 return "subselect";
231 }
232
235 pointer_cast<Check_function_as_value_generator_parameters *>(args);
236 func_arg->err_code = func_arg->get_unnamed_function_error_code();
237 return true;
238 }
239
240 /// argument used by walk method collect_scalar_subqueries ("css")
242 ///< accumulated all subq (or aggregates) found
243 std::vector<Item_subselect *> list;
246 bool contains(Query_expression *candidate) {
247 for (auto sq : list) {
248 if (sq->unit == candidate) return true;
249 }
250 return false;
251 }
252 };
253
254 bool collect_subqueries(uchar *) override;
255 Item *replace_item_field(uchar *arg) override;
256 Item *replace_item_view_ref(uchar *arg) override;
258
260 friend class Item_in_optimizer;
261 friend bool Item_field::fix_fields(THD *, Item **);
263 friend bool Item_ref::fix_fields(THD *, Item **);
264 friend void Item_ident::fix_after_pullout(Query_block *parent_query_block,
265 Query_block *removed_query_block);
266
267 private:
268 bool subq_opt_away_processor(uchar *arg) override;
269
270 protected:
271 uint unit_cols() const;
272};
273
274/* single value subselect */
275
277 protected:
279 bool no_rows; ///< @c no_rows_in_result
280 public:
283 : Item_subselect(), value(nullptr), row(nullptr), no_rows(false) {}
284
285 void cleanup() override;
286 subs_type substype() const override { return SINGLEROW_SUBS; }
287
288 void reset() override;
289 trans_res select_transformer(THD *thd, Query_block *select) override;
290 void store(uint i, Item *item);
291 double val_real() override;
292 longlong val_int() override;
293 String *val_str(String *) override;
294 my_decimal *val_decimal(my_decimal *) override;
295 bool val_json(Json_wrapper *result) override;
296 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
297 bool get_time(MYSQL_TIME *ltime) override;
298 bool val_bool() override;
299 enum Item_result result_type() const override;
300 bool resolve_type(THD *) override;
301
302 /*
303 Mark the subquery as having no rows.
304 If there are aggregate functions (in the outer query),
305 we need to generate a NULL row. @c return_zero_rows().
306 */
307 void no_rows_in_result() override;
308
309 uint cols() const override { return unit_cols(); }
310
311 /**
312 @note that this returns the i-th element of the SELECT list.
313 To check for nullability, look at this->maybe_null and not
314 element_index[i]->maybe_null, since the selected expressions are
315 always NULL if the subquery is empty.
316 */
317 Item *element_index(uint i) override {
318 return reinterpret_cast<Item *>(row[i]);
319 }
320 Item **addr(uint i) override { return (Item **)row + i; }
321 bool check_cols(uint c) override;
322 bool null_inside() override;
323 void bring_value() override;
324
325 bool collect_scalar_subqueries(uchar *) override;
326 virtual bool is_maxmin() const { return false; }
327
328 /**
329 Argument for walk method replace_scalar_subquery
330 */
332 Item_singlerow_subselect *m_target; ///< subquery to be replaced with field
333 Field *m_field; ///< the replacement field
334 Query_block *m_outer_query_block; ///< The transformed query block.
335 Query_block *m_inner_query_block; ///< The immediately surrounding query
336 ///< block. This will be the transformed
337 ///< block or a subquery of it
338 bool m_add_coalesce{false};
340 Query_block *select, bool add_coalesce)
341 : m_target(target),
342 m_field(field),
343 m_outer_query_block(select),
344 m_inner_query_block(select),
345 m_add_coalesce(add_coalesce) {}
346 };
347
348 Item *replace_scalar_subquery(uchar *arge) override;
349 /**
350 This method is used to implement a special case of semantic tree
351 rewriting, mandated by a SQL:2003 exception in the specification.
352 The only caller of this method is handle_sql2003_note184_exception(),
353 see the code there for more details.
354 Note that this method breaks the object internal integrity, by
355 removing it's association with the corresponding Query_block,
356 making this object orphan from the parse tree.
357 No other method, beside the destructor, should be called on this
358 object, as it is now invalid.
359 @return the Query_block structure that was given in the constructor.
360 */
362 std::optional<ContainedSubquery> get_contained_subquery(
363 const Query_block *outer_query_block) override;
365};
366
367/* used in static ALL/ANY optimization */
369 protected:
370 bool max;
371 bool was_values; // Set if we have found at least one row
372 public:
374 bool max, bool ignore_nulls);
375 void print(const THD *thd, String *str,
376 enum_query_type query_type) const override;
377 void cleanup() override;
378 bool any_value() { return was_values; }
379 void register_value() { was_values = true; }
380 void reset_value_registration() override { was_values = false; }
381 bool is_maxmin() const override { return true; }
382};
383
384/* exists subselect */
385
386/**
387 Strategy which will be used to handle this subquery: flattening to a
388 semi-join, conversion to a derived table, rewrite of IN to EXISTS...
389 Sometimes the strategy is first only a candidate, then the real decision
390 happens in a second phase. Other times the first decision is final.
391 */
392enum class Subquery_strategy : int {
393 /// Nothing decided yet
395 /// Candidate for rewriting IN(subquery) to EXISTS, or subquery
396 /// materialization
398 /// Candidate for semi-join flattening
400 /// Candidate for rewriting to joined derived table
402 /// Semi-join flattening
403 SEMIJOIN,
404 /// Rewrite to joined derived table
406 /// Evaluate as EXISTS subquery (possibly after rewriting from another type)
408 /// Subquery materialization (HASH_SJ_ENGINE)
410 /// Subquery has been deleted, probably because it was always false
411 DELETED,
412};
413
416
417 protected:
418 /// value of this item (boolean: exists/not-exists)
419 bool value{false};
420
421 public:
422 /// Priority of this predicate in the convert-to-semi-join-nest process.
424 /// Execution strategy chosen for this Item
426 /// Used by the transformation to derived table
428
429 /**
430 Used by subquery optimizations to keep track about where this subquery
431 predicate is located, and whether it is a candidate for transformation.
432 (Table_ref*) 1 - the predicate is an AND-part of the WHERE
433 join nest pointer - the predicate is an AND-part of ON expression
434 of a join nest
435 NULL - for all other locations. It also means that the
436 predicate is not a candidate for transformation.
437 See also THD::emb_on_expr_nest.
438
439 As for the second case above (the join nest pointer), note that this value
440 may change if scalar subqueries are transformed to derived tables,
441 cf. transform_scalar_subqueries_to_join_with_derived, due to the need to
442 build new join nests. The change is performed in Query_block::nest_derived.
443 */
445
447
449
450 explicit Item_exists_subselect(const POS &pos) : super(pos) {}
451
453
456 return RES_OK;
457 }
458 subs_type substype() const override { return EXISTS_SUBS; }
459 bool is_bool_func() const override { return true; }
460 void reset() override { value = false; }
461
462 enum Item_result result_type() const override { return INT_RESULT; }
463 /*
464 The item is
465 ([NOT] IN/EXISTS) [ IS [NOT] TRUE|FALSE ]
466 */
468 bool with_is_op() const {
469 switch (value_transform) {
470 case BOOL_IS_TRUE:
471 case BOOL_IS_FALSE:
472 case BOOL_NOT_TRUE:
473 case BOOL_NOT_FALSE:
474 return true;
475 default:
476 return false;
477 }
478 }
479 /// True if the IS TRUE/FALSE wasn't explicit in the query
480 bool implicit_is_op = false;
481 Item *truth_transformer(THD *, enum Bool_test test) override;
482 bool translate(bool &null_v, bool v);
483 void apply_is_true() override {
484 bool had_is = with_is_op();
486 if (!had_is && value_transform == BOOL_IS_TRUE)
487 implicit_is_op = true; // needn't be written by EXPLAIN
488 }
489 /// True if the Item has decided that it can do antijoin
490 bool can_do_aj = false;
492 longlong val_int() override;
493 double val_real() override;
494 String *val_str(String *) override;
495 my_decimal *val_decimal(my_decimal *) override;
496 bool val_bool() override;
497 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override {
498 return get_date_from_int(ltime, fuzzydate);
499 }
500 bool get_time(MYSQL_TIME *ltime) override { return get_time_from_int(ltime); }
501 bool resolve_type(THD *thd) override;
502 void print(const THD *thd, String *str,
503 enum_query_type query_type) const override;
504
506};
507
508/**
509 Representation of IN subquery predicates of the form
510 "left_expr IN (SELECT ...)".
511
512 @details
513 This class has:
514 - A "subquery execution engine" (as a subclass of Item_subselect) that allows
515 it to evaluate subqueries. (and this class participates in execution by
516 having was_null variable where part of execution result is stored.
517 - Transformation methods (todo: more on this).
518
519 This class is not used directly, it is "wrapped" into Item_in_optimizer
520 which provides some small bits of subquery evaluation.
521*/
522
525
526 public:
528
529 protected:
530 /**
531 Cache of the left operand of the subquery predicate. Allocated in the
532 runtime memory root, for each execution, thus need not be freed.
533 */
535 bool left_expr_cache_filled; ///< Whether left_expr_cache holds a value
536 /** The need for expr cache may be optimized away, @sa init_left_expr_cache.
537 */
539
540 private:
541 /**
542 In the case of
543
544 x COMP_OP (SELECT1 UNION SELECT2 ...)
545
546 - the subquery transformation is done on SELECT1; this requires wrapping
547 'x' with more Item layers, and injecting that in a condition in SELECT1.
548
549 - the same transformation is done on SELECT2; but the wrapped 'x' doesn't
550 need to be created again, the one created for SELECT1 could be reused
551
552 - to achieve this, the wrapped 'x' is stored in member
553 'm_injected_left_expr' when it is created for SELECT1, and is later
554 reused for SELECT2.
555
556 This will refer to a cached value which is reevaluated once for each
557 candidate row, cf. setup in #single_value_transformer.
558 */
560
561 /**
562 Pointer to the created Item_in_optimizer; it is stored for the same
563 reasons as 'm_injected_left_expr'.
564 */
567
568 protected:
569 /**
570 True if naked IN is allowed to exchange FALSE for UNKNOWN.
571 Because this is about the naked IN, there is no public ignore_unknown(),
572 intentionally, so that callers don't get it wrong.
573 */
575
576 private:
577 /**
578 This bundles several pieces of information useful when doing the
579 IN->EXISTS transform. If this transform has not been done, pointer is
580 NULL.
581 */
583 /**
584 True: if IN->EXISTS has been done and has added a condition to the
585 subquery's WHERE clause.
586 */
588 /**
589 True: if subquery was dependent (correlated) before IN->EXISTS
590 was done.
591 */
593 /**
594 True: if subquery was dependent (correlated) after IN->EXISTS
595 was done.
596 */
599
600 bool mark_as_outer(Item *left_row, size_t col);
601
602 public:
603 /* Used to trigger on/off conditions that were pushed down to subselect */
605
606 Item_func_not_all *upper_item; // point on NOT/NOP before ALL/SOME subquery
607
608 private:
610
611 public:
614 }
615
616 /// Is reliable only if IN->EXISTS has been done.
619 }
620
621 bool *get_cond_guard(int i) {
622 return pushed_cond_guards ? pushed_cond_guards + i : nullptr;
623 }
624 void set_cond_guard_var(int i, bool v) {
626 }
627
629 Item_in_subselect(const POS &pos, Item *left_expr,
630 PT_subquery *pt_subquery_arg);
631
637 need_expr_cache(true),
640 was_null(false),
641 abort_on_null(false),
645
646 bool itemize(Parse_context *pc, Item **res) override;
647
648 void cleanup() override;
649 subs_type substype() const override { return IN_SUBS; }
650
651 void reset() override {
652 value = false;
653 null_value = false;
654 was_null = false;
655 }
656 trans_res select_transformer(THD *thd, Query_block *select) override;
658 Comp_creator *func);
660 Comp_creator *func);
663 Comp_creator *func);
665 bool subquery_allows_materialization(THD *thd, Query_block *query_block,
666 const Query_block *outer);
667 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
668 Item *transform(Item_transformer transformer, uchar *arg) override;
669 bool exec(THD *thd) override;
670 longlong val_int() override;
671 double val_real() override;
672 String *val_str(String *) override;
673 my_decimal *val_decimal(my_decimal *) override;
674 bool val_bool() override;
675 bool test_limit();
676 void print(const THD *thd, String *str,
677 enum_query_type query_type) const override;
678 bool fix_fields(THD *thd, Item **ref) override;
679 void fix_after_pullout(Query_block *parent_query_block,
680 Query_block *removed_query_block) override;
681 bool init_left_expr_cache(THD *thd);
682
683 /**
684 Once the decision to use IN->EXISTS has been taken, performs some last
685 steps of this transformation.
686 */
687 bool finalize_exists_transform(THD *thd, Query_block *select);
688 /**
689 Once the decision to use materialization has been taken, performs some
690 last steps of this transformation.
691 */
693 AccessPath *root_access_path() const override;
694 std::optional<ContainedSubquery> get_contained_subquery(
695 const Query_block *outer_query_block) override;
696
699 friend class Item_in_optimizer;
702
703 private:
704 bool val_bool_naked();
705};
706
707/// ALL/ANY/SOME subselect.
709 public:
712 bool all;
713
715 Query_block *select, bool all);
716
717 // only ALL subquery has upper not
718 subs_type substype() const override { return all ? ALL_SUBS : ANY_SUBS; }
719 trans_res select_transformer(THD *thd, Query_block *select) override;
720 void print(const THD *thd, String *str,
721 enum_query_type query_type) const override;
722};
723
725 public:
727 Item_subselect *si);
728 /**
729 Cleanup subquery after complete query execution, free all resources.
730 */
731 void cleanup();
732 bool prepare(THD *thd);
733 void fix_length_and_dec(Item_cache **row);
734 /**
735 Execute the subquery
736
737 SYNOPSIS
738 exec()
739
740 DESCRIPTION
741 Execute the subquery. The result of execution is subquery value that is
742 captured by previously set up Query_result-based 'sink'.
743
744 RETURN
745 false - OK
746 true - Execution error.
747 */
748 bool exec(THD *thd);
749 void print(const THD *thd, String *str, enum_query_type query_type);
752 Query_block *single_query_block() const; // Only if unit is simple.
753
754 enum Item_result type() const { return res_type; }
756 bool may_be_null() const { return maybe_null; }
757
758#ifndef NDEBUG
759 /**
760 @returns the internal Item. Defined only in debug builds, because should
761 be used only for debug asserts.
762 */
763 const Item_subselect *get_item() const { return item; }
764#endif
765
766 private:
767 Query_result_interceptor *result; /* results storage class */
768 Item_subselect *item; /* item, that use this subquery */
769 enum Item_result res_type; /* type of results */
770 enum_field_types res_field_type; /* column type of the results */
771 /**
772 True if at least one of the columns returned by the subquery may
773 be null, or if a single-row subquery may return zero rows.
774 */
776
777 Query_expression *unit; /* corresponding unit structure */
778
779 void set_row(const mem_root_deque<Item *> &item_list, Item_cache **row,
780 bool never_empty);
781
783};
784
785/**
786 A subquery execution engine that evaluates the subquery by doing index
787 lookups in a single table's index.
788
789 This engine is used to resolve subqueries in forms
790
791 outer_expr IN (SELECT tbl.key FROM tbl WHERE subq_where)
792
793 or, row-based:
794
795 (oe1, .. oeN) IN (SELECT key_part1, ... key_partK
796 FROM tbl WHERE subqwhere)
797
798 i.e. the subquery is a single table SELECT without GROUP BY, aggregate
799 functions, etc.
800*/
802 protected:
803 Query_result_union *result = nullptr; /* results storage class */
804 /// Table which is read, using one of eq_ref, ref, ref_or_null.
805 TABLE *table{nullptr};
809 Item *cond; /* The WHERE condition of subselect */
810 ulonglong hash; /* Hash value calculated by RefIterator, when needed. */
811 /*
812 The "having" clause. This clause (further referred to as "artificial
813 having") was inserted by subquery transformation code. It contains
814 Item(s) that have a side-effect: they record whether the subquery has
815 produced a row with NULL certain components. We need to use it for cases
816 like
817 (oe1, oe2) IN (SELECT t.key, t.no_key FROM t1)
818 where we do index lookup on t.key=oe1 but need also to check if there
819 was a row such that t.no_key IS NULL.
820 */
822
823 Item_in_subselect *item; /* item that uses this engine */
824
825 public:
827
829 const Index_lookup &ref,
830 enum join_type join_type,
832 Item *having_arg)
833 : table(table),
835 ref(ref),
837 cond(where),
838 having(having_arg),
839 item(subs) {}
841 virtual bool exec(THD *thd);
842 virtual void print(const THD *thd, String *str, enum_query_type query_type);
844 virtual void cleanup() {}
845 virtual void create_iterators(THD *) {}
846};
847
848/*
849 This function is actually defined in sql_parse.cc, but it depends on
850 chooser_compare_func_creator defined in this file.
851 */
854 Query_block *select);
855
856/**
857 Compute an IN predicate via a hash semi-join. The subquery is materialized
858 during the first evaluation of the IN predicate. The IN predicate is executed
859 via the functionality inherited from subselect_indexsubquery_engine.
860*/
861
863 private:
864 /* true if the subquery was materialized into a temp table. */
866 // true if we know for sure that there are zero rows in the table.
867 // Set only after is_materialized is true.
868 bool has_zero_rows = false;
869 /**
870 Existence of inner NULLs in materialized table:
871 By design, other values than IRRELEVANT_OR_FALSE are possible only if the
872 subquery has only one inner expression.
873 */
875 /// none, or they don't matter
877 /// they matter, and we don't know yet if they exists
879 /// they matter, and we know there exists at least one.
880 NEX_TRUE = 2
881 };
886
887 /// Saved result object, must be restored after use
889
890 public:
892 Query_expression *unit_arg)
894 in_predicate, nullptr, nullptr),
895 is_materialized(false),
896 unit(unit_arg) {}
897 ~subselect_hash_sj_engine() override;
898
899 bool setup(THD *thd, const mem_root_deque<Item *> &tmp_columns);
900 void cleanup() override;
901 bool exec(THD *thd) override;
902 void print(const THD *thd, String *str, enum_query_type query_type) override;
903 enum_engine_type engine_type() const override { return HASH_SJ_ENGINE; }
904
905 TABLE *get_table() const { return table; }
906 const Index_lookup &index_lookup() const { return ref; }
907 enum join_type get_join_type() const { return type; }
909 void create_iterators(THD *thd) override;
910};
911
912/**
913 Removes every predicate injected by IN->EXISTS.
914
915 This function is different from others:
916 - it wants to remove all traces of IN->EXISTS (for
917 materialization)
918 - remove_subq_pushed_predicates() and remove_additional_cond() want to
919 remove only the conditions of IN->EXISTS which index lookup already
920 satisfies (they are just an optimization).
921
922 If there are no in2exists conditions, it will return the exact same
923 pointer. If it returns a new Item, the old Item is left alone, so it
924 can be reused in other settings.
925
926 @param thd Thread handle.
927 @param conds Condition; may be nullptr.
928 @param copy true if a copy of the new condition needs to be returned
929 (used in case of hypergraph optimizer).
930 @returns new condition
931 */
932Item *remove_in2exists_conds(THD *thd, Item *conds, bool copy);
933
934/// Returns whether the Item is an IN-subselect.
935bool IsItemInSubSelect(Item *item);
936
937#endif /* ITEM_SUBSELECT_INCLUDED */
Abstract factory interface for creating comparison predicates.
Definition: item_cmpfunc.h:528
Definition: field.h:574
ALL/ANY/SOME subselect.
Definition: item_subselect.h:708
Item_allany_subselect(Item *left_expr, chooser_compare_func_creator fc, Query_block *select, bool all)
Definition: item_subselect.cc:1491
Comp_creator * func
Definition: item_subselect.h:711
trans_res select_transformer(THD *thd, Query_block *select) override
Definition: item_subselect.cc:2713
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:2723
chooser_compare_func_creator func_creator
Definition: item_subselect.h:710
bool all
Definition: item_subselect.h:712
subs_type substype() const override
Definition: item_subselect.h:718
Definition: item.h:6585
Definition: item_subselect.h:414
enum_condition_context outer_condition_context
Used by the transformation to derived table.
Definition: item_subselect.h:427
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:483
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1505
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.h:497
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1584
Item_exists_subselect()
Definition: item_subselect.h:448
double val_real() override
Definition: item_subselect.cc:1570
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.h:500
bool implicit_is_op
True if the IS TRUE/FALSE wasn't explicit in the query.
Definition: item_subselect.h:480
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:1400
longlong val_int() override
Definition: item_subselect.cc:1572
Subquery_strategy strategy
Execution strategy chosen for this Item.
Definition: item_subselect.h:425
bool val_bool() override
Definition: item_subselect.cc:1608
int sj_convert_priority
Priority of this predicate in the convert-to-semi-join-nest process.
Definition: item_subselect.h:423
void reset() override
Definition: item_subselect.h:460
bool value
value of this item (boolean: exists/not-exists)
Definition: item_subselect.h:419
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1342
trans_res select_transformer(THD *, Query_block *) override
Definition: item_subselect.h:454
bool can_do_aj
True if the Item has decided that it can do antijoin.
Definition: item_subselect.h:490
bool with_is_op() const
Definition: item_subselect.h:468
enum Bool_test value_transform
Definition: item_subselect.h:467
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:452
subs_type substype() const override
Definition: item_subselect.h:458
Item_subselect super
Definition: item_subselect.h:415
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:1363
bool is_bool_func() const override
Definition: item_subselect.h:459
Table_ref * embedding_join_nest
Used by subquery optimizations to keep track about where this subquery predicate is located,...
Definition: item_subselect.h:444
bool choose_semijoin_or_antijoin()
Helper for resolve_subquery().
Definition: item_subselect.cc:1533
Item_exists_subselect(const POS &pos)
Definition: item_subselect.h:450
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1601
enum Item_result result_type() const override
Definition: item_subselect.h:462
int fix_outer_field(THD *thd, Field **field, Item **reference)
Resolve the name of an outer select column reference.
Definition: item.cc:5220
bool fix_fields(THD *, Item **) override
Resolve the name of a column reference.
Definition: item.cc:5661
Definition: item_cmpfunc.h:915
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Fix after tables have been moved from one query_block level to the parent level, e....
Definition: item.cc:3129
Definition: item_cmpfunc.h:492
Representation of IN subquery predicates of the form "left_expr IN (SELECT ...)".
Definition: item_subselect.h:523
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:2522
Item * left_expr
Definition: item_subselect.h:527
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:2537
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1662
struct Item_in_subselect::In2exists_info * in2exists_info
Item_in_optimizer * optimizer
Pointer to the created Item_in_optimizer; it is stored for the same reasons as 'm_injected_left_expr'...
Definition: item_subselect.h:565
double val_real() override
Definition: item_subselect.cc:1619
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:2586
bool need_expr_cache
The need for expr cache may be optimized away,.
Definition: item_subselect.h:538
void set_cond_guard_var(int i, bool v)
Definition: item_subselect.h:624
Item_func_not_all * upper_item
Definition: item_subselect.h:606
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:440
bool itemize(Parse_context *pc, Item **res) override
The same as contextualize() but with additional parameter.
Definition: item_subselect.cc:1480
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:2492
bool abort_on_null
True if naked IN is allowed to exchange FALSE for UNKNOWN.
Definition: item_subselect.h:574
void reset() override
Definition: item_subselect.h:651
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:375
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:742
bool dependent_before_in2exists() const
Is reliable only if IN->EXISTS has been done.
Definition: item_subselect.h:617
bool * pushed_cond_guards
Definition: item_subselect.h:604
AccessPath * root_access_path() const override
Definition: item_subselect.cc:532
PT_subquery * pt_subselect
Definition: item_subselect.h:609
longlong val_int() override
Definition: item_subselect.cc:1626
trans_res 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:1909
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:382
bool val_bool() override
Definition: item_subselect.cc:1640
List< Cached_item > * left_expr_cache
Cache of the left operand of the subquery predicate.
Definition: item_subselect.h:534
trans_res single_value_transformer(THD *thd, Query_block *select, Comp_creator *func)
Rewrite a single-column IN/ALL/ANY subselect.
Definition: item_subselect.cc:1701
bool was_null
Definition: item_subselect.h:566
bool init_left_expr_cache(THD *thd)
Initialize the cache of the left operand of the IN predicate.
Definition: item_subselect.cc:2555
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:500
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1633
trans_res row_value_in_to_exists_transformer(THD *thd, Query_block *select)
Transform a (possibly non-correlated) IN subquery into a correlated EXISTS.
Definition: item_subselect.cc:2195
trans_res select_in_like_transformer(THD *thd, Query_block *select, Comp_creator *func)
Prepare IN/ALL/ANY/SOME subquery transformation and call appropriate transformation function.
Definition: item_subselect.cc:2411
bool in2exists_added_to_where() const
Definition: item_subselect.h:612
bool * get_cond_guard(int i)
Definition: item_subselect.h:621
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:736
subs_type substype() const override
Definition: item_subselect.h:649
Item_exists_subselect super
Definition: item_subselect.h:524
bool test_limit()
Definition: item_subselect.cc:1431
trans_res row_value_transformer(THD *thd, Query_block *select)
Definition: item_subselect.cc:2128
Item_in_subselect()
Definition: item_subselect.h:632
bool val_bool_naked()
Definition: item_subselect.cc:1647
Item_ref * m_injected_left_expr
In the case of.
Definition: item_subselect.h:559
bool exec(THD *thd) override
Definition: item_subselect.cc:753
bool left_expr_cache_filled
Whether left_expr_cache holds a value.
Definition: item_subselect.h:535
trans_res select_transformer(THD *thd, Query_block *select) override
Definition: item_subselect.cc:2384
Definition: item_cmpfunc.h:2293
Definition: item_subselect.h:368
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1093
bool max
Definition: item_subselect.h:370
Item_maxmin_subselect(Item_subselect *parent, Query_block *query_block, bool max, bool ignore_nulls)
Definition: item_subselect.cc:1067
bool any_value()
Definition: item_subselect.h:378
bool is_maxmin() const override
Definition: item_subselect.h:381
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:1086
void reset_value_registration() override
Definition: item_subselect.h:380
void register_value()
Definition: item_subselect.h:379
bool was_values
Definition: item_subselect.h:371
Definition: item.h:6073
Definition: item.h:5643
bool fix_fields(THD *, Item **) override
Resolve the name of a reference to a column reference.
Definition: item.cc:7985
Item with result field.
Definition: item.h:5566
Definition: item_subselect.h:276
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:2811
enum Item_result result_type() const override
Definition: item_subselect.cc:1168
void store(uint i, Item *item)
Definition: item_subselect.cc:1163
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:341
trans_res select_transformer(THD *thd, Query_block *select) override
Definition: item_subselect.cc:1114
bool null_inside() override
Definition: item_subselect.cc:1212
Item ** addr(uint i) override
Definition: item_subselect.h:320
double val_real() override
Definition: item_subselect.cc:1226
bool resolve_type(THD *) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1172
void no_rows_in_result() override
Definition: item_subselect.cc:1195
bool val_json(Json_wrapper *result) override
Get a JSON value from an Item.
Definition: item_subselect.cc:1269
void reset() override
Definition: item_subselect.cc:1099
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.cc:1279
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:2850
longlong val_int() override
Definition: item_subselect.cc:1237
uint cols() const override
Definition: item_subselect.h:309
virtual bool is_maxmin() const
Definition: item_subselect.h:326
Item * element_index(uint i) override
Definition: item_subselect.h:317
Item_cache ** row
Definition: item_subselect.h:278
Item_singlerow_subselect()
Definition: item_subselect.h:282
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:883
bool collect_scalar_subqueries(uchar *) override
Definition: item_subselect.cc:2737
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.cc:1290
String * val_str(String *) override
Definition: item_subselect.cc:1248
bool val_bool() override
Definition: item_subselect.cc:1300
bool no_rows
no_rows_in_result
Definition: item_subselect.h:279
subs_type substype() const override
Definition: item_subselect.h:286
void bring_value() override
Definition: item_subselect.cc:1219
bool check_cols(uint c) override
Definition: item_subselect.cc:1204
Item_cache * value
Definition: item_subselect.h:278
my_decimal * val_decimal(my_decimal *) override
Definition: item_subselect.cc:1258
Definition: item_subselect.h:79
subselect_indexsubquery_engine * indexsubquery_engine
Definition: item_subselect.h:140
enum_parsing_context parsing_place
Definition: item_subselect.h:147
Item * replace_item_view_ref(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:2939
bool clean_up_after_removal(uchar *arg) override
Clean up after removing the subquery from the item tree.
Definition: item_subselect.cc:2679
bool is_evaluated() const
Definition: item_subselect.cc:2721
bool collect_subqueries(uchar *) override
Definition: item_subselect.cc:2706
table_map used_tables() const override
Definition: item_subselect.h:199
subs_type
Definition: item_subselect.h:156
@ UNKNOWN_SUBS
Definition: item_subselect.h:157
@ EXISTS_SUBS
Definition: item_subselect.h:159
@ SINGLEROW_SUBS
Definition: item_subselect.h:158
@ ALL_SUBS
Definition: item_subselect.h:161
@ ANY_SUBS
Definition: item_subselect.h:162
@ IN_SUBS
Definition: item_subselect.h:160
void accumulate_expression(Item *item)
Accumulate properties from a selected expression within a query block.
Definition: item_subselect.cc:276
void accumulate_used_tables(table_map add_tables)
Accumulate used tables.
Definition: item_subselect.h:181
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:233
bool is_uncacheable() const
Definition: item_subselect.cc:3142
void accumulate_properties()
Accumulate properties from underlying query expression.
Definition: item_subselect.cc:214
virtual bool exec(THD *thd)
Definition: item_subselect.cc:648
enum_engine_type
Definition: item_subselect.h:116
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:116
@ HASH_SJ_ENGINE
Definition: item_subselect.h:116
@ OTHER_ENGINE
Definition: item_subselect.h:116
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:831
Query_expression * unit
Definition: item_subselect.h:108
virtual void reset_value_registration()
Definition: item_subselect.h:221
bool explain_subquery_checker(uchar **arg) override
Register subquery to the table where it is used within a condition.
Definition: item_subselect.cc:641
bool traced_before
Whether or not execution of this subselect has been traced by optimizer tracing already.
Definition: item_subselect.h:90
Item * substitution
Definition: item_subselect.h:105
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:812
enum_parsing_context place()
Definition: item_subselect.h:222
virtual void reset()
Definition: item_subselect.h:188
Item * replace_item_field(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:2931
uint max_columns
Definition: item_subselect.h:145
join_type get_join_type() const
Definition: item_subselect.cc:322
bool assigned() const
Definition: item_subselect.h:190
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:113
void accumulate_condition(Item *item)
Accumulate properties from a condition or GROUP/ORDER within a query block.
Definition: item_subselect.cc:287
virtual AccessPath * root_access_path() const
Definition: item_subselect.h:125
void create_iterators(THD *thd)
Definition: item_subselect.cc:292
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:327
Item * replace_item(Item_transformer t, uchar *arg)
Definition: item_subselect.cc:2874
virtual trans_res select_transformer(THD *thd, Query_block *select)=0
const TABLE * get_table() const
Definition: item_subselect.cc:312
enum Type type() const override
Definition: item_subselect.cc:805
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:553
bool resolve_type(THD *) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:807
void set_indexsubquery_engine(subselect_indexsubquery_engine *eng)
Definition: item_subselect.h:206
void assigned(bool a)
Definition: item_subselect.h:191
const char * func_name() const override
Definition: item_subselect.h:228
bool have_to_be_excluded
Definition: item_subselect.h:149
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:200
table_map used_tables_cache
Definition: item_subselect.h:143
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_subselect.cc:824
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:620
bool changed
Definition: item_subselect.h:153
Item_subselect()
Definition: item_subselect.cc:103
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_subselect.h:193
void init(Query_block *select, Query_result_subquery *result)
Definition: item_subselect.cc:139
const Index_lookup & index_lookup() const
Definition: item_subselect.cc:317
enum_engine_type engine_type() const
Definition: item_subselect.cc:298
virtual subs_type substype() const
Definition: item_subselect.h:185
unique_ptr_destroy_only< SubqueryWithResult > subquery
Definition: item_subselect.h:136
Item_result_field super
Definition: item_subselect.h:80
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:2651
trans_res
Definition: item_subselect.h:155
@ RES_REDUCE
Definition: item_subselect.h:155
@ RES_ERROR
Definition: item_subselect.h:155
@ RES_OK
Definition: item_subselect.h:155
bool value_assigned
Definition: item_subselect.h:83
bool subq_opt_away_processor(uchar *arg) override
Mark the subquery as optimized away, for EXPLAIN.
Definition: item_subselect.cc:2663
uint unit_cols() const
Definition: item_subselect.cc:3137
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:718
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:850
bool null_value
True if item is null.
Definition: item.h:3425
Type
Definition: item.h:886
Bool_test
< Modifier for result transformation
Definition: item.h:934
@ BOOL_NOT_FALSE
Definition: item.h:938
@ BOOL_NOT_TRUE
Definition: item.h:937
@ BOOL_IS_TRUE
Definition: item.h:934
@ BOOL_IS_FALSE
Definition: item.h:935
@ BOOL_IDENTITY
Definition: item.h:940
bool get_date_from_int(MYSQL_TIME *ltime, my_time_flags_t flags)
Convert val_int() to date in MYSQL_TIME.
Definition: item.cc:1459
bool update_null_value()
Make sure the null_value member has a correct value.
Definition: item.cc:7338
bool get_time_from_int(MYSQL_TIME *ltime)
Convert val_int() to time in MYSQL_TIME.
Definition: item.cc:1546
Definition: sql_optimizer.h:125
Abstraction for accessing JSON values irrespective of whether they are (started out as) binary JSON v...
Definition: json_dom.h:1160
Definition: sql_list.h:433
Definition: parse_tree_nodes.h:1605
Base class for parse tree nodes (excluding the Parse_tree_root hierarchy)
Definition: parse_tree_node_base.h:138
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1153
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:623
Definition: item_subselect.cc:1311
Definition: query_result.h:173
Definition: item_subselect.cc:850
Base class for result from a subquery.
Definition: query_result.h:295
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
Definition: item_subselect.h:724
enum Item_result type() const
Definition: item_subselect.h:754
Item_subselect * item
Definition: item_subselect.h:768
bool maybe_null
True if at least one of the columns returned by the subquery may be null, or if a single-row subquery...
Definition: item_subselect.h:775
bool may_be_null() const
Definition: item_subselect.h:756
void print(const THD *thd, String *str, enum_query_type query_type)
Definition: item_subselect.cc:3144
Query_block * single_query_block() const
Definition: item_subselect.cc:3208
enum Item_result res_type
Definition: item_subselect.h:769
enum_field_types res_field_type
Definition: item_subselect.h:770
bool exec(THD *thd)
Execute the subquery.
Definition: item_subselect.cc:3063
SubqueryWithResult(Query_expression *u, Query_result_interceptor *res, Item_subselect *si)
Definition: item_subselect.cc:2948
Query_result_interceptor * result
Definition: item_subselect.h:767
enum_field_types field_type() const
Definition: item_subselect.h:755
Query_expression * unit
Definition: item_subselect.h:777
void fix_length_and_dec(Item_cache **row)
Definition: item_subselect.cc:3043
bool prepare(THD *thd)
Prepare the query expression underlying the subquery.
Definition: item_subselect.cc:2972
const Item_subselect * get_item() const
Definition: item_subselect.h:763
void set_row(const mem_root_deque< Item * > &item_list, Item_cache **row, bool never_empty)
Makes storage for the output values for a scalar or row subquery and calculates their data and column...
Definition: item_subselect.cc:2989
void cleanup()
Cleanup subquery after complete query execution, free all resources.
Definition: item_subselect.cc:2943
bool change_query_result(THD *thd, Item_subselect *si, Query_result_subquery *result)
change query result object of subquery.
Definition: item_subselect.cc:3200
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:33
Definition: table.h:2755
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:109
my_decimal class limits 'decimal_t' type to what we need in MySQL.
Definition: my_decimal.h:93
Compute an IN predicate via a hash semi-join.
Definition: item_subselect.h:862
void create_iterators(THD *thd) override
Definition: item_subselect.cc:3410
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:3641
nulls_exist
Existence of inner NULLs in materialized table: By design, other values than IRRELEVANT_OR_FALSE are ...
Definition: item_subselect.h:874
@ NEX_TRUE
they matter, and we know there exists at least one.
Definition: item_subselect.h:880
@ NEX_UNKNOWN
they matter, and we don't know yet if they exists
Definition: item_subselect.h:878
@ NEX_IRRELEVANT_OR_FALSE
none, or they don't matter
Definition: item_subselect.h:876
void cleanup() override
Cleanup performed after each execution.
Definition: item_subselect.cc:3487
unique_ptr_destroy_only< RowIterator > m_iterator
Definition: item_subselect.h:884
TABLE * get_table() const
Definition: item_subselect.h:905
subselect_hash_sj_engine(Item_in_subselect *in_predicate, Query_expression *unit_arg)
Definition: item_subselect.h:891
Query_expression *const unit
Definition: item_subselect.h:883
~subselect_hash_sj_engine() override
Definition: item_subselect.cc:3476
Query_result_interceptor * saved_result
Saved result object, must be restored after use.
Definition: item_subselect.h:888
enum nulls_exist mat_table_has_nulls
Definition: item_subselect.h:882
bool is_materialized
Definition: item_subselect.h:865
bool has_zero_rows
Definition: item_subselect.h:868
const Index_lookup & index_lookup() const
Definition: item_subselect.h:906
bool exec(THD *thd) override
Execute a subquery IN predicate via materialization.
Definition: item_subselect.cc:3523
enum_engine_type engine_type() const override
Definition: item_subselect.h:903
AccessPath * root_access_path() const
Definition: item_subselect.h:908
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:3240
enum join_type get_join_type() const
Definition: item_subselect.h:907
AccessPath * m_root_access_path
Definition: item_subselect.h:885
A subquery execution engine that evaluates the subquery by doing index lookups in a single table's in...
Definition: item_subselect.h:801
Item * having
Definition: item_subselect.h:821
TABLE * table
Table which is read, using one of eq_ref, ref, ref_or_null.
Definition: item_subselect.h:805
virtual ~subselect_indexsubquery_engine()=default
virtual void cleanup()
Definition: item_subselect.h:844
virtual bool exec(THD *thd)
Definition: item_subselect.cc:3126
virtual void print(const THD *thd, String *str, enum_query_type query_type)
Definition: item_subselect.cc:3149
Item * cond
Definition: item_subselect.h:809
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_arg)
Definition: item_subselect.h:828
virtual void create_iterators(THD *)
Definition: item_subselect.h:845
join_type type
Definition: item_subselect.h:808
enum_engine_type
Definition: item_subselect.h:826
@ HASH_SJ_ENGINE
Definition: item_subselect.h:826
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:826
Index_lookup ref
Definition: item_subselect.h:807
ulonglong hash
Definition: item_subselect.h:810
virtual enum_engine_type engine_type() const
Definition: item_subselect.h:843
Item_in_subselect * item
Definition: item_subselect.h:823
Table_ref * table_ref
Definition: item_subselect.h:806
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:1064
enum_query_type
Query type constants (usable as bitmap flags).
Definition: enum_query_type.h:30
Fido Client Authentication nullptr
Definition: fido_client_plugin.cc:221
This file contains the field type.
enum_field_types
Column types for MySQL.
Definition: field_types.h:52
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:981
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:6646
Item *(Item::* Item_transformer)(uchar *arg)
Type for transformers used by Item::transform and Item::compile.
Definition: item.h:720
bool IsItemInSubSelect(Item *item)
Returns whether the Item is an IN-subselect.
Definition: item_subselect.cc:2618
Subquery_strategy
Strategy which will be used to handle this subquery: flattening to a semi-join, conversion to a deriv...
Definition: item_subselect.h:392
@ 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.
Item * remove_in2exists_conds(THD *thd, Item *conds, bool copy)
Removes every predicate injected by IN->EXISTS.
Definition: item_subselect.cc:405
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:488
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:136
void copy(Shards< COUNT > &dst, const Shards< COUNT > &src) noexcept
Copy the counters, overwrite destination.
Definition: ut0counter.h:353
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1063
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
enum_parsing_context
Names for different query parse tree parts.
Definition: parse_tree_node_base.h:57
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:286
bool(Item::*)(unsigned char *) Item_processor
Processor type for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:304
enum_condition_context
Enumeration for Query_block::condition_context.
Definition: sql_const.h:310
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
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:189
Struct used to pass around arguments to/from check_function_as_value_generator.
Definition: item.h:486
int err_code
the error code found during check(if any)
Definition: item.h:493
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:505
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:582
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:587
bool dependent_before
True: if subquery was dependent (correlated) before IN->EXISTS was done.
Definition: item_subselect.h:592
bool dependent_after
True: if subquery was dependent (correlated) after IN->EXISTS was done.
Definition: item_subselect.h:597
Argument for walk method replace_scalar_subquery.
Definition: item_subselect.h:331
Query_block * m_outer_query_block
The transformed query block.
Definition: item_subselect.h:334
Field * m_field
the replacement field
Definition: item_subselect.h:333
Query_block * m_inner_query_block
The immediately surrounding query.
Definition: item_subselect.h:335
bool m_add_coalesce
Definition: item_subselect.h:338
Item_singlerow_subselect * m_target
subquery to be replaced with field
Definition: item_subselect.h:332
Scalar_subquery_replacement(Item_singlerow_subselect *target, Field *field, Query_block *select, bool add_coalesce)
Definition: item_subselect.h:339
argument used by walk method collect_scalar_subqueries ("css")
Definition: item_subselect.h:241
Collect_subq_info(Query_block *owner)
Definition: item_subselect.h:245
Query_block * m_query_block
Definition: item_subselect.h:244
std::vector< Item_subselect * > list
< accumulated all subq (or aggregates) found
Definition: item_subselect.h:243
bool contains(Query_expression *candidate)
Definition: item_subselect.h:246
Definition: mysql_time.h:81
Environment data for the contextualization phase.
Definition: parse_tree_node_base.h:120
Definition: table.h:1395
Bison "location" class.
Definition: parse_location.h:42
Definition: result.h:29
unsigned int uint
Definition: uca-dump.cc: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:868