MySQL 9.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, 2025, Oracle and/or its affiliates.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License, version 2.0,
8 as published by the Free Software Foundation.
9
10 This program is designed to work with certain software (including
11 but not limited to OpenSSL) that is licensed under separate terms,
12 as designated in a particular file or component or in included license
13 documentation. The authors of MySQL hereby grant you an additional
14 permission to link the program and your derivative works with the
15 separately licensed software that they have either included with
16 the program or referenced in the documentation.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License, version 2.0, for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
26
27/// Implements classes that represent subqueries and predicates containing
28/// table subqueries.
29
30#include <assert.h>
31#include <sys/types.h>
32
33#include <cstddef>
34#include <memory> // unique_ptr
35#include <vector>
36
37#include "field_types.h" // enum_field_types
38#include "my_alloc.h" // Destroy_only
39
40#include "my_inttypes.h"
41#include "my_table_map.h"
42#include "my_time.h"
44#include "mysql_time.h"
45#include "sql/comp_creator.h"
46#include "sql/enum_query_type.h"
47#include "sql/item.h" // Item_result_field
48#include "sql/iterators/row_iterator.h" // IWYU pragma: keep
49#include "sql/parse_location.h" // POS
51#include "sql/sql_const.h"
53#include "template_utils.h"
54
55class Comp_creator;
56class Field;
59class JOIN;
60class Json_wrapper;
61class PT_subquery;
65class Query_block;
67class String;
68class THD;
70class my_decimal;
72struct AccessPath;
73class Table_ref;
74
75template <class T>
76class List;
77
78/// Base class that is common to all subqueries and subquery predicates
79
82
83 public:
85
86 /**
87 For Item_subselect constructor with POS parameter, the contextualized
88 field must be transitioned explicitly.
89 */
91#ifndef NDEBUG
92 assert(!contextualized);
93 contextualized = true;
94#endif // NDEBUG
95 }
96 /**
97 If !=NO_PLAN_IDX: this Item is in the condition attached to the JOIN_TAB
98 having this index in the parent JOIN.
99 */
101
102 // For EXPLAIN.
105
106 // For EXPLAIN. Only valid if engine_type() == HASH_SJ_ENGINE.
107 const TABLE *get_table() const;
108 const Index_lookup &index_lookup() const;
109 join_type get_join_type() const;
110
111 void create_iterators(THD *thd);
112 virtual AccessPath *root_access_path() const { return nullptr; }
113
115 SCALAR_SUBQUERY, ///< Scalar or row subquery
116 EXISTS_SUBQUERY, ///< [NOT] EXISTS subquery predicate
117 IN_SUBQUERY, ///< [NOT] IN subquery predicate
118 ALL_SUBQUERY, ///< comp-op ALL quantified comparison predicate
119 ANY_SUBQUERY ///< comp-op ANY quantified comparison predicate
120 };
121
122 /// Accumulate used tables
126 }
127
128 /// Return whether this subquery references any tables in the directly
129 /// containing query block, i.e. whether there are outer references to the
130 /// containing block inside the subquery.
132 return (subquery_used_tables() & ~PSEUDO_TABLE_BITS) != 0;
133 }
134
135 virtual Subquery_type subquery_type() const = 0;
136
137 /**
138 @returns whether this subquery is a single column scalar subquery.
139 (Note that scalar and row subqueries are both represented as
140 scalar subqueries, this function can be used to distinguish them)
141 */
142 virtual bool is_single_column_scalar_subquery() const { return false; }
143
144 void cleanup() override;
145 /**
146 Reset state after a single execution of a subquery, useful when a
147 dependent subquery must be evaluated multiple times for varying values
148 of the outer references.
149 This is a lighter cleanup procedure than the one provided by cleanup().
150 */
151 virtual void reset() {
152 m_value_assigned = false;
153 null_value = true;
154 }
155 bool is_value_assigned() const { return m_value_assigned; }
158 enum Type type() const override;
159 bool is_null() override { return update_null_value() || null_value; }
160 bool fix_fields(THD *thd, Item **ref) override;
161 void fix_after_pullout(Query_block *parent_query_block,
162 Query_block *removed_query_block) override;
163 virtual bool exec(THD *thd);
164 table_map used_tables() const override { return m_used_tables_cache; }
165 table_map not_null_tables() const override { return 0; }
166 /// @returns used tables for subquery (excluding any left-hand expression)
168 Item *get_tmp_table_item(THD *thd) override;
169 void update_used_tables() override;
170 void print(const THD *thd, String *str,
171 enum_query_type query_type) const override;
172
175 }
176
177 /*
178 True if this subquery has been already evaluated. Implemented only for
179 single select and union subqueries only.
180 */
181 bool is_evaluated() const;
182 bool is_uncacheable() const;
183
184 /**
185 Used by max/min subquery to initialize value presence registration
186 mechanism. Engine calls this function before re-execution of subquery.
187 */
188 virtual void reset_has_values() {}
189 /**
190 @returns the "place" where this subquery is located in the simply
191 containing query block.
192 */
194
195 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
196 bool explain_subquery_checker(uchar **arg) override;
197 bool inform_item_in_cond_of_tab(uchar *arg) override;
198 bool clean_up_after_removal(uchar *arg) override;
199
202 pointer_cast<Check_function_as_value_generator_parameters *>(args);
203 func_arg->err_code = func_arg->get_unnamed_function_error_code();
204 return true;
205 }
206
207 /// argument used by walk method collect_scalar_subqueries ("css")
209 ///< accumulated all subq (or aggregates) found
210 std::vector<Item_subselect *> list;
213 bool contains(Query_expression *candidate) {
214 for (auto sq : list) {
215 if (sq->m_query_expr == candidate) return true;
216 }
217 return false;
218 }
219 };
220
221 bool collect_subqueries(uchar *) override;
222 Item *replace_item_field(uchar *arg) override;
223 Item *replace_item_view_ref(uchar *arg) override;
224
225 protected:
227 explicit Item_subselect(const POS &pos) : super(pos) { set_subquery(); }
228 /**
229 Bind this subquery object with the supplied query expression.
230 As part of transformations, this function may re-bind the subquery to
231 a different query expression.
232
233 @param qe supplied query expression
234 */
235 void bind(Query_expression *qe);
236
237 /// The query expression of the subquery
238 Query_expression *m_query_expr{nullptr}; // Actual value set in construction
239
240 /// The query result object associated with the query expression
242
243 /// Only relevant for Item_in_subselect; optimized structure used for
244 /// execution in place of running the entire subquery.
246
247 /// cache of used tables
249 /// cache of used tables from subquery only (not including LHS of IN subquery)
251
252 /// allowed number of columns (1 for scalar subqueries)
253 uint m_max_columns{0}; // Irrelevant value, actually set during construction
254 /// where subquery is placed
256
257 private:
258 bool subq_opt_away_processor(uchar *arg) override;
259
260 /// Accumulate properties from underlying query expression
262 /// Accumulate properties from underlying query block
264 /// Accumulate properties from a selected expression within a query block.
265 void accumulate_expression(Item *item);
266 /// Accumulate properties from a condition or GROUP/ORDER within a query
267 /// block.
268 void accumulate_condition(Item *item);
269
270 /// True if value has been assigned to subquery
271 bool m_value_assigned{false};
272 /**
273 Whether or not execution of this subquery has been traced by
274 optimizer tracing already. If optimizer trace option
275 REPEATED_SUBSELECT is disabled, this is used to disable tracing
276 after the first one.
277 */
278 bool m_traced_before{false};
279};
280
281/// Class that represents scalar subquery and row subquery
282
284 public:
285 explicit Item_singlerow_subselect(Query_block *query_block);
286 Item_singlerow_subselect(const POS &pos, Query_block *query_block);
288
289 bool fix_fields(THD *thd, Item **ref) override;
290 void cleanup() override;
291 Subquery_type subquery_type() const override { return SCALAR_SUBQUERY; }
292 bool create_row(const mem_root_deque<Item *> &item_list, Item_cache **row,
293 bool possibly_empty);
294
295 bool is_single_column_scalar_subquery() const override;
296
297 void reset() override;
298 void store(uint i, Item *item);
299 double val_real() override;
300 longlong val_int() override;
301 String *val_str(String *) override;
302 my_decimal *val_decimal(my_decimal *) override;
303 bool val_json(Json_wrapper *result) override;
304 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
305 bool get_time(MYSQL_TIME *ltime) override;
306 bool val_bool() override;
307 enum Item_result result_type() const override;
308 bool resolve_type(THD *) override;
309
310 /*
311 Mark the subquery as having no rows.
312 If there are aggregate functions (in the outer query),
313 we need to generate a NULL row. @c return_zero_rows().
314 */
315 void no_rows_in_result() override;
316
317 uint cols() const override;
318
319 /**
320 @note that this returns the i-th element of the SELECT list.
321 To check for nullability, look at this->is_nullable() and not
322 element_index[i]->is_nullable(), since the selected expressions are
323 always NULL if the subquery is empty.
324 */
325 Item *element_index(uint i) override { return m_row[i]; }
326 Item **addr(uint i) override { return pointer_cast<Item **>(m_row) + i; }
327 bool check_cols(uint c) override;
328 bool null_inside() override;
329 void bring_value() override;
330
331 bool collect_scalar_subqueries(uchar *) override;
332 virtual bool is_maxmin() const { return false; }
333
334 /**
335 Argument for walk method replace_scalar_subquery
336 */
338 ///< subquery to be replaced with ␓field from derived table
340 ///< The derived table of the transform
342 ///< the replacement field
344 ///< The transformed query block.
346 ///< The immediately surrounding query block. This will be the transformed
347 ///< block or a subquery of it
349 ///< True if subquery's selected item contains a COUNT aggregate
350 bool m_add_coalesce{false};
351 ///< Presence of HAVING clause in subquery: Only relevant if
352 ///< \c m_add_coalesce is true
354 ///< Index of field holding value of having clause in derived table's list
355 ///< of fields. Only relevant if \c m_add_coalesce is true
357
359 TABLE *derived, Field *field,
360 Query_block *select, bool add_coalesce,
361 bool add_having_compensation, uint having_idx)
362 : m_target(target),
363 m_derived(derived),
364 m_field(field),
365 m_outer_query_block(select),
366 m_inner_query_block(select),
367 m_add_coalesce(add_coalesce),
368 m_add_having_compensation(add_having_compensation),
369 m_having_idx(having_idx) {}
370 };
371
372 Item *replace_scalar_subquery(uchar *arge) override;
373 /**
374 This method is used to implement a special case of semantic tree
375 rewriting, mandated by a SQL:2003 exception in the specification.
376 The only caller of this method is handle_sql2003_note184_exception(),
377 see the code there for more details.
378 Note that this method breaks the object internal integrity, by
379 removing it's association with the corresponding Query_block,
380 making this object orphan from the parse tree.
381 No other method, beside the destructor, should be called on this
382 object, as it is now invalid.
383 @return the Query_block structure that was given in the constructor.
384 */
386 std::optional<ContainedSubquery> get_contained_subquery(
387 const Query_block *outer_query_block) override;
389
390 private:
391 /// Value cache of a scalar subquery
393 /**
394 Value cache for a row or scalar subquery. In case of a scalar subquery,
395 m_row points directly at m_value. In case of a row subquery, m_row
396 is an array of pointers to individual Item_cache objects.
397 */
398 Item_cache **m_row{nullptr};
399 bool m_no_rows{false}; ///< @c no_rows_in_result
400};
401
402/* used in static ALL/ANY optimization */
404 public:
405 /**
406 Create an Item for use in transformation of quantified comparison
407 predicates that can be evaluated using MAX or MIN aggregation.
408
409 @param parent The quantified comparison predicate that is transformed.
410 @param query_block The query block representing the inner part of the subq.
411 @param max_arg Whether the aggregation is for MAX or MIN.
412 */
414 bool max_arg);
415 void print(const THD *thd, String *str,
416 enum_query_type query_type) const override;
417 void cleanup() override;
418 bool has_values() const { return m_has_values; }
419 void register_value() { m_has_values = true; }
420 void reset_has_values() override { m_has_values = false; }
421 bool is_maxmin() const override { return true; }
422
423 private:
424 bool m_max; ///< True if performing MAX, false if MIN
425 bool m_has_values{false}; ///< Set if we have found at least one row
426};
427
428/// Classes that represent predicates over table subqueries:
429/// [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL
430
431/**
432 Strategy which will be used to handle this subquery: flattening to a
433 semi-join, conversion to a derived table, rewrite of IN to EXISTS...
434 Sometimes the strategy is first only a candidate, then the real decision
435 happens in a second phase. Other times the first decision is final.
436 */
437enum class Subquery_strategy : int {
438 /// Nothing decided yet
440 /// Candidate for rewriting IN(subquery) to EXISTS, or subquery
441 /// materialization
443 /// Candidate for semi-join flattening
445 /// Candidate for rewriting to joined derived table
447 /// Semi-join flattening
448 SEMIJOIN,
449 /// Rewrite to joined derived table
451 /// Evaluate as EXISTS subquery (possibly after rewriting from another type)
453 /// Subquery materialization (HASH_SJ_ENGINE)
455 /// Subquery has been deleted, probably because it was always false
456 DELETED,
457};
458
461
462 public:
463 /**
464 Create an Item that represents an EXISTS subquery predicate, or any
465 quantified comparison predicate that uses the same base class.
466
467 @param pos String representing the parsed item
468 @param query_block First query block of query expression representing
469 the contained subquery.
470 */
471 Item_exists_subselect(const POS &pos, Query_block *query_block);
472
473 explicit Item_exists_subselect(const POS &pos) : super(pos) {}
474
475 // The left-hand expression of the subquery predicate. Unused with EXISTS
476 Item *left_expr{nullptr};
477
478 /// Priority of this predicate in the convert-to-semi-join-nest process.
480 /// Execution strategy chosen for this Item
482 /// Used by the transformation to derived table
484
485 /**
486 Used by subquery optimizations to keep track about where this subquery
487 predicate is located, and whether it is a candidate for transformation.
488 (Table_ref*) 1 - the predicate is an AND-part of the WHERE
489 join nest pointer - the predicate is an AND-part of ON expression
490 of a join nest
491 NULL - for all other locations. It also means that the
492 predicate is not a candidate for transformation.
493 See also THD::emb_on_expr_nest.
494
495 As for the second case above (the join nest pointer), note that this value
496 may change if scalar subqueries are transformed to derived tables,
497 cf. transform_scalar_subqueries_to_join_with_derived, due to the need to
498 build new join nests. The change is performed in Query_block::nest_derived.
499 */
501
503
504 /*
505 Transform subquery predicate to a form that can be executed, e.g.
506 as an EXISTS subquery, or a MAX or MIN aggregation on the subquery.
507
508 This is a virtual function that has implementations for EXISTS, IN
509 and quantified comparison subquery predicates.
510
511 @param thd Thread handle
512 @param[out] transformed Points to transformed representation of the object
513 if unchanged: No transformation was performed
514
515 @returns false if success, true if error
516 */
517 virtual bool transformer(THD *thd, Item **transformed);
518
519 Subquery_type subquery_type() const override { return EXISTS_SUBQUERY; }
520 bool is_bool_func() const override { return true; }
521 void reset() override {
523 m_value = false;
524 }
525
526 enum Item_result result_type() const override { return INT_RESULT; }
527 /*
528 The item is
529 ([NOT] IN/EXISTS) [ IS [NOT] TRUE|FALSE ]
530 */
532 bool with_is_op() const {
533 switch (value_transform) {
534 case BOOL_IS_TRUE:
535 case BOOL_IS_FALSE:
536 case BOOL_NOT_TRUE:
537 case BOOL_NOT_FALSE:
538 return true;
539 default:
540 return false;
541 }
542 }
543 /// True if the IS TRUE/FALSE wasn't explicit in the query
544 bool implicit_is_op = false;
545 Item *truth_transformer(THD *, enum Bool_test test) override;
546 /**
547 Convert result according to value_transform, null value and supplied value
548
549 @param v boolean value from the primitive subquery predicate
550
551 @returns translated boolean value
552
553 @note Operation will possibly take into account and possibly change null
554 value of the Item.
555 */
556 virtual bool return_value(bool v);
557 void apply_is_true() override {
558 const bool had_is = with_is_op();
560 if (!had_is && value_transform == BOOL_IS_TRUE)
561 implicit_is_op = true; // needn't be written by EXPLAIN
562 }
564 bool use_anti_join_transform() const;
565 bool fix_fields(THD *thd, Item **ref) override;
566 longlong val_int() override;
567 double val_real() override;
568 String *val_str(String *) override;
569 my_decimal *val_decimal(my_decimal *) override;
570 bool val_bool() override;
571 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override {
572 return get_date_from_int(ltime, fuzzydate);
573 }
574 bool get_time(MYSQL_TIME *ltime) override { return get_time_from_int(ltime); }
575 bool resolve_type(THD *thd) override;
576 void print(const THD *thd, String *str,
577 enum_query_type query_type) const override;
578
580
581 protected:
582 bool is_semijoin_candidate(THD *thd) const;
583 bool is_derived_candidate(THD *thd) const;
584
585 /// value of this item (boolean: exists/not-exists)
586 bool m_value{false};
587};
588
589/**
590 Representation of IN subquery predicates of the form
591 "left_expr IN (SELECT ...)".
592
593 @details
594 This class has:
595 - A "subquery execution engine" (as a subclass of Item_subselect) that allows
596 it to evaluate subqueries. (and this class participates in execution by
597 having m_was_null variable where part of execution result is stored.
598 - Transformation methods (todo: more on this).
599
600 This class is not used directly, it is "wrapped" into Item_in_optimizer
601 which provides some small bits of subquery evaluation.
602*/
603
606
607 public:
608 Item_in_subselect(const POS &pos, Item *left_expr, Query_block *query_block);
609 Item_in_subselect(const POS &pos, Item *left_expr,
610 PT_subquery *pt_subquery_arg);
611
614
615 bool do_itemize(Parse_context *pc, Item **res) override;
616
617 void cleanup() override;
618 Subquery_type subquery_type() const override { return IN_SUBQUERY; }
619
620 void reset() override {
621 m_value = false;
622 null_value = false;
623 m_was_null = false;
624 }
625 // Whether to ignore UNKNOWN result (only return TRUE or FALSE)
626 bool ignore_unknown() const {
628 }
629 /*
630 @returns true if implementation has to process NULL values.
631 Always true if ignore_unknown() is false.
632 Also true if quantified comparison predicate is ALL.
633 Virtual since IN and ALL/ANY need different checks.
634 */
635 virtual bool process_nulls() const { return value_transform != BOOL_IS_TRUE; }
636 bool return_value(bool v) override;
637
638 bool transformer(THD *thd, Item **transformed) override;
640 Item **transformed);
642 Item **transformed);
643 bool row_value_transformer(THD *thd, Item **transformed);
645 Comp_creator *func);
647 Item_in_optimizer *optimizer);
648 bool subquery_allows_materialization(THD *thd, Query_block *query_block,
649 const Query_block *outer);
650 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
652 Item *compile(Item_analyzer analyzer, uchar **arg_p,
653 Item_transformer transformer, uchar *arg_t) override;
654
655 bool exec(THD *thd) override;
656 longlong val_int() override;
657 double val_real() override;
658 String *val_str(String *) override;
659 my_decimal *val_decimal(my_decimal *) override;
660 bool val_bool() override;
661 bool test_limit();
662 void print(const THD *thd, String *str,
663 enum_query_type query_type) const override;
664 void fix_after_pullout(Query_block *parent_query_block,
665 Query_block *removed_query_block) override;
666 void update_used_tables() override;
667 bool init_left_expr_cache(THD *thd);
668
669 /**
670 Once the decision to use IN->EXISTS has been taken, performs some last
671 steps of this transformation.
672 */
673 bool finalize_exists_transform(THD *thd, Query_block *select);
674 /**
675 Once the decision to use materialization has been taken, performs some
676 last steps of this transformation.
677 */
679 AccessPath *root_access_path() const override;
680 std::optional<ContainedSubquery> get_contained_subquery(
681 const Query_block *outer_query_block) override;
682
684 return m_in2exists_info != nullptr && m_in2exists_info->added_to_where;
685 }
686
687 /// Is reliable only if IN->EXISTS has been done.
689 return m_in2exists_info->dependent_before;
690 }
691
692 bool *get_cond_guard(int i) const {
693 return m_pushed_cond_guards != nullptr ? m_pushed_cond_guards + i : nullptr;
694 }
695 void set_cond_guard_var(int i, bool v) const {
696 if (m_pushed_cond_guards != nullptr) m_pushed_cond_guards[i] = v;
697 }
698
701 friend class Item_in_optimizer;
704
705 /// Used to trigger on/off conditions that were pushed down to subquery
706 bool *m_pushed_cond_guards{nullptr};
707
708 /// Point on NOT/NOP before ALL/SOME subquery
710
711 protected:
712 /**
713 Cache of the left operand of the subquery predicate. Allocated in the
714 runtime memory root, for each execution, thus need not be freed.
715 */
717
718 /// Whether m_left_expr_cache holds a value
720
721 /// The need for expr cache may be optimized away, @sa init_left_expr_cache.
722 bool need_expr_cache{true};
723
724 private:
725 bool mark_as_outer(Item *left_row, size_t col);
726
727 /**
728 In the case of
729
730 x COMP_OP (SELECT1 UNION SELECT2 ...)
731
732 - the subquery transformation is done on SELECT1; this requires wrapping
733 'x' with more Item layers, and injecting that in a condition in SELECT1.
734
735 - the same transformation is done on SELECT2; but the wrapped 'x' doesn't
736 need to be created again, the one created for SELECT1 could be reused
737
738 - to achieve this, the wrapped 'x' is stored in member
739 'm_injected_left_expr' when it is created for SELECT1, and is later
740 reused for SELECT2.
741
742 This will refer to a cached value which is reevaluated once for each
743 candidate row, cf. setup in #single_value_transformer.
744 */
746
747 bool m_was_null{false};
748
749 /**
750 This bundles several pieces of information useful when doing the
751 IN->EXISTS transform. If this transform has not been done, pointer is
752 NULL.
753 */
755 /**
756 True: if IN->EXISTS has been done and has added a condition to the
757 subquery's WHERE clause.
758 */
760 /**
761 True: if subquery was dependent (correlated) before IN->EXISTS
762 was done.
763 */
765 /**
766 True: if subquery was dependent (correlated) after IN->EXISTS
767 was done.
768 */
770 } *m_in2exists_info{nullptr};
771
773
774 bool val_bool_naked();
775};
776
777/**
778 Class that represents a quantified comparison predicate.
779
780 expression comp-op ANY ( subquery )
781 expression comp-op ALL ( subquery )
782
783 Note that the special cases = ANY (aka IN) and <> ALL (aka NOT IN)
784 are handled by the base class Item_in_subselect.
785*/
787 public:
790 bool all);
791
792 Subquery_type subquery_type() const override {
794 }
796
797 Item *truth_transformer(THD *, enum Bool_test test) override;
798 void apply_is_true() override {
799 implicit_is_op = true;
802 } else if (value_transform == BOOL_NEGATED) {
804 }
805 }
806 bool process_nulls() const override {
807 return !ignore_unknown() || m_all_subquery;
808 }
809 bool eqne_op() const;
810 bool return_value(bool v) override;
811
812 bool transformer(THD *thd, Item **transformed) override;
813 void print(const THD *thd, String *str,
814 enum_query_type query_type) const override;
815
816 private:
817 /// The original source for the comparison function
819 /// The comparison function generator, possibly inverted by NOT
821 /// Whether ALL or ANY subquery
823 /// Used to generate the correct comparison function
824 bool m_inverted{false};
825};
826
827/**
828 A subquery execution engine that evaluates the subquery by doing index
829 lookups in a single table's index.
830
831 This engine is used to resolve subqueries in forms
832
833 outer_expr IN (SELECT tbl.key FROM tbl WHERE subq_where)
834
835 or, row-based:
836
837 (oe1, .. oeN) IN (SELECT key_part1, ... key_partK
838 FROM tbl WHERE subqwhere)
839
840 i.e. the subquery is a single table SELECT without GROUP BY, aggregate
841 functions, etc.
842*/
844 protected:
845 Query_result_union *result = nullptr; /* results storage class */
846 /// Table which is read, using one of eq_ref, ref, ref_or_null.
847 TABLE *table{nullptr};
851 Item *m_cond; ///< The WHERE condition of the subquery
852 ulonglong m_hash; ///< Hash value calculated by RefIterator, when needed.
853 /*
854 The "having" clause. This clause (further referred to as "artificial
855 having") was inserted by subquery transformation code. It contains
856 Item(s) that have a side-effect: they record whether the subquery has
857 produced a row with NULL certain components. We need to use it for cases
858 like
859 (oe1, oe2) IN (SELECT t.key, t.no_key FROM t1)
860 where we do index lookup on t.key=oe1 but need also to check if there
861 was a row such that t.no_key IS NULL.
862 */
864
865 Item_in_subselect *item; /* item that uses this engine */
866
867 public:
869
871 const Index_lookup &ref,
872 enum join_type join_type,
874 Item *having)
875 : table(table),
877 ref(ref),
879 m_cond(where),
880 m_having(having),
881 item(subs) {}
883 virtual bool exec(THD *thd);
884 virtual void print(const THD *thd, String *str, enum_query_type query_type);
886 virtual void cleanup() {}
887 virtual void create_iterators(THD *) {}
888};
889
890/*
891 This function is actually defined in sql_parse.cc, but it depends on
892 chooser_compare_func_creator defined in this file.
893 */
894Item *all_any_subquery_creator(THD *thd, const POS &pos, Item *left_expr,
896 Query_block *select);
897
898/**
899 Compute an IN predicate via a hash semi-join. The subquery is materialized
900 during the first evaluation of the IN predicate. The IN predicate is executed
901 via the functionality inherited from subselect_indexsubquery_engine.
902*/
903
905 private:
906 /* true if the subquery was materialized into a temp table. */
908 // true if we know for sure that there are zero rows in the table.
909 // Set only after is_materialized is true.
910 bool has_zero_rows = false;
911 /**
912 Existence of inner NULLs in materialized table:
913 By design, other values than IRRELEVANT_OR_FALSE are possible only if the
914 subquery has only one inner expression.
915 */
917 /// none, or they don't matter
919 /// they matter, and we don't know yet if they exists
921 /// they matter, and we know there exists at least one.
922 NEX_TRUE = 2
923 };
928
929 /// Saved result object, must be restored after use
931
932 public:
934 Query_expression *query_expr)
936 in_predicate, nullptr, nullptr),
937 is_materialized(false),
938 m_query_expr(query_expr) {}
939 ~subselect_hash_sj_engine() override;
940
941 bool setup(THD *thd, const mem_root_deque<Item *> &tmp_columns);
942 void cleanup() override;
943 bool exec(THD *thd) override;
944 void print(const THD *thd, String *str, enum_query_type query_type) override;
945 enum_engine_type engine_type() const override { return HASH_SJ_ENGINE; }
946
947 TABLE *get_table() const { return table; }
948 const Index_lookup &index_lookup() const { return ref; }
949 enum join_type get_join_type() const { return type; }
951 void create_iterators(THD *thd) override;
952};
953
954/**
955 Removes every predicate injected by IN->EXISTS.
956
957 This function is different from others:
958 - it wants to remove all traces of IN->EXISTS (for
959 materialization)
960 - remove_subq_pushed_predicates() and remove_additional_cond() want to
961 remove only the conditions of IN->EXISTS which index lookup already
962 satisfies (they are just an optimization).
963
964 If there are no in2exists conditions, it will return the exact same
965 pointer. If it returns a new Item, the old Item is left alone, so it
966 can be reused in other settings.
967
968 @param conds Condition; may be nullptr.
969 @returns new condition
970 */
972
973/// @returns whether the item is a quantified comparison predicate
975
976#endif /* ITEM_SUBSELECT_INCLUDED */
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:247
Abstract factory interface for creating comparison predicates.
Definition: item_cmpfunc.h:533
Definition: field.h:573
Class that represents a quantified comparison predicate.
Definition: item_subselect.h:786
Comp_creator * m_compare_func
The comparison function generator, possibly inverted by NOT.
Definition: item_subselect.h:820
bool transformer(THD *thd, Item **transformed) override
Definition: item_subselect.cc:3103
bool return_value(bool v) override
ALL and ANY subquery predicates are wrapped in an Item_func_not_all or Item_func_nop_all object that ...
Definition: item_subselect.cc:1430
Item_allany_subselect(const POS &pos, Item *left_expr, chooser_compare_func_creator fc, Query_block *select, bool all)
Definition: item_subselect.cc:1516
Subquery_type subquery_type() const override
Definition: item_subselect.h:792
Comp_creator * compare_func() const
Definition: item_subselect.h:795
bool eqne_op() const
Definition: item_subselect.cc:3135
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:3143
bool process_nulls() const override
Definition: item_subselect.h:806
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:798
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:3081
chooser_compare_func_creator m_func_creator
The original source for the comparison function.
Definition: item_subselect.h:818
bool m_all_subquery
Whether ALL or ANY subquery.
Definition: item_subselect.h:822
bool m_inverted
Used to generate the correct comparison function.
Definition: item_subselect.h:824
Definition: item.h:6804
Definition: item_subselect.h:459
enum_condition_context outer_condition_context
Used by the transformation to derived table.
Definition: item_subselect.h:483
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:557
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1532
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.h:571
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1863
bool m_value
value of this item (boolean: exists/not-exists)
Definition: item_subselect.h:586
double val_real() override
Definition: item_subselect.cc:1849
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.h:574
bool implicit_is_op
True if the IS TRUE/FALSE wasn't explicit in the query.
Definition: item_subselect.h:544
bool is_semijoin_candidate(THD *thd) const
Definition: item_subselect.cc:1571
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:1446
longlong val_int() override
Definition: item_subselect.cc:1851
bool is_derived_candidate(THD *thd) const
Definition: item_subselect.cc:1667
Subquery_strategy strategy
Execution strategy chosen for this Item.
Definition: item_subselect.h:481
Item_exists_subselect(const POS &pos, Query_block *query_block)
Create an Item that represents an EXISTS subquery predicate, or any quantified comparison predicate t...
Definition: item_subselect.cc:1341
Item * left_expr
Definition: item_subselect.h:476
virtual bool return_value(bool v)
Convert result according to value_transform, null value and supplied value.
Definition: item_subselect.cc:1380
bool val_bool() override
Definition: item_subselect.cc:1887
int sj_convert_priority
Priority of this predicate in the convert-to-semi-join-nest process.
Definition: item_subselect.h:479
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:521
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1354
virtual bool transformer(THD *thd, Item **transformed)
Definition: item_subselect.cc:1554
bool with_is_op() const
Definition: item_subselect.h:532
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:2819
enum Bool_test value_transform
Definition: item_subselect.h:531
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:502
Subquery_type subquery_type() const override
Definition: item_subselect.h:519
bool allow_table_subquery_transform() const
Helper for is_semijoin_candidate() and is_derived_candidate().
Definition: item_subselect.cc:1797
Item_subselect super
Definition: item_subselect.h:460
bool is_bool_func() const override
Definition: item_subselect.h:520
Table_ref * embedding_join_nest
Used by subquery optimizations to keep track about where this subquery predicate is located,...
Definition: item_subselect.h:500
Item_exists_subselect(const POS &pos)
Definition: item_subselect.h:473
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1880
bool use_anti_join_transform() const
Definition: item_subselect.cc:1829
enum Item_result result_type() const override
Definition: item_subselect.h:526
Definition: item_cmpfunc.h:942
Definition: item_cmpfunc.h:500
Representation of IN subquery predicates of the form "left_expr IN (SELECT ...)".
Definition: item_subselect.h:604
Item_in_subselect(const POS &pos, Item *left_expr, Query_block *query_block)
Definition: item_subselect.cc:1480
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:2890
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1939
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:793
double val_real() override
Definition: item_subselect.cc:1896
struct Item_in_subselect::In2exists_info nullptr
virtual bool process_nulls() const
Definition: item_subselect.h:635
bool m_left_expr_cache_filled
Whether m_left_expr_cache holds a value.
Definition: item_subselect.h:719
bool single_value_transformer(THD *thd, Comp_creator *func, Item **transformed)
Transform a single-column IN/ALL/ANY subquery predicate.
Definition: item_subselect.cc:1975
void set_cond_guard_var(int i, bool v) const
Definition: item_subselect.h:695
bool row_value_transformer(THD *thd, Item **transformed)
Transform a multi-column IN/ALL/ANY subquery predicate.
Definition: item_subselect.cc:2415
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:2948
Item_func_not_all * m_upper_item
Point on NOT/NOP before ALL/SOME subquery.
Definition: item_subselect.h:709
bool need_expr_cache
The need for expr cache may be optimized away,.
Definition: item_subselect.h:722
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:503
bool do_itemize(Parse_context *pc, Item **res) override
The core function that does the actual itemization.
Definition: item_subselect.cc:1503
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:2777
Item_in_subselect(const POS &pos)
Definition: item_subselect.h:612
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:620
List< Cached_item > * m_left_expr_cache
Cache of the left operand of the subquery predicate.
Definition: item_subselect.h:716
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:455
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:786
bool * m_pushed_cond_guards
Used to trigger on/off conditions that were pushed down to subquery.
Definition: item_subselect.h:706
bool dependent_before_in2exists() const
Is reliable only if IN->EXISTS has been done.
Definition: item_subselect.h:688
AccessPath * root_access_path() const override
Definition: item_subselect.cc:594
PT_subquery * pt_subselect
Definition: item_subselect.h:772
longlong val_int() override
Definition: item_subselect.cc:1903
bool return_value(bool v) override
Same as for Item_exists_subselect(), except it has to process NULL values.
Definition: item_subselect.cc:1390
bool * get_cond_guard(int i) const
Definition: item_subselect.h:692
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:2480
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:462
bool val_bool() override
Definition: item_subselect.cc:1917
bool m_was_null
Definition: item_subselect.h:747
bool init_left_expr_cache(THD *thd)
Initialize the cache of the left operand of the IN predicate.
Definition: item_subselect.cc:2915
bool quantified_comp_transformer(THD *thd, Comp_creator *func, Item **transformed)
Perform transformation of quantified comparison predicates (ie.
Definition: item_subselect.cc:2691
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:562
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1910
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_subselect.cc:2897
bool in2exists_added_to_where() const
Definition: item_subselect.h:683
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:780
Item_exists_subselect super
Definition: item_subselect.h:605
Subquery_type subquery_type() const override
Definition: item_subselect.h:618
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:2200
bool test_limit()
Definition: item_subselect.cc:1474
bool ignore_unknown() const
Definition: item_subselect.h:626
bool val_bool_naked()
Definition: item_subselect.cc:1924
Item_ref * m_injected_left_expr
In the case of.
Definition: item_subselect.h:745
bool exec(THD *thd) override
Definition: item_subselect.cc:809
bool transformer(THD *thd, Item **transformed) override
Definition: item_subselect.cc:2675
Definition: item_cmpfunc.h:2367
Definition: item_subselect.h:403
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1141
bool m_has_values
Set if we have found at least one row.
Definition: item_subselect.h:425
bool is_maxmin() const override
Definition: item_subselect.h:421
bool m_max
True if performing MAX, false if MIN.
Definition: item_subselect.h:424
void reset_has_values() override
Used by max/min subquery to initialize value presence registration mechanism.
Definition: item_subselect.h:420
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:1134
bool has_values() const
Definition: item_subselect.h:418
void register_value()
Definition: item_subselect.h:419
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:1118
Definition: item.h:6346
Definition: item.h:5898
Item with result field.
Definition: item.h:5833
Class that represents scalar subquery and row subquery.
Definition: item_subselect.h:283
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:3232
enum Item_result result_type() const override
Definition: item_subselect.cc:1161
void store(uint i, Item *item)
Definition: item_subselect.cc:1152
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:421
bool null_inside() override
Definition: item_subselect.cc:1215
Item ** addr(uint i) override
Definition: item_subselect.h:326
double val_real() override
Definition: item_subselect.cc:1229
bool resolve_type(THD *) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1166
void no_rows_in_result() override
Definition: item_subselect.cc:1198
bool val_json(Json_wrapper *result) override
Get a JSON value from an Item.
Definition: item_subselect.cc:1274
Item_cache ** m_row
Value cache for a row or scalar subquery.
Definition: item_subselect.h:398
bool m_no_rows
no_rows_in_result
Definition: item_subselect.h:399
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.cc:1147
Subquery_type subquery_type() const override
Definition: item_subselect.h:291
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.cc:1285
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:3290
longlong val_int() override
Definition: item_subselect.cc:1240
uint cols() const override
Definition: item_subselect.cc:3512
virtual bool is_maxmin() const
Definition: item_subselect.h:332
bool is_single_column_scalar_subquery() const override
Definition: item_subselect.cc:1157
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:353
Item * element_index(uint i) override
Definition: item_subselect.h:325
Item_singlerow_subselect()
Definition: item_subselect.h:287
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:933
bool collect_scalar_subqueries(uchar *) override
Definition: item_subselect.cc:3157
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.cc:1297
String * val_str(String *) override
Definition: item_subselect.cc:1251
bool val_bool() override
Definition: item_subselect.cc:1308
void bring_value() override
Definition: item_subselect.cc:1222
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:3411
bool check_cols(uint c) override
Definition: item_subselect.cc:1207
my_decimal * val_decimal(my_decimal *) override
Definition: item_subselect.cc:1262
Item_cache * m_value
Value cache of a scalar subquery.
Definition: item_subselect.h:392
Base class that is common to all subqueries and subquery predicates.
Definition: item_subselect.h:80
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:245
Item * replace_item_view_ref(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:3395
void set_value_assigned()
Definition: item_subselect.h:156
bool clean_up_after_removal(uchar *arg) override
Clean up after removing the subquery from the item tree.
Definition: item_subselect.cc:3041
bool is_evaluated() const
Definition: item_subselect.cc:3139
enum_parsing_context m_parsing_place
where subquery is placed
Definition: item_subselect.h:255
bool collect_subqueries(uchar *) override
Definition: item_subselect.cc:3074
table_map used_tables() const override
Definition: item_subselect.h:164
void accumulate_expression(Item *item)
Accumulate properties from a selected expression within a query block.
Definition: item_subselect.cc:287
void accumulate_used_tables(table_map add_tables)
Accumulate used tables.
Definition: item_subselect.h:123
Query_expression * m_query_expr
The query expression of the subquery.
Definition: item_subselect.h:238
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:200
table_map subquery_used_tables() const
Definition: item_subselect.h:167
bool is_uncacheable() const
Definition: item_subselect.cc:3517
void accumulate_properties()
Accumulate properties from underlying query expression.
Definition: item_subselect.cc:223
virtual bool exec(THD *thd)
Definition: item_subselect.cc:687
Query_expression * query_expr() const
Definition: item_subselect.h:84
enum_engine_type
Definition: item_subselect.h:103
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:103
@ HASH_SJ_ENGINE
Definition: item_subselect.h:103
@ OTHER_ENGINE
Definition: item_subselect.h:103
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:885
Subquery_type
Definition: item_subselect.h:114
@ ALL_SUBQUERY
comp-op ALL quantified comparison predicate
Definition: item_subselect.h:118
@ IN_SUBQUERY
[NOT] IN subquery predicate
Definition: item_subselect.h:117
@ SCALAR_SUBQUERY
Scalar or row subquery.
Definition: item_subselect.h:115
@ ANY_SUBQUERY
comp-op ANY quantified comparison predicate
Definition: item_subselect.h:119
@ EXISTS_SUBQUERY
[NOT] EXISTS subquery predicate
Definition: item_subselect.h:116
void set_contextualized()
For Item_subselect constructor with POS parameter, the contextualized field must be transitioned expl...
Definition: item_subselect.h:90
bool explain_subquery_checker(uchar **arg) override
Register subquery to the table where it is used within a condition.
Definition: item_subselect.cc:680
bool m_value_assigned
True if value has been assigned to subquery.
Definition: item_subselect.h:271
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:864
enum_parsing_context place()
Definition: item_subselect.h:193
virtual void reset()
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:151
Item * replace_item_field(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:3385
join_type get_join_type() const
Definition: item_subselect.cc:333
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:100
void accumulate_condition(Item *item)
Accumulate properties from a condition or GROUP/ORDER within a query block.
Definition: item_subselect.cc:298
virtual AccessPath * root_access_path() const
Definition: item_subselect.h:112
void create_iterators(THD *thd)
Definition: item_subselect.cc:303
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:338
Query_result_interceptor * m_query_result
The query result object associated with the query expression.
Definition: item_subselect.h:241
table_map m_subquery_used_tables
cache of used tables from subquery only (not including LHS of IN subquery)
Definition: item_subselect.h:250
const TABLE * get_table() const
Definition: item_subselect.cc:323
enum Type type() const override
Definition: item_subselect.cc:862
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:615
void set_indexsubquery_engine(subselect_indexsubquery_engine *eng)
Definition: item_subselect.h:173
void bind(Query_expression *qe)
Bind this subquery object with the supplied query expression.
Definition: item_subselect.cc:167
void reset_value_assigned()
Definition: item_subselect.h:157
bool contains_outer_references() const
Return whether this subquery references any tables in the directly containing query block,...
Definition: item_subselect.h:131
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:165
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_subselect.cc:876
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:659
Item_subselect()
Definition: item_subselect.h:226
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_subselect.h:159
const Index_lookup & index_lookup() const
Definition: item_subselect.cc:328
enum_engine_type engine_type() const
Definition: item_subselect.cc:309
bool is_value_assigned() const
Definition: item_subselect.h:155
Item_result_field super
Definition: item_subselect.h:81
bool m_traced_before
Whether or not execution of this subquery has been traced by optimizer tracing already.
Definition: item_subselect.h:278
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:3013
virtual void reset_has_values()
Used by max/min subquery to initialize value presence registration mechanism.
Definition: item_subselect.h:188
bool subq_opt_away_processor(uchar *arg) override
Mark the subquery as optimized away, for EXPLAIN.
Definition: item_subselect.cc:3025
uint m_max_columns
allowed number of columns (1 for scalar subqueries)
Definition: item_subselect.h:253
virtual bool is_single_column_scalar_subquery() const
Definition: item_subselect.h:142
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:760
Item_subselect(const POS &pos)
Definition: item_subselect.h:227
table_map m_used_tables_cache
cache of used tables
Definition: item_subselect.h:248
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:930
void set_subquery()
Set the "has subquery" property.
Definition: item.h:3443
bool null_value
True if item is null.
Definition: item.h:3716
Bool_test
< Modifier for result transformation
Definition: item.h:1008
@ BOOL_NOT_FALSE
Definition: item.h:1013
@ BOOL_NOT_TRUE
Definition: item.h:1012
@ BOOL_IS_TRUE
Definition: item.h:1009
@ BOOL_IS_FALSE
Definition: item.h:1010
@ BOOL_IDENTITY
Definition: item.h:1015
@ BOOL_NEGATED
Definition: item.h:1016
bool get_date_from_int(MYSQL_TIME *ltime, my_time_flags_t flags)
Convert val_int() to date in MYSQL_TIME.
Definition: item.cc:1589
bool update_null_value()
Make sure the null_value member has a correct value.
Definition: item.cc:7539
bool get_time_from_int(MYSQL_TIME *ltime)
Convert val_int() to time in MYSQL_TIME.
Definition: item.cc:1676
Definition: sql_optimizer.h:133
Abstraction for accessing JSON values irrespective of whether they are (started out as) binary JSON v...
Definition: json_dom.h:1150
Definition: sql_list.h:494
Definition: parse_tree_nodes.h:1809
Base class for parse tree nodes (excluding the Parse_tree_root hierarchy)
Definition: parse_tree_node_base.h:231
bool contextualized
Definition: parse_tree_node_base.h:240
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1174
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:638
Definition: item_subselect.cc:1319
Definition: query_result.h:191
Query result class for scalar and row subqueries.
Definition: item_subselect.cc:107
Base class for result from a subquery.
Definition: query_result.h:340
Definition: sql_union.h:40
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:167
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Definition: table.h:2904
Object containing parameters used when creating and using temporary tables.
Definition: temp_table_param.h:97
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
my_decimal class limits 'decimal_t' type to what we need in MySQL.
Definition: my_decimal.h:96
Compute an IN predicate via a hash semi-join.
Definition: item_subselect.h:904
void create_iterators(THD *thd) override
Definition: item_subselect.cc:3755
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:3988
nulls_exist
Existence of inner NULLs in materialized table: By design, other values than IRRELEVANT_OR_FALSE are ...
Definition: item_subselect.h:916
@ NEX_TRUE
they matter, and we know there exists at least one.
Definition: item_subselect.h:922
@ NEX_UNKNOWN
they matter, and we don't know yet if they exists
Definition: item_subselect.h:920
@ NEX_IRRELEVANT_OR_FALSE
none, or they don't matter
Definition: item_subselect.h:918
void cleanup() override
Cleanup performed after each execution.
Definition: item_subselect.cc:3833
unique_ptr_destroy_only< RowIterator > m_iterator
Definition: item_subselect.h:926
subselect_hash_sj_engine(Item_in_subselect *in_predicate, Query_expression *query_expr)
Definition: item_subselect.h:933
TABLE * get_table() const
Definition: item_subselect.h:947
~subselect_hash_sj_engine() override
Definition: item_subselect.cc:3822
Query_result_interceptor * saved_result
Saved result object, must be restored after use.
Definition: item_subselect.h:930
enum nulls_exist mat_table_has_nulls
Definition: item_subselect.h:924
bool is_materialized
Definition: item_subselect.h:907
Query_expression *const m_query_expr
Definition: item_subselect.h:925
bool has_zero_rows
Definition: item_subselect.h:910
const Index_lookup & index_lookup() const
Definition: item_subselect.h:948
bool exec(THD *thd) override
Execute a subquery IN predicate via materialization.
Definition: item_subselect.cc:3868
enum_engine_type engine_type() const override
Definition: item_subselect.h:945
AccessPath * root_access_path() const
Definition: item_subselect.h:950
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:3585
enum join_type get_join_type() const
Definition: item_subselect.h:949
AccessPath * m_root_access_path
Definition: item_subselect.h:927
A subquery execution engine that evaluates the subquery by doing index lookups in a single table's in...
Definition: item_subselect.h:843
Item * m_cond
The WHERE condition of the subquery.
Definition: item_subselect.h:851
TABLE * table
Table which is read, using one of eq_ref, ref, ref_or_null.
Definition: item_subselect.h:847
virtual ~subselect_indexsubquery_engine()=default
virtual void cleanup()
Definition: item_subselect.h:886
virtual bool exec(THD *thd)
Definition: item_subselect.cc:3501
virtual void print(const THD *thd, String *str, enum_query_type query_type)
Definition: item_subselect.cc:3521
virtual void create_iterators(THD *)
Definition: item_subselect.h:887
Item * m_having
Definition: item_subselect.h:863
join_type type
Definition: item_subselect.h:850
enum_engine_type
Definition: item_subselect.h:868
@ HASH_SJ_ENGINE
Definition: item_subselect.h:868
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:868
Index_lookup ref
Definition: item_subselect.h:849
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:870
ulonglong m_hash
Hash value calculated by RefIterator, when needed.
Definition: item_subselect.h:852
virtual enum_engine_type engine_type() const
Definition: item_subselect.h:885
Item_in_subselect * item
Definition: item_subselect.h:865
Table_ref * table_ref
Definition: item_subselect.h:848
Comp_creator *(*)(bool invert) chooser_compare_func_creator
Convenience typedef for a function that returns factories for Item comparators (ie....
Definition: comp_creator.h:39
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:31
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:1053
Item * all_any_subquery_creator(THD *thd, const POS &pos, Item *left_expr, chooser_compare_func_creator cmp, bool all, Query_block *select)
Construct ALL/ANY/SOME subquery Item.
Definition: sql_parse.cc:6766
bool(Item::* Item_analyzer)(uchar **argp)
Definition: item.h:712
Item *(Item::* Item_transformer)(uchar *arg)
Type for transformers used by Item::transform and Item::compile.
Definition: item.h:721
Item * remove_in2exists_conds(Item *conds)
Removes every predicate injected by IN->EXISTS.
Definition: item_subselect.cc:487
Subquery_strategy
Classes that represent predicates over table subqueries: [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL.
Definition: item_subselect.h:437
@ 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:2980
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:480
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:56
unsigned char uchar
Definition: my_inttypes.h:52
long long int longlong
Definition: my_inttypes.h:55
uint64_t table_map
Definition: my_table_map.h:30
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:94
static char * where
Definition: mysqldump.cc:153
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1084
PT & ref(PT *tp)
Definition: tablespace_impl.cc:359
MediaType
Definition: media_type.h:33
std::string join(const detail::range auto &rng, std::string_view delim)
join elements of a range into a string separated by a delimiter.
Definition: string.h:74
int add_tables(PFS_engine_table_share_proxy **, unsigned int) noexcept
Definition: pfs_plugin_table_v1_all_empty.cc:33
enum_parsing_context
Names for different query parse tree parts.
Definition: parse_tree_node_base.h:61
@ CTX_NONE
Empty value.
Definition: parse_tree_node_base.h:62
File containing constants that can be used throughout the server.
constexpr const table_map PSEUDO_TABLE_BITS
Definition: sql_const.h:114
enum_walk
Enumeration for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:289
bool(Item::*)(unsigned char *) Item_processor
Processor type for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:307
enum_condition_context
Enumeration for Query_block::condition_context.
Definition: sql_const.h:313
Common types of the Optimizer, used by optimization and execution.
join_type
Definition: sql_opt_exec_shared.h:186
@ JT_UNKNOWN
Definition: sql_opt_exec_shared.h:188
#define NO_PLAN_IDX
undefined index
Definition: sql_opt_exec_shared.h:55
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:238
Struct used to pass around arguments to/from check_function_as_value_generator.
Definition: item.h:488
int err_code
the error code found during check(if any)
Definition: item.h:495
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:507
Structure used for index-based lookups.
Definition: sql_opt_exec_shared.h:67
This bundles several pieces of information useful when doing the IN->EXISTS transform.
Definition: item_subselect.h:754
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:759
bool dependent_before
True: if subquery was dependent (correlated) before IN->EXISTS was done.
Definition: item_subselect.h:764
bool dependent_after
True: if subquery was dependent (correlated) after IN->EXISTS was done.
Definition: item_subselect.h:769
Argument for walk method replace_scalar_subquery.
Definition: item_subselect.h:337
Query_block * m_outer_query_block
The immediately surrounding query block.
Definition: item_subselect.h:345
Field * m_field
The transformed query block.
Definition: item_subselect.h:343
TABLE * m_derived
the replacement field
Definition: item_subselect.h:341
Scalar_subquery_replacement(Item_singlerow_subselect *target, TABLE *derived, Field *field, Query_block *select, bool add_coalesce, bool add_having_compensation, uint having_idx)
Definition: item_subselect.h:358
Query_block * m_inner_query_block
True if subquery's selected item contains a COUNT aggregate.
Definition: item_subselect.h:348
bool m_add_coalesce
Presence of HAVING clause in subquery: Only relevant if m_add_coalesce is true.
Definition: item_subselect.h:350
Item_singlerow_subselect * m_target
< subquery to be replaced with ␓field from derived table
Definition: item_subselect.h:339
bool m_add_having_compensation
Index of field holding value of having clause in derived table's list of fields.
Definition: item_subselect.h:353
uint m_having_idx
Definition: item_subselect.h:356
argument used by walk method collect_scalar_subqueries ("css")
Definition: item_subselect.h:208
Collect_subq_info(Query_block *owner)
Definition: item_subselect.h:212
Query_block * m_query_block
Definition: item_subselect.h:211
std::vector< Item_subselect * > list
< accumulated all subq (or aggregates) found
Definition: item_subselect.h:210
bool contains(Query_expression *candidate)
Definition: item_subselect.h:213
Definition: mysql_time.h:82
Bison "location" class.
Definition: parse_location.h:43
Environment data for the contextualization phase.
Definition: parse_tree_node_base.h:421
Definition: table.h:1425
Definition: result.h:30
Item_result
Type of the user defined function return slot and arguments.
Definition: udf_registration_types.h:39
@ INT_RESULT
double
Definition: udf_registration_types.h:43
static int all(site_def const *s, node_no node)
Definition: xcom_transport.cc:890