MySQL 9.1.0
Source Code Documentation
item.h
Go to the documentation of this file.
1#ifndef ITEM_INCLUDED
2#define ITEM_INCLUDED
3
4/* Copyright (c) 2000, 2024, Oracle and/or its affiliates.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License, version 2.0,
8 as published by the Free Software Foundation.
9
10 This program is designed to work with certain software (including
11 but not limited to OpenSSL) that is licensed under separate terms,
12 as designated in a particular file or component or in included license
13 documentation. The authors of MySQL hereby grant you an additional
14 permission to link the program and your derivative works with the
15 separately licensed software that they have either included with
16 the program or referenced in the documentation.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License, version 2.0, for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
26
27#include <sys/types.h>
28
29#include <cfloat>
30#include <climits>
31#include <cmath>
32#include <cstdio>
33#include <cstring>
34#include <memory>
35#include <new>
36#include <optional>
37#include <string>
38#include <type_traits>
39#include <vector>
40
41#include "decimal.h"
42#include "field_types.h" // enum_field_types
43#include "lex_string.h"
44#include "memory_debugging.h"
45#include "my_alloc.h"
46#include "my_bitmap.h"
47#include "my_compiler.h"
48#include "my_dbug.h"
49#include "my_double2ulonglong.h"
50#include "my_inttypes.h"
51#include "my_sys.h"
52#include "my_table_map.h"
53#include "my_time.h"
54#include "mysql/strings/dtoa.h"
58#include "mysql_com.h"
59#include "mysql_time.h"
60#include "mysqld_error.h"
61#include "nulls.h"
62#include "sql-common/my_decimal.h" // my_decimal
63#include "sql/auth/auth_acls.h" // Access_bitmask
64#include "sql/enum_query_type.h"
65#include "sql/field.h" // Derivation
66#include "sql/mem_root_array.h"
67#include "sql/parse_location.h" // POS
68#include "sql/parse_tree_node_base.h" // Parse_tree_node
69#include "sql/sql_array.h" // Bounds_checked_array
70#include "sql/sql_const.h"
71#include "sql/sql_list.h"
72#include "sql/table.h"
73#include "sql/table_trigger_field_support.h" // Table_trigger_field_support
74#include "sql/thr_malloc.h"
75#include "sql/trigger_def.h" // enum_trigger_variable_type
76#include "sql_string.h"
77#include "string_with_len.h"
78#include "template_utils.h"
79
80class Item;
81class Item_cache;
83class Item_field;
84class Item_func;
85class Item_multi_eq;
87class Item_sum;
88class Json_wrapper;
89class Protocol;
90class Query_block;
92class sp_head;
93class sp_rcontext;
94class THD;
95class user_var_entry;
96struct COND_EQUAL;
97struct TYPELIB;
98
100
101void item_init(void); /* Init item functions */
102
103/**
104 Default condition filtering (selectivity) values used by
105 get_filtering_effect() and friends when better estimates
106 (statistics) are not available for a predicate.
107*/
108/**
109 For predicates that are always satisfied. Must be 1.0 or the filter
110 calculation logic will break down.
111*/
112constexpr float COND_FILTER_ALLPASS{1.0f};
113/// Filtering effect for equalities: col1 = col2
114constexpr float COND_FILTER_EQUALITY{0.1f};
115/// Filtering effect for inequalities: col1 > col2
116constexpr float COND_FILTER_INEQUALITY{0.3333f};
117/// Filtering effect for between: col1 BETWEEN a AND b
118constexpr float COND_FILTER_BETWEEN{0.1111f};
119/**
120 Value is out-of-date, will need recalculation.
121 This is used by post-greedy-search logic which changes the access method and
122 thus makes obsolete the filtering value calculated by best_access_path(). For
123 example, test_if_skip_sort_order().
124*/
125constexpr float COND_FILTER_STALE{-1.0f};
126/**
127 A special subcase of the above:
128 - if this is table/index/range scan, and
129 - rows_fetched is how many rows we will examine, and
130 - rows_fetched is less than the number of rows in the table (as determined
131 by test_if_cheaper_ordering() and test_if_skip_sort_order()).
132 Unlike the ordinary case where rows_fetched:
133 - is set by calculate_scan_cost(), and
134 - is how many rows pass the constant condition (so, less than we will
135 examine), and
136 - the actual rows_fetched to show in EXPLAIN is the number of rows in the
137 table (== rows which we will examine), and
138 - the constant condition's effect has to be moved to filter_effect for
139 EXPLAIN.
140*/
141constexpr float COND_FILTER_STALE_NO_CONST{-2.0f};
142
143static inline uint32 char_to_byte_length_safe(uint32 char_length_arg,
144 uint32 mbmaxlen_arg) {
145 const ulonglong tmp = ((ulonglong)char_length_arg) * mbmaxlen_arg;
146 return (tmp > UINT_MAX32) ? (uint32)UINT_MAX32 : (uint32)tmp;
147}
148
150 Item_result result_type,
151 uint8 decimals) {
152 if (is_temporal_type(real_type_to_type(data_type)))
153 return decimals ? DECIMAL_RESULT : INT_RESULT;
154 if (result_type == STRING_RESULT) return REAL_RESULT;
155 return result_type;
156}
157
158/*
159 "Declared Type Collation"
160 A combination of collation and its derivation.
161
162 Flags for collation aggregation modes:
163 MY_COLL_ALLOW_SUPERSET_CONV - allow conversion to a superset
164 MY_COLL_ALLOW_COERCIBLE_CONV - allow conversion of a coercible value
165 (i.e. constant).
166 MY_COLL_ALLOW_CONV - allow any kind of conversion
167 (combination of the above two)
168 MY_COLL_ALLOW_NUMERIC_CONV - if all items were numbers, convert to
169 @@character_set_connection
170 MY_COLL_DISALLOW_NONE - don't allow return DERIVATION_NONE
171 (e.g. when aggregating for comparison)
172 MY_COLL_CMP_CONV - combination of MY_COLL_ALLOW_CONV
173 and MY_COLL_DISALLOW_NONE
174*/
175
176#define MY_COLL_ALLOW_SUPERSET_CONV 1
177#define MY_COLL_ALLOW_COERCIBLE_CONV 2
178#define MY_COLL_DISALLOW_NONE 4
179#define MY_COLL_ALLOW_NUMERIC_CONV 8
180
181#define MY_COLL_ALLOW_CONV \
182 (MY_COLL_ALLOW_SUPERSET_CONV | MY_COLL_ALLOW_COERCIBLE_CONV)
183#define MY_COLL_CMP_CONV (MY_COLL_ALLOW_CONV | MY_COLL_DISALLOW_NONE)
184
186 public:
190
194 }
199 }
200 DTCollation(const CHARSET_INFO *collation_arg, Derivation derivation_arg) {
201 collation = collation_arg;
202 derivation = derivation_arg;
203 set_repertoire_from_charset(collation_arg);
204 }
205 void set(const DTCollation &dt) {
206 collation = dt.collation;
209 }
210 void set(const CHARSET_INFO *collation_arg, Derivation derivation_arg) {
211 collation = collation_arg;
212 derivation = derivation_arg;
213 set_repertoire_from_charset(collation_arg);
214 }
215 void set(const CHARSET_INFO *collation_arg, Derivation derivation_arg,
216 uint repertoire_arg) {
217 collation = collation_arg;
218 derivation = derivation_arg;
219 repertoire = repertoire_arg;
220 }
221 void set_numeric() {
225 }
226 void set(const CHARSET_INFO *collation_arg) {
227 collation = collation_arg;
228 set_repertoire_from_charset(collation_arg);
229 }
230 void set(Derivation derivation_arg) { derivation = derivation_arg; }
231 void set_repertoire(uint repertoire_arg) { repertoire = repertoire_arg; }
232 bool aggregate(DTCollation &dt, uint flags = 0);
233 bool set(DTCollation &dt1, DTCollation &dt2, uint flags = 0) {
234 set(dt1);
235 return aggregate(dt2, flags);
236 }
237 const char *derivation_name() const {
238 switch (derivation) {
240 return "NUMERIC";
242 return "IGNORABLE";
244 return "COERCIBLE";
246 return "IMPLICIT";
248 return "SYSCONST";
250 return "EXPLICIT";
251 case DERIVATION_NONE:
252 return "NONE";
253 default:
254 return "UNKNOWN";
255 }
256 }
257};
258
259/**
260 Class used as argument to Item::walk() together with mark_field_in_map()
261*/
263 public:
266
267 /**
268 If == NULL, update map of any table.
269 If <> NULL, update map of only this table.
270 */
271 TABLE *const table;
272 /// How to mark the map.
274};
275
276/**
277 Class used as argument to Item::walk() together with used_tables_for_level()
278*/
280 public:
282
283 Query_block *const select; ///< Level for which data is accumulated
284 table_map used_tables; ///< Accumulated used tables data
285};
286
287/*************************************************************************/
288
289/**
290 Storage for name strings.
291 Enpowers Simple_cstring with allocation routines from the sql_strmake family.
292
293 This class must stay as small as possible as we often
294 pass it into functions using call-by-value evaluation.
295
296 Don't add new members or virtual methods into this class!
297*/
299 private:
300 void set_or_copy(const char *str, size_t length, bool is_null_terminated) {
301 if (is_null_terminated)
302 set(str, length);
303 else
304 copy(str, length);
305 }
306
307 public:
309 /*
310 Please do NOT add constructor Name_string(const char *str) !
311 It will involve hidden strlen() call, which can affect
312 performance negatively. Use Name_string(str, len) instead.
313 */
314 Name_string(const char *str, size_t length) : Simple_cstring(str, length) {}
317 Name_string(const char *str, size_t length, bool is_null_terminated)
318 : Simple_cstring() {
319 set_or_copy(str, length, is_null_terminated);
320 }
321 Name_string(const LEX_STRING str, bool is_null_terminated)
322 : Simple_cstring() {
323 set_or_copy(str.str, str.length, is_null_terminated);
324 }
325 /**
326 Allocate space using sql_strmake() or sql_strmake_with_convert().
327 */
328 void copy(const char *str, size_t length, const CHARSET_INFO *cs);
329 /**
330 Variants for copy(), for various argument combinations.
331 */
332 void copy(const char *str, size_t length) {
334 }
335 void copy(const char *str) {
336 copy(str, (str ? strlen(str) : 0), system_charset_info);
337 }
338 void copy(const LEX_STRING lex) { copy(lex.str, lex.length); }
339 void copy(const LEX_STRING *lex) { copy(lex->str, lex->length); }
340 void copy(const Name_string str) { copy(str.ptr(), str.length()); }
341 /**
342 Compare name to another name in C string, case insensitively.
343 */
344 bool eq(const char *str) const {
345 assert(str && ptr());
346 return my_strcasecmp(system_charset_info, ptr(), str) == 0;
347 }
348 bool eq_safe(const char *str) const { return is_set() && str && eq(str); }
349 /**
350 Compare name to another name in Name_string, case insensitively.
351 */
352 bool eq(const Name_string name) const { return eq(name.ptr()); }
353 bool eq_safe(const Name_string name) const {
354 return is_set() && name.is_set() && eq(name);
355 }
356};
357
358#define NAME_STRING(x) Name_string(STRING_WITH_LEN(x))
359
360/**
361 Max length of an Item string for its use in an error message.
362 This should be kept in sync with MYSQL_ERRMSG_SIZE (which should
363 not be exceeded).
364*/
365#define ITEM_TO_QUERY_SUBSTRING_CHAR_LIMIT (300)
366
367extern const Name_string null_name_string;
368
369/**
370 Storage for Item names.
371 Adds "autogenerated" flag and warning functionality to Name_string.
372*/
374 private:
375 bool m_is_autogenerated; /* indicates if name of this Item
376 was autogenerated or set by user */
377 public:
381 /**
382 Set m_is_autogenerated flag to the given value.
383 */
386 }
387 /**
388 Return the auto-generated flag.
389 */
390 bool is_autogenerated() const { return m_is_autogenerated; }
391 using Name_string::copy;
392 /**
393 Copy name together with autogenerated flag.
394 Produce a warning if name was cut.
395 */
396 void copy(const char *str_arg, size_t length_arg, const CHARSET_INFO *cs_arg,
397 bool is_autogenerated_arg);
398};
399
400/**
401 Instances of Name_resolution_context store the information necessary for
402 name resolution of Items and other context analysis of a query made in
403 fix_fields().
404
405 This structure is a part of Query_block, a pointer to this structure is
406 assigned when an item is created (which happens mostly during parsing
407 (sql_yacc.yy)), but the structure itself will be initialized after parsing
408 is complete
409
410 @todo move subquery of INSERT ... SELECT and CREATE ... SELECT to
411 separate Query_block which allow to remove tricks of changing this
412 structure before and after INSERT/CREATE and its SELECT to make correct
413 field name resolution.
414*/
416 /**
417 The name resolution context to search in when an Item cannot be
418 resolved in this context (the context of an outer select)
419 */
421 /// Link to next name res context with the same query block as the base
423
424 /**
425 List of tables used to resolve the items of this context. Usually these
426 are tables from the FROM clause of SELECT statement. The exceptions are
427 INSERT ... SELECT and CREATE ... SELECT statements, where SELECT
428 subquery is not moved to a separate Query_block. For these types of
429 statements we have to change this member dynamically to ensure correct
430 name resolution of different parts of the statement.
431 */
433 /**
434 In most cases the two table references below replace 'table_list' above
435 for the purpose of name resolution. The first and last name resolution
436 table references allow us to search only in a sub-tree of the nested
437 join tree in a FROM clause. This is needed for NATURAL JOIN, JOIN ... USING
438 and JOIN ... ON.
439 */
441 /**
442 Last table to search in the list of leaf table references that begins
443 with first_name_resolution_table.
444 */
446
447 /**
448 Query_block item belong to, in case of merged VIEW it can differ from
449 Query_block where item was created, so we can't use table_list/field_list
450 from there
451 */
453
454 /*
455 Processor of errors caused during Item name resolving, now used only to
456 hide underlying tables in errors about views (i.e. it substitute some
457 errors for views)
458 */
461
462 /**
463 When true, items are resolved in this context against
464 Query_block::item_list, SELECT_lex::group_list and
465 this->table_list. If false, items are resolved only against
466 this->table_list.
467
468 @see Query_block::item_list, Query_block::group_list
469 */
471
472 /**
473 Security context of this name resolution context. It's used for views
474 and is non-zero only if the view is defined with SQL SECURITY DEFINER.
475 */
477
481 }
482};
483
484/**
485 Struct used to pass around arguments to/from
486 check_function_as_value_generator
487*/
490 int default_error_code, Value_generator_source val_gen_src)
491 : err_code(default_error_code), source(val_gen_src) {}
492 /// the order of the column in table
493 int col_index{-1};
494 /// the error code found during check(if any)
496 /*
497 If it is a generated column, default expression or check constraint
498 expression value generator.
499 */
501 /// the name of the function which is not allowed
502 const char *banned_function_name{nullptr};
503
504 /// Return the correct error code, based on whether or not if we are checking
505 /// for disallowed functions in generated column expressions, in default
506 /// value expressions or in check constraint expression.
508 return ((source == VGS_GENERATED_COLUMN)
509 ? ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED
511 ? ER_DEFAULT_VAL_GENERATED_FUNCTION_IS_NOT_ALLOWED
512 : ER_CHECK_CONSTRAINT_FUNCTION_IS_NOT_ALLOWED);
513 }
514};
515/*
516 Store and restore the current state of a name resolution context.
517*/
518
520 private:
526
527 public:
528 /* Save the state of a name resolution context. */
529 void save_state(Name_resolution_context *context, Table_ref *table_list) {
530 save_table_list = context->table_list;
533 save_next_local = table_list->next_local;
535 }
536
537 /* Restore a name resolution context from saved state. */
538 void restore_state(Name_resolution_context *context, Table_ref *table_list) {
539 table_list->next_local = save_next_local;
541 context->table_list = save_table_list;
544 }
545
546 void update_next_local(Table_ref *table_list) {
547 save_next_local = table_list;
548 }
549
552 }
553};
554
555/*
556 This enum is used to report information about monotonicity of function
557 represented by Item* tree.
558 Monotonicity is defined only for Item* trees that represent table
559 partitioning expressions (i.e. have no subqueries/user vars/dynamic parameters
560 etc etc). An Item* tree is assumed to have the same monotonicity properties
561 as its corresponding function F:
562
563 [signed] longlong F(field1, field2, ...) {
564 put values of field_i into table record buffer;
565 return item->val_int();
566 }
567
568 NOTE
569 At the moment function monotonicity is not well defined (and so may be
570 incorrect) for Item trees with parameters/return types that are different
571 from INT_RESULT, may be NULL, or are unsigned.
572 It will be possible to address this issue once the related partitioning bugs
573 (BUG#16002, BUG#15447, BUG#13436) are fixed.
574
575 The NOT_NULL enums are used in TO_DAYS, since TO_DAYS('2001-00-00') returns
576 NULL which puts those rows into the NULL partition, but
577 '2000-12-31' < '2001-00-00' < '2001-01-01'. So special handling is needed
578 for this (see Bug#20577).
579*/
580
581typedef enum monotonicity_info {
582 NON_MONOTONIC, /* none of the below holds */
583 MONOTONIC_INCREASING, /* F() is unary and (x < y) => (F(x) <= F(y)) */
584 MONOTONIC_INCREASING_NOT_NULL, /* But only for valid/real x and y */
585 MONOTONIC_STRICT_INCREASING, /* F() is unary and (x < y) => (F(x) < F(y)) */
586 MONOTONIC_STRICT_INCREASING_NOT_NULL /* But only for valid/real x and y */
588
589/**
590 A type for SQL-like 3-valued Booleans: true/false/unknown.
591*/
592class Bool3 {
593 public:
594 /// @returns an instance set to "FALSE"
595 static const Bool3 false3() { return Bool3(v_FALSE); }
596 /// @returns an instance set to "UNKNOWN"
597 static const Bool3 unknown3() { return Bool3(v_UNKNOWN); }
598 /// @returns an instance set to "TRUE"
599 static const Bool3 true3() { return Bool3(v_TRUE); }
600
601 bool is_true() const { return m_val == v_TRUE; }
602 bool is_unknown() const { return m_val == v_UNKNOWN; }
603 bool is_false() const { return m_val == v_FALSE; }
604
605 private:
607 /// This is private; instead, use false3()/etc.
608 Bool3(value v) : m_val(v) {}
609
611 /*
612 No operator to convert Bool3 to bool (or int) - intentionally: how
613 would you map unknown3 to true/false?
614 It is because we want to block such conversions that Bool3 is a class
615 instead of a plain enum.
616 */
617};
618
619/**
620 Type properties, used to collect type information for later assignment
621 to an Item object. The object stores attributes signedness, max length
622 and collation. However, precision and scale (for decimal numbers) and
623 fractional second precision (for time and datetime) are not stored,
624 since any type derived from this object will have default values for these
625 attributes.
626*/
628 public:
629 /// Constructor for any signed numeric type or date type
630 /// Defaults are provided for attributes like signedness and max length
632 : m_type(type_arg),
633 m_unsigned_flag(false),
634 m_max_length(0),
636 assert(type_arg != MYSQL_TYPE_VARCHAR && type_arg != MYSQL_TYPE_JSON);
637 }
638 /// Constructor for any numeric type, with explicit signedness
639 Type_properties(enum_field_types type_arg, bool unsigned_arg)
640 : m_type(type_arg),
641 m_unsigned_flag(unsigned_arg),
642 m_max_length(0),
644 assert(is_numeric_type(type_arg) || type_arg == MYSQL_TYPE_BIT ||
645 type_arg == MYSQL_TYPE_YEAR);
646 }
647 /// Constructor for character type, with explicit character set.
648 /// Default length/max length is provided.
650 : m_type(type_arg),
651 m_unsigned_flag(false),
652 m_max_length(0),
654 /// Constructor for Item
655 Type_properties(Item &item);
657 const bool m_unsigned_flag;
660};
661
662/*************************************************************************/
663
665 public:
667 virtual ~Settable_routine_parameter() = default;
668 /**
669 Set required privileges for accessing the parameter.
670
671 @param privilege The required privileges for this field, with the
672 following alternatives:
673 MODE_IN - SELECT_ACL
674 MODE_OUT - UPDATE_ACL
675 MODE_INOUT - SELECT_ACL | UPDATE_ACL
676 */
678 [[maybe_unused]]) {}
679
680 /*
681 Set parameter value.
682
683 SYNOPSIS
684 set_value()
685 thd thread handle
686 ctx context to which parameter belongs (if it is local
687 variable).
688 it item which represents new value
689
690 RETURN
691 false if parameter value has been set,
692 true if error has occurred.
693 */
694 virtual bool set_value(THD *thd, sp_rcontext *ctx, Item **it) = 0;
695
696 virtual void set_out_param_info(Send_field *info [[maybe_unused]]) {}
697
698 virtual const Send_field *get_out_param_info() const { return nullptr; }
699};
700
701/*
702 Analyzer function
703 SYNOPSIS
704 argp in/out IN: Analysis parameter
705 OUT: Parameter to be passed to the transformer
706
707 RETURN
708 true Invoke the transformer
709 false Don't do it
710
711*/
712typedef bool (Item::*Item_analyzer)(uchar **argp);
713
714/**
715 Type for transformers used by Item::transform and Item::compile
716 @param arg Argument used by the transformer. Really a typeless pointer
717 in spite of the uchar type (historical reasons). The
718 transformer needs to cast this to the desired pointer type
719 @returns The transformed item
720*/
721typedef Item *(Item::*Item_transformer)(uchar *arg);
722typedef void (*Cond_traverser)(const Item *item, void *arg);
723
724/**
725 Utility mixin class to be able to walk() only parts of item trees.
726
727 Used with PREFIX+POSTFIX walk: in the prefix call of the Item
728 processor, we process the item X, may decide that its children should not
729 be processed (just like if they didn't exist): processor calls stop_at(X)
730 for that. Then walk() goes to a child Y; the processor tests is_stopped(Y)
731 which returns true, so processor sees that it must not do any processing
732 and returns immediately. Finally, the postfix call to the processor on X
733 tests is_stopped(X) which returns "true" and understands that the
734 not-to-be-processed children have been skipped so calls restart(). Thus,
735 any sibling of X, any part of the Item tree not under X, can then be
736 processed.
737*/
739 protected:
744
745 /// Stops walking children of this item
746 void stop_at(const Item *i) {
747 assert(stopped_at_item == nullptr);
748 stopped_at_item = i;
749 }
750
751 /**
752 @returns if we are stopped. If item 'i' is where we stopped, restarts the
753 walk for next items.
754 */
755 bool is_stopped(const Item *i) {
756 if (stopped_at_item != nullptr) {
757 /*
758 Walking was disabled for a tree part rooted a one ancestor of 'i' or
759 rooted at 'i'.
760 */
761 if (stopped_at_item == i) {
762 /*
763 Walking was disabled for the tree part rooted at 'i'; we have now just
764 returned back to this root (POSTFIX call), left the tree part:
765 enable the walk again, for other tree parts.
766 */
767 stopped_at_item = nullptr;
768 }
769 // No further processing to do for this item:
770 return true;
771 }
772 return false;
773 }
774
775 private:
776 const Item *stopped_at_item{nullptr};
777};
778
779/// Increment *num if it is less than its maximal value.
780template <typename T>
781void SafeIncrement(T *num) {
782 if (*num < std::numeric_limits<T>::max()) {
783 *num += 1;
784 }
785}
786
787/**
788 This class represents the cost of evaluating an Item. @see SortPredicates
789 to see how this is used.
790*/
791class CostOfItem final {
792 public:
793 /// Set '*this' to represent the cost of 'item'.
794 void Compute(const Item &item) {
795 if (!m_computed) {
796 ComputeInternal(item);
797 }
798 }
799
801 assert(!m_computed);
802 m_is_expensive = true;
803 }
804
805 /// Add the cost of accessing a Field_str.
807 assert(!m_computed);
809 }
810
811 /// Add the cost of accessing any other Field.
813 assert(!m_computed);
815 }
816
817 bool IsExpensive() const {
818 assert(m_computed);
819 return m_is_expensive;
820 }
821
822 /**
823 Get the cost of field access when evaluating the Item associated with this
824 object. The cost unit is arbitrary, but the relative cost of different
825 items reflect the fact that operating on Field_str is more expensive than
826 other Field subclasses.
827 */
828 double FieldCost() const {
829 assert(m_computed);
831 }
832
833 private:
834 /// The cost of accessing a Field_str, relative to other Field types.
835 /// (The value was determined using benchmarks.)
836 static constexpr double kStrFieldCost = 1.8;
837
838 /// The cost of accessing a Field other than Field_str. 1.0 by definition.
839 static constexpr double kOtherFieldCost = 1.0;
840
841 /// True if 'ComputeInternal()' has been called.
842 bool m_computed{false};
843
844 /// True if the associated Item calls user defined functions or stored
845 /// procedures.
846 bool m_is_expensive{false};
847
848 /// The number of Field_str objects accessed by the associated Item.
850
851 /// The number of other Field objects accessed by the associated Item.
853
854 /// Compute the cost of 'root' and its descendants.
855 void ComputeInternal(const Item &root);
856};
857
858/**
859 This class represents a subquery contained in some subclass of
860 Item_subselect, @see FindContainedSubqueries().
861*/
863 /// The strategy for executing the subquery.
864 enum class Strategy : char {
865 /**
866 An independent subquery that is materialized, e.g.:
867 "SELECT * FROM tab WHERE field IN <independent subquery>".
868 where 'independent subquery' does not depend on any fields in 'tab'.
869 (This corresponds to the Item_in_subselect class.)
870 */
872
873 /**
874 A subquery that is reevaluated for each row, e.g.:
875 "SELECT * FROM tab WHERE field IN <dependent subquery>" or
876 "SELECT * FROM tab WHERE field = <dependent subquery>".
877 where 'dependent subquery' depends on at least one field in 'tab'.
878 Alternatively, the subquery may be independent of 'tab', but contain
879 a non-deterministic function such as 'rand()'. Such subqueries are also
880 required to be reevaluated for each row.
881 */
883
884 /**
885 An independent single-row subquery that is evaluated once, e.g.:
886 "SELECT * FROM tab WHERE field = <independent single-row subquery>".
887 (This corresponds to the Item_singlerow_subselect class.)
888 */
890 };
891
892 /// The root path of the subquery.
894
895 /// The strategy for executing the subquery.
897
898 /// The width (in bytes) of the subquery's rows. For variable-sized values we
899 /// use Item.max_length (but cap it at kMaxItemLengthEstimate).
900 /// @see kMaxItemLengthEstimate and
901 /// @see Item_in_subselect::get_contained_subquery().
903};
904
905/**
906 Base class that is used to represent any kind of expression in a
907 relational query. The class provides subclasses for simple components, like
908 literal (constant) values, column references and variable references,
909 as well as more complex expressions like comparison predicates,
910 arithmetic and string functions, row objects, function references and
911 subqueries.
912
913 The lifetime of an Item class object is often the same as a relational
914 statement, which may be used for several executions, but in some cases
915 it may also be generated for an optimized statement and thus be valid
916 only for one execution.
917
918 For Item objects with longer lifespan than one execution, we must take
919 special precautions when referencing objects with shorter lifespan.
920 For example, TABLE and Field objects against most tables are valid only for
921 one execution. For such objects, Item classes should rather reference
922 Table_ref and Item_field objects instead of TABLE and Field, because
923 these classes support dynamic rebinding of objects before each execution.
924 See Item::bind_fields() which binds new objects per execution and
925 Item::cleanup() that deletes references to such objects.
926
927 These mechanisms can also be used to handle other objects with shorter
928 lifespan, such as function references and variable references.
929*/
930class Item : public Parse_tree_node {
932
933 friend class udf_handler;
934
935 protected:
936 /**
937 Sets the result value of the function an empty string, using the current
938 character set. No memory is allocated.
939 @retval A pointer to the str_value member.
940 */
943 return &str_value;
944 }
945
946 public:
947 Item(const Item &) = delete;
948 void operator=(Item &) = delete;
949 static void *operator new(size_t size) noexcept {
950 return (*THR_MALLOC)->Alloc(size);
951 }
952 static void *operator new(size_t size, MEM_ROOT *mem_root,
953 const std::nothrow_t &arg
954 [[maybe_unused]] = std::nothrow) noexcept {
955 return mem_root->Alloc(size);
956 }
957
958 static void operator delete(void *ptr [[maybe_unused]],
959 size_t size [[maybe_unused]]) {
960 TRASH(ptr, size);
961 }
962 static void operator delete(void *, MEM_ROOT *,
963 const std::nothrow_t &) noexcept {}
964
965 enum Type {
967 FIELD_ITEM, ///< A reference to a field (column) in a table.
968 FUNC_ITEM, ///< A function call reference.
969 SUM_FUNC_ITEM, ///< A grouped aggregate function, or window function.
970 AGGR_FIELD_ITEM, ///< A special field for certain aggregate operations.
971 STRING_ITEM, ///< A string literal value.
972 INT_ITEM, ///< An integer literal value.
973 DECIMAL_ITEM, ///< A decimal literal value.
974 REAL_ITEM, ///< A floating-point literal value.
975 NULL_ITEM, ///< A NULL value.
976 HEX_BIN_ITEM, ///< A hexadecimal or binary literal value.
977 DEFAULT_VALUE_ITEM, ///< A default value for a column.
978 COND_ITEM, ///< An AND or OR condition.
979 REF_ITEM, ///< An indirect reference to another item.
980 INSERT_VALUE_ITEM, ///< A value from a VALUES function (deprecated).
981 SUBQUERY_ITEM, ///< A subquery or predicate referencing a subquery.
982 ROW_ITEM, ///< A row of other items.
983 CACHE_ITEM, ///< An internal item used to cache values.
984 TYPE_HOLDER_ITEM, ///< An internal item used to help aggregate a type.
985 PARAM_ITEM, ///< A dynamic parameter used in a prepared statement.
986 ROUTINE_FIELD_ITEM, ///< A variable inside a routine (proc, func, trigger)
987 TRIGGER_FIELD_ITEM, ///< An OLD or NEW field, used in trigger definitions.
988 XPATH_NODESET_ITEM, ///< Used in XPATH expressions.
989 VALUES_COLUMN_ITEM, ///< A value from a VALUES clause.
990 NAME_CONST_ITEM ///< A NAME_CONST expression
991 };
992
994
996
997 /// How to cache constant JSON data
999 /// Don't cache
1001 /// Source data is a JSON string, parse and cache result
1003 /// Source data is SQL scalar, convert and cache result
1006
1007 enum Bool_test ///< Modifier for result transformation
1008 {
1019 };
1020
1021 // Return the default data type for a given result type
1023 switch (result) {
1024 case INT_RESULT:
1025 return MYSQL_TYPE_LONGLONG;
1026 case DECIMAL_RESULT:
1027 return MYSQL_TYPE_NEWDECIMAL;
1028 case REAL_RESULT:
1029 return MYSQL_TYPE_DOUBLE;
1030 case STRING_RESULT:
1031 return MYSQL_TYPE_VARCHAR;
1032 case INVALID_RESULT:
1033 return MYSQL_TYPE_INVALID;
1034 case ROW_RESULT:
1035 default:
1036 assert(false);
1037 }
1038 return MYSQL_TYPE_INVALID;
1039 }
1040
1041 // Return the default result type for a given data type
1043 switch (type) {
1044 case MYSQL_TYPE_TINY:
1045 case MYSQL_TYPE_SHORT:
1046 case MYSQL_TYPE_INT24:
1047 case MYSQL_TYPE_LONG:
1049 case MYSQL_TYPE_BOOL:
1050 case MYSQL_TYPE_BIT:
1051 case MYSQL_TYPE_YEAR:
1052 return INT_RESULT;
1054 case MYSQL_TYPE_DECIMAL:
1055 return DECIMAL_RESULT;
1056 case MYSQL_TYPE_FLOAT:
1057 case MYSQL_TYPE_DOUBLE:
1058 return REAL_RESULT;
1059 case MYSQL_TYPE_VARCHAR:
1061 case MYSQL_TYPE_STRING:
1065 case MYSQL_TYPE_BLOB:
1066 case MYSQL_TYPE_VECTOR:
1068 case MYSQL_TYPE_JSON:
1069 case MYSQL_TYPE_ENUM:
1070 case MYSQL_TYPE_SET:
1071 return STRING_RESULT;
1073 case MYSQL_TYPE_DATE:
1074 case MYSQL_TYPE_TIME:
1076 case MYSQL_TYPE_NEWDATE:
1079 case MYSQL_TYPE_TIME2:
1080 return STRING_RESULT;
1081 case MYSQL_TYPE_INVALID:
1082 return INVALID_RESULT;
1083 case MYSQL_TYPE_NULL:
1084 return STRING_RESULT;
1086 break;
1087 }
1088 assert(false);
1089 return INVALID_RESULT;
1090 }
1091
1092 /**
1093 Provide data type for a user or system variable, based on the type of
1094 the item that is assigned to the variable.
1095
1096 @note MYSQL_TYPE_VARCHAR is returned for all string types, but must be
1097 further adjusted based on maximum string length by the caller.
1098
1099 @param src_type Source type that variable's type is derived from
1100 */
1102 switch (src_type) {
1103 case MYSQL_TYPE_BOOL:
1104 case MYSQL_TYPE_TINY:
1105 case MYSQL_TYPE_SHORT:
1106 case MYSQL_TYPE_INT24:
1107 case MYSQL_TYPE_LONG:
1109 case MYSQL_TYPE_BIT:
1110 return MYSQL_TYPE_LONGLONG;
1111 case MYSQL_TYPE_DECIMAL:
1113 return MYSQL_TYPE_NEWDECIMAL;
1114 case MYSQL_TYPE_FLOAT:
1115 case MYSQL_TYPE_DOUBLE:
1116 return MYSQL_TYPE_DOUBLE;
1117 case MYSQL_TYPE_VARCHAR:
1119 case MYSQL_TYPE_STRING:
1120 return MYSQL_TYPE_VARCHAR;
1121 case MYSQL_TYPE_YEAR:
1122 return MYSQL_TYPE_LONGLONG;
1124 case MYSQL_TYPE_DATE:
1125 case MYSQL_TYPE_TIME:
1127 case MYSQL_TYPE_NEWDATE:
1130 case MYSQL_TYPE_TIME2:
1131 case MYSQL_TYPE_JSON:
1132 case MYSQL_TYPE_ENUM:
1133 case MYSQL_TYPE_SET:
1135 case MYSQL_TYPE_NULL:
1137 case MYSQL_TYPE_BLOB:
1138 case MYSQL_TYPE_VECTOR:
1141 return MYSQL_TYPE_VARCHAR;
1142 case MYSQL_TYPE_INVALID:
1144 return MYSQL_TYPE_INVALID;
1145 }
1146 assert(false);
1147 return MYSQL_TYPE_NULL;
1148 }
1149
1150 /// Item constructor for general use.
1151 Item();
1152
1153 /**
1154 Constructor used by Item_field, Item_ref & aggregate functions.
1155 Used for duplicating lists in processing queries with temporary tables.
1156
1157 Also used for Item_cond_and/Item_cond_or for creating top AND/OR structure
1158 of WHERE clause to protect it of optimisation changes in prepared statements
1159 */
1160 Item(THD *thd, const Item *item);
1161
1162 /**
1163 Parse-time context-independent constructor.
1164
1165 This constructor and caller constructors of child classes must not
1166 access/change thd->lex (including thd->lex->current_query_block(),
1167 thd->m_parser_state etc structures).
1168
1169 If we need to finalize the construction of the object, then we move
1170 all context-sensitive code to the itemize() virtual function.
1171
1172 The POS parameter marks this constructor and other context-independent
1173 constructors of child classes for easy recognition/separation from other
1174 (context-dependent) constructors.
1175 */
1176 explicit Item(const POS &);
1177
1178#ifdef EXTRA_DEBUG
1179 ~Item() override { item_name.set(0); }
1180#else
1181 ~Item() override = default;
1182#endif
1183
1184 private:
1185 /*
1186 Hide the contextualize*() functions: call/override the itemize()
1187 in Item class tree instead.
1188 */
1190 assert(0);
1191 return true;
1192 }
1193
1194 protected:
1195 /**
1196 Helper function to skip itemize() for grammar-allocated items
1197
1198 @param [out] res pointer to "this"
1199
1200 @retval true can skip itemize()
1201 @retval false can't skip: the item is allocated directly by the parser
1202 */
1203 bool skip_itemize(Item **res) {
1204 *res = this;
1205 return !is_parser_item;
1206 }
1207
1208 /*
1209 Checks if the function should return binary result based on the items
1210 provided as parameter.
1211 Function should only be used by Item_bit_func*
1212
1213 @param a item to check
1214 @param b item to check, may be nullptr
1215
1216 @returns true if binary result.
1217 */
1218 static bool bit_func_returns_binary(const Item *a, const Item *b);
1219
1220 /**
1221 The core function that does the actual itemization. itemize() is just a
1222 wrapper over this.
1223 */
1224 virtual bool do_itemize(Parse_context *pc, Item **res);
1225
1226 public:
1227 /**
1228 The same as contextualize() but with additional parameter
1229
1230 This function finalize the construction of Item objects (see the Item(POS)
1231 constructor): we can access/change parser contexts from the itemize()
1232 function.
1233
1234 Derived classes should not override this. If needed, they should
1235 override do_itemize().
1236
1237 @param pc current parse context
1238 @param [out] res pointer to "this" or to a newly allocated
1239 replacement object to use in the Item tree instead
1240
1241 @retval false success
1242 @retval true syntax/OOM/etc error
1243 */
1244 // Visual Studio with MSVC_CPPCHECK=ON gives warning C26435:
1245 // Function <fun> should specify exactly one of
1246 // 'virtual', 'override', or 'final'
1249 virtual bool itemize(Parse_context *pc, Item **res) final {
1250 // For condition#2 below ... If position is empty, this item was not
1251 // created in the parser; so don't show it in the parse tree.
1252 if (pc->m_show_parse_tree == nullptr || this->m_pos.is_empty())
1253 return do_itemize(pc, res);
1254
1255 Show_parse_tree *tree = pc->m_show_parse_tree.get();
1256
1257 if (begin_parse_tree(tree)) return true;
1258
1259 if (do_itemize(pc, res)) return true;
1260
1261 if (end_parse_tree(tree)) return true;
1262
1263 return false;
1264 }
1266
1267 void rename(char *new_name);
1268 void init_make_field(Send_field *tmp_field, enum enum_field_types type);
1269 /**
1270 Called for every Item after use (preparation and execution).
1271 Release all allocated resources, such as dynamic memory.
1272 Prepare for new execution by clearing cached values.
1273 Do not remove values allocated during preparation, destructor handles this.
1274 */
1275 virtual void cleanup() { marker = MARKER_NONE; }
1276 /**
1277 Called when an item has been removed, can be used to notify external
1278 objects about the removal, e.g subquery predicates that are part of
1279 the sj_candidates container.
1280 */
1281 virtual void notify_removal() {}
1282 virtual void make_field(Send_field *field);
1283 virtual Field *make_string_field(TABLE *table) const;
1284 virtual bool fix_fields(THD *, Item **);
1285 /**
1286 Fix after tables have been moved from one query_block level to the parent
1287 level, e.g by semijoin conversion.
1288 Basically re-calculate all attributes dependent on the tables.
1289
1290 @param parent_query_block query_block that tables are moved to.
1291 @param removed_query_block query_block that tables are moved away from,
1292 child of parent_query_block.
1293 */
1294 virtual void fix_after_pullout(Query_block *parent_query_block
1295 [[maybe_unused]],
1296 Query_block *removed_query_block
1297 [[maybe_unused]]) {}
1298 /*
1299 should be used in case where we are sure that we do not need
1300 complete fix_fields() procedure.
1301 */
1302 inline void quick_fix_field() { fixed = true; }
1303 virtual void set_can_use_prefix_key() {}
1304
1305 /**
1306 Propagate data type specifications into parameters and user variables.
1307 If item has descendants, propagate type recursively into these.
1308
1309 @param thd thread handler
1310 @param type Data type properties that are propagated
1311
1312 @returns false if success, true if error
1313 */
1314 virtual bool propagate_type(THD *thd [[maybe_unused]],
1315 const Type_properties &type [[maybe_unused]]) {
1316 return false;
1317 }
1318
1319 /**
1320 Wrapper for easier calling of propagate_type(const Type_properties &).
1321 @param thd thread handler
1322 @param def type to make Type_properties object
1323 @param pin if true: also mark the type as pinned
1324 @param inherit if true: also mark the type as inherited
1325
1326 @returns false if success, true if error
1327 */
1329 bool pin = false, bool inherit = false) {
1330 /*
1331 Propagate supplied type if types have not yet been assigned to expression,
1332 or type is pinned, in which case the supplied type overrides the
1333 actual type of parameters. Note we do not support "pinning" of
1334 expressions containing parameters, only standalone parameters,
1335 but this is a very minor problem.
1336 */
1337 if (data_type() != MYSQL_TYPE_INVALID && !(pin && type() == PARAM_ITEM))
1338 return false;
1339 if (propagate_type(thd, (def == MYSQL_TYPE_VARCHAR)
1341 : (def == MYSQL_TYPE_JSON)
1343 : Type_properties(def)))
1344 return true;
1345 if (pin) pin_data_type();
1346 if (inherit) set_data_type_inherited();
1347
1348 return false;
1349 }
1350
1351 /**
1352 For Items with data type JSON, mark that a string argument is treated
1353 as a scalar JSON value. Only relevant for the Item_param class.
1354 */
1355 virtual void mark_json_as_scalar() {}
1356
1357 /**
1358 If this item represents a IN/ALL/ANY/comparison_operator
1359 subquery, return that (along with data on how it will be executed).
1360 (These subqueries correspond to
1361 @see Item_in_subselect and @see Item_singlerow_subselect .) Also,
1362 @see FindContainedSubqueries() for context.
1363 @param outer_query_block the Query_block to which 'this' belongs.
1364 @returns The subquery that 'this' represents, if there is one.
1365 */
1366 virtual std::optional<ContainedSubquery> get_contained_subquery(
1367 const Query_block *outer_query_block [[maybe_unused]]) {
1368 return std::nullopt;
1369 }
1370
1371 protected:
1372 /**
1373 Helper function which does all of the work for
1374 save_in_field(Field*, bool), except some error checking common to
1375 all subclasses, which is performed by save_in_field() itself.
1376
1377 Subclasses that need to specialize the behaviour of
1378 save_in_field(), should override this function instead of
1379 save_in_field().
1380
1381 @param[in,out] field the field to save the item into
1382 @param no_conversions whether or not to allow conversions of the value
1383
1384 @return the status from saving into the field
1385 @retval TYPE_OK item saved without any errors or warnings
1386 @retval != TYPE_OK there were errors or warnings when saving the item
1387 */
1389 bool no_conversions);
1390
1391 public:
1392 /**
1393 Save the item into a field but do not emit any warnings.
1394
1395 @param field field to save the item into
1396 @param no_conversions whether or not to allow conversions of the value
1397
1398 @return the status from saving into the field
1399 @retval TYPE_OK item saved without any issues
1400 @retval != TYPE_OK there were issues saving the item
1401 */
1403 bool no_conversions);
1404 /**
1405 Save a temporal value in packed longlong format into a Field.
1406 Used in optimizer.
1407
1408 Subclasses that need to specialize this function, should override
1409 save_in_field_inner().
1410
1411 @param[in,out] field the field to save the item into
1412 @param no_conversions whether or not to allow conversions of the value
1413
1414 @return the status from saving into the field
1415 @retval TYPE_OK item saved without any errors or warnings
1416 @retval != TYPE_OK there were errors or warnings when saving the item
1417 */
1418 type_conversion_status save_in_field(Field *field, bool no_conversions);
1419
1420 /**
1421 A slightly faster value of save_in_field() that returns no error value
1422 (you will need to check thd->is_error() yourself), and does not support
1423 saving into hidden fields for functional indexes. Used by copy_funcs(),
1424 to avoid the functional call overhead and RAII setup of save_in_field().
1425 */
1426 void save_in_field_no_error_check(Field *field, bool no_conversions) {
1427 assert(!field->is_field_for_functional_index());
1428 save_in_field_inner(field, no_conversions);
1429 }
1430
1431 virtual void save_org_in_field(Field *field) { save_in_field(field, true); }
1432
1433 virtual bool send(Protocol *protocol, String *str);
1434 bool evaluate(THD *thd, String *str);
1435 /**
1436 Compare this item with another item for equality.
1437 If both pointers are the same, the items are equal.
1438 Both items must be of same type.
1439 For literal values, metadata must be the same and the values must be equal.
1440 Strings are compared with the embedded collation.
1441 For column references, table references and column names must be the same.
1442 For functions, the function type, function properties and arguments must
1443 be equal. Otherwise, see specific implementations.
1444 @todo: Current implementation requires that cache objects, ref objects
1445 and rollup wrappers are stripped away. This should be eliminated.
1446 */
1447 virtual bool eq(const Item *) const;
1448
1449 const Item *unwrap_for_eq() const;
1450
1451 virtual Item_result result_type() const { return REAL_RESULT; }
1452 /**
1453 Result type when an item appear in a numeric context.
1454 See Field::numeric_context_result_type() for more comments.
1455 */
1458 }
1459 /**
1460 Similar to result_type() but makes DATE, DATETIME, TIMESTAMP
1461 pretend to be numbers rather than strings.
1462 */
1465 : result_type();
1466 }
1467
1468 /**
1469 Set data type for item as inherited.
1470 Non-empty implementation only for dynamic parameters.
1471 */
1472 virtual void set_data_type_inherited() {}
1473
1474 /**
1475 Pin the data type for the item.
1476 Non-empty implementation only for dynamic parameters.
1477 */
1478 virtual void pin_data_type() {}
1479
1480 /// Retrieve the derived data type of the Item.
1482 return static_cast<enum_field_types>(m_data_type);
1483 }
1484
1485 /**
1486 Retrieve actual data type for an item. Equal to data_type() for
1487 all items, except parameters.
1488 */
1489 virtual enum_field_types actual_data_type() const { return data_type(); }
1490
1491 /**
1492 Get the default data (output) type for the specific item.
1493 Important for some SQL functions that may deliver multiple result types,
1494 and is used to determine data type for function's parameters that cannot
1495 be type-resolved by looking at the context.
1496 An example of such function is '+', which may return INT, DECIMAL,
1497 DOUBLE, depending on arguments.
1498 On the contrary, many other functions have a fixed output type, usually
1499 set with set_data_type_XXX(), which overrides the value of
1500 default_data_type(). For example, COS always returns DOUBLE,
1501 */
1503 // If data type has been set, the information returned here is irrelevant:
1504 assert(data_type() == MYSQL_TYPE_INVALID);
1505 return MYSQL_TYPE_VARCHAR;
1506 }
1507 /**
1508 Set the data type of the current Item. It is however recommended to
1509 use one of the type-specific setters if possible.
1510
1511 @param data_type The data type of this Item.
1512 */
1514 m_data_type = static_cast<uint8>(data_type);
1515 }
1516
1517 inline void set_data_type_null() {
1520 max_length = 0;
1521 set_nullable(true);
1522 }
1523
1524 inline void set_data_type_bool() {
1527 decimals = 0;
1528 max_length = 1;
1529 }
1530
1531 /**
1532 Set the data type of the Item to be a specific integer type
1533
1534 @param type Integer type
1535 @param unsigned_prop Whether the integer is signed or not
1536 @param max_width Maximum width of field in number of digits
1537 */
1538 inline void set_data_type_int(enum_field_types type, bool unsigned_prop,
1539 uint32 max_width) {
1540 assert(type == MYSQL_TYPE_TINY || type == MYSQL_TYPE_SHORT ||
1545 unsigned_flag = unsigned_prop;
1546 decimals = 0;
1547 fix_char_length(max_width);
1548 }
1549
1550 /**
1551 Set the data type of the Item to be longlong.
1552 Maximum display width is set to be the maximum of a 64-bit integer,
1553 but it may be adjusted later. The unsigned property is not affected.
1554 */
1558 decimals = 0;
1559 fix_char_length(21);
1560 }
1561
1562 /**
1563 Set the data type of the Item to be decimal.
1564 The unsigned property must have been set before calling this function.
1565
1566 @param precision Number of digits of precision
1567 @param scale Number of digits after decimal point.
1568 */
1569 inline void set_data_type_decimal(uint8 precision, uint8 scale) {
1572 assert(precision <= DECIMAL_MAX_PRECISION);
1573 decimals = scale;
1575 precision, scale, unsigned_flag));
1576 }
1577
1578 /// Set the data type of the Item to be double precision floating point.
1579 inline void set_data_type_double() {
1584 }
1585
1586 /// Set the data type of the Item to be single precision floating point.
1587 inline void set_data_type_float() {
1592 }
1593
1594 /**
1595 Set the Item to be variable length string. Actual type is determined from
1596 maximum string size. Collation must have been set before calling function.
1597
1598 @param max_l Maximum number of characters in string
1599 */
1600 inline void set_data_type_string(uint32 max_l) {
1607 else
1609 }
1610
1611 /**
1612 Set the Item to be variable length string. Like function above, but with
1613 larger string length precision.
1614
1615 @param max_char_length_arg Maximum number of characters in string
1616 */
1617 inline void set_data_type_string(ulonglong max_char_length_arg) {
1618 ulonglong max_result_length =
1619 max_char_length_arg * collation.collation->mbmaxlen;
1620 if (max_result_length > MAX_BLOB_WIDTH) {
1621 max_result_length = MAX_BLOB_WIDTH;
1622 m_nullable = true;
1623 }
1625 uint32(max_result_length / collation.collation->mbmaxlen));
1626 }
1627
1628 /**
1629 Set the Item to be variable length string. Like function above, but will
1630 also set character set and collation.
1631
1632 @param max_l Maximum number of characters in string
1633 @param cs Pointer to character set and collation struct
1634 */
1635 inline void set_data_type_string(uint32 max_l, const CHARSET_INFO *cs) {
1637 set_data_type_string(max_l);
1638 }
1639
1640 /**
1641 Set the Item to be variable length string. Like function above, but will
1642 also set full collation information.
1643
1644 @param max_l Maximum number of characters in string
1645 @param coll Ref to collation data, including derivation and repertoire
1646 */
1647 inline void set_data_type_string(uint32 max_l, const DTCollation &coll) {
1648 collation.set(coll);
1649 set_data_type_string(max_l);
1650 }
1651
1652 /**
1653 Set the Item to be fixed length string. Collation must have been set
1654 before calling function.
1655
1656 @param max_l Number of characters in string
1657 */
1658 inline void set_data_type_char(uint32 max_l) {
1659 assert(max_l <= MAX_CHAR_WIDTH);
1663 }
1664
1665 /**
1666 Set the Item to be fixed length string. Like function above, but will
1667 also set character set and collation.
1668
1669 @param max_l Maximum number of characters in string
1670 @param cs Pointer to character set and collation struct
1671 */
1672 inline void set_data_type_char(uint32 max_l, const CHARSET_INFO *cs) {
1674 set_data_type_char(max_l);
1675 }
1676
1677 /**
1678 Set the Item to be of BLOB type.
1679
1680 @param type Actual blob data type
1681 @param max_l Maximum number of characters in data type
1682 */
1687 ulonglong max_width = max_l * collation.collation->mbmaxlen;
1688 if (max_width > Field::MAX_LONG_BLOB_WIDTH) {
1689 max_width = Field::MAX_LONG_BLOB_WIDTH;
1690 }
1691 max_length = max_width;
1693 }
1694
1695 /// Set all type properties for Item of DATE type.
1696 inline void set_data_type_date() {
1699 decimals = 0;
1701 }
1702
1703 /**
1704 Set all type properties for Item of TIME type.
1705
1706 @param fsp Fractional seconds precision
1707 */
1708 inline void set_data_type_time(uint8 fsp) {
1709 assert(fsp <= DATETIME_MAX_DECIMALS);
1712 decimals = fsp;
1713 max_length = MAX_TIME_WIDTH + fsp + (fsp > 0 ? 1 : 0);
1714 }
1715
1716 /**
1717 Set all properties for Item of DATETIME type.
1718
1719 @param fsp Fractional seconds precision
1720 */
1722 assert(fsp <= DATETIME_MAX_DECIMALS);
1725 decimals = fsp;
1726 max_length = MAX_DATETIME_WIDTH + fsp + (fsp > 0 ? 1 : 0);
1727 }
1728
1729 /**
1730 Set all properties for Item of TIMESTAMP type.
1731
1732 @param fsp Fractional seconds precision
1733 */
1735 assert(fsp <= DATETIME_MAX_DECIMALS);
1738 decimals = fsp;
1739 max_length = MAX_DATETIME_WIDTH + fsp + (fsp > 0 ? 1 : 0);
1740 }
1741
1742 /**
1743 Set the data type of the Item to be VECTOR.
1744 */
1749 max_length = max_l;
1750 }
1751
1752 /**
1753 Set the data type of the Item to be GEOMETRY.
1754 */
1760 }
1761 /**
1762 Set the data type of the Item to be JSON.
1763 */
1769 }
1770
1771 /**
1772 Set the data type of the Item to be YEAR.
1773 */
1777 decimals = 0;
1778 fix_char_length(4); // YYYY
1779 unsigned_flag = true;
1780 }
1781
1782 /**
1783 Set the data type of the Item to be bit.
1784
1785 @param max_bits Maximum number of bits to store in this field.
1786 */
1787 void set_data_type_bit(uint32 max_bits) {
1790 max_length = max_bits;
1791 unsigned_flag = true;
1792 }
1793
1794 /**
1795 Set data type properties of the item from the properties of another item.
1796
1797 @param item Item to set data type properties from.
1798 */
1799 inline void set_data_type_from_item(const Item *item) {
1800 set_data_type(item->data_type());
1801 collation = item->collation;
1802 max_length = item->max_length;
1803 decimals = item->decimals;
1805 }
1806
1807 /**
1808 Determine correct string field type, based on string length
1809
1810 @param max_bytes Maximum string size, in number of bytes
1811 */
1813 if (max_bytes > Field::MAX_MEDIUM_BLOB_WIDTH)
1814 return MYSQL_TYPE_LONG_BLOB;
1815 else if (max_bytes > Field::MAX_VARCHAR_WIDTH)
1817 else
1818 return MYSQL_TYPE_VARCHAR;
1819 }
1820
1821 /// Get the typelib information for an item of type set or enum
1822 virtual TYPELIB *get_typelib() const { return nullptr; }
1823
1824 virtual Item_result cast_to_int_type() const { return result_type(); }
1825 virtual enum Type type() const = 0;
1826
1827 bool aggregate_type(const char *name, Item **items, uint count);
1828
1829 /*
1830 Return information about function monotonicity. See comment for
1831 enum_monotonicity_info for details. This function can only be called
1832 after fix_fields() call.
1833 */
1835 return NON_MONOTONIC;
1836 }
1837
1838 /*
1839 Convert "func_arg $CMP$ const" half-interval into "FUNC(func_arg) $CMP2$
1840 const2"
1841
1842 SYNOPSIS
1843 val_int_endpoint()
1844 left_endp false <=> The interval is "x < const" or "x <= const"
1845 true <=> The interval is "x > const" or "x >= const"
1846
1847 incl_endp IN false <=> the comparison is '<' or '>'
1848 true <=> the comparison is '<=' or '>='
1849 OUT The same but for the "F(x) $CMP$ F(const)" comparison
1850
1851 DESCRIPTION
1852 This function is defined only for unary monotonic functions. The caller
1853 supplies the source half-interval
1854
1855 x $CMP$ const
1856
1857 The value of const is supplied implicitly as the value of this item's
1858 argument, the form of $CMP$ comparison is specified through the
1859 function's arguments. The call returns the result interval
1860
1861 F(x) $CMP2$ F(const)
1862
1863 passing back F(const) as the return value, and the form of $CMP2$
1864 through the out parameter. NULL values are assumed to be comparable and
1865 be less than any non-NULL values.
1866
1867 RETURN
1868 The output range bound, which equal to the value of val_int()
1869 - If the value of the function is NULL then the bound is the
1870 smallest possible value of LLONG_MIN
1871 */
1872 virtual longlong val_int_endpoint(bool left_endp [[maybe_unused]],
1873 bool *incl_endp [[maybe_unused]]) {
1874 assert(0);
1875 return 0;
1876 }
1877
1878 /* valXXX methods must return NULL or 0 or 0.0 if null_value is set. */
1879 /*
1880 Return double precision floating point representation of item.
1881
1882 SYNOPSIS
1883 val_real()
1884
1885 RETURN
1886 In case of NULL value return 0.0 and set null_value flag to true.
1887 If value is not null null_value flag will be reset to false.
1888 */
1889 virtual double val_real() = 0;
1890 /*
1891 Return integer representation of item.
1892
1893 SYNOPSIS
1894 val_int()
1895
1896 RETURN
1897 In case of NULL value return 0 and set null_value flag to true.
1898 If value is not null null_value flag will be reset to false.
1899 */
1900 virtual longlong val_int() = 0;
1901 /**
1902 Return date value of item in packed longlong format.
1903 */
1904 virtual longlong val_date_temporal();
1905 /**
1906 Return time value of item in packed longlong format.
1907 */
1908 virtual longlong val_time_temporal();
1909
1910 /**
1911 Return date or time value of item in packed longlong format,
1912 depending on item field type.
1913 */
1915 if (data_type() == MYSQL_TYPE_TIME) return val_time_temporal();
1916 assert(is_temporal_with_date());
1917 return val_date_temporal();
1918 }
1919
1920 /**
1921 Produces a key suitable for filesort. Most of the time, val_int() would
1922 suffice, but for temporal values, the packed value (as sent to the handler)
1923 is called for. It is also necessary that the value is in UTC. This function
1924 supplies just that.
1925
1926 @return A sort key value.
1927 */
1931 return val_int();
1932 }
1933
1934 /**
1935 Get date or time value in packed longlong format.
1936 Before conversion from MYSQL_TIME to packed format,
1937 the MYSQL_TIME value is rounded to "dec" fractional digits.
1938 */
1940
1941 /*
1942 This is just a shortcut to avoid the cast. You should still use
1943 unsigned_flag to check the sign of the item.
1944 */
1945 inline ulonglong val_uint() { return (ulonglong)val_int(); }
1946 /*
1947 Return string representation of this item object.
1948
1949 SYNOPSIS
1950 val_str()
1951 str an allocated buffer this or any nested Item object can use to
1952 store return value of this method.
1953
1954 NOTE
1955 Buffer passed via argument should only be used if the item itself
1956 doesn't have an own String buffer. In case when the item maintains
1957 it's own string buffer, it's preferable to return it instead to
1958 minimize number of mallocs/memcpys.
1959 The caller of this method can modify returned string, but only in case
1960 when it was allocated on heap, (is_alloced() is true). This allows
1961 the caller to efficiently use a buffer allocated by a child without
1962 having to allocate a buffer of it's own. The buffer, given to
1963 val_str() as argument, belongs to the caller and is later used by the
1964 caller at it's own choosing.
1965 A few implications from the above:
1966 - unless you return a string object which only points to your buffer
1967 but doesn't manages it you should be ready that it will be
1968 modified.
1969 - even for not allocated strings (is_alloced() == false) the caller
1970 can change charset (see Item_func_{typecast/binary}. XXX: is this
1971 a bug?
1972 - still you should try to minimize data copying and return internal
1973 object whenever possible.
1974
1975 RETURN
1976 In case of NULL value or error, return error_str() as this function will
1977 check if the return value may be null, and it will either set null_value
1978 to true and return nullptr or to false and it will return empty string.
1979 If value is not null set null_value flag to false before returning it.
1980 */
1981 virtual String *val_str(String *str) = 0;
1982
1983 /*
1984 Returns string representation of this item in ASCII format.
1985
1986 SYNOPSIS
1987 val_str_ascii()
1988 str - similar to val_str();
1989
1990 NOTE
1991 This method is introduced for performance optimization purposes.
1992
1993 1. val_str() result of some Items in string context
1994 depends on @@character_set_results.
1995 @@character_set_results can be set to a "real multibyte" character
1996 set like UCS2, UTF16, UTF32. (We'll use only UTF32 in the examples
1997 below for convenience.)
1998
1999 So the default string result of such functions
2000 in these circumstances is real multi-byte character set, like UTF32.
2001
2002 For example, all numbers in string context
2003 return result in @@character_set_results:
2004
2005 SELECT CONCAT(20010101); -> UTF32
2006
2007 We do sprintf() first (to get ASCII representation)
2008 and then convert to UTF32;
2009
2010 So these kind "data sources" can use ASCII representation
2011 internally, but return multi-byte data only because
2012 @@character_set_results wants so.
2013 Therefore, conversion from ASCII to UTF32 is applied internally.
2014
2015
2016 2. Some other functions need in fact ASCII input.
2017
2018 For example,
2019 inet_aton(), GeometryFromText(), Convert_TZ(), GET_FORMAT().
2020
2021 Similar, fields of certain type, like DATE, TIME,
2022 when you insert string data into them, expect in fact ASCII input.
2023 If they get non-ASCII input, for example UTF32, they
2024 convert input from UTF32 to ASCII, and then use ASCII
2025 representation to do further processing.
2026
2027
2028 3. Now imagine we pass result of a data source of the first type
2029 to a data destination of the second type.
2030
2031 What happens:
2032 a. data source converts data from ASCII to UTF32, because
2033 @@character_set_results wants so and passes the result to
2034 data destination.
2035 b. data destination gets UTF32 string.
2036 c. data destination converts UTF32 string to ASCII,
2037 because it needs ASCII representation to be able to handle data
2038 correctly.
2039
2040 As a result we get two steps of unnecessary conversion:
2041 From ASCII to UTF32, then from UTF32 to ASCII.
2042
2043 A better way to handle these situations is to pass ASCII
2044 representation directly from the source to the destination.
2045
2046 This is why val_str_ascii() introduced.
2047
2048 RETURN
2049 Similar to val_str()
2050 */
2051 virtual String *val_str_ascii(String *str);
2052
2053 /*
2054 Return decimal representation of item with fixed point.
2055
2056 SYNOPSIS
2057 val_decimal()
2058 decimal_buffer buffer which can be used by Item for returning value
2059 (but can be not)
2060
2061 NOTE
2062 Returned value should not be changed if it is not the same which was
2063 passed via argument.
2064
2065 RETURN
2066 Return pointer on my_decimal (it can be other then passed via argument)
2067 if value is not NULL (null_value flag will be reset to false).
2068 In case of NULL value it return 0 pointer and set null_value flag
2069 to true.
2070 */
2071 virtual my_decimal *val_decimal(my_decimal *decimal_buffer) = 0;
2072 /*
2073 Return boolean value of item.
2074
2075 RETURN
2076 false value is false or NULL
2077 true value is true (not equal to 0)
2078 */
2079 virtual bool val_bool();
2080
2081 /**
2082 Get a JSON value from an Item.
2083
2084 All subclasses that can return a JSON value, should override this
2085 function. The function in the base class is not expected to be
2086 called. If it is called, it most likely means that some subclass
2087 is missing an override of val_json().
2088
2089 @param[in,out] result The resulting Json_wrapper.
2090
2091 @return false if successful, true on failure
2092 */
2093 /* purecov: begin deadcode */
2094 virtual bool val_json(Json_wrapper *result [[maybe_unused]]) {
2095 assert(false);
2096 my_error(ER_NOT_SUPPORTED_YET, MYF(0), "item type for JSON");
2097 return error_json();
2098 }
2099 /* purecov: end */
2100
2101 /**
2102 Calculate the filter contribution that is relevant for table
2103 'filter_for_table' for this item.
2104
2105 @param thd Thread handler
2106 @param filter_for_table The table we are calculating filter effect for
2107 @param read_tables Tables earlier in the join sequence.
2108 Predicates for table 'filter_for_table' that
2109 rely on values from these tables can be part of
2110 the filter effect.
2111 @param fields_to_ignore Fields in 'filter_for_table' that should not
2112 be part of the filter calculation. The filtering
2113 effect of these fields is already part of the
2114 calculation somehow (e.g. because there is a
2115 predicate "col = <const>", and the optimizer
2116 has decided to do ref access on 'col').
2117 @param rows_in_table The number of rows in table 'filter_for_table'
2118
2119 @return the filtering effect (between 0 and 1) this
2120 Item contributes with.
2121 */
2122 virtual float get_filtering_effect(THD *thd [[maybe_unused]],
2123 table_map filter_for_table
2124 [[maybe_unused]],
2125 table_map read_tables [[maybe_unused]],
2126 const MY_BITMAP *fields_to_ignore
2127 [[maybe_unused]],
2128 double rows_in_table [[maybe_unused]]) {
2129 // Filtering effect cannot be calculated for a table already read.
2130 assert((read_tables & filter_for_table) == 0);
2131 return COND_FILTER_ALLPASS;
2132 }
2133
2134 /**
2135 Get the value to return from val_json() in case of errors.
2136
2137 @see Item::error_bool
2138
2139 @return The value val_json() should return, which is true.
2140 */
2141 bool error_json() {
2143 return true;
2144 }
2145
2146 /**
2147 Convert a non-temporal type to date
2148 */
2150
2151 /**
2152 Convert a non-temporal type to time
2153 */
2155
2156 protected:
2157 /* Helper functions, see item_sum.cc */
2174 double val_real_from_decimal();
2175 double val_real_from_string();
2176
2177 /**
2178 Get the value to return from val_bool() in case of errors.
2179
2180 This function is called from val_bool() when an error has occurred
2181 and we need to return something to abort evaluation of the
2182 item. The expected pattern in val_bool() is
2183
2184 if (@<error condition@>)
2185 {
2186 my_error(...)
2187 return error_bool();
2188 }
2189
2190 @return The value val_bool() should return.
2191 */
2192 bool error_bool() {
2194 return false;
2195 }
2196
2197 /**
2198 Get the value to return from val_int() in case of errors.
2199
2200 @see Item::error_bool
2201
2202 @return The value val_int() should return.
2203 */
2206 return 0;
2207 }
2208
2209 /**
2210 Get the value to return from val_real() in case of errors.
2211
2212 @see Item::error_bool
2213
2214 @return The value val_real() should return.
2215 */
2216 double error_real() {
2218 return 0.0;
2219 }
2220
2221 /**
2222 Get the value to return from get_date() in case of errors.
2223
2224 @see Item::error_bool
2225
2226 @return The true: the function failed.
2227 */
2228 bool error_date() {
2230 return true;
2231 }
2232
2233 /**
2234 Get the value to return from get_time() in case of errors.
2235
2236 @see Item::error_bool
2237
2238 @return The true: the function failed.
2239 */
2240 bool error_time() {
2242 return true;
2243 }
2244
2245 public:
2246 /**
2247 Get the value to return from val_decimal() in case of errors.
2248
2249 @see Item::error_decimal
2250
2251 @return The value val_decimal() should return.
2252 */
2255 if (null_value) return nullptr;
2256 my_decimal_set_zero(decimal_value);
2257 return decimal_value;
2258 }
2259
2260 /**
2261 Get the value to return from val_str() in case of errors.
2262
2263 @see Item::error_bool
2264
2265 @return The value val_str() should return.
2266 */
2270 }
2271
2272 protected:
2273 /**
2274 Gets the value to return from val_str() when returning a NULL value.
2275 @return The value val_str() should return.
2276 */
2278 assert(m_nullable);
2279 null_value = true;
2280 return nullptr;
2281 }
2282
2283 /**
2284 Convert val_str() to date in MYSQL_TIME
2285 */
2287 /**
2288 Convert val_real() to date in MYSQL_TIME
2289 */
2291 /**
2292 Convert val_decimal() to date in MYSQL_TIME
2293 */
2295 /**
2296 Convert val_int() to date in MYSQL_TIME
2297 */
2299 /**
2300 Convert get_time() from time to date in MYSQL_TIME
2301 */
2302 bool get_date_from_time(MYSQL_TIME *ltime);
2303
2304 /**
2305 Convert a numeric type to date
2306 */
2307 bool get_date_from_numeric(MYSQL_TIME *ltime, my_time_flags_t fuzzydate);
2308
2309 /**
2310 Convert val_str() to time in MYSQL_TIME
2311 */
2312 bool get_time_from_string(MYSQL_TIME *ltime);
2313 /**
2314 Convert val_real() to time in MYSQL_TIME
2315 */
2316 bool get_time_from_real(MYSQL_TIME *ltime);
2317 /**
2318 Convert val_decimal() to time in MYSQL_TIME
2319 */
2320 bool get_time_from_decimal(MYSQL_TIME *ltime);
2321 /**
2322 Convert val_int() to time in MYSQL_TIME
2323 */
2324 bool get_time_from_int(MYSQL_TIME *ltime);
2325 /**
2326 Convert date to time
2327 */
2328 bool get_time_from_date(MYSQL_TIME *ltime);
2329 /**
2330 Convert datetime to time
2331 */
2333
2334 /**
2335 Convert a numeric type to time
2336 */
2337 bool get_time_from_numeric(MYSQL_TIME *ltime);
2338
2340
2342
2343 public:
2347
2348 /**
2349 If this Item is being materialized into a temporary table, returns the
2350 field that is being materialized into. (Typically, this is the
2351 “result_field” members for items that have one.)
2352 */
2354 DBUG_TRACE;
2355 return nullptr;
2356 }
2357 /* This is also used to create fields in CREATE ... SELECT: */
2358 virtual Field *tmp_table_field(TABLE *) { return nullptr; }
2359 virtual const char *full_name() const {
2360 return item_name.is_set() ? item_name.ptr() : "???";
2361 }
2362
2363 /* bit map of tables used by item */
2364 virtual table_map used_tables() const { return (table_map)0L; }
2365
2366 /**
2367 Return table map of tables that can't be NULL tables (tables that are
2368 used in a context where if they would contain a NULL row generated
2369 by a LEFT or RIGHT join, the item would not be true).
2370 This expression is used on WHERE item to determinate if a LEFT JOIN can be
2371 converted to a normal join.
2372 Generally this function should return used_tables() if the function
2373 would return null if any of the arguments are null
2374 As this is only used in the beginning of optimization, the value don't
2375 have to be updated in update_used_tables()
2376 */
2377 virtual table_map not_null_tables() const { return used_tables(); }
2378
2379 /**
2380 Returns true if this is a simple constant item like an integer, not
2381 a constant expression. Used in the optimizer to propagate basic constants.
2382 It is assumed that val_xxx() does not modify the item's state for
2383 such items. It is also assumed that val_str() can be called with nullptr
2384 as argument as val_str() will return an internally cached const string.
2385 */
2386 virtual bool basic_const_item() const { return false; }
2387 /**
2388 @returns true when a const item may be evaluated during resolving.
2389 Only const items that are basic const items are evaluated when
2390 resolving CREATE VIEW statements. For other statements, all
2391 const items may be evaluated during resolving.
2392 */
2393 bool may_eval_const_item(const THD *thd) const;
2394 /**
2395 @return cloned item if it is constant
2396 @retval nullptr if this is not const
2397 */
2398 virtual Item *clone_item() const { return nullptr; }
2399 virtual cond_result eq_cmp_result() const { return COND_OK; }
2400 inline uint float_length(uint decimals_par) const {
2401 return decimals != DECIMAL_NOT_SPECIFIED ? (DBL_DIG + 2 + decimals_par)
2402 : DBL_DIG + 8;
2403 }
2404 virtual uint decimal_precision() const;
2405 inline int decimal_int_part() const {
2407 }
2408 /**
2409 TIME precision of the item: 0..6
2410 */
2411 virtual uint time_precision();
2412 /**
2413 DATETIME precision of the item: 0..6
2414 */
2415 virtual uint datetime_precision();
2416 /**
2417 Returns true if item is constant, regardless of query evaluation state.
2418 An expression is constant if it:
2419 - refers no tables.
2420 - refers no subqueries that refers any tables.
2421 - refers no non-deterministic functions.
2422 - refers no statement parameters.
2423 - contains no group expression under rollup
2424 */
2425 bool const_item() const { return (used_tables() == 0); }
2426 /**
2427 Returns true if item is constant during one query execution.
2428 If const_for_execution() is true but const_item() is false, value is
2429 not available before tables have been locked and parameters have been
2430 assigned values. This applies to
2431 - statement parameters
2432 - non-dependent subqueries
2433 - deterministic stored functions that contain SQL code.
2434 For items where the default implementation of used_tables() and
2435 const_item() are effective, const_item() will always return true.
2436 */
2437 bool const_for_execution() const {
2438 return !(used_tables() & ~INNER_TABLE_BIT);
2439 }
2440
2441 /**
2442 Return true if this is a const item that may be evaluated in
2443 the current phase of statement processing.
2444 - No evaluation is performed when analyzing a view, otherwise:
2445 - Items that have the const_item() property can always be evaluated.
2446 - Items that have the const_for_execution() property can be evaluated when
2447 tables are locked (ie during optimization or execution).
2448
2449 This function should be used in the following circumstances:
2450 - during preparation to check whether an item can be permanently transformed
2451 - to check that an item is constant in functions that may be used in both
2452 the preparation and optimization phases.
2453
2454 This function should not be used by code that is called during optimization
2455 and/or execution only. Use const_for_execution() in this case.
2456 */
2457 bool may_evaluate_const(const THD *thd) const;
2458
2459 /**
2460 @returns true if this item is non-deterministic, which means that a
2461 has a component that must be evaluated once per row in
2462 execution of a JOIN query.
2463 */
2465
2466 /**
2467 @returns true if this item is an outer reference, usually this means that
2468 it references a column that contained in a table located in
2469 the FROM clause of an outer query block.
2470 */
2471 bool is_outer_reference() const {
2473 }
2474
2475 /**
2476 This method is used for to:
2477 - to generate a view definition query (SELECT-statement);
2478 - to generate a SQL-query for EXPLAIN EXTENDED;
2479 - to generate a SQL-query to be shown in INFORMATION_SCHEMA;
2480 - to generate a SQL-query that looks like a prepared statement for
2481 query_rewrite
2482 - debug.
2483
2484 For more information about view definition query, INFORMATION_SCHEMA
2485 query and why they should be generated from the Item-tree, @see
2486 mysql_register_view().
2487 */
2488 virtual void print(const THD *, String *str, enum_query_type) const {
2489 str->append(full_name());
2490 }
2491
2492 void print_item_w_name(const THD *thd, String *,
2493 enum_query_type query_type) const;
2494 /**
2495 Prints the item when it's part of ORDER BY and GROUP BY.
2496 @param thd Thread handle
2497 @param str String to print to
2498 @param query_type How to format the item
2499 @param used_alias The alias with which this item was referenced, or
2500 nullptr if it was not referenced with an alias.
2501 */
2502 void print_for_order(const THD *thd, String *str, enum_query_type query_type,
2503 const char *used_alias) const;
2504
2505 /**
2506 Updates used tables, not null tables information and accumulates
2507 properties up the item tree, cf. used_tables_cache, not_null_tables_cache
2508 and m_accum_properties.
2509
2510 TODO(sgunders): Consider just removing these caches; it causes a lot of bugs
2511 (cache invalidation is known to be a complex problem), and the performance
2512 benefits are dubious.
2513 */
2514 virtual void update_used_tables() {}
2515
2517 return false;
2518 }
2519 /* Called for items that really have to be split */
2520 bool split_sum_func2(THD *thd, Ref_item_array ref_item_array,
2521 mem_root_deque<Item *> *fields, Item **ref,
2522 bool skip_registered);
2523 virtual bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) = 0;
2524 virtual bool get_time(MYSQL_TIME *ltime) = 0;
2525 /**
2526 Get timestamp in "struct timeval" format.
2527 @retval false on success
2528 @retval true on error
2529 */
2530 virtual bool get_timeval(my_timeval *tm, int *warnings);
2531 /**
2532 The method allows to determine nullness of a complex expression
2533 without fully evaluating it, instead of calling val*() then
2534 checking null_value. Used in Item_func_isnull/Item_func_isnotnull
2535 and Item_sum_count/Item_sum_count_distinct.
2536 Any item which can be NULL must implement this method.
2537
2538 @retval false if the expression is not NULL.
2539 @retval true if the expression is NULL, or evaluation caused an error.
2540 The null_value member is set according to the return value.
2541 */
2542 virtual bool is_null() { return false; }
2543
2544 /**
2545 Make sure the null_value member has a correct value.
2546 null_value is set true also when evaluation causes error.
2547
2548 @returns false if success, true if error
2549 */
2550 bool update_null_value();
2551
2552 /**
2553 Apply the IS TRUE truth property, meaning that an UNKNOWN result and a
2554 FALSE result are treated the same.
2555
2556 This property is applied e.g to all conditions in WHERE, HAVING and ON
2557 clauses, and is recursively applied to operands of AND, OR
2558 operators. Some items (currently AND and subquery predicates) may enable
2559 special optimizations when they have this property.
2560 */
2561 virtual void apply_is_true() {}
2562 /*
2563 set field of temporary table for Item which can be switched on temporary
2564 table during query processing (grouping and so on). @see
2565 Item_result_field.
2566 */
2567 virtual void set_result_field(Field *) {}
2568 virtual bool is_result_field() const { return false; }
2569 virtual Field *get_result_field() const { return nullptr; }
2570 virtual bool is_bool_func() const { return false; }
2571 /*
2572 Set value of aggregate function in case of no rows for grouping were found.
2573 Also used for subqueries with outer references in SELECT list.
2574 */
2575 virtual void no_rows_in_result() {}
2576 virtual Item *copy_or_same(THD *) { return this; }
2577 virtual Item *copy_andor_structure(THD *) { return this; }
2578 /**
2579 @returns the "real item" underlying the owner object. Used to strip away
2580 Item_ref objects.
2581 @note remember to implement both real_item() functions in sub classes!
2582 */
2583 virtual Item *real_item() { return this; }
2584 virtual const Item *real_item() const { return this; }
2585 /**
2586 If an Item is materialized in a temporary table, a different Item may have
2587 to be used in the part of the query that runs after the materialization.
2588 For instance, if the Item was an Item_field, the new Item_field needs to
2589 point into the temporary table instead of the original one, but if, on the
2590 other hand, the Item was a literal constant, it can be reused as-is.
2591 This function encapsulates these policies for the different kinds of Items.
2592 See also get_tmp_table_field().
2593
2594 TODO: Document how aggregate functions (Item_sum) are handled.
2595 */
2596 virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
2597
2598 static const CHARSET_INFO *default_charset();
2599 virtual const CHARSET_INFO *compare_collation() const { return nullptr; }
2600
2601 /*
2602 For backward compatibility, to make numeric
2603 data types return "binary" charset in client-side metadata.
2604 */
2607 : &my_charset_bin;
2608 }
2609
2610 /**
2611 Traverses a tree of Items in prefix and/or postfix order.
2612 Optionally walks into subqueries.
2613
2614 @param processor processor function to be invoked per item
2615 returns true to abort traversal, false to continue
2616 @param walk controls how to traverse the item tree
2617 enum_walk::PREFIX: call processor before invoking
2618 children enum_walk::POSTFIX: call processor after invoking children
2619 enum_walk::SUBQUERY go down into subqueries
2620 walk values are bit-coded and may be combined.
2621 Omitting both enum_walk::PREFIX and enum_walk::POSTFIX
2622 is undefined behaviour.
2623 @param arg Optional pointer to a walk-specific object
2624
2625 @retval false walk succeeded
2626 @retval true walk aborted
2627 by agreement, an error may have been reported
2628 */
2629
2630 virtual bool walk(Item_processor processor, enum_walk walk [[maybe_unused]],
2631 uchar *arg) {
2632 return ((walk & enum_walk::PREFIX) && (this->*processor)(arg)) ||
2633 ((walk & enum_walk::POSTFIX) && (this->*processor)(arg));
2634 }
2635
2636 /** @see WalkItem, CompileItem, TransformItem */
2637 template <class T>
2639 return (*reinterpret_cast<std::remove_reference_t<T> *>(arg))(this);
2640 }
2641
2642 /** See CompileItem */
2643 template <class T>
2645 return (*reinterpret_cast<std::remove_reference_t<T> *>(*arg))(this);
2646 }
2647
2648 /**
2649 Perform a generic transformation of the Item tree, by adding zero or
2650 more additional Item objects to it.
2651
2652 @param transformer Transformer function
2653 @param[in,out] arg Pointer to struct used by transformer function
2654
2655 @returns Returned item tree after transformation, NULL if error
2656
2657 Transformation is performed as follows:
2658
2659 @code
2660 transform()
2661 {
2662 transform children if any;
2663 return this->*some_transformer(...);
2664 }
2665 @endcode
2666
2667 Note that unlike Item::compile(), transform() does not support an analyzer
2668 function, ie. all children are unconditionally invoked.
2669
2670 Item::transform() should handle all transformations during preparation.
2671 Notice that all transformations are permanent; they are not rolled back.
2672
2673 Use Item::compile() to perform transformations during optimization.
2674 */
2675 virtual Item *transform(Item_transformer transformer, uchar *arg);
2676
2677 /**
2678 Perform a generic "compilation" of the Item tree, ie transform the Item tree
2679 by adding zero or more Item objects to it.
2680
2681 @param analyzer Analyzer function, see details section
2682 @param[in,out] arg_p Pointer to struct used by analyzer function
2683 @param transformer Transformer function, see details section
2684 @param[in,out] arg_t Pointer to struct used by transformer function
2685
2686 @returns Returned item tree after transformation, NULL if error
2687
2688 The process of this transformation is assumed to be as follows:
2689
2690 @code
2691 compile()
2692 {
2693 if (this->*some_analyzer(...))
2694 {
2695 compile children if any;
2696 return this->*some_transformer(...);
2697 }
2698 else
2699 return this;
2700 }
2701 @endcode
2702
2703 i.e. analysis is performed top-down while transformation is done
2704 bottom-up. If no transformation is applied, the item is returned unchanged.
2705 A transformation error is indicated by returning a NULL pointer. Notice
2706 that the analyzer function should never cause an error.
2707
2708 The function is supposed to be used during the optimization stage of
2709 query execution. All new allocations are recorded using
2710 THD::change_item_tree() so that they can be rolled back after execution.
2711
2712 @todo Pass THD to compile() function, thus no need to use current_thd.
2713 */
2714 virtual Item *compile(Item_analyzer analyzer, uchar **arg_p,
2715 Item_transformer transformer, uchar *arg_t) {
2716 if ((this->*analyzer)(arg_p)) return ((this->*transformer)(arg_t));
2717 return this;
2718 }
2719
2720 virtual void traverse_cond(Cond_traverser traverser, void *arg,
2722 (*traverser)(this, arg);
2723 }
2724
2725 /*
2726 This is used to get the most recent version of any function in
2727 an item tree. The version is the version where a MySQL function
2728 was introduced in. So any function which is added should use
2729 this function and set the int_arg to maximum of the input data
2730 and their own version info.
2731 */
2732 virtual bool intro_version(uchar *) { return false; }
2733
2734 /// cleanup() item if it is resolved ('fixed').
2736 if (fixed) cleanup();
2737 return false;
2738 }
2739
2740 virtual bool collect_item_field_processor(uchar *) { return false; }
2741 virtual bool collect_item_field_or_ref_processor(uchar *) { return false; }
2742 virtual bool collect_outer_field_processor(uchar *) { return false; }
2743
2745 public:
2748 : m_items(fields_or_refs) {}
2751 const Collect_item_fields_or_refs &) = delete;
2752
2753 friend class Item_sum;
2754 friend class Item_field;
2755 friend class Item_ref;
2756 };
2757
2759 public:
2762 /// Used to compute \c Item_field's \c m_protected_by_any_value. Pushed and
2763 /// popped when walking arguments of \c Item_func_any_value.a
2766 Query_block *transformed_block)
2767 : m_item_fields_or_view_refs(fields_or_vr),
2768 m_transformed_block(transformed_block) {}
2770 delete;
2772 const Collect_item_fields_or_view_refs &) = delete;
2773
2774 friend class Item_sum;
2775 friend class Item_field;
2777 friend class Item_view_ref;
2778 };
2779
2780 /**
2781 Collects fields and view references that have the qualifying table
2782 in the specified query block.
2783 */
2785 return false;
2786 }
2787
2788 /**
2789 Item::walk function. Set bit in table->tmp_set for all fields in
2790 table 'arg' that are referred to by the Item.
2791 */
2792 virtual bool add_field_to_set_processor(uchar *) { return false; }
2793
2794 /// A processor to handle the select lex visitor framework.
2795 virtual bool visitor_processor(uchar *arg);
2796
2797 /**
2798 Item::walk function. Set bit in table->cond_set for all fields of
2799 all tables that are referred to by the Item.
2800 */
2801 virtual bool add_field_to_cond_set_processor(uchar *) { return false; }
2802
2803 /**
2804 Visitor interface for removing all column expressions (Item_field) in
2805 this expression tree from a bitmap. @see walk()
2806
2807 @param arg A MY_BITMAP* cast to unsigned char*, where the bits represent
2808 Field::field_index values.
2809 */
2810 virtual bool remove_column_from_bitmap(uchar *arg [[maybe_unused]]) {
2811 return false;
2812 }
2813 virtual bool find_item_in_field_list_processor(uchar *) { return false; }
2814 virtual bool change_context_processor(uchar *) { return false; }
2815 virtual bool find_item_processor(uchar *arg) { return this == (void *)arg; }
2817 return !basic_const_item();
2818 }
2819 /// Is this an Item_field which references the given Field argument?
2820 virtual bool find_field_processor(uchar *) { return false; }
2821 /// Wrap incompatible arguments in CAST nodes to the expected data types
2822 virtual bool cast_incompatible_args(uchar *) { return false; }
2823 /**
2824 Mark underlying field in read or write map of a table.
2825
2826 @param arg Mark_field object
2827 */
2828 virtual bool mark_field_in_map(uchar *arg [[maybe_unused]]) { return false; }
2829
2830 protected:
2831 /**
2832 Helper function for mark_field_in_map(uchar *arg).
2833
2834 @param mark_field Mark_field object
2835 @param field Field to be marked for read/write
2836 */
2837 static inline bool mark_field_in_map(Mark_field *mark_field, Field *field) {
2838 TABLE *table = mark_field->table;
2839 if (table != nullptr && table != field->table) return false;
2840
2841 table = field->table;
2842 table->mark_column_used(field, mark_field->mark);
2843
2844 return false;
2845 }
2846
2847 public:
2848 /**
2849 Reset execution state for such window function types
2850 as determined by arg
2851
2852 @param arg pointing to a bool which, if true, says to reset state
2853 for framing window function, else for non-framing
2854 */
2855 virtual bool reset_wf_state(uchar *arg [[maybe_unused]]) { return false; }
2856
2857 /**
2858 Return used table information for the specified query block (level).
2859 For a field that is resolved from this query block, return the table number.
2860 For a field that is resolved from a query block outer to the specified one,
2861 return OUTER_REF_TABLE_BIT
2862
2863 @param[in,out] arg pointer to an instance of class Used_tables, which is
2864 constructed with the query block as argument.
2865 The used tables information is accumulated in the field
2866 used_tables in this class.
2867
2868 @note This function is used to update used tables information after
2869 merging a query block (a subquery) with its parent.
2870 */
2871 virtual bool used_tables_for_level(uchar *arg [[maybe_unused]]) {
2872 return false;
2873 }
2874 /**
2875 Check privileges.
2876
2877 @param thd thread handle
2878 */
2879 virtual bool check_column_privileges(uchar *thd [[maybe_unused]]) {
2880 return false;
2881 }
2882 virtual bool inform_item_in_cond_of_tab(uchar *) { return false; }
2883 /**
2884 Bind objects from the current execution context to field objects in
2885 item trees. Typically used to bind Field objects from TABLEs to
2886 Item_field objects.
2887 */
2888 virtual void bind_fields() {}
2889
2890 /**
2891 Context object for (functions that override)
2892 Item::clean_up_after_removal().
2893 */
2895 public:
2897 assert(root != nullptr);
2898 }
2899
2901
2902 private:
2903 /**
2904 Pointer to Cleanup_after_removal_context containing from which
2905 select the walk started, i.e., the Query_block that contained the clause
2906 that was removed.
2907 */
2909
2910 friend class Item;
2911 friend class Item_sum;
2912 friend class Item_subselect;
2913 friend class Item_ref;
2914 };
2915 /**
2916 Clean up after removing the item from the item tree.
2917
2918 param arg pointer to a Cleanup_after_removal_context object
2919 @todo: If class ORDER is refactored so that all indirect
2920 grouping/ordering expressions are represented with Item_ref
2921 objects, all implementations of cleanup_after_removal() except
2922 the one for Item_ref can be removed.
2923 */
2924 virtual bool clean_up_after_removal(uchar *arg);
2925
2926 /// @see Distinct_check::check_query()
2927 virtual bool aggregate_check_distinct(uchar *) { return false; }
2928 /// @see Group_check::check_query()
2929 virtual bool aggregate_check_group(uchar *) { return false; }
2930 /// @see Group_check::analyze_conjunct()
2931 virtual bool is_strong_side_column_not_in_fd(uchar *) { return false; }
2932 /// @see Group_check::is_in_fd_of_underlying()
2933 virtual bool is_column_not_in_fd(uchar *) { return false; }
2934 virtual Bool3 local_column(const Query_block *) const {
2935 return Bool3::false3();
2936 }
2937
2938 /**
2939 Minion class under \c Collect_scalar_subquery_info ("Css"). Information
2940 about one scalar subquery being considered for transformation
2941 */
2942 struct Css_info {
2943 /// set of locations
2945 /// the scalar subquery
2948 /// Where did we find item above? Used when \c m_location == \c L_JOIN_COND,
2949 /// nullptr for other locations.
2951 /// If true, we can forego cardinality checking of the derived table
2953 /// If true, add a COALESCE around replaced subquery: used for implicitly
2954 /// grouped COUNT() in subquery select list when subquery is correlated
2955 bool m_add_coalesce{false};
2956 /// Set iff \c m_add_coalesce is true: we may get a NULL anyway even for
2957 /// COUNT if a HAVING clause is false in the subquery.
2959 /// Index of the having expression copied to select list
2961 };
2962
2963 /**
2964 Context struct used by walk method collect_scalar_subqueries to
2965 accumulate information about scalar subqueries found.
2966
2967 In: m_location of expression walked, m_join_condition_context
2968 Out: m_list
2969 */
2971 enum Location { L_SELECT = 1, L_WHERE = 2, L_HAVING = 4, L_JOIN_COND = 8 };
2972 /// accumulated all scalar subqueries found
2973 std::vector<Css_info> m_list;
2974 /// we are currently looking at this kind of clause, cf. enum Location
2979 friend class Item_sum;
2981 };
2982
2983 virtual bool collect_scalar_subqueries(uchar *) { return false; }
2984 virtual bool collect_grouped_aggregates(uchar *) { return false; }
2985 virtual bool collect_subqueries(uchar *) { return false; }
2986 virtual bool update_depended_from(uchar *) { return false; }
2987 /**
2988 Check if an aggregate is referenced from within the GROUP BY
2989 clause of the query block in which it is aggregated. Such
2990 references will be rejected.
2991 @see Item_ref::fix_fields()
2992 @retval true if this is an aggregate which is referenced from
2993 the GROUP BY clause of the aggregating query block
2994 @retval false otherwise
2995 */
2996 virtual bool has_aggregate_ref_in_group_by(uchar *) { return false; }
2997
2998 bool visit_all_analyzer(uchar **) { return true; }
2999 virtual bool cache_const_expr_analyzer(uchar **cache_item);
3001
3002 virtual bool equality_substitution_analyzer(uchar **) { return false; }
3003
3004 virtual Item *equality_substitution_transformer(uchar *) { return this; }
3005
3006 /**
3007 Check if a partition function is allowed.
3008
3009 @return whether a partition function is not accepted
3010
3011 @details
3012 check_partition_func_processor is used to check if a partition function
3013 uses an allowed function. An allowed function will always ensure that
3014 X=Y guarantees that also part_function(X)=part_function(Y) where X is
3015 a set of partition fields and so is Y. The problems comes mainly from
3016 character sets where two equal strings can be quite unequal. E.g. the
3017 german character for double s is equal to 2 s.
3018
3019 The default is that an item is not allowed
3020 in a partition function. Allowed functions
3021 can never depend on server version, they cannot depend on anything
3022 related to the environment. They can also only depend on a set of
3023 fields in the table itself. They cannot depend on other tables and
3024 cannot contain any queries and cannot contain udf's or similar.
3025 If a new Item class is defined and it inherits from a class that is
3026 allowed in a partition function then it is very important to consider
3027 whether this should be inherited to the new class. If not the function
3028 below should be defined in the new Item class.
3029
3030 The general behaviour is that most integer functions are allowed.
3031 If the partition function contains any multi-byte collations then
3032 the function check_part_func_fields will report an error on the
3033 partition function independent of what functions are used. So the
3034 only character sets allowed are single character collation and
3035 even for those only a limited set of functions are allowed. The
3036 problem with multi-byte collations is that almost every string
3037 function has the ability to change things such that two strings
3038 that are equal will not be equal after manipulated by a string
3039 function. E.g. two strings one contains a double s, there is a
3040 special german character that is equal to two s. Now assume a
3041 string function removes one character at this place, then in
3042 one the double s will be removed and in the other there will
3043 still be one s remaining and the strings are no longer equal
3044 and thus the partition function will not sort equal strings into
3045 the same partitions.
3046
3047 So the check if a partition function is valid is two steps. First
3048 check that the field types are valid, next check that the partition
3049 function is valid. The current set of partition functions valid
3050 assumes that there are no multi-byte collations amongst the partition
3051 fields.
3052 */
3053 virtual bool check_partition_func_processor(uchar *) { return true; }
3054 virtual bool subst_argument_checker(uchar **arg) {
3055 if (*arg) *arg = nullptr;
3056 return true;
3057 }
3058 virtual bool explain_subquery_checker(uchar **) { return true; }
3059 virtual Item *explain_subquery_propagator(uchar *) { return this; }
3060
3061 virtual Item *equal_fields_propagator(uchar *) { return this; }
3062 // Mark the item to not be part of substitution.
3063 virtual bool disable_constant_propagation(uchar *) { return false; }
3064
3066 // Stack of pointers to enclosing functions
3068 };
3069 virtual Item *replace_equal_field(uchar *) { return this; }
3070 virtual bool replace_equal_field_checker(uchar **) { return true; }
3071 /*
3072 Check if an expression value has allowed arguments, like DATE/DATETIME
3073 for date functions. Also used by partitioning code to reject
3074 timezone-dependent expressions in a (sub)partitioning function.
3075 */
3076 virtual bool check_valid_arguments_processor(uchar *) { return false; }
3077
3078 /**
3079 Check if this item is allowed for a virtual column or inside a
3080 default expression. Should be overridden in child classes.
3081
3082 @param[in,out] args Due to the limitation of Item::walk()
3083 it is declared as a pointer to uchar, underneath there's a actually a
3084 structure of type Check_function_as_value_generator_parameters.
3085 It is used mainly in Item_field.
3086
3087 @returns true if function is not accepted
3088 */
3089 virtual bool check_function_as_value_generator(uchar *args);
3090
3091 /**
3092 Check if a generated expression depends on DEFAULT function with
3093 specific column name as argument.
3094
3095 @param[in] args Name of column used as DEFAULT function argument.
3096
3097 @returns false if the function is not DEFAULT(args), otherwise true.
3098 */
3100 [[maybe_unused]]) {
3101 return false;
3102 }
3103 /**
3104 Check if all the columns present in this expression are from the
3105 derived table. Used in determining if a condition can be pushed
3106 down to derived table.
3107 */
3108 virtual bool is_valid_for_pushdown(uchar *arg [[maybe_unused]]) {
3109 // A generic item cannot be pushed down unless it's a constant
3110 // which does not have a subquery.
3111 return !const_item() || has_subquery();
3112 }
3113
3114 /**
3115 Check if all the columns present in this expression are present
3116 in PARTITION clause of window functions of the derived table.
3117 Used in checking if a condition can be pushed down to derived table.
3118 */
3119 virtual bool check_column_in_window_functions(uchar *arg [[maybe_unused]]) {
3120 return false;
3121 }
3122 /**
3123 Check if all the columns present in this expression are present
3124 in GROUP BY clause of the derived table. Used in checking if
3125 a condition can be pushed down to derived table.
3126 */
3127 virtual bool check_column_in_group_by(uchar *arg [[maybe_unused]]) {
3128 return false;
3129 }
3130 /**
3131 Assuming this expression is part of a condition that would be pushed to the
3132 WHERE clause of a materialized derived table, replace, in this expression,
3133 each derived table's column with a clone of the expression lying under it
3134 in the derived table's definition. We replace with a clone, because the
3135 condition can be pushed further down in case of nested derived tables.
3136 */
3137 virtual Item *replace_with_derived_expr(uchar *arg [[maybe_unused]]) {
3138 return this;
3139 }
3140 /**
3141 Assuming this expression is part of a condition that would be pushed to the
3142 HAVING clause of a materialized derived table, replace, in this expression,
3143 each derived table's column with a reference to the expression lying under
3144 it in the derived table's definition. Unlike replace_with_derived_expr, a
3145 clone is not used because HAVING condition will not be pushed further
3146 down in case of nested derived tables.
3147 */
3148 virtual Item *replace_with_derived_expr_ref(uchar *arg [[maybe_unused]]) {
3149 return this;
3150 }
3151 /**
3152 Assuming this expression is part of a condition that would be pushed to a
3153 materialized derived table, replace, in this expression, each view reference
3154 with a clone of the expression in merged derived table's definition.
3155 We replace with a clone, because the referenced item in a view reference
3156 is shared by all the view references to that expression.
3157 */
3158 virtual Item *replace_view_refs_with_clone(uchar *arg [[maybe_unused]]) {
3159 return this;
3160 }
3161 /*
3162 For SP local variable returns pointer to Item representing its
3163 current value and pointer to current Item otherwise.
3164 */
3165 virtual Item *this_item() { return this; }
3166 virtual const Item *this_item() const { return this; }
3167
3168 /*
3169 For SP local variable returns address of pointer to Item representing its
3170 current value and pointer passed via parameter otherwise.
3171 */
3172 virtual Item **this_item_addr(THD *, Item **addr_arg) { return addr_arg; }
3173
3174 // Row emulation
3175 virtual uint cols() const { return 1; }
3176 virtual Item *element_index(uint) { return this; }
3177 virtual Item **addr(uint) { return nullptr; }
3178 virtual bool check_cols(uint c);
3179 // It is not row => null inside is impossible
3180 virtual bool null_inside() { return false; }
3181 // used in row subselects to get value of elements
3182 virtual void bring_value() {}
3183
3184 Field *tmp_table_field_from_field_type(TABLE *table, bool fixed_length) const;
3185 virtual Item_field *field_for_view_update() { return nullptr; }
3186 /**
3187 Informs an item that it is wrapped in a truth test, in case it wants to
3188 transforms itself to implement this test by itself.
3189 @param thd Thread handle
3190 @param test Truth test
3191 */
3192 virtual Item *truth_transformer(THD *thd [[maybe_unused]],
3193 Bool_test test [[maybe_unused]]) {
3194 return nullptr;
3195 }
3196 virtual Item *update_value_transformer(uchar *) { return this; }
3197
3199 Query_block *m_trans_block; ///< Transformed query block
3200 Query_block *m_curr_block; ///< Transformed query block or a contained
3201 ///< subquery. Pushed when diving into
3202 ///< subqueries.
3203 Item_replacement(Query_block *transformed_block, Query_block *current_block)
3204 : m_trans_block(transformed_block), m_curr_block(current_block) {}
3205 };
3207 Field *m_target; ///< The field to be replaced
3208 Item_field *m_item; ///< The replacement field
3209 ///< replacement field iff outer ref
3211 enum class Mode {
3212 CONFLATE, // include both Item_field and Item_default_value
3213 FIELD, // ignore Item_default_value
3214 DEFAULT_VALUE // ignore Item_field
3215 };
3218 Mode default_value = Mode::CONFLATE)
3219 : Item_replacement(select, select),
3220 m_target(target),
3221 m_item(item),
3222 m_default_value(default_value) {}
3223 };
3224
3226 Item_func *m_target; ///< The function call to be replaced
3227 Item_field *m_item; ///< The replacement field
3229 Query_block *select)
3230 : Item_replacement(select, select),
3231 m_target(func_target),
3232 m_item(item) {}
3233 };
3234
3236 Item *m_target; ///< The item identifying the view_ref to be replaced
3237 Field *m_field; ///< The replacement field
3238 ///< subquery. Pushed when diving into
3239 ///< subqueries.
3241 : Item_replacement(select, select), m_target(target), m_field(field) {}
3242 };
3243
3248 : m_target(target), m_replacement(replacement) {}
3249 };
3250
3251 /**
3252 When walking the item tree seeing an Item_singlerow_subselect matching
3253 a target, replace it with a substitute field used when transforming
3254 scalar subqueries into derived tables. Cf.
3255 Query_block::transform_scalar_subqueries_to_join_with_derived.
3256 */
3257 virtual Item *replace_scalar_subquery(uchar *) { return this; }
3258
3259 /**
3260 Transform processor used by Query_block::transform_grouped_to_derived
3261 to replace fields which used to be at the transformed query block
3262 with corresponding fields in the new derived table containing the grouping
3263 operation of the original transformed query block.
3264 */
3265 virtual Item *replace_item_field(uchar *) { return this; }
3266 virtual Item *replace_func_call(uchar *) { return this; }
3267 virtual Item *replace_item_view_ref(uchar *) { return this; }
3268 virtual Item *replace_aggregate(uchar *) { return this; }
3269 virtual Item *replace_outer_ref(uchar *) { return this; }
3270
3275 : m_target(target), m_owner(owner) {}
3276 };
3277
3278 /**
3279 A walker processor overridden by Item_aggregate_ref, q.v.
3280 */
3281 virtual bool update_aggr_refs(uchar *) { return false; }
3282
3283 /**
3284 Convert constant string in this object into the specified character set.
3285
3286 @param thd thread handler
3287 @param tocs target character set
3288 @param ignore_errors if true, ignore errors in conversion
3289
3290 @returns pointer to new Item containing converted character string
3291 = NULL: If conversion failed
3292 */
3293 Item *convert_charset(THD *thd, const CHARSET_INFO *tocs,
3294 bool ignore_errors = false);
3295
3296 /**
3297 Delete this item.
3298 Note that item must have been cleanup up by calling Item::cleanup().
3299 */
3300 void delete_self() { delete this; }
3301
3302 /** @return whether the item is local to a stored procedure */
3303 virtual bool is_splocal() const { return false; }
3304
3305 /*
3306 Return Settable_routine_parameter interface of the Item. Return 0
3307 if this Item is not Settable_routine_parameter.
3308 */
3310 return nullptr;
3311 }
3312 inline bool is_temporal_with_date() const {
3314 }
3317 }
3318 inline bool is_temporal_with_time() const {
3320 }
3321 inline bool is_temporal() const {
3323 }
3324 /**
3325 Check whether this and the given item has compatible comparison context.
3326 Used by the equality propagation. See Item_field::equal_fields_propagator.
3327
3328 @return
3329 true if the context is the same or if fields could be
3330 compared as DATETIME values by the Arg_comparator.
3331 false otherwise.
3332 */
3333 inline bool has_compatible_context(Item *item) const {
3334 // If no explicit context has been set, assume the same type as the item
3335 const Item_result this_context =
3337 const Item_result other_context = item->cmp_context == INVALID_RESULT
3338 ? item->result_type()
3339 : item->cmp_context;
3340
3341 // Check if both items have the same context
3342 if (this_context == other_context) {
3343 return true;
3344 }
3345 /* DATETIME comparison context. */
3347 return item->is_temporal_with_date() || other_context == STRING_RESULT;
3348 if (item->is_temporal_with_date())
3349 return is_temporal_with_date() || this_context == STRING_RESULT;
3350 return false;
3351 }
3353 return Field::GEOM_GEOMETRY;
3354 }
3355 String *check_well_formed_result(String *str, bool send_error, bool truncate);
3356 bool eq_by_collation(Item *item, const CHARSET_INFO *cs);
3357
3359 m_cost.Compute(*this);
3360 return m_cost;
3361 }
3362
3363 /**
3364 @return maximum number of characters that this Item can store
3365 If Item is of string or blob type, return max string length in bytes
3366 divided by bytes per character, otherwise return max_length.
3367 @todo - check if collation for other types should have mbmaxlen = 1
3368 */
3370 /*
3371 Length of e.g. 5.5e5 in an expression such as GREATEST(5.5e5, '5') is 5
3372 (length of that string) although length of the actual value is 6.
3373 Return MAX_DOUBLE_STR_LENGTH to prevent truncation of data without having
3374 to evaluate the value of the item.
3375 */
3376 const uint32 max_len =
3378 if (result_type() == STRING_RESULT)
3379 return max_len / collation.collation->mbmaxlen;
3380 return max_len;
3381 }
3382
3384 if (cs == &my_charset_bin && result_type() == STRING_RESULT) {
3385 return max_length;
3386 }
3387 return max_char_length();
3388 }
3389
3390 inline void fix_char_length(uint32 max_char_length_arg) {
3391 max_length = char_to_byte_length_safe(max_char_length_arg,
3393 }
3394
3395 /*
3396 Return true if the item points to a column of an outer-joined table.
3397 */
3398 virtual bool is_outer_field() const {
3399 assert(fixed);
3400 return false;
3401 }
3402
3403 /**
3404 Check if an item either is a blob field, or will be represented as a BLOB
3405 field if a field is created based on this item.
3406
3407 @retval true If a field based on this item will be a BLOB field,
3408 @retval false Otherwise.
3409 */
3410 bool is_blob_field() const;
3411
3412 /// @returns number of references to an item.
3413 uint reference_count() const { return m_ref_count; }
3414
3415 /// Increment reference count
3417 assert(!m_abandoned);
3418 ++m_ref_count;
3419 }
3420
3421 /// Decrement reference count
3423 assert(m_ref_count > 0);
3424 if (--m_ref_count == 0) m_abandoned = true;
3425 return m_ref_count;
3426 }
3427
3428 protected:
3429 /// Set accumulated properties for an Item
3430 void set_accum_properties(const Item *item) {
3432 }
3433
3434 /// Add more accumulated properties to an Item
3435 void add_accum_properties(const Item *item) {
3437 }
3438
3439 /// Set the "has subquery" property
3441
3442 /// Set the "has stored program" property
3444
3445 public:
3446 /// @return true if this item or any of its descendants contains a subquery.
3448
3449 /// @return true if this item or any of its descendants refers a stored func.
3450 bool has_stored_program() const {
3452 }
3453
3454 /// @return true if this item or any of its descendants is an aggregated func.
3456
3457 /// Set the "has aggregation" property
3459
3460 /// Reset the "has aggregation" property
3461 void reset_aggregation() { m_accum_properties &= ~PROP_AGGREGATION; }
3462
3463 /// @return true if this item or any of its descendants is a window func.
3465
3466 /// Set the "has window function" property
3468
3469 /**
3470 @return true if this item or any of its descendants within the same query
3471 has a reference to a GROUP BY modifier (such as ROLLUP)
3472 */
3475 }
3476
3477 /**
3478 Set the property: this item (tree) contains a reference to a GROUP BY
3479 modifier (such as ROLLUP)
3480 */
3483 }
3484
3485 /**
3486 @return true if this item or any of underlying items is a GROUPING function
3487 */
3488 bool has_grouping_func() const {
3490 }
3491
3492 /// Set the property: this item is a call to GROUPING
3494
3495 /// Whether this Item was created by the IN->EXISTS subquery transformation
3496 virtual bool created_by_in2exists() const { return false; }
3497
3499 if (has_subquery())
3501 }
3502
3503 /**
3504 Analyzer function for GC substitution. @see substitute_gc()
3505 */
3506 virtual bool gc_subst_analyzer(uchar **) { return false; }
3507 /**
3508 Transformer function for GC substitution. @see substitute_gc()
3509 */
3510 virtual Item *gc_subst_transformer(uchar *) { return this; }
3511
3512 /**
3513 A processor that replaces any Fields with a Create_field_wrapper. This
3514 will allow us to resolve functions during CREATE TABLE, where we only have
3515 Create_field available and not Field. Used for functional index
3516 implementation.
3517 */
3518 virtual bool replace_field_processor(uchar *) { return false; }
3519 /**
3520 Check if this item is of a type that is eligible for GC
3521 substitution. All items that belong to subclasses of Item_func are
3522 eligible for substitution. @see substitute_gc()
3523 Item_fields can also be eligible if they are given as an argument to
3524 a function that takes an array (the field can be substituted with a
3525 generated column that backs a multi-valued index on that field).
3526
3527 @param array true if the item is an argument to a function that takes an
3528 array, or false otherwise
3529 @return true if the expression is eligible for substitution, false otherwise
3530 */
3531 bool can_be_substituted_for_gc(bool array = false) const;
3532
3534 uint nitems);
3535 void aggregate_decimal_properties(Item **items, uint nitems);
3537 uint nitems);
3539 Item **items, uint nitems);
3540 void aggregate_bit_properties(Item **items, uint nitems);
3541
3542 /**
3543 This function applies only to Item_field objects referred to by an Item_ref
3544 object that has been marked as a const_item.
3545
3546 @param arg Keep track of whether an Item_ref refers to an Item_field.
3547 */
3548 virtual bool repoint_const_outer_ref(uchar *arg [[maybe_unused]]) {
3549 return false;
3550 }
3551 virtual bool strip_db_table_name_processor(uchar *) { return false; }
3552
3553 /**
3554 Compute the cost of evaluating this Item.
3555 @param root_cost The cost object to which the cost should be added.
3556 */
3557 virtual void compute_cost(CostOfItem *root_cost [[maybe_unused]]) const {}
3558
3559 bool is_abandoned() const { return m_abandoned; }
3560
3561 private:
3562 virtual bool subq_opt_away_processor(uchar *) { return false; }
3563
3564 public: // Start of data fields
3565 /**
3566 Intrusive list pointer for free list. If not null, points to the next
3567 Item on some Query_arena's free list. For instance, stored procedures
3568 have their own Query_arena's.
3569
3570 @see Query_arena::free_list
3571 */
3573
3574 protected:
3575 /// str_values's main purpose is to cache the value in save_in_field
3577
3578 public:
3579 /**
3580 Character set and collation properties assigned for this Item.
3581 Used if Item represents a character string expression.
3582 */
3584 Item_name_string item_name; ///< Name from query
3585 Item_name_string orig_name; ///< Original item name (if it was renamed)
3586 /**
3587 Maximum length of result of evaluating this item, in number of bytes.
3588 - For character or blob data types, max char length multiplied by max
3589 character size (collation.mbmaxlen).
3590 - For decimal type, it is the precision in digits plus sign (unless
3591 unsigned) plus decimal point (unless it has zero decimals).
3592 - For other numeric types, the default or specific display length.
3593 - For date/time types, the display length (10 for DATE, 10 + optional FSP
3594 for TIME, 19 + optional fsp for datetime/timestamp).
3595 - For bit, the number of bits.
3596 - For enum, the string length of the widest enum element.
3597 - For set, the sum of the string length of each set element plus separators.
3598 - For geometry, the maximum size of a BLOB (it's underlying storage type).
3599 - For json, the maximum size of a BLOB (it's underlying storage type).
3600 */
3601 uint32 max_length; ///< Maximum length, in bytes
3602 enum item_marker ///< Values for member 'marker'
3603 {
3605 /// When contextualization or itemization adds an implicit comparison '0<>'
3606 /// (see make_condition()), to record that this Item_func_ne was created for
3607 /// this purpose; this value is tested during resolution.
3609 /// When doing constant propagation (e.g. change_cond_ref_to_const(), to
3610 /// remember that we have already processed the item.
3612 /// When creating an internal temporary table: says how to store BIT fields.
3614 /// When analyzing functional dependencies for only_full_group_by (says
3615 /// whether a nullable column can be treated at not nullable).
3617 /// When we change DISTINCT to GROUP BY: used for book-keeping of
3618 /// fields.
3620 /// When pushing conditions down to derived table: it says a condition
3621 /// contains only derived table's columns.
3623 /// Used during traversal to avoid deleting an item twice.
3625 /// When pushing index conditions: it says whether a condition uses only
3626 /// indexed columns.
3629 /**
3630 This member has several successive meanings, depending on the phase we're
3631 in (@see item_marker).
3632 The important property is that a phase must have a value (or few values)
3633 which is reserved for this phase. If it wants to set "marked", it assigns
3634 the value; it it wants to test if it is marked, it tests marker !=
3635 value. If the value has been assigned and the phase wants to cancel it can
3636 set marker to MARKER_NONE, which is a magic number which no phase
3637 reserves.
3638 A phase can expect 'marker' to be MARKER_NONE at the start of execution of
3639 a normal statement, at the start of preparation of a PS, and at the start
3640 of execution of a PS.
3641 A phase should not expect marker's value to survive after the phase's
3642 end - as a following phase may change it.
3643 */
3645 Item_result cmp_context; ///< Comparison context
3646 private:
3647 /**
3648 Number of references to this item. It is used for two purposes:
3649 1. When eliminating redundant expressions, the reference count is used
3650 to tell how many Item_ref objects that point to an item. When a
3651 sub-tree of items is eliminated, it is traversed and any item that
3652 is referenced from an Item_ref has its reference count decremented.
3653 Only when the reference count reaches zero is the item actually deleted.
3654 2. Keeping track of unused expressions selected from merged derived tables.
3655 An item that is added to the select list of a query block has its
3656 reference count set to 1. Any references from outer query blocks are
3657 through Item_ref objects, thus they will cause the reference count
3658 to be incremented. At end of resolving, the reference counts of all
3659 items in select list of merged derived tables are decremented, thus
3660 if the reference count becomes zero, the expression is known to
3661 be unused and can be removed.
3662 */
3664 bool m_abandoned{false}; ///< true if item has been fully de-referenced
3665 const bool is_parser_item; ///< true if allocated directly by parser
3666 uint8 m_data_type; ///< Data type assigned to Item
3667
3668 /**
3669 The cost of evaluating this item. This is only needed for predicates,
3670 therefore we use lazy evaluation.
3671 */
3673
3674 public:
3675 bool fixed; ///< True if item has been resolved
3676 /**
3677 Number of decimals in result when evaluating this item
3678 - For integer type, always zero.
3679 - For decimal type, number of decimals.
3680 - For float type, it may be DECIMAL_NOT_SPECIFIED
3681 - For time, datetime and timestamp, number of decimals in fractional second
3682 - For string types, may be decimals of cast source or DECIMAL_NOT_SPECIFIED
3683 */
3685
3686 bool is_nullable() const { return m_nullable; }
3687 void set_nullable(bool nullable) { m_nullable = nullable; }
3688
3689 private:
3690 /**
3691 True if this item may hold the NULL value(if null_value may be set to true).
3692
3693 For items that represent rows, it is true if one of the columns
3694 may be null.
3695
3696 For items that represent scalar or row subqueries, it is true if
3697 one of the returned columns could be null, or if the subquery
3698 could return zero rows.
3699
3700 It is worth noting that this information is correct only until
3701 equality propagation has been run by the optimization phase.
3702 Indeed, consider:
3703 select * from t1, t2,t3 where t1.pk=t2.a and t1.pk+1...
3704 the '+' is not nullable as t1.pk is not nullable;
3705 but if the optimizer chooses plan is t2-t3-t1, then, due to equality
3706 propagation it will replace t1.pk in '+' with t2.a (as t2 is before t1
3707 in plan), making the '+' capable of returning NULL when t2.a is NULL.
3708 */
3710
3711 public:
3712 bool null_value; ///< True if item is null
3714 bool m_is_window_function; ///< True if item represents window func
3715 /**
3716 If the item is in a SELECT list (Query_block::fields) and hidden is true,
3717 the item wasn't actually in the list as given by the user (it was added
3718 by the optimizer, to e.g. make sure it was part of a given
3719 materialization), and should not be returned in the actual result.
3720
3721 If the item is not in a SELECT list, the value is irrelevant.
3722 */
3723 bool hidden{false};
3724 /**
3725 True if item is a top most element in the expression being
3726 evaluated for a check constraint.
3727 */
3729
3730 protected:
3731 /**
3732 Set of properties that are calculated by accumulation from underlying items.
3733 Computed by constructors and fix_fields() and updated by
3734 update_used_tables(). The properties are accumulated up to the root of the
3735 current item tree, except they are not accumulated across subqueries and
3736 functions.
3737 */
3738 static constexpr uint8 PROP_SUBQUERY = 0x01;
3739 static constexpr uint8 PROP_STORED_PROGRAM = 0x02;
3740 static constexpr uint8 PROP_AGGREGATION = 0x04;
3741 static constexpr uint8 PROP_WINDOW_FUNCTION = 0x08;
3742 /**
3743 Set if the item or one or more of the underlying items contains a
3744 GROUP BY modifier (such as ROLLUP).
3745 */
3746 static constexpr uint8 PROP_HAS_GROUPING_SET_DEP = 0x10;
3747 /**
3748 Set if the item or one or more of the underlying items is a GROUPING
3749 function.
3750 */
3751 static constexpr uint8 PROP_GROUPING_FUNC = 0x20;
3752
3754
3755 public:
3756 /**
3757 Check if this expression can be used for partial update of a given
3758 JSON column.
3759
3760 For example, the expression `JSON_REPLACE(col, '$.foo', 'bar')`
3761 can be used to partially update the column `col`.
3762
3763 @param field the JSON column that is being updated
3764 @return true if this expression can be used for partial update,
3765 false otherwise
3766 */
3767 virtual bool supports_partial_update(const Field_json *field
3768 [[maybe_unused]]) const {
3769 return false;
3770 }
3771
3772 /**
3773 Whether the item returns array of its data type
3774 */
3775 virtual bool returns_array() const { return false; }
3776
3777 /**
3778 A helper function to ensure proper usage of CAST(.. AS .. ARRAY)
3779 */
3780 virtual void allow_array_cast() {}
3781};
3782
3783/**
3784 Descriptor of what and how to cache for
3785 Item::cache_const_expr_transformer/analyzer.
3786
3787*/
3788
3790 /// Path from the expression's top to the current item in item tree
3791 /// used to track parent of current item for caching JSON data
3793 /// Item to cache. Used as a binary flag, but kept as Item* for assertion
3794 Item *cache_item{nullptr};
3795 /// How to cache JSON data. @see Item::enum_const_item_cache
3797};
3798
3799/**
3800 A helper class to give in a functor to Item::walk(). Use as e.g.:
3801
3802 bool result = WalkItem(root_item, enum_walk::POSTFIX, [](Item *item) { ... });
3803
3804 TODO: Make Item::walk() just take in a functor in the first place, instead of
3805 a pointer-to-member and an opaque argument.
3806 */
3807template <class T>
3808inline bool WalkItem(Item *item, enum_walk walk, T &&functor) {
3809 return item->walk(&Item::walk_helper_thunk<T>, walk,
3810 reinterpret_cast<uchar *>(&functor));
3811}
3812
3813/**
3814 Overload for const 'item' and functor taking 'const Item*' argument.
3815*/
3816template <class T>
3817inline bool WalkItem(const Item *item, enum_walk walk, T &&functor) {
3818 auto to_const = [&](const Item *descendant) { return functor(descendant); };
3819 return WalkItem(const_cast<Item *>(item), walk, to_const);
3820}
3821
3822/**
3823 Same as WalkItem, but for Item::compile(). Use as e.g.:
3824
3825 Item *item = CompileItem(root_item,
3826 [](Item *item) { return true; }, // Analyzer.
3827 [](Item *item) { return item; }); // Transformer.
3828 */
3829template <class T, class U>
3830inline Item *CompileItem(Item *item, T &&analyzer, U &&transformer) {
3831 uchar *analyzer_ptr = reinterpret_cast<uchar *>(&analyzer);
3832 return item->compile(&Item::analyze_helper_thunk<T>, &analyzer_ptr,
3833 &Item::walk_helper_thunk<U>,
3834 reinterpret_cast<uchar *>(&transformer));
3835}
3836
3837/**
3838 Same as WalkItem, but for Item::transform(). Use as e.g.:
3839
3840 Item *item = TransformItem(root_item, [](Item *item) { return item; });
3841 */
3842template <class T>
3843Item *TransformItem(Item *item, T &&transformer) {
3844 return item->transform(&Item::walk_helper_thunk<T>,
3845 pointer_cast<uchar *>(&transformer));
3846}
3847
3850
3851 public:
3853 explicit Item_basic_constant(const POS &pos) : Item(pos), used_table_map(0) {}
3854
3855 /// @todo add implementation of basic_const_item
3856 /// and remove from subclasses as appropriate.
3857
3859 table_map used_tables() const override { return used_table_map; }
3860 bool check_function_as_value_generator(uchar *) override { return false; }
3861 /* to prevent drop fixed flag (no need parent cleanup call) */
3862 void cleanup() override {
3863 // @todo We should ensure we never change "basic constant" nodes.
3864 // We should then be able to add this assert:
3865 // assert(marker == MARKER_NONE);
3866 // and remove the call to Item::cleanup()
3867 Item::cleanup();
3868 }
3869 bool basic_const_item() const override { return true; }
3871};
3872
3873/*****************************************************************************
3874 The class is a base class for representation of stored routine variables in
3875 the Item-hierarchy. There are the following kinds of SP-vars:
3876 - local variables (Item_splocal);
3877 - CASE expression (Item_case_expr);
3878*****************************************************************************/
3879
3880class Item_sp_variable : public Item {
3881 public:
3883
3884 public:
3885#ifndef NDEBUG
3886 /*
3887 Routine to which this Item_splocal belongs. Used for checking if correct
3888 runtime context is used for variable handling.
3889 */
3890 sp_head *m_sp{nullptr};
3891#endif
3892
3893 public:
3894 Item_sp_variable(const Name_string sp_var_name);
3895
3896 table_map used_tables() const override { return INNER_TABLE_BIT; }
3897 bool fix_fields(THD *thd, Item **) override;
3898
3899 double val_real() override;
3900 longlong val_int() override;
3901 String *val_str(String *sp) override;
3902 my_decimal *val_decimal(my_decimal *decimal_value) override;
3903 bool val_json(Json_wrapper *result) override;
3904 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
3905 bool get_time(MYSQL_TIME *ltime) override;
3906 bool is_null() override;
3907
3908 public:
3909 inline void make_field(Send_field *field) override;
3910 bool send(Protocol *protocol, String *str) override {
3911 // Need to override send() in case this_item() is an Item_field with a
3912 // ZEROFILL attribute.
3913 return this_item()->send(protocol, str);
3914 }
3915 bool is_valid_for_pushdown(uchar *arg [[maybe_unused]]) override {
3916 // It is ok to push down a condition like "column > SP_variable"
3917 return false;
3918 }
3919
3920 protected:
3922 Field *field, bool no_conversions) override;
3923};
3924
3925/*****************************************************************************
3926 Item_sp_variable inline implementation.
3927*****************************************************************************/
3928
3930 Item *it = this_item();
3932 it->make_field(field);
3933}
3934
3936 Field *field, bool no_conversions) {
3937 return this_item()->save_in_field(field, no_conversions);
3938}
3939
3940/*****************************************************************************
3941 A reference to local SP variable (incl. reference to SP parameter), used in
3942 runtime.
3943*****************************************************************************/
3944
3945class Item_splocal final : public Item_sp_variable,
3948
3949 public:
3950 /*
3951 If this variable is a parameter in LIMIT clause.
3952 Used only during NAME_CONST substitution, to not append
3953 NAME_CONST to the resulting query and thus not break
3954 the slave.
3955 */
3957 /*
3958 Position of this reference to SP variable in the statement (the
3959 statement itself is in sp_instr_stmt::m_query).
3960 This is valid only for references to SP variables in statements,
3961 excluding DECLARE CURSOR statement. It is used to replace references to SP
3962 variables with NAME_CONST calls when putting statements into the binary
3963 log.
3964 Value of 0 means that this object doesn't corresponding to reference to
3965 SP variable in query text.
3966 */
3968 /*
3969 Byte length of SP variable name in the statement (see pos_in_query).
3970 The value of this field may differ from the name_length value because
3971 name_length contains byte length of UTF8-encoded item name, but
3972 the query string (see sp_instr_stmt::m_query) is currently stored with
3973 a charset from the SET NAMES statement.
3974 */
3976
3977 Item_splocal(const Name_string sp_var_name, uint sp_var_idx,
3978 enum_field_types sp_var_type, uint pos_in_q = 0,
3979 uint len_in_q = 0);
3980
3981 bool is_splocal() const override { return true; }
3982
3983 Item *this_item() override;
3984 const Item *this_item() const override;
3985 Item **this_item_addr(THD *thd, Item **) override;
3986
3987 void print(const THD *thd, String *str,
3988 enum_query_type query_type) const override;
3989
3990 public:
3991 uint get_var_idx() const { return m_var_idx; }
3992
3993 Type type() const override { return ROUTINE_FIELD_ITEM; }
3994 Item_result result_type() const override {
3995 return type_to_result(data_type());
3996 }
3997 bool val_json(Json_wrapper *result) override;
3998
3999 private:
4000 bool set_value(THD *thd, sp_rcontext *ctx, Item **it) override;
4001
4002 public:
4004 return this;
4005 }
4006};
4007
4008/*****************************************************************************
4009 A reference to case expression in SP, used in runtime.
4010*****************************************************************************/
4011
4012class Item_case_expr final : public Item_sp_variable {
4013 public:
4014 Item_case_expr(uint case_expr_id);
4015
4016 public:
4017 Item *this_item() override;
4018 const Item *this_item() const override;
4019 Item **this_item_addr(THD *thd, Item **) override;
4020
4021 Type type() const override { return this_item()->type(); }
4022 Item_result result_type() const override {
4023 return this_item()->result_type();
4024 }
4025 /*
4026 NOTE: print() is intended to be used from views and for debug.
4027 Item_case_expr can not occur in views, so here it is only for debug
4028 purposes.
4029 */
4030 void print(const THD *thd, String *str,
4031 enum_query_type query_type) const override;
4032
4033 private:
4035};
4036
4037/*
4038 NAME_CONST(given_name, const_value).
4039 This 'function' has all properties of the supplied const_value (which is
4040 assumed to be a literal constant), and the name given_name.
4041
4042 This is used to replace references to SP variables when we write PROCEDURE
4043 statements into the binary log.
4044
4045 TODO
4046 Together with Item_splocal and Item::this_item() we can actually extract
4047 common a base of this class and Item_splocal. Maybe it is possible to
4048 extract a common base with class Item_ref, too.
4049*/
4050
4051class Item_name_const final : public Item {
4052 typedef Item super;
4053
4057
4058 public:
4059 Item_name_const(const POS &pos, Item *name_arg, Item *val);
4060
4061 bool do_itemize(Parse_context *pc, Item **res) override;
4062 bool fix_fields(THD *, Item **) override;
4063
4064 enum Type type() const override { return NAME_CONST_ITEM; }
4065 double val_real() override;
4066 longlong val_int() override;
4067 String *val_str(String *sp) override;
4068 my_decimal *val_decimal(my_decimal *) override;
4069 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
4070 bool get_time(MYSQL_TIME *ltime) override;
4071 bool is_null() override;
4072 void print(const THD *thd, String *str,
4073 enum_query_type query_type) const override;
4074
4075 Item_result result_type() const override { return value_item->result_type(); }
4076
4078 // Item_name_const always wraps a literal, so there is no need to cache it.
4079 return false;
4080 }
4081
4082 protected:
4084 bool no_conversions) override {
4085 return value_item->save_in_field(field, no_conversions);
4086 }
4087};
4088
4089bool convert_const_strings(DTCollation &coll, Item **args, uint nargs,
4090 int item_sep);
4092 Item **items, uint nitems, uint flags);
4093bool agg_item_charsets(DTCollation &c, const char *name, Item **items,
4094 uint nitems, uint flags, int item_sep);
4096 const char *name, Item **items,
4097 uint nitems, int item_sep = 1) {
4098 const uint flags = MY_COLL_ALLOW_SUPERSET_CONV |
4100 return agg_item_charsets(c, name, items, nitems, flags, item_sep);
4101}
4103 Item **items, uint nitems,
4104 int item_sep = 1) {
4105 const uint flags = MY_COLL_ALLOW_SUPERSET_CONV |
4107 return agg_item_charsets(c, name, items, nitems, flags, item_sep);
4108}
4109
4112
4113 public:
4115 explicit Item_num(const POS &pos) : super(pos) { collation.set_numeric(); }
4116
4117 virtual Item_num *neg() = 0;
4118 bool check_partition_func_processor(uchar *) override { return false; }
4119};
4120
4121inline constexpr uint16 NO_FIELD_INDEX((uint16)(-1));
4122
4123class Item_ident : public Item {
4124 typedef Item super;
4125
4126 protected:
4127 /**
4128 The fields m_orig_db_name, m_orig_table_name and m_orig_field_name are
4129 maintained so that we can provide information about the origin of a
4130 column that may have been renamed within the query, e.g. as required by
4131 connectors.
4132
4133 Names the original schema of the table that is the source of the field.
4134 If field is from
4135 - a non-aliased base table, the same as db_name.
4136 - an aliased base table, the name of the schema of the base table.
4137 - an expression (including aggregation), a NULL pointer.
4138 - a derived table, the name of the schema of the underlying base table.
4139 - a view, the name of the schema of the underlying base table.
4140 - a temporary table (in optimization stage), the name of the schema of
4141 the source base table.
4142 */
4143 const char *m_orig_db_name;
4144 /**
4145 Names the original table that is the source of the field. If field is from
4146 - a non-aliased base table, the same as table_name.
4147 - an aliased base table, the name of the base table.
4148 - an expression (including aggregation), a NULL pointer.
4149 - a derived table, the name of the underlying base table.
4150 - a view, the name of the underlying base table.
4151 - a temporary table (in optimization stage), the name of the source base tbl
4152 */
4154 /**
4155 Names the field in the source base table. If field is from
4156 - an expression, a NULL pointer.
4157 - a view or base table and is not aliased, the same as field_name.
4158 - a view or base table and is aliased, the column name of the view or
4159 base table.
4160 - a derived table, the column name of the underlying base table.
4161 - a temporary table (in optimization stage), the name of the source column.
4162 */
4164 bool m_alias_of_expr; ///< if this Item's name is alias of SELECT expression
4165
4166 public:
4167 /**
4168 For regularly resolved column references, 'context' points to a name
4169 resolution context object belonging to the query block which simply
4170 contains the reference. To further clarify, in
4171 SELECT (SELECT t.a) FROM t;
4172 t.a is an Item_ident whose 'context' belongs to the subquery
4173 (context->query_block == that of the subquery).
4174 For column references that are part of a generated column expression,
4175 'context' points to a temporary name resolution context object during
4176 resolving, but is set to nullptr after resolving is done. Note that
4177 Item_ident::local_column() depends on that.
4178 */
4180 /**
4181 Schema name of the base table or view the column is part of.
4182 If an expression, a NULL pointer.
4183 If from a derived table, a NULL pointer.
4184 */
4185 const char *db_name;
4186 /**
4187 If column is from a non-aliased base table or view, name of base table or
4188 view.
4189 If column is from an aliased base table or view, the alias name.
4190 If column is from a derived table, the name of the derived table.
4191 If column is from an expression, a NULL pointer.
4192 */
4193 const char *table_name;
4194 /**
4195 If column is aliased, the column alias name.
4196 If column is from a non-aliased base table or view, the name of the
4197 column in that base table or view.
4198 If column is from an expression, a string generated from that expression.
4199
4200 Notice that a column can be aliased in two ways:
4201 1. With an explicit column alias, or @<as clause@>, or
4202 2. With only a column name specified, which differs from the table's
4203 column name due to case insensitivity.
4204 In both cases field_name will differ from m_orig_field_name.
4205 field_name is normally identical to Item::item_name.
4206 */
4207 const char *field_name;
4208 /**
4209 Points to the Table_ref object of the table or view that the column or
4210 reference is resolved against (only valid after resolving).
4211 Notice that for the following types of "tables", no Table_ref object is
4212 assigned and hence m_table_ref is NULL:
4213 - Temporary tables assigned by join optimizer for sorting and aggregation.
4214 - Stored procedure dummy tables.
4215 For fields referencing such tables, table number is always 0, and other
4216 uses of m_table_ref is not needed.
4217 */
4219 /**
4220 For a column or reference that is an outer reference, depended_from points
4221 to the qualifying query block, otherwise it is NULL
4222 (only valid after resolving).
4223 */
4225
4226 Item_ident(Name_resolution_context *context_arg, const char *db_name_arg,
4227 const char *table_name_arg, const char *field_name_arg)
4228 : m_orig_db_name(db_name_arg),
4229 m_orig_table_name(table_name_arg),
4230 m_orig_field_name(field_name_arg),
4231 m_alias_of_expr(false),
4232 context(context_arg),
4233 db_name(db_name_arg),
4234 table_name(table_name_arg),
4235 field_name(field_name_arg) {
4236 item_name.set(field_name_arg);
4237 }
4238
4239 Item_ident(const POS &pos, const char *db_name_arg,
4240 const char *table_name_arg, const char *field_name_arg)
4241 : super(pos),
4242 m_orig_db_name(db_name_arg),
4243 m_orig_table_name(table_name_arg),
4244 m_orig_field_name(field_name_arg),
4245 m_alias_of_expr(false),
4246 db_name(db_name_arg),
4247 table_name(table_name_arg),
4248 field_name(field_name_arg) {
4249 item_name.set(field_name_arg);
4250 }
4251
4252 /// Constructor used by Item_field & Item_*_ref (see Item comment)
4253
4255 : Item(thd, item),
4260 context(item->context),
4261 db_name(item->db_name),
4262 table_name(item->table_name),
4263 field_name(item->field_name),
4264 m_table_ref(item->m_table_ref),
4266
4267 bool do_itemize(Parse_context *pc, Item **res) override;
4268
4269 const char *full_name() const override;
4270 void set_orignal_db_name(const char *name_arg) { m_orig_db_name = name_arg; }
4271 void set_original_table_name(const char *name_arg) {
4272 m_orig_table_name = name_arg;
4273 }
4274 void set_original_field_name(const char *name_arg) {
4275 m_orig_field_name = name_arg;
4276 }
4277 const char *original_db_name() const { return m_orig_db_name; }
4278 const char *original_table_name() const { return m_orig_table_name; }
4279 const char *original_field_name() const { return m_orig_field_name; }
4280 void fix_after_pullout(Query_block *parent_query_block,
4281 Query_block *removed_query_block) override;
4282 bool aggregate_check_distinct(uchar *arg) override;
4283 bool aggregate_check_group(uchar *arg) override;
4284 Bool3 local_column(const Query_block *sl) const override;
4285
4286 void print(const THD *thd, String *str,
4287 enum_query_type query_type) const override {
4288 print(thd, str, query_type, db_name, table_name);
4289 }
4290
4291 protected:
4292 /**
4293 Function to print column name for a table
4294
4295 To print a column for a permanent table (picks up database and table from
4296 Item_ident object):
4297
4298 item->print(str, qt)
4299
4300 To print a column for a temporary table:
4301
4302 item->print(str, qt, specific_db, specific_table)
4303
4304 Items of temporary table fields have empty/NULL values of table_name and
4305 db_name. To print column names in a 3D form (`database`.`table`.`column`),
4306 this function prints db_name_arg and table_name_arg parameters instead of
4307 this->db_name and this->table_name respectively.
4308
4309 @param thd Thread handle.
4310 @param [out] str Output string buffer.
4311 @param query_type Bitmap to control printing details.
4312 @param db_name_arg String to output as a column database name.
4313 @param table_name_arg String to output as a column table name.
4314 */
4315 void print(const THD *thd, String *str, enum_query_type query_type,
4316 const char *db_name_arg, const char *table_name_arg) const;
4317
4318 public:
4319 ///< Argument object to change_context_processor
4323 };
4324 bool change_context_processor(uchar *arg) override {
4325 context = reinterpret_cast<Change_context *>(arg)->m_context;
4326 return false;
4327 }
4328
4329 /// @returns true if this Item's name is alias of SELECT expression
4330 bool is_alias_of_expr() const { return m_alias_of_expr; }
4331 /// Marks that this Item's name is alias of SELECT expression
4333
4334 /**
4335 Argument structure for walk processor Item::update_depended_from
4336 */
4338 Query_block *old_depended_from; // the transformed query block
4339 Query_block *new_depended_from; // the new derived table for grouping
4340 };
4341
4342 bool update_depended_from(uchar *) override;
4343
4344 /**
4345 @returns true if a part of this Item's full name (name or table name) is
4346 an alias.
4347 */
4348 virtual bool alias_name_used() const { return m_alias_of_expr; }
4350 const char *db_name, const char *table_name,
4352 bool any_privileges);
4353 bool is_strong_side_column_not_in_fd(uchar *arg) override;
4354 bool is_column_not_in_fd(uchar *arg) override;
4355};
4356
4357class Item_ident_for_show final : public Item {
4358 public:
4360 const char *db_name;
4361 const char *table_name;
4362
4363 Item_ident_for_show(Field *par_field, const char *db_arg,
4364 const char *table_name_arg)
4365 : field(par_field), db_name(db_arg), table_name(table_name_arg) {}
4366
4367 enum Type type() const override { return FIELD_ITEM; }
4368 bool fix_fields(THD *thd, Item **ref) override;
4369 double val_real() override { return field->val_real(); }
4370 longlong val_int() override { return field->val_int(); }
4371 String *val_str(String *str) override { return field->val_str(str); }
4373 return field->val_decimal(dec);
4374 }
4375 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override {
4376 return field->get_date(ltime, fuzzydate);
4377 }
4378 bool get_time(MYSQL_TIME *ltime) override { return field->get_time(ltime); }
4379 void make_field(Send_field *tmp_field) override;
4381 return field->charset_for_protocol();
4382 }
4383};
4384
4385class Item_field : public Item_ident {
4387
4388 protected:
4389 void set_field(Field *field);
4390 void fix_after_pullout(Query_block *parent_query_block,
4391 Query_block *removed_query_block) override {
4392 super::fix_after_pullout(parent_query_block, removed_query_block);
4393
4394 // Update nullability information, as the table may have taken over
4395 // null_row status from the derived table it was part of.
4397 field->table->is_nullable());
4398 }
4400 bool no_conversions) override;
4401
4402 public:
4403 /// Source field
4404 Field *field{nullptr};
4405
4406 private:
4407 /// Result field
4409
4410 // save_in_field() and save_org_in_field() are often called repeatedly
4411 // with the same destination field (although the destination for the
4412 // two are distinct, thus two distinct caches). We detect this case by
4413 // storing the last destination, and whether it was of a compatible type
4414 // that we can memcpy into (see fields_are_memcpyable()). This saves time
4415 // doing the same type checking over and over again.
4416 //
4417 // The _memcpyable fields are uint32_t(-1) if the fields are not memcpyable,
4418 // and pack_length() (ie., the amount of bytes to copy) if they are.
4419 // See field_conv_with_cache(), where this logic is encapsulated.
4424
4425 /**
4426 If this field is derived from another field, e.g. it is reading a column
4427 from a temporary table which is populated from a base table, this member
4428 points to the field used to populate the temporary table column.
4429 */
4431
4432 /**
4433 State used for transforming scalar subqueries to JOINs with derived tables,
4434 cf. \c transform_grouped_to_derived. Has accessor.
4435 */
4437
4438 /**
4439 Holds a list of items whose values must be equal to the value of
4440 this field, during execution.
4441
4442 Used during optimization to perform multiple equality analysis,
4443 this analysis should be performed during preparation instead, so that
4444 Item_field can be const after preparation.
4445 */
4447
4448 public:
4449 /**
4450 Index for this field in table->field array. Holds NO_FIELD_INDEX
4451 if index value is not known.
4452 */
4455
4457 assert(item_equal != nullptr);
4458 item_equal_all_join_nests = item_equal;
4459 }
4460
4461 // A list of fields that are considered "equal" to this field. E.g., a query
4462 // on the form "a JOIN b ON a.i = b.i JOIN c ON b.i = c.i" would consider
4463 // a.i, b.i and c.i equal due to equality propagation. This is the same as
4464 // "item_equal" above, except that "item_equal" will only contain fields from
4465 // the same join nest. This is used by hash join and BKA when they need to
4466 // undo multi-equality propagation done by the optimizer. (The optimizer may
4467 // generate join conditions that references unreachable fields for said
4468 // iterators.) The split is done because NDB expects the list to only
4469 // contain fields from the same join nest.
4471 /// If true, the optimizer's constant propagation will not replace this item
4472 /// with an equal constant.
4474 /*
4475 if any_privileges set to true then here real effective privileges will
4476 be stored
4477 */
4479 /* field need any privileges (for VIEW creation) */
4480 bool any_privileges{false};
4481 /*
4482 if this field is used in a context where covering prefix keys
4483 are supported.
4484 */
4486 Item_field(Name_resolution_context *context_arg, const char *db_arg,
4487 const char *table_name_arg, const char *field_name_arg);
4488 Item_field(const POS &pos, const char *db_arg, const char *table_name_arg,
4489 const char *field_name_arg);
4490 Item_field(THD *thd, Item_field *item);
4491 Item_field(THD *thd, Name_resolution_context *context_arg, Field *field);
4493
4494 bool do_itemize(Parse_context *pc, Item **res) override;
4495
4496 enum Type type() const override { return FIELD_ITEM; }
4497 bool eq(const Item *item) const override;
4498 double val_real() override;
4499 longlong val_int() override;
4500 longlong val_time_temporal() override;
4501 longlong val_date_temporal() override;
4504 my_decimal *val_decimal(my_decimal *) override;
4505 String *val_str(String *) override;
4506 bool val_json(Json_wrapper *result) override;
4507 bool send(Protocol *protocol, String *str_arg) override;
4508 void reset_field(Field *f);
4509 bool fix_fields(THD *, Item **) override;
4510 void make_field(Send_field *tmp_field) override;
4511 void save_org_in_field(Field *field) override;
4512 table_map used_tables() const override;
4513 Item_result result_type() const override { return field->result_type(); }
4516 }
4517 TYPELIB *get_typelib() const override;
4519 return field->cast_to_int_type();
4520 }
4523 }
4524 longlong val_int_endpoint(bool left_endp, bool *incl_endp) override;
4525 void set_result_field(Field *field_arg) override { result_field = field_arg; }
4527 Field *tmp_table_field(TABLE *) override { return result_field; }
4530 item->base_item_field() != nullptr ? item->base_item_field() : item;
4531 }
4533 return m_base_item_field ? m_base_item_field : this;
4534 }
4535 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) override;
4536 bool get_time(MYSQL_TIME *ltime) override;
4537 bool get_timeval(my_timeval *tm, int *warnings) override;
4538 bool is_null() override {
4539 // NOTE: May return true even if maybe_null is not set!
4540 // This can happen if the underlying TABLE did not have a NULL row
4541 // at set_field() time (ie., table->is_null_row() was false),
4542 // but does now.
4543 return field->is_null();
4544 }
4545 Item *get_tmp_table_item(THD *thd) override;
4546 bool collect_item_field_processor(uchar *arg) override;
4547 bool collect_item_field_or_ref_processor(uchar *arg) override;
4549 bool collect_outer_field_processor(uchar *arg) override;
4550 bool add_field_to_set_processor(uchar *arg) override;
4551 bool add_field_to_cond_set_processor(uchar *) override;
4552 bool remove_column_from_bitmap(uchar *arg) override;
4553 bool find_item_in_field_list_processor(uchar *arg) override;
4554 bool find_field_processor(uchar *arg) override {
4555 return pointer_cast<Field *>(arg) == field;
4556 }
4557 bool check_function_as_value_generator(uchar *args) override;
4558 bool mark_field_in_map(uchar *arg) override {
4559 auto mark_field = pointer_cast<Mark_field *>(arg);
4560 bool rc = Item::mark_field_in_map(mark_field, field);
4562 rc |= Item::mark_field_in_map(mark_field, result_field);
4563 return rc;
4564 }
4565 bool used_tables_for_level(uchar *arg) override;
4566 bool check_column_privileges(uchar *arg) override;
4567 bool check_partition_func_processor(uchar *) override { return false; }
4568 void bind_fields() override;
4569 bool is_valid_for_pushdown(uchar *arg) override;
4570 bool check_column_in_window_functions(uchar *arg) override;
4571 bool check_column_in_group_by(uchar *arg) override;
4572 Item *replace_with_derived_expr(uchar *arg) override;
4574 void cleanup() override;
4575 void reset_field();
4576 Item_multi_eq *find_multi_equality(COND_EQUAL *cond_equal) const;
4577 bool subst_argument_checker(uchar **arg) override;
4578 Item *equal_fields_propagator(uchar *arg) override;
4579 Item *replace_item_field(uchar *) override;
4580 bool