MySQL 8.4.3
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, 2024, Oracle and/or its affiliates.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License, version 2.0,
8 as published by the Free Software Foundation.
9
10 This program is designed to work with certain software (including
11 but not limited to OpenSSL) that is licensed under separate terms,
12 as designated in a particular file or component or in included license
13 documentation. The authors of MySQL hereby grant you an additional
14 permission to link the program and your derivative works with the
15 separately licensed software that they have either included with
16 the program or referenced in the documentation.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License, version 2.0, for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
26
27/// 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 If !=NO_PLAN_IDX: this Item is in the condition attached to the JOIN_TAB
88 having this index in the parent JOIN.
89 */
91
92 // For EXPLAIN.
95
96 // For EXPLAIN. Only valid if engine_type() == HASH_SJ_ENGINE.
97 const TABLE *get_table() const;
98 const Index_lookup &index_lookup() const;
100
101 void create_iterators(THD *thd);
102 virtual AccessPath *root_access_path() const { return nullptr; }
103
105 SCALAR_SUBQUERY, ///< Scalar or row subquery
106 EXISTS_SUBQUERY, ///< [NOT] EXISTS subquery predicate
107 IN_SUBQUERY, ///< [NOT] IN subquery predicate
108 ALL_SUBQUERY, ///< comp-op ALL quantified comparison predicate
109 ANY_SUBQUERY ///< comp-op ANY quantified comparison predicate
110 };
111
112 /// Accumulate used tables
116 }
117
118 virtual Subquery_type subquery_type() const = 0;
119
120 /**
121 @returns whether this subquery is a single column scalar subquery.
122 (Note that scalar and row subqueries are both represented as
123 scalar subqueries, this function can be used to distinguish them)
124 */
125 virtual bool is_single_column_scalar_subquery() const { return false; }
126
127 void cleanup() override;
128 /**
129 Reset state after a single execution of a subquery, useful when a
130 dependent subquery must be evaluated multiple times for varying values
131 of the outer references.
132 This is a lighter cleanup procedure than the one provided by cleanup().
133 */
134 virtual void reset() {
135 m_value_assigned = false;
136 null_value = true;
137 }
138 bool is_value_assigned() const { return m_value_assigned; }
141 enum Type type() const override;
142 bool is_null() override { return update_null_value() || null_value; }
143 bool fix_fields(THD *thd, Item **ref) override;
144 void fix_after_pullout(Query_block *parent_query_block,
145 Query_block *removed_query_block) override;
146 virtual bool exec(THD *thd);
147 table_map used_tables() const override { return m_used_tables_cache; }
148 table_map not_null_tables() const override { return 0; }
149 /// @returns used tables for subquery (excluding any left-hand expression)
151 Item *get_tmp_table_item(THD *thd) override;
152 void update_used_tables() override;
153 void print(const THD *thd, String *str,
154 enum_query_type query_type) const override;
155
158 }
159
160 /*
161 True if this subquery has been already evaluated. Implemented only for
162 single select and union subqueries only.
163 */
164 bool is_evaluated() const;
165 bool is_uncacheable() const;
166
167 /**
168 Used by max/min subquery to initialize value presence registration
169 mechanism. Engine calls this function before re-execution of subquery.
170 */
171 virtual void reset_has_values() {}
172 /**
173 @returns the "place" where this subquery is located in the simply
174 containing query block.
175 */
177
178 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
179 bool explain_subquery_checker(uchar **arg) override;
180 bool inform_item_in_cond_of_tab(uchar *arg) override;
181 bool clean_up_after_removal(uchar *arg) override;
182
183 const char *func_name() const override {
184 assert(0);
185 return "subquery";
186 }
187
190 pointer_cast<Check_function_as_value_generator_parameters *>(args);
191 func_arg->err_code = func_arg->get_unnamed_function_error_code();
192 return true;
193 }
194
195 /// argument used by walk method collect_scalar_subqueries ("css")
197 ///< accumulated all subq (or aggregates) found
198 std::vector<Item_subselect *> list;
201 bool contains(Query_expression *candidate) {
202 for (auto sq : list) {
203 if (sq->m_query_expr == candidate) return true;
204 }
205 return false;
206 }
207 };
208
209 bool collect_subqueries(uchar *) override;
210 Item *replace_item_field(uchar *arg) override;
211 Item *replace_item_view_ref(uchar *arg) override;
212
213 protected:
215 explicit Item_subselect(const POS &pos) : super(pos) { set_subquery(); }
216 /**
217 Bind this subquery object with the supplied query expression.
218 As part of transformations, this function may re-bind the subquery to
219 a different query expression.
220
221 @param qe supplied query expression
222 */
223 void bind(Query_expression *qe);
224
225 /// The query expression of the subquery
226 Query_expression *m_query_expr{nullptr}; // Actual value set in construction
227
228 /// The query result object associated with the query expression
230
231 /// Only relevant for Item_in_subselect; optimized structure used for
232 /// execution in place of running the entire subquery.
234
235 /// cache of used tables
237 /// cache of used tables from subquery only (not including LHS of IN subquery)
239
240 /// allowed number of columns (1 for scalar subqueries)
241 uint m_max_columns{0}; // Irrelevant value, actually set during construction
242 /// where subquery is placed
244
245 private:
246 bool subq_opt_away_processor(uchar *arg) override;
247
248 /// Accumulate properties from underlying query expression
250 /// Accumulate properties from underlying query block
252 /// Accumulate properties from a selected expression within a query block.
253 void accumulate_expression(Item *item);
254 /// Accumulate properties from a condition or GROUP/ORDER within a query
255 /// block.
256 void accumulate_condition(Item *item);
257
258 /// True if value has been assigned to subquery
259 bool m_value_assigned{false};
260 /**
261 Whether or not execution of this subquery has been traced by
262 optimizer tracing already. If optimizer trace option
263 REPEATED_SUBSELECT is disabled, this is used to disable tracing
264 after the first one.
265 */
266 bool m_traced_before{false};
267};
268
269/// Class that represents scalar subquery and row subquery
270
272 public:
275
276 bool fix_fields(THD *thd, Item **ref) override;
277 void cleanup() override;
278 Subquery_type subquery_type() const override { return SCALAR_SUBQUERY; }
279 bool create_row(const mem_root_deque<Item *> &item_list, Item_cache **row,
280 bool possibly_empty);
281
282 bool is_single_column_scalar_subquery() const override;
283
284 void reset() override;
285 void store(uint i, Item *item);
286 double val_real() override;
287 longlong val_int() override;
288 String *val_str(String *) override;
289 my_decimal *val_decimal(my_decimal *) override;
290 bool val_json(Json_wrapper *result) override;
291 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
292 bool get_time(MYSQL_TIME *ltime) override;
293 bool val_bool() override;
294 enum Item_result result_type() const override;
295 bool resolve_type(THD *) override;
296
297 /*
298 Mark the subquery as having no rows.
299 If there are aggregate functions (in the outer query),
300 we need to generate a NULL row. @c return_zero_rows().
301 */
302 void no_rows_in_result() override;
303
304 uint cols() const override;
305
306 /**
307 @note that this returns the i-th element of the SELECT list.
308 To check for nullability, look at this->is_nullable() and not
309 element_index[i]->is_nullable(), since the selected expressions are
310 always NULL if the subquery is empty.
311 */
312 Item *element_index(uint i) override { return m_row[i]; }
313 Item **addr(uint i) override { return pointer_cast<Item **>(m_row) + i; }
314 bool check_cols(uint c) override;
315 bool null_inside() override;
316 void bring_value() override;
317
318 bool collect_scalar_subqueries(uchar *) override;
319 virtual bool is_maxmin() const { return false; }
320
321 /**
322 Argument for walk method replace_scalar_subquery
323 */
325 Item_singlerow_subselect *m_target; ///< subquery to be replaced with field
326 Field *m_field; ///< the replacement field
327 Query_block *m_outer_query_block; ///< The transformed query block.
328 Query_block *m_inner_query_block; ///< The immediately surrounding query
329 ///< block. This will be the transformed
330 ///< block or a subquery of it
331 bool m_add_coalesce{false};
333 Query_block *select, bool add_coalesce)
334 : m_target(target),
335 m_field(field),
336 m_outer_query_block(select),
337 m_inner_query_block(select),
338 m_add_coalesce(add_coalesce) {}
339 };
340
341 Item *replace_scalar_subquery(uchar *arge) override;
342 /**
343 This method is used to implement a special case of semantic tree
344 rewriting, mandated by a SQL:2003 exception in the specification.
345 The only caller of this method is handle_sql2003_note184_exception(),
346 see the code there for more details.
347 Note that this method breaks the object internal integrity, by
348 removing it's association with the corresponding Query_block,
349 making this object orphan from the parse tree.
350 No other method, beside the destructor, should be called on this
351 object, as it is now invalid.
352 @return the Query_block structure that was given in the constructor.
353 */
355 std::optional<ContainedSubquery> get_contained_subquery(
356 const Query_block *outer_query_block) override;
358
359 private:
360 /// Value cache of a scalar subquery
362 /**
363 Value cache for a row or scalar subquery. In case of a scalar subquery,
364 m_row points directly at m_value. In case of a row subquery, m_row
365 is an array of pointers to individual Item_cache objects.
366 */
367 Item_cache **m_row{nullptr};
368 bool m_no_rows{false}; ///< @c no_rows_in_result
369};
370
371/* used in static ALL/ANY optimization */
373 public:
374 /**
375 Create an Item for use in transformation of quantified comparison
376 predicates that can be evaluated using MAX or MIN aggregation.
377
378 @param parent The quantified comparison predicate that is transformed.
379 @param query_block The query block representing the inner part of the subq.
380 @param max_arg Whether the aggregation is for MAX or MIN.
381 */
383 bool max_arg);
384 void print(const THD *thd, String *str,
385 enum_query_type query_type) const override;
386 void cleanup() override;
387 bool has_values() const { return m_has_values; }
388 void register_value() { m_has_values = true; }
389 void reset_has_values() override { m_has_values = false; }
390 bool is_maxmin() const override { return true; }
391
392 private:
393 bool m_max; ///< True if performing MAX, false if MIN
394 bool m_has_values{false}; ///< Set if we have found at least one row
395};
396
397/// Classes that represent predicates over table subqueries:
398/// [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL
399
400/**
401 Strategy which will be used to handle this subquery: flattening to a
402 semi-join, conversion to a derived table, rewrite of IN to EXISTS...
403 Sometimes the strategy is first only a candidate, then the real decision
404 happens in a second phase. Other times the first decision is final.
405 */
406enum class Subquery_strategy : int {
407 /// Nothing decided yet
409 /// Candidate for rewriting IN(subquery) to EXISTS, or subquery
410 /// materialization
412 /// Candidate for semi-join flattening
414 /// Candidate for rewriting to joined derived table
416 /// Semi-join flattening
417 SEMIJOIN,
418 /// Rewrite to joined derived table
420 /// Evaluate as EXISTS subquery (possibly after rewriting from another type)
422 /// Subquery materialization (HASH_SJ_ENGINE)
424 /// Subquery has been deleted, probably because it was always false
425 DELETED,
426};
427
430
431 public:
432 /**
433 Create an Item that represents an EXISTS subquery predicate, or any
434 quantified comparison predicate that uses the same base class.
435
436 @param query_block First query block of query expression representing
437 the contained subquery.
438 */
439 explicit Item_exists_subselect(Query_block *query_block);
440
442
443 explicit Item_exists_subselect(const POS &pos) : super(pos) {}
444
445 // The left-hand expression of the subquery predicate. Unused with EXISTS
446 Item *left_expr{nullptr};
447
448 /// Priority of this predicate in the convert-to-semi-join-nest process.
450 /// Execution strategy chosen for this Item
452 /// Used by the transformation to derived table
454
455 /**
456 Used by subquery optimizations to keep track about where this subquery
457 predicate is located, and whether it is a candidate for transformation.
458 (Table_ref*) 1 - the predicate is an AND-part of the WHERE
459 join nest pointer - the predicate is an AND-part of ON expression
460 of a join nest
461 NULL - for all other locations. It also means that the
462 predicate is not a candidate for transformation.
463 See also THD::emb_on_expr_nest.
464
465 As for the second case above (the join nest pointer), note that this value
466 may change if scalar subqueries are transformed to derived tables,
467 cf. transform_scalar_subqueries_to_join_with_derived, due to the need to
468 build new join nests. The change is performed in Query_block::nest_derived.
469 */
471
473
474 /*
475 Transform subquery predicate to a form that can be executed, e.g.
476 as an EXISTS subquery, or a MAX or MIN aggregation on the subquery.
477
478 This is a virtual function that has implementations for EXISTS, IN
479 and quantified comparison subquery predicates.
480
481 @param thd Thread handle
482 @param[out] transformed Points to transformed representation of the object
483 if unchanged: No transformation was performed
484
485 @returns false if success, true if error
486 */
487 virtual bool transformer(THD *thd, Item **transformed);
488
489 Subquery_type subquery_type() const override { return EXISTS_SUBQUERY; }
490 bool is_bool_func() const override { return true; }
491 void reset() override {
493 m_value = false;
494 }
495
496 enum Item_result result_type() const override { return INT_RESULT; }
497 /*
498 The item is
499 ([NOT] IN/EXISTS) [ IS [NOT] TRUE|FALSE ]
500 */
502 bool with_is_op() const {
503 switch (value_transform) {
504 case BOOL_IS_TRUE:
505 case BOOL_IS_FALSE:
506 case BOOL_NOT_TRUE:
507 case BOOL_NOT_FALSE:
508 return true;
509 default:
510 return false;
511 }
512 }
513 /// True if the IS TRUE/FALSE wasn't explicit in the query
514 bool implicit_is_op = false;
515 Item *truth_transformer(THD *, enum Bool_test test) override;
516 bool translate(bool &null_v, bool v);
517 void apply_is_true() override {
518 const bool had_is = with_is_op();
520 if (!had_is && value_transform == BOOL_IS_TRUE)
521 implicit_is_op = true; // needn't be written by EXPLAIN
522 }
523 /// True if the Item has decided that it can do antijoin
524 bool can_do_aj = false;
526 bool fix_fields(THD *thd, Item **ref) override;
527 longlong val_int() override;
528 double val_real() override;
529 String *val_str(String *) override;
530 my_decimal *val_decimal(my_decimal *) override;
531 bool val_bool() override;
532 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override {
533 return get_date_from_int(ltime, fuzzydate);
534 }
535 bool get_time(MYSQL_TIME *ltime) override { return get_time_from_int(ltime); }
536 bool resolve_type(THD *thd) override;
537 void print(const THD *thd, String *str,
538 enum_query_type query_type) const override;
539
541
542 protected:
543 bool is_semijoin_candidate(THD *thd);
544 bool is_derived_candidate(THD *thd);
545
546 /// value of this item (boolean: exists/not-exists)
547 bool m_value{false};
548
549 /**
550 True if naked IN is allowed to exchange FALSE for UNKNOWN.
551 Because this is about the naked IN, there is no public ignore_unknown(),
552 intentionally, so that callers don't get it wrong.
553 */
554 bool abort_on_null{false};
555};
556
557/**
558 Representation of IN subquery predicates of the form
559 "left_expr IN (SELECT ...)".
560
561 @details
562 This class has:
563 - A "subquery execution engine" (as a subclass of Item_subselect) that allows
564 it to evaluate subqueries. (and this class participates in execution by
565 having m_was_null variable where part of execution result is stored.
566 - Transformation methods (todo: more on this).
567
568 This class is not used directly, it is "wrapped" into Item_in_optimizer
569 which provides some small bits of subquery evaluation.
570*/
571
574
575 public:
577 Item_in_subselect(const POS &pos, Item *left_expr,
578 PT_subquery *pt_subquery_arg);
579
581
582 bool do_itemize(Parse_context *pc, Item **res) override;
583
584 void cleanup() override;
585 Subquery_type subquery_type() const override { return IN_SUBQUERY; }
586
587 void reset() override {
588 m_value = false;
589 null_value = false;
590 m_was_null = false;
591 }
592 bool transformer(THD *thd, Item **transformed) override;
594 Item **transformed);
596 Item **transformed);
597 bool row_value_transformer(THD *thd, Item **transformed);
599 Comp_creator *func);
601 Item_in_optimizer *optimizer);
602 bool subquery_allows_materialization(THD *thd, Query_block *query_block,
603 const Query_block *outer);
604 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
606 Item *compile(Item_analyzer analyzer, uchar **arg_p,
607 Item_transformer transformer, uchar *arg_t) override;
608
609 bool exec(THD *thd) override;
610 longlong val_int() override;
611 double val_real() override;
612 String *val_str(String *) override;
613 my_decimal *val_decimal(my_decimal *) override;
614 bool val_bool() override;
615 bool test_limit();
616 void print(const THD *thd, String *str,
617 enum_query_type query_type) const override;
618 void fix_after_pullout(Query_block *parent_query_block,
619 Query_block *removed_query_block) override;
620 void update_used_tables() override;
621 bool init_left_expr_cache(THD *thd);
622
623 /**
624 Once the decision to use IN->EXISTS has been taken, performs some last
625 steps of this transformation.
626 */
627 bool finalize_exists_transform(THD *thd, Query_block *select);
628 /**
629 Once the decision to use materialization has been taken, performs some
630 last steps of this transformation.
631 */
633 AccessPath *root_access_path() const override;
634 std::optional<ContainedSubquery> get_contained_subquery(
635 const Query_block *outer_query_block) override;
636
638 return m_in2exists_info != nullptr && m_in2exists_info->added_to_where;
639 }
640
641 /// Is reliable only if IN->EXISTS has been done.
643 return m_in2exists_info->dependent_before;
644 }
645
646 bool *get_cond_guard(int i) const {
647 return m_pushed_cond_guards != nullptr ? m_pushed_cond_guards + i : nullptr;
648 }
649 void set_cond_guard_var(int i, bool v) const {
650 if (m_pushed_cond_guards != nullptr) m_pushed_cond_guards[i] = v;
651 }
652
655 friend class Item_in_optimizer;
658
659 /// Used to trigger on/off conditions that were pushed down to subquery
660 bool *m_pushed_cond_guards{nullptr};
661
662 /// Point on NOT/NOP before ALL/SOME subquery
664
665 protected:
666 /**
667 Cache of the left operand of the subquery predicate. Allocated in the
668 runtime memory root, for each execution, thus need not be freed.
669 */
671
672 /// Whether m_left_expr_cache holds a value
674
675 /// The need for expr cache may be optimized away, @sa init_left_expr_cache.
676 bool need_expr_cache{true};
677
678 private:
679 bool mark_as_outer(Item *left_row, size_t col);
680
681 /**
682 In the case of
683
684 x COMP_OP (SELECT1 UNION SELECT2 ...)
685
686 - the subquery transformation is done on SELECT1; this requires wrapping
687 'x' with more Item layers, and injecting that in a condition in SELECT1.
688
689 - the same transformation is done on SELECT2; but the wrapped 'x' doesn't
690 need to be created again, the one created for SELECT1 could be reused
691
692 - to achieve this, the wrapped 'x' is stored in member
693 'm_injected_left_expr' when it is created for SELECT1, and is later
694 reused for SELECT2.
695
696 This will refer to a cached value which is reevaluated once for each
697 candidate row, cf. setup in #single_value_transformer.
698 */
700
701 bool m_was_null{false};
702
703 /**
704 This bundles several pieces of information useful when doing the
705 IN->EXISTS transform. If this transform has not been done, pointer is
706 NULL.
707 */
709 /**
710 True: if IN->EXISTS has been done and has added a condition to the
711 subquery's WHERE clause.
712 */
714 /**
715 True: if subquery was dependent (correlated) before IN->EXISTS
716 was done.
717 */
719 /**
720 True: if subquery was dependent (correlated) after IN->EXISTS
721 was done.
722 */
724 } *m_in2exists_info{nullptr};
725
727
728 bool val_bool_naked();
729};
730
731/**
732 Class that represents a quantified comparison predicate.
733
734 expression comp-op ANY ( subquery )
735 expression comp-op ALL ( subquery )
736
737 Note that the special cases = ANY (aka IN) and <> ALL (aka NOT IN)
738 are handled by the base class Item_in_subselect.
739*/
741 public:
743 Query_block *select, bool all);
744
745 Subquery_type subquery_type() const override {
747 }
748 bool transformer(THD *thd, Item **transformed) override;
749 void print(const THD *thd, String *str,
750 enum_query_type query_type) const override;
751
754 bool m_all;
755};
756
757/**
758 A subquery execution engine that evaluates the subquery by doing index
759 lookups in a single table's index.
760
761 This engine is used to resolve subqueries in forms
762
763 outer_expr IN (SELECT tbl.key FROM tbl WHERE subq_where)
764
765 or, row-based:
766
767 (oe1, .. oeN) IN (SELECT key_part1, ... key_partK
768 FROM tbl WHERE subqwhere)
769
770 i.e. the subquery is a single table SELECT without GROUP BY, aggregate
771 functions, etc.
772*/
774 protected:
775 Query_result_union *result = nullptr; /* results storage class */
776 /// Table which is read, using one of eq_ref, ref, ref_or_null.
777 TABLE *table{nullptr};
781 Item *m_cond; ///< The WHERE condition of the subquery
782 ulonglong m_hash; ///< Hash value calculated by RefIterator, when needed.
783 /*
784 The "having" clause. This clause (further referred to as "artificial
785 having") was inserted by subquery transformation code. It contains
786 Item(s) that have a side-effect: they record whether the subquery has
787 produced a row with NULL certain components. We need to use it for cases
788 like
789 (oe1, oe2) IN (SELECT t.key, t.no_key FROM t1)
790 where we do index lookup on t.key=oe1 but need also to check if there
791 was a row such that t.no_key IS NULL.
792 */
794
795 Item_in_subselect *item; /* item that uses this engine */
796
797 public:
799
801 const Index_lookup &ref,
802 enum join_type join_type,
804 Item *having)
805 : table(table),
807 ref(ref),
809 m_cond(where),
810 m_having(having),
811 item(subs) {}
813 virtual bool exec(THD *thd);
814 virtual void print(const THD *thd, String *str, enum_query_type query_type);
816 virtual void cleanup() {}
817 virtual void create_iterators(THD *) {}
818};
819
820/*
821 This function is actually defined in sql_parse.cc, but it depends on
822 chooser_compare_func_creator defined in this file.
823 */
826 Query_block *select);
827
828/**
829 Compute an IN predicate via a hash semi-join. The subquery is materialized
830 during the first evaluation of the IN predicate. The IN predicate is executed
831 via the functionality inherited from subselect_indexsubquery_engine.
832*/
833
835 private:
836 /* true if the subquery was materialized into a temp table. */
838 // true if we know for sure that there are zero rows in the table.
839 // Set only after is_materialized is true.
840 bool has_zero_rows = false;
841 /**
842 Existence of inner NULLs in materialized table:
843 By design, other values than IRRELEVANT_OR_FALSE are possible only if the
844 subquery has only one inner expression.
845 */
847 /// none, or they don't matter
849 /// they matter, and we don't know yet if they exists
851 /// they matter, and we know there exists at least one.
852 NEX_TRUE = 2
853 };
858
859 /// Saved result object, must be restored after use
861
862 public:
864 Query_expression *query_expr)
866 in_predicate, nullptr, nullptr),
867 is_materialized(false),
868 m_query_expr(query_expr) {}
869 ~subselect_hash_sj_engine() override;
870
871 bool setup(THD *thd, const mem_root_deque<Item *> &tmp_columns);
872 void cleanup() override;
873 bool exec(THD *thd) override;
874 void print(const THD *thd, String *str, enum_query_type query_type) override;
875 enum_engine_type engine_type() const override { return HASH_SJ_ENGINE; }
876
877 TABLE *get_table() const { return table; }
878 const Index_lookup &index_lookup() const { return ref; }
879 enum join_type get_join_type() const { return type; }
881 void create_iterators(THD *thd) override;
882};
883
884/**
885 Removes every predicate injected by IN->EXISTS.
886
887 This function is different from others:
888 - it wants to remove all traces of IN->EXISTS (for
889 materialization)
890 - remove_subq_pushed_predicates() and remove_additional_cond() want to
891 remove only the conditions of IN->EXISTS which index lookup already
892 satisfies (they are just an optimization).
893
894 If there are no in2exists conditions, it will return the exact same
895 pointer. If it returns a new Item, the old Item is left alone, so it
896 can be reused in other settings.
897
898 @param conds Condition; may be nullptr.
899 @returns new condition
900 */
902
903/// @returns whether the item is a quantified comparison predicate
905
906#endif /* ITEM_SUBSELECT_INCLUDED */
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:251
Abstract factory interface for creating comparison predicates.
Definition: item_cmpfunc.h:525
Definition: field.h:575
Class that represents a quantified comparison predicate.
Definition: item_subselect.h:740
Item_allany_subselect(Item *left_expr, chooser_compare_func_creator fc, Query_block *select, bool all)
Definition: item_subselect.cc:1452
bool transformer(THD *thd, Item **transformed) override
Definition: item_subselect.cc:2918
bool m_all
Definition: item_subselect.h:754
Subquery_type subquery_type() const override
Definition: item_subselect.h:745
Comp_creator * m_func
Definition: item_subselect.h:753
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:2928
chooser_compare_func_creator m_func_creator
Definition: item_subselect.h:752
Definition: item.h:6857
Definition: item_subselect.h:428
enum_condition_context outer_condition_context
Used by the transformation to derived table.
Definition: item_subselect.h:453
bool is_semijoin_candidate(THD *thd)
Definition: item_subselect.cc:1508
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:517
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1469
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.h:532
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1717
bool m_value
value of this item (boolean: exists/not-exists)
Definition: item_subselect.h:547
Item_exists_subselect()
Definition: item_subselect.h:441
double val_real() override
Definition: item_subselect.cc:1703
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.h:535
bool implicit_is_op
True if the IS TRUE/FALSE wasn't explicit in the query.
Definition: item_subselect.h:514
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:1380
longlong val_int() override
Definition: item_subselect.cc:1705
Subquery_strategy strategy
Execution strategy chosen for this Item.
Definition: item_subselect.h:451
Item * left_expr
Definition: item_subselect.h:446
bool val_bool() override
Definition: item_subselect.cc:1741
int sj_convert_priority
Priority of this predicate in the convert-to-semi-join-nest process.
Definition: item_subselect.h:449
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:491
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1322
bool abort_on_null
True if naked IN is allowed to exchange FALSE for UNKNOWN.
Definition: item_subselect.h:554
virtual bool transformer(THD *thd, Item **transformed)
Definition: item_subselect.cc:1491
bool is_derived_candidate(THD *thd)
Definition: item_subselect.cc:1599
bool can_do_aj
True if the Item has decided that it can do antijoin.
Definition: item_subselect.h:524
bool with_is_op() const
Definition: item_subselect.h:502
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:2657
enum Bool_test value_transform
Definition: item_subselect.h:501
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:472
Subquery_type subquery_type() const override
Definition: item_subselect.h:489
Item_subselect super
Definition: item_subselect.h:429
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:1343
bool is_bool_func() const override
Definition: item_subselect.h:490
Table_ref * embedding_join_nest
Used by subquery optimizations to keep track about where this subquery predicate is located,...
Definition: item_subselect.h:470
bool choose_semijoin_or_antijoin()
Helper for is_semijoin_candidate() and is_derived_candidate().
Definition: item_subselect.cc:1666
Item_exists_subselect(const POS &pos)
Definition: item_subselect.h:443
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1734
enum Item_result result_type() const override
Definition: item_subselect.h:496
Definition: item_cmpfunc.h:920
Definition: item_cmpfunc.h:492
Representation of IN subquery predicates of the form "left_expr IN (SELECT ...)".
Definition: item_subselect.h:572
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:2727
my_decimal * val_decimal(my_decimal *) override
Return the result of EXISTS as a decimal value.
Definition: item_subselect.cc:1794
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:770
double val_real() override
Definition: item_subselect.cc:1752
struct Item_in_subselect::In2exists_info nullptr
bool m_left_expr_cache_filled
Whether m_left_expr_cache holds a value.
Definition: item_subselect.h:673
bool single_value_transformer(THD *thd, Comp_creator *func, Item **transformed)
Transform a single-column IN/ALL/ANY subquery predicate.
Definition: item_subselect.cc:1830
void set_cond_guard_var(int i, bool v) const
Definition: item_subselect.h:649
bool row_value_transformer(THD *thd, Item **transformed)
Transform a multi-column IN/ALL/ANY subquery predicate.
Definition: item_subselect.cc:2259
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:2785
Item_func_not_all * m_upper_item
Point on NOT/NOP before ALL/SOME subquery.
Definition: item_subselect.h:663
bool need_expr_cache
The need for expr cache may be optimized away,.
Definition: item_subselect.h:676
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:481
bool do_itemize(Parse_context *pc, Item **res) override
The core function that does the actual itemization.
Definition: item_subselect.cc:1439
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:2615
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:587
List< Cached_item > * m_left_expr_cache
Cache of the left operand of the subquery predicate.
Definition: item_subselect.h:670
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:433
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:763
bool * m_pushed_cond_guards
Used to trigger on/off conditions that were pushed down to subquery.
Definition: item_subselect.h:660
bool dependent_before_in2exists() const
Is reliable only if IN->EXISTS has been done.
Definition: item_subselect.h:642
AccessPath * root_access_path() const override
Definition: item_subselect.cc:572
PT_subquery * pt_subselect
Definition: item_subselect.h:726
longlong val_int() override
Definition: item_subselect.cc:1759
bool * get_cond_guard(int i) const
Definition: item_subselect.h:646
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:2324
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:440
bool val_bool() override
Definition: item_subselect.cc:1773
bool m_was_null
Definition: item_subselect.h:701
bool init_left_expr_cache(THD *thd)
Initialize the cache of the left operand of the IN predicate.
Definition: item_subselect.cc:2752
bool quantified_comp_transformer(THD *thd, Comp_creator *func, Item **transformed)
Perform transformation of quantified comparison predicates (ie.
Definition: item_subselect.cc:2534
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:540
String * val_str(String *) override
Return the result of EXISTS as a string value.
Definition: item_subselect.cc:1766
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_subselect.cc:2734
bool in2exists_added_to_where() const
Definition: item_subselect.h:637
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:757
Item_exists_subselect super
Definition: item_subselect.h:573
Subquery_type subquery_type() const override
Definition: item_subselect.h:585
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:2051
bool test_limit()
Definition: item_subselect.cc:1411
Item_in_subselect()
Definition: item_subselect.h:580
bool val_bool_naked()
Definition: item_subselect.cc:1780
Item_ref * m_injected_left_expr
In the case of.
Definition: item_subselect.h:699
bool exec(THD *thd) override
Definition: item_subselect.cc:786
bool transformer(THD *thd, Item **transformed) override
Definition: item_subselect.cc:2518
Definition: item_cmpfunc.h:2318
Definition: item_subselect.h:372
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:1110
bool m_has_values
Set if we have found at least one row.
Definition: item_subselect.h:394
bool is_maxmin() const override
Definition: item_subselect.h:390
bool m_max
True if performing MAX, false if MIN.
Definition: item_subselect.h:393
void reset_has_values() override
Used by max/min subquery to initialize value presence registration mechanism.
Definition: item_subselect.h:389
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:1103
bool has_values() const
Definition: item_subselect.h:387
void register_value()
Definition: item_subselect.h:388
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:1087
Definition: item.h:6339
Definition: item.h:5888
Item with result field.
Definition: item.h:5811
Class that represents scalar subquery and row subquery.
Definition: item_subselect.h:271
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:3017
enum Item_result result_type() const override
Definition: item_subselect.cc:1130
void store(uint i, Item *item)
Definition: item_subselect.cc:1121
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:399
bool null_inside() override
Definition: item_subselect.cc:1184
Item ** addr(uint i) override
Definition: item_subselect.h:313
double val_real() override
Definition: item_subselect.cc:1198
bool resolve_type(THD *) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_subselect.cc:1135
void no_rows_in_result() override
Definition: item_subselect.cc:1167
bool val_json(Json_wrapper *result) override
Get a JSON value from an Item.
Definition: item_subselect.cc:1243
Item_cache ** m_row
Value cache for a row or scalar subquery.
Definition: item_subselect.h:367
bool m_no_rows
no_rows_in_result
Definition: item_subselect.h:368
void reset() override
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.cc:1116
Subquery_type subquery_type() const override
Definition: item_subselect.h:278
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_subselect.cc:1254
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:3056
longlong val_int() override
Definition: item_subselect.cc:1209
uint cols() const override
Definition: item_subselect.cc:3267
virtual bool is_maxmin() const
Definition: item_subselect.h:319
bool is_single_column_scalar_subquery() const override
Definition: item_subselect.cc:1126
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:330
Item * element_index(uint i) override
Definition: item_subselect.h:312
Item_singlerow_subselect()
Definition: item_subselect.h:274
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:902
bool collect_scalar_subqueries(uchar *) override
Definition: item_subselect.cc:2942
bool get_time(MYSQL_TIME *ltime) override
Definition: item_subselect.cc:1266
String * val_str(String *) override
Definition: item_subselect.cc:1220
bool val_bool() override
Definition: item_subselect.cc:1277
void bring_value() override
Definition: item_subselect.cc:1191
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:3173
bool check_cols(uint c) override
Definition: item_subselect.cc:1176
my_decimal * val_decimal(my_decimal *) override
Definition: item_subselect.cc:1231
Item_cache * m_value
Value cache of a scalar subquery.
Definition: item_subselect.h:361
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:233
Item * replace_item_view_ref(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:3157
void set_value_assigned()
Definition: item_subselect.h:139
bool clean_up_after_removal(uchar *arg) override
Clean up after removing the subquery from the item tree.
Definition: item_subselect.cc:2878
bool is_evaluated() const
Definition: item_subselect.cc:2924
enum_parsing_context m_parsing_place
where subquery is placed
Definition: item_subselect.h:243
bool collect_subqueries(uchar *) override
Definition: item_subselect.cc:2911
table_map used_tables() const override
Definition: item_subselect.h:147
void accumulate_expression(Item *item)
Accumulate properties from a selected expression within a query block.
Definition: item_subselect.cc:264
void accumulate_used_tables(table_map add_tables)
Accumulate used tables.
Definition: item_subselect.h:113
Query_expression * m_query_expr
The query expression of the subquery.
Definition: item_subselect.h:226
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:188
table_map subquery_used_tables() const
Definition: item_subselect.h:150
bool is_uncacheable() const
Definition: item_subselect.cc:3272
void accumulate_properties()
Accumulate properties from underlying query expression.
Definition: item_subselect.cc:200
virtual bool exec(THD *thd)
Definition: item_subselect.cc:663
Query_expression * query_expr() const
Definition: item_subselect.h:84
enum_engine_type
Definition: item_subselect.h:93
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:93
@ HASH_SJ_ENGINE
Definition: item_subselect.h:93
@ OTHER_ENGINE
Definition: item_subselect.h:93
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_subselect.cc:862
Subquery_type
Definition: item_subselect.h:104
@ ALL_SUBQUERY
comp-op ALL quantified comparison predicate
Definition: item_subselect.h:108
@ IN_SUBQUERY
[NOT] IN subquery predicate
Definition: item_subselect.h:107
@ SCALAR_SUBQUERY
Scalar or row subquery.
Definition: item_subselect.h:105
@ ANY_SUBQUERY
comp-op ANY quantified comparison predicate
Definition: item_subselect.h:109
@ EXISTS_SUBQUERY
[NOT] EXISTS subquery predicate
Definition: item_subselect.h:106
bool explain_subquery_checker(uchar **arg) override
Register subquery to the table where it is used within a condition.
Definition: item_subselect.cc:656
bool m_value_assigned
True if value has been assigned to subquery.
Definition: item_subselect.h:259
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:841
enum_parsing_context place()
Definition: item_subselect.h:176
virtual void reset()
Reset state after a single execution of a subquery, useful when a dependent subquery must be evaluate...
Definition: item_subselect.h:134
Item * replace_item_field(uchar *arg) override
Transform processor.
Definition: item_subselect.cc:3147
join_type get_join_type() const
Definition: item_subselect.cc:310
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:90
void accumulate_condition(Item *item)
Accumulate properties from a condition or GROUP/ORDER within a query block.
Definition: item_subselect.cc:275
virtual AccessPath * root_access_path() const
Definition: item_subselect.h:102
void create_iterators(THD *thd)
Definition: item_subselect.cc:280
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_subselect.cc:315
Query_result_interceptor * m_query_result
The query result object associated with the query expression.
Definition: item_subselect.h:229
table_map m_subquery_used_tables
cache of used tables from subquery only (not including LHS of IN subquery)
Definition: item_subselect.h:238
const TABLE * get_table() const
Definition: item_subselect.cc:300
enum Type type() const override
Definition: item_subselect.cc:839
bool fix_fields(THD *thd, Item **ref) override
Definition: item_subselect.cc:593
void set_indexsubquery_engine(subselect_indexsubquery_engine *eng)
Definition: item_subselect.h:156
const char * func_name() const override
Definition: item_subselect.h:183
void bind(Query_expression *qe)
Bind this subquery object with the supplied query expression.
Definition: item_subselect.cc:144
void reset_value_assigned()
Definition: item_subselect.h:140
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:148
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_subselect.cc:853
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:635
Item_subselect()
Definition: item_subselect.h:214
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_subselect.h:142
const Index_lookup & index_lookup() const
Definition: item_subselect.cc:305
enum_engine_type engine_type() const
Definition: item_subselect.cc:286
bool is_value_assigned() const
Definition: item_subselect.h:138
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:266
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:2850
virtual void reset_has_values()
Used by max/min subquery to initialize value presence registration mechanism.
Definition: item_subselect.h:171
bool subq_opt_away_processor(uchar *arg) override
Mark the subquery as optimized away, for EXPLAIN.
Definition: item_subselect.cc:2862
uint m_max_columns
allowed number of columns (1 for scalar subqueries)
Definition: item_subselect.h:241
virtual bool is_single_column_scalar_subquery() const
Definition: item_subselect.h:125
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Definition: item_subselect.cc:737
Item_subselect(const POS &pos)
Definition: item_subselect.h:215
table_map m_used_tables_cache
cache of used tables
Definition: item_subselect.h:236
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:936
void set_subquery()
Set the "has subquery" property.
Definition: item.h:3394
bool null_value
True if item is null.
Definition: item.h:3667
Type
Definition: item.h:971
Bool_test
< Modifier for result transformation
Definition: item.h:1013
@ BOOL_NOT_FALSE
Definition: item.h:1018
@ BOOL_NOT_TRUE
Definition: item.h:1017
@ BOOL_IS_TRUE
Definition: item.h:1014
@ BOOL_IS_FALSE
Definition: item.h:1015
@ BOOL_IDENTITY
Definition: item.h:1020
bool get_date_from_int(MYSQL_TIME *ltime, my_time_flags_t flags)
Convert val_int() to date in MYSQL_TIME.
Definition: item.cc:1629
bool update_null_value()
Make sure the null_value member has a correct value.
Definition: item.cc:7627
bool get_time_from_int(MYSQL_TIME *ltime)
Convert val_int() to time in MYSQL_TIME.
Definition: item.cc:1716
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:1153
Definition: sql_list.h:467
Definition: parse_tree_nodes.h:1773
Base class for parse tree nodes (excluding the Parse_tree_root hierarchy)
Definition: parse_tree_node_base.h:231
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1163
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:626
Definition: item_subselect.cc:1288
Definition: query_result.h:181
Query result class for scalar and row subqueries.
Definition: item_subselect.cc:107
Base class for result from a subquery.
Definition: query_result.h:312
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:2864
Object containing parameters used when creating and using temporary tables.
Definition: temp_table_param.h:95
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
my_decimal class limits 'decimal_t' type to what we need in MySQL.
Definition: my_decimal.h:95
Compute an IN predicate via a hash semi-join.
Definition: item_subselect.h:834
void create_iterators(THD *thd) override
Definition: item_subselect.cc:3511
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:3744
nulls_exist
Existence of inner NULLs in materialized table: By design, other values than IRRELEVANT_OR_FALSE are ...
Definition: item_subselect.h:846
@ NEX_TRUE
they matter, and we know there exists at least one.
Definition: item_subselect.h:852
@ NEX_UNKNOWN
they matter, and we don't know yet if they exists
Definition: item_subselect.h:850
@ NEX_IRRELEVANT_OR_FALSE
none, or they don't matter
Definition: item_subselect.h:848
void cleanup() override
Cleanup performed after each execution.
Definition: item_subselect.cc:3589
unique_ptr_destroy_only< RowIterator > m_iterator
Definition: item_subselect.h:856
subselect_hash_sj_engine(Item_in_subselect *in_predicate, Query_expression *query_expr)
Definition: item_subselect.h:863
TABLE * get_table() const
Definition: item_subselect.h:877
~subselect_hash_sj_engine() override
Definition: item_subselect.cc:3578
Query_result_interceptor * saved_result
Saved result object, must be restored after use.
Definition: item_subselect.h:860
enum nulls_exist mat_table_has_nulls
Definition: item_subselect.h:854
bool is_materialized
Definition: item_subselect.h:837
Query_expression *const m_query_expr
Definition: item_subselect.h:855
bool has_zero_rows
Definition: item_subselect.h:840
const Index_lookup & index_lookup() const
Definition: item_subselect.h:878
bool exec(THD *thd) override
Execute a subquery IN predicate via materialization.
Definition: item_subselect.cc:3624
enum_engine_type engine_type() const override
Definition: item_subselect.h:875
AccessPath * root_access_path() const
Definition: item_subselect.h:880
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:3340
enum join_type get_join_type() const
Definition: item_subselect.h:879
AccessPath * m_root_access_path
Definition: item_subselect.h:857
A subquery execution engine that evaluates the subquery by doing index lookups in a single table's in...
Definition: item_subselect.h:773
Item * m_cond
The WHERE condition of the subquery.
Definition: item_subselect.h:781
TABLE * table
Table which is read, using one of eq_ref, ref, ref_or_null.
Definition: item_subselect.h:777
virtual ~subselect_indexsubquery_engine()=default
virtual void cleanup()
Definition: item_subselect.h:816
virtual bool exec(THD *thd)
Definition: item_subselect.cc:3256
virtual void print(const THD *thd, String *str, enum_query_type query_type)
Definition: item_subselect.cc:3276
virtual void create_iterators(THD *)
Definition: item_subselect.h:817
Item * m_having
Definition: item_subselect.h:793
join_type type
Definition: item_subselect.h:780
enum_engine_type
Definition: item_subselect.h:798
@ HASH_SJ_ENGINE
Definition: item_subselect.h:798
@ INDEXSUBQUERY_ENGINE
Definition: item_subselect.h:798
Index_lookup ref
Definition: item_subselect.h:779
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:800
ulonglong m_hash
Hash value calculated by RefIterator, when needed.
Definition: item_subselect.h:782
virtual enum_engine_type engine_type() const
Definition: item_subselect.h:815
Item_in_subselect * item
Definition: item_subselect.h:795
Table_ref * table_ref
Definition: item_subselect.h:778
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:1057
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:1040
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:6718
bool(Item::* Item_analyzer)(uchar **argp)
Definition: item.h:718
Item *(Item::* Item_transformer)(uchar *arg)
Type for transformers used by Item::transform and Item::compile.
Definition: item.h:727
Item * remove_in2exists_conds(Item *conds)
Removes every predicate injected by IN->EXISTS.
Definition: item_subselect.cc:465
Subquery_strategy
Classes that represent predicates over table subqueries: [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL.
Definition: item_subselect.h:406
@ 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:2817
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
std::unique_ptr< T, Destroy_only< T > > unique_ptr_destroy_only
std::unique_ptr, but only destroying.
Definition: my_alloc.h:477
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:56
unsigned char uchar
Definition: my_inttypes.h:52
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
Time declarations shared between the server and client API: you should not add anything to this heade...
static char * where
Definition: mysqldump.cc:152
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1081
PT & ref(PT *tp)
Definition: tablespace_impl.cc:359
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.
enum_walk
Enumeration for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:287
bool(Item::*)(unsigned char *) Item_processor
Processor type for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:305
enum_condition_context
Enumeration for Query_block::condition_context.
Definition: sql_const.h:311
Common types of the Optimizer, used by optimization and execution.
join_type
Definition: sql_opt_exec_shared.h: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:213
Struct used to pass around arguments to/from check_function_as_value_generator.
Definition: item.h:492
int err_code
the error code found during check(if any)
Definition: item.h:499
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:511
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:708
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:713
bool dependent_before
True: if subquery was dependent (correlated) before IN->EXISTS was done.
Definition: item_subselect.h:718
bool dependent_after
True: if subquery was dependent (correlated) after IN->EXISTS was done.
Definition: item_subselect.h:723
Argument for walk method replace_scalar_subquery.
Definition: item_subselect.h:324
Query_block * m_outer_query_block
The transformed query block.
Definition: item_subselect.h:327
Field * m_field
the replacement field
Definition: item_subselect.h:326
Query_block * m_inner_query_block
The immediately surrounding query.
Definition: item_subselect.h:328
bool m_add_coalesce
Definition: item_subselect.h:331
Item_singlerow_subselect * m_target
subquery to be replaced with field
Definition: item_subselect.h:325
Scalar_subquery_replacement(Item_singlerow_subselect *target, Field *field, Query_block *select, bool add_coalesce)
Definition: item_subselect.h:332
argument used by walk method collect_scalar_subqueries ("css")
Definition: item_subselect.h:196
Collect_subq_info(Query_block *owner)
Definition: item_subselect.h:200
Query_block * m_query_block
Definition: item_subselect.h:199
std::vector< Item_subselect * > list
< accumulated all subq (or aggregates) found
Definition: item_subselect.h:198
bool contains(Query_expression *candidate)
Definition: item_subselect.h:201
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:420
Definition: table.h:1406
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:885