MySQL 8.4.5
Source Code Documentation
item_cmpfunc.h
Go to the documentation of this file.
1#ifndef ITEM_CMPFUNC_INCLUDED
2#define ITEM_CMPFUNC_INCLUDED
3
4/* Copyright (c) 2000, 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/* compare and test functions */
28
29#include <assert.h>
30#include <sys/types.h>
31
32#include <cstring>
33#include <memory>
34
35#include "field_types.h"
36#include "my_alloc.h"
37#include "my_compiler.h"
38
39#include "my_inttypes.h"
40#include "my_table_map.h"
41#include "my_time.h"
43#include "mysql_time.h"
45#include "sql/enum_query_type.h"
46#include "sql/item.h"
47#include "sql/item_func.h" // Item_int_func
48#include "sql/item_row.h" // Item_row
49#include "sql/mem_root_array.h" // Mem_root_array
50#include "sql/parse_location.h" // POS
51#include "sql/sql_const.h"
52#include "sql/sql_list.h"
53#include "sql/table.h"
54#include "sql_string.h"
55#include "template_utils.h" // down_cast
56
57class Arg_comparator;
58class Field;
59class Item_eq_base;
61class Item_subselect;
62class Item_sum_hybrid;
64class Json_wrapper;
65class PT_item_list;
66class Query_block;
67class THD;
68struct CHARSET_INFO;
69struct MY_BITMAP;
70struct Parse_context;
71
73
74typedef int (Arg_comparator::*arg_cmp_func)();
75
76/// A class that represents a join condition in a hash join. The class holds an
77/// equality condition, as well as a pre-calculated bitmap of the used tables
78/// (Item::used_tables()) for each side of the condition.
79///
80/// The class also contains one Item for each side of the condition. In most
81/// cases, the Item is only a pointer to the left/right Item of the join
82/// condition. But for certain data types (DECIMAL, DOUBLE(M, N), FLOAT(M, N)),
83/// the Item might be a typecast. Either way, the caller should use these Items
84/// when i.e. reading the values from the join condition, so that the values are
85/// read in the right data type context. See the comments for
86/// Item_eq_base::create_cast_if_needed for more details around this.
88 public:
90
92
95 bool left_uses_any_table(table_map tables) const {
96 return (m_left_used_tables & tables) != 0;
97 }
98
99 bool right_uses_any_table(table_map tables) const {
100 return (m_right_used_tables & tables) != 0;
101 }
102
104
106
107 /// Returns true if this join condition evaluates to TRUE if both
108 /// operands are NULL.
109 bool null_equals_null() const { return m_null_equals_null; }
110
111 private:
115
116 // Item::used_tables() is heavily used during the join to determine which side
117 // of the condition we are to read the value from, so caching the result of
118 // used_tables() gives a nice speedup.
121
122 // The maximum number of characters among the two arguments. This is
123 // especially relevant when we have a PAD SPACE collation and the SQL mode
124 // PAD_CHAR_TO_FULL_LENGTH enabled, since we will have to pad the shortest
125 // argument to the same length as the longest argument.
126 const size_t m_max_character_length{0};
127
128 // Normally, we store the full sort key for the condition as key in the hash
129 // table. However, if the string is very long, or we have a PAD SPACE
130 // collation, this could result in huge sort keys. If we detect that this
131 // could happen in the worst case, we store just a hash in the key instead (so
132 // we hash the hash). If so, we have to do a recheck afterwards, in order to
133 // guard against hash collisions.
135
136 // True if NULL is considered equal to NULL, and not as UNKNOWN.
138};
139
141 Item **left{nullptr};
142 Item **right{nullptr};
145 Arg_comparator *comparators{nullptr}; // used only for compare_row()
147 double precision{0.0};
148 /* Fields used in DATE/DATETIME comparison. */
149 Item *left_cache{nullptr}; // Cached values of "left" and "right" items
150 Item *right_cache{nullptr};
151 bool set_null{true}; // true <=> set owner->null_value
152 // when one of arguments is NULL.
153
155 static bool get_date_from_const(Item *date_arg, Item *str_arg,
156 ulonglong *const_value);
157 /**
158 Only used by compare_json() in the case where a JSON value is
159 compared to an SQL value. This member points to pre-allocated
160 memory that can be used instead of the heap when converting the
161 SQL value to a JSON value.
162 */
164
165 public:
167 /* Allow owner function to use string buffers. */
169
170 Arg_comparator() = default;
171
173
175 bool set_cmp_func(Item_result_field *owner_arg, Item **left, Item **right,
177
178 bool set_cmp_func(Item_result_field *owner_arg, Item **left, Item **right,
179 bool set_null_arg);
180
181 bool set_cmp_func(Item_result_field *owner_arg, Item **left, Item **right,
182 bool set_null_arg, Item_result type);
183 /**
184 Comparison function are expected to operate on arguments having the
185 same data types. Since MySQL has very loosened up rules, it accepts
186 all kind of arguments which the standard SQL does not allow, and then it
187 converts the arguments internally to ones usable in the comparison.
188 This function transforms these internal conversions to explicit CASTs
189 so that the internally executed query becomes compatible with the standard
190 At the moment nodes are injected only for comparisons between:
191
192 1) temporal types and numeric data types: in which case the
193 comparison is normally done as DOUBLE, so the arguments which are not
194 floating point, will get converted to DOUBLE, and also for
195
196 2) comparisons between temporal types: in which case the
197 comparison happens as DATETIME if the arguments have different data
198 types, so in this case the temporal arguments that are not DATETIME
199 will get wrapped in a CAST to DATETIME.
200
201 WL#12108; This function will limit itself to comparison between regular
202 functions, aggregation functions and fields, all of which are constant
203 for execution (so this excludes stored procedures, stored functions, GC,
204 user defined functions, as well as literals).
205 For const arguments, see type conversions done in fold_condition.
206
207 @return false if successful, true otherwise
208 */
209 bool inject_cast_nodes();
210
211 inline int compare() { return (this->*func)(); }
212
213 int compare_string(); // compare args[0] & args[1]
214 int compare_binary_string(); // compare args[0] & args[1]
215 int compare_real(); // compare args[0] & args[1]
216 int compare_decimal(); // compare args[0] & args[1]
217 int compare_int_signed(); // compare args[0] & args[1]
222 int compare_row(); // compare args[0] & args[1]
223 int compare_real_fixed();
224 int compare_datetime(); // compare args[0] & args[1] as DATETIMEs
225 int compare_json();
226 bool compare_null_values();
227
228 static bool can_compare_as_dates(const Item *a, const Item *b);
229
230 void set_datetime_cmp_func(Item_result_field *owner_arg, Item **a1,
231 Item **b1);
233 void cleanup();
234 /*
235 Set correct cmp_context if items would be compared as INTs.
236 */
239 if ((*left)->is_temporal()) (*left)->cmp_context = INT_RESULT;
240 if ((*right)->is_temporal()) (*right)->cmp_context = INT_RESULT;
241 }
242
244
246
248
250
251 /// @returns true if the class has decided that values should be extracted
252 /// from the Items using function pointers set up by this class.
254 return get_value_a_func != nullptr;
255 }
256
257 // Read the value from one of the Items (decided by "left_argument"), using
258 // the function pointers that this class has set up. This can happen for DATE,
259 // TIME, DATETIME and YEAR values, and the returned value is a temporal value
260 // in packed format.
261 longlong extract_value_from_argument(THD *thd, Item *item, bool left_argument,
262 bool *is_null) const;
263
264 Item **get_left_ptr() const { return left; }
265 Item *get_right() const { return *right; }
266
267 private:
268 /// A function pointer that is used for retrieving the value from argument
269 /// "left". This function is only used when we are comparing in a datetime
270 /// context, and it retrieves the value as a DATE, TIME, DATETIME or YEAR,
271 /// depending on the comparison context.
272 ///
273 /// @param thd thread handle. Used to retrieve the SQL mode among other things
274 /// @param item_arg the item to retrieve the value from
275 /// @param cache_arg a pointer to an Item where we can cache the value
276 /// from "item_arg". Can be nullptr
277 /// @param warn_item if raising an conversion warning, the warning gets the
278 /// data type and item name from this item
279 /// @param is_null whether or not "item_arg" returned SQL NULL
280 ///
281 /// @returns a DATE/TIME/YEAR/DATETIME value, in packed format
282 longlong (*get_value_a_func)(THD *thd, Item ***item_arg, Item **cache_arg,
283 const Item *warn_item, bool *is_null){nullptr};
284
285 // This function does the same as "get_value_a_func", except that it returns
286 // the value from the argument "right" (the right side of the comparison).
287 longlong (*get_value_b_func)(THD *thd, Item ***item_arg, Item **cache_arg,
288 const Item *warn_item, bool *is_null){nullptr};
289
290 // The data type that is used when comparing the two Items. I.e., if the type
291 // is INT_RESULT, we call val_int() on both sides and compare those.
293};
294
296 protected:
298 explicit Item_bool_func(const POS &pos) : Item_int_func(pos) {
300 }
301
303 Item_bool_func(const POS &pos, Item *a) : Item_int_func(pos, a) {
305 }
306
307 Item_bool_func(Item *a, Item *b, Item *c) : Item_int_func(a, b, c) {
309 }
312 }
313 Item_bool_func(const POS &pos, Item *a, Item *b) : Item_int_func(pos, a, b) {
315 }
316 Item_bool_func(const POS &pos, Item *a, Item *b, Item *c)
317 : Item_int_func(pos, a, b, c) {
319 }
320
322 : Item_int_func(thd, item),
325 }
326
327 public:
328 bool is_bool_func() const override { return true; }
329 bool resolve_type(THD *thd) override {
330 max_length = 1;
331 return Item_int_func::resolve_type(thd);
332 }
333 uint decimal_precision() const override { return 1; }
334 bool created_by_in2exists() const override { return m_created_by_in2exists; }
336
337 static const char *bool_transform_names[10];
338 /**
339 Array that transforms a boolean test according to another.
340 First dimension is existing value, second dimension is test to apply
341 */
342 static const Bool_test bool_transform[10][8];
343
344 private:
345 /**
346 True <=> this item was added by IN->EXISTS subquery transformation, and
347 should thus be deleted if we switch to materialization.
348 */
350};
351
352/**
353 A predicate that is "always true" or "always false". To be used as a
354 standalone condition or as part of conditions, together with other condition
355 and predicate objects.
356 Mostly used when generating conditions internally.
357*/
359 public:
361 max_length = 1;
364 fixed = true;
365 }
366 explicit Item_func_bool_const(const POS &pos) : Item_bool_func(pos) {
367 max_length = 1;
370 fixed = true;
371 }
372 bool fix_fields(THD *, Item **) override { return false; }
373 bool basic_const_item() const override { return true; }
374 void cleanup() override { result_field = nullptr; }
375};
376
377/// A predicate that is "always true".
378
380 public:
382 explicit Item_func_true(const POS &pos) : Item_func_bool_const(pos) {}
383 const char *func_name() const override { return "true"; }
384 bool val_bool() override { return true; }
385 longlong val_int() override { return 1; }
386 void print(const THD *, String *str, enum_query_type) const override {
387 str->append("true");
388 }
389 enum Functype functype() const override { return TRUE_FUNC; }
390};
391
392/// A predicate that is "always false".
393
395 public:
397 explicit Item_func_false(const POS &pos) : Item_func_bool_const(pos) {}
398 const char *func_name() const override { return "false"; }
399 bool val_bool() override { return false; }
400 longlong val_int() override { return 0; }
401 void print(const THD *, String *str, enum_query_type) const override {
402 str->append("false");
403 }
404 enum Functype functype() const override { return FALSE_FUNC; }
405};
406
407/**
408 Item class, to represent <code>X IS [NOT] (TRUE | FALSE)</code>
409 boolean predicates.
410*/
411class Item_func_truth final : public Item_bool_func {
413
414 public:
415 longlong val_int() override;
416 bool resolve_type(THD *) override;
417 void print(const THD *thd, String *str,
418 enum_query_type query_type) const override;
419 Item *truth_transformer(THD *, Bool_test test) override {
421 return this;
422 }
423 const char *func_name() const override {
425 }
426 enum Functype functype() const override { return ISTRUTH_FUNC; }
427
429 : super(pos, a), truth_test(truth_test) {
430 null_on_null = false;
431 switch (truth_test) {
432 case BOOL_IS_TRUE:
433 case BOOL_IS_FALSE:
434 case BOOL_NOT_TRUE:
435 case BOOL_NOT_FALSE:
436 break;
437 default:
438 assert(false);
439 }
440 }
443 null_on_null = false;
444 switch (truth_test) {
445 case BOOL_IS_TRUE:
446 case BOOL_IS_FALSE:
447 case BOOL_NOT_TRUE:
448 case BOOL_NOT_FALSE:
449 break;
450 default:
451 assert(false);
452 }
453 }
454 void apply_is_true() override {
455 /*
456 This item cannot produce NULL result. But, if the upper item confuses
457 NULL and FALSE, we can do as if NULL input caused a NULL result when it
458 actually causes a FALSE result.
459 */
460 switch (truth_test) {
461 case BOOL_IS_TRUE:
462 case BOOL_IS_FALSE:
463 null_on_null = true;
464 default:
465 break;
466 }
467 }
468
469 protected:
470 Bool_test truth_test; ///< The value we're testing for.
471};
472
473static const int UNKNOWN = -1;
474
475/*
476 Item_in_optimizer(Item_in_subselect(...))
477
478 Item_in_optimizer is used to wrap an instance of Item_in_subselect. This
479 class does the following:
480 - Evaluate the left expression and store it in Item_cache_* object (to
481 avoid re-evaluating it many times during subquery execution)
482 - Shortcut the evaluation of "NULL IN (...)" to NULL in the cases where we
483 don't care if the result is NULL or FALSE.
484
485 args[0] keeps a reference to the Item_in_subselect object.
486
487 NOTE
488 It is not quite clear why the above listed functionality should be
489 placed into a separate class called 'Item_in_optimizer'.
490*/
491
492class Item_in_optimizer final : public Item_bool_func {
493 private:
494 Item_cache *cache{nullptr};
495 /**
496 Stores the value of "NULL IN (SELECT ...)" for uncorrelated subqueries:
497 UNKNOWN - "NULL in (SELECT ...)" has not yet been evaluated
498 FALSE - result is FALSE
499 TRUE - result is NULL
500 */
502
503 public:
505 : Item_bool_func(pointer_cast<Item *>(item)) {
506 set_subquery();
507 }
508 bool fix_fields(THD *, Item **) override;
509 bool fix_left(THD *thd);
510 void fix_after_pullout(Query_block *parent_query_block,
511 Query_block *removed_query_block) override;
512 bool split_sum_func(THD *thd, Ref_item_array ref_item_array,
513 mem_root_deque<Item *> *fields) override;
514 void print(const THD *thd, String *str,
515 enum_query_type query_type) const override;
516 bool is_null() override;
517 longlong val_int() override;
518 void cleanup() override;
519 const char *func_name() const override { return "<in_optimizer>"; }
520 Item_cache **get_cache() { return &cache; }
521 void update_used_tables() override;
522};
523
524/// Abstract factory interface for creating comparison predicates.
526 public:
527 virtual ~Comp_creator() = default;
528 virtual Item_bool_func *create(Item *a, Item *b) const = 0;
529
530 /// This interface is only used by Item_allany_subselect.
531 virtual const char *symbol(bool invert) const = 0;
532 virtual bool eqne_op() const = 0;
533 virtual bool l_op() const = 0;
534};
535
536/// Abstract base class for the comparison operators =, <> and <=>.
538 public:
539 Item_bool_func *create(Item *a, Item *b) const override;
540 bool eqne_op() const override { return true; }
541 bool l_op() const override { return false; }
542
543 protected:
544 /**
545 Creates only an item tree node, without attempting to rewrite row
546 constructors.
547 @see create()
548 */
550
551 /// Combines a list of conditions <code>exp op exp</code>.
553};
554
556 public:
557 const char *symbol(bool invert) const override { return invert ? "<>" : "="; }
558
559 protected:
560 Item_bool_func *create_scalar_predicate(Item *a, Item *b) const override;
561 Item_bool_func *combine(List<Item> list) const override;
562};
563
565 public:
566 const char *symbol(bool invert [[maybe_unused]]) const override {
567 // This will never be called with true.
568 assert(!invert);
569 return "<=>";
570 }
571
572 protected:
573 Item_bool_func *create_scalar_predicate(Item *a, Item *b) const override;
574 Item_bool_func *combine(List<Item> list) const override;
575};
576
578 public:
579 const char *symbol(bool invert) const override { return invert ? "=" : "<>"; }
580
581 protected:
582 Item_bool_func *create_scalar_predicate(Item *a, Item *b) const override;
583 Item_bool_func *combine(List<Item> list) const override;
584};
585
586class Gt_creator : public Comp_creator {
587 public:
588 Item_bool_func *create(Item *a, Item *b) const override;
589 const char *symbol(bool invert) const override { return invert ? "<=" : ">"; }
590 bool eqne_op() const override { return false; }
591 bool l_op() const override { return false; }
592};
593
594class Lt_creator : public Comp_creator {
595 public:
596 Item_bool_func *create(Item *a, Item *b) const override;
597 const char *symbol(bool invert) const override { return invert ? ">=" : "<"; }
598 bool eqne_op() const override { return false; }
599 bool l_op() const override { return true; }
600};
601
602class Ge_creator : public Comp_creator {
603 public:
604 Item_bool_func *create(Item *a, Item *b) const override;
605 const char *symbol(bool invert) const override { return invert ? "<" : ">="; }
606 bool eqne_op() const override { return false; }
607 bool l_op() const override { return false; }
608};
609
610class Le_creator : public Comp_creator {
611 public:
612 Item_bool_func *create(Item *a, Item *b) const override;
613 const char *symbol(bool invert) const override { return invert ? ">" : "<="; }
614 bool eqne_op() const override { return false; }
615 bool l_op() const override { return true; }
616};
617
618/// Base class for functions that usually take two arguments, which are possibly
619/// strings, and perform some kind of comparison on the two arguments and return
620/// a boolean. The functions may take more than two arguments (for example, LIKE
621/// takes an optional third argument in the ESCAPE clause), but all of the
622/// functions perform a comparison between the first two arguments, and extra
623/// arguments are modifiers that affect how the comparison is performed.
625 private:
626 bool convert_constant_arg(THD *thd, Item *field, Item **item,
627 bool *converted);
628
629 protected:
631 bool abort_on_null{false};
632
634 : Item_bool_func(a, b), cmp(args, args + 1) {}
635
637 : Item_bool_func(a, b, c), cmp(args, args + 1) {}
638
639 Item_bool_func2(const POS &pos, Item *a, Item *b)
640 : Item_bool_func(pos, a, b), cmp(args, args + 1) {}
641
642 Item_bool_func2(const POS &pos, Item *a, Item *b, Item *c)
643 : Item_bool_func(pos, a, b, c), cmp(args, args + 1) {}
644
645 public:
646 bool resolve_type(THD *) override;
647 /// Sets up a comparator of the correct type based on the type of the
648 /// function's arguments. Also sets up caches to hold constant values
649 /// converted to the type expected by the comparator. See
650 /// Arg_comparator::set_cmp_func().
651 virtual bool set_cmp_func() {
652 return cmp.set_cmp_func(this, args, args + 1, is_nullable());
653 }
654 optimize_type select_optimize(const THD *) override { return OPTIMIZE_OP; }
655 /// @returns an operator REV_OP so that "B REV_OP A" is equivalent to
656 /// "A this_operator B".
657 virtual enum Functype rev_functype() const { return UNKNOWN_FUNC; }
658 bool have_rev_func() const override { return rev_functype() != UNKNOWN_FUNC; }
659
660 void print(const THD *thd, String *str,
661 enum_query_type query_type) const override {
662 Item_func::print_op(thd, str, query_type);
663 }
664
665 bool is_null() override { return args[0]->is_null() || args[1]->is_null(); }
666 const CHARSET_INFO *compare_collation() const override {
668 }
670 void apply_is_true() override { abort_on_null = true; }
671 /// Treat UNKNOWN result like FALSE because callers see no difference
672 bool ignore_unknown() const { return abort_on_null; }
673 void cleanup() override {
675 cmp.cleanup();
676 }
677 const Arg_comparator *get_comparator() const { return &cmp; }
679 friend class Arg_comparator;
680 bool allow_replacement(Item_field *const original,
681 Item *const subst) override {
682 /*
683 If UNKNOWN results can be treated as false (e.g when placed in WHERE, ON
684 or HAVING), a non-nullable field can be replaced with a nullable one.
685 */
686 return ignore_unknown() || original->is_nullable() || !subst->is_nullable();
687 }
688};
689
690/**
691 Item_func_comparison is a class for comparison functions that take two
692 arguments and return a boolean result.
693 It is a common class for the regular comparison operators (=, <>, <, <=,
694 >, >=) as well as the special <=> equality operator.
695*/
697 public:
699 allowed_arg_cols = 0; // Fetch this value from first argument
700 }
701 Item_func_comparison(const POS &pos, Item *a, Item *b)
702 : Item_bool_func2(pos, a, b) {
703 allowed_arg_cols = 0; // Fetch this value from first argument
704 }
705
706 Item *truth_transformer(THD *, Bool_test) override;
707 virtual Item *negated_item();
708 bool subst_argument_checker(uchar **) override { return true; }
709 bool is_null() override;
710
711 bool cast_incompatible_args(uchar *) override;
712};
713
714/**
715 XOR inherits from Item_bool_func2 because it is not optimized yet.
716 Later, when XOR is optimized, it needs to inherit from
717 Item_cond instead. See WL#5800.
718*/
719class Item_func_xor final : public Item_bool_func2 {
721
722 public:
723 Item_func_xor(Item *i1, Item *i2) : Item_bool_func2(i1, i2) {}
724 Item_func_xor(const POS &pos, Item *i1, Item *i2)
725 : Item_bool_func2(pos, i1, i2) {}
726
727 enum Functype functype() const override { return XOR_FUNC; }
728 const char *func_name() const override { return "xor"; }
729 bool do_itemize(Parse_context *pc, Item **res) override;
730 longlong val_int() override;
731 void apply_is_true() override {}
732 Item *truth_transformer(THD *, Bool_test) override;
733
734 float get_filtering_effect(THD *thd, table_map filter_for_table,
735 table_map read_tables,
736 const MY_BITMAP *fields_to_ignore,
737 double rows_in_table) override;
738};
739
741 public:
743 Item_func_not(const POS &pos, Item *a) : Item_bool_func(pos, a) {}
744
745 longlong val_int() override;
746 enum Functype functype() const override { return NOT_FUNC; }
747 const char *func_name() const override { return "not"; }
748 Item *truth_transformer(THD *, Bool_test) override;
749 void print(const THD *thd, String *str,
750 enum_query_type query_type) const override;
751
752 float get_filtering_effect(THD *thd, table_map filter_for_table,
753 table_map read_tables,
754 const MY_BITMAP *fields_to_ignore,
755 double rows_in_table) override;
756};
757
758/**
759 Wrapper class when MATCH function is used in WHERE clause.
760 The MATCH clause can be used as a function returning a floating point value
761 in the SELECT list or in the WHERE clause. However, it may also be used as
762 a boolean function in the WHERE clause, where it has different semantics than
763 when used together with a comparison operator. With a comparison operator,
764 the match operation is performed with ranking. To preserve this behavior,
765 the Item_func_match object is wrapped inside an object of class
766 Item_func_match_predicate, which effectively transforms the function into
767 a predicate. The overridden functions implemented in this class generally
768 forward all evaluation to the underlying object.
769*/
771 public:
773
774 longlong val_int() override;
775 enum Functype functype() const override { return MATCH_FUNC; }
776 const char *func_name() const override { return "match"; }
777 void print(const THD *thd, String *str,
778 enum_query_type query_type) const override {
779 args[0]->print(thd, str, query_type);
780 }
781
782 float get_filtering_effect(THD *thd, table_map filter_for_table,
783 table_map read_tables,
784 const MY_BITMAP *fields_to_ignore,
785 double rows_in_table) override {
786 return args[0]->get_filtering_effect(thd, filter_for_table, read_tables,
787 fields_to_ignore, rows_in_table);
788 }
789};
791class JOIN;
792
793/*
794 trigcond<param>(arg) ::= param? arg : true
795
796 The class Item_func_trig_cond is used for guarded predicates
797 which are employed only for internal purposes.
798 A guarded predicate is an object consisting of an a regular or
799 a guarded predicate P and a pointer to a boolean guard variable g.
800 A guarded predicate P/g is evaluated to true if the value of the
801 guard g is false, otherwise it is evaluated to the same value that
802 the predicate P: val(P/g)= g ? val(P):true.
803 Guarded predicates allow us to include predicates into a conjunction
804 conditionally. Currently they are utilized for pushed down predicates
805 in queries with outer join operations.
806
807 In the future, probably, it makes sense to extend this class to
808 the objects consisting of three elements: a predicate P, a pointer
809 to a variable g and a firing value s with following evaluation
810 rule: val(P/g,s)= g==s? val(P) : true. It will allow us to build only
811 one item for the objects of the form P/g1/g2...
812
813 Objects of this class are built only for query execution after
814 the execution plan has been already selected. That's why this
815 class needs only val_int out of generic methods.
816
817 Current uses of Item_func_trig_cond objects:
818 - To wrap selection conditions when executing outer joins
819 - To wrap condition that is pushed down into subquery
820*/
821
823 public:
825 /**
826 This trigger type deactivates join conditions when a row has been
827 NULL-complemented. For example, in t1 LEFT JOIN t2, the join condition
828 can be tested on t2's row only if that row is not NULL-complemented.
829 */
831
832 /**
833 This trigger type deactivates predicated from WHERE condition when no
834 row satisfying the join condition has been found. For Example, in t1
835 LEFT JOIN t2, the where condition pushed to t2 can be tested only after
836 at least one t2 row has been produced, which may be a NULL-complemented
837 row.
838 */
840
841 /**
842 In IN->EXISTS subquery transformation, new predicates are added:
843 WHERE inner_field=outer_field OR inner_field IS NULL,
844 as well as
845 HAVING inner_field IS NOT NULL,
846 are disabled if outer_field is a NULL value
847 */
849 };
850
851 private:
852 /** Pointer to trigger variable */
853 bool *trig_var;
854 /// Optional: JOIN of table which is the source of trig_var
855 const JOIN *m_join;
856 /// Optional: if join!=NULL: index of table
858 /** Type of trig_var; for printing */
860
861 public:
862 /**
863 @param a the item for @<condition@>
864 @param f pointer to trigger variable
865 @param join if a table's property is the source of 'f', JOIN
866 which owns this table; NULL otherwise.
867 @param idx if join!=NULL: index of this table in the
868 JOIN_TAB/QEP_TAB array. NO_PLAN_IDX otherwise.
869 @param trig_type_arg type of 'f'
870 */
872 enum_trig_type trig_type_arg)
873 : Item_bool_func(a),
874 trig_var(f),
875 m_join(join),
876 m_idx(idx),
877 trig_type(trig_type_arg) {}
878 longlong val_int() override;
879 enum Functype functype() const override { return TRIG_COND_FUNC; }
880 /// '@<if@>', to distinguish from the if() SQL function
881 const char *func_name() const override { return "<if>"; }
882 /// Get range of inner tables spanned by associated outer join operation
883 void get_table_range(Table_ref **first_table, Table_ref **last_table) const;
884 /// Get table_map of inner tables spanned by associated outer join operation
886 bool fix_fields(THD *thd, Item **ref) override {
887 if (Item_bool_func::fix_fields(thd, ref)) return true;
889 return false;
890 }
893 assert(m_join != nullptr);
894 // Make this function dependent on the inner tables
896 } else if (trig_type == OUTER_FIELD_IS_NOT_NULL) {
898 }
899 }
900 void update_used_tables() override {
903 }
904 void fix_after_pullout(Query_block *parent_query_block,
905 Query_block *removed_query_block) override {
906 Item_bool_func::fix_after_pullout(parent_query_block, removed_query_block);
908 }
909 const JOIN *get_join() const { return m_join; }
910 enum enum_trig_type get_trig_type() const { return trig_type; }
911 bool *get_trig_var() { return trig_var; }
913 void print(const THD *thd, String *str,
914 enum_query_type query_type) const override;
915 plan_idx idx() const { return m_idx; }
916
917 bool contains_only_equi_join_condition() const override;
918};
919
921 /* allow to check presence of values in max/min optimization */
926
927 public:
928 bool show;
929
931 : Item_func_not(a),
935 abort_on_null(false),
936 show(false) {}
937 void apply_is_true() override { abort_on_null = true; }
938 /// Treat UNKNOWN result like FALSE because callers see no difference
939 bool ignore_unknown() const { return abort_on_null; }
940 longlong val_int() override;
941 enum Functype functype() const override { return NOT_ALL_FUNC; }
942 const char *func_name() const override { return "<not>"; }
943 void print(const THD *thd, String *str,
944 enum_query_type query_type) const override;
947 void set_subselect(Item_subselect *item) { subselect = item; }
948 table_map not_null_tables() const override {
949 /*
950 See handling of not_null_tables_cache in
951 Item_in_optimizer::fix_fields().
952
953 This item is the result of a transformation from an ALL clause
954 such as
955 left-expr < ALL(subquery)
956 into
957 <not>(left-expr >= ANY(subquery)
958
959 An inequality usually rejects NULLs from both operands, so the
960 not_null_tables() of the inequality is the union of the
961 null-rejecting tables of both operands. However, since this is a
962 transformed ALL clause that should return true if the subquery
963 is empty (even if left-expr is NULL), it is not null rejecting
964 for left-expr. The not null tables mask for left-expr should be
965 removed, leaving only the null-rejecting tables of the
966 subquery. Item_subselect::not_null_tables() always returns 0 (no
967 null-rejecting tables). Therefore, always return 0.
968 */
969 return 0;
970 }
972 Item *truth_transformer(THD *, Bool_test) override;
973};
974
976 public:
978 longlong val_int() override;
979 const char *func_name() const override { return "<nop>"; }
981 Item *truth_transformer(THD *, Bool_test) override;
982};
983
984/**
985 Base class for the equality comparison operators = and <=>.
986
987 Both of these operators can be used to construct a key for a hash join, as
988 both represent an equality, only differing in how NULL values are handled. The
989 common code for constructing hash join keys is located in this class.
990*/
992 protected:
994 Item_eq_base(const POS &pos, Item *a, Item *b)
995 : Item_func_comparison(pos, a, b) {}
996
997 public:
998 bool contains_only_equi_join_condition() const final;
999
1000 /// Read the value from the join condition, and append it to the output vector
1001 /// "join_key_buffer". The function will determine which side of the condition
1002 /// to read the value from by using the bitmap "tables".
1003 ///
1004 /// @param thd the thread handler
1005 /// @param tables a bitmap that marks the tables that are involved in the join
1006 /// @param join_condition an instance containing the join condition together
1007 /// with some pre-calculated values
1008 /// @param[out] join_key_buffer a buffer where the value from the join
1009 /// condition will be appended
1010 /// @param is_multi_column_key true if the hash join key has multiple columns
1011 /// (that is, the hash join condition is a conjunction)
1012 ///
1013 /// @returns true if this is an ordinary equality (=) predicate and the value
1014 /// evaluated to NULL, or false otherwise.
1016 const HashJoinCondition &join_condition,
1017 bool is_multi_column_key,
1018 String *join_key_buffer) const;
1019
1020 /// Wrap the argument in a typecast, if needed.
1021 ///
1022 /// When computing a hash of the join value during a hash join, we want to
1023 /// create a hash value that is memcmp-able. This is quite straightforward
1024 /// for most data types, but it can be tricky for some types. For the
1025 /// straightforward cases, this function just returns the argument it was
1026 /// given in. For the complex cases, the function returns the given argument,
1027 /// wrapped in a typecast node. Which typecast node it is wrapped in is
1028 /// determined by the comparison context of this equality condition. The
1029 /// comparison context is given by the member "cmp"; a comparator class that
1030 /// is set up during query resolving.
1031 ///
1032 /// @param mem_root the MEM_ROOT where the typecast node is allocated
1033 /// @param argument the argument that we might wrap in a typecast. This is
1034 /// either the left or the right side of the Item_eq_base
1035 ///
1036 /// @returns either the argument it was given, or the argument wrapped in a
1037 /// typecast
1038 Item *create_cast_if_needed(MEM_ROOT *mem_root, Item *argument) const;
1039
1040 /// If this equality originally came from a multi-equality, this documents
1041 /// which one it came from (otherwise nullptr). It is used during planning:
1042 /// For selectivity estimates and for not pushing down the same multi-equality
1043 /// to the same join more than once (see IsBadJoinForCondition()).
1044 ///
1045 /// This is used only in the hypergraph optimizer; the pre-hypergraph
1046 /// optimizer uses COND_EQUAL to find this instead.
1047 ///
1048 /// It is always nullptr in Item_func_equal objects, as such objects are never
1049 /// created from multiple equalities.
1051};
1052
1053/**
1054 Implements the comparison operator equals (=)
1055*/
1056class Item_func_eq final : public Item_eq_base {
1057 public:
1059 Item_func_eq(const POS &pos, Item *a, Item *b) : Item_eq_base(pos, a, b) {}
1060 longlong val_int() override;
1061 enum Functype functype() const override { return EQ_FUNC; }
1062 enum Functype rev_functype() const override { return EQ_FUNC; }
1063 cond_result eq_cmp_result() const override { return COND_TRUE; }
1064 const char *func_name() const override { return "="; }
1065 Item *negated_item() override;
1066 bool equality_substitution_analyzer(uchar **) override { return true; }
1068 bool clean_up_after_removal(uchar *arg) override;
1069 bool gc_subst_analyzer(uchar **) override { return true; }
1070
1071 float get_filtering_effect(THD *thd, table_map filter_for_table,
1072 table_map read_tables,
1073 const MY_BITMAP *fields_to_ignore,
1074 double rows_in_table) override;
1075
1076 /// See if this is a condition where any of the arguments refers to a field
1077 /// that is outside the bits marked by 'left_side_tables' and
1078 /// 'right_side_tables'.
1079 ///
1080 /// This is a situation that can happen during equality propagation in the
1081 /// optimization phase. Consider the following query:
1082 ///
1083 /// SELECT * FROM t1 LEFT JOIN
1084 /// (t2 LEFT JOIN t3 ON t3.i = t2.i) ON t2.i = t1.i;
1085 ///
1086 /// The optimizer will see that t1.i = t2.i = t3.i. Furthermore, it will
1087 /// replace one side of this condition with a field from a table that is as
1088 /// early in the join order as possible. However, this will break queries
1089 /// executed in the iterator executor. The above query will end up with
1090 /// something like this after optimization:
1091 ///
1092 /// Left hash join <--- t1.i = t2.i
1093 /// | |
1094 /// t1 Left hash join <--- t1.i = t3.i
1095 /// | |
1096 /// t2 t3
1097 ///
1098 /// Note that 't2.i = t3.i' has been rewritten to 't1.i = t3.i'. When
1099 /// evaluating the join between t2 and t3, t1 is outside our reach!
1100 /// To overcome this, we must reverse the changes done by the equality
1101 /// propagation. It is possible to do so because during equality propagation,
1102 /// we save a list of all of the fields that were considered equal.
1103 /// If we are asked to replace ("replace" set to true), arguments of this
1104 /// function are replaced with an equal field. If we are not replacing, we
1105 /// set "found" to "true" if an equal field is found, "false" otherwise.
1107 table_map right_side_tables,
1108 bool replace, bool *found);
1109};
1110
1111/**
1112 The <=> operator evaluates the same as
1113
1114 a IS NULL || b IS NULL ? a IS NULL == b IS NULL : a = b
1115
1116 a <=> b is equivalent to the standard operation a IS NOT DISTINCT FROM b.
1117
1118 Notice that the result is TRUE or FALSE, and never UNKNOWN.
1119*/
1120class Item_func_equal final : public Item_eq_base {
1121 public:
1123 null_on_null = false;
1124 }
1125 Item_func_equal(const POS &pos, Item *a, Item *b) : Item_eq_base(pos, a, b) {
1126 null_on_null = false;
1127 }
1128 // Needs null value propagated to parent, even though operator is not nullable
1129 bool set_cmp_func() override {
1130 return cmp.set_cmp_func(this, args, args + 1, true);
1131 }
1132 longlong val_int() override;
1133 bool resolve_type(THD *thd) override;
1134 enum Functype functype() const override { return EQUAL_FUNC; }
1135 enum Functype rev_functype() const override { return EQUAL_FUNC; }
1136 cond_result eq_cmp_result() const override { return COND_TRUE; }
1137 const char *func_name() const override { return "<=>"; }
1138 Item *truth_transformer(THD *, Bool_test) override { return nullptr; }
1139 bool is_null() override { return false; }
1140
1141 float get_filtering_effect(THD *thd, table_map filter_for_table,
1142 table_map read_tables,
1143 const MY_BITMAP *fields_to_ignore,
1144 double rows_in_table) override;
1145};
1146
1147/// '<,>,=<,=>' operators.
1149 public:
1151
1152 float get_filtering_effect(THD *thd, table_map filter_for_table,
1153 table_map read_tables,
1154 const MY_BITMAP *fields_to_ignore,
1155 double rows_in_table) override;
1156
1157 bool gc_subst_analyzer(uchar **) override { return true; }
1158};
1159
1160/**
1161 Implements the comparison operator greater than or equals (>=)
1162*/
1164 public:
1166 longlong val_int() override;
1167 enum Functype functype() const override { return GE_FUNC; }
1168 enum Functype rev_functype() const override { return LE_FUNC; }
1169 cond_result eq_cmp_result() const override { return COND_TRUE; }
1170 const char *func_name() const override { return ">="; }
1171 Item *negated_item() override;
1172};
1173
1174/**
1175 Implements the comparison operator greater than (>)
1176*/
1178 public:
1180 longlong val_int() override;
1181 enum Functype functype() const override { return GT_FUNC; }
1182 enum Functype rev_functype() const override { return LT_FUNC; }
1183 cond_result eq_cmp_result() const override { return COND_FALSE; }
1184 const char *func_name() const override { return ">"; }
1185 Item *negated_item() override;
1186};
1187
1188/**
1189 Implements the comparison operator less than or equals (<=)
1190*/
1192 public:
1194 longlong val_int() override;
1195 enum Functype functype() const override { return LE_FUNC; }
1196 enum Functype rev_functype() const override { return GE_FUNC; }
1197 cond_result eq_cmp_result() const override { return COND_TRUE; }
1198 const char *func_name() const override { return "<="; }
1199 Item *negated_item() override;
1200};
1201
1202/**
1203 Internal function used by subquery to derived transformation to check
1204 if a subquery is scalar. We model it to check if the count is greater than
1205 1 using Item_func_gt.
1206*/
1207
1209 public:
1211 longlong val_int() override;
1212 const char *func_name() const override { return "reject_if"; }
1213 /// Redefine to avoid pushing into derived table
1214 bool is_valid_for_pushdown(uchar *arg [[maybe_unused]]) override {
1215 return true;
1216 }
1217 float get_filtering_effect(THD *thd, table_map filter_for_table,
1218 table_map read_tables,
1219 const MY_BITMAP *fields_to_ignore,
1220 double rows_in_table) override;
1221 /**
1222 We add RAND_TABLE_BIT to prevent moving this item from the JOIN condition:
1223 it might raise an error too early: only if the join condition succeeds is
1224 it relevant and should be evaluated. Cf.
1225 Query_block::decorrelate_derived_scalar_subquery_post
1226
1227 @return Always RAND_TABLE_BIT
1228 */
1230 return RAND_TABLE_BIT;
1231 }
1232};
1233
1234/**
1235 Implements the comparison operator less than (<)
1236*/
1238 public:
1240 longlong val_int() override;
1241 enum Functype functype() const override { return LT_FUNC; }
1242 enum Functype rev_functype() const override { return GT_FUNC; }
1243 cond_result eq_cmp_result() const override { return COND_FALSE; }
1244 const char *func_name() const override { return "<"; }
1245 Item *negated_item() override;
1246};
1247
1248/**
1249 Implements the comparison operator not equals (<>)
1250*/
1252 public:
1253 /// A lower limit for the selectivity of 'field != unknown_value'.
1254 static constexpr double kMinSelectivityForUnknownValue = 0.2;
1255
1257 longlong val_int() override;
1258 enum Functype functype() const override { return NE_FUNC; }
1259 enum Functype rev_functype() const override { return NE_FUNC; }
1260 cond_result eq_cmp_result() const override { return COND_FALSE; }
1261 optimize_type select_optimize(const THD *) override { return OPTIMIZE_KEY; }
1262 const char *func_name() const override { return "<>"; }
1263 Item *negated_item() override;
1264
1265 float get_filtering_effect(THD *thd, table_map filter_for_table,
1266 table_map read_tables,
1267 const MY_BITMAP *fields_to_ignore,
1268 double rows_in_table) override;
1269};
1270
1271/*
1272 The class Item_func_opt_neg is defined to factor out the functionality
1273 common for the classes Item_func_between and Item_func_in. The objects
1274 of these classes can express predicates or their negations.
1275 The alternative approach would be to create pairs Item_func_between,
1276 Item_func_notbetween and Item_func_in, Item_func_notin.
1277
1278*/
1279
1281 public:
1282 bool negated; /* <=> the item represents NOT <func> */
1283 bool pred_level; /* <=> [NOT] <func> is used on a predicate level */
1284 public:
1285 Item_func_opt_neg(const POS &pos, Item *a, Item *b, Item *c, bool is_negation)
1286 : Item_int_func(pos, a, b, c), negated(false), pred_level(false) {
1287 if (is_negation) negate();
1288 }
1289 Item_func_opt_neg(const POS &pos, PT_item_list *list, bool is_negation)
1290 : Item_int_func(pos, list), negated(false), pred_level(false) {
1291 if (is_negation) negate();
1292 }
1293
1294 public:
1295 inline void negate() { negated = !negated; }
1296 inline void apply_is_true() override { pred_level = true; }
1297 bool ignore_unknown() const { return pred_level; }
1299 if (test != BOOL_NEGATED) return nullptr;
1300 negated = !negated;
1301 return this;
1302 }
1303 bool allow_replacement(Item_field *const original,
1304 Item *const subst) override {
1305 /*
1306 If UNKNOWN results can be treated as false (e.g when placed in WHERE, ON
1307 or HAVING), a non-nullable field can be replaced with a nullable one.
1308 */
1309 return ignore_unknown() || original->is_nullable() || !subst->is_nullable();
1310 }
1311
1312 bool eq(const Item *item, bool binary_cmp) const override;
1313 bool subst_argument_checker(uchar **) override { return true; }
1314
1315 protected:
1316 void add_json_info(Json_object *obj) override {
1317 obj->add_alias("negated", create_dom_ptr<Json_boolean>(negated));
1318 }
1319};
1320
1323
1324 public:
1326 String value0, value1, value2;
1327 /* true <=> arguments will be compared as dates. */
1331
1332 /* Comparators used for DATE/DATETIME comparison. */
1334 Item_func_between(const POS &pos, Item *a, Item *b, Item *c, bool is_negation)
1335 : Item_func_opt_neg(pos, a, b, c, is_negation),
1336 compare_as_dates_with_strings(false),
1337 compare_as_temporal_dates(false),
1338 compare_as_temporal_times(false) {}
1339 longlong val_int() override;
1340 optimize_type select_optimize(const THD *) override { return OPTIMIZE_KEY; }
1341 enum Functype functype() const override { return BETWEEN; }
1342 const char *func_name() const override { return "between"; }
1343 bool fix_fields(THD *, Item **) override;
1344 void fix_after_pullout(Query_block *parent_query_block,
1345 Query_block *removed_query_block) override;
1346 bool resolve_type(THD *) override;
1347 void print(const THD *thd, String *str,
1348 enum_query_type query_type) const override;
1349 bool is_bool_func() const override { return true; }
1350 const CHARSET_INFO *compare_collation() const override {
1351 return cmp_collation.collation;
1352 }
1353 uint decimal_precision() const override { return 1; }
1354 bool gc_subst_analyzer(uchar **) override { return true; }
1355
1356 float get_filtering_effect(THD *thd, table_map filter_for_table,
1357 table_map read_tables,
1358 const MY_BITMAP *fields_to_ignore,
1359 double rows_in_table) override;
1360 void update_used_tables() override;
1361
1363 // not_null_tables_cache == union(T1(e),T1(e1),T1(e2))
1364 if (pred_level && !negated) return;
1365
1366 /// not_null_tables_cache == union(T1(e), intersection(T1(e1),T1(e2)))
1368 args[0]->not_null_tables() |
1369 (args[1]->not_null_tables() & args[2]->not_null_tables());
1370 }
1371};
1372
1373class Item_func_strcmp final : public Item_bool_func2 {
1374 public:
1375 Item_func_strcmp(const POS &pos, Item *a, Item *b)
1376 : Item_bool_func2(pos, a, b) {}
1377 longlong val_int() override;
1378 optimize_type select_optimize(const THD *) override { return OPTIMIZE_NONE; }
1379 const char *func_name() const override { return "strcmp"; }
1380 enum Functype functype() const override { return STRCMP_FUNC; }
1381
1382 void print(const THD *thd, String *str,
1383 enum_query_type query_type) const override {
1384 Item_func::print(thd, str, query_type);
1385 }
1386 // We derive (indirectly) from Item_bool_func, but this is not a true boolean.
1387 // Override length and unsigned_flag set by set_data_type_bool().
1388 bool resolve_type(THD *thd) override {
1389 if (Item_bool_func2::resolve_type(thd)) return true;
1390 fix_char_length(2); // returns "1" or "0" or "-1"
1391 unsigned_flag = false;
1392 return false;
1393 }
1394};
1395
1398 double dbl;
1400};
1401
1402class Item_func_interval final : public Item_int_func {
1404
1408
1409 public:
1411 Item *expr2, class PT_item_list *opt_expr_list = nullptr)
1412 : super(pos, alloc_row(pos, mem_root, expr1, expr2, opt_expr_list)),
1413 row(down_cast<Item_row *>(args[0])),
1414 intervals(nullptr) {
1415 allowed_arg_cols = 0; // Fetch this value from first argument
1416 }
1417
1418 bool do_itemize(Parse_context *pc, Item **res) override;
1419 longlong val_int() override;
1420 bool resolve_type(THD *) override;
1421 const char *func_name() const override { return "interval"; }
1422 uint decimal_precision() const override { return 2; }
1423 void print(const THD *thd, String *str,
1424 enum_query_type query_type) const override;
1425 void update_used_tables() override;
1426
1427 private:
1428 // Runs in CTOR init list, cannot access *this as Item_func_interval
1429 static Item_row *alloc_row(const POS &pos, MEM_ROOT *mem_root, Item *expr1,
1430 Item *expr2, class PT_item_list *opt_expr_list);
1431};
1432
1434 protected:
1435 Item_func_coalesce(const POS &pos, Item *a, Item *b)
1436 : Item_func_numhybrid(pos, a, b) {
1437 null_on_null = false;
1438 }
1440 null_on_null = false;
1441 }
1443
1444 public:
1446 : Item_func_numhybrid(pos, list) {
1447 null_on_null = false;
1448 }
1450 return MYSQL_TYPE_VARCHAR;
1451 }
1453 null_on_null = false;
1454 }
1455 TYPELIB *get_typelib() const override;
1456 double real_op() override;
1457 longlong int_op() override;
1458 String *str_op(String *) override;
1459 /**
1460 Get the result of COALESCE as a JSON value.
1461 @param[in,out] wr the result value holder
1462 */
1463 bool val_json(Json_wrapper *wr) override;
1464 bool date_op(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
1465 bool time_op(MYSQL_TIME *ltime) override;
1466 my_decimal *decimal_op(my_decimal *) override;
1467 bool resolve_type(THD *thd) override;
1468 bool resolve_type_inner(THD *thd) override;
1469 void set_numeric_type() override {}
1470 enum Item_result result_type() const override { return hybrid_type; }
1471 const char *func_name() const override { return "coalesce"; }
1472 enum Functype functype() const override { return COALESCE_FUNC; }
1473};
1474
1476 protected:
1478
1479 public:
1480 Item_func_ifnull(const POS &pos, Item *a, Item *b)
1481 : Item_func_coalesce(pos, a, b) {}
1482 double real_op() override;
1483 longlong int_op() override;
1484 String *str_op(String *str) override;
1485 bool date_op(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
1486 bool time_op(MYSQL_TIME *ltime) override;
1487 my_decimal *decimal_op(my_decimal *) override;
1488 bool val_json(Json_wrapper *result) override;
1489 const char *func_name() const override { return "ifnull"; }
1490 Field *tmp_table_field(TABLE *table) override;
1491};
1492
1493/**
1494 ANY_VALUE(expr) is like expr except that it is not checked by
1495 aggregate_check logic. It serves as a solution for users who want to
1496 bypass this logic.
1497*/
1499 public:
1500 Item_func_any_value(const POS &pos, Item *a) : Item_func_coalesce(pos, a) {}
1502 const char *func_name() const override { return "any_value"; }
1503 bool aggregate_check_group(uchar *arg) override;
1504 bool aggregate_check_distinct(uchar *arg) override;
1506
1507 private:
1508 // used when walk'ing with collect_item_field_or_view_ref_processor
1509 bool m_phase_post{false};
1510};
1511
1512class Item_func_if final : public Item_func {
1514
1515 public:
1517 : Item_func(a, b, c), cached_result_type(INT_RESULT) {
1518 null_on_null = false;
1519 }
1520 Item_func_if(const POS &pos, Item *a, Item *b, Item *c)
1521 : Item_func(pos, a, b, c), cached_result_type(INT_RESULT) {
1522 null_on_null = false;
1523 }
1524
1525 double val_real() override;
1526 longlong val_int() override;
1527 String *val_str(String *str) override;
1528 my_decimal *val_decimal(my_decimal *) override;
1529 bool val_json(Json_wrapper *wr) override;
1530 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
1531 bool get_time(MYSQL_TIME *ltime) override;
1532 enum Item_result result_type() const override { return cached_result_type; }
1533 bool fix_fields(THD *, Item **) override;
1535 return MYSQL_TYPE_VARCHAR;
1536 }
1537 bool resolve_type(THD *thd) override;
1538 bool resolve_type_inner(THD *thd) override;
1539 void fix_after_pullout(Query_block *parent_query_block,
1540 Query_block *removed_query_block) override;
1541 TYPELIB *get_typelib() const override;
1542 const char *func_name() const override { return "if"; }
1543 enum Functype functype() const override { return IF_FUNC; }
1544 void update_used_tables() override;
1545
1546 ///< T1(IF(e,e1,e2)) = intersection(T1(e1),T1(e2))
1549 (args[1]->not_null_tables() & args[2]->not_null_tables());
1550 }
1551};
1552
1553class Item_func_nullif final : public Item_bool_func2 {
1555
1556 public:
1557 Item_func_nullif(const POS &pos, Item *a, Item *b)
1558 : Item_bool_func2(pos, a, b), cached_result_type(INT_RESULT) {
1559 null_on_null = false;
1560 }
1561 double val_real() override;
1562 longlong val_int() override;
1563 String *val_str(String *str) override;
1564 my_decimal *val_decimal(my_decimal *) override;
1565 bool val_json(Json_wrapper *wr) override;
1566 Item_result result_type() const override { return cached_result_type; }
1568 return MYSQL_TYPE_VARCHAR;
1569 }
1570 bool resolve_type(THD *thd) override;
1571 bool resolve_type_inner(THD *thd) override;
1572 TYPELIB *get_typelib() const override;
1573 const char *func_name() const override { return "nullif"; }
1574 enum Functype functype() const override { return NULLIF_FUNC; }
1575
1576 // No, we should NOT inherit from Item_bool_func2
1577 uint decimal_precision() const override { return Item::decimal_precision(); }
1578
1579 void print(const THD *thd, String *str,
1580 enum_query_type query_type) const override {
1581 Item_func::print(thd, str, query_type);
1582 }
1583
1584 bool is_null() override;
1585 /**
1586 This is a workaround for the broken inheritance hierarchy: this should
1587 inherit from Item_func instead of Item_bool_func2
1588 */
1589 bool is_bool_func() const override { return false; }
1590};
1591
1592/* Functions to handle the optimized IN */
1593
1594/* A vector of values of some type */
1595
1597 private:
1598 const uint m_size; ///< Size of the vector
1599 public:
1600 uint m_used_size{0}; ///< The actual size of the vector (NULL may be ignored)
1601
1602 /**
1603 See Item_func_in::resolve_type() for why we need both
1604 count and used_count.
1605 */
1606 explicit in_vector(uint elements) : m_size(elements) {}
1607
1608 virtual ~in_vector() = default;
1609
1610 /**
1611 Calls item->val_int() or item->val_str() etc.
1612 and then does binary_search if the value is non-null.
1613 @param item to evaluate, and lookup in the IN-list.
1614 @return true if evaluated value of the item was found.
1615 */
1616 virtual bool find_item(Item *item) = 0;
1617
1618 /**
1619 Create an instance of Item_{type} (e.g. Item_decimal) constant object
1620 which type allows it to hold an element of this vector without any
1621 conversions.
1622 The purpose of this function is to be able to get elements of this
1623 vector in form of Item_xxx constants without creating Item_xxx object
1624 for every array element you get (i.e. this implements "FlyWeight" pattern)
1625
1626 @param mem_root Where to allocate the Item.
1627 */
1629
1630 /**
1631 Store the value at position #pos into provided item object
1632
1633 @param pos Index of value to store
1634 @param item Constant item to store value into. The item must be of the same
1635 type that create_item() returns.
1636 */
1637 virtual void value_to_item(uint pos, Item_basic_constant *item) const = 0;
1638
1639 /** Compare values number pos1 and pos2 for equality */
1640 virtual bool compare_elems(uint pos1, uint pos2) const = 0;
1641
1642 virtual bool is_row_result() const { return false; }
1643
1644 /**
1645 Fill the vector by evaluating the items passed as arguments.
1646 Note that null values are skipped so the vector may end up containing
1647 fewer elements than the number of items.
1648 The vector is sorted so that it can be used for binary search.
1649
1650 @param items Items to evaluate
1651 @param item_count Number of items
1652
1653 @return true if any null values was found, false otherwise.
1654 */
1655 bool fill(Item **items, uint item_count);
1656 virtual void cleanup() {}
1657
1658 private:
1659 virtual void set(uint pos, Item *item) = 0;
1660
1661 /// Sort the IN-list array, so we can do efficient lookup with binary_search.
1662 virtual void sort_array() = 0;
1663};
1664
1665class in_string final : public in_vector {
1669 // String objects are not sortable, sort pointers instead.
1672
1673 public:
1674 in_string(MEM_ROOT *mem_root, uint elements, const CHARSET_INFO *cs);
1676 return new (mem_root) Item_string(collation);
1677 }
1678 void value_to_item(uint pos, Item_basic_constant *item) const override {
1679 item->set_str_value(base_pointers[pos]);
1680 }
1681 bool find_item(Item *item) override;
1682 bool compare_elems(uint pos1, uint pos2) const override;
1683 void cleanup() override;
1684
1685 private:
1686 void set(uint pos, Item *item) override;
1687 void sort_array() override;
1688};
1689
1690class in_longlong : public in_vector {
1691 public:
1695 };
1696
1697 protected:
1699
1700 public:
1702 : in_vector(elements), base(mem_root, elements) {}
1704 /*
1705 We've created a signed INT, this may not be correct in the
1706 general case (see BUG#19342).
1707 */
1708 return new (mem_root) Item_int(0LL);
1709 }
1710 void value_to_item(uint pos, Item_basic_constant *item) const override {
1711 down_cast<Item_int *>(item)->value = base[pos].val;
1712 item->unsigned_flag = base[pos].unsigned_flag;
1713 }
1714 bool find_item(Item *item) override;
1715 bool compare_elems(uint pos1, uint pos2) const override;
1716
1717 private:
1718 void set(uint pos, Item *item) override { val_item(item, &base[pos]); }
1719 void sort_array() override;
1720 virtual void val_item(Item *item, packed_longlong *result);
1721};
1722
1724 public:
1726 : in_longlong(mem_root, elements) {}
1728 return new (mem_root) Item_temporal(MYSQL_TYPE_DATETIME, 0LL);
1729 }
1730
1731 private:
1732 void val_item(Item *item, packed_longlong *result) override;
1733};
1734
1735class in_time_as_longlong final : public in_longlong {
1736 public:
1738 : in_longlong(mem_root, elements) {}
1740 return new (mem_root) Item_temporal(MYSQL_TYPE_TIME, 0LL);
1741 }
1742
1743 private:
1744 void val_item(Item *item, packed_longlong *result) override;
1745};
1746
1747/*
1748 Class to represent a vector of constant DATE/DATETIME values.
1749 Values are obtained with help of the get_datetime_value() function.
1750*/
1751class in_datetime final : public in_longlong {
1752 /// An item used to issue warnings.
1754
1755 public:
1756 in_datetime(MEM_ROOT *mem_root, Item *warn_item_arg, uint elements)
1757 : in_longlong(mem_root, elements), warn_item(warn_item_arg) {}
1759 return new (mem_root) Item_temporal(MYSQL_TYPE_DATETIME, 0LL);
1760 }
1761
1762 private:
1763 void set(uint pos, Item *item) override;
1764 void val_item(Item *item, packed_longlong *result) override;
1765};
1766
1767class in_double final : public in_vector {
1769
1770 public:
1771 in_double(MEM_ROOT *mem_root, uint elements)
1772 : in_vector(elements), base(mem_root, elements) {}
1774 return new (mem_root) Item_float(0.0, 0);
1775 }
1776 void value_to_item(uint pos, Item_basic_constant *item) const override {
1777 down_cast<Item_float *>(item)->value = base[pos];
1778 }
1779 bool find_item(Item *item) override;
1780 bool compare_elems(uint pos1, uint pos2) const override;
1781
1782 private:
1783 void set(uint pos, Item *item) override;
1784 void sort_array() override;
1785};
1786
1787class in_decimal final : public in_vector {
1789
1790 public:
1792 : in_vector(elements), base(mem_root, elements) {}
1794 return new (mem_root) Item_decimal(0, false);
1795 }
1796 void value_to_item(uint pos, Item_basic_constant *item) const override {
1797 down_cast<Item_decimal *>(item)->set_decimal_value(&base[pos]);
1798 }
1799 bool find_item(Item *item) override;
1800 bool compare_elems(uint pos1, uint pos2) const override;
1801
1802 private:
1803 void set(uint pos, Item *item) override;
1804 void sort_array() override;
1805};
1806
1807/*
1808** Classes for easy comparing of non const items
1809*/
1810
1812 public:
1813 cmp_item() = default;
1814 virtual ~cmp_item() = default;
1815 /**
1816 Allocate comparator objects for each value object, based on the template
1817 comparator objects. Only implemented for derived class cmp_item_row.
1818
1819 @param mem_root mem_root for allocation.
1820 @param tmpl The template item object.
1821 @param arg The value item.
1822
1823 @returns false if success, true if error.
1824 */
1825 virtual bool allocate_value_comparators(MEM_ROOT *mem_root, cmp_item *tmpl,
1826 Item *arg);
1827 virtual void store_value(Item *item) = 0;
1828 /**
1829 @returns result (true, false or UNKNOWN) of
1830 "stored argument's value <> item's value"
1831 */
1832 virtual int cmp(Item *item) = 0;
1833 // for optimized IN with row
1834 virtual int compare(const cmp_item *item) const = 0;
1835
1836 /**
1837 Create an appropriate comparator for the given type.
1838
1839 @param thd Session handle.
1840 @param result_type Used to find the appropriate comparator.
1841 @param item Item object used to distinguish temporal types.
1842 @param cs Charset
1843
1844 @returns new cmp_item_xxx object, or nullptr if error.
1845 */
1846 static cmp_item *new_comparator(THD *thd, Item_result result_type, Item *item,
1847 const CHARSET_INFO *cs);
1848 virtual cmp_item *make_same() = 0;
1849 virtual void store_value_by_template(cmp_item *, Item *item) {
1850 store_value(item);
1851 }
1852 virtual void set_null_value(bool nv) = 0;
1853};
1854
1855/// cmp_item which stores a scalar (i.e. non-ROW).
1857 protected:
1858 bool m_null_value; ///< If stored value is NULL
1859 void set_null_value(bool nv) override { m_null_value = nv; }
1860};
1861
1862class cmp_item_string final : public cmp_item_scalar {
1863 private:
1867
1868 public:
1869 cmp_item_string(const CHARSET_INFO *cs) : value(cs), cmp_charset(cs) {}
1870
1871 int compare(const cmp_item *ci) const override {
1872 const cmp_item_string *l_cmp = down_cast<const cmp_item_string *>(ci);
1873 return sortcmp(value_res, l_cmp->value_res, cmp_charset);
1874 }
1875
1876 void store_value(Item *item) override {
1877 String *res = eval_string_arg(cmp_charset, item, &value);
1878 if (res && (res != &value || !res->is_alloced())) {
1879 // 'res' may point in item's transient internal data, so make a copy
1880 value.copy(*res);
1881 }
1882 value_res = &value;
1883 set_null_value(item->null_value);
1884 }
1885
1886 int cmp(Item *arg) override;
1887 cmp_item *make_same() override;
1888};
1889
1890class cmp_item_json final : public cmp_item_scalar {
1891 private:
1892 /// Cached JSON value to look up
1894 /// Cache for the value above
1896 /// String buffer
1898
1899 public:
1900 /**
1901 Construct a cmp_item_json object.
1902 @param wrapper a Json_wrapper for holding the JSON value in the comparison
1903 @param holder pre-alloced memory for creating JSON scalar values without
1904 using the heap
1905 */
1908 ~cmp_item_json() override;
1909
1910 int compare(const cmp_item *ci) const override;
1911 void store_value(Item *item) override;
1912 int cmp(Item *arg) override;
1913 cmp_item *make_same() override;
1914};
1915
1916class cmp_item_int final : public cmp_item_scalar {
1918
1919 public:
1920 void store_value(Item *item) override {
1921 value = item->val_int();
1922 set_null_value(item->null_value);
1923 }
1924 int cmp(Item *arg) override {
1925 const bool rc = value != arg->val_int();
1926 return (m_null_value || arg->null_value) ? UNKNOWN : rc;
1927 }
1928 int compare(const cmp_item *ci) const override {
1929 const cmp_item_int *l_cmp = down_cast<const cmp_item_int *>(ci);
1930 return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
1931 }
1932 cmp_item *make_same() override;
1933};
1934
1935/*
1936 Compare items of temporal type.
1937 Values are obtained with: get_datetime_value() (DATE/DATETIME/TIMESTAMP) and
1938 get_time_value() (TIME).
1939*/
1942
1943 public:
1944 /* Item used for issuing warnings. */
1946 /// Distinguish between DATE/DATETIME/TIMESTAMP and TIME
1948
1949 cmp_item_datetime(const Item *warn_item_arg);
1950 void store_value(Item *item) override;
1951 int cmp(Item *arg) override;
1952 int compare(const cmp_item *ci) const override;
1953 cmp_item *make_same() override;
1954};
1955
1957 double value;
1958
1959 public:
1960 void store_value(Item *item) override {
1961 value = item->val_real();
1962 set_null_value(item->null_value);
1963 }
1964 int cmp(Item *arg) override {
1965 const bool rc = value != arg->val_real();
1966 return (m_null_value || arg->null_value) ? UNKNOWN : rc;
1967 }
1968 int compare(const cmp_item *ci) const override {
1969 const cmp_item_real *l_cmp = down_cast<const cmp_item_real *>(ci);
1970 return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
1971 }
1972 cmp_item *make_same() override;
1973};
1974
1977
1978 public:
1979 void store_value(Item *item) override;
1980 int cmp(Item *arg) override;
1981 int compare(const cmp_item *c) const override;
1982 cmp_item *make_same() override;
1983};
1984
1985/**
1986 CASE ... WHEN ... THEN ... END function implementation.
1987
1988 When there is no expression between CASE and the first WHEN
1989 (the CASE expression) then this function simple checks all WHEN expressions
1990 one after another. When some WHEN expression evaluated to TRUE then the
1991 value of the corresponding THEN expression is returned.
1992
1993 When the CASE expression is specified then it is compared to each WHEN
1994 expression individually. When an equal WHEN expression is found
1995 corresponding THEN expression is returned.
1996 In order to do correct comparisons several comparators are used. One for
1997 each result type. Different result types that are used in particular
1998 CASE ... END expression are collected in the resolve_type() member
1999 function and only comparators for there result types are used.
2000*/
2001
2002class Item_func_case final : public Item_func {
2004
2005 int first_expr_num, else_expr_num;
2006 enum Item_result cached_result_type, left_result_type;
2011 cmp_item *cmp_items[5]; /* For all result types */
2013
2014 protected:
2015 void add_json_info(Json_object *obj) override {
2016 obj->add_alias("has_case_expression",
2017 create_dom_ptr<Json_boolean>(get_first_expr_num() != -1));
2018 }
2019
2020 public:
2022 Item *first_expr_arg, Item *else_expr_arg)
2023 : super(pos),
2024 first_expr_num(-1),
2025 else_expr_num(-1),
2026 cached_result_type(INT_RESULT),
2027 left_result_type(INT_RESULT),
2028 case_item(nullptr) {
2029 null_on_null = false;
2030 ncases = list->size();
2031 if (first_expr_arg) {
2032 first_expr_num = list->size();
2033 list->push_back(first_expr_arg);
2034 }
2035 if (else_expr_arg) {
2036 else_expr_num = list->size();
2037 list->push_back(else_expr_arg);
2038 }
2039 set_arguments(list, true);
2040 memset(&cmp_items, 0, sizeof(cmp_items));
2041 }
2042 ~Item_func_case() override;
2043 int get_first_expr_num() const { return first_expr_num; }
2044 int get_else_expr_num() const { return else_expr_num; }
2045 double val_real() override;
2046 longlong val_int() override;
2047 String *val_str(String *) override;
2048 my_decimal *val_decimal(my_decimal *) override;
2049 bool val_json(Json_wrapper *wr) override;
2050 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
2051 bool get_time(MYSQL_TIME *ltime) override;
2052 bool fix_fields(THD *thd, Item **ref) override;
2054 return MYSQL_TYPE_VARCHAR;
2055 }
2056 bool resolve_type(THD *thd) override;
2057 bool resolve_type_inner(THD *thd) override;
2058 TYPELIB *get_typelib() const override;
2059 enum Item_result result_type() const override { return cached_result_type; }
2060 const char *func_name() const override { return "case"; }
2061 void print(const THD *thd, String *str,
2062 enum_query_type query_type) const override;
2063 Item *find_item(String *str);
2064 const CHARSET_INFO *compare_collation() const override {
2065 return cmp_collation.collation;
2066 }
2067 enum Functype functype() const override { return CASE_FUNC; }
2068};
2069
2070/**
2071 in_expr [NOT] IN (in_value_list).
2072
2073 The current implementation distinguishes 2 cases:
2074 1) all items in in_value_list are constants and have the same
2075 result type. This case is handled by in_vector class.
2076 2) otherwise Item_func_in employs several cmp_item objects to perform
2077 comparisons of in_expr and an item from in_value_list. One cmp_item
2078 object for each result type. Different result types are collected in the
2079 resolve_type() member function by means of collect_cmp_types() function.
2080*/
2081class Item_func_in final : public Item_func_opt_neg {
2082 public:
2083 /// An array of const values, created when the bisection lookup method is used
2084 in_vector *m_const_array{nullptr};
2085 /**
2086 If there is some NULL among @<in value list@>, during a val_int() call; for
2087 example
2088 IN ( (1,(3,'col')), ... ), where 'col' is a column which evaluates to
2089 NULL.
2090 */
2091 bool have_null{false};
2092 /// Set to true when values in const array are populated
2093 bool m_populated{false};
2094
2095 private:
2096 /// Set to true if all values in IN-list are const
2097 bool m_values_are_const{true};
2098 /// Set to true if const array must be repopulated per execution.
2099 bool m_need_populate{false};
2100 /**
2101 Set to true by resolve_type() if the IN list contains a
2102 dependent subquery, in which case condition filtering will not be
2103 calculated for this item.
2104 */
2105 bool dep_subq_in_list{false};
2106 /// True until start of 2nd call to resolve_type()
2107 bool first_resolve_call{true};
2108
2110 cmp_item *cmp_items[6]; /* One cmp_item for each result type */
2112
2113 public:
2114 Item_func_in(const POS &pos, PT_item_list *list, bool is_negation)
2115 : Item_func_opt_neg(pos, list, is_negation) {
2116 memset(&cmp_items, 0, sizeof(cmp_items));
2117 allowed_arg_cols = 0; // Fetch this value from first argument
2118 }
2119 ~Item_func_in() override;
2120 longlong val_int() override;
2121 bool fix_fields(THD *, Item **) override;
2122 void fix_after_pullout(Query_block *parent_query_block,
2123 Query_block *removed_query_block) override;
2124 bool resolve_type(THD *) override;
2125 void update_used_tables() override;
2126 uint decimal_precision() const override { return 1; }
2127
2128 /**
2129 Populate values for bisection with fresh values, should be called once
2130 per execution.
2131
2132 @param thd Thread handler
2133
2134 @returns false if success, true if error
2135 */
2136 bool populate_bisection(THD *thd);
2137 void cleanup() override;
2138 optimize_type select_optimize(const THD *) override { return OPTIMIZE_KEY; }
2139 void print(const THD *thd, String *str,
2140 enum_query_type query_type) const override;
2141 enum Functype functype() const override { return IN_FUNC; }
2142 const char *func_name() const override { return " IN "; }
2143 bool is_bool_func() const override { return true; }
2144 const CHARSET_INFO *compare_collation() const override {
2145 return cmp_collation.collation;
2146 }
2147 bool gc_subst_analyzer(uchar **) override { return true; }
2148
2149 float get_filtering_effect(THD *thd, table_map filter_for_table,
2150 table_map read_tables,
2151 const MY_BITMAP *fields_to_ignore,
2152 double rows_in_table) override;
2153
2155 // not_null_tables_cache == union(T1(e),union(T1(ei)))
2156 if (pred_level && negated) return;
2157
2159
2160 ///< not_null_tables_cache = union(T1(e),intersection(T1(ei)))
2161 Item **arg_end = args + arg_count;
2162 for (Item **arg = args + 1; arg != arg_end; arg++)
2163 not_null_tables_cache &= (*arg)->not_null_tables();
2165 }
2166
2167 private:
2168 /**
2169 Usable if @<in value list@> is made only of constants. Returns true if one
2170 of these constants contains a NULL. Example:
2171 IN ( (-5, (12,NULL)), ... ).
2172 */
2173 bool list_contains_null();
2174 /**
2175 Utility function to help calculate the total filtering effect of
2176 IN predicates. This function calculates the filtering effect from
2177 a single field (or field reference) on the left hand side of the
2178 expression.
2179
2180 @param fieldref Field (or field reference) on left hand side of
2181 IN, i.e., this function should be called for
2182 each fi in "(f1,...,fn) IN (values)"
2183 @param filter_for_table The table we are calculating filter effect for
2184 @param fields_to_ignore Fields in 'filter_for_table' that should not
2185 be part of the filter calculation. The filtering
2186 effect of these fields are already part of the
2187 calculation somehow (e.g. because there is a
2188 predicate "col = <const>", and the optimizer
2189 has decided to do ref access on 'col').
2190 @param rows_in_table The number of rows in table 'filter_for_table'
2191
2192 @return the filtering effect (between 0 and 1) 'the_field'
2193 participates with in this IN predicate.
2194 */
2195 float get_single_col_filtering_effect(Item_ident *fieldref,
2196 table_map filter_for_table,
2197 const MY_BITMAP *fields_to_ignore,
2198 double rows_in_table);
2199 void cleanup_arrays(); ///< Helper function for this common task
2200};
2201
2202class cmp_item_row : public cmp_item {
2203 cmp_item **comparators{nullptr};
2204 uint n;
2205
2206 // Only used for Mem_root_array::resize()
2207 cmp_item_row() : n(0) {}
2208
2209 friend class Mem_root_array_YY<cmp_item_row>;
2210
2211 public:
2212 cmp_item_row(THD *thd, Item *item) : n(item->cols()) {
2213 allocate_template_comparators(thd, item);
2214 }
2215 ~cmp_item_row() override;
2216
2218 : comparators(other.comparators), n(other.n) {
2219 other.comparators = nullptr;
2220 other.n = 0;
2221 }
2222
2223 bool allocate_value_comparators(MEM_ROOT *mem_root, cmp_item *tmpl,
2224 Item *arg) override;
2225 void store_value(Item *item) override;
2226 int cmp(Item *arg) override;
2227 int compare(const cmp_item *arg) const override;
2228 cmp_item *make_same() override;
2229 void store_value_by_template(cmp_item *tmpl, Item *) override;
2230 void set_null_value(bool nv) override {
2231 for (uint i = 0; i < n; i++) {
2232 comparators[i]->set_null_value(nv);
2233 }
2234 }
2235
2236 private:
2237 /**
2238 Allocate comparator objects for the LHS argument to IN, used as template
2239 for the value comparators.
2240
2241 @param thd Session handle
2242 @param item Item to allocate comparator objects for, left-hand IN operand
2243
2244 @returns false if success, true if error.
2245 */
2246 bool allocate_template_comparators(THD *thd, Item *item);
2247};
2248
2249class in_row final : public in_vector {
2252 // Sort pointers, rather than objects.
2254
2255 public:
2256 in_row(MEM_ROOT *mem_root, uint elements, cmp_item_row *cmp);
2257 bool is_row_result() const override { return true; }
2258 /**
2259 Allocate extra objects for evaluation
2260
2261 @param mem_root Memory root for allocation.
2262 @param lhs The left-hand side object of the IN predicate.
2263 @param arg_count Number of arguments on the right-hand side of the predicate
2264
2265 @returns false if success, true if error.
2266 */
2267 bool allocate(MEM_ROOT *mem_root, Item *lhs, uint arg_count);
2268 bool find_item(Item *item) override;
2269 bool compare_elems(uint pos1, uint pos2) const override;
2270
2272 assert(false);
2273 return nullptr;
2274 }
2275 void value_to_item(uint, Item_basic_constant *) const override {
2276 assert(false);
2277 }
2278
2279 private:
2280 void set(uint pos, Item *item) override;
2281 void sort_array() override;
2282};
2283
2284/* Functions used by where clause */
2285
2288
2289 bool cache_used = false;
2291
2292 public:
2294 Item_func_isnull(const POS &pos, Item *a) : super(pos, a) {
2295 null_on_null = false;
2296 }
2297 longlong val_int() override;
2298 enum Functype functype() const override { return ISNULL_FUNC; }
2299 bool resolve_type(THD *thd) override;
2300 const char *func_name() const override { return "isnull"; }
2301 /* Optimize case of not_null_column IS NULL */
2302 void update_used_tables() override;
2303
2304 float get_filtering_effect(THD *thd, table_map filter_for_table,
2305 table_map read_tables,
2306 const MY_BITMAP *fields_to_ignore,
2307 double rows_in_table) override;
2308 optimize_type select_optimize(const THD *) override { return OPTIMIZE_NULL; }
2309 Item *truth_transformer(THD *, Bool_test test) override;
2310 void print(const THD *thd, String *str,
2311 enum_query_type query_type) const override;
2312 const CHARSET_INFO *compare_collation() const override {
2313 return args[0]->collation.collation;
2314 }
2315 bool fix_fields(THD *thd, Item **ref) override;
2316};
2317
2318/* Functions used by HAVING for rewriting IN subquery */
2319
2320/*
2321 This is like IS NOT NULL but it also remembers if it ever has
2322 encountered a NULL; it remembers this in the "was_null" property of the
2323 "owner" item.
2324*/
2327
2328 public:
2330 : Item_func_isnull(a), owner(ow) {}
2331 enum Functype functype() const override { return ISNOTNULLTEST_FUNC; }
2332 longlong val_int() override;
2333 const char *func_name() const override { return "<is_not_null_test>"; }
2334 bool resolve_type(THD *thd) override;
2335 void update_used_tables() override;
2336 /**
2337 We add RAND_TABLE_BIT to prevent moving this item from HAVING to WHERE.
2338
2339 @retval Always RAND_TABLE_BIT
2340 */
2342 return RAND_TABLE_BIT;
2343 }
2344 void print(const THD *thd, String *str,
2345 enum_query_type query_type) const override {
2346 Item_bool_func::print(thd, str, query_type);
2347 }
2348};
2349
2351 public:
2353 Item_func_isnotnull(const POS &pos, Item *a) : Item_bool_func(pos, a) {
2354 null_on_null = false;
2355 }
2356
2357 longlong val_int() override;
2358 enum Functype functype() const override { return ISNOTNULL_FUNC; }
2359 bool resolve_type(THD *thd) override {
2360 set_nullable(false);
2361 return Item_bool_func::resolve_type(thd);
2362 }
2363 const char *func_name() const override { return "isnotnull"; }
2364 optimize_type select_optimize(const THD *) override { return OPTIMIZE_NULL; }
2365 Item *truth_transformer(THD *, Bool_test test) override;
2366 void print(const THD *thd, String *str,
2367 enum_query_type query_type) const override;
2368 const CHARSET_INFO *compare_collation() const override {
2369 return args[0]->collation.collation;
2370 }
2371 void apply_is_true() override {
2372 null_on_null = true;
2373 } // Same logic as for Item_func_truth's function
2374 float get_filtering_effect(THD *thd, table_map filter_for_table,
2375 table_map read_tables,
2376 const MY_BITMAP *fields_to_ignore,
2377 double rows_in_table) override;
2378};
2379
2380class Item_func_like final : public Item_bool_func2 {
2381 /// True if escape clause is const (a literal)
2382 bool escape_is_const = false;
2383 /// Tells if the escape clause has been evaluated.
2384 bool escape_evaluated = false;
2385 bool eval_escape_clause(THD *thd);
2386 /// The escape character (0 if no escape character).
2388
2389 public:
2391 Item_func_like(Item *a, Item *b, Item *escape_arg)
2392 : Item_bool_func2(a, b, escape_arg) {
2393 assert(escape_arg != nullptr);
2394 }
2395 Item_func_like(const POS &pos, Item *a, Item *b, Item *escape_arg)
2396 : Item_bool_func2(pos, a, b, escape_arg) {
2397 assert(escape_arg != nullptr);
2398 }
2399 Item_func_like(const POS &pos, Item *a, Item *b)
2400 : Item_bool_func2(pos, a, b) {}
2401
2402 longlong val_int() override;
2403 enum Functype functype() const override { return LIKE_FUNC; }
2404 optimize_type select_optimize(const THD *thd) override;
2405 /// Result may be not equal with equal inputs if ESCAPE character is present
2406 cond_result eq_cmp_result() const override { return COND_OK; }
2407 const char *func_name() const override { return "like"; }
2408 bool fix_fields(THD *thd, Item **ref) override;
2409 bool resolve_type(THD *) override;
2410 void cleanup() override;
2411 Item *replace_scalar_subquery(uchar *) override;
2412 // Overridden because Item_bool_func2::print() doesn't print the ESCAPE
2413 // clause.
2414 void print(const THD *thd, String *str,
2415 enum_query_type query_type) const override;
2416 /**
2417 @retval true non default escape char specified
2418 using "expr LIKE pat ESCAPE 'escape_char'" syntax
2419 */
2420 bool escape_was_used_in_parsing() const { return arg_count > 2; }
2421
2422 /// Returns the escape character.
2423 int escape() const {
2424 assert(escape_is_evaluated());
2425 return m_escape;
2426 }
2427
2428 /**
2429 Has the escape clause been evaluated? It only needs to be evaluated
2430 once per execution, since we require it to be constant during execution.
2431 The escape member has a valid value if and only if this function returns
2432 true.
2433 */
2434 bool escape_is_evaluated() const { return escape_evaluated; }
2435
2436 float get_filtering_effect(THD *thd, table_map filter_for_table,
2437 table_map read_tables,
2438 const MY_BITMAP *fields_to_ignore,
2439 double rows_in_table) override;
2440
2441 private:
2442 /**
2443 The method updates covering keys depending on the
2444 length of wild string prefix.
2445
2446 @param thd Pointer to THD object.
2447
2448 @retval true if error happens during wild string prefix calculation,
2449 false otherwise.
2450 */
2451 bool check_covering_prefix_keys(THD *thd);
2452};
2453
2456
2457 protected:
2460
2461 public:
2462 /* Item_cond() is only used to create top level items */
2465 list.push_back(i1);
2466 list.push_back(i2);
2467 }
2468 Item_cond(const POS &pos, Item *i1, Item *i2)
2469 : Item_bool_func(pos), abort_on_null(false) {
2470 list.push_back(i1);
2471 list.push_back(i2);
2472 }
2473
2474 Item_cond(THD *thd, Item_cond *item);
2476 : Item_bool_func(), list(nlist), abort_on_null(false) {}
2477 bool add(Item *item) {
2478 assert(item);
2479 return list.push_back(item);
2480 }
2481 bool add_at_head(Item *item) {
2482 assert(item);
2483 return list.push_front(item);
2484 }
2486 assert(nlist->elements);
2487 list.prepend(nlist);
2488 }
2489
2490 bool do_itemize(Parse_context *pc, Item **res) override;
2491
2492 bool fix_fields(THD *, Item **ref) override;
2493 void fix_after_pullout(Query_block *parent_query_block,
2494 Query_block *removed_query_block) override;
2495
2496 Type type() const override { return COND_ITEM; }
2498 bool eq(const Item *item, bool binary_cmp) const override;
2499 table_map used_tables() const override { return used_tables_cache; }
2500 void update_used_tables() override;
2501 void print(const THD *thd, String *str,
2502 enum_query_type query_type) const override;
2503 bool split_sum_func(THD *thd, Ref_item_array ref_item_array,
2504 mem_root_deque<Item *> *fields) override;
2505 void apply_is_true() override { abort_on_null = true; }
2506 void copy_andor_arguments(THD *thd, Item_cond *item);
2507 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
2508 Item *transform(Item_transformer transformer, uchar *arg) override;
2509 void traverse_cond(Cond_traverser, void *arg, traverse_order order) override;
2510 bool truth_transform_arguments(THD *thd, Bool_test test);
2511 bool subst_argument_checker(uchar **) override { return true; }
2512 Item *compile(Item_analyzer analyzer, uchar **arg_p,
2513 Item_transformer transformer, uchar *arg_t) override;
2514 bool remove_const_conds(THD *thd, Item *item, Item **new_item);
2515 /// Treat UNKNOWN result like FALSE because callers see no difference
2516 bool ignore_unknown() const { return abort_on_null; }
2517 bool equality_substitution_analyzer(uchar **) override { return true; }
2518};
2519
2520/*
2521 The class Item_equal is used to represent conjunctions of equality
2522 predicates of the form field1 = field2, and field=const in where
2523 conditions and on expressions.
2524
2525 All equality predicates of the form field1=field2 contained in a
2526 conjunction are substituted for a sequence of items of this class.
2527 An item of this class Item_equal(f1,f2,...fk) represents a
2528 multiple equality f1=f2=...=fk.
2529
2530 If a conjunction contains predicates f1=f2 and f2=f3, a new item of
2531 this class is created Item_equal(f1,f2,f3) representing the multiple
2532 equality f1=f2=f3 that substitutes the above equality predicates in
2533 the conjunction.
2534 A conjunction of the predicates f2=f1 and f3=f1 and f3=f2 will be
2535 substituted for the item representing the same multiple equality
2536 f1=f2=f3.
2537 An item Item_equal(f1,f2) can appear instead of a conjunction of
2538 f2=f1 and f1=f2, or instead of just the predicate f1=f2.
2539
2540 An item of the class Item_equal inherits equalities from outer
2541 conjunctive levels.
2542
2543 Suppose we have a where condition of the following form:
2544 WHERE f1=f2 AND f3=f4 AND f3=f5 AND ... AND (...OR (f1=f3 AND ...)).
2545 In this case:
2546 f1=f2 will be substituted for Item_equal(f1,f2);
2547 f3=f4 and f3=f5 will be substituted for Item_equal(f3,f4,f5);
2548 f1=f3 will be substituted for Item_equal(f1,f2,f3,f4,f5);
2549
2550 An object of the class Item_equal can contain an optional constant
2551 item c. Then it represents a multiple equality of the form
2552 c=f1=...=fk.
2553
2554 Objects of the class Item_equal are used for the following:
2555
2556 1. An object Item_equal(t1.f1,...,tk.fk) allows us to consider any
2557 pair of tables ti and tj as joined by an equi-condition.
2558 Thus it provide us with additional access paths from table to table.
2559
2560 2. An object Item_equal(t1.f1,...,tk.fk) is applied to deduce new
2561 SARGable predicates:
2562 f1=...=fk AND P(fi) => f1=...=fk AND P(fi) AND P(fj).
2563 It also can give us additional index scans and can allow us to
2564 improve selectivity estimates.
2565
2566 3. An object Item_equal(t1.f1,...,tk.fk) is used to optimize the
2567 selected execution plan for the query: if table ti is accessed
2568 before the table tj then in any predicate P in the where condition
2569 the occurrence of tj.fj is substituted for ti.fi. This can allow
2570 an evaluation of the predicate at an earlier step.
2571
2572 When feature 1 is supported they say that join transitive closure
2573 is employed.
2574 When feature 2 is supported they say that search argument transitive
2575 closure is employed.
2576 Both features are usually supported by preprocessing original query and
2577 adding additional predicates.
2578 We do not just add predicates, we rather dynamically replace some
2579 predicates that can not be used to access tables in the investigated
2580 plan for those, obtained by substitution of some fields for equal fields,
2581 that can be used.
2582
2583 Prepared Statements/Stored Procedures note: instances of class
2584 Item_equal are created only at the time a PS/SP is executed and
2585 are deleted in the end of execution. All changes made to these
2586 objects need not be registered in the list of changes of the parse
2587 tree and do not harm PS/SP re-execution.
2588
2589 Item equal objects are employed only at the optimize phase. Usually they are
2590 not supposed to be evaluated. Yet in some cases we call the method val_int()
2591 for them. We have to take care of restricting the predicate such an
2592 object represents f1=f2= ...=fn to the projection of known fields fi1=...=fik.
2593*/
2594class Item_equal final : public Item_bool_func {
2595 /// List of equal field items.
2597 /// Optional constant item equal to all the field items.
2598 Item *m_const_arg{nullptr};
2599 /// Helper for comparing the fields.
2600 cmp_item *eval_item{nullptr};
2601 /// Helper for comparing constants.
2603 /// Flag set to true if the equality is known to be always false.
2604 bool cond_false{false};
2605 /// Should constants be compared as datetimes?
2606 bool compare_as_dates{false};
2607
2608 public:
2609 ~Item_equal() override;
2610
2612 Item_equal(Item *c, Item_field *f);
2613 explicit Item_equal(Item_equal *item_equal);
2614
2615 Item *const_arg() const { return m_const_arg; }
2616 void set_const_arg(Item *c) { m_const_arg = c; }
2617 bool compare_const(THD *thd, Item *c);
2618 bool add(THD *thd, Item *c, Item_field *f);
2619 bool add(THD *thd, Item *c);
2620 void add(Item_field *f);
2621 uint members();
2622 bool contains(const Field *field) const;
2623 /**
2624 Get the first field of multiple equality, use for semantic checking.
2625
2626 @retval First field in the multiple equality.
2627 */
2628 Item_field *get_first() { return fields.head(); }
2629 Item_field *get_subst_item(const Item_field *field);
2630 bool merge(THD *thd, Item_equal *item);
2631 bool update_const(THD *thd);
2632 enum Functype functype() const override { return MULT_EQUAL_FUNC; }
2633 longlong val_int() override;
2634 const char *func_name() const override { return "multiple equal"; }
2635 optimize_type select_optimize(const THD *) override { return OPTIMIZE_EQUAL; }
2637 // Multiple equality nodes (Item_equal) should have been
2638 // converted back to simple equalities (Item_func_eq) by
2639 // substitute_for_best_equal_field before cast nodes are injected.
2640 assert(false);
2641 return false;
2642 }
2644 return const_arg() == nullptr;
2645 }
2646
2647 /**
2648 Order field items in multiple equality according to a sorting criteria.
2649
2650 The function perform ordering of the field items in the Item_equal
2651 object according to the criteria determined by the cmp callback parameter.
2652 If cmp(item_field1,item_field2,arg)<0 than item_field1 must be
2653 placed after item_field2.
2654
2655 The function sorts field items by the exchange sort algorithm.
2656 The list of field items is looked through and whenever two neighboring
2657 members follow in a wrong order they are swapped. This is performed
2658 again and again until we get all members in a right order.
2659
2660 @param compare function to compare field item
2661 */
2662 template <typename Node_cmp_func>
2663 void sort(Node_cmp_func compare) {
2664 fields.sort(compare);
2665 }
2666
2667 // A class to iterate over fields without exposing fields directly.
2669 public:
2670 explicit FieldProxy(Item_equal *item) : m_fields(&item->fields) {}
2671 List_STL_Iterator<Item_field> begin() { return m_fields->begin(); }
2672 List_STL_Iterator<Item_field> end() { return m_fields->end(); }
2674 return m_fields->cbegin();
2675 }
2676 List_STL_Iterator<const Item_field> end() const { return m_fields->cend(); }
2678 return m_fields->cbegin();
2679 }
2681 return m_fields->cend();
2682 }
2683
2684 private:
2686 };
2688 public:
2689 explicit ConstFieldProxy(const Item_equal *item)
2690 : m_fields(&item->fields) {}
2692 return m_fields->cbegin();
2693 }
2694 List_STL_Iterator<const Item_field> end() const { return m_fields->cend(); }
2696 return m_fields->cbegin();
2697 }
2699 return m_fields->cend();
2700 }
2701 size_t size() const { return m_fields->size(); }
2702
2703 private:
2705 };
2708
2709 bool resolve_type(THD *) override;
2710 bool fix_fields(THD *thd, Item **ref) override;
2711 void update_used_tables() override;
2712 bool walk(Item_processor processor, enum_walk walk, uchar *arg) override;
2713 void print(const THD *thd, String *str,
2714 enum_query_type query_type) const override;
2715 bool eq(const Item *item, bool binary_cmp) const override;
2716 const CHARSET_INFO *compare_collation() const override {
2717 return fields.head()->collation.collation;
2718 }
2719
2720 bool equality_substitution_analyzer(uchar **) override { return true; }
2721
2723
2724 float get_filtering_effect(THD *thd, table_map filter_for_table,
2725 table_map read_tables,
2726 const MY_BITMAP *fields_to_ignore,
2727 double rows_in_table) override;
2728 Item *m_const_folding[2]; ///< temporary area used for constant folding
2729
2730 private:
2732};
2733
2735 public:
2736 uint max_members; /* max number of members the current level
2737 list and all lower level lists */
2738 COND_EQUAL *upper_levels; /* multiple equalities of upper and levels */
2739 List<Item_equal> current_level; /* list of multiple equalities of
2740 the current and level */
2741 COND_EQUAL() { upper_levels = nullptr; }
2742};
2743
2744class Item_cond_and final : public Item_cond {
2745 public:
2746 COND_EQUAL cond_equal; /* contains list of Item_equal objects for
2747 the current and level and reference
2748 to multiple equalities of upper and levels */
2750
2751 Item_cond_and(Item *i1, Item *i2) : Item_cond(i1, i2) {}
2752 Item_cond_and(const POS &pos, Item *i1, Item *i2) : Item_cond(pos, i1, i2) {}
2753
2754 Item_cond_and(THD *thd, Item_cond_and *item) : Item_cond(thd, item) {}
2755 Item_cond_and(List<Item> &list_arg) : Item_cond(list_arg) {}
2756 enum Functype functype() const override { return COND_AND_FUNC; }
2757 longlong val_int() override;
2758 const char *func_name() const override { return "and"; }
2760 Item_cond_and *item;
2761 if ((item = new Item_cond_and(thd, this)))
2762 item->copy_andor_arguments(thd, this);
2763 return item;
2764 }
2765 Item *truth_transformer(THD *, Bool_test) override;
2766 bool gc_subst_analyzer(uchar **) override { return true; }
2767
2768 float get_filtering_effect(THD *thd, table_map filter_for_table,
2769 table_map read_tables,
2770 const MY_BITMAP *fields_to_ignore,
2771 double rows_in_table) override;
2772
2773 bool contains_only_equi_join_condition() const override;
2774};
2775
2776class Item_cond_or final : public Item_cond {
2777 public:
2779
2780 Item_cond_or(Item *i1, Item *i2) : Item_cond(i1, i2) {}
2781 Item_cond_or(const POS &pos, Item *i1, Item *i2) : Item_cond(pos, i1, i2) {}
2782
2783 Item_cond_or(THD *thd, Item_cond_or *item) : Item_cond(thd, item) {}
2784 Item_cond_or(List<Item> &list_arg) : Item_cond(list_arg) {}
2785 enum Functype functype() const override { return COND_OR_FUNC; }
2786 longlong val_int() override;
2787 const char *func_name() const override { return "or"; }
2789 Item_cond_or *item;
2790 if ((item = new Item_cond_or(thd, this)))
2791 item->copy_andor_arguments(thd, this);
2792 return item;
2793 }
2794 Item *truth_transformer(THD *, Bool_test) override;
2795 bool gc_subst_analyzer(uchar **) override { return true; }
2796
2797 float get_filtering_effect(THD *thd, table_map filter_for_table,
2798 table_map read_tables,
2799 const MY_BITMAP *fields_to_ignore,
2800 double rows_in_table) override;
2801};
2802
2803/// Builds condition: (a AND b) IS TRUE
2804inline Item *and_conds(Item *a, Item *b) {
2805 if (!b) return a;
2806 if (!a) return b;
2807
2808 Item *item = new Item_cond_and(a, b);
2809 if (item == nullptr) return nullptr;
2810 item->apply_is_true();
2811 return item;
2812}
2813
2814longlong get_datetime_value(THD *thd, Item ***item_arg, Item ** /* cache_arg */,
2815 const Item *warn_item, bool *is_null);
2816
2817// TODO: the next two functions should be moved to sql_time.{h,cc}
2820
2822 enum_mysql_timestamp_type warn_type,
2823 const char *warn_name, MYSQL_TIME *l_time);
2824
2825// Helper function to ensure_multi_equality_fields_are_available().
2826// Finds and adjusts (if "replace" is set to true) an "Item_field" in a
2827// function with an equal field in the available tables. For more
2828// details look at FindEqualField().
2829void find_and_adjust_equal_fields(Item *item, table_map available_tables,
2830 bool replace, bool *found);
2831
2832/*
2833 These need definitions from this file but the variables are defined
2834 in mysqld.h. The variables really belong in this component, but for
2835 the time being we leave them in mysqld.cc to avoid merge problems.
2836*/
2837extern Eq_creator eq_creator;
2839extern Ne_creator ne_creator;
2840extern Gt_creator gt_creator;
2841extern Lt_creator lt_creator;
2842extern Ge_creator ge_creator;
2843extern Le_creator le_creator;
2844
2845/// Returns true if the item is a conjunction.
2846inline bool IsAnd(const Item *item) {
2847 return item->type() == Item::COND_ITEM &&
2848 down_cast<const Item_cond *>(item)->functype() ==
2850}
2851
2852/**
2853 Calls "func" on each term in "condition" if it's a conjunction (and
2854 recursively on any conjunction directly contained in it, thereby flattening
2855 nested AND structures). Otherwise, calls "func" on "condition". It aborts and
2856 returns true as soon as a call to "func" returns true.
2857 */
2858template <class Func>
2859bool WalkConjunction(Item *condition, Func func) {
2860 if (condition == nullptr) {
2861 return false;
2862 } else if (IsAnd(condition)) {
2863 for (Item &item : *down_cast<Item_cond_and *>(condition)->argument_list()) {
2864 if (WalkConjunction(&item, func)) {
2865 return true;
2866 }
2867 }
2868 return false;
2869 } else {
2870 return func(condition);
2871 }
2872}
2873
2874#endif /* ITEM_CMPFUNC_INCLUDED */
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:251
Definition: item_cmpfunc.h:140
bool inject_cast_nodes()
Comparison function are expected to operate on arguments having the same data types.
Definition: item_cmpfunc.cc:1444
int compare_time_packed()
Compare arguments using numeric packed temporal representation.
Definition: item_cmpfunc.cc:1982
void cleanup()
Definition: item_cmpfunc.cc:869
uint get_child_comparator_count() const
Definition: item_cmpfunc.h:245
int compare_int_signed_unsigned()
Compare signed (*left) with unsigned (*B)
Definition: item_cmpfunc.cc:2045
String value1
Definition: item_cmpfunc.h:168
void set_datetime_cmp_func(Item_result_field *owner_arg, Item **a1, Item **b1)
Definition: item_cmpfunc.cc:1602
Item * left_cache
Definition: item_cmpfunc.h:149
longlong(* get_value_a_func)(THD *thd, Item ***item_arg, Item **cache_arg, const Item *warn_item, bool *is_null)
A function pointer that is used for retrieving the value from argument "left".
Definition: item_cmpfunc.h:282
int compare_int_unsigned_signed()
Compare unsigned (*left) with signed (*B)
Definition: item_cmpfunc.cc:2066
Arg_comparator * comparators
Definition: item_cmpfunc.h:145
Item_result m_compare_type
Definition: item_cmpfunc.h:292
Arg_comparator * get_child_comparators() const
Definition: item_cmpfunc.h:247
static bool can_compare_as_dates(const Item *a, const Item *b)
Checks whether compare_datetime() can be used to compare items.
Definition: item_cmpfunc.cc:1184
double precision
Definition: item_cmpfunc.h:147
int compare_datetime()
Compare item values as dates.
Definition: item_cmpfunc.cc:1726
uint16 comparator_count
Definition: item_cmpfunc.h:146
Item ** right
Definition: item_cmpfunc.h:142
arg_cmp_func func
Definition: item_cmpfunc.h:143
String value2
Definition: item_cmpfunc.h:168
Item ** left
Definition: item_cmpfunc.h:141
Item ** get_left_ptr() const
Definition: item_cmpfunc.h:264
Json_scalar_holder * json_scalar
Only used by compare_json() in the case where a JSON value is compared to an SQL value.
Definition: item_cmpfunc.h:163
void set_cmp_context_for_datetime()
Definition: item_cmpfunc.h:237
bool set_cmp_func(Item_result_field *owner_arg, Item **left, Item **right, Item_result type)
Sets compare functions for various datatypes.
Definition: item_cmpfunc.cc:1254
static arg_cmp_func comparator_matrix[5]
Definition: item_cmpfunc.h:232
bool use_custom_value_extractors() const
Definition: item_cmpfunc.h:253
int compare()
Definition: item_cmpfunc.h:211
Item_result get_compare_type() const
Definition: item_cmpfunc.h:243
int compare_int_signed()
Definition: item_cmpfunc.cc:1956
int compare_binary_string()
Compare strings byte by byte.
Definition: item_cmpfunc.cc:1885
bool compare_as_json() const
Definition: item_cmpfunc.h:249
Arg_comparator()=default
Item * get_right() const
Definition: item_cmpfunc.h:265
int compare_json()
Compare two Item objects as JSON.
Definition: item_cmpfunc.cc:1818
int compare_real()
Definition: item_cmpfunc.cc:1903
bool set_null
Definition: item_cmpfunc.h:151
static bool get_date_from_const(Item *date_arg, Item *str_arg, ulonglong *const_value)
Check if str_arg is a constant and convert it to datetime packed value.
Definition: item_cmpfunc.cc:1110
bool try_year_cmp_func(Item_result type)
Definition: item_cmpfunc.cc:1545
Item * right_cache
Definition: item_cmpfunc.h:150
Item_result_field * owner
Definition: item_cmpfunc.h:144
longlong(* get_value_b_func)(THD *thd, Item ***item_arg, Item **cache_arg, const Item *warn_item, bool *is_null)
Definition: item_cmpfunc.h:287
int compare_real_fixed()
Definition: item_cmpfunc.cc:1938
longlong extract_value_from_argument(THD *thd, Item *item, bool left_argument, bool *is_null) const
Definition: item_cmpfunc.cc:8108
int compare_string()
Definition: item_cmpfunc.cc:1853
int compare_decimal()
Definition: item_cmpfunc.cc:1921
int compare_row()
Definition: item_cmpfunc.cc:2084
bool compare_null_values()
Compare NULL values for two arguments.
Definition: item_cmpfunc.cc:2176
bool set_compare_func(Item_result_field *owner, Item_result type)
Definition: item_cmpfunc.cc:887
DTCollation cmp_collation
Definition: item_cmpfunc.h:166
Arg_comparator(Item **left, Item **right)
Definition: item_cmpfunc.h:172
int compare_int_unsigned()
Compare values as BIGINT UNSIGNED.
Definition: item_cmpfunc.cc:2018
Definition: item_cmpfunc.h:2734
uint max_members
Definition: item_cmpfunc.h:2736
COND_EQUAL * upper_levels
Definition: item_cmpfunc.h:2738
List< Item_equal > current_level
Definition: item_cmpfunc.h:2739
COND_EQUAL()
Definition: item_cmpfunc.h:2741
Abstract factory interface for creating comparison predicates.
Definition: item_cmpfunc.h:525
virtual ~Comp_creator()=default
virtual bool l_op() const =0
virtual bool eqne_op() const =0
virtual Item_bool_func * create(Item *a, Item *b) const =0
virtual const char * symbol(bool invert) const =0
This interface is only used by Item_allany_subselect.
Definition: item.h:179
const CHARSET_INFO * collation
Definition: item.h:181
Definition: item_cmpfunc.h:555
Item_bool_func * create_scalar_predicate(Item *a, Item *b) const override
Creates only an item tree node, without attempting to rewrite row constructors.
Definition: item_cmpfunc.cc:398
const char * symbol(bool invert) const override
This interface is only used by Item_allany_subselect.
Definition: item_cmpfunc.h:557
Item_bool_func * combine(List< Item > list) const override
Combines a list of conditions exp op exp.
Definition: item_cmpfunc.cc:403
Definition: item_cmpfunc.h:564
const char * symbol(bool invert) const override
This interface is only used by Item_allany_subselect.
Definition: item_cmpfunc.h:566
Item_bool_func * create_scalar_predicate(Item *a, Item *b) const override
Creates only an item tree node, without attempting to rewrite row constructors.
Definition: item_cmpfunc.cc:407
Item_bool_func * combine(List< Item > list) const override
Combines a list of conditions exp op exp.
Definition: item_cmpfunc.cc:412
Definition: field.h:575
Definition: item_cmpfunc.h:602
Item_bool_func * create(Item *a, Item *b) const override
Definition: item_cmpfunc.cc:433
bool l_op() const override
Definition: item_cmpfunc.h:607
bool eqne_op() const override
Definition: item_cmpfunc.h:606
const char * symbol(bool invert) const override
This interface is only used by Item_allany_subselect.
Definition: item_cmpfunc.h:605
Definition: item_cmpfunc.h:586
bool l_op() const override
Definition: item_cmpfunc.h:591
Item_bool_func * create(Item *a, Item *b) const override
Definition: item_cmpfunc.cc:425
bool eqne_op() const override
Definition: item_cmpfunc.h:590
const char * symbol(bool invert) const override
This interface is only used by Item_allany_subselect.
Definition: item_cmpfunc.h:589
A class that represents a join condition in a hash join.
Definition: item_cmpfunc.h:87
const size_t m_max_character_length
Definition: item_cmpfunc.h:126
const table_map m_right_used_tables
Definition: item_cmpfunc.h:120
Item_eq_base * m_join_condition
Definition: item_cmpfunc.h:112
Item * right_extractor() const
Definition: item_cmpfunc.h:94
HashJoinCondition(Item_eq_base *join_condition, MEM_ROOT *mem_root)
Definition: item_cmpfunc.cc:8073
const table_map m_left_used_tables
Definition: item_cmpfunc.h:119
bool store_full_sort_key() const
Definition: item_cmpfunc.h:105
bool left_uses_any_table(table_map tables) const
Definition: item_cmpfunc.h:95
bool m_store_full_sort_key
Definition: item_cmpfunc.h:134
Item * left_extractor() const
Definition: item_cmpfunc.h:93
Item_eq_base * join_condition() const
Definition: item_cmpfunc.h:91
bool m_null_equals_null
Definition: item_cmpfunc.h:137
Item * m_right_extractor
Definition: item_cmpfunc.h:114
bool right_uses_any_table(table_map tables) const
Definition: item_cmpfunc.h:99
Item * m_left_extractor
Definition: item_cmpfunc.h:113
size_t max_character_length() const
Definition: item_cmpfunc.h:103
bool null_equals_null() const
Returns true if this join condition evaluates to TRUE if both operands are NULL.
Definition: item_cmpfunc.h:109
Definition: item.h:3806
void set_str_value(String *str)
Definition: item.h:3828
Base class for functions that usually take two arguments, which are possibly strings,...
Definition: item_cmpfunc.h:624
bool allow_replacement(Item_field *const original, Item *const subst) override
Check whether a function allows replacement of a field with another item: In particular,...
Definition: item_cmpfunc.h:680
bool have_rev_func() const override
Definition: item_cmpfunc.h:658
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:654
bool abort_on_null
Definition: item_cmpfunc.h:631
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_cmpfunc.h:670
bool convert_constant_arg(THD *thd, Item *field, Item **item, bool *converted)
Definition: item_cmpfunc.cc:725
Item_result compare_type() const
Definition: item_cmpfunc.h:669
Arg_comparator cmp
Definition: item_cmpfunc.h:630
Item_bool_func2(const POS &pos, Item *a, Item *b, Item *c)
Definition: item_cmpfunc.h:642
bool resolve_type(THD *) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_cmpfunc.cc:743
Item_bool_func2(Item *a, Item *b, Item *c)
Definition: item_cmpfunc.h:636
Item_bool_func2(Item *a, Item *b)
Definition: item_cmpfunc.h:633
virtual bool set_cmp_func()
Sets up a comparator of the correct type based on the type of the function's arguments.
Definition: item_cmpfunc.h:651
const CHARSET_INFO * compare_collation() const override
Definition: item_cmpfunc.h:666
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_cmpfunc.h:665
Item_bool_func2(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:639
virtual enum Functype rev_functype() const
Definition: item_cmpfunc.h:657
bool ignore_unknown() const
Treat UNKNOWN result like FALSE because callers see no difference.
Definition: item_cmpfunc.h:672
const Arg_comparator * get_comparator() const
Definition: item_cmpfunc.h:677
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.h:660
Item * replace_scalar_subquery(uchar *) override
When walking the item tree seeing an Item_singlerow_subselect matching a target, replace it with a su...
Definition: item_cmpfunc.cc:862
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_cmpfunc.h:673
Definition: item_cmpfunc.h:295
Item_bool_func(Item *a)
Definition: item_cmpfunc.h:302
Item_bool_func(Item *a, Item *b, Item *c)
Definition: item_cmpfunc.h:307
Item_bool_func(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:313
bool m_created_by_in2exists
True <=> this item was added by IN->EXISTS subquery transformation, and should thus be deleted if we ...
Definition: item_cmpfunc.h:349
void set_created_by_in2exists()
Definition: item_cmpfunc.cc:2182
bool created_by_in2exists() const override
Whether this Item was created by the IN->EXISTS subquery transformation.
Definition: item_cmpfunc.h:334
Item_bool_func(const POS &pos)
Definition: item_cmpfunc.h:298
Item_bool_func(THD *thd, Item_bool_func *item)
Definition: item_cmpfunc.h:321
Item_bool_func(Item *a, Item *b)
Definition: item_cmpfunc.h:310
Item_bool_func(const POS &pos, Item *a, Item *b, Item *c)
Definition: item_cmpfunc.h:316
uint decimal_precision() const override
Definition: item_cmpfunc.h:333
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_cmpfunc.h:329
Item_bool_func(const POS &pos, Item *a)
Definition: item_cmpfunc.h:303
bool is_bool_func() const override
Definition: item_cmpfunc.h:328
Item_bool_func()
Definition: item_cmpfunc.h:297
static const Bool_test bool_transform[10][8]
Array that transforms a boolean test according to another.
Definition: item_cmpfunc.h:342
static const char * bool_transform_names[10]
Definition: item_cmpfunc.h:337
Definition: item.h:6858
Definition: item_cmpfunc.h:2744
Item * copy_andor_structure(THD *thd) override
Definition: item_cmpfunc.h:2759
Item_cond_and(List< Item > &list_arg)
Definition: item_cmpfunc.h:2755
COND_EQUAL cond_equal
Definition: item_cmpfunc.h:2746
const char * func_name() const override
Definition: item_cmpfunc.h:2758
enum Functype functype() const override
Definition: item_cmpfunc.h:2756
Item_cond_and()
Definition: item_cmpfunc.h:2749
Item_cond_and(const POS &pos, Item *i1, Item *i2)
Definition: item_cmpfunc.h:2752
Item_cond_and(Item *i1, Item *i2)
Definition: item_cmpfunc.h:2751
bool gc_subst_analyzer(uchar **) override
Analyzer function for GC substitution.
Definition: item_cmpfunc.h:2766
Item_cond_and(THD *thd, Item_cond_and *item)
Definition: item_cmpfunc.h:2754
Definition: item_cmpfunc.h:2776
bool gc_subst_analyzer(uchar **) override
Analyzer function for GC substitution.
Definition: item_cmpfunc.h:2795
enum Functype functype() const override
Definition: item_cmpfunc.h:2785
Item_cond_or(Item *i1, Item *i2)
Definition: item_cmpfunc.h:2780
Item * copy_andor_structure(THD *thd) override
Definition: item_cmpfunc.h:2788
Item_cond_or(List< Item > &list_arg)
Definition: item_cmpfunc.h:2784
Item_cond_or(const POS &pos, Item *i1, Item *i2)
Definition: item_cmpfunc.h:2781
Item_cond_or()
Definition: item_cmpfunc.h:2778
const char * func_name() const override
Definition: item_cmpfunc.h:2787
Item_cond_or(THD *thd, Item_cond_or *item)
Definition: item_cmpfunc.h:2783
Definition: item_cmpfunc.h:2454
void add_at_head(List< Item > *nlist)
Definition: item_cmpfunc.h:2485
bool add_at_head(Item *item)
Definition: item_cmpfunc.h:2481
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_cmpfunc.h:2505
Item_cond(Item *i1, Item *i2)
Definition: item_cmpfunc.h:2464
Item_bool_func super
Definition: item_cmpfunc.h:2455
bool ignore_unknown() const
Treat UNKNOWN result like FALSE because callers see no difference.
Definition: item_cmpfunc.h:2516
void copy_andor_arguments(THD *thd, Item_cond *item)
Definition: item_cmpfunc.cc:5711
table_map used_tables() const override
Definition: item_cmpfunc.h:2499
Item_cond(const POS &pos, Item *i1, Item *i2)
Definition: item_cmpfunc.h:2468
Item_cond(List< Item > &nlist)
Definition: item_cmpfunc.h:2475
bool subst_argument_checker(uchar **) override
Definition: item_cmpfunc.h:2511
List< Item > * argument_list()
Definition: item_cmpfunc.h:2497
Type type() const override
Definition: item_cmpfunc.h:2496
Item_cond()
Definition: item_cmpfunc.h:2463
List< Item > list
Definition: item_cmpfunc.h:2458
bool equality_substitution_analyzer(uchar **) override
Definition: item_cmpfunc.h:2517
bool add(Item *item)
Definition: item_cmpfunc.h:2477
bool abort_on_null
Definition: item_cmpfunc.h:2459
Definition: item.h:5299
Base class for the equality comparison operators = and <=>.
Definition: item_cmpfunc.h:991
Item_eq_base(Item *a, Item *b)
Definition: item_cmpfunc.h:993
Item_equal * source_multiple_equality
If this equality originally came from a multi-equality, this documents which one it came from (otherw...
Definition: item_cmpfunc.h:1050
bool contains_only_equi_join_condition() const final
Whether this Item is an equi-join condition.
Definition: item_cmpfunc.cc:7659
Item_eq_base(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:994
Item * create_cast_if_needed(MEM_ROOT *mem_root, Item *argument) const
Wrap the argument in a typecast, if needed.
Definition: item_cmpfunc.cc:8045
bool append_join_key_for_hash_join(THD *thd, table_map tables, const HashJoinCondition &join_condition, bool is_multi_column_key, String *join_key_buffer) const
Read the value from the join condition, and append it to the output vector "join_key_buffer".
Definition: item_cmpfunc.cc:8019
Definition: item_cmpfunc.h:2687
ConstFieldProxy(const Item_equal *item)
Definition: item_cmpfunc.h:2689
List_STL_Iterator< const Item_field > cbegin() const
Definition: item_cmpfunc.h:2695
List_STL_Iterator< const Item_field > cend() const
Definition: item_cmpfunc.h:2698
List_STL_Iterator< const Item_field > begin() const
Definition: item_cmpfunc.h:2691
size_t size() const
Definition: item_cmpfunc.h:2701
const List< Item_field > * m_fields
Definition: item_cmpfunc.h:2704
List_STL_Iterator< const Item_field > end() const
Definition: item_cmpfunc.h:2694
Definition: item_cmpfunc.h:2668
List_STL_Iterator< Item_field > begin()
Definition: item_cmpfunc.h:2671
List_STL_Iterator< Item_field > end()
Definition: item_cmpfunc.h:2672
List< Item_field > * m_fields
Definition: item_cmpfunc.h:2685
List_STL_Iterator< const Item_field > begin() const
Definition: item_cmpfunc.h:2673
List_STL_Iterator< const Item_field > cbegin() const
Definition: item_cmpfunc.h:2677
List_STL_Iterator< const Item_field > cend() const
Definition: item_cmpfunc.h:2680
List_STL_Iterator< const Item_field > end() const
Definition: item_cmpfunc.h:2676
FieldProxy(Item_equal *item)
Definition: item_cmpfunc.h:2670
Definition: item_cmpfunc.h:2594
ConstFieldProxy get_fields() const
Definition: item_cmpfunc.h:2707
bool contains_only_equi_join_condition() const override
Whether this Item is an equi-join condition.
Definition: item_cmpfunc.h:2643
void set_const_arg(Item *c)
Definition: item_cmpfunc.h:2616
void check_covering_prefix_keys()
bool cast_incompatible_args(uchar *) override
Wrap incompatible arguments in CAST nodes to the expected data types.
Definition: item_cmpfunc.h:2636
Item * const_arg() const
Definition: item_cmpfunc.h:2615
const CHARSET_INFO * compare_collation() const override
Definition: item_cmpfunc.h:2716
void sort(Node_cmp_func compare)
Order field items in multiple equality according to a sorting criteria.
Definition: item_cmpfunc.h:2663
Arg_comparator cmp
Helper for comparing constants.
Definition: item_cmpfunc.h:2602
Item_field * get_first()
Get the first field of multiple equality, use for semantic checking.
Definition: item_cmpfunc.h:2628
const char * func_name() const override
Definition: item_cmpfunc.h:2634
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:2635
List< Item_field > fields
List of equal field items.
Definition: item_cmpfunc.h:2596
FieldProxy get_fields()
Definition: item_cmpfunc.h:2706
enum Functype functype() const override
Definition: item_cmpfunc.h:2632
bool equality_substitution_analyzer(uchar **) override
Definition: item_cmpfunc.h:2720
Definition: item.h:4345
Definition: item.h:5345
ANY_VALUE(expr) is like expr except that it is not checked by aggregate_check logic.
Definition: item_cmpfunc.h:1498
const char * func_name() const override
Definition: item_cmpfunc.h:1502
Item_func_any_value(const POS &pos, Item *a)
Definition: item_cmpfunc.h:1500
Item_func_any_value(Item *a)
Definition: item_cmpfunc.h:1501
Definition: item_cmpfunc.h:1321
Arg_comparator ge_cmp
Definition: item_cmpfunc.h:1333
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:1340
bool compare_as_dates_with_strings
Definition: item_cmpfunc.h:1328
bool is_bool_func() const override
Definition: item_cmpfunc.h:1349
Item_func_between(const POS &pos, Item *a, Item *b, Item *c, bool is_negation)
Definition: item_cmpfunc.h:1334
Item_result cmp_type
Definition: item_cmpfunc.h:1325
bool compare_as_temporal_dates
Definition: item_cmpfunc.h:1329
const CHARSET_INFO * compare_collation() const override
Definition: item_cmpfunc.h:1350
String value0
Definition: item_cmpfunc.h:1326
const char * func_name() const override
Definition: item_cmpfunc.h:1342
void update_not_null_tables()
Definition: item_cmpfunc.h:1362
uint decimal_precision() const override
Definition: item_cmpfunc.h:1353
DTCollation cmp_collation
Definition: item_cmpfunc.h:1322
bool gc_subst_analyzer(uchar **) override
Analyzer function for GC substitution.
Definition: item_cmpfunc.h:1354
bool compare_as_temporal_times
Definition: item_cmpfunc.h:1330
enum Functype functype() const override
Definition: item_cmpfunc.h:1341
A predicate that is "always true" or "always false".
Definition: item_cmpfunc.h:358
Item_func_bool_const(const POS &pos)
Definition: item_cmpfunc.h:366
Item_func_bool_const()
Definition: item_cmpfunc.h:360
bool fix_fields(THD *, Item **) override
Definition: item_cmpfunc.h:372
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_cmpfunc.h:374
bool basic_const_item() const override
Returns true if this is a simple constant item like an integer, not a constant expression.
Definition: item_cmpfunc.h:373
CASE ... WHEN ... THEN ... END function implementation.
Definition: item_cmpfunc.h:2002
Item_result cmp_type
Definition: item_cmpfunc.h:2009
enum_field_types default_data_type() const override
Get the default data (output) type for the specific item.
Definition: item_cmpfunc.h:2053
const CHARSET_INFO * compare_collation() const override
Definition: item_cmpfunc.h:2064
cmp_item * case_item
Definition: item_cmpfunc.h:2012
int else_expr_num
Definition: item_cmpfunc.h:2005
DTCollation cmp_collation
Definition: item_cmpfunc.h:2010
Item_func super
Definition: item_cmpfunc.h:2003
Item_func_case(const POS &pos, mem_root_deque< Item * > *list, Item *first_expr_arg, Item *else_expr_arg)
Definition: item_cmpfunc.h:2021
int get_first_expr_num() const
Definition: item_cmpfunc.h:2043
const char * func_name() const override
Definition: item_cmpfunc.h:2060
enum Item_result result_type() const override
Definition: item_cmpfunc.h:2059
enum Item_result cached_result_type left_result_type
Definition: item_cmpfunc.h:2006
uint ncases
Definition: item_cmpfunc.h:2008
void add_json_info(Json_object *obj) override
Add all the node-specific json fields.
Definition: item_cmpfunc.h:2015
String tmp_value
Definition: item_cmpfunc.h:2007
enum Functype functype() const override
Definition: item_cmpfunc.h:2067
int get_else_expr_num() const
Definition: item_cmpfunc.h:2044
Definition: item_cmpfunc.h:1433
Item_func_coalesce(const POS &pos, Item *a)
Definition: item_cmpfunc.h:1439
Item_func_coalesce(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:1435
enum Item_result result_type() const override
Definition: item_cmpfunc.h:1470
Item_func_coalesce(Item *a, Item *b)
Definition: item_cmpfunc.h:1452
const char * func_name() const override
Definition: item_cmpfunc.h:1471
enum_field_types default_data_type() const override
Get the default data (output) type for the specific item.
Definition: item_cmpfunc.h:1449
Item_func_coalesce(Item *a)
Definition: item_cmpfunc.h:1442
Item_func_coalesce(const POS &pos, PT_item_list *list)
Definition: item_cmpfunc.h:1445
enum Functype functype() const override
Definition: item_cmpfunc.h:1472
void set_numeric_type() override
Definition: item_cmpfunc.h:1469
Item_func_comparison is a class for comparison functions that take two arguments and return a boolean...
Definition: item_cmpfunc.h:696
bool subst_argument_checker(uchar **) override
Definition: item_cmpfunc.h:708
Item_func_comparison(Item *a, Item *b)
Definition: item_cmpfunc.h:698
Item_func_comparison(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:701
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_cmpfunc.cc:6919
Item * truth_transformer(THD *, Bool_test) override
Informs an item that it is wrapped in a truth test, in case it wants to transforms itself to implemen...
Definition: item_cmpfunc.cc:6794
virtual Item * negated_item()
just fake method, should never be called.
Definition: item_cmpfunc.cc:6914
bool cast_incompatible_args(uchar *) override
Wrap incompatible arguments in CAST nodes to the expected data types.
Definition: item_cmpfunc.cc:6934
Implements the comparison operator equals (=)
Definition: item_cmpfunc.h:1056
enum Functype functype() const override
Definition: item_cmpfunc.h:1061
bool gc_subst_analyzer(uchar **) override
Analyzer function for GC substitution.
Definition: item_cmpfunc.h:1069
cond_result eq_cmp_result() const override
Definition: item_cmpfunc.h:1063
Item_func_eq(Item *a, Item *b)
Definition: item_cmpfunc.h:1058
Item_func_eq(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:1059
enum Functype rev_functype() const override
Definition: item_cmpfunc.h:1062
const char * func_name() const override
Definition: item_cmpfunc.h:1064
bool equality_substitution_analyzer(uchar **) override
Definition: item_cmpfunc.h:1066
The <=> operator evaluates the same as.
Definition: item_cmpfunc.h:1120
Item * truth_transformer(THD *, Bool_test) override
Informs an item that it is wrapped in a truth test, in case it wants to transforms itself to implemen...
Definition: item_cmpfunc.h:1138
bool set_cmp_func() override
Sets up a comparator of the correct type based on the type of the function's arguments.
Definition: item_cmpfunc.h:1129
cond_result eq_cmp_result() const override
Definition: item_cmpfunc.h:1136
enum Functype functype() const override
Definition: item_cmpfunc.h:1134
enum Functype rev_functype() const override
Definition: item_cmpfunc.h:1135
const char * func_name() const override
Definition: item_cmpfunc.h:1137
Item_func_equal(Item *a, Item *b)
Definition: item_cmpfunc.h:1122
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_cmpfunc.h:1139
Item_func_equal(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:1125
A predicate that is "always false".
Definition: item_cmpfunc.h:394
longlong val_int() override
Definition: item_cmpfunc.h:400
Item_func_false()
Definition: item_cmpfunc.h:396
const char * func_name() const override
Definition: item_cmpfunc.h:398
Item_func_false(const POS &pos)
Definition: item_cmpfunc.h:397
enum Functype functype() const override
Definition: item_cmpfunc.h:404
bool val_bool() override
Definition: item_cmpfunc.h:399
void print(const THD *, String *str, enum_query_type) const override
This method is used for to:
Definition: item_cmpfunc.h:401
Implements the comparison operator greater than or equals (>=)
Definition: item_cmpfunc.h:1163
enum Functype rev_functype() const override
Definition: item_cmpfunc.h:1168
cond_result eq_cmp_result() const override
Definition: item_cmpfunc.h:1169
Item_func_ge(Item *a, Item *b)
Definition: item_cmpfunc.h:1165
const char * func_name() const override
Definition: item_cmpfunc.h:1170
enum Functype functype() const override
Definition: item_cmpfunc.h:1167
Implements the comparison operator greater than (>)
Definition: item_cmpfunc.h:1177
Item_func_gt(Item *a, Item *b)
Definition: item_cmpfunc.h:1179
cond_result eq_cmp_result() const override
Definition: item_cmpfunc.h:1183
enum Functype rev_functype() const override
Definition: item_cmpfunc.h:1182
const char * func_name() const override
Definition: item_cmpfunc.h:1184
enum Functype functype() const override
Definition: item_cmpfunc.h:1181
Definition: item_cmpfunc.h:1512
Item_func_if(Item *a, Item *b, Item *c)
Definition: item_cmpfunc.h:1516
enum Functype functype() const override
Definition: item_cmpfunc.h:1543
enum Item_result result_type() const override
Definition: item_cmpfunc.h:1532
enum_field_types default_data_type() const override
Get the default data (output) type for the specific item.
Definition: item_cmpfunc.h:1534
const char * func_name() const override
Definition: item_cmpfunc.h:1542
void update_not_null_tables()
Definition: item_cmpfunc.h:1547
enum Item_result cached_result_type
Definition: item_cmpfunc.h:1513
Item_func_if(const POS &pos, Item *a, Item *b, Item *c)
Definition: item_cmpfunc.h:1520
Definition: item_cmpfunc.h:1475
bool field_type_defined
Definition: item_cmpfunc.h:1477
Item_func_ifnull(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:1480
const char * func_name() const override
Definition: item_cmpfunc.h:1489
in_expr [NOT] IN (in_value_list).
Definition: item_cmpfunc.h:2081
DTCollation cmp_collation
Definition: item_cmpfunc.h:2111
Item_func_in(const POS &pos, PT_item_list *list, bool is_negation)
Definition: item_cmpfunc.h:2114
enum Functype functype() const override
Definition: item_cmpfunc.h:2141
const char * func_name() const override
Definition: item_cmpfunc.h:2142
Item_result left_result_type
Definition: item_cmpfunc.h:2109
bool is_bool_func() const override
Definition: item_cmpfunc.h:2143
uint decimal_precision() const override
Definition: item_cmpfunc.h:2126
const CHARSET_INFO * compare_collation() const override
Definition: item_cmpfunc.h:2144
void update_not_null_tables()
Definition: item_cmpfunc.h:2154
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:2138
bool gc_subst_analyzer(uchar **) override
Analyzer function for GC substitution.
Definition: item_cmpfunc.h:2147
'<,>,=<,=>' operators.
Definition: item_cmpfunc.h:1148
bool gc_subst_analyzer(uchar **) override
Analyzer function for GC substitution.
Definition: item_cmpfunc.h:1157
Item_func_inequality(Item *a, Item *b)
Definition: item_cmpfunc.h:1150
Definition: item_cmpfunc.h:1402
Item_row * row
Definition: item_cmpfunc.h:1405
bool use_decimal_comparison
Definition: item_cmpfunc.h:1406
const char * func_name() const override
Definition: item_cmpfunc.h:1421
interval_range * intervals
Definition: item_cmpfunc.h:1407
uint decimal_precision() const override
Definition: item_cmpfunc.h:1422
Item_int_func super
Definition: item_cmpfunc.h:1403
Item_func_interval(const POS &pos, MEM_ROOT *mem_root, Item *expr1, Item *expr2, class PT_item_list *opt_expr_list=nullptr)
Definition: item_cmpfunc.h:1410
Definition: item_cmpfunc.h:2350
const CHARSET_INFO * compare_collation() const override
Definition: item_cmpfunc.h:2368
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_cmpfunc.h:2371
const char * func_name() const override
Definition: item_cmpfunc.h:2363
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:2364
Item_func_isnotnull(Item *a)
Definition: item_cmpfunc.h:2352
enum Functype functype() const override
Definition: item_cmpfunc.h:2358
Item_func_isnotnull(const POS &pos, Item *a)
Definition: item_cmpfunc.h:2353
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_cmpfunc.h:2359
Definition: item_cmpfunc.h:2286
Item_func_isnull(Item *a)
Definition: item_cmpfunc.h:2293
Item_func_isnull(const POS &pos, Item *a)
Definition: item_cmpfunc.h:2294
const char * func_name() const override
Definition: item_cmpfunc.h:2300
Item_bool_func super
Definition: item_cmpfunc.h:2287
enum Functype functype() const override
Definition: item_cmpfunc.h:2298
bool cached_value
Definition: item_cmpfunc.h:2290
const CHARSET_INFO * compare_collation() const override
Definition: item_cmpfunc.h:2312
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:2308
Implements the comparison operator less than or equals (<=)
Definition: item_cmpfunc.h:1191
cond_result eq_cmp_result() const override
Definition: item_cmpfunc.h:1197
enum Functype rev_functype() const override
Definition: item_cmpfunc.h:1196
Item_func_le(Item *a, Item *b)
Definition: item_cmpfunc.h:1193
const char * func_name() const override
Definition: item_cmpfunc.h:1198
enum Functype functype() const override
Definition: item_cmpfunc.h:1195
Definition: item_cmpfunc.h:2380
Item_func_like(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:2399
int escape() const
Returns the escape character.
Definition: item_cmpfunc.h:2423
int m_escape
The escape character (0 if no escape character).
Definition: item_cmpfunc.h:2387
enum Functype functype() const override
Definition: item_cmpfunc.h:2403
bool escape_was_used_in_parsing() const
Definition: item_cmpfunc.h:2420
Item_func_like(Item *a, Item *b, Item *escape_arg)
Definition: item_cmpfunc.h:2391
Item_func_like(Item *a, Item *b)
Definition: item_cmpfunc.h:2390
cond_result eq_cmp_result() const override
Result may be not equal with equal inputs if ESCAPE character is present.
Definition: item_cmpfunc.h:2406
const char * func_name() const override
Definition: item_cmpfunc.h:2407
bool escape_is_evaluated() const
Has the escape clause been evaluated? It only needs to be evaluated once per execution,...
Definition: item_cmpfunc.h:2434
Item_func_like(const POS &pos, Item *a, Item *b, Item *escape_arg)
Definition: item_cmpfunc.h:2395
Implements the comparison operator less than (<)
Definition: item_cmpfunc.h:1237
Item_func_lt(Item *a, Item *b)
Definition: item_cmpfunc.h:1239
cond_result eq_cmp_result() const override
Definition: item_cmpfunc.h:1243
enum Functype functype() const override
Definition: item_cmpfunc.h:1241
enum Functype rev_functype() const override
Definition: item_cmpfunc.h:1242
const char * func_name() const override
Definition: item_cmpfunc.h:1244
Wrapper class when MATCH function is used in WHERE clause.
Definition: item_cmpfunc.h:770
float get_filtering_effect(THD *thd, table_map filter_for_table, table_map read_tables, const MY_BITMAP *fields_to_ignore, double rows_in_table) override
Calculate the filter contribution that is relevant for table 'filter_for_table' for this item.
Definition: item_cmpfunc.h:782
Item_func_match_predicate(Item *a)
Definition: item_cmpfunc.h:772
const char * func_name() const override
Definition: item_cmpfunc.h:776
longlong val_int() override
Definition: item_cmpfunc.cc:7333
enum Functype functype() const override
Definition: item_cmpfunc.h:775
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.h:777
Implements the comparison operator not equals (<>)
Definition: item_cmpfunc.h:1251
enum Functype rev_functype() const override
Definition: item_cmpfunc.h:1259
cond_result eq_cmp_result() const override
Definition: item_cmpfunc.h:1260
const char * func_name() const override
Definition: item_cmpfunc.h:1262
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:1261
Item_func_ne(Item *a, Item *b)
Definition: item_cmpfunc.h:1256
enum Functype functype() const override
Definition: item_cmpfunc.h:1258
Definition: item_cmpfunc.h:975
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_cmpfunc.h:980
Item * truth_transformer(THD *, Bool_test) override
Apply NOT transformation to the item and return a new one.
Definition: item_cmpfunc.cc:6855
Item_func_nop_all(Item *a)
Definition: item_cmpfunc.h:977
const char * func_name() const override
Definition: item_cmpfunc.h:979
longlong val_int() override
Special NOP (No OPeration) for ALL subquery.
Definition: item_cmpfunc.cc:551
Definition: item_cmpfunc.h:920
bool empty_underlying_subquery()
Definition: item_cmpfunc.cc:513
bool abort_on_null
Definition: item_cmpfunc.h:925
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.cc:534
const char * func_name() const override
Definition: item_cmpfunc.h:942
Item_subselect * subselect
Definition: item_cmpfunc.h:924
Item * truth_transformer(THD *, Bool_test) override
Apply NOT transformation to the item and return a new one.
Definition: item_cmpfunc.cc:6866
longlong val_int() override
special NOT for ALL subquery.
Definition: item_cmpfunc.cc:499
void set_subselect(Item_subselect *item)
Definition: item_cmpfunc.h:947
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_cmpfunc.h:948
void set_sum_test(Item_sum_hybrid *item)
Definition: item_cmpfunc.h:945
bool show
Definition: item_cmpfunc.h:928
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_cmpfunc.h:937
enum Functype functype() const override
Definition: item_cmpfunc.h:941
void set_sub_test(Item_maxmin_subselect *item)
Definition: item_cmpfunc.h:946
bool ignore_unknown() const
Treat UNKNOWN result like FALSE because callers see no difference.
Definition: item_cmpfunc.h:939
Item_sum_hybrid * test_sum_item
Definition: item_cmpfunc.h:922
Item_func_not_all(Item *a)
Definition: item_cmpfunc.h:930
Item_maxmin_subselect * test_sub_item
Definition: item_cmpfunc.h:923
Definition: item_cmpfunc.h:740
Item * truth_transformer(THD *, Bool_test) override
Apply NOT transformation to the item and return a new one.
Definition: item_cmpfunc.cc:6788
enum Functype functype() const override
Definition: item_cmpfunc.h:746
const char * func_name() const override
Definition: item_cmpfunc.h:747
longlong val_int() override
Definition: item_cmpfunc.cc:467
Item_func_not(Item *a)
Definition: item_cmpfunc.h:742
float get_filtering_effect(THD *thd, table_map filter_for_table, table_map read_tables, const MY_BITMAP *fields_to_ignore, double rows_in_table) override
Calculate the filter contribution that is relevant for table 'filter_for_table' for this item.
Definition: item_cmpfunc.cc:441
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.cc:488
Item_func_not(const POS &pos, Item *a)
Definition: item_cmpfunc.h:743
Definition: item_cmpfunc.h:1553
enum_field_types default_data_type() const override
Get the default data (output) type for the specific item.
Definition: item_cmpfunc.h:1567
enum Functype functype() const override
Definition: item_cmpfunc.h:1574
Item_result result_type() const override
Definition: item_cmpfunc.h:1566
bool is_bool_func() const override
This is a workaround for the broken inheritance hierarchy: this should inherit from Item_func instead...
Definition: item_cmpfunc.h:1589
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.h:1579
enum Item_result cached_result_type
Definition: item_cmpfunc.h:1554
Item_func_nullif(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:1557
const char * func_name() const override
Definition: item_cmpfunc.h:1573
uint decimal_precision() const override
Definition: item_cmpfunc.h:1577
Definition: item_func.h:836
Definition: item_cmpfunc.h:1280
void negate()
Definition: item_cmpfunc.h:1295
bool ignore_unknown() const
Definition: item_cmpfunc.h:1297
bool subst_argument_checker(uchar **) override
Definition: item_cmpfunc.h:1313
Item * truth_transformer(THD *, 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_cmpfunc.h:1298
void add_json_info(Json_object *obj) override
Add all the node-specific json fields.
Definition: item_cmpfunc.h:1316
bool pred_level
Definition: item_cmpfunc.h:1283
Item_func_opt_neg(const POS &pos, Item *a, Item *b, Item *c, bool is_negation)
Definition: item_cmpfunc.h:1285
bool allow_replacement(Item_field *const original, Item *const subst) override
Check whether a function allows replacement of a field with another item: In particular,...
Definition: item_cmpfunc.h:1303
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_cmpfunc.h:1296
Item_func_opt_neg(const POS &pos, PT_item_list *list, bool is_negation)
Definition: item_cmpfunc.h:1289
bool negated
Definition: item_cmpfunc.h:1282
Internal function used by subquery to derived transformation to check if a subquery is scalar.
Definition: item_cmpfunc.h:1208
table_map get_initial_pseudo_tables() const override
We add RAND_TABLE_BIT to prevent moving this item from the JOIN condition: it might raise an error to...
Definition: item_cmpfunc.h:1229
const char * func_name() const override
Definition: item_cmpfunc.h:1212
bool is_valid_for_pushdown(uchar *arg) override
Redefine to avoid pushing into derived table.
Definition: item_cmpfunc.h:1214
Item_func_reject_if(Item *a)
Definition: item_cmpfunc.h:1210
Definition: item_cmpfunc.h:1373
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.h:1382
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_cmpfunc.h:1388
const char * func_name() const override
Definition: item_cmpfunc.h:1379
Item_func_strcmp(const POS &pos, Item *a, Item *b)
Definition: item_cmpfunc.h:1375
enum Functype functype() const override
Definition: item_cmpfunc.h:1380
optimize_type select_optimize(const THD *) override
Definition: item_cmpfunc.h:1378
Definition: item_cmpfunc.h:822
bool fix_fields(THD *thd, Item **ref) override
Definition: item_cmpfunc.h:886
enum_trig_type
Definition: item_cmpfunc.h:824
@ FOUND_MATCH
This trigger type deactivates predicated from WHERE condition when no row satisfying the join conditi...
Definition: item_cmpfunc.h:839
@ IS_NOT_NULL_COMPL
This trigger type deactivates join conditions when a row has been NULL-complemented.
Definition: item_cmpfunc.h:830
@ OUTER_FIELD_IS_NOT_NULL
In IN->EXISTS subquery transformation, new predicates are added: WHERE inner_field=outer_field OR inn...
Definition: item_cmpfunc.h:848
const char * func_name() const override
'<if>', to distinguish from the if() SQL function
Definition: item_cmpfunc.h:881
void add_trig_func_tables()
Definition: item_cmpfunc.h:891
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_cmpfunc.h:900
enum enum_trig_type get_trig_type() const
Definition: item_cmpfunc.h:910
bool contains_only_equi_join_condition() const override
Whether this Item is an equi-join condition.
Definition: item_cmpfunc.cc:7699
Item_func_trig_cond(Item *a, bool *f, const JOIN *join, plan_idx idx, enum_trig_type trig_type_arg)
Definition: item_cmpfunc.h:871
table_map get_inner_tables() const
Get table_map of inner tables spanned by associated outer join operation.
Definition: item_cmpfunc.cc:7379
const JOIN * get_join() const
Definition: item_cmpfunc.h:909
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.cc:7399
void get_table_range(Table_ref **first_table, Table_ref **last_table) const
Get range of inner tables spanned by associated outer join operation.
Definition: item_cmpfunc.cc:7358
bool * get_trig_var()
Definition: item_cmpfunc.h:911
plan_idx idx() const
Definition: item_cmpfunc.h:915
plan_idx m_idx
Optional: if join!=NULL: index of table.
Definition: item_cmpfunc.h:857
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Fix after tables have been moved from one query_block level to the parent level, e....
Definition: item_cmpfunc.h:904
longlong val_int() override
Definition: item_cmpfunc.cc:7344
enum_trig_type trig_type
Type of trig_var; for printing.
Definition: item_cmpfunc.h:859
enum Functype functype() const override
Definition: item_cmpfunc.h:879
bool * trig_var
Pointer to trigger variable.
Definition: item_cmpfunc.h:853
enum_trig_type get_trig_type()
Definition: item_cmpfunc.h:912
const JOIN * m_join
Optional: JOIN of table which is the source of trig_var.
Definition: item_cmpfunc.h:855
A predicate that is "always true".
Definition: item_cmpfunc.h:379
bool val_bool() override
Definition: item_cmpfunc.h:384
enum Functype functype() const override
Definition: item_cmpfunc.h:389
Item_func_true()
Definition: item_cmpfunc.h:381
void print(const THD *, String *str, enum_query_type) const override
This method is used for to:
Definition: item_cmpfunc.h:386
Item_func_true(const POS &pos)
Definition: item_cmpfunc.h:382
const char * func_name() const override
Definition: item_cmpfunc.h:383
longlong val_int() override
Definition: item_cmpfunc.h:385
Item class, to represent X IS [NOT] (TRUE | FALSE) boolean predicates.
Definition: item_cmpfunc.h:411
Bool_test truth_test
The value we're testing for.
Definition: item_cmpfunc.h:470
Item_bool_func super
Definition: item_cmpfunc.h:412
longlong val_int() override
Definition: item_cmpfunc.cc:2246
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_cmpfunc.h:454
enum Functype functype() const override
Definition: item_cmpfunc.h:426
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.cc:2236
Item_func_truth(const POS &pos, Item *a, Bool_test truth_test)
Definition: item_cmpfunc.h:428
bool resolve_type(THD *) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_cmpfunc.cc:2230
Item * truth_transformer(THD *, 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_cmpfunc.h:419
Item_func_truth(Item *a, Bool_test truth_test)
Definition: item_cmpfunc.h:441
const char * func_name() const override
Definition: item_cmpfunc.h:423
XOR inherits from Item_bool_func2 because it is not optimized yet.
Definition: item_cmpfunc.h:719
Item_bool_func2 super
Definition: item_cmpfunc.h:720
const char * func_name() const override
Definition: item_cmpfunc.h:728
longlong val_int() override
Make a logical XOR of the arguments.
Definition: item_cmpfunc.cc:6747
float get_filtering_effect(THD *thd, table_map filter_for_table, table_map read_tables, const MY_BITMAP *fields_to_ignore, double rows_in_table) override
Calculate the filter contribution that is relevant for table 'filter_for_table' for this item.
Definition: item_cmpfunc.cc:6709
enum Functype functype() const override
Definition: item_cmpfunc.h:727
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_cmpfunc.h:731
Item_func_xor(const POS &pos, Item *i1, Item *i2)
Definition: item_cmpfunc.h:724
Item_func_xor(Item *i1, Item *i2)
Definition: item_cmpfunc.h:723
Item * truth_transformer(THD *, Bool_test) override
XOR can be negated by negating one of the operands:
Definition: item_cmpfunc.cc:6806
bool do_itemize(Parse_context *pc, Item **res) override
The core function that does the actual itemization.
Definition: item_cmpfunc.cc:6694
Definition: item_func.h:102
my_decimal * val_decimal(my_decimal *) override
Definition: item_func.cc:836
Item ** args
Array of pointers to arguments.
Definition: item_func.h:109
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_func.cc:733
bool split_sum_func(THD *thd, Ref_item_array ref_item_array, mem_root_deque< Item * > *fields) override
See comments in Item_cmp_func::split_sum_func()
Definition: item_func.cc:722
void traverse_cond(Cond_traverser traverser, void *arg, traverse_order order) override
Definition: item_func.cc:641
Item * compile(Item_analyzer analyzer, uchar **arg_p, Item_transformer transformer, uchar *arg_t) override
Compile Item_func object with a processor and a transformer callback functions.
Definition: item_func.cc:699
Functype
Definition: item_func.h:187
@ TRIG_COND_FUNC
Definition: item_func.h:231
@ NOT_ALL_FUNC
Definition: item_func.h:228
@ LIKE_FUNC
Definition: item_func.h:198
@ FALSE_FUNC
Definition: item_func.h:311
@ NULLIF_FUNC
Definition: item_func.h:272
@ NOT_FUNC
Definition: item_func.h:227
@ XOR_FUNC
Definition: item_func.h:204
@ COND_OR_FUNC
Definition: item_func.h:203
@ COND_AND_FUNC
Definition: item_func.h:202
@ EQ_FUNC
Definition: item_func.h:189
@ TRUE_FUNC
Definition: item_func.h:310
@ IN_FUNC
Definition: item_func.h:206
@ LE_FUNC
Definition: item_func.h:193
@ MATCH_FUNC
Definition: item_func.h:197
@ LT_FUNC
Definition: item_func.h:192
@ ISNULL_FUNC
Definition: item_func.h:199
@ ISNOTNULLTEST_FUNC
Definition: item_func.h:209
@ MULT_EQUAL_FUNC
Definition: item_func.h:207
@ ISTRUTH_FUNC
Definition: item_func.h:201
@ BETWEEN
Definition: item_func.h:205
@ IF_FUNC
Definition: item_func.h:271
@ STRCMP_FUNC
Definition: item_func.h:309
@ NE_FUNC
Definition: item_func.h:191
@ GE_FUNC
Definition: item_func.h:194
@ EQUAL_FUNC
Definition: item_func.h:190
@ GT_FUNC
Definition: item_func.h:195
@ UNKNOWN_FUNC
Definition: item_func.h:188
@ ISNOTNULL_FUNC
Definition: item_func.h:200
@ CASE_FUNC
Definition: item_func.h:273
@ COALESCE_FUNC
Definition: item_func.h:303
void print_op(const THD *thd, String *str, enum_query_type query_type) const
Definition: item_func.cc:763
table_map used_tables_cache
Value used in calculation of result of used_tables()
Definition: item_func.h:171
optimize_type
Definition: item_func.h:325
@ OPTIMIZE_NONE
Definition: item_func.h:326
@ OPTIMIZE_EQUAL
Definition: item_func.h:330
@ OPTIMIZE_NULL
Definition: item_func.h:329
@ OPTIMIZE_KEY
Definition: item_func.h:327
@ OPTIMIZE_OP
Definition: item_func.h:328
bool do_itemize(Parse_context *pc, Item **res) override
The core function that does the actual itemization.
Definition: item_func.cc:360
bool resolve_type(THD *thd) override
Resolve type-related information for this item, such as result field type, maximum size,...
Definition: item_func.h:680
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_func.cc:747
bool fix_fields(THD *, Item **ref) override
Definition: item_func.cc:405
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Fix after tables have been moved from one query_block level to the parent level, e....
Definition: item_func.cc:459
bool set_arguments(mem_root_deque< Item * > *list, bool context_free)
Copy arguments from list to args array.
Definition: item_func.cc:328
uint arg_count
How many arguments in 'args'.
Definition: item_func.h:132
Field * tmp_table_field(TABLE *t_arg) override
Definition: item_func.cc:794
bool eq(const Item *item, bool binary_cmp) const override
Definition: item_func.cc:777
table_map not_null_tables_cache
Value used in calculation of result of not_null_tables()
Definition: item_func.h:173
bool null_on_null
Affects how to determine that NULL argument implies a NULL function return.
Definition: item_func.h:164
bool walk(Item_processor processor, enum_walk walk, uchar *arg) override
Traverses a tree of Items in prefix and/or postfix order.
Definition: item_func.cc:630
Item * transform(Item_transformer transformer, uchar *arg) override
Transform an Item_func object with a transformer callback function.
Definition: item_func.cc:674
virtual bool resolve_type_inner(THD *)
Resolve type of function after all arguments have had their data types resolved.
Definition: item_func.h:481
uint allowed_arg_cols
Definition: item_func.h:169
Definition: item.h:4083
Definition: item_cmpfunc.h:492
bool split_sum_func(THD *thd, Ref_item_array ref_item_array, mem_root_deque< Item * > *fields) override
Definition: item_cmpfunc.cc:2364
bool is_null() override
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item_cmpfunc.cc:2554
bool fix_left(THD *thd)
Definition: item_cmpfunc.cc:2279
Item_cache * cache
Definition: item_cmpfunc.h:494
const char * func_name() const override
Definition: item_cmpfunc.h:519
longlong val_int() override
The implementation of optimized <outer expression> [NOT] IN <subquery> predicates.
Definition: item_cmpfunc.cc:2461
Item_in_optimizer(Item_in_subselect *item)
Definition: item_cmpfunc.h:504
int result_for_null_param
Stores the value of "NULL IN (SELECT ...)" for uncorrelated subqueries: UNKNOWN - "NULL in (SELECT ....
Definition: item_cmpfunc.h:501
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block) override
Fix after tables have been moved from one query_block level to the parent level, e....
Definition: item_cmpfunc.cc:2353
void update_used_tables() override
Updates used tables, not null tables information and accumulates properties up the item tree,...
Definition: item_cmpfunc.cc:2559
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item_cmpfunc.cc:2541
Item_cache ** get_cache()
Definition: item_cmpfunc.h:520
bool fix_fields(THD *, Item **) override
Definition: item_cmpfunc.cc:2321
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.cc:2376
Representation of IN subquery predicates of the form "left_expr IN (SELECT ...)".
Definition: item_subselect.h:572
Definition: item_func.h:983
String * val_str(String *str) override
Definition: item_func.cc:1473
bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override
Definition: item_func.h:1031
double val_real() override
Definition: item_func.cc:1467
enum Item_result result_type() const override
Definition: item_func.h:1035
bool get_time(MYSQL_TIME *ltime) override
Definition: item_func.h:1034
Definition: item.h:5104
Definition: item_cmpfunc.h:2325
void print(const THD *thd, String *str, enum_query_type query_type) const override
This method is used for to:
Definition: item_cmpfunc.h:2344
Item_in_subselect * owner
Definition: item_cmpfunc.h:2326
const char * func_name() const override
Definition: item_cmpfunc.h:2333
Item_is_not_null_test(Item_in_subselect *ow, Item *a)
Definition: item_cmpfunc.h:2329
table_map get_initial_pseudo_tables() const override
We add RAND_TABLE_BIT to prevent moving this item from HAVING to WHERE.
Definition: item_cmpfunc.h:2341
enum Functype functype() const override
Definition: item_cmpfunc.h:2331
Definition: item_subselect.h:372
Item with result field.
Definition: item.h:5812
Field * result_field
Definition: item.h:5814
void cleanup() override
Called for every Item after use (preparation and execution).
Definition: item.cc:10927
Item which stores (x,y,...) and ROW(x,y,...).
Definition: item_row.h:54
Definition: item.h:5443
Base class that is common to all subqueries and subquery predicates.
Definition: item_subselect.h:80
Abstract base class for the MIN and MAX aggregate functions.
Definition: item_sum.h:1540
Definition: item.h:5230
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:936
virtual double val_real()=0
virtual float get_filtering_effect(THD *thd, table_map filter_for_table, table_map read_tables, const MY_BITMAP *fields_to_ignore, double rows_in_table)
Calculate the filter contribution that is relevant for table 'filter_for_table' for this item.
Definition: item.h:2096
void set_nullable(bool nullable)
Definition: item.h:3643
DTCollation collation
Character set and collation properties assigned for this Item.
Definition: item.h:3539
void set_data_type_bool()
Definition: item.h:1512
virtual bool collect_item_field_or_view_ref_processor(uchar *)
Collects fields and view references that have the qualifying table in the specified query block.
Definition: item.h:2757
bool is_nullable() const
Definition: item.h:3642
void set_subquery()
Set the "has subquery" property.
Definition: item.h:3395
void fix_char_length(uint32 max_char_length_arg)
Definition: item.h:3345
virtual Item * equality_substitution_transformer(uchar *)
Definition: item.h:2973
virtual uint decimal_precision() const
Definition: item.cc:774
virtual bool val_json(Json_wrapper *result)
Get a JSON value from an Item.
Definition: item.h:2068
virtual longlong val_int()=0
virtual void print(const THD *, String *str, enum_query_type) const
This method is used for to:
Definition: item.h:2462
bool fixed
True if item has been resolved.
Definition: item.h:3631
bool null_value
True if item is null.
Definition: item.h:3668
Type
Definition: item.h:971
@ COND_ITEM
An AND or OR condition.
Definition: item.h:984
virtual void apply_is_true()
Apply the IS TRUE truth property, meaning that an UNKNOWN result and a FALSE result are treated the s...
Definition: item.h:2535
virtual table_map not_null_tables() const
Return table map of tables that can't be NULL tables (tables that are used in a context where if they...
Definition: item.h:2351
virtual TYPELIB * get_typelib() const
Get the typelib information for an item of type set or enum.
Definition: item.h:1796
bool unsigned_flag
Definition: item.h:3669
virtual bool aggregate_check_group(uchar *)
Definition: item.h:2903
virtual bool is_null()
The method allows to determine nullness of a complex expression without fully evaluating it,...
Definition: item.h:2516
virtual bool clean_up_after_removal(uchar *arg)
Clean up after removing the item from the item tree.
Definition: item.cc:7787
virtual bool aggregate_check_distinct(uchar *)
Definition: item.h:2901
cond_result
Definition: item.h:998
@ COND_TRUE
Definition: item.h:998
@ COND_FALSE
Definition: item.h:998
@ COND_OK
Definition: item.h:998
traverse_order
Definition: item.h:1000
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_NEGATED
Definition: item.h:1021
uint32 max_length
Maximum length of result of evaluating this item, in number of bytes.
Definition: item.h:3557
virtual enum Type type() const =0
virtual uint cols() const
Definition: item.h:3144
Definition: sql_optimizer.h:133
Represents a JSON container value of type "object" (ECMA), type J_OBJECT here.
Definition: json_dom.h:369
bool add_alias(const std::string &key, Json_dom *value)
Insert the value into the object.
Definition: json_dom.h:411
A class that is capable of holding objects of any sub-type of Json_scalar.
Definition: json_dom.h:1886
Abstraction for accessing JSON values irrespective of whether they are (started out as) binary JSON v...
Definition: json_dom.h:1153
Definition: item_cmpfunc.h:610
Item_bool_func * create(Item *a, Item *b) const override
Definition: item_cmpfunc.cc:437
bool l_op() const override
Definition: item_cmpfunc.h:615
const char * symbol(bool invert) const override
This interface is only used by Item_allany_subselect.
Definition: item_cmpfunc.h:613
bool eqne_op() const override
Definition: item_cmpfunc.h:614
Abstract base class for the comparison operators =, <> and <=>.
Definition: item_cmpfunc.h:537
virtual Item_bool_func * create_scalar_predicate(Item *a, Item *b) const =0
Creates only an item tree node, without attempting to rewrite row constructors.
virtual Item_bool_func * combine(List< Item > list) const =0
Combines a list of conditions exp op exp.
bool eqne_op() const override
Definition: item_cmpfunc.h:540
Item_bool_func * create(Item *a, Item *b) const override
This implementation of the factory method also implements flattening of row constructors.
Definition: item_cmpfunc.cc:379
bool l_op() const override
Definition: item_cmpfunc.h:541
Definition: sql_list.h:653
Definition: sql_list.h:467
void sort(Node_cmp_func cmp)
Sort the list.
Definition: sql_list.h:567
T * head()
Definition: sql_list.h:493
Definition: item_cmpfunc.h:594
Item_bool_func * create(Item *a, Item *b) const override
Definition: item_cmpfunc.cc:429
bool l_op() const override
Definition: item_cmpfunc.h:599
bool eqne_op() const override
Definition: item_cmpfunc.h:598
const char * symbol(bool invert) const override
This interface is only used by Item_allany_subselect.
Definition: item_cmpfunc.h:597
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:61
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:426
Definition: item_cmpfunc.h:577
Item_bool_func * create_scalar_predicate(Item *a, Item *b) const override
Creates only an item tree node, without attempting to rewrite row constructors.
Definition: item_cmpfunc.cc:416
const char * symbol(bool invert) const override
This interface is only used by Item_allany_subselect.
Definition: item_cmpfunc.h:579
Item_bool_func * combine(List< Item > list) const override
Combines a list of conditions exp op exp.
Definition: item_cmpfunc.cc:421
Wrapper class for an Item list head, used to allocate Item lists in the parser in a context-independe...
Definition: parse_tree_helpers.h:105
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:1167
String class wrapper with a preallocated buffer of size buff_sz.
Definition: sql_string.h:681
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:167
bool copy()
Definition: sql_string.cc:198
bool is_alloced() const
Definition: sql_string.h:437
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:2865
uint elements
Definition: sql_list.h:169
Definition: item_cmpfunc.h:1940
longlong value
Definition: item_cmpfunc.h:1941
bool has_date
Distinguish between DATE/DATETIME/TIMESTAMP and TIME.
Definition: item_cmpfunc.h:1947
const Item * warn_item
Definition: item_cmpfunc.h:1945
Definition: item_cmpfunc.h:1975
my_decimal value
Definition: item_cmpfunc.h:1976
Definition: item_cmpfunc.h:1916
longlong value
Definition: item_cmpfunc.h:1917
void store_value(Item *item) override
Definition: item_cmpfunc.h:1920
int cmp(Item *arg) override
Definition: item_cmpfunc.h:1924
int compare(const cmp_item *ci) const override
Definition: item_cmpfunc.h:1928
Definition: item_cmpfunc.h:1890
unique_ptr_destroy_only< Json_wrapper > m_value
Cached JSON value to look up.
Definition: item_cmpfunc.h:1893
~cmp_item_json() override
String m_str_value
String buffer.
Definition: item_cmpfunc.h:1897
unique_ptr_destroy_only< Json_scalar_holder > m_holder
Cache for the value above.
Definition: item_cmpfunc.h:1895
Definition: item_cmpfunc.h:1956
int cmp(Item *arg) override
Definition: item_cmpfunc.h:1964
double value
Definition: item_cmpfunc.h:1957
void store_value(Item *item) override
Definition: item_cmpfunc.h:1960
int compare(const cmp_item *ci) const override
Definition: item_cmpfunc.h:1968
Definition: item_cmpfunc.h:2202
cmp_item_row(cmp_item_row &&other)
Definition: item_cmpfunc.h:2217
uint n
Definition: item_cmpfunc.h:2204
void set_null_value(bool nv) override
Definition: item_cmpfunc.h:2230
cmp_item_row(THD *thd, Item *item)
Definition: item_cmpfunc.h:2212
cmp_item_row()
Definition: item_cmpfunc.h:2207
cmp_item which stores a scalar (i.e. non-ROW).
Definition: item_cmpfunc.h:1856
bool m_null_value
If stored value is NULL.
Definition: item_cmpfunc.h:1858
void set_null_value(bool nv) override
Definition: item_cmpfunc.h:1859
Definition: item_cmpfunc.h:1862
const String * value_res
Definition: item_cmpfunc.h:1864
int compare(const cmp_item *ci) const override
Definition: item_cmpfunc.h:1871
cmp_item_string(const CHARSET_INFO *cs)
Definition: item_cmpfunc.h:1869
void store_value(Item *item) override
Definition: item_cmpfunc.h:1876
const CHARSET_INFO * cmp_charset
Definition: item_cmpfunc.h:1866
StringBuffer< STRING_BUFFER_USUAL_SIZE > value
Definition: item_cmpfunc.h:1865
Definition: item_cmpfunc.h:1811
virtual void store_value(Item *item)=0
virtual int compare(const cmp_item *item) const =0
virtual int cmp(Item *item)=0
virtual void set_null_value(bool nv)=0
virtual ~cmp_item()=default
virtual cmp_item * make_same()=0
cmp_item()=default
virtual void store_value_by_template(cmp_item *, Item *item)
Definition: item_cmpfunc.h:1849
Definition: item_cmpfunc.h:1723
Item_basic_constant * create_item(MEM_ROOT *mem_root) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:1727
in_datetime_as_longlong(MEM_ROOT *mem_root, uint elements)
Definition: item_cmpfunc.h:1725
Definition: item_cmpfunc.h:1751
Item_basic_constant * create_item(MEM_ROOT *mem_root) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:1758
Item * warn_item
An item used to issue warnings.
Definition: item_cmpfunc.h:1753
in_datetime(MEM_ROOT *mem_root, Item *warn_item_arg, uint elements)
Definition: item_cmpfunc.h:1756
Definition: item_cmpfunc.h:1787
Mem_root_array< my_decimal > base
Definition: item_cmpfunc.h:1788
in_decimal(MEM_ROOT *mem_root, uint elements)
Definition: item_cmpfunc.h:1791
void value_to_item(uint pos, Item_basic_constant *item) const override
Store the value at position pos into provided item object.
Definition: item_cmpfunc.h:1796
Item_basic_constant * create_item(MEM_ROOT *mem_root) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:1793
Definition: item_cmpfunc.h:1767
in_double(MEM_ROOT *mem_root, uint elements)
Definition: item_cmpfunc.h:1771
void value_to_item(uint pos, Item_basic_constant *item) const override
Store the value at position pos into provided item object.
Definition: item_cmpfunc.h:1776
Mem_root_array< double > base
Definition: item_cmpfunc.h:1768
Item_basic_constant * create_item(MEM_ROOT *mem_root) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:1773
Definition: item_cmpfunc.h:1690
Item_basic_constant * create_item(MEM_ROOT *mem_root) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:1703
in_longlong(MEM_ROOT *mem_root, uint elements)
Definition: item_cmpfunc.h:1701
void value_to_item(uint pos, Item_basic_constant *item) const override
Store the value at position pos into provided item object.
Definition: item_cmpfunc.h:1710
void set(uint pos, Item *item) override
Definition: item_cmpfunc.h:1718
Mem_root_array< packed_longlong > base
Definition: item_cmpfunc.h:1698
Definition: item_cmpfunc.h:2249
Mem_root_array< cmp_item_row * > base_pointers
Definition: item_cmpfunc.h:2253
Mem_root_array< cmp_item_row > base_objects
Definition: item_cmpfunc.h:2251
Item_basic_constant * create_item(MEM_ROOT *) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:2271
unique_ptr_destroy_only< cmp_item_row > tmp
Definition: item_cmpfunc.h:2250
bool is_row_result() const override
Definition: item_cmpfunc.h:2257
void value_to_item(uint, Item_basic_constant *) const override
Store the value at position pos into provided item object.
Definition: item_cmpfunc.h:2275
Definition: item_cmpfunc.h:1665
Mem_root_array< String * > base_pointers
Definition: item_cmpfunc.h:1670
Mem_root_array< String > base_objects
Definition: item_cmpfunc.h:1668
void value_to_item(uint pos, Item_basic_constant *item) const override
Store the value at position pos into provided item object.
Definition: item_cmpfunc.h:1678
const CHARSET_INFO * collation
Definition: item_cmpfunc.h:1671
String tmp
Definition: item_cmpfunc.h:1667
Item_basic_constant * create_item(MEM_ROOT *mem_root) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:1675
Definition: item_cmpfunc.h:1735
Item_basic_constant * create_item(MEM_ROOT *mem_root) const override
Create an instance of Item_{type} (e.g.
Definition: item_cmpfunc.h:1739
in_time_as_longlong(MEM_ROOT *mem_root, uint elements)
Definition: item_cmpfunc.h:1737
Definition: item_cmpfunc.h:1596
const uint m_size
Size of the vector.
Definition: item_cmpfunc.h:1598
virtual void cleanup()
Definition: item_cmpfunc.h:1656
virtual void set(uint pos, Item *item)=0
virtual void value_to_item(uint pos, Item_basic_constant *item) const =0
Store the value at position pos into provided item object.
virtual ~in_vector()=default
virtual bool find_item(Item *item)=0
Calls item->val_int() or item->val_str() etc.
virtual bool is_row_result() const
Definition: item_cmpfunc.h:1642
virtual bool compare_elems(uint pos1, uint pos2) const =0
Compare values number pos1 and pos2 for equality.
virtual Item_basic_constant * create_item(MEM_ROOT *mem_root) const =0
Create an instance of Item_{type} (e.g.
virtual void sort_array()=0
Sort the IN-list array, so we can do efficient lookup with binary_search.
in_vector(uint elements)
See Item_func_in::resolve_type() for why we need both count and used_count.
Definition: item_cmpfunc.h:1606
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
static MEM_ROOT mem_root
Definition: client_plugin.cc:114
static bool contains(const std::vector< std::string > &container, const std::string &file)
Definition: config_files.cc:41
enum_query_type
Query type constants (usable as bitmap flags).
Definition: enum_query_type.h:31
This file contains the field type.
enum_field_types
Column types for MySQL Note: Keep include/mysql/components/services/bits/stored_program_bits....
Definition: field_types.h:55
@ MYSQL_TYPE_VARCHAR
Definition: field_types.h:71
@ MYSQL_TYPE_TIME
Definition: field_types.h:67
@ MYSQL_TYPE_DATETIME
Definition: field_types.h:68
bool(Item::* Item_analyzer)(uchar **argp)
Definition: item.h:718
void(* Cond_traverser)(const Item *item, void *arg)
Definition: item.h:728
Item *(Item::* Item_transformer)(uchar *arg)
Type for transformers used by Item::transform and Item::compile.
Definition: item.h:727
static void ensure_multi_equality_fields_are_available(Item **args, int arg_idx, table_map available_tables, bool replace, bool *found)
Definition: item_cmpfunc.cc:8145
int(Arg_comparator::* arg_cmp_func)()
Definition: item_cmpfunc.h:74
Eq_creator eq_creator
Definition: mysqld.cc:1522
Ge_creator ge_creator
Definition: mysqld.cc:1527
Item * make_condition(Parse_context *pc, Item *item)
Ensure that all expressions involved in conditions are boolean functions.
Definition: item_cmpfunc.cc:5670
void find_and_adjust_equal_fields(Item *item, table_map available_tables, bool replace, bool *found)
Definition: item_cmpfunc.cc:8126
Lt_creator lt_creator
Definition: mysqld.cc:1526
bool get_mysql_time_from_str_no_warn(THD *thd, String *str, MYSQL_TIME *l_time, MYSQL_TIME_STATUS *status)
A minion of get_mysql_time_from_str, see its description.
Definition: item_cmpfunc.cc:996
Gt_creator gt_creator
Definition: mysqld.cc:1525
static const int UNKNOWN
Definition: item_cmpfunc.h:473
bool IsAnd(const Item *item)
Returns true if the item is a conjunction.
Definition: item_cmpfunc.h:2846
Ne_creator ne_creator
Definition: mysqld.cc:1523
Equal_creator equal_creator
Definition: mysqld.cc:1524
bool WalkConjunction(Item *condition, Func func)
Calls "func" on each term in "condition" if it's a conjunction (and recursively on any conjunction di...
Definition: item_cmpfunc.h:2859
bool get_mysql_time_from_str(THD *thd, String *str, enum_mysql_timestamp_type warn_type, const char *warn_name, MYSQL_TIME *l_time)
Parse date provided in a string to a MYSQL_TIME.
Definition: item_cmpfunc.cc:1027
Le_creator le_creator
Definition: mysqld.cc:1528
longlong get_datetime_value(THD *thd, Item ***item_arg, Item **, const Item *warn_item, bool *is_null)
Retrieve correct DATETIME value from given item.
Definition: item_cmpfunc.cc:1635
Item * and_conds(Item *a, Item *b)
Builds condition: (a AND b) IS TRUE.
Definition: item_cmpfunc.h:2804
String * eval_string_arg(const CHARSET_INFO *to_cs, Item *arg, String *buffer)
Definition: item_func.h:95
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
Header for compiler-dependent features.
It is interface module to fixed precision decimals library.
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
uint16_t uint16
Definition: my_inttypes.h:65
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...
enum_mysql_timestamp_type
Definition: mysql_time.h:45
static bool replace
Definition: mysqlimport.cc:70
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1086
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
Definition: commit_order_queue.h:34
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
static mysql_service_status_t add(reference_caching_channel channel, const char *implementation_name) noexcept
Definition: component.cc:127
std::set< Key, Compare, ut::allocator< Key > > set
Specialization of set which uses ut_allocator.
Definition: ut0new.h:2883
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2879
required uint32 status
Definition: replication_asynchronous_connection_failover.proto:61
required string type
Definition: replication_group_member_actions.proto:34
static int compare(size_t a, size_t b)
Function to compare two size_t integers for their relative order.
Definition: rpl_utility.cc:107
File containing constants that can be used throughout the server.
constexpr const table_map RAND_TABLE_BIT
Definition: sql_const.h:111
constexpr const size_t STRING_BUFFER_USUAL_SIZE
Definition: sql_const.h:124
constexpr const table_map OUTER_REF_TABLE_BIT
Definition: sql_const.h:110
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
int plan_idx
This represents the index of a JOIN_TAB/QEP_TAB in an array.
Definition: sql_opt_exec_shared.h:54
Our own string classes, used pervasively throughout the executor.
int sortcmp(const String *a, const String *b, const CHARSET_INFO *cs)
Definition: sql_string.cc:689
Definition: m_ctype.h:423
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:83
Structure to return status from str_to_datetime(), str_to_time(), number_to_datetime(),...
Definition: my_time.h:170
Definition: mysql_time.h:82
Definition: my_bitmap.h:43
Bison "location" class.
Definition: parse_location.h:43
Environment data for the contextualization phase.
Definition: parse_tree_node_base.h:420
Definition: table.h:1407
Definition: typelib.h:35
Definition: item_cmpfunc.h:1692
bool unsigned_flag
Definition: item_cmpfunc.h:1694
longlong val
Definition: item_cmpfunc.h:1693
Definition: item_cmpfunc.h:1396
Item_result type
Definition: item_cmpfunc.h:1397
double dbl
Definition: item_cmpfunc.h:1398
my_decimal dec
Definition: item_cmpfunc.h:1399
Definition: result.h:30
Target down_cast(Source *arg)
Casts from one pointer type to another in a type hierarchy.
Definition: template_utils.h:96
constexpr T pointer_cast(void *p)
Casts from one pointer type, to another, without using reinterpret_cast or C-style cast: foo f; bar *...
Definition: template_utils.h:75
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
@ INVALID_RESULT
Definition: udf_registration_types.h:40
int n
Definition: xcom_base.cc:509