MySQL 8.4.3
Source Code Documentation
sql_lex.h
Go to the documentation of this file.
1/* Copyright (c) 2000, 2024, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is designed to work with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have either included with
13 the program or referenced in the documentation.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License, version 2.0, for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
23
24/**
25 @defgroup GROUP_PARSER Parser
26 @{
27*/
28
29#ifndef SQL_LEX_INCLUDED
30#define SQL_LEX_INCLUDED
31
32#include <string.h>
33#include <sys/types.h> // TODO: replace with cstdint
34
35#include <algorithm>
36#include <cstdint>
37#include <cstring>
38#include <functional>
39#include <map>
40#include <memory>
41#include <new>
42#include <string>
43#include <utility>
44
45#include "lex_string.h"
46#include "map_helpers.h"
47#include "mem_root_deque.h"
48#include "memory_debugging.h"
49#include "my_alloc.h" // Destroy_only
50#include "my_base.h"
51#include "my_compiler.h"
52#include "my_dbug.h"
53#include "my_inttypes.h" // TODO: replace with cstdint
54#include "my_sqlcommand.h"
55#include "my_sys.h"
56#include "my_table_map.h"
57#include "my_thread_local.h"
59#include "mysql/service_mysql_alloc.h" // my_free
61#include "mysql_com.h"
62#include "mysqld_error.h"
63#include "prealloced_array.h" // Prealloced_array
64#include "sql/dd/info_schema/table_stats.h" // dd::info_schema::Table_stati...
65#include "sql/dd/info_schema/tablespace_stats.h" // dd::info_schema::Tablesp...
66#include "sql/enum_query_type.h"
67#include "sql/handler.h"
68#include "sql/item.h" // Name_resolution_context
69#include "sql/item_subselect.h" // Subquery_strategy
72#include "sql/key_spec.h" // KEY_CREATE_INFO
73#include "sql/mdl.h"
74#include "sql/mem_root_array.h" // Mem_root_array
75#include "sql/parse_location.h"
76#include "sql/parse_tree_node_base.h" // enum_parsing_context
77#include "sql/parser_yystype.h"
78#include "sql/query_options.h" // OPTION_NO_CONST_TABLES
79#include "sql/query_term.h"
80#include "sql/set_var.h"
81#include "sql/sql_array.h"
82#include "sql/sql_connect.h" // USER_RESOURCES
83#include "sql/sql_const.h"
84#include "sql/sql_data_change.h" // enum_duplicates
85#include "sql/sql_error.h" // warn_on_deprecated_charset
86#include "sql/sql_list.h"
87#include "sql/sql_plugin_ref.h"
88#include "sql/sql_servers.h" // Server_options
89#include "sql/sql_udf.h" // Item_udftype
90#include "sql/table.h" // Table_ref
91#include "sql/thr_malloc.h"
92#include "sql/trigger_def.h" // enum_trigger_action_time_type
93#include "sql/visible_fields.h"
94#include "sql_string.h"
95#include "string_with_len.h"
96#include "strings/sql_chars.h"
97#include "thr_lock.h" // thr_lock_type
98#include "violite.h" // SSL_type
99
100class Alter_info;
101class Event_parse_data;
102class Field;
103class Item_cond;
105class Item_func_match;
109class Item_sum;
110class JOIN;
111class Opt_hints_global;
112class Opt_hints_qb;
113class PT_subquery;
114class PT_with_clause;
115class Parse_tree_root;
116class Protocol;
117class Query_result;
120class Query_block;
121class Query_expression;
123class Sql_cmd;
124class THD;
125class Value_generator;
126class Window;
127class partition_info;
128class sp_head;
129class sp_name;
130class sp_pcontext;
131struct LEX;
132struct NESTED_JOIN;
133struct PSI_digest_locker;
134struct sql_digest_state;
135union Lexer_yystype;
137
139constexpr const int MAX_SELECT_NESTING{sizeof(nesting_map) * 8 - 1};
140
141/*
142 There are 8 different type of table access so there is no more than
143 combinations 2^8 = 256:
144
145 . STMT_READS_TRANS_TABLE
146
147 . STMT_READS_NON_TRANS_TABLE
148
149 . STMT_READS_TEMP_TRANS_TABLE
150
151 . STMT_READS_TEMP_NON_TRANS_TABLE
152
153 . STMT_WRITES_TRANS_TABLE
154
155 . STMT_WRITES_NON_TRANS_TABLE
156
157 . STMT_WRITES_TEMP_TRANS_TABLE
158
159 . STMT_WRITES_TEMP_NON_TRANS_TABLE
160
161 The unsafe conditions for each combination is represented within a byte
162 and stores the status of the option --binlog-direct-non-trans-updates,
163 whether the trx-cache is empty or not, and whether the isolation level
164 is lower than ISO_REPEATABLE_READ:
165
166 . option (OFF/ON)
167 . trx-cache (empty/not empty)
168 . isolation (>= ISO_REPEATABLE_READ / < ISO_REPEATABLE_READ)
169
170 bits 0 : . OFF, . empty, . >= ISO_REPEATABLE_READ
171 bits 1 : . OFF, . empty, . < ISO_REPEATABLE_READ
172 bits 2 : . OFF, . not empty, . >= ISO_REPEATABLE_READ
173 bits 3 : . OFF, . not empty, . < ISO_REPEATABLE_READ
174 bits 4 : . ON, . empty, . >= ISO_REPEATABLE_READ
175 bits 5 : . ON, . empty, . < ISO_REPEATABLE_READ
176 bits 6 : . ON, . not empty, . >= ISO_REPEATABLE_READ
177 bits 7 : . ON, . not empty, . < ISO_REPEATABLE_READ
178*/
179extern uint binlog_unsafe_map[256];
180/*
181 Initializes the array with unsafe combinations and its respective
182 conditions.
183*/
185
186/*
187 If we encounter a diagnostics statement (GET DIAGNOSTICS, or e.g.
188 the old SHOW WARNINGS|ERRORS, or "diagnostics variables" such as
189 @@warning_count | @@error_count, we'll set some hints so this
190 information is not lost. DA_KEEP_UNSPECIFIED is used in LEX constructor to
191 avoid leaving variables uninitialized.
192 */
194 DA_KEEP_NOTHING = 0, /**< keep nothing */
195 DA_KEEP_DIAGNOSTICS, /**< keep the diagnostics area */
196 DA_KEEP_COUNTS, /**< keep \@warning_count / \@error_count */
197 DA_KEEP_PARSE_ERROR, /**< keep diagnostics area after parse error */
198 DA_KEEP_UNSPECIFIED /**< keep semantics is unspecified */
200
206
214
215/**
216 enum_sp_type defines type codes of stored programs.
217
218 @note these codes are used when dealing with the mysql.routines system table,
219 so they must not be changed.
220
221 @note the following macros were used previously for the same purpose. Now they
222 are used for ACL only.
223*/
224enum class enum_sp_type {
225 FUNCTION = 1,
226 PROCEDURE,
227 TRIGGER,
228 EVENT,
229 /*
230 Must always be the last one.
231 Denotes an error condition.
232 */
234};
235
237 if (val >= static_cast<longlong>(enum_sp_type::FUNCTION) &&
238 val < static_cast<longlong>(enum_sp_type::INVALID_SP_TYPE))
239 return static_cast<enum_sp_type>(val);
240 else
242}
243
245 return static_cast<longlong>(val);
246}
247
248inline uint to_uint(enum_sp_type val) { return static_cast<uint>(val); }
249
250/*
251 Values for the type enum. This reflects the order of the enum declaration
252 in the CREATE TABLE command. These values are used to enumerate object types
253 for the ACL statements.
254
255 These values were also used for enumerating stored program types. However, now
256 enum_sp_type should be used for that instead of them.
257*/
258#define TYPE_ENUM_FUNCTION 1
259#define TYPE_ENUM_PROCEDURE 2
260#define TYPE_ENUM_TRIGGER 3
261#define TYPE_ENUM_PROXY 4
262
263enum class Acl_type {
264 TABLE = 0,
267};
268
270 {STRING_WITH_LEN("")},
271 {STRING_WITH_LEN("CONTAINS SQL")},
272 {STRING_WITH_LEN("NO SQL")},
273 {STRING_WITH_LEN("READS SQL DATA")},
274 {STRING_WITH_LEN("MODIFIES SQL DATA")}};
275
277 VIEW_CREATE_NEW, // check that there are not such VIEW/table
278 VIEW_ALTER, // check that VIEW with such name exists
279 VIEW_CREATE_OR_REPLACE // check only that there are not such table
280};
281
283 ALTER_USER_COMMENT_NOT_USED, // No user metadata ALTER in the AST
284 ALTER_USER_COMMENT, // A text comment is expected
285 ALTER_USER_ATTRIBUTE // A JSON object is expected
286};
287
288/* Options to add_table_to_list() */
289#define TL_OPTION_UPDATING 0x01
290#define TL_OPTION_IGNORE_LEAVES 0x02
291#define TL_OPTION_ALIAS 0x04
292
293/* Structure for db & table in sql_yacc */
294class Table_function;
295
297 public:
302
303 Table_ident(Protocol *protocol, const LEX_CSTRING &db_arg,
304 const LEX_CSTRING &table_arg, bool force);
305 Table_ident(const LEX_CSTRING &db_arg, const LEX_CSTRING &table_arg)
306 : db(db_arg), table(table_arg), sel(nullptr), table_function(nullptr) {}
307 Table_ident(const LEX_CSTRING &table_arg)
308 : table(table_arg), sel(nullptr), table_function(nullptr) {
309 db = NULL_CSTR;
310 }
311 /**
312 This constructor is used only for the case when we create a derived
313 table. A derived table has no name and doesn't belong to any database.
314 Later, if there was an alias specified for the table, it will be set
315 by add_table_to_list.
316 */
318 db = EMPTY_CSTR; /* a subject to casedn_str */
320 }
321 /*
322 This constructor is used only for the case when we create a table function.
323 It has no name and doesn't belong to any database as it exists only
324 during query execution. Later, if there was an alias specified for the
325 table, it will be set by add_table_to_list.
326 */
327 Table_ident(LEX_CSTRING &table_arg, Table_function *table_func_arg)
328 : table(table_arg), sel(nullptr), table_function(table_func_arg) {
329 /* We must have a table name here as this is used with add_table_to_list */
330 db = EMPTY_CSTR; /* a subject to casedn_str */
331 }
332 // True if we can tell from syntax that this is a table function.
333 bool is_table_function() const { return (table_function != nullptr); }
334 // True if we can tell from syntax that this is an unnamed derived table.
335 bool is_derived_table() const { return sel; }
336 void change_db(const char *db_name) {
337 db.str = db_name;
338 db.length = strlen(db_name);
339 }
340};
341
344
345/**
346 Structure to hold parameters for CHANGE REPLICATION SOURCE, START REPLICA, and
347 STOP REPLICA.
348
349 Remark: this should not be confused with Master_info (and perhaps
350 would better be renamed to st_lex_replication_info). Some fields,
351 e.g., delay, are saved in Relay_log_info, not in Master_info.
352*/
354 /*
355 The array of IGNORE_SERVER_IDS has a preallocation, and is not expected
356 to grow to any significant size, so no instrumentation.
357 */
359 initialize();
360 }
367 char *gtid;
368 char *view_id;
369 const char *channel; // identifier similar to database name
370 enum {
377
378 /*
379 Enum is used for making it possible to detect if the user
380 changed variable or if it should be left at old value
381 */
382 enum {
392 /*
393 Ciphersuites used for TLS 1.3 communication with the master server.
394 */
399 };
408 /**
409 Flag that is set to `true` whenever `PRIVILEGE_CHECKS_USER` is set to `NULL`
410 as a part of a `CHANGE REPLICATION SOURCE TO` statement.
411 */
413 /**
414 Username and hostname parts of the `PRIVILEGE_CHECKS_USER`, when it's set to
415 a user.
416 */
418 /**
419 Flag indicating if row format should be enforced for this channel event
420 stream.
421 */
423
424 /**
425 Identifies what is the slave policy on primary keys in tables.
426 If set to STREAM it just replicates the value of sql_require_primary_key.
427 If set to ON it fails when the source tries to replicate a table creation
428 or alter operation that does not have a primary key.
429 If set to OFF it does not enforce any policies on the channel for primary
430 keys.
431 */
432 enum {
439
440 enum {
446
448
449 /// Initializes everything to zero/NULL/empty.
450 void initialize();
451 /// Sets all fields to their "unspecified" value.
452 void set_unspecified();
453
454 private:
455 // Not copyable or assignable.
458};
459
461 bool all;
462};
463
469
470/*
471 String names used to print a statement with index hints.
472 Keep in sync with index_hint_type.
473*/
474extern const char *index_hint_type_name[];
476
477/*
478 Bits in index_clause_map : one for each possible FOR clause in
479 USE/FORCE/IGNORE INDEX index hint specification
480*/
481#define INDEX_HINT_MASK_JOIN (1)
482#define INDEX_HINT_MASK_GROUP (1 << 1)
483#define INDEX_HINT_MASK_ORDER (1 << 2)
484
485#define INDEX_HINT_MASK_ALL \
486 (INDEX_HINT_MASK_JOIN | INDEX_HINT_MASK_GROUP | INDEX_HINT_MASK_ORDER)
487
488/* Single element of an USE/FORCE/IGNORE INDEX list specified as a SQL hint */
490 public:
491 /* The type of the hint : USE/FORCE/IGNORE */
493 /* Where the hit applies to. A bitmask of INDEX_HINT_MASK_<place> values */
495 /*
496 The index name. Empty (str=NULL) name represents an empty list
497 USE INDEX () clause
498 */
500
501 Index_hint(const char *str, uint length) {
502 key_name.str = str;
504 }
505
506 void print(const THD *thd, String *str);
507};
508
509/*
510 Class Query_expression represents a query expression.
511 Class Query_block represents a query block.
512
513 In addition to what is explained below, the query block(s) of a query
514 expression is contained in a tree expressing the nesting of set operations,
515 cf. query_term.h
516
517 A query expression contains one or more query blocks (more than one means
518 that the query expression contains one or more set operations - UNION,
519 INTERSECT or EXCEPT - unless the query blocks are used to describe
520 subqueries). These classes are connected as follows: both classes have a
521 master, a slave, a next and a prev field. For class Query_block, master and
522 slave connect to objects of type Query_expression, whereas for class
523 Query_expression, they connect to Query_block. master is pointer to outer
524 node. slave is pointer to the first inner node.
525
526 neighbors are two Query_block or Query_expression objects on
527 the same level.
528
529 The structures are linked with the following pointers:
530 - list of neighbors (next/prev) (prev of first element point to slave
531 pointer of outer structure)
532 - For Query_block, this is a list of query blocks.
533 - For Query_expression, this is a list of subqueries.
534
535 - pointer to outer node (master), which is
536 If this is Query_expression
537 - pointer to outer query_block.
538 If this is Query_block
539 - pointer to outer Query_expression.
540
541 - pointer to inner objects (slave), which is either:
542 If this is an Query_expression:
543 - first query block that belong to this query expression.
544 If this is an Query_block
545 - first query expression that belong to this query block (subqueries).
546
547 - list of all Query_block objects (link_next/link_prev)
548 This is to be used for things like derived tables creation, where we
549 go through this list and create the derived tables.
550
551 In addition to the above mentioned link, the query's tree structure is
552 represented by the member m_query_term, see query_term.h
553 For example for following query:
554
555 select *
556 from table1
557 where table1.field IN (select * from table1_1_1 union
558 select * from table1_1_2)
559 union
560 select *
561 from table2
562 where table2.field=(select (select f1 from table2_1_1_1_1
563 where table2_1_1_1_1.f2=table2_1_1.f3)
564 from table2_1_1
565 where table2_1_1.f1=table2.f2)
566 union
567 select * from table3;
568
569 we will have following structure:
570
571 select1: (select * from table1 ...)
572 select2: (select * from table2 ...)
573 select3: (select * from table3)
574 select1.1.1: (select * from table1_1_1)
575 ...
576
577 main unit
578 select1 select2 select3
579 |^^ |^
580 s||| ||master
581 l||| |+---------------------------------+
582 a||| +---------------------------------+|
583 v|||master slave ||
584 e||+-------------------------+ ||
585 V| neighbor | V|
586 unit1.1<+==================>unit1.2 unit2.1
587 select1.1.1 select 1.1.2 select1.2.1 select2.1.1
588 |^
589 ||
590 V|
591 unit2.1.1.1
592 select2.1.1.1.1
593
594
595 relation in main unit will be following:
596 (bigger picture for:
597 main unit
598 select1 select2 select3
599 in the above picture)
600
601 main unit
602 |^^^
603 ||||
604 ||||
605 |||+------------------------------+
606 ||+--------------+ |
607 slave||master | |
608 V| neighbor | neighbor |
609 select1<========>select2<========>select3
610
611 list of all query_block will be following (as it will be constructed by
612 parser):
613
614 select1->select2->select3->select2.1.1->select 2.1.2->select2.1.1.1.1-+
615 |
616 +---------------------------------------------------------------------+
617 |
618 +->select1.1.1->select1.1.2
619
620*/
621
622/**
623 This class represents a query expression (one query block or
624 several query blocks combined with UNION).
625*/
627 /**
628 Intrusive double-linked list of all query expressions
629 immediately contained within the same query block.
630 */
633
634 /**
635 The query block wherein this query expression is contained,
636 NULL if the query block is the outer-most one.
637 */
639 /// The first query block in this query expression.
641
642 // The query set operation structure, see doc for Query_term.
644
645 public:
646 /// Getter for m_query_term, q.v.
647 Query_term *query_term() const { return m_query_term; }
648 /// Setter for m_query_term, q.v.
650 /// Convenience method to avoid down casting, i.e. interpret m_query_term
651 /// as a Query_term_set_op.
652 /// @retval a non-null node iff !is_simple
653 /// @retval nullptr if is_simple() holds.
655 return is_simple() ? nullptr : down_cast<Query_term_set_op *>(m_query_term);
656 }
657 /// Return the query block iff !is_simple() holds
659 if (is_simple())
660 return nullptr;
661 else
662 return m_query_term->query_block();
663 }
664 bool is_leaf_block(Query_block *qb);
666 for (auto qt : query_terms<>()) {
667 if (qt->query_block() == qb) return qt;
668 }
669 return nullptr;
670 }
671
672 /**
673 Return iterator object over query terms rooted in m_query_term,
674 using either post order visiting (default) or pre order,
675 optionally skipping leaf nodes (query blocks corresponding to SELECTs or
676 table constructors). By default, we visit all nodes.
677 Usage: for (auto qt : query_terms<..>() { ... }
678 E.g.
679 for (auto qt : query_terms<>()) { } Visit all nodes, post order
680 for (auto qt : query_terms<QTC_PRE_ORDER, false>()) { }
681 Skip leaves, pre order
682 @tparam order == QTC_POST_ORDER if post order traversal is desired;default
683 == QTC_PRE_ORDER pre-order traversal
684 @tparam visit_leaves == VL_VISIT_LEAVES: if we want the traversal to include
685 leaf nodes i.e. the SELECTs or table constructors
686 == VL_SKIP_LEAVES: leaves will be skipped
687 @returns iterator object
688 */
689 template <Visit_order order = QTC_POST_ORDER,
690 Visit_leaves visit_leaves = VL_VISIT_LEAVES>
693 }
694
695 /**
696 Return the Query_block of the last query term in a n-ary set
697 operation that is the right side of the last DISTINCT set operation in that
698 n_ary set operation:
699 E.e. for
700 A UNION B UNION ALL C,
701 B's block will be returned. If no DISTINCT is present or not a set
702 operation, return nullptr.
703
704 @returns query block of last distinct right operand
705 */
707 auto const setop = down_cast<Query_term_set_op *>(m_query_term);
708 if (setop->m_last_distinct > 0)
709 return setop->m_children[setop->m_last_distinct]->query_block();
710 else
711 return nullptr;
712 }
713
715 if (is_simple()) return false;
716 return down_cast<Query_term_set_op *>(m_query_term)->m_last_distinct > 0;
717 }
718
719 private:
720 /**
721 Marker for subqueries in WHERE, HAVING, ORDER BY, GROUP BY and
722 SELECT item lists.
723 Must be read/written when holding LOCK_query_plan.
724
725 See Item_subselect::explain_subquery_checker
726 */
728
729 bool prepared; ///< All query blocks in query expression are prepared
730 bool optimized; ///< All query blocks in query expression are optimized
731 bool executed; ///< Query expression has been executed
732
733 /// Object to which the result for this query expression is sent.
734 /// Not used if we materialize directly into a parent query expression's
735 /// result table (see optimize()).
737
738 /**
739 An iterator you can read from to get all records for this query.
740
741 May be nullptr even after create_access_paths(), or in the case of an
742 unfinished materialization (see optimize()).
743 */
746
747 /**
748 If there is an unfinished materialization (see optimize()),
749 contains one element for each operand (query block) in this query
750 expression.
751 */
753
754 private:
755 /**
756 Convert the executor structures to a set of access paths, storing the result
757 in m_root_access_path.
758 */
759 void create_access_paths(THD *thd);
760
761 public:
762 /**
763 result of this query can't be cached, bit field, can be :
764 UNCACHEABLE_DEPENDENT
765 UNCACHEABLE_RAND
766 UNCACHEABLE_SIDEEFFECT
767 */
769
770 explicit Query_expression(enum_parsing_context parsing_context);
771
772 /// @return true for a query expression without UNION/INTERSECT/EXCEPT or
773 /// multi-level ORDER, i.e. we have a "simple table".
774 bool is_simple() const { return m_query_term->term_type() == QT_QUERY_BLOCK; }
775
776 /// Values for Query_expression::cleaned
778 UC_DIRTY, ///< Unit isn't cleaned
779 UC_PART_CLEAN, ///< Unit were cleaned, except JOIN and JOIN_TABs were
780 ///< kept for possible EXPLAIN
781 UC_CLEAN ///< Unit completely cleaned, all underlying JOINs were
782 ///< freed
783 };
784 enum_clean_state cleaned; ///< cleanliness state
785
786 private:
787 /*
788 list of types of items inside union (used for union & derived tables)
789
790 Item_type_holders from which this list consist may have pointers to Field,
791 pointers is valid only after preparing SELECTS of this unit and before
792 any SELECT of this unit execution
793
794 All hidden items are stripped away from this list.
795 */
797
798 public:
799 /**
800 Return the query block holding the top level ORDER BY, LIMIT and OFFSET.
801
802 If the query is not a set operation (UNION, INTERSECT or EXCEPT, and the
803 query expression has no multi-level ORDER BY/LIMIT, this represents the
804 single query block of the query itself, cf. documentation for class
805 Query_term.
806
807 @return query block containing the global parameters
808 */
810 return query_term()->query_block();
811 }
812
813 /* LIMIT clause runtime counters */
815 /// Points to subquery if this query expression is used in one, otherwise NULL
817 /**
818 The WITH clause which is the first part of this query expression. NULL if
819 none.
820 */
822 /**
823 If this query expression is underlying of a derived table, the derived
824 table. NULL if none.
825 */
827 /**
828 First query block (in this UNION) which references the CTE.
829 NULL if not the query expression of a recursive CTE.
830 */
832
833 /**
834 If 'this' is body of lateral derived table:
835 map of tables in the same FROM clause as this derived table, and to which
836 the derived table's body makes references.
837 In pre-resolution stages, this is OUTER_REF_TABLE_BIT, just to indicate
838 that this has LATERAL; after resolution, which has found references in the
839 body, this is the proper map (with no PSEUDO_TABLE_BITS anymore).
840 */
842
843 /**
844 This query expression represents a scalar subquery and we need a run-time
845 check that the cardinality doesn't exceed 1.
846 */
848
849 /// @return true if query expression can be merged into an outer query
850 bool is_mergeable() const;
851
852 /// @return true if query expression is recommended to be merged
853 bool merge_heuristic(const LEX *lex) const;
854
855 /// @return the query block this query expression belongs to as subquery
857
858 /// @return the first query block inside this query expression
860
861 /// @return the next query expression within same query block (next subquery)
863
864 /// @return the query result object in use for this query expression
866
867 RowIterator *root_iterator() const { return m_root_iterator.get(); }
869 return std::move(m_root_iterator);
870 }
872
873 // Asks each query block to switch to an access path with in2exists
874 // conditions removed (if they were ever added).
875 // See JOIN::change_to_access_path_without_in2exists().
877
879 m_root_access_path = nullptr;
880 m_root_iterator.reset();
881 }
882
883 /**
884 Ensures that there are iterators created for the access paths created
885 by optimize(), even if it was called with create_access_paths = false.
886 If there are already iterators, it is a no-op. optimize() must have
887 been called earlier.
888
889 The use case for this is if we have a query block that's not top-level,
890 but we figure out after the fact that we wanted to run it anyway.
891 The typical case would be that we notice that the query block can return
892 at most one row (a so-called const table), and want to run it during
893 optimization.
894 */
895 bool force_create_iterators(THD *thd);
896
897 /// See optimize().
898 bool unfinished_materialization() const { return !m_operands.empty(); }
899
900 /// See optimize().
903 return std::move(m_operands);
904 }
905
906 /// Set new query result object for this query expression
908
909 /**
910 Whether there is a chance that optimize() is capable of materializing
911 directly into a result table if given one. Note that even if this function
912 returns true, optimize() can choose later not to do so, since it depends
913 on information (in particular, whether the query blocks can run under
914 the iterator executor or not) that is not available before optimize time.
915
916 TODO(sgunders): Now that all query blocks can run under the iterator
917 executor, the above may no longer be true. This needs investigation.
918 */
920
921 bool prepare(THD *thd, Query_result *result,
922 mem_root_deque<Item *> *insert_field_list,
923 ulonglong added_options, ulonglong removed_options);
924
925 /**
926 If and only if materialize_destination is non-nullptr, it means that the
927 caller intends to materialize our result into the given table. If it is
928 advantageous (in particular, if this query expression is a UNION DISTINCT),
929 optimize() will not create an iterator by itself, but rather do an
930 unfinished materialize. This means that it will collect iterators for
931 all the query blocks and prepare them for materializing into the given
932 table, but not actually create a root iterator for this query expression;
933 the caller is responsible for calling release_query_blocks_to_materialize()
934 and creating the iterator itself.
935
936 Even if materialize_destination is non-nullptr, this function may choose
937 to make a regular iterator. The caller is responsible for checking
938 unfinished_materialization() if it has given a non-nullptr table.
939
940 @param thd Thread handle.
941
942 @param materialize_destination What table to try to materialize into,
943 or nullptr if the caller does not intend to materialize the result.
944
945 @param create_iterators If false, only access paths are created,
946 not iterators. Only top level query blocks (these that we are to call
947 exec() on) should have iterators. See also force_create_iterators().
948
949 @param finalize_access_paths Relevant for the hypergraph optimizer only.
950 If false, the given access paths will _not_ be finalized, so you cannot
951 create iterators from it before finalize() is called (see
952 FinalizePlanForQueryBlock()), and create_iterators must also be false.
953 This is relevant only if you are potentially optimizing multiple times
954 (see change_to_access_path_without_in2exists()), since you are only
955 allowed to finalize a query block once. "Fake" query blocks (see
956 query_term.h) are always finalized.
957 */
958 bool optimize(THD *thd, TABLE *materialize_destination, bool create_iterators,
959 bool finalize_access_paths);
960
961 /**
962 For any non-finalized query block, finalize it so that we are allowed to
963 create iterators. Must be called after the final access path is chosen
964 (ie., after any calls to change_to_access_path_without_in2exists()).
965 */
966 bool finalize(THD *thd);
967
968 /**
969 Do everything that would be needed before running Init() on the root
970 iterator. In particular, clear out data from previous execution iterations,
971 if needed.
972 */
973 bool ClearForExecution();
974
975 bool ExecuteIteratorQuery(THD *thd);
976 bool execute(THD *thd);
977 bool explain(THD *explain_thd, const THD *query_thd);
978 bool explain_query_term(THD *explain_thd, const THD *query_thd,
979 Query_term *qt);
980 void cleanup(bool full);
981 /**
982 Destroy contained objects, in particular temporary tables which may
983 have their own mem_roots.
984 */
985 void destroy();
986
987 void print(const THD *thd, String *str, enum_query_type query_type);
988 bool accept(Select_lex_visitor *visitor);
989
990 /**
991 Create a block to be used for ORDERING and LIMIT/OFFSET processing of a
992 query term, which isn't itself a query specification or table value
993 constructor. Such blocks are not included in the list starting in
994 Query_Expression::first_query_block, and Query_block::next_query_block().
995 They blocks are accessed via Query_term::query_block().
996
997 @param term the term on behalf of which we are making a post processing
998 block
999 @returns a query block
1000 */
1002
1003 bool prepare_query_term(THD *thd, Query_term *qts,
1004 Query_result *common_result, ulonglong added_options,
1005 ulonglong create_options, int level,
1006 Mem_root_array<bool> &nullable);
1008 assert(!is_prepared());
1009 prepared = true;
1010 }
1012 assert(is_prepared() && !is_optimized());
1013 optimized = true;
1014 }
1016 // assert(is_prepared() && is_optimized() && !is_executed());
1017 assert(is_prepared() && is_optimized());
1018 executed = true;
1019 }
1020 /// Reset this query expression for repeated evaluation within same execution
1022 assert(is_prepared() && is_optimized());
1023 executed = false;
1024 }
1025 /// Clear execution state, needed before new execution of prepared statement
1027 // Cannot be enforced when called from Prepared_statement::execute():
1028 // assert(is_prepared());
1029 optimized = false;
1030 executed = false;
1031 cleaned = UC_DIRTY;
1032 }
1033 /// Check state of preparation of the contained query expression.
1034 bool is_prepared() const { return prepared; }
1035 /// Check state of optimization of the contained query expression.
1036 bool is_optimized() const { return optimized; }
1037 /**
1038 Check state of execution of the contained query expression.
1039 Should not be used to check the state of a complete statement, use
1040 LEX::is_exec_completed() instead.
1041 */
1042 bool is_executed() const { return executed; }
1044 Query_result_interceptor *old_result);
1045 bool set_limit(THD *thd, Query_block *provider);
1046 bool has_any_limit() const;
1047
1048 inline bool is_union() const;
1049 inline bool is_set_operation() const;
1050
1051 /// Include a query expression below a query block.
1052 void include_down(LEX *lex, Query_block *outer);
1053
1054 /// Exclude this unit and immediately contained query_block objects
1055 void exclude_level();
1056
1057 /// Exclude subtree of current unit from tree of SELECTs
1058 void exclude_tree();
1059
1060 /// Renumber query blocks of a query expression according to supplied LEX
1061 void renumber_selects(LEX *lex);
1062
1064 bool save_cmd_properties(THD *thd);
1065
1066 friend class Query_block;
1067
1070 size_t num_visible_fields() const;
1071
1072 // If we are doing a query with global LIMIT, we need somewhere to store the
1073 // record count for FOUND_ROWS(). It can't be in any of the JOINs, since
1074 // they may have their own LimitOffsetIterators, which will write to
1075 // join->send_records whenever there is an OFFSET. Thus, we'll keep it here
1076 // instead.
1078
1081 void set_explain_marker_from(THD *thd, const Query_expression *u);
1082
1083#ifndef NDEBUG
1084 /**
1085 Asserts that none of {this unit and its children units} is fully cleaned
1086 up.
1087 */
1089#else
1090 void assert_not_fully_clean() {}
1091#endif
1092 void invalidate();
1093
1094 bool is_recursive() const { return first_recursive != nullptr; }
1095
1097
1099
1100 void fix_after_pullout(Query_block *parent_query_block,
1101 Query_block *removed_query_block);
1102
1103 /**
1104 If unit is a subquery, which forms an object of the upper level (an
1105 Item_subselect, a derived Table_ref), adds to this object a map
1106 of tables of the upper level which the unit references.
1107 */
1109
1110 /**
1111 If unit is a subquery, which forms an object of the upper level (an
1112 Item_subselect, a derived Table_ref), returns the place of this object
1113 in the upper level query block.
1114 */
1116
1117 bool walk(Item_processor processor, enum_walk walk, uchar *arg);
1118
1119 /**
1120 Replace all targeted items using transformer provided and info in
1121 arg.
1122 */
1123 bool replace_items(Item_transformer t, uchar *arg);
1124
1125 /*
1126 An exception: this is the only function that needs to adjust
1127 explain_marker.
1128 */
1129 friend bool parse_view_definition(THD *thd, Table_ref *view_ref);
1130};
1131
1134
1135/**
1136 Query_block type enum
1137*/
1139 EXPLAIN_NONE = 0,
1152 // Total:
1153 EXPLAIN_total ///< fake type, total number of all valid types
1154
1155 // Don't insert new types below this line!
1156};
1157
1158/**
1159 This class represents a query block, aka a query specification, which is
1160 a query consisting of a SELECT keyword, followed by a table list,
1161 optionally followed by a WHERE clause, a GROUP BY, etc.
1162*/
1163class Query_block : public Query_term {
1164 public:
1165 /**
1166 @note the group_by and order_by lists below will probably be added to the
1167 constructor when the parser is converted into a true bottom-up design.
1168
1169 //SQL_I_LIST<ORDER> *group_by, SQL_I_LIST<ORDER> order_by
1170 */
1172
1173 /// Query_term methods overridden
1174 void debugPrint(int level, std::ostringstream &buf) const override;
1175 /// Minion of debugPrint
1176 void qbPrint(int level, std::ostringstream &buf) const;
1177 Query_term_type term_type() const override { return QT_QUERY_BLOCK; }
1178 const char *operator_string() const override { return "query_block"; }
1179 Query_block *query_block() const override {
1180 return const_cast<Query_block *>(this);
1181 }
1182 void label_children() override {}
1183 void destroy_tree() override { m_parent = nullptr; }
1184
1185 bool open_result_tables(THD *, int) override;
1186 /// end of overridden methods from Query_term
1187 bool absorb_limit_of(Query_block *block);
1188
1189 Item *where_cond() const { return m_where_cond; }
1191 void set_where_cond(Item *cond) { m_where_cond = cond; }
1192 Item *having_cond() const { return m_having_cond; }
1194 void set_having_cond(Item *cond) { m_having_cond = cond; }
1195 Item *qualify_cond() const { return m_qualify_cond; }
1197 void set_qualify_cond(Item *cond) { m_qualify_cond = cond; }
1200 bool change_query_result(THD *thd, Query_result_interceptor *new_result,
1201 Query_result_interceptor *old_result);
1202
1203 /// Set base options for a query block (and active options too)
1204 void set_base_options(ulonglong options_arg) {
1205 DBUG_EXECUTE_IF("no_const_tables", options_arg |= OPTION_NO_CONST_TABLES;);
1206
1207 // Make sure we do not overwrite options by accident
1208 assert(m_base_options == 0 && m_active_options == 0);
1209 m_base_options = options_arg;
1210 m_active_options = options_arg;
1211 }
1212
1213 /// Add base options to a query block, also update active options
1215 assert(first_execution);
1218 }
1219
1220 /**
1221 Remove base options from a query block.
1222 Active options are also updated, and we assume here that "extra" options
1223 cannot override removed base options.
1224 */
1226 assert(first_execution);
1229 }
1230
1231 /// Make active options from base options, supplied options and environment:
1232 void make_active_options(ulonglong added_options, ulonglong removed_options);
1233
1234 /// Adjust the active option set
1236
1237 /// @return the active query options
1239
1240 /**
1241 Set associated tables as read_only, ie. they cannot be inserted into,
1242 updated or deleted from during this statement.
1243 Commonly used for query blocks that are part of derived tables or
1244 views that are materialized.
1245 */
1247 // Set all referenced base tables as read only.
1248 for (Table_ref *tr = leaf_tables; tr != nullptr; tr = tr->next_leaf)
1249 tr->set_readonly();
1250 }
1251
1252 /// @returns a map of all tables references in the query block
1253 table_map all_tables_map() const { return (1ULL << leaf_table_count) - 1; }
1254
1255 bool remove_aggregates(THD *thd, Query_block *select);
1256
1260 Query_block *next_query_block() const { return next; }
1261
1263
1265
1266 void mark_as_dependent(Query_block *last, bool aggregate);
1267
1268 /// @returns true if query block references any tables
1269 bool has_tables() const { return m_table_list.elements != 0; }
1270
1271 /// @return true if query block is explicitly grouped (non-empty GROUP BY)
1272 bool is_explicitly_grouped() const { return group_list.elements != 0; }
1273
1274 /**
1275 @return true if this query block is implicitly grouped, ie it is not
1276 explicitly grouped but contains references to set functions.
1277 The query will return max. 1 row (@see also is_single_grouped()).
1278 */
1280 return m_agg_func_used && group_list.elements == 0;
1281 }
1282
1283 /**
1284 @return true if this query block has GROUP BY modifier.
1285 */
1287 return (olap != UNSPECIFIED_OLAP_TYPE);
1288 }
1289
1290 /**
1291 @return true if this query block is explicitly or implicitly grouped.
1292 @note a query with DISTINCT is not considered to be aggregated.
1293 @note in standard SQL, a query with HAVING is defined as grouped, however
1294 MySQL allows HAVING without any aggregation to be the same as WHERE.
1295 */
1296 bool is_grouped() const { return group_list.elements > 0 || m_agg_func_used; }
1297
1298 /// @return true if this query block contains DISTINCT at start of select list
1299 bool is_distinct() const { return active_options() & SELECT_DISTINCT; }
1300
1301 /**
1302 @return true if this query block contains an ORDER BY clause.
1303
1304 @note returns false if ORDER BY has been eliminated, e.g if the query
1305 can return max. 1 row.
1306 */
1307 bool is_ordered() const { return order_list.elements > 0; }
1308
1309 /**
1310 Based on the structure of the query at resolution time, it is possible to
1311 conclude that DISTINCT is useless and remove it.
1312 This is the case if:
1313 - all GROUP BY expressions are in SELECT list, so resulting group rows are
1314 distinct,
1315 - and ROLLUP is not specified, so it adds no row for NULLs.
1316
1317 @returns true if we can remove DISTINCT.
1318
1319 @todo could refine this to if ROLLUP were specified and all GROUP
1320 expressions were non-nullable, because ROLLUP then adds only NULL values.
1321 Currently, ROLLUP+DISTINCT is rejected because executor cannot handle
1322 it in all cases.
1323 */
1324 bool can_skip_distinct() const {
1325 return is_grouped() && hidden_group_field_count == 0 &&
1327 }
1328
1329 /// @return true if this query block has a LIMIT clause
1330 bool has_limit() const { return select_limit != nullptr; }
1331
1332 /// @return true if query block references full-text functions
1333 bool has_ft_funcs() const { return ftfunc_list->elements > 0; }
1334
1335 /// @returns true if query block is a recursive member of a recursive unit
1336 bool is_recursive() const { return recursive_reference != nullptr; }
1337
1338 /**
1339 Finds a group expression matching the given item, or nullptr if
1340 none. When there are multiple candidates, ones that match in name are
1341 given priority (such that “a AS c GROUP BY a,b,c” resolves to c, not a);
1342 if there is still a tie, the leftmost is given priority.
1343
1344 @param item The item to search for.
1345 @param [out] rollup_level If not nullptr, will be set to the group
1346 expression's index (0-based).
1347 */
1348 ORDER *find_in_group_list(Item *item, int *rollup_level) const;
1349 int group_list_size() const;
1350
1351 /// @returns true if query block contains window functions
1352 bool has_windows() const { return m_windows.elements > 0; }
1353
1354 void invalidate();
1355
1356 uint get_in_sum_expr() const { return in_sum_expr; }
1357
1358 bool add_item_to_list(Item *item);
1360 Table_ref *add_table_to_list(THD *thd, Table_ident *table, const char *alias,
1361 ulong table_options,
1363 enum_mdl_type mdl_type = MDL_SHARED_READ,
1364 List<Index_hint> *hints = nullptr,
1365 List<String> *partition_names = nullptr,
1366 LEX_STRING *option = nullptr,
1367 Parse_context *pc = nullptr);
1368
1369 /**
1370 Add item to the hidden part of select list
1371
1372 @param item item to add
1373
1374 @return Pointer to reference of the added item
1375 */
1376 Item **add_hidden_item(Item *item);
1377
1378 /// Remove hidden items from select list
1379 void remove_hidden_items();
1380
1381 Table_ref *get_table_list() const { return m_table_list.first; }
1382 bool init_nested_join(THD *thd);
1384 Table_ref *nest_last_join(THD *thd, size_t table_cnt = 2);
1387
1388 /// Wrappers over fields / get_fields_list() that hide items where
1389 /// item->hidden, meant for range-based for loops. See sql/visible_fields.h.
1391 auto visible_fields() const { return VisibleFields(fields); }
1392
1393 /// Check privileges for views that are merged into query block
1394 bool check_view_privileges(THD *thd, Access_bitmask want_privilege_first,
1395 Access_bitmask want_privilege_next);
1396 /// Check privileges for all columns referenced from query block
1397 bool check_column_privileges(THD *thd);
1398
1399 /// Check privileges for column references in subqueries of a query block
1401
1402 /// Resolve and prepare information about tables for one query block
1403 bool setup_tables(THD *thd, Table_ref *tables, bool select_insert);
1404
1405 /// Resolve OFFSET and LIMIT clauses
1406 bool resolve_limits(THD *thd);
1407
1408 /// Resolve derived table, view, table function information for a query block
1409 bool resolve_placeholder_tables(THD *thd, bool apply_semijoin);
1410
1411 /// Propagate exclusion from table uniqueness test into subqueries
1413
1414 /// Merge name resolution context objects of a subquery into its parent
1415 void merge_contexts(Query_block *inner);
1416
1417 /// Merge derived table into query block
1418 bool merge_derived(THD *thd, Table_ref *derived_table);
1419
1420 bool flatten_subqueries(THD *thd);
1421
1422 /**
1423 Update available semijoin strategies for semijoin nests.
1424
1425 Available semijoin strategies needs to be updated on every execution since
1426 optimizer_switch setting may have changed.
1427
1428 @param thd Pointer to THD object for session.
1429 Used to access optimizer_switch
1430 */
1432
1433 /**
1434 Returns which subquery execution strategies can be used for this query
1435 block.
1436
1437 @param thd Pointer to THD object for session.
1438 Used to access optimizer_switch
1439
1440 @retval SUBQ_MATERIALIZATION Subquery Materialization should be used
1441 @retval SUBQ_EXISTS In-to-exists execution should be used
1442 @retval CANDIDATE_FOR_IN2EXISTS_OR_MAT A cost-based decision should be made
1443 */
1444 Subquery_strategy subquery_strategy(const THD *thd) const;
1445
1446 /**
1447 Returns whether semi-join is enabled for this query block
1448
1449 @see @c Opt_hints_qb::semijoin_enabled for details on how hints
1450 affect this decision. If there are no hints for this query block,
1451 optimizer_switch setting determines whether semi-join is used.
1452
1453 @param thd Pointer to THD object for session.
1454 Used to access optimizer_switch
1455
1456 @return true if semijoin is enabled,
1457 false otherwise
1458 */
1459 bool semijoin_enabled(const THD *thd) const;
1460
1462 sj_candidates = sj_cand;
1463 }
1465 sj_candidates->push_back(predicate);
1466 }
1467 bool has_sj_candidates() const {
1468 return sj_candidates != nullptr && !sj_candidates->empty();
1469 }
1470
1471 bool has_subquery_transforms() const { return sj_candidates != nullptr; }
1472
1473 /// Add full-text function elements from a list into this query block
1475
1476 void set_lock_for_table(const Lock_descriptor &descriptor, Table_ref *table);
1477
1478 void set_lock_for_tables(thr_lock_type lock_type);
1479
1480 inline void init_order() {
1481 assert(order_list.elements == 0);
1482 order_list.elements = 0;
1483 order_list.first = nullptr;
1484 order_list.next = &order_list.first;
1485 }
1486 /*
1487 This method created for reiniting LEX in mysql_admin_table() and can be
1488 used only if you are going remove all Query_block & units except belonger
1489 to LEX (LEX::unit & LEX::select, for other purposes use
1490 Query_expression::exclude_level()
1491 */
1492 void cut_subtree() { slave = nullptr; }
1493 bool test_limit();
1494 /**
1495 Get offset for LIMIT.
1496
1497 Evaluate offset item if necessary.
1498
1499 @return Number of rows to skip.
1500
1501 @todo Integrate better with Query_expression::set_limit()
1502 */
1503 ha_rows get_offset(const THD *thd) const;
1504 /**
1505 Get limit.
1506
1507 Evaluate limit item if necessary.
1508
1509 @return Limit of rows in result.
1510
1511 @todo Integrate better with Query_expression::set_limit()
1512 */
1513 ha_rows get_limit(const THD *thd) const;
1514
1515 /// Assign a default name resolution object for this query block.
1516 bool set_context(Name_resolution_context *outer_context);
1517
1518 /// Setup the array containing references to base items
1519 bool setup_base_ref_items(THD *thd);
1520 void print(const THD *thd, String *str, enum_query_type query_type);
1521
1522 /**
1523 Print detail of the Query_block object.
1524
1525 @param thd Thread handler
1526 @param query_type Options to print out string output
1527 @param[out] str String of output.
1528 */
1529 void print_query_block(const THD *thd, String *str,
1530 enum_query_type query_type);
1531
1532 /**
1533 Print detail of the UPDATE statement.
1534
1535 @param thd Thread handler
1536 @param[out] str String of output
1537 @param query_type Options to print out string output
1538 */
1539 void print_update(const THD *thd, String *str, enum_query_type query_type);
1540
1541 /**
1542 Print detail of the DELETE statement.
1543
1544 @param thd Thread handler
1545 @param[out] str String of output
1546 @param query_type Options to print out string output
1547 */
1548 void print_delete(const THD *thd, String *str, enum_query_type query_type);
1549
1550 /**
1551 Print detail of the INSERT statement.
1552
1553 @param thd Thread handler
1554 @param[out] str String of output
1555 @param query_type Options to print out string output
1556 */
1557 void print_insert(const THD *thd, String *str, enum_query_type query_type);
1558
1559 /**
1560 Print detail of Hints.
1561
1562 @param thd Thread handler
1563 @param[out] str String of output
1564 @param query_type Options to print out string output
1565 */
1566 void print_hints(const THD *thd, String *str, enum_query_type query_type);
1567
1568 /**
1569 Print error.
1570
1571 @param thd Thread handler
1572 @param[out] str String of output
1573
1574 @retval false If there is no error
1575 @retval true else
1576 */
1577 bool print_error(const THD *thd, String *str);
1578
1579 /**
1580 Print select options.
1581
1582 @param[out] str String of output
1583 */
1585
1586 /**
1587 Print UPDATE options.
1588
1589 @param[out] str String of output
1590 */
1592
1593 /**
1594 Print DELETE options.
1595
1596 @param[out] str String of output
1597 */
1599
1600 /**
1601 Print INSERT options.
1602
1603 @param[out] str String of output
1604 */
1606
1607 /**
1608 Print list of tables.
1609
1610 @param thd Thread handler
1611 @param[out] str String of output
1612 @param table_list Table_ref object
1613 @param query_type Options to print out string output
1614 */
1615 void print_table_references(const THD *thd, String *str,
1616 Table_ref *table_list,
1617 enum_query_type query_type);
1618
1619 /**
1620 Print list of items in Query_block object.
1621
1622 @param thd Thread handle
1623 @param[out] str String of output
1624 @param query_type Options to print out string output
1625 */
1626 void print_item_list(const THD *thd, String *str, enum_query_type query_type);
1627
1628 /**
1629 Print assignments list. Used in UPDATE and
1630 INSERT ... ON DUPLICATE KEY UPDATE ...
1631
1632 @param thd Thread handle
1633 @param[out] str String of output
1634 @param query_type Options to print out string output
1635 @param fields List columns to be assigned.
1636 @param values List of values.
1637 */
1638 void print_update_list(const THD *thd, String *str,
1639 enum_query_type query_type,
1641 const mem_root_deque<Item *> &values);
1642
1643 /**
1644 Print column list to be inserted into. Used in INSERT.
1645
1646 @param thd Thread handle
1647 @param[out] str String of output
1648 @param query_type Options to print out string output
1649 */
1650 void print_insert_fields(const THD *thd, String *str,
1651 enum_query_type query_type);
1652
1653 /**
1654 Print list of values, used in INSERT and for general VALUES clause.
1655
1656 @param thd Thread handle
1657 @param[out] str String of output
1658 @param query_type Options to print out string output
1659 @param values List of values
1660 @param prefix Prefix to print before each row in value list
1661 = nullptr: No prefix wanted
1662 */
1663 void print_values(const THD *thd, String *str, enum_query_type query_type,
1664 const mem_root_deque<mem_root_deque<Item *> *> &values,
1665 const char *prefix);
1666
1667 /**
1668 Print list of tables in FROM clause.
1669
1670 @param thd Thread handler
1671 @param[out] str String of output
1672 @param query_type Options to print out string output
1673 */
1674 void print_from_clause(const THD *thd, String *str,
1675 enum_query_type query_type);
1676
1677 /**
1678 Print list of conditions in WHERE clause.
1679
1680 @param thd Thread handle
1681 @param[out] str String of output
1682 @param query_type Options to print out string output
1683 */
1684 void print_where_cond(const THD *thd, String *str,
1685 enum_query_type query_type);
1686
1687 /**
1688 Print list of items in GROUP BY clause.
1689
1690 @param thd Thread handle
1691 @param[out] str String of output
1692 @param query_type Options to print out string output
1693 */
1694 void print_group_by(const THD *thd, String *str, enum_query_type query_type);
1695
1696 /**
1697 Print list of items in HAVING clause.
1698
1699 @param thd Thread handle
1700 @param[out] str String of output
1701 @param query_type Options to print out string output
1702 */
1703 void print_having(const THD *thd, String *str, enum_query_type query_type);
1704
1705 /**
1706 Print list of items in QUALIFY clause.
1707
1708 @param thd Thread handle
1709 @param[out] str String of output
1710 @param query_type Options to print out string output
1711 */
1712 void print_qualify(const THD *thd, String *str,
1713 enum_query_type query_type) const;
1714
1715 /**
1716 Print details of Windowing functions.
1717
1718 @param thd Thread handler
1719 @param[out] str String of output
1720 @param query_type Options to print out string output
1721 */
1722 void print_windows(const THD *thd, String *str, enum_query_type query_type);
1723
1724 /**
1725 Print list of items in ORDER BY clause.
1726
1727 @param thd Thread handle
1728 @param[out] str String of output
1729 @param query_type Options to print out string output
1730 */
1731 void print_order_by(const THD *thd, String *str,
1732 enum_query_type query_type) const;
1733
1734 void print_limit(const THD *thd, String *str,
1735 enum_query_type query_type) const;
1736 bool save_properties(THD *thd);
1737
1738 /**
1739 Accept function for SELECT and DELETE.
1740
1741 @param visitor Select_lex_visitor Object
1742 */
1743 bool accept(Select_lex_visitor *visitor);
1744
1745 /**
1746 Cleanup this subtree (this Query_block and all nested Query_blockes and
1747 Query_expressions).
1748 @param full if false only partial cleanup is done, JOINs and JOIN_TABs are
1749 kept to provide info for EXPLAIN CONNECTION; if true, complete cleanup is
1750 done, all JOINs are freed.
1751 */
1752 void cleanup(bool full) override;
1753 /*
1754 Recursively cleanup the join of this select lex and of all nested
1755 select lexes. This is not a full cleanup.
1756 */
1757 void cleanup_all_joins();
1758 /**
1759 Destroy contained objects, in particular temporary tables which may
1760 have their own mem_roots.
1761 */
1762 void destroy();
1763
1764 /// @return true when query block is not part of a set operation and is not a
1765 /// parenthesized query expression.
1768 }
1769
1770 /**
1771 @return true if query block is found during preparation to produce no data.
1772 Notice that if query is implicitly grouped, an aggregation row will
1773 still be returned.
1774 */
1775 bool is_empty_query() const { return m_empty_query; }
1776
1777 /// Set query block as returning no data
1778 /// @todo This may also be set when we have an always false WHERE clause
1780 assert(join == nullptr);
1781 m_empty_query = true;
1782 }
1783 /*
1784 For MODE_ONLY_FULL_GROUP_BY we need to know if
1785 this query block is the aggregation query of at least one aggregate
1786 function.
1787 */
1788 bool agg_func_used() const { return m_agg_func_used; }
1790
1791 void set_agg_func_used(bool val) { m_agg_func_used = val; }
1792
1794
1795 bool right_joins() const { return m_right_joins; }
1797
1798 /// Lookup for Query_block type
1799 enum_explain_type type() const;
1800
1801 /// Lookup for a type string
1802 const char *get_type_str() { return type_str[static_cast<int>(type())]; }
1804 return type_str[static_cast<int>(type)];
1805 }
1806
1808 bool is_cacheable() const { return !uncacheable; }
1809
1810 /// @returns true if this query block outputs at most one row.
1812 return (m_table_list.size() == 0 &&
1813 (!is_table_value_constructor || row_value_list->size() == 1));
1814 }
1815
1816 /// Include query block inside a query expression.
1817 void include_down(LEX *lex, Query_expression *outer);
1818
1819 /// Include a query block next to another query block.
1820 void include_neighbour(LEX *lex, Query_block *before);
1821
1822 /// Include query block inside a query expression, but do not link.
1824
1825 /// Include query block into global list.
1826 void include_in_global(Query_block **plink);
1827
1828 /// Include chain of query blocks into global list.
1830
1831 /// Renumber query blocks of contained query expressions
1832 void renumber(LEX *lex);
1833
1834 /**
1835 Does permanent transformations which are local to a query block (which do
1836 not merge it to another block).
1837 */
1838 bool apply_local_transforms(THD *thd, bool prune);
1839
1840 /// Pushes parts of the WHERE condition of this query block to materialized
1841 /// derived tables.
1843
1844 bool get_optimizable_conditions(THD *thd, Item **new_where,
1845 Item **new_having);
1846
1847 bool validate_outermost_option(LEX *lex, const char *wrong_option) const;
1848 bool validate_base_options(LEX *lex, ulonglong options) const;
1849
1850 bool walk(Item_processor processor, enum_walk walk, uchar *arg);
1851
1852 bool add_tables(THD *thd, const Mem_root_array<Table_ident *> *tables,
1853 ulong table_options, thr_lock_type lock_type,
1854 enum_mdl_type mdl_type);
1855
1856 bool resolve_rollup_wfs(THD *thd);
1857
1858 bool setup_conds(THD *thd);
1859 bool prepare(THD *thd, mem_root_deque<Item *> *insert_field_list);
1860 bool optimize(THD *thd, bool finalize_access_paths);
1861 void reset_nj_counters(mem_root_deque<Table_ref *> *join_list = nullptr);
1862
1863 // If the query block has exactly one single visible field, returns it.
1864 // If not, returns nullptr.
1865 Item *single_visible_field() const;
1866 size_t num_visible_fields() const;
1867
1868 // Whether the SELECT list is empty (hidden fields are ignored).
1869 // Typically used to distinguish INSERT INTO ... SELECT queries
1870 // from INSERT INTO ... VALUES queries.
1871 bool field_list_is_empty() const;
1872
1873 /// Creates a clone for the given expression by re-parsing the
1874 /// expression. Used in condition pushdown to derived tables.
1875 Item *clone_expression(THD *thd, Item *item, Table_ref *derived_table);
1876 /// Returns an expression from the select list of the query block
1877 /// using the field's index in a derived table.
1878 Item *get_derived_expr(uint expr_index);
1879
1881 AccessPath *child_path, TABLE *dst_table) const;
1882
1883 // ************************************************
1884 // * Members (most of these should not be public) *
1885 // ************************************************
1886
1888 /**
1889 All expressions needed after join and filtering, ie., select list,
1890 group by list, having clause, window clause, order by clause,
1891 including hidden fields.
1892 Does not include join conditions nor where clause.
1893
1894 This should ideally be changed into Mem_root_array<Item *>, but
1895 find_order_in_list() depends on pointer stability (it stores a pointer
1896 to an element in referenced_by[]). Similarly, there are some instances
1897 of thd->change_item_tree() that store pointers to elements in this list.
1898
1899 Because of this, adding or removing elements in the middle is not allowed;
1900 std::deque guarantees pointer stability only in the face of adding
1901 or removing elements from either end, ie., {push,pop}_{front_back}.
1902
1903 Currently, all hidden items must be before all visible items.
1904 This is primarily due to the requirement for pointer stability
1905 but also because change_to_use_tmp_fields() depends on it when mapping
1906 items to ref_item_array indexes. It would be good to get rid of this
1907 requirement in the future.
1908 */
1910
1911 /**
1912 All windows defined on the select, both named and inlined
1913 */
1915
1916 /**
1917 A pointer to ftfunc_list_alloc, list of full text search functions.
1918 */
1921
1922 /// The VALUES items of a table value constructor.
1924
1925 /// List of semi-join nests generated for this query block
1927
1928 /// List of tables in FROM clause - use Table_ref::next_local to traverse
1930
1931 /**
1932 ORDER BY clause.
1933 This list may be mutated during optimization (by remove_const() in the old
1934 optimizer or by RemoveRedundantOrderElements() in the hypergraph optimizer),
1935 so for prepared statements, we keep a copy of the ORDER.next pointers in
1936 order_list_ptrs, and re-establish the original list before each execution.
1937 */
1940
1941 /**
1942 GROUP BY clause. This list may be mutated during optimization (by
1943 \c remove_const() in the old optimizer or by
1944 RemoveRedundantOrderElements() in the hypergraph optimizer), so for prepared
1945 statements, we keep a copy of the ORDER.next pointers in \c group_list_ptrs,
1946 and re-establish the original list before each execution. The list can also
1947 be temporarily pruned and restored by \c Group_check (if transform done,
1948 cf. \c Query_block::m_gl_size_orig).
1949 */
1952 /**
1953 For an explicitly grouped, correlated, scalar subquery which is transformed
1954 to join with derived tables: the number of added non-column expressions.
1955 Used for better functional dependency analysis since this is checked during
1956 prepare *after* transformations. Transforms will append inner expressions
1957 to the group by list, rendering the check too optimistic. To remedy this,
1958 we temporarily remove the added compound (i.e. not simple column)
1959 expressions when doing the full group by check. This is bit too
1960 pessimistic: we can get occasionally false positives (full group by check
1961 error). The underlying problem is that we do not perform full group by
1962 checking before transformations. See also \c Group_check's ctor and dtor.
1963 */
1965
1966 // Used so that AggregateIterator knows which items to signal when the rollup
1967 // level changes. Obviously only used in the presence of rollup.
1972
1973 /// Query-block-level hints, for this query block
1975
1976 char *db{nullptr};
1977
1978 /**
1979 If this query block is a recursive member of a recursive unit: the
1980 Table_ref, in this recursive member, referencing the query
1981 name.
1982 */
1984
1985 /// Reference to LEX that this query block belongs to
1986 LEX *parent_lex{nullptr};
1987
1988 /**
1989 The set of those tables whose fields are referenced in the select list of
1990 this select level.
1991 */
1993 table_map outer_join{0}; ///< Bitmap of all inner tables from outer joins
1994
1995 /**
1996 Context for name resolution for all column references except columns
1997 from joined tables.
1998 */
2000
2001 /**
2002 Pointer to first object in list of Name res context objects that have
2003 this query block as the base query block.
2004 Includes field "context" which is embedded in this query block.
2005 */
2007
2008 /**
2009 After optimization it is pointer to corresponding JOIN. This member
2010 should be changed only when THD::LOCK_query_plan mutex is taken.
2011 */
2012 JOIN *join{nullptr};
2013 /// Set of table references contained in outer-most join nest
2015 /// Pointer to the set of table references in the currently active join
2017 /// table embedding the above list
2019 /**
2020 Points to first leaf table of query block. After setup_tables() is done,
2021 this is a list of base tables and derived tables. After derived tables
2022 processing is done, this is a list of base tables only.
2023 Use Table_ref::next_leaf to traverse the list.
2024 */
2026 /// Last table for LATERAL join, used by table functions
2028
2029 /// LIMIT clause, NULL if no limit is given
2031 /// LIMIT ... OFFSET clause, NULL if no offset is given
2033
2034 /**
2035 Circular linked list of aggregate functions in nested query blocks.
2036 This is needed if said aggregate functions depend on outer values
2037 from this query block; if so, we want to add them as hidden items
2038 in our own field list, to be able to evaluate them.
2039 @see Item_sum::check_sum_func
2040 */
2042
2043 /**
2044 Array of pointers to "base" items; one each for every selected expression
2045 and referenced item in the query block. All references to fields are to
2046 buffers associated with the primary input tables.
2047 */
2049
2050 uint select_number{0}; ///< Query block number (used for EXPLAIN)
2051
2052 /**
2053 Saved values of the WHERE and HAVING clauses. Allowed values are:
2054 - COND_UNDEF if the condition was not specified in the query or if it
2055 has not been optimized yet
2056 - COND_TRUE if the condition is always true
2057 - COND_FALSE if the condition is impossible
2058 - COND_OK otherwise
2059 */
2062
2063 /// Parse context: indicates where the current expression is being parsed
2065 /// Parse context: is inside a set function if this is positive
2067 /// Parse context: is inside a window function if this is positive
2069
2070 /**
2071 Three fields used by semi-join transformations to know when semi-join is
2072 possible, and in which condition tree the subquery predicate is located.
2073 */
2083 RESOLVE_NONE}; ///< Indicates part of query being resolved
2084
2085 /**
2086 Number of fields used in select list or where clause of current select
2087 and all inner subselects.
2088 */
2090 /**
2091 Number of items in the select list, HAVING clause, QUALIFY clause and ORDER
2092 BY clause. It is used to reserve space in the base_ref_items array so that
2093 it is big enough to hold hidden items for any of the expressions or
2094 sub-expressions in those clauses.
2095 */
2097 /// Number of arguments of and/or/xor in where/having/on
2099 /// Number of predicates after preparation
2100 uint cond_count{0};
2101 /// Number of between predicates in where/having/on
2103 /// Maximal number of elements in multiple equalities
2105
2106 /**
2107 Number of Item_sum-derived objects in this SELECT. Keeps count of
2108 aggregate functions and window functions(to allocate items in ref array).
2109 See Query_block::setup_base_ref_items.
2110 */
2112 /// Number of Item_sum-derived objects in children and descendant SELECTs
2114
2115 /// Keep track for allocation of base_ref_items: scalar subqueries may be
2116 /// replaced by a field during scalar_to_derived transformation
2118
2119 /// Number of materialized derived tables and views in this query block.
2121 /// Number of partitioned tables
2123
2124 /**
2125 Number of wildcards used in the SELECT list. For example,
2126 SELECT *, t1.*, catalog.t2.* FROM t0, t1, t2;
2127 has 3 wildcards.
2128 */
2129 uint with_wild{0};
2130
2131 /// Number of leaf tables in this query block.
2133 /// Number of derived tables and views in this query block.
2135 /// Number of table functions in this query block
2137
2138 /**
2139 Nesting level of query block, outer-most query block has level 0,
2140 its subqueries have level 1, etc. @see also sql/item_sum.h.
2141 */
2143
2144 /**
2145 Indicates whether this query block contains non-primitive grouping (such as
2146 ROLLUP).
2147 */
2149
2150 /// @see enum_condition_context
2152
2153 /// If set, the query block is of the form VALUES row_list.
2155
2156 /// Describes context of this query block (e.g if it is a derived table).
2158
2159 /**
2160 result of this query can't be cached, bit field, can be :
2161 UNCACHEABLE_DEPENDENT
2162 UNCACHEABLE_RAND
2163 UNCACHEABLE_SIDEEFFECT
2164 */
2166
2167 void update_used_tables();
2169 bool save_cmd_properties(THD *thd);
2170
2171 /**
2172 This variable is required to ensure proper work of subqueries and
2173 stored procedures. Generally, one should use the states of
2174 Query_arena to determine if it's a statement prepare or first
2175 execution of a stored procedure. However, in case when there was an
2176 error during the first execution of a stored procedure, the SP body
2177 is not expelled from the SP cache. Therefore, a deeply nested
2178 subquery might be left unoptimized. So we need this per-subquery
2179 variable to inidicate the optimization/execution state of every
2180 subquery. Prepared statements work OK in that regard, as in
2181 case of an error during prepare the PS is not created.
2182 */
2184
2185 /// True when semi-join pull-out processing is complete
2186 bool sj_pullout_done{false};
2187
2188 /// Used by nested scalar_to_derived transformations
2190
2191 /// True: skip local transformations during prepare() call (used by INSERT)
2193
2195
2196 /// true when having fix field called in processing of this query block
2197 bool having_fix_field{false};
2198 /// true when GROUP BY fix field called in processing of this query block
2199 bool group_fix_field{false};
2200
2201 /**
2202 True if contains or aggregates set functions.
2203 @note this is wrong when a locally found set function is aggregated
2204 in an outer query block.
2205 */
2206 bool with_sum_func{false};
2207
2208 /**
2209 HAVING clause contains subquery => we can't close tables before
2210 query processing end even if we use temporary table
2211 */
2213
2214 /**
2215 If true, use select_limit to limit number of rows selected.
2216 Applicable when no explicit limit is supplied, and only for the
2217 outermost query block of a SELECT statement.
2218 */
2220
2221 /// If true, limit object is added internally
2222 bool m_internal_limit{false};
2223
2224 /// exclude this query block from unique_table() check
2226
2227 bool no_table_names_allowed{false}; ///< used for global order by
2228
2229 /// Hidden items added during optimization
2230 /// @note that using this means we modify resolved data during optimization
2232
2234
2235 private:
2236 friend class Query_expression;
2237 friend class Condition_context;
2238
2239 /// Helper for save_properties()
2241 Group_list_ptrs **list_ptrs);
2242
2244 bool simplify_joins(THD *thd, mem_root_deque<Table_ref *> *join_list,
2245 bool top, bool in_sj, Item **new_conds,
2246 uint *changelog = nullptr);
2247 /// Remove semijoin condition for this query block
2248 void clear_sj_expressions(NESTED_JOIN *nested_join);
2249 /// Build semijoin condition for th query block
2250 bool build_sj_cond(THD *thd, NESTED_JOIN *nested_join,
2251 Query_block *subq_query_block, table_map outer_tables_map,
2252 Item **sj_cond, bool *simple_const);
2254 Table_ref *join_nest);
2255
2258 Item *join_cond, bool left_outer,
2259 bool use_inner_join);
2260 bool transform_subquery_to_derived(THD *thd, Table_ref **out_tl,
2261 Query_expression *subs_query_expression,
2262 Item_subselect *subq, bool use_inner_join,
2263 bool reject_multiple_rows,
2264 Item *join_condition,
2265 Item *lifted_where_cond);
2267 THD *thd, Item_exists_subselect *subq_pred);
2269 THD *thd, Table_ref *derived, Lifted_expressions_map *lifted_expressions,
2270 mem_root_deque<Item *> &exprs_added_to_group_by, uint hidden_fields);
2272 Lifted_expressions_map *lifted_exprs,
2273 Item *selected_field_or_ref,
2274 const uint first_non_hidden);
2276 THD *thd, Lifted_expressions_map *lifted_exprs);
2278 THD *thd, List_iterator<Item> &inner_exprs, Item *selected_item,
2279 bool *selected_expr_added_to_group_by,
2280 mem_root_deque<Item *> *exprs_added_to_group_by);
2282 THD *thd, Table_ref *derived, Item *lifted_where,
2283 Lifted_expressions_map *lifted_where_expressions, bool *added_card_check,
2284 size_t *added_window_card_checks);
2286 THD *thd, Table_ref *derived, Lifted_expressions_map *lifted_exprs,
2287 bool added_card_check, size_t added_window_card_checks);
2288 void replace_referenced_item(Item *const old_item, Item *const new_item);
2289 void remap_tables(THD *thd);
2291 Item *resolve_rollup_item(THD *thd, Item *item);
2292 bool resolve_rollup(THD *thd);
2293
2294 bool setup_wild(THD *thd);
2295 bool setup_order_final(THD *thd);
2296 bool setup_group(THD *thd);
2297 void fix_after_pullout(Query_block *parent_query_block,
2298 Query_block *removed_query_block);
2301 bool empty_order_list(Query_block *sl);
2303 bool in_update);
2304 bool find_common_table_expr(THD *thd, Table_ident *table_id, Table_ref *tl,
2305 Parse_context *pc, bool *found);
2306 /**
2307 Transform eligible scalar subqueries in the SELECT list, WHERE condition,
2308 HAVING condition or JOIN conditions of a query block[*] to an equivalent
2309 derived table of a LEFT OUTER join, e.g. as shown in this uncorrelated
2310 subquery:
2311
2312 [*] a.k.a "transformed query block" throughout this method and its minions.
2313
2314 <pre>
2315 SELECT * FROM t1
2316 WHERE t1.a > (SELECT COUNT(a) AS cnt FROM t2); ->
2317
2318 SELECT t1.* FROM t1 LEFT OUTER JOIN
2319 (SELECT COUNT(a) AS cnt FROM t2) AS derived
2320 ON TRUE WHERE t1.a > derived.cnt;
2321 </pre>
2322
2323 Grouping in the transformed query block may necessitate the grouping to be
2324 moved down to another derived table, cf. transform_grouped_to_derived.
2325
2326 Limitations:
2327 - only implicitly grouped subqueries (guaranteed to have cardinality one)
2328 are identified as scalar subqueries.
2329 _ Correlated subqueries are not handled
2330
2331 @param[in,out] thd the session context
2332 @returns true on error
2333 */
2336 Item **lifted_where);
2337 bool replace_item_in_expression(Item **expr, bool was_hidden,
2339 Item_transformer transformer);
2340 bool transform_grouped_to_derived(THD *thd, bool *break_off);
2341 bool replace_subquery_in_expr(THD *thd, Item::Css_info *subquery,
2342 Table_ref *tr, Item **expr);
2343 bool nest_derived(THD *thd, Item *join_cond,
2344 mem_root_deque<Table_ref *> *join_list,
2345 Table_ref *new_derived_table);
2346
2348
2349 // Delete unused columns from merged derived tables
2351
2352 bool prepare_values(THD *thd);
2353 bool check_only_full_group_by(THD *thd);
2354 /**
2355 Copies all non-aggregated calls to the full-text search MATCH function from
2356 the HAVING clause to the SELECT list (as hidden items), so that we can
2357 materialize their result and not only their input. This is needed when the
2358 result will be accessed after aggregation, as the result from MATCH cannot
2359 be recalculated from its input alone. It also needs the underlying scan to
2360 be positioned on the correct row. Storing the value before aggregation
2361 removes the need for evaluating MATCH again after materialization.
2362 */
2364
2365 //
2366 // Members:
2367 //
2368
2369 /**
2370 Pointer to collection of subqueries candidate for semi/antijoin
2371 conversion.
2372 Template parameter is "true": no need to run DTORs on pointers.
2373 */
2375
2376 /// How many expressions are part of the order by but not select list.
2378
2379 /**
2380 Intrusive linked list of all query blocks within the same
2381 query expression.
2382 */
2384
2385 /// The query expression containing this query block.
2387 /// The first query expression contained within this query block.
2389
2390 /// Intrusive double-linked global list of query blocks.
2393
2394 /// Result of this query block
2396
2397 /**
2398 Options assigned from parsing and throughout resolving,
2399 should not be modified after resolving is done.
2400 */
2402 /**
2403 Active options. Derived from base options, modifiers added during
2404 resolving and values from session variable option_bits. Since the latter
2405 may change, active options are refreshed per execution of a statement.
2406 */
2408
2409 /**
2410 If the query block includes non-primitive grouping, then these modifiers are
2411 represented as grouping sets. The variable 'm_num_grouping_sets' holds the
2412 count of grouping sets.
2413 */
2415
2416 public:
2418 nullptr}; ///< Used when resolving outer join condition
2419
2420 /**
2421 Initializes the grouping set if the query block includes GROUP BY
2422 modifiers.
2423 */
2424 bool allocate_grouping_sets(THD *thd);
2425
2426 /**
2427 Populates the grouping sets if the query block includes non-primitive
2428 grouping.
2429 */
2430 bool populate_grouping_sets(THD *thd);
2432
2433 private:
2434 /**
2435 Condition to be evaluated after all tables in a query block are joined.
2436 After all permanent transformations have been conducted by
2437 Query_block::prepare(), this condition is "frozen", any subsequent changes
2438 to it must be done with change_item_tree(), unless they only modify AND/OR
2439 items and use a copy created by Query_block::get_optimizable_conditions().
2440 Same is true for 'having_cond'.
2441 */
2443
2444 /// Condition to be evaluated on grouped rows after grouping.
2446
2447 /// Condition to be evaluated after window functions.
2449
2450 /// Number of GROUP BY expressions added to all_fields
2452
2453 /// A backup of the items in base_ref_items at the end of preparation, so that
2454 /// base_ref_items can be restored between executions of prepared statements.
2455 /// Empty if it's a regular statement.
2457
2458 /**
2459 True if query block has semi-join nests merged into it. Notice that this
2460 is updated earlier than sj_nests, so check this if info is needed
2461 before the full resolver process is complete.
2462 */
2463 bool has_sj_nests{false};
2464 bool has_aj_nests{false}; ///< @see has_sj_nests; counts antijoin nests.
2465 bool m_right_joins{false}; ///< True if query block has right joins
2466
2467 /// Allow merge of immediate unnamed derived tables
2469
2470 bool m_agg_func_used{false};
2472
2473 /**
2474 True if query block does not generate any rows before aggregation,
2475 determined during preparation (not optimization).
2476 */
2477 bool m_empty_query{false};
2478
2479 static const char
2481};
2482
2483inline bool Query_expression::is_union() const {
2484 Query_term *qt = query_term();
2485 while (qt->term_type() == QT_UNARY)
2486 qt = down_cast<Query_term_unary *>(qt)->m_children[0];
2487 return qt->term_type() == QT_UNION;
2488}
2489
2491 Query_term *qt = query_term();
2492 while (qt->term_type() == QT_UNARY)
2493 qt = down_cast<Query_term_unary *>(qt)->m_children[0];
2494 const Query_term_type type = qt->term_type();
2495 return type == QT_UNION || type == QT_INTERSECT || type == QT_EXCEPT;
2496}
2497
2498/// Utility RAII class to save/modify/restore the condition_context information
2499/// of a query block. @see enum_condition_context.
2501 public:
2503 Query_block *select_ptr,
2505 : select(nullptr), saved_value() {
2506 if (select_ptr) {
2507 select = select_ptr;
2509 // More restrictive wins over less restrictive:
2510 if (new_type == enum_condition_context::NEITHER ||
2511 (new_type == enum_condition_context::ANDS_ORS &&
2513 select->condition_context = new_type;
2514 }
2515 }
2518 }
2519
2520 private:
2523};
2524
2526 std::function<bool(Table_ref *)> action);
2527
2528/**
2529 Base class for secondary engine execution context objects. Secondary
2530 storage engines may create classes derived from this one which
2531 contain state they need to preserve between optimization and
2532 execution of statements. The context objects should be allocated on
2533 the execution MEM_ROOT.
2534*/
2536 public:
2537 /**
2538 Destructs the secondary engine execution context object. It is
2539 called after the query execution has completed. Secondary engines
2540 may override the destructor in subclasses and add code that
2541 performs cleanup tasks that are needed after query execution.
2542 */
2544};
2545
2547 char *user;
2551
2552 void reset();
2554
2560 LEX_CSTRING language; ///< CREATE|ALTER ... LANGUAGE <language>
2561};
2562
2563extern const LEX_STRING null_lex_str;
2564
2568
2569 /**
2570 FOLLOWS or PRECEDES as specified in the CREATE TRIGGER statement.
2571 */
2573
2574 /**
2575 Trigger name referenced in the FOLLOWS/PRECEDES clause of the CREATE TRIGGER
2576 statement.
2577 */
2579};
2580
2582
2583/*
2584 Class representing list of all tables used by statement and other
2585 information which is necessary for opening and locking its tables,
2586 like SQL command for this statement.
2587
2588 Also contains information about stored functions used by statement
2589 since during its execution we may have to add all tables used by its
2590 stored functions/triggers to this list in order to pre-open and lock
2591 them.
2592
2593 Also used by LEX::reset_n_backup/restore_backup_query_tables_list()
2594 methods to save and restore this information.
2595*/
2596
2598 public:
2600
2601 /**
2602 SQL command for this statement. Part of this class since the
2603 process of opening and locking tables for the statement needs
2604 this information to determine correct type of lock for some of
2605 the tables.
2606 */
2608 /* Global list of all tables used by this statement */
2610 /* Pointer to next_global member of last element in the previous list. */
2612 /*
2613 If non-0 then indicates that query requires prelocking and points to
2614 next_global member of last own element in query table list (i.e. last
2615 table which was not added to it as part of preparation to prelocking).
2616 0 - indicates that this query does not need prelocking.
2617 */
2619 /*
2620 Set of stored routines called by statement.
2621 (Note that we use lazy-initialization for this hash).
2622
2623 See Sroutine_hash_entry for explanation why this hash uses binary
2624 key comparison.
2625 */
2627 std::unique_ptr<malloc_unordered_map<std::string, Sroutine_hash_entry *>>
2629 /*
2630 List linking elements of 'sroutines' set. Allows you to add new elements
2631 to this set as you iterate through the list of existing elements.
2632 'sroutines_list_own_last' is pointer to ::next member of last element of
2633 this list which represents routine which is explicitly used by query.
2634 'sroutines_list_own_elements' number of explicitly used routines.
2635 We use these two members for restoring of 'sroutines_list' to the state
2636 in which it was right after query parsing.
2637 */
2641
2642 /**
2643 Locking state of tables in this particular statement.
2644
2645 If we under LOCK TABLES or in prelocked mode we consider tables
2646 for the statement to be "locked" if there was a call to lock_tables()
2647 (which called handler::start_stmt()) for tables of this statement
2648 and there was no matching close_thread_tables() call.
2649
2650 As result this state may differ significantly from one represented
2651 by Open_tables_state::lock/locked_tables_mode more, which are always
2652 "on" under LOCK TABLES or in prelocked mode.
2653 */
2657 return (lock_tables_state == LTS_LOCKED);
2658 }
2659
2660 /**
2661 Number of tables which were open by open_tables() and to be locked
2662 by lock_tables().
2663 Note that we set this member only in some cases, when this value
2664 needs to be passed from open_tables() to lock_tables() which are
2665 separated by some amount of code.
2666 */
2668
2669 /*
2670 These constructor and destructor serve for creation/destruction
2671 of Query_tables_list instances which are used as backup storage.
2672 */
2675
2676 /* Initializes (or resets) Query_tables_list object for "real" use. */
2677 void reset_query_tables_list(bool init);
2680 *this = std::move(*state);
2681 }
2682
2683 /*
2684 Direct addition to the list of query tables.
2685 If you are using this function, you must ensure that the table
2686 object, in particular table->db member, is initialized.
2687 */
2689 *(table->prev_global = query_tables_last) = table;
2690 query_tables_last = &table->next_global;
2691 }
2693 void mark_as_requiring_prelocking(Table_ref **tables_own_last) {
2694 query_tables_own_last = tables_own_last;
2695 }
2696 /* Return pointer to first not-own table in query-tables or 0 */
2698 return (query_tables_own_last ? *query_tables_own_last : nullptr);
2699 }
2702 *query_tables_own_last = nullptr;
2704 query_tables_own_last = nullptr;
2705 }
2706 }
2707
2708 /**
2709 All types of unsafe statements.
2710
2711 @note The int values of the enum elements are used to point to
2712 bits in two bitmaps in two different places:
2713
2714 - Query_tables_list::binlog_stmt_flags
2715 - THD::binlog_unsafe_warning_flags
2716
2717 Hence in practice this is not an enum at all, but a map from
2718 symbols to bit indexes.
2719
2720 The ordering of elements in this enum must correspond to the order of
2721 elements in the array binlog_stmt_unsafe_errcode.
2722 */
2724 /**
2725 SELECT..LIMIT is unsafe because the set of rows returned cannot
2726 be predicted.
2727 */
2729 /**
2730 Access to log tables is unsafe because slave and master probably
2731 log different things.
2732 */
2734 /**
2735 Inserting into an autoincrement column in a stored routine is unsafe.
2736 Even with just one autoincrement column, if the routine is invoked more
2737 than once slave is not guaranteed to execute the statement graph same way
2738 as the master. And since it's impossible to estimate how many times a
2739 routine can be invoked at the query pre-execution phase (see lock_tables),
2740 the statement is marked pessimistically unsafe.
2741 */
2743 /**
2744 Using a UDF (user-defined function) is unsafe.
2745 */
2747 /**
2748 Using most system variables is unsafe, because slave may run
2749 with different options than master.
2750 */
2752 /**
2753 Using some functions is unsafe (e.g., UUID).
2754 */
2756
2757 /**
2758 Mixing transactional and non-transactional statements are unsafe if
2759 non-transactional reads or writes are occur after transactional
2760 reads or writes inside a transaction.
2761 */
2763
2764 /**
2765 Mixing self-logging and non-self-logging engines in a statement
2766 is unsafe.
2767 */
2769
2770 /**
2771 Statements that read from both transactional and non-transactional
2772 tables and write to any of them are unsafe.
2773 */
2775
2776 /**
2777 INSERT...IGNORE SELECT is unsafe because which rows are ignored depends
2778 on the order that rows are retrieved by SELECT. This order cannot be
2779 predicted and may differ on master and the slave.
2780 */
2782
2783 /**
2784 INSERT...SELECT...UPDATE is unsafe because which rows are updated depends
2785 on the order that rows are retrieved by SELECT. This order cannot be
2786 predicted and may differ on master and the slave.
2787 */
2789
2790 /**
2791 Query that writes to a table with auto_inc column after selecting from
2792 other tables are unsafe as the order in which the rows are retrieved by
2793 select may differ on master and slave.
2794 */
2796
2797 /**
2798 INSERT...REPLACE SELECT is unsafe because which rows are replaced depends
2799 on the order that rows are retrieved by SELECT. This order cannot be
2800 predicted and may differ on master and the slave.
2801 */
2803
2804 /**
2805 CREATE TABLE... IGNORE... SELECT is unsafe because which rows are ignored
2806 depends on the order that rows are retrieved by SELECT. This order cannot
2807 be predicted and may differ on master and the slave.
2808 */
2810
2811 /**
2812 CREATE TABLE...REPLACE... SELECT is unsafe because which rows are replaced
2813 depends on the order that rows are retrieved from SELECT. This order
2814 cannot be predicted and may differ on master and the slave
2815 */
2817
2818 /**
2819 CREATE TABLE...SELECT on a table with auto-increment column is unsafe
2820 because which rows are replaced depends on the order that rows are
2821 retrieved from SELECT. This order cannot be predicted and may differ on
2822 master and the slave
2823 */
2825
2826 /**
2827 UPDATE...IGNORE is unsafe because which rows are ignored depends on the
2828 order that rows are updated. This order cannot be predicted and may differ
2829 on master and the slave.
2830 */
2832
2833 /**
2834 INSERT... ON DUPLICATE KEY UPDATE on a table with more than one
2835 UNIQUE KEYS is unsafe.
2836 */
2838
2839 /**
2840 INSERT into auto-inc field which is not the first part in composed
2841 primary key.
2842 */
2844
2845 /**
2846 Using a plugin is unsafe.
2847 */
2851
2852 /**
2853 XA transactions and statements.
2854 */
2856
2857 /**
2858 If a substatement inserts into or updates a table that has a column with
2859 an unsafe DEFAULT expression, it may not have the same effect on the
2860 slave.
2861 */
2863
2864 /**
2865 DML or DDL statement that reads a ACL table is unsafe, because the row
2866 are read without acquiring SE row locks. This would allow ACL tables to
2867 be updated by concurrent thread. It would not have the same effect on the
2868 slave.
2869 */
2871
2872 /**
2873 Generating invisible primary key for a table created using CREATE TABLE...
2874 SELECT... is unsafe because order in which rows are retrieved by the
2875 SELECT determines which (if any) rows are inserted. This order cannot be
2876 predicted and values for generated invisible primary key column may
2877 differ on source and replica when @@session.binlog_format=STATEMENT.
2878 */
2880
2881 /* the last element of this enumeration type. */
2884 /**
2885 This has all flags from 0 (inclusive) to BINLOG_STMT_FLAG_COUNT
2886 (exclusive) set.
2887 */
2889 ((1 << BINLOG_STMT_UNSAFE_COUNT) - 1);
2890
2891 /**
2892 Maps elements of enum_binlog_stmt_unsafe to error codes.
2893 */
2895
2896 /**
2897 Determine if this statement is marked as unsafe.
2898
2899 @retval 0 if the statement is not marked as unsafe.
2900 @retval nonzero if the statement is marked as unsafe.
2901 */
2902 inline bool is_stmt_unsafe() const { return get_stmt_unsafe_flags() != 0; }
2903
2905 return binlog_stmt_flags & (1 << unsafe);
2906 }
2907
2908 /**
2909 Flag the current (top-level) statement as unsafe.
2910 The flag will be reset after the statement has finished.
2911
2912 @param unsafe_type The type of unsafety: one of the @c
2913 BINLOG_STMT_FLAG_UNSAFE_* flags in @c enum_binlog_stmt_flag.
2914 */
2915 inline void set_stmt_unsafe(enum_binlog_stmt_unsafe unsafe_type) {
2916 DBUG_TRACE;
2917 assert(unsafe_type >= 0 && unsafe_type < BINLOG_STMT_UNSAFE_COUNT);
2918 binlog_stmt_flags |= (1U << unsafe_type);
2919 return;
2920 }
2921
2922 /**
2923 Set the bits of binlog_stmt_flags determining the type of
2924 unsafeness of the current statement. No existing bits will be
2925 cleared, but new bits may be set.
2926
2927 @param flags A binary combination of zero or more bits, (1<<flag)
2928 where flag is a member of enum_binlog_stmt_unsafe.
2929 */
2931 DBUG_TRACE;
2932 assert((flags & ~BINLOG_STMT_UNSAFE_ALL_FLAGS) == 0);
2934 return;
2935 }
2936
2937 /**
2938 Return a binary combination of all unsafe warnings for the
2939 statement. If the statement has been marked as unsafe by the
2940 'flag' member of enum_binlog_stmt_unsafe, then the return value
2941 from this function has bit (1<<flag) set to 1.
2942 */
2944 DBUG_TRACE;
2946 }
2947
2948 /**
2949 Determine if this statement is a row injection.
2950
2951 @retval 0 if the statement is not a row injection
2952 @retval nonzero if the statement is a row injection
2953 */
2954 inline bool is_stmt_row_injection() const {
2955 constexpr uint32_t shift =
2956 static_cast<uint32_t>(BINLOG_STMT_UNSAFE_COUNT) +
2957 static_cast<uint32_t>(BINLOG_STMT_TYPE_ROW_INJECTION);
2958 return binlog_stmt_flags & (1U << shift);
2959 }
2960
2961 /**
2962 Flag the statement as a row injection. A row injection is either
2963 a BINLOG statement, or a row event in the relay log executed by
2964 the slave SQL thread.
2965 */
2967 constexpr uint32_t shift =
2968 static_cast<uint32_t>(BINLOG_STMT_UNSAFE_COUNT) +
2969 static_cast<uint32_t>(BINLOG_STMT_TYPE_ROW_INJECTION);
2970 DBUG_TRACE;
2971 binlog_stmt_flags |= (1U << shift);
2972 }
2973
2975 /*
2976 If a transactional table is about to be read. Note that
2977 a write implies a read.
2978 */
2980 /*
2981 If a non-transactional table is about to be read. Note that
2982 a write implies a read.
2983 */
2985 /*
2986 If a temporary transactional table is about to be read. Note
2987 that a write implies a read.
2988 */
2990 /*
2991 If a temporary non-transactional table is about to be read. Note
2992 that a write implies a read.
2993 */
2995 /*
2996 If a transactional table is about to be updated.
2997 */
2999 /*
3000 If a non-transactional table is about to be updated.
3001 */
3003 /*
3004 If a temporary transactional table is about to be updated.
3005 */
3007 /*
3008 If a temporary non-transactional table is about to be updated.
3009 */
3011 /*
3012 The last element of the enumeration. Please, if necessary add
3013 anything before this.
3014 */
3017
3018#ifndef NDEBUG
3019 static inline const char *stmt_accessed_table_string(
3020 enum_stmt_accessed_table accessed_table) {
3021 switch (accessed_table) {
3023 return "STMT_READS_TRANS_TABLE";
3024 break;
3026 return "STMT_READS_NON_TRANS_TABLE";
3027 break;
3029 return "STMT_READS_TEMP_TRANS_TABLE";
3030 break;
3032 return "STMT_READS_TEMP_NON_TRANS_TABLE";
3033 break;
3035 return "STMT_WRITES_TRANS_TABLE";
3036 break;
3038 return "STMT_WRITES_NON_TRANS_TABLE";
3039 break;
3041 return "STMT_WRITES_TEMP_TRANS_TABLE";
3042 break;
3044 return "STMT_WRITES_TEMP_NON_TRANS_TABLE";
3045 break;
3047 default:
3048 assert(0);
3049 break;
3050 }
3052 return "";
3053 }
3054#endif /* DBUG */
3055
3056#define BINLOG_DIRECT_ON \
3057 0xF0 /* unsafe when \
3058 --binlog-direct-non-trans-updates \
3059 is ON */
3060
3061#define BINLOG_DIRECT_OFF \
3062 0xF /* unsafe when \
3063 --binlog-direct-non-trans-updates \
3064 is OFF */
3065
3066#define TRX_CACHE_EMPTY 0x33 /* unsafe when trx-cache is empty */
3067
3068#define TRX_CACHE_NOT_EMPTY 0xCC /* unsafe when trx-cache is not empty */
3069
3070#define IL_LT_REPEATABLE 0xAA /* unsafe when < ISO_REPEATABLE_READ */
3071
3072#define IL_GTE_REPEATABLE 0x55 /* unsafe when >= ISO_REPEATABLE_READ */
3073
3074 /**
3075 Sets the type of table that is about to be accessed while executing a
3076 statement.
3078 @param accessed_table Enumeration type that defines the type of table,
3079 e.g. temporary, transactional, non-transactional.
3080 */
3081 inline void set_stmt_accessed_table(enum_stmt_accessed_table accessed_table) {
3082 DBUG_TRACE;
3083
3084 assert(accessed_table >= 0 && accessed_table < STMT_ACCESS_TABLE_COUNT);
3085 stmt_accessed_table_flag |= (1U << accessed_table);
3086
3087 return;
3088 }
3089
3090 /**
3091 Checks if a type of table is about to be accessed while executing a
3092 statement.
3093
3094 @param accessed_table Enumeration type that defines the type of table,
3095 e.g. temporary, transactional, non-transactional.
3097 @retval true if the type of the table is about to be accessed
3098 @retval false otherwise
3099 */
3100 inline bool stmt_accessed_table(enum_stmt_accessed_table accessed_table) {
3101 DBUG_TRACE;
3102
3103 assert(accessed_table >= 0 && accessed_table < STMT_ACCESS_TABLE_COUNT);
3104
3105 return (stmt_accessed_table_flag & (1U << accessed_table)) != 0;
3106 }
3107
3108 /*
3109 Checks if a mixed statement is unsafe.
3110
3111
3112 @param in_multi_stmt_transaction_mode defines if there is an on-going
3113 multi-transactional statement.
3114 @param binlog_direct defines if --binlog-direct-non-trans-updates is
3115 active.
3116 @param trx_cache_is_not_empty defines if the trx-cache is empty or not.
3117 @param trx_isolation defines the isolation level.
3118
3119 @return
3120 @retval true if the mixed statement is unsafe
3121 @retval false otherwise
3122 */
3123 inline bool is_mixed_stmt_unsafe(bool in_multi_stmt_transaction_mode,
3124 bool binlog_direct,
3125 bool trx_cache_is_not_empty,
3126 uint tx_isolation) {
3127 bool unsafe = false;
3128
3129 if (in_multi_stmt_transaction_mode) {
3130 const uint condition =
3131 (binlog_direct ? BINLOG_DIRECT_ON : BINLOG_DIRECT_OFF) &
3132 (trx_cache_is_not_empty ? TRX_CACHE_NOT_EMPTY : TRX_CACHE_EMPTY) &
3133 (tx_isolation >= ISO_REPEATABLE_READ ? IL_GTE_REPEATABLE
3135
3136 unsafe = (binlog_unsafe_map[stmt_accessed_table_flag] & condition);
3137
3138#if !defined(NDEBUG)
3139 DBUG_PRINT("LEX::is_mixed_stmt_unsafe",
3140 ("RESULT %02X %02X %02X\n", condition,
3143
3144 int type_in = 0;
3145 for (; type_in < STMT_ACCESS_TABLE_COUNT; type_in++) {
3147 DBUG_PRINT("LEX::is_mixed_stmt_unsafe",
3148 ("ACCESSED %s ", stmt_accessed_table_string(
3149 (enum_stmt_accessed_table)type_in)));
3150 }
3151#endif
3152 }
3153
3156 tx_isolation < ISO_REPEATABLE_READ)
3157 unsafe = true;
3160 tx_isolation < ISO_REPEATABLE_READ)
3161 unsafe = true;
3162
3163 return (unsafe);
3164 }
3165
3166 /**
3167 true if the parsed tree contains references to stored procedures
3168 or functions, false otherwise
3170 bool uses_stored_routines() const { return sroutines_list.elements != 0; }
3172 void set_using_match() { using_match = true; }
3173 bool get_using_match() { return using_match; }
3174
3176 bool is_stmt_unsafe_with_mixed_mode() const {
3178 }
3179
3180 private:
3181 /**
3182 Enumeration listing special types of statements.
3183
3184 Currently, the only possible type is ROW_INJECTION.
3185 */
3187 /**
3188 The statement is a row injection (i.e., either a BINLOG
3189 statement or a row event executed by the slave SQL thread).
3190 */
3192
3193 /** The last element of this enumeration type. */
3195 };
3196
3197 /**
3198 Bit field indicating the type of statement.
3199
3200 There are two groups of bits:
3201
3202 - The low BINLOG_STMT_UNSAFE_COUNT bits indicate the types of
3203 unsafeness that the current statement has.
3204
3205 - The next BINLOG_STMT_TYPE_COUNT bits indicate if the statement
3206 is of some special type.
3207
3208 This must be a member of LEX, not of THD: each stored procedure
3209 needs to remember its unsafeness state between calls and each
3210 stored procedure has its own LEX object (but no own THD object).
3211 */
3213
3214 /**
3215 Bit field that determines the type of tables that are about to be
3216 be accessed while executing a statement.
3217 */
3220 /**
3221 It will be set true if 'MATCH () AGAINST' is used in the statement.
3222 */
3223 bool using_match;
3224
3225 /**
3226 This flag is set to true if statement is unsafe to be binlogged in STATEMENT
3227 format, when in MIXED mode.
3228 Currently this flag is set to true if stored program used in statement has
3229 CREATE/DROP temporary table operation(s) as sub-statement(s).
3230 */
3231 bool stmt_unsafe_with_mixed_mode{false};
3232};
3233
3234/*
3235 st_parsing_options contains the flags for constructions that are
3236 allowed in the current statement.
3238
3240 bool allows_variable;
3241 bool allows_select_into;
3242
3243 st_parsing_options() { reset(); }
3244 void reset();
3245};
3247/**
3248 The state of the lexical parser, when parsing comments.
3249*/
3251 /**
3252 Not parsing comments.
3253 */
3254 NO_COMMENT,
3255
3256 /**
3257 Parsing comments that need to be preserved.
3258 (Copy '/' '*' and '*' '/' sequences to the preprocessed buffer.)
3259 Typically, these are user comments '/' '*' ... '*' '/'.
3260 */
3262
3263 /**
3264 Parsing comments that need to be discarded.
3265 (Don't copy '/' '*' '!' and '*' '/' sequences to the preprocessed buffer.)
3266 Typically, these are special comments '/' '*' '!' ... '*' '/',
3267 or '/' '*' '!' 'M' 'M' 'm' 'm' 'm' ... '*' '/', where the comment
3268 markers should not be expanded.
3269 */
3271};
3272
3273/**
3274 This class represents the character input stream consumed during lexical
3275 analysis.
3276
3277 In addition to consuming the input stream, this class performs some comment
3278 pre processing, by filtering out out-of-bound special text from the query
3279 input stream.
3280
3281 Two buffers, with pointers inside each, are maintained in parallel. The
3282 'raw' buffer is the original query text, which may contain out-of-bound
3283 comments. The 'cpp' (for comments pre processor) is the pre-processed buffer
3284 that contains only the query text that should be seen once out-of-bound data
3285 is removed.
3286*/
3287
3288class Lex_input_stream {
3289 public:
3290 /**
3291 Constructor
3293 @param grammar_selector_token_arg See grammar_selector_token.
3294 */
3295
3296 explicit Lex_input_stream(uint grammar_selector_token_arg)
3297 : grammar_selector_token(grammar_selector_token_arg) {}
3298
3299 /**
3300 Object initializer. Must be called before usage.
3302 @retval false OK
3303 @retval true Error
3304 */
3305 bool init(THD *thd, const char *buff, size_t length);
3306
3307 void reset(const char *buff, size_t length);
3308
3309 /**
3310 Set the echo mode.
3311
3312 When echo is true, characters parsed from the raw input stream are
3313 preserved. When false, characters parsed are silently ignored.
3314 @param echo the echo mode.
3315 */
3316 void set_echo(bool echo) { m_echo = echo; }
3317
3318 void save_in_comment_state() {
3321 }
3322
3326 }
3327
3328 /**
3329 Skip binary from the input stream.
3330 @param n number of bytes to accept.
3331 */
3332 void skip_binary(int n) {
3333 assert(m_ptr + n <= m_end_of_query);
3334 if (m_echo) {
3335 memcpy(m_cpp_ptr, m_ptr, n);
3336 m_cpp_ptr += n;
3337 }
3338 m_ptr += n;
3339 }
3340
3341 /**
3342 Get a character, and advance in the stream.
3343 @return the next character to parse.
3344 */
3345 unsigned char yyGet() {
3346 assert(m_ptr <= m_end_of_query);
3347 const char c = *m_ptr++;
3348 if (m_echo) *m_cpp_ptr++ = c;
3349 return c;
3350 }
3351
3352 /**
3353 Get the last character accepted.
3354 @return the last character accepted.
3355 */
3356 unsigned char yyGetLast() const { return m_ptr[-1]; }
3358 /**
3359 Look at the next character to parse, but do not accept it.
3360 */
3361 unsigned char yyPeek() const {
3362 assert(m_ptr <= m_end_of_query);
3363 return m_ptr[0];
3364 }
3365
3366 /**
3367 Look ahead at some character to parse.
3368 @param n offset of the character to look up
3369 */
3370 unsigned char yyPeekn(int n) const {
3371 assert(m_ptr + n <= m_end_of_query);
3372 return m_ptr[n];
3373 }
3374
3375 /**
3376 Cancel the effect of the last yyGet() or yySkip().
3377 Note that the echo mode should not change between calls to yyGet / yySkip
3378 and yyUnget. The caller is responsible for ensuring that.
3379 */
3380 void yyUnget() {
3381 m_ptr--;
3382 if (m_echo) m_cpp_ptr--;
3383 }
3385 /**
3386 Accept a character, by advancing the input stream.
3387 */
3388 void yySkip() {
3389 assert(m_ptr <= m_end_of_query);
3390 if (m_echo)
3391 *m_cpp_ptr++ = *m_ptr++;
3392 else
3393 m_ptr++;
3394 }
3395
3396 /**
3397 Accept multiple characters at once.
3398 @param n the number of characters to accept.
3399 */
3400 void yySkipn(int n) {
3401 assert(m_ptr + n <= m_end_of_query);
3402 if (m_echo) {
3403 memcpy(m_cpp_ptr, m_ptr, n);
3404 m_cpp_ptr += n;
3405 }
3406 m_ptr += n;
3407 }
3408
3409 /**
3410 Puts a character back into the stream, canceling
3411 the effect of the last yyGet() or yySkip().
3412 Note that the echo mode should not change between calls
3413 to unput, get, or skip from the stream.
3414 */
3415 char *yyUnput(char ch) {
3416 *--m_ptr = ch;
3417 if (m_echo) m_cpp_ptr--;
3418 return m_ptr;
3419 }
3420
3421 /**
3422 Inject a character into the pre-processed stream.
3423
3424 Note, this function is used to inject a space instead of multi-character
3425 C-comment. Thus there is no boundary checks here (basically, we replace
3426 N-chars by 1-char here).
3427 */
3428 char *cpp_inject(char ch) {
3429 *m_cpp_ptr = ch;
3430 return ++m_cpp_ptr;
3431 }
3432
3433 /**
3434 End of file indicator for the query text to parse.
3435 @return true if there are no more characters to parse
3436 */
3437 bool eof() const { return (m_ptr >= m_end_of_query); }
3438
3439 /**
3440 End of file indicator for the query text to parse.
3441 @param n number of characters expected
3442 @return true if there are less than n characters to parse
3444 bool eof(int n) const { return ((m_ptr + n) >= m_end_of_query); }
3445
3446 /** Get the raw query buffer. */
3447 const char *get_buf() const { return m_buf; }
3448
3449 /** Get the pre-processed query buffer. */
3450 const char *get_cpp_buf() const { return m_cpp_buf; }
3451
3452 /** Get the end of the raw query buffer. */
3453 const char *get_end_of_query() const { return m_end_of_query; }
3454
3455 /** Mark the stream position as the start of a new token. */
3456 void start_token() {
3458 m_tok_end = m_ptr;
3459
3462 }
3463
3464 /**
3465 Adjust the starting position of the current token.
3466 This is used to compensate for starting whitespace.
3467 */
3468 void restart_token() {
3471 }
3472
3473 /** Get the token start position, in the raw buffer. */
3474 const char *get_tok_start() const { return m_tok_start; }
3475
3476 /** Get the token start position, in the pre-processed buffer. */
3477 const char *get_cpp_tok_start() const { return m_cpp_tok_start; }
3478
3479 /** Get the token end position, in the raw buffer. */
3480 const char *get_tok_end() const { return m_tok_end; }
3481
3482 /** Get the token end position, in the pre-processed buffer. */
3483 const char *get_cpp_tok_end() const { return m_cpp_tok_end; }
3484
3485 /** Get the current stream pointer, in the raw buffer. */
3486 const char *get_ptr() const { return m_ptr; }
3487
3488 /** Get the current stream pointer, in the pre-processed buffer. */
3489 const char *get_cpp_ptr() const { return m_cpp_ptr; }
3490
3491 /** Get the length of the current token, in the raw buffer. */
3492 uint yyLength() const {
3493 /*
3494 The assumption is that the lexical analyser is always 1 character ahead,
3495 which the -1 account for.
3496 */
3497 assert(m_ptr > m_tok_start);
3498 return (uint)((m_ptr - m_tok_start) - 1);
3499 }
3500
3501 /** Get the utf8-body string. */
3502 const char *get_body_utf8_str() const { return m_body_utf8; }
3503
3504 /** Get the utf8-body length. */
3509 void body_utf8_start(THD *thd, const char *begin_ptr);
3510 void body_utf8_append(const char *ptr);
3511 void body_utf8_append(const char *ptr, const char *end_ptr);
3513 const CHARSET_INFO *txt_cs,
3514 const char *end_ptr);
3515
3516 uint get_lineno(const char *raw_ptr) const;
3517
3518 /** Current thread. */
3519 THD *m_thd;
3520
3521 /** Current line number. */
3522 uint yylineno;
3523
3524 /** Length of the last token parsed. */
3525 uint yytoklen;
3526
3527 /** Interface with bison, value of the last token parsed. */
3529
3530 /**
3531 LALR(2) resolution, look ahead token.
3532 Value of the next token to return, if any,
3533 or -1, if no token was parsed in advance.
3534 Note: 0 is a legal token, and represents YYEOF.
3535 */
3536 int lookahead_token;
3537
3538 /** LALR(2) resolution, value of the look ahead token.*/
3540
3541 /// Skip adding of the current token's digest since it is already added
3542 ///
3543 /// Usually we calculate a digest token by token at the top-level function
3544 /// of the lexer: MYSQLlex(). However, some complex ("hintable") tokens break
3545 /// that data flow: for example, the `SELECT /*+ HINT(t) */` is the single
3546 /// token from the main parser's point of view, and we add the "SELECT"
3547 /// keyword to the digest buffer right after the lex_one_token() call,
3548 /// but the "/*+ HINT(t) */" is a sequence of separate tokens from the hint
3549 /// parser's point of view, and we add those tokens to the digest buffer
3550 /// *inside* the lex_one_token() call. Thus, the usual data flow adds
3551 /// tokens from the "/*+ HINT(t) */" string first, and only than it appends
3552 /// the "SELECT" keyword token to that stream: "/*+ HINT(t) */ SELECT".
3553 /// This is not acceptable, since we use the digest buffer to restore
3554 /// query strings in their normalized forms, so the order of added tokens is
3555 /// important. Thus, we add tokens of "hintable" keywords to a digest buffer
3556 /// right in the hint parser and skip adding of them at the caller with the
3557 /// help of skip_digest flag.
3559
3560 void add_digest_token(uint token, Lexer_yystype *yylval);
3561
3562 void reduce_digest_token(uint token_left, uint token_right);
3563
3564 /**
3565 True if this scanner tokenizes a partial query (partition expression,
3566 generated column expression etc.)
3567
3568 @return true if parsing a partial query, otherwise false.
3569 */
3570 bool is_partial_parser() const { return grammar_selector_token >= 0; }
3571
3572 /**
3573 Outputs warnings on deprecated charsets in complete SQL statements
3575 @param [in] cs The character set/collation to check for a deprecation.
3576 @param [in] alias The name/alias of @p cs.
3577 */
3579 const char *alias) const {
3580 if (!is_partial_parser()) {
3582 }
3583 }
3584
3585 /**
3586 Outputs warnings on deprecated collations in complete SQL statements
3587
3588 @param [in] collation The collation to check for a deprecation.
3589 */
3591 if (!is_partial_parser()) {
3593 }
3594 }
3595
3597
3598 private:
3599 /** Pointer to the current position in the raw input stream. */
3600 char *m_ptr;
3601
3602 /** Starting position of the last token parsed, in the raw buffer. */
3603 const char *m_tok_start;
3604
3605 /** Ending position of the previous token parsed, in the raw buffer. */
3606 const char *m_tok_end;
3607
3608 /** End of the query text in the input stream, in the raw buffer. */
3609 const char *m_end_of_query;
3610
3611 /** Beginning of the query text in the input stream, in the raw buffer. */
3612 const char *m_buf;
3613
3614 /** Length of the raw buffer. */
3615 size_t m_buf_length;
3616
3617 /** Echo the parsed stream to the pre-processed buffer. */
3618 bool m_echo;
3619 bool m_echo_saved;
3620
3621 /** Pre-processed buffer. */
3622 char *m_cpp_buf;
3623
3624 /** Pointer to the current position in the pre-processed input stream. */
3625 char *m_cpp_ptr;
3626
3627 /**
3628 Starting position of the last token parsed,
3629 in the pre-processed buffer.
3630 */
3631 const char *m_cpp_tok_start;
3632
3633 /**
3634 Ending position of the previous token parsed,
3635 in the pre-processed buffer.
3636 */
3637 const char *m_cpp_tok_end;
3638
3639 /** UTF8-body buffer created during parsing. */
3640 char *m_body_utf8;
3641
3642 /** Pointer to the current position in the UTF8-body buffer. */
3643 char *m_body_utf8_ptr;
3644
3645 /**
3646 Position in the pre-processed buffer. The query from m_cpp_buf to
3647 m_cpp_utf_processed_ptr is converted to UTF8-body.
3648 */
3649 const char *m_cpp_utf8_processed_ptr;
3650
3651 public:
3652 /** Current state of the lexical analyser. */
3654
3655 /**
3656 Position of ';' in the stream, to delimit multiple queries.
3657 This delimiter is in the raw buffer.
3658 */
3659 const char *found_semicolon;
3660
3661 /** Token character bitmaps, to detect 7bit strings. */
3663
3664 /** SQL_MODE = IGNORE_SPACE. */
3665 bool ignore_space;
3666
3667 /**
3668 true if we're parsing a prepared statement: in this mode
3669 we should allow placeholders.
3670 */
3671 bool stmt_prepare_mode;
3672 /**
3673 true if we should allow multi-statements.
3674 */
3675 bool multi_statements;
3676
3677 /** State of the lexical analyser for comments. */
3680
3681 /**
3682 Starting position of the TEXT_STRING or IDENT in the pre-processed
3683 buffer.
3684
3685 NOTE: this member must be used within MYSQLlex() function only.
3686 */
3687 const char *m_cpp_text_start;
3688
3689 /**
3690 Ending position of the TEXT_STRING or IDENT in the pre-processed
3691 buffer.
3692
3693 NOTE: this member must be used within MYSQLlex() function only.
3694 */
3695 const char *m_cpp_text_end;
3696
3697 /**
3698 Character set specified by the character-set-introducer.
3699
3700 NOTE: this member must be used within MYSQLlex() function only.
3701 */
3703
3704 /**
3705 Current statement digest instrumentation.
3706 */
3708
3709 /**
3710 The synthetic 1st token to prepend token stream with.
3711
3712 This token value tricks parser to simulate multiple %start-ing points.
3713 Currently the grammar is aware of 4 such synthetic tokens:
3714 1. GRAMMAR_SELECTOR_PART for partitioning stuff from DD,
3715 2. GRAMMAR_SELECTOR_GCOL for generated column stuff from DD,
3716 3. GRAMMAR_SELECTOR_EXPR for generic single expressions from DD/.frm.
3717 4. GRAMMAR_SELECTOR_CTE for generic subquery expressions from CTEs.
3718 5. -1 when parsing with the main grammar (no grammar selector available).
3719
3720 @note yylex() is expected to return the value of type int:
3721 0 is for EOF and everything else for real token numbers.
3722 Bison, in its turn, generates positive token numbers.
3723 So, the negative grammar_selector_token means "not a token".
3724 In other words, -1 is "empty value".
3725 */
3726 const int grammar_selector_token;
3728 bool text_string_is_7bit() const { return !(tok_bitmap & 0x80); }
3732 public:
3733 String column;
3735 LEX_COLUMN(const String &x, const Access_bitmask &y) : column(x), rights(y) {}
3736};
3737
3738enum class role_enum;
3740/*
3741 This structure holds information about grantor's context
3742*/
3743class LEX_GRANT_AS {
3744 public:
3746 void cleanup();
3748 public:
3749 bool grant_as_used;
3751 LEX_USER *user;
3753};
3754
3755/*
3756 Some queries can be executed only using the secondary engine. The enum
3757 "execute_only_in_secondary_reasons" retains the explanations for queries that
3758 cannot be executed using the primary engine.
3759*/
3762 CUBE,
3764};
3765
3767 Some queries can be executed only in using the hypergraph optimizer. The enum
3768 "execute_only_in_hypergraph_reasons" retains the explanations for the same.
3773};
3774
3775/**
3776 The LEX object currently serves three different purposes:
3777
3778 - It contains some universal properties of an SQL command, such as
3779 sql_command, presence of IGNORE in data change statement syntax, and list
3780 of tables (query_tables).
3781
3782 - It contains some execution state variables, like m_exec_started
3783 (set to true when execution is started), plugins (list of plugins used
3784 by statement), insert_update_values_map (a map of objects used by certain
3785 INSERT statements), etc.
3786
3787 - It contains a number of members that should be local to subclasses of
3788 Sql_cmd, like purge_value_list (for the PURGE command), kill_value_list
3789 (for the KILL command).
3790
3791 The LEX object is strictly a part of class Sql_cmd, for those SQL commands
3792 that are represented by an Sql_cmd class. For the remaining SQL commands,
3793 it is a standalone object linked to the current THD.
3794
3795 The lifecycle of a LEX object is as follows:
3796
3797 - The LEX object is constructed either on the execution mem_root
3798 (for regular statements), on a Prepared_statement mem_root (for
3799 prepared statements), on an SP mem_root (for stored procedure instructions),
3800 or created on the current mem_root for short-lived uses.
3801
3802 - Call lex_start() to initialize a LEX object before use.
3803 This initializes the execution state part of the object.
3804 It also calls LEX::reset() to ensure that all members are properly inited.
3805
3806 - Parse and resolve the statement, using the LEX as a work area.
3807
3808 - Execute an SQL command: call set_exec_started() when starting to execute
3809 (actually when starting to optimize).
3810 Typically call is_exec_started() to distinguish between preparation
3811 and optimization/execution stages of SQL command execution.
3812
3813 - Call clear_execution() when execution is finished. This will clear all
3814 execution state associated with the SQL command, it also includes calling
3815 LEX::reset_exec_started().
3816
3817 @todo - Create subclasses of Sql_cmd to contain data that are local
3818 to specific commands.
3819
3820 @todo - Create a Statement context object that will hold the execution state
3821 part of struct LEX.
3822
3823 @todo - Ensure that a LEX struct is never reused, thus making e.g
3824 LEX::reset() redundant.
3825*/
3827struct LEX : public Query_tables_list {
3828 friend bool lex_start(THD *thd);
3830 Query_expression *unit; ///< Outer-most query expression
3831 /// @todo: query_block can be replaced with unit->first-select()
3832 Query_block *query_block; ///< First query block
3833 Query_block *all_query_blocks_list; ///< List of all query blocks
3834 private:
3835 /* current Query_block in parsing */
3837
3839 Some queries can only be executed on a secondary engine, for example,
3840 queries with non-primitive grouping like CUBE.
3841 */
3843
3846
3848 Some queries can only be executed in hypergraph optimizer, for example,
3849 queries with QUALIFY clause.
3850 */
3854
3855 public:
3856 inline Query_block *current_query_block() const {
3857 return m_current_query_block;
3858 }
3859
3860 /*
3861 We want to keep current_thd out of header files, so the debug assert
3862 is moved to the .cc file.
3863 */
3865 inline void set_current_query_block(Query_block *select) {
3866#ifndef NDEBUG
3868#endif
3870 }
3871 /// @return true if this is an EXPLAIN statement
3872 bool is_explain() const { return explain_format != nullptr; }
3873 bool is_explain_analyze = false;
3874
3875 /**
3876 Whether the currently-running statement should be prepared and executed
3877 with the hypergraph optimizer. This will not change after the statement is
3878 prepared, so you can use it in any optimization phase to e.g. figure out
3879 whether to inhibit some transformation that the hypergraph optimizer
3880 does not properly understand yet. If a different optimizer is requested,
3881 the statement must be re-prepared with the proper optimizer settings.
3882 */
3885 }
3886
3887 void set_using_hypergraph_optimizer(bool use_hypergraph) {
3889 }
3890
3891 private:
3894 public:
3897 char *to_log; /* For PURGE BINARY LOGS TO */
3899 // Widcard from SHOW ... LIKE <wildcard> statements.
3903 nullptr, 0}; ///< Argument of the BINLOG event statement.
3910 THD *thd;
3911
3912 /* Optimizer hints */
3915 /* maintain a list of used plugins for this LEX */
3920 /// Table being inserted into (may be a view)
3922 /// Leaf table being inserted into (always a base table)
3924
3925 /** SELECT of CREATE VIEW statement */
3927
3928 /* Partition info structure filled in by PARTITION BY parse part */
3930
3932 The definer of the object being created (view, trigger, stored routine).
3933 I.e. the value of DEFINER clause.
3943
3944 // PURGE statement-specific fields:
3946
3947 // KILL statement-specific fields:
3949
3950 // other stuff:
3952 List<Item_func_set_user_var> set_var_list; // in-query assignment list
3953 /**
3954 List of placeholders ('?') for parameters of a prepared statement. Because
3955 we append to this list during parsing, it is naturally sorted by
3956 position of the '?' in the query string. The code which fills placeholders
3957 with user-supplied values, and the code which writes a query for
3958 statement-based logging, rely on this order.
3959 This list contains only real placeholders, not the clones which originate
3960 in a re-parsed CTE definition.
3961 */
3963
3965
3966 void insert_values_map(Item_field *f1, Field *f2) {
3968 insert_update_values_map = new std::map<Item_field *, Field *>;
3969 insert_update_values_map->insert(std::make_pair(f1, f2));
3970 }
3971 void destroy_values_map() {
3973 insert_update_values_map->clear();
3975 insert_update_values_map = nullptr;
3976 }
3977 }
3978 void clear_values_map() {
3981 }
3982 }
3983 bool has_values_map() const { return insert_update_values_map != nullptr; }
3984 std::map<Item_field *, Field *>::iterator begin_values_map() {
3985 return insert_update_values_map->begin();
3987 std::map<Item_field *, Field *>::iterator end_values_map() {
3988 return insert_update_values_map->end();
3992 }
3994 const bool execute_only_in_secondary_engine_param,
3997 execute_only_in_secondary_engine_param;
4000 reason == SUPPORTED_IN_PRIMARY);
4001 }
4002
4004 const {
4006 }
4007
4011 case CUBE:
4012 return "CUBE";
4013 case TABLESAMPLE:
4014 return "TABLESAMPLE";
4015 default:
4016 return "UNDEFINED";
4017 }
4021 }
4023 bool execute_in_hypergraph_optimizer_param,
4026 execute_in_hypergraph_optimizer_param;
4028 }
4029
4033 ? "QUALIFY clause"
4034 : "UNDEFINED";
4035 }
4036
4038 const {
4040 }
4041
4042 private:
4043 /*
4044 With Visual Studio, an std::map will always allocate two small objects
4045 on the heap. Sometimes we put LEX objects in a MEM_ROOT, and never run
4046 the LEX DTOR. To avoid memory leaks, put this std::map on the heap,
4047 and call clear_values_map() at the end of each statement.
4048 */
4049 std::map<Item_field *, Field *> *insert_update_values_map;
4050
4051 public:
4052 /*
4053 A stack of name resolution contexts for the query. This stack is used
4054 at parse time to set local name resolution contexts for various parts
4055 of a query. For example, in a JOIN ... ON (some_condition) clause the
4056 Items in 'some_condition' must be resolved only against the operands
4057 of the the join, and not against the whole clause. Similarly, Items in
4058 subqueries should be resolved against the subqueries (and outer queries).
4059 The stack is used in the following way: when the parser detects that
4060 all Items in some clause need a local context, it creates a new context
4061 and pushes it on the stack. All newly created Items always store the
4062 top-most context in the stack. Once the parser leaves the clause that
4063 required a local context, the parser pops the top-most context.
4069 HA_CHECK_OPT check_opt; // check/repair options
4072 LEX_SOURCE_INFO mi; // used by CHANGE REPLICATION SOURCE
4077 ulong type;
4078 /**
4079 This field is used as a work field during resolving to validate
4080 the use of aggregate functions. For example in a query
4081 SELECT ... FROM ...WHERE MIN(i) == 1 GROUP BY ... HAVING MIN(i) > 2
4082 MIN(i) in the WHERE clause is not allowed since only non-aggregated data
4083 is present, whereas MIN(i) in the HAVING clause is allowed because HAVING
4084 operates on the output of a grouping operation.
4085 Each query block is assigned a nesting level. This field is a bit field
4086 that contains the value one in the position of that nesting level if
4087 aggregate functions are allowed for that query block.
4088 */
4090 /**
4091 Windowing functions are not allowed in HAVING - in contrast to grouped
4092 aggregate functions, since windowing in SQL logically follows after all
4093 grouping operations. Nor are they allowed inside grouped aggregate
4094 function arguments. One bit per query block, as also \c allow_sum_func. For
4095 ORDER BY and QUALIFY predicates, window functions \em are allowed unless
4096 they are contained in arguments of a grouped aggregate function. Nor are
4097 references to outer window functions (via alias) allowed in subqueries, but
4098 that is checked separately.
4099 */
4102 /// If true: during prepare, we did a subquery transformation (IN-to-EXISTS,
4103 /// SOME/ANY) that doesn't currently work for subquery to a derived table
4104 /// transformation.
4106
4108
4109 /*
4110 Usually `expr` rule of yacc is quite reused but some commands better
4111 not support subqueries which comes standard with this rule, like
4112 KILL, HA_READ, CREATE/ALTER EVENT etc. Set this to `false` to get
4113 syntax error back.
4114 */
4115 bool expr_allows_subquery{true};
4116 /**
4117 If currently re-parsing a CTE's definition, this is the offset in bytes
4118 of that definition in the original statement which had the WITH
4119 clause. Otherwise this is 0.
4120 */
4122 /**
4123 If currently re-parsing a condition which is pushed down to a derived
4124 table, this will be set to true.
4125 */
4127 /**
4128 If currently re-parsing a condition that is being pushed down to a
4129 derived table, this has the positions of all the parameters that are
4130 part of that condition in the original statement. Otherwise it is empty.
4134 enum SSL_type ssl_type; /* defined in violite.h */
4140 /// QUERY ID for SHOW PROFILE
4142 uint profile_options;
4143 uint grant, grant_tot_col;
4144 /**
4145 Set to true when GRANT ... GRANT OPTION ... TO ...
4146 is used (vs. GRANT ... WITH GRANT OPTION).
4147 The flag is used by @ref mysql_grant to grant GRANT OPTION (@ref GRANT_ACL)
4148 to all dynamic privileges.
4152 int select_number; ///< Number of query block (by EXPLAIN)
4155 /**
4156 @todo ensure that correct CONTEXT_ANALYSIS_ONLY is set for all preparation
4157 code, so we can fully rely on this field.
4158 */
4160 bool drop_if_exists;
4161 /**
4162 refers to optional IF EXISTS clause in REVOKE sql. This flag when set to
4163 true will report warnings in case privilege being granted is not granted to
4164 given user/role. When set to false error is reported.
4165 */
4166 bool grant_if_exists;
4167 /**
4168 refers to optional IGNORE UNKNOWN USER clause in REVOKE sql. This flag when
4169 set to true will report warnings in case target user/role for which
4170 privilege being granted does not exists. When set to false error is
4171 reported.
4175 bool autocommit;
4177 // For show commands to show hidden columns and indexes.
4178 bool m_extended_show;
4179
4180 enum enum_yes_no_unknown tx_chain, tx_release;
4181
4182 /**
4183 Whether this query will return the same answer every time, given unchanged
4184 data. Used to be for the query cache, but is now used to find out if an
4185 expression is usable for partitioning.
4186 */
4189 private:
4190 /// True if statement references UDF functions
4191 bool m_has_udf{false};
4194 public:
4195 bool is_ignore() const { return ignore; }
4196 void set_ignore(bool ignore_param) { ignore = ignore_param; }
4197 void set_has_udf() { m_has_udf = true; }
4198 bool has_udf() const { return m_has_udf; }
4201 /* Prepared statements SQL syntax:*/
4202 LEX_CSTRING prepared_stmt_name; /* Statement name (in all queries) */
4204 Prepared statement query text or name of variable that holds the
4205 prepared statement (in PREPARE ... queries)
4206 */
4208 /* If true, prepared_stmt_code is a name of variable that holds the query */
4210 /* Names of user variables holding parameters (in EXECUTE) */
4214 bool sp_lex_in_use; /* Keep track on lex usage in SPs for error handling */
4215 bool all_privileges;
4219
4220 private:
4221 bool m_broken; ///< see mark_broken()
4222 /**
4223 Set to true when execution has started (after parsing, tables opened and
4224 query preparation is complete. Used to track arena state for SPs).
4225 */
4226 bool m_exec_started;
4227 /**
4228 Set to true when execution is completed, ie optimization has been done
4229 and execution is successful or ended in error.
4230 */
4231 bool m_exec_completed;
4232 /**
4233 Current SP parsing context.
4234 @see also sp_head::m_root_parsing_ctx.
4235 */
4238 /**
4239 Statement context for Query_block::make_active_options.
4240 */
4242
4243 public:
4244 /**
4245 Gets the options that have been set for this statement. The options are
4246 propagated to the Query_block objects and should usually be read with
4247 #Query_block::active_options().
4248
4249 @return a bit set of options set for this statement
4250 */
4252 /**
4253 Add options to values of m_statement_options. options is an ORed
4254 bit set of options defined in query_options.h
4256 @param options Add this set of options to the set already in
4257 m_statement_options
4261 }
4262 bool is_broken() const { return m_broken; }
4263 /**
4264 Certain permanent transformations (like in2exists), if they fail, may
4265 leave the LEX in an inconsistent state. They should call the
4266 following function, so that this LEX is not reused by another execution.
4268 @todo If lex_start () were a member function of LEX, the "broken"
4269 argument could always be "true" and thus could be removed.
4270 */
4271 void mark_broken(bool broken = true) {
4272 if (broken) {
4273 /*
4274 "OPEN <cursor>" cannot be re-prepared if the cursor uses no tables
4275 ("SELECT FROM DUAL"). Indeed in that case cursor_query is left empty
4276 in constructions of sp_instr_cpush, and thus
4277 sp_lex_instr::parse_expr() cannot re-prepare. So we mark the statement
4278 as broken only if tables are used.
4279 */
4280 if (is_metadata_used()) m_broken = true;
4281 } else
4282 m_broken = false;
4284
4286
4287 void cleanup(bool full) {
4288 unit->cleanup(full);
4289 if (full) {
4294
4295 bool is_exec_started() const { return m_exec_started; }
4296 void set_exec_started() { m_exec_started = true; }
4297 void reset_exec_started() {
4298 m_exec_started = false;
4299 m_exec_completed = false;
4300 }
4301 /**
4302 Check whether the statement has been executed (regardless of completion -
4303 successful or in error).
4304 Check this instead of Query_expression::is_executed() to determine
4305 the state of a complete statement.
4306 */
4307 bool is_exec_completed() const { return m_exec_completed; }
4308 void set_exec_completed() { m_exec_completed = true; }
4310
4314
4315 /// Check if the current statement uses meta-data (uses a table or a stored
4316 /// routine).
4317 bool is_metadata_used() const {
4318 return query_tables != nullptr || has_udf() ||
4319 (sroutines != nullptr && !sroutines->empty());
4320 }
4321
4322 /// We have detected the presence of an alias of a window function with a
4323 /// window on query block qb. Check if the reference is illegal at this point
4324 /// during resolution.
4325 /// @param qb The query block of the window function
4326 /// @return true if window function is referenced from another query block
4327 /// than its window, or if window functions are disallowed at the current
4328 /// point during prepare, cf. also documentation of \c m_deny_window_func.
4329 bool deny_window_function(Query_block *qb) const {
4330 return qb != current_query_block() ||
4331 ((~allow_sum_func | m_deny_window_func) >>
4333 0x1;
4334 }
4336 public:
4338
4340
4341 bool only_view; /* used for SHOW CREATE TABLE/VIEW */
4342 /*
4343 view created to be run from definer (standard behaviour)
4344 */
4346
4347 /**
4348 Intended to point to the next word after DEFINER-clause in the
4349 following statements:
4350
4351 - CREATE TRIGGER (points to "TRIGGER");
4352 - CREATE PROCEDURE (points to "PROCEDURE");
4353 - CREATE FUNCTION (points to "FUNCTION" or "AGGREGATE");
4354 - CREATE EVENT (points to "EVENT")
4356 This pointer is required to add possibly omitted DEFINER-clause to the
4357 DDL-statement before dumping it to the binlog.
4358 */
4359 const char *stmt_definition_begin;
4360 const char *stmt_definition_end;
4361
4362 /**
4363 During name resolution search only in the table list given by
4364 Name_resolution_context::first_name_resolution_table and
4365 Name_resolution_context::last_name_resolution_table
4366 (see Item_field::fix_fields()).
4367 */
4369
4370 bool is_lex_started; /* If lex_start() did run. For debugging. */
4371 /// Set to true while resolving values in ON DUPLICATE KEY UPDATE clause
4374 class Explain_format *explain_format{nullptr};
4375
4376 // Maximum execution time for a statement.
4377 ulong max_execution_time;
4378
4380 To flag the current statement as dependent for binary logging
4381 on explicit_defaults_for_timestamp
4382 */
4384
4385 /**
4386 Used to inform the parser whether it should contextualize the parse
4387 tree. When we get a pure parser this will not be needed.
4388 */
4389 bool will_contextualize;
4390
4391 LEX();
4393 virtual ~LEX();
4394
4395 /// Destroy contained objects, but not the LEX object itself.
4396 void destroy() {
4397 if (unit == nullptr) return;
4398 unit->destroy();
4399 unit = nullptr;
4400 query_block = nullptr;
4401 all_query_blocks_list = nullptr;
4402 m_current_query_block = nullptr;
4403 explain_format = nullptr;
4405 }
4406
4407 /// Reset query context to initial state
4408 void reset();
4409
4410 /// Create an empty query block within this LEX object.
4412
4413 /// Create query expression object that contains one query block.
4414 Query_block *new_query(Query_block *curr_query_block);
4415
4416 /// Create query block and attach it to the current query expression.
4418
4419 /// Create top-level query expression and query block.
4420 bool new_top_level_query();
4421
4422 /// Create query expression and query block in existing memory objects.
4423 void new_static_query(Query_expression *sel_query_expression,
4424 Query_block *select);
4425
4426 /// Create query expression under current_query_block and a query block under
4427 /// the new query expression. The new query expression is linked in under
4428 /// current_query_block. The new query block is linked in under the new
4429 /// query expression.
4430 ///
4431 /// @param thd current session context
4432 /// @param current_query_block the root under which we create the new
4433 /// expression
4434 /// and block
4435 /// @param where_clause any where clause for the block
4436 /// @param having_clause any having clause for the block
4437 /// @param ctx the parsing context
4438 ///
4439 /// @returns the new query expression, or nullptr on error.
4441 THD *thd, Query_block *current_query_block, Item *where_clause,
4442 Item *having_clause, enum_parsing_context ctx);
4443
4444 inline bool is_ps_or_view_context_analysis() {
4447 }
4448
4449 inline bool is_view_context_analysis() {
4451 }
4452
4453 void clear_execution();
4454
4455 /**
4456 Set the current query as uncacheable.
4457
4458 @param curr_query_block Current select query block
4459 @param cause Why this query is uncacheable.
4460
4461 @details
4462 All query blocks representing subqueries, from the current one up to
4463 the outer-most one, but excluding the main query block, are also set
4464 as uncacheable.
4465 */
4466 void set_uncacheable(Query_block *curr_query_block, uint8 cause) {
4467 safe_to_cache_query = false;
4468
4469 if (m_current_query_block == nullptr) return;
4470 Query_block *sl;
4471 Query_expression *un;
4472 for (sl = curr_query_block, un = sl->master_query_expression(); un != unit;
4473 sl = sl->outer_query_block(), un = sl->master_query_expression()) {
4474 sl->uncacheable |= cause;
4475 un->uncacheable |= cause;
4476 }
4477 }
4479
4480 Table_ref *unlink_first_table(bool *link_to_local);
4481 void link_first_table_back(Table_ref *first, bool link_to_local);
4483
4485
4487 for (Table_ref *tr = insert_table->first_leaf_table(); tr != nullptr;
4488 tr = tr->next_leaf)
4489 tr->restore_properties();
4490 }
4491
4493
4494 bool can_use_merged();
4495 bool can_not_use_merged();
4496 bool need_correct_ident();
4497 /*
4498 Is this update command where 'WHITH CHECK OPTION' clause is important
4499
4500 SYNOPSIS
4501 LEX::which_check_option_applicable()
4502
4503 RETURN
4504 true have to take 'WHITH CHECK OPTION' clause into account
4505 false 'WHITH CHECK OPTION' clause do not need
4506 */
4507 inline bool which_check_option_applicable() {
4508 switch (sql_command) {
4509 case SQLCOM_UPDATE:
4511 case SQLCOM_INSERT:
4513 case SQLCOM_REPLACE:
4515 case SQLCOM_LOAD:
4516 return true;
4517 default:
4518 return false;
4519 }
4521
4523
4525 return context_stack.push_front(context);
4526 }
4527
4528 void pop_context() { context_stack.pop(); }
4529
4530 bool copy_db_to(char const **p_db, size_t *p_db_length) const;
4531
4532 bool copy_db_to(char **p_db, size_t *p_db_length) const {
4533 return copy_db_to(const_cast<const char **>(p_db), p_db_length);
4534 }
4535
4537
4540
4541 bool table_or_sp_used();
4542
4543 /**
4544 @brief check if the statement is a single-level join
4545 @return result of the check
4546 @retval true The statement doesn't contain subqueries, unions and
4547 stored procedure calls.
4548 @retval false There are subqueries, UNIONs or stored procedure calls.
4549 */
4550 bool is_single_level_stmt() {
4551 /*
4552 This check exploits the fact that the last added to all_select_list is
4553 on its top. So query_block (as the first added) will be at the tail
4554 of the list.
4555 */
4557 (sroutines == nullptr || sroutines->empty())) {
4559 return true;
4560 }
4561 return false;
4562 }
4563
4564 void release_plugins();
4565
4566 /**
4567 IS schema queries read some dynamic table statistics from SE.
4568 These statistics are cached, to avoid opening of table more
4569 than once while preparing a single output record buffer.
4570 */
4573
4574 bool accept(Select_lex_visitor *visitor);
4575
4576 bool set_wild(LEX_STRING);
4577 void clear_privileges();
4578
4579 bool make_sql_cmd(Parse_tree_root *parse_tree);
4580
4581 private:
4582 /**
4583 Context object used by secondary storage engines to store query
4584 state during optimization and execution.
4585 */
4587
4588 public:
4589 /**
4590 Gets the secondary engine execution context for this statement.
4591 */
4593 const {
4595 }
4596
4597 /**
4598 Sets the secondary engine execution context for this statement.
4599 The old context object is destroyed, if there is one. Can be set
4600 to nullptr to destroy the old context object and clear the
4601 pointer.
4602
4603 The supplied context object should be allocated on the execution
4604 MEM_ROOT, so that its memory doesn't have to be manually freed
4605 after query execution.
4606 */
4609
4610 /**
4611 Validates if a query can run with the old optimizer.
4612 @return True if the query cannot be run with old optimizer, false otherwise.
4615
4616 private:
4618
4619 public:
4622 }
4623
4626 }
4629
4630 private:
4631 bool rewrite_required{false};
4633 public:
4634 void set_rewrite_required() { rewrite_required = true; }
4635 void reset_rewrite_required() { rewrite_required = false; }
4636 bool is_rewrite_required() { return rewrite_required; }
4637};
4638
4640 RAII class to ease the call of LEX::mark_broken() if error.
4641 Used during preparation and optimization of DML queries.
4642*/
4644 public:
4645 Prepare_error_tracker(THD *thd_arg) : thd(thd_arg) {}
4647
4648 private:
4649 THD *const thd;
4650};
4651
4652/**
4653 The internal state of the syntax parser.
4654 This object is only available during parsing,
4655 and is private to the syntax parser implementation (sql_yacc.yy).
4656*/
4657class Yacc_state {
4658 public:
4660 reset();
4661 }
4662
4663 void reset() {
4664 if (yacc_yyss != nullptr) {
4666 yacc_yyss = nullptr;
4667 }
4668 if (yacc_yyvs != nullptr) {
4670 yacc_yyvs = nullptr;
4671 }
4672 if (yacc_yyls != nullptr) {
4674 yacc_yyls = nullptr;
4675 }
4678 }
4679
4680 ~Yacc_state();
4681
4682 /**
4683 Reset part of the state which needs resetting before parsing
4684 substatement.
4685 */
4689 }
4690
4691 /**
4692 Bison internal state stack, yyss, when dynamically allocated using
4693 my_yyoverflow().
4694 */
4696
4697 /**
4698 Bison internal semantic value stack, yyvs, when dynamically allocated using
4699 my_yyoverflow().
4700 */
4702
4703 /**
4704 Bison internal location value stack, yyls, when dynamically allocated using
4705 my_yyoverflow().
4706 */
4708
4709 /**
4710 Type of lock to be used for tables being added to the statement's
4711 table list in table_factor, table_alias_ref, single_multi and
4712 table_wild_one rules.
4713 Statements which use these rules but require lock type different
4714 from one specified by this member have to override it by using
4715 Query_block::set_lock_for_tables() method.
4716
4717 The default value of this member is TL_READ_DEFAULT. The only two
4718 cases in which we change it are:
4719 - When parsing SELECT HIGH_PRIORITY.
4720 - Rule for DELETE. In which we use this member to pass information
4721 about type of lock from delete to single_multi part of rule.
4722
4723 We should try to avoid introducing new use cases as we would like
4724 to get rid of this member eventually.
4725 */
4727
4728 /**
4729 The type of requested metadata lock for tables added to
4730 the statement table list.
4731 */
4733
4734 /*
4735 TODO: move more attributes from the LEX structure here.
4736 */
4737};
4738
4739/**
4740 Input parameters to the parser.
4741*/
4742struct Parser_input {
4743 /**
4744 True if the text parsed corresponds to an actual query,
4745 and not another text artifact.
4746 This flag is used to disable digest parsing of nested:
4747 - view definitions
4748 - table trigger definitions
4749 - table partition definitions
4750 - event scheduler event definitions
4751 */
4752 bool m_has_digest;
4753 /**
4754 True if the caller needs to compute a digest.
4755 This flag is used to request explicitly a digest computation,
4756 independently of the performance schema configuration.
4757 */
4758 bool m_compute_digest;
4759
4760 Parser_input() : m_has_digest(false), m_compute_digest(false) {}
4761};
4762
4763/**
4764 Internal state of the parser.
4765 The complete state consist of:
4766 - input parameters that control the parser behavior
4767 - state data used during lexical parsing,
4768 - state data used during syntactic parsing.
4769*/
4770class Parser_state {
4771 protected:
4772 /**
4773 Constructor for special parsers of partial SQL clauses (DD)
4774
4775 @param grammar_selector_token See Lex_input_stream::grammar_selector_token
4776 */
4777 explicit Parser_state(int grammar_selector_token)
4778 : m_input(), m_lip(grammar_selector_token), m_yacc(), m_comment(false) {}
4779
4780 public:
4781 Parser_state() : m_input(), m_lip(~0U), m_yacc(), m_comment(false) {}
4782
4783 /**
4784 Object initializer. Must be called before usage.
4786 @retval false OK
4787 @retval true Error
4788 */
4789 bool init(THD *thd, const char *buff, size_t length) {
4790 return m_lip.init(thd, buff, length);
4791 }
4792
4793 void reset(const char *found_semicolon, size_t length) {
4794 m_lip.reset(found_semicolon, length);
4796 }
4798 /// Signal that the current query has a comment
4799 void add_comment() { m_comment = true; }
4800 /// Check whether the current query has a comment
4801 bool has_comment() const { return m_comment; }
4802
4803 public:
4807 /**
4808 Current performance digest instrumentation.
4809 */
4811
4812 private:
4813 bool m_comment; ///< True if current query contains comments
4814};
4816/**
4817 Parser state for partition expression parser (.frm/DD stuff)
4818*/
4820 public:
4822
4824};
4826/**
4827 Parser state for generated column expression parser (.frm/DD stuff)
4828*/
4830 public:
4832
4834};
4836/**
4837 Parser state for single expression parser (.frm/DD stuff)
4838*/
4840 public:
4842
4843 Item *result;
4844};
4846/**
4847 Parser state for CTE subquery parser
4848*/
4850 public:
4852
4854};
4855
4857 Parser state for Derived table's condition parser.
4858 (Used in condition pushdown to derived tables)
4859*/
4861 public:
4865};
4866
4867struct st_lex_local : public LEX {
4868 static void *operator new(size_t size) noexcept {
4869 return (*THR_MALLOC)->Alloc(size);
4870 }
4871 static void *operator new(size_t size, MEM_ROOT *mem_root,
4872 const std::nothrow_t &arg
4873 [[maybe_unused]] = std::nothrow) noexcept {
4874 return mem_root->Alloc(size);
4875 }
4876 static void operator delete(void *ptr [[maybe_unused]],
4877 size_t size [[maybe_unused]]) {
4878 TRASH(ptr, size);
4879 }
4880 static void operator delete(
4881 void *, MEM_ROOT *, const std::nothrow_t &) noexcept { /* Never called */
4882 }
4883};
4884
4885extern void lex_free(void);
4886extern bool lex_start(THD *thd);
4887extern void lex_end(LEX *lex);
4888extern int my_sql_parser_lex(MY_SQL_PARSER_STYPE *, POS *, class THD *);
4889
4890extern void trim_whitespace(const CHARSET_INFO *cs, LEX_STRING *str);
4891
4892extern bool is_lex_native_function(const LEX_STRING *name);
4894bool is_keyword(const char *name, size_t len);
4895bool db_is_default_db(const char *db, size_t db_len, const THD *thd);
4896
4898
4899void print_derived_column_names(const THD *thd, String *str,
4901
4902/**
4903 @} (End of group GROUP_PARSER)
4904*/
4905
4906/**
4907 Check if the given string is invalid using the system charset.
4908
4909 @param string_val Reference to the string.
4910 @param charset_info Pointer to charset info.
4911
4912 @return true if the string has an invalid encoding using
4913 the system charset else false.
4914*/
4915
4916inline bool is_invalid_string(const LEX_CSTRING &string_val,
4917 const CHARSET_INFO *charset_info) {
4918 size_t valid_len;
4919 bool len_error;
4920
4921 if (validate_string(charset_info, string_val.str, string_val.length,
4922 &valid_len, &len_error)) {
4923 char hexbuf[7];
4924 octet2hex(
4925 hexbuf, string_val.str + valid_len,
4926 static_cast<uint>(std::min<size_t>(string_val.length - valid_len, 3)));
4927 my_error(ER_INVALID_CHARACTER_STRING, MYF(0), charset_info->csname, hexbuf);
4928 return true;
4929 }
4930 return false;
4931}
4932
4933/**
4934 Check if the given string is invalid using the system charset.
4935
4936 @param string_val Reference to the string.
4937 @param charset_info Pointer to charset info.
4938 @param[out] invalid_sub_str If string has an invalid encoding then invalid
4939 string in printable ASCII format is stored.
4940
4941 @return true if the string has an invalid encoding using
4942 the system charset else false.
4943*/
4944
4945inline bool is_invalid_string(const LEX_CSTRING &string_val,
4947 std::string &invalid_sub_str) {
4948 size_t valid_len;
4949 bool len_error;
4950
4951 if (validate_string(charset_info, string_val.str, string_val.length,
4952 &valid_len, &len_error)) {
4953 char printable_buff[32];
4955 printable_buff, sizeof(printable_buff), string_val.str + valid_len,
4956 static_cast<uint>(std::min<size_t>(string_val.length - valid_len, 3)),
4957 charset_info, 3);
4958 invalid_sub_str = printable_buff;
4959 return true;
4960 }
4961 return false;
4962}
4963
4964/**
4965 In debug mode, verify that we're not adding an item twice to the fields list
4966 with inconsistent hidden flags. Must be called before adding the item to
4967 fields.
4968 */
4970 [[maybe_unused]],
4971 Item *item [[maybe_unused]],
4972 bool hidden [[maybe_unused]]) {
4973#ifndef NDEBUG
4974 if (std::find(fields.begin(), fields.end(), item) != fields.end()) {
4975 // The item is already in the list, so we can't add it
4976 // with a different value for hidden.
4977 assert(item->hidden == hidden);
4978 }
4979#endif
4980}
4981
4982bool walk_item(Item *item, Select_lex_visitor *visitor);
4984bool accept_table(Table_ref *t, Select_lex_visitor *visitor);
4986 Select_lex_visitor *visitor);
4987Table_ref *nest_join(THD *thd, Query_block *select, Table_ref *embedding,
4988 mem_root_deque<Table_ref *> *jlist, size_t table_cnt,
4989 const char *legend);
4990void get_select_options_str(ulonglong options, std::string *str);
4991#endif /* SQL_LEX_INCLUDED */
static mysql_service_status_t init()
Component initialization.
Definition: audit_api_message_emit.cc:571
uint32_t Access_bitmask
Definition: auth_acls.h:34
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:251
Data describing the table being created by CREATE TABLE or altered by ALTER TABLE.
Definition: sql_alter.h:205
Parser state for CTE subquery parser.
Definition: sql_lex.h:4845
Common_table_expr_parser_state()
Definition: sql_lex.cc:1215
PT_subquery * result
Definition: sql_lex.h:4849
Utility RAII class to save/modify/restore the condition_context information of a query block.
Definition: sql_lex.h:2500
enum_condition_context saved_value
Definition: sql_lex.h:2522
~Condition_context()
Definition: sql_lex.h:2516
Query_block * select
Definition: sql_lex.h:2521
Condition_context(Query_block *select_ptr, enum_condition_context new_type=enum_condition_context::NEITHER)
Definition: sql_lex.h:2502
Parser state for Derived table's condition parser.
Definition: sql_lex.h:4856
Item * result
Definition: sql_lex.h:4860
Derived_expr_parser_state()
Definition: sql_lex.cc:1218
Definition: event_parse_data.h:44
Base class for structured and hierarchical EXPLAIN output formatters.
Definition: opt_explain_format.h:506
Parser state for single expression parser (.frm/DD stuff)
Definition: sql_lex.h:4835
Expression_parser_state()
Definition: sql_lex.cc:1212
Item * result
Definition: sql_lex.h:4839
Definition: field.h:575
Parser state for generated column expression parser (.frm/DD stuff)
Definition: sql_lex.h:4825
Value_generator * result
Definition: sql_lex.h:4829
Gcol_expr_parser_state()
Definition: sql_lex.cc:1209
Definition: sql_lex.h:489
LEX_CSTRING key_name
Definition: sql_lex.h:499
void print(const THD *thd, String *str)
Print an index hint.
Definition: sql_lex.cc:2760
index_clause_map clause
Definition: sql_lex.h:494
enum index_hint_type type
Definition: sql_lex.h:492
Index_hint(const char *str, uint length)
Definition: sql_lex.h:501
Definition: item_cmpfunc.h:2447
Definition: item_subselect.h:428
Definition: item.h:4344
Definition: item_func.h:3414
Definition: item_func.h:3465
This class is used to implement operations like SET @variable or @variable:= expression.
Definition: item_func.h:3224
A wrapper Item that normally returns its parameter, but becomes NULL when processing rows for rollup.
Definition: item_func.h:1679
A wrapper Item that contains a number of aggregate items, one for each level of rollup (see Item_roll...
Definition: item_sum.h:2724
Base class that is common to all subqueries and subquery predicates.
Definition: item_subselect.h:80
Class Item_sum is the base class used for special expressions that SQL calls 'set functions'.
Definition: item_sum.h:399
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:936
cond_result
Definition: item.h:998
@ COND_UNDEF
Definition: item.h:998
Definition: sql_optimizer.h:133
Definition: key_spec.h:67
Definition: sql_lex.h:3727
LEX_COLUMN(const String &x, const Access_bitmask &y)
Definition: sql_lex.h:3731
String column
Definition: sql_lex.h:3729
Access_bitmask rights
Definition: sql_lex.h:3730
Definition: sql_lex.h:3739
List< LEX_USER > * role_list
Definition: sql_lex.h:3748
void cleanup()
Definition: sql_lex.cc:5252
bool grant_as_used
Definition: sql_lex.h:3745
role_enum role_type
Definition: sql_lex.h:3746
LEX_USER * user
Definition: sql_lex.h:3747
LEX_GRANT_AS()
Definition: sql_lex.cc:5259
This class represents the character input stream consumed during lexical analysis.
Definition: sql_lexer_input_stream.h:70
void restart_token()
Adjust the starting position of the current token.
Definition: sql_lexer_input_stream.h:250
void body_utf8_start(THD *thd, const char *begin_ptr)
The operation is called from the parser in order to 1) designate the intention to have utf8 body; 1) ...
Definition: sql_lexer.cc:154
const int grammar_selector_token
The synthetic 1st token to prepend token stream with.
Definition: sql_lexer_input_stream.h:508
void skip_binary(int n)
Skip binary from the input stream.
Definition: sql_lexer_input_stream.h:114
bool skip_digest
Skip adding of the current token's digest since it is already added.
Definition: sql_lexer_input_stream.h:340
const char * m_cpp_text_end
Ending position of the TEXT_STRING or IDENT in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:477
const char * get_end_of_query() const
Get the end of the raw query buffer.
Definition: sql_lexer_input_stream.h:235
sql_digest_state * m_digest
Current statement digest instrumentation.
Definition: sql_lexer_input_stream.h:489
const char * get_cpp_tok_start() const
Get the token start position, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:259
void body_utf8_append(const char *ptr)
The operation appends unprocessed part of the pre-processed buffer till the given pointer (ptr) and s...
Definition: sql_lexer.cc:215
char * m_cpp_ptr
Pointer to the current position in the pre-processed input stream.
Definition: sql_lexer_input_stream.h:407
uchar tok_bitmap
Token character bitmaps, to detect 7bit strings.
Definition: sql_lexer_input_stream.h:444
void restore_in_comment_state()
Definition: sql_lexer_input_stream.h:105
THD * m_thd
Current thread.
Definition: sql_lexer_input_stream.h:301
const char * get_tok_start() const
Get the token start position, in the raw buffer.
Definition: sql_lexer_input_stream.h:256
const CHARSET_INFO * query_charset
Definition: sql_lexer_input_stream.h:378
const char * get_buf() const
Get the raw query buffer.
Definition: sql_lexer_input_stream.h:229
bool multi_statements
true if we should allow multi-statements.
Definition: sql_lexer_input_stream.h:457
char * yyUnput(char ch)
Puts a character back into the stream, canceling the effect of the last yyGet() or yySkip().
Definition: sql_lexer_input_stream.h:197
uint get_body_utf8_length() const
Get the utf8-body length.
Definition: sql_lexer_input_stream.h:287
bool m_echo_saved
Definition: sql_lexer_input_stream.h:401
const char * m_cpp_tok_end
Ending position of the previous token parsed, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:419
char * cpp_inject(char ch)
Inject a character into the pre-processed stream.
Definition: sql_lexer_input_stream.h:210
const char * found_semicolon
Position of ';' in the stream, to delimit multiple queries.
Definition: sql_lexer_input_stream.h:441
void warn_on_deprecated_collation(const CHARSET_INFO *collation) const
Outputs warnings on deprecated collations in complete SQL statements.
Definition: sql_lexer_input_stream.h:372
Lexer_yystype * lookahead_yylval
LALR(2) resolution, value of the look ahead token.
Definition: sql_lexer_input_stream.h:321
bool init(THD *thd, const char *buff, size_t length)
Object initializer.
Definition: sql_lexer.cc:74
enum my_lex_states next_state
Current state of the lexical analyser.
Definition: sql_lexer_input_stream.h:435
const char * get_tok_end() const
Get the token end position, in the raw buffer.
Definition: sql_lexer_input_stream.h:262
uint yyLength() const
Get the length of the current token, in the raw buffer.
Definition: sql_lexer_input_stream.h:274
char * m_body_utf8
UTF8-body buffer created during parsing.
Definition: sql_lexer_input_stream.h:422
const char * get_ptr() const
Get the current stream pointer, in the raw buffer.
Definition: sql_lexer_input_stream.h:268
enum_comment_state in_comment_saved
Definition: sql_lexer_input_stream.h:461
uint get_lineno(const char *raw_ptr) const
Definition: sql_lex.cc:1189
bool text_string_is_7bit() const
Definition: sql_lexer_input_stream.h:510
bool stmt_prepare_mode
true if we're parsing a prepared statement: in this mode we should allow placeholders.
Definition: sql_lexer_input_stream.h:453
const char * get_body_utf8_str() const
Get the utf8-body string.
Definition: sql_lexer_input_stream.h:284
void add_digest_token(uint token, Lexer_yystype *yylval)
Definition: sql_lexer.cc:259
const char * m_cpp_utf8_processed_ptr
Position in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:431
size_t m_buf_length
Length of the raw buffer.
Definition: sql_lexer_input_stream.h:397
const char * get_cpp_tok_end() const
Get the token end position, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:265
const char * get_cpp_buf() const
Get the pre-processed query buffer.
Definition: sql_lexer_input_stream.h:232
void reduce_digest_token(uint token_left, uint token_right)
Definition: sql_lexer.cc:265
char * m_cpp_buf
Pre-processed buffer.
Definition: sql_lexer_input_stream.h:404
const char * m_cpp_text_start
Starting position of the TEXT_STRING or IDENT in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:469
const char * m_tok_start
Starting position of the last token parsed, in the raw buffer.
Definition: sql_lexer_input_stream.h:385
Lex_input_stream(uint grammar_selector_token_arg)
Constructor.
Definition: sql_lexer_input_stream.h:78
void save_in_comment_state()
Definition: sql_lexer_input_stream.h:100
unsigned char yyGet()
Get a character, and advance in the stream.
Definition: sql_lexer_input_stream.h:127
void warn_on_deprecated_charset(const CHARSET_INFO *cs, const char *alias) const
Outputs warnings on deprecated charsets in complete SQL statements.
Definition: sql_lexer_input_stream.h:360
void yySkip()
Accept a character, by advancing the input stream.
Definition: sql_lexer_input_stream.h:170
bool m_echo
Echo the parsed stream to the pre-processed buffer.
Definition: sql_lexer_input_stream.h:400
char * m_body_utf8_ptr
Pointer to the current position in the UTF8-body buffer.
Definition: sql_lexer_input_stream.h:425
uint yylineno
Current line number.
Definition: sql_lexer_input_stream.h:304
void yySkipn(int n)
Accept multiple characters at once.
Definition: sql_lexer_input_stream.h:182
enum_comment_state in_comment
State of the lexical analyser for comments.
Definition: sql_lexer_input_stream.h:460
int lookahead_token
LALR(2) resolution, look ahead token.
Definition: sql_lexer_input_stream.h:318
void body_utf8_append_literal(THD *thd, const LEX_STRING *txt, const CHARSET_INFO *txt_cs, const char *end_ptr)
The operation converts the specified text literal to the utf8 and appends the result to the utf8-body...
Definition: sql_lexer.cc:231
unsigned char yyGetLast() const
Get the last character accepted.
Definition: sql_lexer_input_stream.h:138
bool ignore_space
SQL_MODE = IGNORE_SPACE.
Definition: sql_lexer_input_stream.h:447
void set_echo(bool echo)
Set the echo mode.
Definition: sql_lexer_input_stream.h:98
Lexer_yystype * yylval
Interface with bison, value of the last token parsed.
Definition: sql_lexer_input_stream.h:310
void start_token()
Mark the stream position as the start of a new token.
Definition: sql_lexer_input_stream.h:238
void reset(const char *buff, size_t length)
Prepare Lex_input_stream instance state for use for handling next SQL statement.
Definition: sql_lexer.cc:102
void yyUnget()
Cancel the effect of the last yyGet() or yySkip().
Definition: sql_lexer_input_stream.h:162
char * m_ptr
Pointer to the current position in the raw input stream.
Definition: sql_lexer_input_stream.h:382
const char * m_end_of_query
End of the query text in the input stream, in the raw buffer.
Definition: sql_lexer_input_stream.h:391
unsigned char yyPeekn(int n) const
Look ahead at some character to parse.
Definition: sql_lexer_input_stream.h:152
unsigned char yyPeek() const
Look at the next character to parse, but do not accept it.
Definition: sql_lexer_input_stream.h:143
bool eof() const
End of file indicator for the query text to parse.
Definition: sql_lexer_input_stream.h:219
const CHARSET_INFO * m_underscore_cs
Character set specified by the character-set-introducer.
Definition: sql_lexer_input_stream.h:484
const char * m_tok_end
Ending position of the previous token parsed, in the raw buffer.
Definition: sql_lexer_input_stream.h:388
bool is_partial_parser() const
True if this scanner tokenizes a partial query (partition expression, generated column expression etc...
Definition: sql_lexer_input_stream.h:352
const char * m_buf
Begining of the query text in the input stream, in the raw buffer.
Definition: sql_lexer_input_stream.h:394
const char * m_cpp_tok_start
Starting position of the last token parsed, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:413
uint yytoklen
Length of the last token parsed.
Definition: sql_lexer_input_stream.h:307
const char * get_cpp_ptr() const
Get the current stream pointer, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:271
Definition: sql_list.h:606
Definition: sql_list.h:467
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:426
Storage for name strings.
Definition: item.h:292
Global level hints.
Definition: opt_hints.h:350
Query block level hints.
Definition: opt_hints.h:372
Definition: parse_tree_nodes.h:1773
Represents the WITH clause: WITH [...], [...] SELECT ..., ^^^^^^^^^^^^^^^^^.
Definition: parse_tree_nodes.h:365
Base class for all top-level nodes of SQL statements.
Definition: parse_tree_nodes.h:161
Internal state of the parser.
Definition: sql_lexer_parser_state.h:44
Lex_input_stream m_lip
Definition: sql_lexer_parser_state.h:79
void add_comment()
Signal that the current query has a comment.
Definition: sql_lexer_parser_state.h:73
void reset(const char *found_semicolon, size_t length)
Definition: sql_lexer_parser_state.h:67
Yacc_state m_yacc
Definition: sql_lexer_parser_state.h:80
Parser_state()
Definition: sql_lex.h:4777
Parser_input m_input
Definition: sql_lexer_parser_state.h:78
bool has_comment() const
Check whether the current query has a comment.
Definition: sql_lexer_parser_state.h:75
bool m_comment
True if current query contains comments.
Definition: sql_lexer_parser_state.h:88
bool init(THD *thd, const char *buff, size_t length)
Object initializer.
Definition: sql_lexer_parser_state.h:63
PSI_digest_locker * m_digest_psi
Current performance digest instrumentation.
Definition: sql_lex.h:4806
Parser state for partition expression parser (.frm/DD stuff)
Definition: sql_lex.h:4815
Partition_expr_parser_state()
Definition: sql_lex.cc:1206
partition_info * result
Definition: sql_lex.h:4819
A typesafe replacement for DYNAMIC_ARRAY.
Definition: prealloced_array.h:71
RAII class to ease the call of LEX::mark_broken() if error.
Definition: sql_lex.h:4639
~Prepare_error_tracker()
Definition: sql_lex.cc:139
THD *const thd
Definition: sql_lex.h:4645
Prepare_error_tracker(THD *thd_arg)
Definition: sql_lex.h:4641
Definition: protocol.h:33
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1163
void print_update_list(const THD *thd, String *str, enum_query_type query_type, const mem_root_deque< Item * > &fields, const mem_root_deque< Item * > &values)
Print assignments list.
Definition: sql_lex.cc:3342
void print_delete(const THD *thd, String *str, enum_query_type query_type)
Print detail of the DELETE statement.
Definition: sql_lex.cc:3122
void add_base_options(ulonglong options)
Add base options to a query block, also update active options.
Definition: sql_lex.h:1214
uint n_scalar_subqueries
Keep track for allocation of base_ref_items: scalar subqueries may be replaced by a field during scal...
Definition: sql_lex.h:2117
void label_children() override
Set the correct value of Query_term::m_sibling_idx recursively for set operations.
Definition: sql_lex.h:1182
void qbPrint(int level, std::ostringstream &buf) const
Minion of debugPrint.
Definition: query_term.cc:389
Query_block * next
Intrusive linked list of all query blocks within the same query expression.
Definition: sql_lex.h:2383
void cleanup_all_joins()
Definition: sql_union.cc:2105
uint select_number
Query block number (used for EXPLAIN)
Definition: sql_lex.h:2050
bool subquery_in_having
HAVING clause contains subquery => we can't close tables before query processing end even if we use t...
Definition: sql_lex.h:2212
Query_term_type term_type() const override
Get the node tree type.
Definition: sql_lex.h:1177
void print_where_cond(const THD *thd, String *str, enum_query_type query_type)
Print list of conditions in WHERE clause.
Definition: sql_lex.cc:3429
Item * where_cond() const
Definition: sql_lex.h:1189
bool is_grouped() const
Definition: sql_lex.h:1296
void print_insert_options(String *str)
Print INSERT options.
Definition: sql_lex.cc:3270
bool m_json_agg_func_used
Definition: sql_lex.h:2471
mem_root_deque< mem_root_deque< Item * > * > * row_value_list
The VALUES items of a table value constructor.
Definition: sql_lex.h:1923
bool is_dependent() const
Definition: sql_lex.h:1807
void print_qualify(const THD *thd, String *str, enum_query_type query_type) const
Print list of items in QUALIFY clause.
Definition: sql_lex.cc:3481
mem_root_deque< Item * > * get_fields_list()
Definition: sql_lex.h:1386
MaterializePathParameters::Operand setup_materialize_query_block(AccessPath *child_path, TABLE *dst_table) const
Make materialization parameters for a query block given its input path and destination table,...
Definition: sql_union.cc:1357
bool with_sum_func
True if contains or aggregates set functions.
Definition: sql_lex.h:2206
Ref_item_array m_saved_base_items
A backup of the items in base_ref_items at the end of preparation, so that base_ref_items can be rest...
Definition: sql_lex.h:2456
bool is_explicitly_grouped() const
Definition: sql_lex.h:1272
Item * m_where_cond
Condition to be evaluated after all tables in a query block are joined.
Definition: sql_lex.h:2442
olap_type olap
Indicates whether this query block contains non-primitive grouping (such as ROLLUP).
Definition: sql_lex.h:2148
Item::cond_result having_value
Definition: sql_lex.h:2061
Item::cond_result cond_value
Saved values of the WHERE and HAVING clauses.
Definition: sql_lex.h:2060
bool setup_base_ref_items(THD *thd)
Setup the array containing references to base items.
Definition: sql_lex.cc:2584
uint get_in_sum_expr() const
Definition: sql_lex.h:1356
void print_values(const THD *thd, String *str, enum_query_type query_type, const mem_root_deque< mem_root_deque< Item * > * > &values, const char *prefix)
Print list of values, used in INSERT and for general VALUES clause.
Definition: sql_lex.cc:3383
bool group_fix_field
true when GROUP BY fix field called in processing of this query block
Definition: sql_lex.h:2199
void print_item_list(const THD *thd, String *str, enum_query_type query_type)
Print list of items in Query_block object.
Definition: sql_lex.cc:3318
Resolve_place resolve_place
Indicates part of query being resolved.
Definition: sql_lex.h:2082
bool m_right_joins
True if query block has right joins.
Definition: sql_lex.h:2465
Query_block(MEM_ROOT *mem_root, Item *where, Item *having)
Construct and initialize Query_block object.
Definition: sql_lex.cc:2256
bool is_implicitly_grouped() const
Definition: sql_lex.h:1279
void add_subquery_transform_candidate(Item_exists_subselect *predicate)
Definition: sql_lex.h:1464
Item * m_having_cond
Condition to be evaluated on grouped rows after grouping.
Definition: sql_lex.h:2445
uint cond_count
Number of predicates after preparation.
Definition: sql_lex.h:2100
Query_result * m_query_result
Result of this query block.
Definition: sql_lex.h:2395
void cleanup(bool full) override
Cleanup this subtree (this Query_block and all nested Query_blockes and Query_expressions).
Definition: sql_union.cc:2076
bool absorb_limit_of(Query_block *block)
end of overridden methods from Query_term
Definition: query_term.cc:461
Table_ref * end_lateral_table
Last table for LATERAL join, used by table functions.
Definition: sql_lex.h:2027
void print_hints(const THD *thd, String *str, enum_query_type query_type)
Print detail of Hints.
Definition: sql_lex.cc:3202
bool accept(Select_lex_visitor *visitor)
Accept function for SELECT and DELETE.
Definition: sql_lex.cc:3570
uint max_equal_elems
Maximal number of elements in multiple equalities.
Definition: sql_lex.h:2104
uint table_func_count
Number of table functions in this query block.
Definition: sql_lex.h:2136
Item ** qualify_cond_ref()
Definition: sql_lex.h:1196
Mem_root_array< Item_exists_subselect * > * sj_candidates
Pointer to collection of subqueries candidate for semi/antijoin conversion.
Definition: sql_lex.h:2374
bool having_fix_field
true when having fix field called in processing of this query block
Definition: sql_lex.h:2197
bool has_aj_nests
Definition: sql_lex.h:2464
uint hidden_items_from_optimization
Hidden items added during optimization.
Definition: sql_lex.h:2231
Query_block * link_next
Intrusive double-linked global list of query blocks.
Definition: sql_lex.h:2391
void invalidate()
Invalidate by nulling out pointers to other Query_expressions and Query_blockes.
Definition: sql_lex.cc:2576
Opt_hints_qb * opt_hints_qb
Query-block-level hints, for this query block.
Definition: sql_lex.h:1974
Query_block * query_block() const override
The query_block which holds the ORDER BY and LIMIT information for this set operation.
Definition: sql_lex.h:1179
Query_block ** link_prev
Definition: sql_lex.h:2392
uint with_wild
Number of wildcards used in the SELECT list.
Definition: sql_lex.h:2129
Name_resolution_context context
Context for name resolution for all column references except columns from joined tables.
Definition: sql_lex.h:1999
Item ** where_cond_ref()
Definition: sql_lex.h:1190
void make_active_options(ulonglong added_options, ulonglong removed_options)
Make active options from base options, supplied options and environment:
Definition: sql_lex.cc:2439
void set_empty_query()
Set query block as returning no data.
Definition: sql_lex.h:1779
Query_expression * slave
The first query expression contained within this query block.
Definition: sql_lex.h:2388
bool is_item_list_lookup
Definition: sql_lex.h:2194
void mark_as_dependent(Query_block *last, bool aggregate)
Mark all query blocks from this to 'last' as dependent.
Definition: sql_lex.cc:2475
Table_ref * leaf_tables
Points to first leaf table of query block.
Definition: sql_lex.h:2025
bool save_order_properties(THD *thd, SQL_I_List< ORDER > *list, Group_list_ptrs **list_ptrs)
Helper for save_properties()
Definition: sql_lex.cc:4367
Item_sum * inner_sum_func_list
Circular linked list of aggregate functions in nested query blocks.
Definition: sql_lex.h:2041
Item ** having_cond_ref()
Definition: sql_lex.h:1193
bool first_execution
This variable is required to ensure proper work of subqueries and stored procedures.
Definition: sql_lex.h:2183
Item * having_cond() const
Definition: sql_lex.h:1192
void print_delete_options(String *str)
Print DELETE options.
Definition: sql_lex.cc:3262
bool add_ftfunc_to_list(Item_func_match *func)
Definition: sql_lex.cc:2568
void print_having(const THD *thd, String *str, enum_query_type query_type)
Print list of items in HAVING clause.
Definition: sql_lex.cc:3465
bool walk(Item_processor processor, enum_walk walk, uchar *arg)
Definition: sql_lex.cc:4815
bool m_agg_func_used
Definition: sql_lex.h:2470
Query_expression * first_inner_query_expression() const
Definition: sql_lex.h:1258
uint materialized_derived_table_count
Number of materialized derived tables and views in this query block.
Definition: sql_lex.h:2120
List< Item_func_match > * ftfunc_list
A pointer to ftfunc_list_alloc, list of full text search functions.
Definition: sql_lex.h:1919
uint in_sum_expr
Parse context: is inside a set function if this is positive.
Definition: sql_lex.h:2066
enum_condition_context condition_context
Definition: sql_lex.h:2151
void set_right_joins()
Definition: sql_lex.h:1796
auto visible_fields()
Wrappers over fields / get_fields_list() that hide items where item->hidden, meant for range-based fo...
Definition: sql_lex.h:1390
uint n_sum_items
Number of Item_sum-derived objects in this SELECT.
Definition: sql_lex.h:2111
Query_block * outer_query_block() const
Definition: sql_lex.h:1259
void renumber(LEX *lex)
Renumber query blocks of contained query expressions.
Definition: sql_lex.cc:4541
mem_root_deque< Table_ref * > * m_current_table_nest
Pointer to the set of table references in the currently active join.
Definition: sql_lex.h:2016
List< Window > m_windows
All windows defined on the select, both named and inlined.
Definition: sql_lex.h:1914
Table_ref * find_table_by_name(const Table_ident *ident)
Finds a (possibly unresolved) table reference in the from clause by name.
Definition: sql_lex.cc:4886
uint leaf_table_count
Number of leaf tables in this query block.
Definition: sql_lex.h:2132
void set_having_cond(Item *cond)
Definition: sql_lex.h:1194
bool m_use_select_limit
If true, use select_limit to limit number of rows selected.
Definition: sql_lex.h:2219
bool has_limit() const
Definition: sql_lex.h:1330
void set_qualify_cond(Item *cond)
Definition: sql_lex.h:1197
bool validate_outermost_option(LEX *lex, const char *wrong_option) const
Check if an option that can be used only for an outer-most query block is applicable to this query bl...
Definition: sql_lex.cc:4720
void destroy()
Destroy contained objects, in particular temporary tables which may have their own mem_roots.
Definition: sql_union.cc:2116
uint derived_table_count
Number of derived tables and views in this query block.
Definition: sql_lex.h:2134
bool is_ordered() const
Definition: sql_lex.h:1307
void destroy_tree() override
Destroy the query term tree structure.
Definition: sql_lex.h:1183
uint partitioned_table_count
Number of partitioned tables.
Definition: sql_lex.h:2122
Prealloced_array< Item_rollup_group_item *, 4 > rollup_group_items
Definition: sql_lex.h:1968
void print_insert_fields(const THD *thd, String *str, enum_query_type query_type)
Print column list to be inserted into.
Definition: sql_lex.cc:3363
bool json_agg_func_used() const
Definition: sql_lex.h:1789
bool get_optimizable_conditions(THD *thd, Item **new_where, Item **new_having)
Returns disposable copies of WHERE/HAVING/ON conditions.
Definition: sql_lex.cc:4618
uint between_count
Number of between predicates in where/having/on.
Definition: sql_lex.h:2102
Query_result * query_result() const
Definition: sql_lex.h:1199
void include_in_global(Query_block **plink)
Include query block into global list.
Definition: sql_lex.cc:4557
bool agg_func_used() const
Definition: sql_lex.h:1788
Resolve_place
Three fields used by semi-join transformations to know when semi-join is possible,...
Definition: sql_lex.h:2074
@ RESOLVE_HAVING
Definition: sql_lex.h:2078
@ RESOLVE_NONE
Definition: sql_lex.h:2075
@ RESOLVE_SELECT_LIST
Definition: sql_lex.h:2080
@ RESOLVE_QUALIFY
Definition: sql_lex.h:2079
@ RESOLVE_JOIN_NEST
Definition: sql_lex.h:2076
@ RESOLVE_CONDITION
Definition: sql_lex.h:2077
void include_chain_in_global(Query_block **start)
Include chain of query blocks into global list.
Definition: sql_lex.cc:4568
SQL_I_List< ORDER > order_list
ORDER BY clause.
Definition: sql_lex.h:1938
char * db
Definition: sql_lex.h:1976
List< Item_func_match > ftfunc_list_alloc
Definition: sql_lex.h:1920
static const char * get_type_str(enum_explain_type type)
Definition: sql_lex.h:1803
void remove_base_options(ulonglong options)
Remove base options from a query block.
Definition: sql_lex.h:1225
enum_explain_type type() const
Lookup for Query_block type.
Definition: sql_lex.cc:4438
Item * offset_limit
LIMIT ... OFFSET clause, NULL if no offset is given.
Definition: sql_lex.h:2032
void set_sj_candidates(Mem_root_array< Item_exists_subselect * > *sj_cand)
Definition: sql_lex.h:1461
void print_order_by(const THD *thd, String *str, enum_query_type query_type) const
Print list of items in ORDER BY clause.
Definition: sql_lex.cc:3511
static const char * type_str[static_cast< int >(enum_explain_type::EXPLAIN_total)]
Definition: sql_lex.h:2480
Query_expression * master
The query expression containing this query block.
Definition: sql_lex.h:2386
bool has_subquery_transforms() const
Definition: sql_lex.h:1471
Ref_item_array base_ref_items
Array of pointers to "base" items; one each for every selected expression and referenced item in the ...
Definition: sql_lex.h:2048
int hidden_order_field_count
How many expressions are part of the order by but not select list.
Definition: sql_lex.h:2377
enum_parsing_context parsing_place
Parse context: indicates where the current expression is being parsed.
Definition: sql_lex.h:2064
void init_order()
Definition: sql_lex.h:1480
uint8 uncacheable
result of this query can't be cached, bit field, can be : UNCACHEABLE_DEPENDENT UNCACHEABLE_RAND UNCA...
Definition: sql_lex.h:2165
ulonglong m_base_options
Options assigned from parsing and throughout resolving, should not be modified after resolving is don...
Definition: sql_lex.h:2401
bool source_table_is_one_row() const
Definition: sql_lex.h:1811
uint in_window_expr
Parse context: is inside a window function if this is positive.
Definition: sql_lex.h:2068
void include_down(LEX *lex, Query_expression *outer)
Include query block inside a query expression.
Definition: sql_lex.cc:4492
void include_standalone(Query_expression *sel)
Include query block inside a query expression, but do not link.
Definition: sql_lex.cc:4529
Group_list_ptrs * group_list_ptrs
Definition: sql_lex.h:1951
uint saved_cond_count
Number of arguments of and/or/xor in where/having/on.
Definition: sql_lex.h:2098
Subquery_strategy subquery_strategy(const THD *thd) const
Returns which subquery execution strategies can be used for this query block.
Definition: sql_lex.cc:4641
Query_block * next_query_block() const
Definition: sql_lex.h:1260
Name_resolution_context * first_context
Pointer to first object in list of Name res context objects that have this query block as the base qu...
Definition: sql_lex.h:2006
void include_neighbour(LEX *lex, Query_block *before)
Include a query block next to another query block.
Definition: sql_lex.cc:4510
bool is_table_value_constructor
If set, the query block is of the form VALUES row_list.
Definition: sql_lex.h:2154
Item * get_derived_expr(uint expr_index)
Returns an expression from the select list of the query block using the field's index in a derived ta...
Definition: sql_derived.cc:1302
bool semijoin_enabled(const THD *thd) const
Returns whether semi-join is enabled for this query block.
Definition: sql_lex.cc:4667
Query_expression * master_query_expression() const
Definition: sql_lex.h:1257
void update_semijoin_strategies(THD *thd)
Update available semijoin strategies for semijoin nests.
Definition: sql_lex.cc:4672
uint select_n_having_items
Number of items in the select list, HAVING clause, QUALIFY clause and ORDER BY clause.
Definition: sql_lex.h:2096
Table_ref * get_table_list() const
Definition: sql_lex.h:1381
void print_update(const THD *thd, String *str, enum_query_type query_type)
Print detail of the UPDATE statement.
Definition: sql_lex.cc:3085
bool is_simple_query_block() const
Definition: sql_lex.h:1766
void print_table_references(const THD *thd, String *str, Table_ref *table_list, enum_query_type query_type)
Print list of tables.
Definition: sql_lex.cc:3284
bool has_tables() const
Definition: sql_lex.h:1269
void debugPrint(int level, std::ostringstream &buf) const override
Query_term methods overridden.
Definition: query_term.cc:439
bool m_internal_limit
If true, limit object is added internally.
Definition: sql_lex.h:2222
int hidden_group_field_count
Number of GROUP BY expressions added to all_fields.
Definition: sql_lex.h:2451
bool is_recursive() const
Definition: sql_lex.h:1336
int get_number_of_grouping_sets() const
Definition: sql_lex.h:2431
void print_windows(const THD *thd, String *str, enum_query_type query_type)
Print details of Windowing functions.
Definition: sql_lex.cc:3489
bool no_table_names_allowed
used for global order by
Definition: sql_lex.h:2227
bool validate_base_options(LEX *lex, ulonglong options) const
Validate base options for a query block.
Definition: sql_lex.cc:4757
void set_where_cond(Item *cond)
Definition: sql_lex.h:1191
Item * select_limit
LIMIT clause, NULL if no limit is given.
Definition: sql_lex.h:2030
ulonglong active_options() const
Definition: sql_lex.h:1238
bool save_properties(THD *thd)
Save properties of a prepared statement needed for repeated optimization.
Definition: sql_lex.cc:4390
Table_ref * embedding
table embedding the above list
Definition: sql_lex.h:2018
bool open_result_tables(THD *, int) override
Open tmp tables for the tree of set operation query results, by recursing.
Definition: query_term.cc:453
table_map select_list_tables
The set of those tables whose fields are referenced in the select list of this select level.
Definition: sql_lex.h:1992
bool m_was_implicitly_grouped
Used by nested scalar_to_derived transformations.
Definition: sql_lex.h:2189
bool has_sj_nests
True if query block has semi-join nests merged into it.
Definition: sql_lex.h:2463
Prealloced_array< Item_rollup_sum_switcher *, 4 > rollup_sums
Definition: sql_lex.h:1970
SQL_I_List< ORDER > group_list
GROUP BY clause.
Definition: sql_lex.h:1950
SQL_I_List< Table_ref > m_table_list
List of tables in FROM clause - use Table_ref::next_local to traverse.
Definition: sql_lex.h:1929
uint select_n_where_fields
Number of fields used in select list or where clause of current select and all inner subselects.
Definition: sql_lex.h:2089
bool skip_local_transforms
True: skip local transformations during prepare() call (used by INSERT)
Definition: sql_lex.h:2192
void print_limit(const THD *thd, String *str, enum_query_type query_type) const
Definition: sql_lex.cc:2729
const char * get_type_str()
Lookup for a type string.
Definition: sql_lex.h:1802
Table_ref * resolve_nest
Used when resolving outer join condition.
Definition: sql_lex.h:2417
bool is_empty_query() const
Definition: sql_lex.h:1775
void print_query_block(const THD *thd, String *str, enum_query_type query_type)
Print detail of the Query_block object.
Definition: sql_lex.cc:3061
mem_root_deque< Table_ref * > m_table_nest
Set of table references contained in outer-most join nest.
Definition: sql_lex.h:2014
bool set_context(Name_resolution_context *outer_context)
Assign a default name resolution object for this query block.
Definition: sql_lex.cc:2273
void set_json_agg_func_used(bool val)
Definition: sql_lex.h:1793
bool allow_merge_derived
Allow merge of immediate unnamed derived tables.
Definition: sql_lex.h:2468
bool add_tables(THD *thd, const Mem_root_array< Table_ident * > *tables, ulong table_options, thr_lock_type lock_type, enum_mdl_type mdl_type)
Add tables from an array to a list of used tables.
Definition: sql_lex.cc:2299
void print_select_options(String *str)
Print select options.
Definition: sql_lex.cc:3248
void set_query_result(Query_result *result)
Definition: sql_lex.h:1198
mem_root_deque< Table_ref * > sj_nests
List of semi-join nests generated for this query block.
Definition: sql_lex.h:1926
Table_ref * recursive_reference
If this query block is a recursive member of a recursive unit: the Table_ref, in this recursive membe...
Definition: sql_lex.h:1983
bool add_item_to_list(Item *item)
Definition: sql_lex.cc:2559
void print(const THD *thd, String *str, enum_query_type query_type)
Definition: sql_lex.cc:3022
bool is_non_primitive_grouped() const
Definition: sql_lex.h:1286
bool exclude_from_table_unique_test
exclude this query block from unique_table() check
Definition: sql_lex.h:2225
bool sj_pullout_done
True when semi-join pull-out processing is complete.
Definition: sql_lex.h:2186
int nest_level
Nesting level of query block, outer-most query block has level 0, its subqueries have level 1,...
Definition: sql_lex.h:2142
const char * operator_string() const override
Get the node type description.
Definition: sql_lex.h:1178
Group_list_ptrs * order_list_ptrs
Definition: sql_lex.h:1939
uint n_child_sum_items
Number of Item_sum-derived objects in children and descendant SELECTs.
Definition: sql_lex.h:2113
bool save_cmd_properties(THD *thd)
Save prepared statement properties for a query block and underlying query expressions.
Definition: sql_lex.cc:4907
void set_agg_func_used(bool val)
Definition: sql_lex.h:1791
bool print_error(const THD *thd, String *str)
Print error.
Definition: sql_lex.cc:3227
Item * qualify_cond() const
Definition: sql_lex.h:1195
bool is_cacheable() const
Definition: sql_lex.h:1808
ha_rows get_offset(const THD *thd) const
Get offset for LIMIT.
Definition: sql_lex.cc:2538
void add_active_options(ulonglong options)
Adjust the active option set.
Definition: sql_lex.h:1235
ha_rows get_limit(const THD *thd) const
Get limit.
Definition: sql_lex.cc:2545
Item * clone_expression(THD *thd, Item *item, Table_ref *derived_table)
Creates a clone for the given expression by re-parsing the expression.
Definition: sql_derived.cc:825
void set_base_options(ulonglong options_arg)
Set base options for a query block (and active options too)
Definition: sql_lex.h:1204
void print_update_options(String *str)
Print UPDATE options.
Definition: sql_lex.cc:3255
void print_insert(const THD *thd, String *str, enum_query_type query_type)
Print detail of the INSERT statement.
Definition: sql_lex.cc:3154
table_map all_tables_map() const
Definition: sql_lex.h:1253
bool right_joins() const
Definition: sql_lex.h:1795
JOIN * join
After optimization it is pointer to corresponding JOIN.
Definition: sql_lex.h:2012
ulonglong m_active_options
Active options.
Definition: sql_lex.h:2407
decltype(SQL_I_List< ORDER >::elements) m_no_of_added_exprs
For an explicitly grouped, correlated, scalar subquery which is transformed to join with derived tabl...
Definition: sql_lex.h:1964
void restore_cmd_properties()
Restore prepared statement properties for this query block and all underlying query expressions so th...
Definition: sql_lex.cc:4928
Item * m_qualify_cond
Condition to be evaluated after window functions.
Definition: sql_lex.h:2448
void cut_subtree()
Definition: sql_lex.h:1492
bool has_sj_candidates() const
Definition: sql_lex.h:1467
void print_from_clause(const THD *thd, String *str, enum_query_type query_type)
Print list of tables in FROM clause.
Definition: sql_lex.cc:3411
bool m_empty_query
True if query block does not generate any rows before aggregation, determined during preparation (not...
Definition: sql_lex.h:2477
table_map outer_join
Bitmap of all inner tables from outer joins.
Definition: sql_lex.h:1993
size_t m_added_non_hidden_fields
Definition: sql_lex.h:1887
int m_num_grouping_sets
If the query block includes non-primitive grouping, then these modifiers are represented as grouping ...
Definition: sql_lex.h:2414
Query_block * next_select_in_list() const
Definition: sql_lex.h:1264
void print_group_by(const THD *thd, String *str, enum_query_type query_type)
Print list of items in GROUP BY clause.
Definition: sql_lex.cc:3444
auto visible_fields() const
Definition: sql_lex.h:1391
bool can_skip_distinct() const
Based on the structure of the query at resolution time, it is possible to conclude that DISTINCT is u...
Definition: sql_lex.h:1324
bool is_distinct() const
Definition: sql_lex.h:1299
void set_tables_readonly()
Set associated tables as read_only, ie.
Definition: sql_lex.h:1246
mem_root_deque< Item * > fields
All expressions needed after join and filtering, ie., select list, group by list, having clause,...
Definition: sql_lex.h:1909
LEX * parent_lex
Reference to LEX that this query block belongs to.
Definition: sql_lex.h:1986
bool test_limit()
Definition: sql_lex.cc:2511
bool has_windows() const
Definition: sql_lex.h:1352
bool has_ft_funcs() const
Definition: sql_lex.h:1333
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:626
bool is_executed() const
Check state of execution of the contained query expression.
Definition: sql_lex.h:1042
bool merge_heuristic(const LEX *lex) const
True if heuristics suggest to merge this query expression.
Definition: sql_lex.cc:3952
Query_block * non_simple_result_query_block() const
Return the query block iff !is_simple() holds.
Definition: sql_lex.h:658
void reset_executed()
Reset this query expression for repeated evaluation within same execution.
Definition: sql_lex.h:1021
void change_to_access_path_without_in2exists(THD *thd)
Definition: sql_union.cc:2003
unique_ptr_destroy_only< RowIterator > m_root_iterator
An iterator you can read from to get all records for this query.
Definition: sql_lex.h:744
Query_expression(enum_parsing_context parsing_context)
Construct and initialize Query_expression object.
Definition: sql_lex.cc:2204
void set_explain_marker_from(THD *thd, const Query_expression *u)
Definition: sql_lex.cc:2531
void set_prepared()
Definition: sql_lex.h:1007
bool executed
Query expression has been executed.
Definition: sql_lex.h:731
bool walk(Item_processor processor, enum_walk walk, uchar *arg)
Definition: sql_union.cc:1995
void clear_root_access_path()
Definition: sql_lex.h:878
void set_explain_marker(THD *thd, enum_parsing_context m)
Definition: sql_lex.cc:2525
bool has_top_level_distinct() const
Definition: sql_lex.h:714
unique_ptr_destroy_only< RowIterator > release_root_iterator()
Definition: sql_lex.h:868
void exclude_tree()
Exclude subtree of current unit from tree of SELECTs.
Definition: sql_lex.cc:2384
Query_term_set_op * set_operation() const
Convenience method to avoid down casting, i.e.
Definition: sql_lex.h:654
bool optimize(THD *thd, TABLE *materialize_destination, bool create_iterators, bool finalize_access_paths)
If and only if materialize_destination is non-nullptr, it means that the caller intends to materializ...
Definition: sql_union.cc:992
void set_executed()
Definition: sql_lex.h:1015
Mem_root_array< MaterializePathParameters::Operand > m_operands
If there is an unfinished materialization (see optimize()), contains one element for each operand (qu...
Definition: sql_lex.h:752
enum_parsing_context explain_marker
Marker for subqueries in WHERE, HAVING, ORDER BY, GROUP BY and SELECT item lists.
Definition: sql_lex.h:727
Query_term * find_blocks_query_term(const Query_block *qb) const
Definition: sql_lex.h:665
enum_parsing_context get_explain_marker(const THD *thd) const
Definition: sql_lex.cc:2519
Query_expression * next_query_expression() const
Definition: sql_lex.h:862
Query_term * query_term() const
Getter for m_query_term, q.v.
Definition: sql_lex.h:647
Query_expression * next
Intrusive double-linked list of all query expressions immediately contained within the same query blo...
Definition: sql_lex.h:631
Query_block * global_parameters() const
Return the query block holding the top level ORDER BY, LIMIT and OFFSET.
Definition: sql_lex.h:809
bool explain_query_term(THD *explain_thd, const THD *query_thd, Query_term *qt)
Definition: sql_union.cc:1508
Query_block * slave
The first query block in this query expression.
Definition: sql_lex.h:640
bool change_query_result(THD *thd, Query_result_interceptor *result, Query_result_interceptor *old_result)
Change the query result object used to return the final result of the unit, replacing occurrences of ...
Definition: sql_union.cc:1935
size_t num_visible_fields() const
Definition: sql_union.cc:1969
bool is_simple() const
Definition: sql_lex.h:774
bool optimized
All query blocks in query expression are optimized.
Definition: sql_lex.h:730
Query_block * outer_query_block() const
Definition: sql_lex.h:856
void exclude_level()
Exclude this unit and immediately contained query_block objects.
Definition: sql_lex.cc:2322
Query_block * first_query_block() const
Definition: sql_lex.h:859
Query_block * master
The query block wherein this query expression is contained, NULL if the query block is the outer-most...
Definition: sql_lex.h:638
Query_block * last_distinct() const
Return the Query_block of the last query term in a n-ary set operation that is the right side of the ...
Definition: sql_lex.h:706
bool prepare_query_term(THD *thd, Query_term *qts, Query_result *common_result, ulonglong added_options, ulonglong create_options, int level, Mem_root_array< bool > &nullable)
Prepare the query term nodes and their associated post processing query blocks (i....
Definition: sql_union.cc:419
enum_clean_state cleaned
cleanliness state
Definition: sql_lex.h:784
bool prepare(THD *thd, Query_result *result, mem_root_deque< Item * > *insert_field_list, ulonglong added_options, ulonglong removed_options)
Prepares all query blocks of a query expression.
Definition: sql_union.cc:701
bool check_materialized_derived_query_blocks(THD *thd)
Sets up query blocks belonging to the query expression of a materialized derived table.
Definition: sql_derived.cc:954
Query_expression ** prev
Definition: sql_lex.h:632
void set_query_term(Query_term *qt)
Setter for m_query_term, q.v.
Definition: sql_lex.h:649
ha_rows offset_limit_cnt
Definition: sql_lex.h:814
Query_term * m_query_term
Definition: sql_lex.h:643
AccessPath * m_root_access_path
Definition: sql_lex.h:745
Mem_root_array< MaterializePathParameters::Operand > release_query_blocks_to_materialize()
See optimize().
Definition: sql_lex.h:902
bool has_any_limit() const
Checks if this query expression has limit defined.
Definition: sql_lex.cc:3886
bool ExecuteIteratorQuery(THD *thd)
Definition: sql_union.cc:1676
void set_optimized()
Definition: sql_lex.h:1011
void cleanup(bool full)
Cleanup this query expression object after preparation or one round of execution.
Definition: sql_union.cc:1844
friend bool parse_view_definition(THD *thd, Table_ref *view_ref)
Parse a view definition.
Definition: sql_view.cc:1186
mem_root_deque< Item * > * get_unit_column_types()
Get column type information for this query expression.
Definition: sql_union.cc:1965
Query_block * create_post_processing_block(Query_term_set_op *term)
Create a block to be used for ORDERING and LIMIT/OFFSET processing of a query term,...
Definition: sql_lex.cc:739
bool replace_items(Item_transformer t, uchar *arg)
Replace all targeted items using transformer provided and info in arg.
Definition: item_subselect.cc:3081
RowIterator * root_iterator() const
Definition: sql_lex.h:867
bool is_leaf_block(Query_block *qb)
Definition: sql_lex.cc:761
bool force_create_iterators(THD *thd)
Ensures that there are iterators created for the access paths created by optimize(),...
Definition: sql_union.cc:1186
Query_block * first_recursive
First query block (in this UNION) which references the CTE.
Definition: sql_lex.h:831
bool prepared
All query blocks in query expression are prepared.
Definition: sql_lex.h:729
void assert_not_fully_clean()
Asserts that none of {this unit and its children units} is fully cleaned up.
Definition: sql_union.cc:1900
void renumber_selects(LEX *lex)
Renumber query blocks of a query expression according to supplied LEX.
Definition: sql_lex.cc:3968
bool accept(Select_lex_visitor *visitor)
Definition: sql_lex.cc:3540
Query_result * query_result() const
Definition: sql_lex.h:865
ha_rows send_records
Definition: sql_lex.h:1077
enum_parsing_context place() const
If unit is a subquery, which forms an object of the upper level (an Item_subselect,...
Definition: sql_lex.cc:4809
mem_root_deque< Item * > types
Definition: sql_lex.h:796
void accumulate_used_tables(table_map map)
If unit is a subquery, which forms an object of the upper level (an Item_subselect,...
Definition: sql_lex.cc:4801
ha_rows select_limit_cnt
Definition: sql_lex.h:814
void create_access_paths(THD *thd)
Convert the executor structures to a set of access paths, storing the result in m_root_access_path.
Definition: sql_union.cc:1424
void print(const THD *thd, String *str, enum_query_type query_type)
Definition: sql_lex.cc:2717
Table_ref * derived_table
If this query expression is underlying of a derived table, the derived table.
Definition: sql_lex.h:826
void restore_cmd_properties()
Loop over all query blocks and restore information needed for optimization, including binding data fo...
Definition: sql_lex.cc:3991
bool finalize(THD *thd)
For any non-finalized query block, finalize it so that we are allowed to create iterators.
Definition: sql_union.cc:1174
Query_terms< order, visit_leaves > query_terms() const
Return iterator object over query terms rooted in m_query_term, using either post order visiting (def...
Definition: sql_lex.h:691
bool set_limit(THD *thd, Query_block *provider)
Set limit and offset for query expression object.
Definition: sql_lex.cc:3867
bool m_reject_multiple_rows
This query expression represents a scalar subquery and we need a run-time check that the cardinality ...
Definition: sql_lex.h:847
bool ClearForExecution()
Do everything that would be needed before running Init() on the root iterator.
Definition: sql_union.cc:1642
Item_subselect * item
Points to subquery if this query expression is used in one, otherwise NULL.
Definition: sql_lex.h:816
enum_clean_state
Values for Query_expression::cleaned.
Definition: sql_lex.h:777
@ UC_PART_CLEAN
Unit were cleaned, except JOIN and JOIN_TABs were kept for possible EXPLAIN.
Definition: sql_lex.h:779
@ UC_CLEAN
Unit completely cleaned, all underlying JOINs were freed.
Definition: sql_lex.h:781
@ UC_DIRTY
Unit isn't cleaned.
Definition: sql_lex.h:778
void invalidate()
Invalidate by nulling out pointers to other Query expressions and Query blocks.
Definition: sql_lex.cc:2424
bool can_materialize_directly_into_result() const
Whether there is a chance that optimize() is capable of materializing directly into a result table if...
Definition: sql_union.cc:676
PT_with_clause * m_with_clause
The WITH clause which is the first part of this query expression.
Definition: sql_lex.h:821
bool explain(THD *explain_thd, const THD *query_thd)
Explain query starting from this unit.
Definition: sql_union.cc:1574
bool is_mergeable() const
Return true if query expression can be merged into an outer query, based on technical constraints.
Definition: sql_lex.cc:3923
Query_result * m_query_result
Object to which the result for this query expression is sent.
Definition: sql_lex.h:736
bool is_prepared() const
Check state of preparation of the contained query expression.
Definition: sql_lex.h:1034
table_map m_lateral_deps
If 'this' is body of lateral derived table: map of tables in the same FROM clause as this derived tab...
Definition: sql_lex.h:841
bool is_optimized() const
Check state of optimization of the contained query expression.
Definition: sql_lex.h:1036
void set_query_result(Query_result *res)
Set new query result object for this query expression.
Definition: sql_lex.h:907
void include_down(LEX *lex, Query_block *outer)
Include a query expression below a query block.
Definition: sql_lex.cc:3899
void destroy()
Destroy contained objects, in particular temporary tables which may have their own mem_roots.
Definition: sql_union.cc:1875
mem_root_deque< Item * > * get_field_list()
Get field list for this query expression.
Definition: sql_union.cc:1984
bool execute(THD *thd)
Execute a query expression that may be a UNION and/or have an ordered result.
Definition: sql_union.cc:1819
bool clear_correlated_query_blocks()
Empties all correlated query blocks defined within the query expression; that is, correlated CTEs def...
Definition: sql_union.cc:1628
bool save_cmd_properties(THD *thd)
Save prepared statement properties for a query expression and underlying query blocks.
Definition: sql_lex.cc:3980
AccessPath * root_access_path() const
Definition: sql_lex.h:871
uint8 uncacheable
result of this query can't be cached, bit field, can be : UNCACHEABLE_DEPENDENT UNCACHEABLE_RAND UNCA...
Definition: sql_lex.h:768
bool unfinished_materialization() const
See optimize().
Definition: sql_lex.h:898
void clear_execution()
Clear execution state, needed before new execution of prepared statement.
Definition: sql_lex.h:1026
bool is_recursive() const
Definition: sql_lex.h:1094
Definition: query_result.h:181
Definition: sql_union.h:40
Definition: query_result.h:58
Definition: sql_lex.h:2597
bool is_mixed_stmt_unsafe(bool in_multi_stmt_transaction_mode, bool binlog_direct, bool trx_cache_is_not_empty, uint tx_isolation)
Definition: sql_lex.h:3119
bool uses_stored_routines() const
true if the parsed tree contains references to stored procedures or functions, false otherwise
Definition: sql_lex.h:3166
void set_stmt_row_injection()
Flag the statement as a row injection.
Definition: sql_lex.h:2966
std::unique_ptr< malloc_unordered_map< std::string, Sroutine_hash_entry * > > sroutines
Definition: sql_lex.h:2628
void set_stmt_unsafe(enum_binlog_stmt_unsafe unsafe_type)
Flag the current (top-level) statement as unsafe.
Definition: sql_lex.h:2915
static const char * stmt_accessed_table_string(enum_stmt_accessed_table accessed_table)
Definition: sql_lex.h:3019
enum_binlog_stmt_type
Enumeration listing special types of statements.
Definition: sql_lex.h:3182
@ BINLOG_STMT_TYPE_ROW_INJECTION
The statement is a row injection (i.e., either a BINLOG statement or a row event executed by the slav...
Definition: sql_lex.h:3187
@ BINLOG_STMT_TYPE_COUNT
The last element of this enumeration type.
Definition: sql_lex.h:3190
Table_ref ** query_tables_last
Definition: sql_lex.h:2611
bool is_stmt_unsafe_with_mixed_mode() const
Definition: sql_lex.h:3172
void reset_query_tables_list(bool init)
Definition: sql_lex.cc:3635
static const int BINLOG_STMT_UNSAFE_ALL_FLAGS
This has all flags from 0 (inclusive) to BINLOG_STMT_FLAG_COUNT (exclusive) set.
Definition: sql_lex.h:2888
~Query_tables_list()=default
enum_sql_command sql_command
SQL command for this statement.
Definition: sql_lex.h:2607
void set_stmt_unsafe_flags(uint32 flags)
Set the bits of binlog_stmt_flags determining the type of unsafeness of the current statement.
Definition: sql_lex.h:2930
uint32 get_stmt_unsafe_flags() const
Return a binary combination of all unsafe warnings for the statement.
Definition: sql_lex.h:2943
void set_stmt_unsafe_with_mixed_mode()
Definition: sql_lex.h:3171
Query_tables_list()=default
bool is_stmt_unsafe() const
Determine if this statement is marked as unsafe.
Definition: sql_lex.h:2902
bool is_stmt_unsafe(enum_binlog_stmt_unsafe unsafe)
Definition: sql_lex.h:2904
uint table_count
Number of tables which were open by open_tables() and to be locked by lock_tables().
Definition: sql_lex.h:2667
uint32 stmt_accessed_table_flag
Bit field that determines the type of tables that are about to be be accessed while executing a state...
Definition: sql_lex.h:3214
enum_stmt_accessed_table
Definition: sql_lex.h:2974
@ STMT_READS_TEMP_TRANS_TABLE
Definition: sql_lex.h:2989
@ STMT_WRITES_TEMP_TRANS_TABLE
Definition: sql_lex.h:3006
@ STMT_WRITES_TRANS_TABLE
Definition: sql_lex.h:2998
@ STMT_WRITES_TEMP_NON_TRANS_TABLE
Definition: sql_lex.h:3010
@ STMT_READS_TRANS_TABLE
Definition: sql_lex.h:2979
@ STMT_READS_TEMP_NON_TRANS_TABLE
Definition: sql_lex.h:2994
@ STMT_ACCESS_TABLE_COUNT
Definition: sql_lex.h:3015
@ STMT_READS_NON_TRANS_TABLE
Definition: sql_lex.h:2984
@ STMT_WRITES_NON_TRANS_TABLE
Definition: sql_lex.h:3002
bool stmt_unsafe_with_mixed_mode
This flag is set to true if statement is unsafe to be binlogged in STATEMENT format,...
Definition: sql_lex.h:3227
uint sroutines_list_own_elements
Definition: sql_lex.h:2640
@ START_SROUTINES_HASH_SIZE
Definition: sql_lex.h:2626
void mark_as_requiring_prelocking(Table_ref **tables_own_last)
Definition: sql_lex.h:2693
bool is_stmt_row_injection() const
Determine if this statement is a row injection.
Definition: sql_lex.h:2954
enum_lock_tables_state lock_tables_state
Definition: sql_lex.h:2655
void set_query_tables_list(Query_tables_list *state)
Definition: sql_lex.h:2679
void set_using_match()
Definition: sql_lex.h:3168
bool stmt_accessed_table(enum_stmt_accessed_table accessed_table)
Checks if a type of table is about to be accessed while executing a statement.
Definition: sql_lex.h:3096
SQL_I_List< Sroutine_hash_entry > sroutines_list
Definition: sql_lex.h:2638
void destroy_query_tables_list()
Definition: sql_lex.cc:3679
Sroutine_hash_entry ** sroutines_list_own_last
Definition: sql_lex.h:2639
bool using_match
It will be set true if 'MATCH () AGAINST' is used in the statement.
Definition: sql_lex.h:3219
void set_stmt_accessed_table(enum_stmt_accessed_table accessed_table)
Sets the type of table that is about to be accessed while executing a statement.
Definition: sql_lex.h:3077
static const int binlog_stmt_unsafe_errcode[BINLOG_STMT_UNSAFE_COUNT]
Maps elements of enum_binlog_stmt_unsafe to error codes.
Definition: sql_lex.h:2894
enum_binlog_stmt_unsafe
All types of unsafe statements.
Definition: sql_lex.h:2723
@ BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION
Using some functions is unsafe (e.g., UUID).
Definition: sql_lex.h:2755
@ BINLOG_STMT_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE
Mixing self-logging and non-self-logging engines in a statement is unsafe.
Definition: sql_lex.h:2768
@ BINLOG_STMT_UNSAFE_COUNT
Definition: sql_lex.h:2882
@ BINLOG_STMT_UNSAFE_XA
XA transactions and statements.
Definition: sql_lex.h:2855
@ BINLOG_STMT_UNSAFE_CREATE_SELECT_AUTOINC
CREATE TABLE...SELECT on a table with auto-increment column is unsafe because which rows are replaced...
Definition: sql_lex.h:2824
@ BINLOG_STMT_UNSAFE_DEFAULT_EXPRESSION_IN_SUBSTATEMENT
If a substatement inserts into or updates a table that has a column with an unsafe DEFAULT expression...
Definition: sql_lex.h:2862
@ BINLOG_STMT_UNSAFE_NOWAIT
Definition: sql_lex.h:2850
@ BINLOG_STMT_UNSAFE_FULLTEXT_PLUGIN
Using a plugin is unsafe.
Definition: sql_lex.h:2848
@ BINLOG_STMT_UNSAFE_INSERT_TWO_KEYS
INSERT... ON DUPLICATE KEY UPDATE on a table with more than one UNIQUE KEYS is unsafe.
Definition: sql_lex.h:2837
@ BINLOG_STMT_UNSAFE_AUTOINC_NOT_FIRST
INSERT into auto-inc field which is not the first part in composed primary key.
Definition: sql_lex.h:2843
@ BINLOG_STMT_UNSAFE_CREATE_SELECT_WITH_GIPK
Generating invisible primary key for a table created using CREATE TABLE... SELECT....
Definition: sql_lex.h:2879
@ BINLOG_STMT_UNSAFE_NONTRANS_AFTER_TRANS
Mixing transactional and non-transactional statements are unsafe if non-transactional reads or writes...
Definition: sql_lex.h:2762
@ BINLOG_STMT_UNSAFE_SYSTEM_VARIABLE
Using most system variables is unsafe, because slave may run with different options than master.
Definition: sql_lex.h:2751
@ BINLOG_STMT_UNSAFE_INSERT_IGNORE_SELECT
INSERT...IGNORE SELECT is unsafe because which rows are ignored depends on the order that rows are re...
Definition: sql_lex.h:2781
@ BINLOG_STMT_UNSAFE_MIXED_STATEMENT
Statements that read from both transactional and non-transactional tables and write to any of them ar...
Definition: sql_lex.h:2774
@ BINLOG_STMT_UNSAFE_AUTOINC_COLUMNS
Inserting into an autoincrement column in a stored routine is unsafe.
Definition: sql_lex.h:2742
@ BINLOG_STMT_UNSAFE_SKIP_LOCKED
Definition: sql_lex.h:2849
@ BINLOG_STMT_UNSAFE_CREATE_IGNORE_SELECT
CREATE TABLE... IGNORE... SELECT is unsafe because which rows are ignored depends on the order that r...
Definition: sql_lex.h:2809
@ BINLOG_STMT_UNSAFE_ACL_TABLE_READ_IN_DML_DDL
DML or DDL statement that reads a ACL table is unsafe, because the row are read without acquiring SE ...
Definition: sql_lex.h:2870
@ BINLOG_STMT_UNSAFE_INSERT_SELECT_UPDATE
INSERT...SELECT...UPDATE is unsafe because which rows are updated depends on the order that rows are ...
Definition: sql_lex.h:2788
@ BINLOG_STMT_UNSAFE_LIMIT
SELECT..LIMIT is unsafe because the set of rows returned cannot be predicted.
Definition: sql_lex.h:2728
@ BINLOG_STMT_UNSAFE_REPLACE_SELECT
INSERT...REPLACE SELECT is unsafe because which rows are replaced depends on the order that rows are ...
Definition: sql_lex.h:2802
@ BINLOG_STMT_UNSAFE_CREATE_REPLACE_SELECT
CREATE TABLE...REPLACE... SELECT is unsafe because which rows are replaced depends on the order that ...
Definition: sql_lex.h:2816
@ BINLOG_STMT_UNSAFE_UDF
Using a UDF (user-defined function) is unsafe.
Definition: sql_lex.h:2746
@ BINLOG_STMT_UNSAFE_UPDATE_IGNORE
UPDATE...IGNORE is unsafe because which rows are ignored depends on the order that rows are updated.
Definition: sql_lex.h:2831
@ BINLOG_STMT_UNSAFE_WRITE_AUTOINC_SELECT
Query that writes to a table with auto_inc column after selecting from other tables are unsafe as the...
Definition: sql_lex.h:2795
@ BINLOG_STMT_UNSAFE_SYSTEM_TABLE
Access to log tables is unsafe because slave and master probably log different things.
Definition: sql_lex.h:2733
Query_tables_list & operator=(Query_tables_list &&)=default
Table_ref * query_tables
Definition: sql_lex.h:2609
bool requires_prelocking()
Definition: sql_lex.h:2692
void chop_off_not_own_tables()
Definition: sql_lex.h:2700
Table_ref * first_not_own_table()
Definition: sql_lex.h:2697
Table_ref ** query_tables_own_last
Definition: sql_lex.h:2618
bool get_using_match()
Definition: sql_lex.h:3169
uint32 binlog_stmt_flags
Bit field indicating the type of statement.
Definition: sql_lex.h:3208
bool is_query_tables_locked() const
Definition: sql_lex.h:2656
enum_lock_tables_state
Locking state of tables in this particular statement.
Definition: sql_lex.h:2654
@ LTS_LOCKED
Definition: sql_lex.h:2654
@ LTS_NOT_LOCKED
Definition: sql_lex.h:2654
void add_to_query_tables(Table_ref *table)
Definition: sql_lex.h:2688
Common base class for n-ary set operations, including unary.
Definition: query_term.h:402
Query term tree structure.
Definition: query_term.h:209
virtual Query_block * query_block() const =0
The query_block which holds the ORDER BY and LIMIT information for this set operation.
Query_term_set_op * m_parent
Back pointer to the node whose child we are, or nullptr (root term).
Definition: query_term.h:272
virtual Query_term_type term_type() const =0
Get the node tree type.
Containing class for iterator over the query term tree.
Definition: query_term.h:579
A context for reading through a single table using a chosen access method: index read,...
Definition: row_iterator.h:82
Simple intrusive linked list.
Definition: sql_list.h:47
Base class for secondary engine execution context objects.
Definition: sql_lex.h:2535
virtual ~Secondary_engine_execution_context()=default
Destructs the secondary engine execution context object.
Abstract base class for traversing the Query_block tree.
Definition: select_lex_visitor.h:40
Context object used by semijoin equality decorrelation code.
Definition: sql_resolver.cc:2375
This class represent server options as set by the parser.
Definition: sql_servers.h:71
Representation of an SQL command.
Definition: sql_cmd.h:83
Structure that represents element in the set of stored routines used by statement or routine.
Definition: sp.h:225
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:167
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Class representing a table function.
Definition: table_function.h:53
Definition: sql_lex.h:296
Table_ident(Query_expression *s)
This constructor is used only for the case when we create a derived table.
Definition: sql_lex.h:317
void change_db(const char *db_name)
Definition: sql_lex.h:336
Query_expression * sel
Definition: sql_lex.h:300
Table_ident(Protocol *protocol, const LEX_CSTRING &db_arg, const LEX_CSTRING &table_arg, bool force)
Definition: sql_lex.cc:156
Table_ident(const LEX_CSTRING &table_arg)
Definition: sql_lex.h:307
bool is_table_function() const
Definition: sql_lex.h:333
bool is_derived_table() const
Definition: sql_lex.h:335
Table_ident(LEX_CSTRING &table_arg, Table_function *table_func_arg)
Definition: sql_lex.h:327
LEX_CSTRING table
Definition: sql_lex.h:299
Table_function * table_function
Definition: sql_lex.h:301
LEX_CSTRING db
Definition: sql_lex.h:298
Table_ident(const LEX_CSTRING &db_arg, const LEX_CSTRING &table_arg)
Definition: sql_lex.h:305
Definition: table.h:2864
Table_ref * first_leaf_table()
Return first leaf table of a base table or a view/derived table.
Definition: table.h:3292
Table_ref * next_leaf
Definition: table.h:3758
Used for storing information associated with generated column, default values generated from expressi...
Definition: field.h:483
Represents the (explicit) window of a SQL 2003 section 7.11 <window clause>, or the implicit (inlined...
Definition: window.h:110
The internal state of the syntax parser.
Definition: sql_lexer_yacc_state.h:246
Yacc_state()
Definition: sql_lexer_yacc_state.h:248
void reset()
Definition: sql_lexer_yacc_state.h:252
thr_lock_type m_lock_type
Type of lock to be used for tables being added to the statement's table list in table_factor,...
Definition: sql_lexer_yacc_state.h:321
uchar * yacc_yyvs
Bison internal semantic value stack, yyvs, when dynamically allocated using my_yyoverflow().
Definition: sql_lexer_yacc_state.h:296
enum_mdl_type m_mdl_type
The type of requested metadata lock for tables added to the statement table list.
Definition: sql_lexer_yacc_state.h:327
~Yacc_state()
Definition: sql_lexer_yacc_state.h:269
uchar * yacc_yyss
Bison internal state stack, yyss, when dynamically allocated using my_yyoverflow().
Definition: sql_lexer_yacc_state.h:290
void reset_before_substatement()
Reset part of the state which needs resetting before parsing substatement.
Definition: sql_lexer_yacc_state.h:281
uchar * yacc_yyls
Bison internal location value stack, yyls, when dynamically allocated using my_yyoverflow().
Definition: sql_lexer_yacc_state.h:302
The class hold dynamic table statistics for a table.
Definition: table_stats.h:103
void invalidate_cache(void)
Definition: table_stats.h:216
The class hold dynamic table statistics for a table.
Definition: tablespace_stats.h:64
void invalidate_cache(void)
Definition: tablespace_stats.h:111
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
Definition: partition_info.h:209
sp_head represents one instance of a stored program.
Definition: sp_head.h:383
Definition: sp_head.h:123
The class represents parse-time context, which keeps track of declared variables/parameters,...
Definition: sp_pcontext.h:252
static MEM_ROOT mem_root
Definition: client_plugin.cc:114
enum_query_type
Query type constants (usable as bitmap flags).
Definition: enum_query_type.h:31
Acl_type
Definition: sql_lex.h:263
uint to_uint(enum_sp_type val)
Definition: sql_lex.h:248
const char * index_hint_type_name[]
Definition: sql_lex.cc:136
enum_sp_data_access
Definition: sql_lex.h:207
void print_derived_column_names(const THD *thd, String *str, const Create_col_name_list *column_names)
Prints into 'str' a comma-separated list of column names, enclosed in parenthesis.
Definition: sql_lex.cc:2189
bool db_is_default_db(const char *db, size_t db_len, const THD *thd)
Definition: sql_lex.cc:2921
bool check_select_for_locking_clause(THD *)
sub_select_type
Definition: sql_lex.h:464
#define TYPE_ENUM_PROCEDURE
Definition: sql_lex.h:259
execute_only_in_secondary_reasons
Definition: sql_lex.h:3756
enum_alter_user_attribute
Definition: sql_lex.h:282
void binlog_unsafe_map_init()
Definition: sql_lex.cc:5138
Bounds_checked_array< Item * > Ref_item_array
Definition: sql_lex.h:1132
longlong to_longlong(enum_sp_type val)
Definition: sql_lex.h:244
enum_view_create_mode
Definition: sql_lex.h:276
bool walk_join_list(mem_root_deque< Table_ref * > &list, std::function< bool(Table_ref *)> action)
Definition: sql_resolver.cc:2670
execute_only_in_hypergraph_reasons
Definition: sql_lex.h:3766
bool is_union() const
Definition: sql_lex.h:2483
uint binlog_unsafe_map[256]
Definition: sql_lex.cc:5043
void lex_end(LEX *lex)
Call this function after preparation and execution of a query.
Definition: sql_lex.cc:532
enum_sp_type to_sp_type(longlong val)
Definition: sql_lex.h:236
enum_explain_type
Query_block type enum.
Definition: sql_lex.h:1138
#define TYPE_ENUM_FUNCTION
Definition: sql_lex.h:258
const LEX_STRING null_lex_str
LEX_STRING constant for null-string to be used in parser and other places.
Definition: sql_lex.cc:92
enum_sp_type
enum_sp_type defines type codes of stored programs.
Definition: sql_lex.h:224
void lex_free(void)
Definition: sql_lex.cc:165
bool is_set_operation() const
Definition: sql_lex.h:2490
constexpr const int MAX_SELECT_NESTING
Definition: sql_lex.h:139
void trim_whitespace(const CHARSET_INFO *cs, LEX_STRING *str)
Definition: sql_lex.cc:2158
bool is_lex_native_function(const LEX_STRING *name)
Check if name is a sql function.
Definition: sql_lex.cc:962
uchar index_clause_map
Definition: sql_lex.h:475
int my_sql_parser_lex(MY_SQL_PARSER_STYPE *, POS *, class THD *)
yylex() function implementation for the main parser
Definition: sql_lex.cc:1363
enum_sp_suid_behaviour
Definition: sql_lex.h:201
const size_t INITIAL_LEX_PLUGIN_LIST_SIZE
Definition: sql_lex.h:138
bool is_keyword(const char *name, size_t len)
Definition: sql_lex.cc:947
const LEX_CSTRING sp_data_access_name[]
Definition: sql_lex.h:269
enum_keep_diagnostics
Definition: sql_lex.h:193
bool lex_start(THD *thd)
Call lex_start() before every query that is to be prepared and executed.
Definition: sql_lex.cc:508
struct struct_replica_connection LEX_REPLICA_CONNECTION
@ SP_READS_SQL_DATA
Definition: sql_lex.h:211
@ SP_MODIFIES_SQL_DATA
Definition: sql_lex.h:212
@ SP_NO_SQL
Definition: sql_lex.h:210
@ SP_DEFAULT_ACCESS
Definition: sql_lex.h:208
@ SP_CONTAINS_SQL
Definition: sql_lex.h:209
@ UNSPECIFIED_TYPE
Definition: sql_lex.h:465
@ DERIVED_TABLE_TYPE
Definition: sql_lex.h:467
@ GLOBAL_OPTIONS_TYPE
Definition: sql_lex.h:466
@ TABLESAMPLE
Definition: sql_lex.h:3759
@ SUPPORTED_IN_PRIMARY
Definition: sql_lex.h:3757
@ CUBE
Definition: sql_lex.h:3758
@ QUALIFY_CLAUSE
Definition: sql_lex.h:3768
@ SUPPORTED_IN_BOTH_OPTIMIZERS
Definition: sql_lex.h:3767
@ EXPLAIN_total
fake type, total number of all valid types
@ NO_COMMENT
Not parsing comments.
Definition: sql_lex.h:3250
@ DISCARD_COMMENT
Parsing comments that need to be discarded.
Definition: sql_lex.h:3266
@ PRESERVE_COMMENT
Parsing comments that need to be preserved.
Definition: sql_lex.h:3257
@ SP_IS_SUID
Definition: sql_lex.h:204
@ SP_IS_DEFAULT_SUID
Definition: sql_lex.h:202
@ SP_IS_NOT_SUID
Definition: sql_lex.h:203
@ DA_KEEP_UNSPECIFIED
keep semantics is unspecified
Definition: sql_lex.h:198
@ DA_KEEP_DIAGNOSTICS
keep the diagnostics area
Definition: sql_lex.h:195
@ DA_KEEP_PARSE_ERROR
keep diagnostics area after parse error
Definition: sql_lex.h:197
@ DA_KEEP_COUNTS
keep @warning_count / @error_count
Definition: sql_lex.h:196
@ DA_KEEP_NOTHING
keep nothing
Definition: sql_lex.h:194
void my_error(int nr, myf MyFlags,...)
Fill in and print a previously registered error message.
Definition: my_error.cc:216
bool change_query_result(THD *thd, Query_result_interceptor *new_result, Query_result_interceptor *old_result)
Change the Query_result object of the query block.
Definition: sql_select.cc:4207
bool optimize(THD *thd, bool finalize_access_paths)
Optimize a query block and all inner query expressions.
Definition: sql_select.cc:2032
bool check_column_privileges(THD *thd)
Check privileges for all columns referenced from query block.
Definition: sql_select.cc:2075
bool check_privileges_for_subqueries(THD *thd)
Check privileges for column references in subqueries of a query block.
Definition: sql_select.cc:2180
bool transform_scalar_subqueries_to_join_with_derived(THD *thd)
Transform eligible scalar subqueries in the SELECT list, WHERE condition, HAVING condition or JOIN co...
Definition: sql_resolver.cc:7991
Item * single_visible_field() const
Definition: sql_resolver.cc:4772
bool remove_redundant_subquery_clauses(THD *thd)
For a table subquery predicate (IN/ANY/ALL/EXISTS/etc): since it does not support LIMIT the following...
Definition: sql_resolver.cc:3992
void delete_unused_merged_columns(mem_root_deque< Table_ref * > *tables)
Delete unused columns from merged tables.
Definition: sql_resolver.cc:5135
bool check_only_full_group_by(THD *thd)
Runs checks mandated by ONLY_FULL_GROUP_BY.
Definition: sql_resolver.cc:4475
void clear_sj_expressions(NESTED_JOIN *nested_join)
Remove semijoin condition for this query block.
Definition: sql_resolver.cc:2232
bool apply_local_transforms(THD *thd, bool prune)
Does permanent transformations which are local to a query block (which do not merge it to another blo...
Definition: sql_resolver.cc:807
void replace_referenced_item(Item *const old_item, Item *const new_item)
Replace item in select list and preserve its reference count.
Definition: sql_resolver.cc:7459
bool record_join_nest_info(mem_root_deque< Table_ref * > *tables)
Record join nest info in the select block.
Definition: sql_resolver.cc:2009
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block)
Definition: sql_resolver.cc:2191
bool transform_grouped_to_derived(THD *thd, bool *break_off)
Minion of transform_scalar_subqueries_to_join_with_derived.
Definition: sql_resolver.cc:5982
bool decorrelate_derived_scalar_subquery_pre(THD *thd, Table_ref *derived, Item *lifted_where, Lifted_expressions_map *lifted_where_expressions, bool *added_card_check, size_t *added_window_card_checks)
We have a correlated scalar subquery, so we must do several things:
Definition: sql_resolver.cc:7099
bool decorrelate_condition(Semijoin_decorrelation &sj_decor, Table_ref *join_nest)
Decorrelate the WHERE clause or a join condition of a subquery used in an IN or EXISTS predicate.
Definition: sql_resolver.cc:2556
bool transform_subquery_to_derived(THD *thd, Table_ref **out_tl, Query_expression *subs_query_expression, Item_subselect *subq, bool use_inner_join, bool reject_multiple_rows, Item *join_condition, Item *lifted_where_cond)
Converts a subquery to a derived table and inserts it into the FROM clause of the owning query block.
Definition: sql_resolver.cc:7491
bool setup_conds(THD *thd)
Resolve WHERE condition and join conditions.
Definition: sql_resolver.cc:1476
bool add_ftfunc_list(List< Item_func_match > *ftfuncs)
Add full-text function elements from a list into this query block.
Definition: sql_resolver.cc:3929
bool setup_join_cond(THD *thd, mem_root_deque< Table_ref * > *tables, bool in_update)
Resolve join conditions for a join nest.
Definition: sql_resolver.cc:1537
void remove_hidden_items()
Remove hidden items from select list.
Definition: sql_resolver.cc:5179
void remap_tables(THD *thd)
Re-map table numbers for all tables in a query block.
Definition: sql_resolver.cc:1312
void repoint_contexts_of_join_nests(mem_root_deque< Table_ref * > join_list)
Go through a list of tables and join nests, recursively, and repoint its query_block pointer.
Definition: sql_resolver.cc:3944
void propagate_unique_test_exclusion()
Propagate exclusion from table uniqueness test into subqueries.
Definition: sql_resolver.cc:3911
void mark_item_as_maybe_null_if_non_primitive_grouped(Item *item) const
Marks occurrences of group by fields in a function's arguments as nullable, so that we do not optimiz...
Definition: sql_resolver.cc:4758
bool convert_subquery_to_semijoin(THD *thd, Item_exists_subselect *subq_pred)
Convert a subquery predicate of this query block into a Table_ref semi-join nest.
Definition: sql_resolver.cc:2850
void fix_after_pullout(Query_block *parent_query_block, Query_block *removed_query_block)
Fix used tables information for a subquery after query transformations.
Definition: sql_resolver.cc:2177
bool lift_fulltext_from_having_to_select_list(THD *thd)
Copies all non-aggregated calls to the full-text search MATCH function from the HAVING clause to the ...
Definition: sql_resolver.cc:8264
bool setup_wild(THD *thd)
Expand all '*' in list of expressions with the matching column references.
Definition: sql_resolver.cc:1419
bool add_inner_func_calls_to_select_list(THD *thd, Lifted_expressions_map *lifted_exprs)
Definition: sql_resolver.cc:6954
bool remove_aggregates(THD *thd, Query_block *select)
A minion of transform_grouped_to_derived.
Definition: sql_resolver.cc:5787
bool prepare_values(THD *thd)
Prepare a table value constructor query block for optimization.
Definition: sql_resolver.cc:725
bool resolve_placeholder_tables(THD *thd, bool apply_semijoin)
Resolve derived table, view, table function information for a query block.
Definition: sql_resolver.cc:1345
bool simplify_joins(THD *thd, mem_root_deque< Table_ref * > *join_list, bool top, bool in_sj, Item **new_conds, uint *changelog=nullptr)
Simplify joins replacing outer joins by inner joins whenever it's possible.
Definition: sql_resolver.cc:1726
void update_used_tables()
Update used tables information for all local expressions.
Definition: sql_resolver.cc:912
bool resolve_limits(THD *thd)
Resolve OFFSET and LIMIT clauses.
Definition: sql_resolver.cc:950
int group_list_size() const
Definition: sql_resolver.cc:4624
bool empty_order_list(Query_block *sl)
Empty the ORDER list.
Definition: sql_resolver.cc:4073
bool prepare(THD *thd, mem_root_deque< Item * > *insert_field_list)
Prepare query block for optimization.
Definition: sql_resolver.cc:179
void reset_nj_counters(mem_root_deque< Table_ref * > *join_list=nullptr)
Set NESTED_JOIN::counter=0 in all nested joins in passed list.
Definition: sql_resolver.cc:1593
bool check_view_privileges(THD *thd, Access_bitmask want_privilege_first, Access_bitmask want_privilege_next)
Check privileges for views that are merged into query block.
Definition: sql_resolver.cc:1189
bool add_inner_fields_to_select_list(THD *thd, Lifted_expressions_map *lifted_exprs, Item *selected_field_or_ref, const uint first_non_hidden)
Minion of decorrelate_derived_scalar_subquery_pre.
Definition: sql_resolver.cc:6893
bool resolve_rollup_wfs(THD *thd)
Replace group by field references inside window functions with references in the presence of ROLLUP.
Definition: sql_resolver.cc:5018
bool field_list_is_empty() const
Definition: sql_resolver.cc:4788
Item ** add_hidden_item(Item *item)
Add item to the hidden part of select list.
Definition: sql_resolver.cc:5170
void merge_contexts(Query_block *inner)
Merge name resolution context objects of a subquery into its parent.
Definition: sql_resolver.cc:3961
bool add_inner_exprs_to_group_by(THD *thd, List_iterator< Item > &inner_exprs, Item *selected_item, bool *selected_expr_added_to_group_by, mem_root_deque< Item * > *exprs_added_to_group_by)
Run through the inner expressions and add them to the block's GROUP BY if not already present.
Definition: sql_resolver.cc:6837
bool transform_table_subquery_to_join_with_derived(THD *thd, Item_exists_subselect *subq_pred)
Replace a table subquery ([NOT] {IN, EXISTS}) with a join to a derived table.
Definition: sql_resolver.cc:5319
bool flatten_subqueries(THD *thd)
Convert semi-join subquery predicates into semi-join join nests.
Definition: sql_resolver.cc:3676
bool replace_subquery_in_expr(THD *thd, Item::Css_info *subquery, Table_ref *tr, Item **expr)
A minion of transform_scalar_subqueries_to_join_with_derived.
Definition: sql_resolver.cc:6476
size_t num_visible_fields() const
Definition: sql_resolver.cc:4784
ORDER * find_in_group_list(Item *item, int *rollup_level) const
Finds a group expression matching the given item, or nullptr if none.
Definition: sql_resolver.cc:4588
bool resolve_table_value_constructor_values(THD *thd)
Resolve the rows of a table value constructor and aggregate the type of each column across rows.
Definition: sql_resolver.cc:5195
bool merge_derived(THD *thd, Table_ref *derived_table)
Merge derived table into query block.
Definition: sql_resolver.cc:3313
bool setup_tables(THD *thd, Table_ref *tables, bool select_insert)
Resolve and prepare information about tables for one query block.
Definition: sql_resolver.cc:1226
bool supported_correlated_scalar_subquery(THD *thd, Item::Css_info *subquery, Item **lifted_where)
Called when the scalar subquery is correlated.
Definition: sql_resolver.cc:7744
bool replace_item_in_expression(Item **expr, bool was_hidden, Item::Item_replacement *info, Item_transformer transformer)
Minion of transform_grouped_to_derived.
Definition: sql_resolver.cc:5904
bool setup_order_final(THD *thd)
Do final setup of ORDER BY clause, after the query block is fully resolved.
Definition: sql_resolver.cc:4509
bool setup_counts_over_partitions(THD *thd, Table_ref *derived, Lifted_expressions_map *lifted_expressions, mem_root_deque< Item * > &exprs_added_to_group_by, uint hidden_fields)
Add all COUNT(0) to SELECT list of the derived table to be used for cardinality checking of the trans...
Definition: sql_resolver.cc:6741
bool nest_derived(THD *thd, Item *join_cond, mem_root_deque< Table_ref * > *join_list, Table_ref *new_derived_table)
Push the generated derived table to the correct location inside a join nest.
Definition: sql_resolver.cc:6627
bool decorrelate_derived_scalar_subquery_post(THD *thd, Table_ref *derived, Lifted_expressions_map *lifted_exprs, bool added_card_check, size_t added_window_card_checks)
See explanation in companion method decorrelate_derived_scalar_subquery_pre.
Definition: sql_resolver.cc:7384
bool allocate_grouping_sets(THD *thd)
Initializes the grouping set if the query block includes GROUP BY modifiers.
Definition: sql_resolver.cc:2601
bool setup_group(THD *thd)
Resolve and set up the GROUP BY list.
Definition: sql_resolver.cc:4555
Table_ref * synthesize_derived(THD *thd, Query_expression *unit, Item *join_cond, bool left_outer, bool use_inner_join)
Create a new Table_ref object for this query block, for either: 1) a derived table which will replace...
Definition: sql_resolver.cc:5691
bool push_conditions_to_derived_tables(THD *thd)
Pushes parts of the WHERE condition of this query block to materialized derived tables.
Definition: sql_resolver.cc:676
bool resolve_rollup(THD *thd)
Resolve items in SELECT list and ORDER BY list for rollup processing.
Definition: sql_resolver.cc:4923
bool build_sj_cond(THD *thd, NESTED_JOIN *nested_join, Query_block *subq_query_block, table_map outer_tables_map, Item **sj_cond, bool *simple_const)
Build semijoin condition for th query block.
Definition: sql_resolver.cc:2259
Item * resolve_rollup_item(THD *thd, Item *item)
Resolve an item (and its tree) for rollup processing by replacing items matching grouped expressions ...
Definition: sql_resolver.cc:4834
bool populate_grouping_sets(THD *thd)
Populates the grouping sets if the query block includes non-primitive grouping.
Definition: sql_resolver.cc:2649
bool is_row_count_valid_for_semi_join()
Check if the offset and limit are valid for a semijoin.
Definition: sql_resolver.cc:1397
bool add_joined_table(Table_ref *table)
Add a table to the current join list.
Definition: sql_parse.cc:6337
void set_lock_for_tables(thr_lock_type lock_type)
Set lock for all tables in current query block.
Definition: sql_parse.cc:6368
bool find_common_table_expr(THD *thd, Table_ident *table_id, Table_ref *tl, Parse_context *pc, bool *found)
Tries to match an identifier to the CTEs in scope; if matched, it modifies *table_name,...
Definition: sql_parse.cc:5751
Table_ref * end_nested_join()
End a nested join table list.
Definition: sql_parse.cc:6252
bool init_nested_join(THD *thd)
Initialize a new table list for a nested join.
Definition: sql_parse.cc:6225
Table_ref * nest_join(THD *thd, Query_block *select, Table_ref *embedding, mem_root_deque< Table_ref * > *jlist, size_t table_cnt, const char *legend)
Plumbing for nest_last_join, q.v.
Definition: sql_parse.cc:6279
Table_ref * add_table_to_list(THD *thd, Table_ident *table, const char *alias, ulong table_options, thr_lock_type flags=TL_UNLOCK, enum_mdl_type mdl_type=MDL_SHARED_READ, List< Index_hint > *hints=nullptr, List< String > *partition_names=nullptr, LEX_STRING *option=nullptr, Parse_context *pc=nullptr)
Add a table to list of used tables.
Definition: sql_parse.cc:5962
void set_lock_for_table(const Lock_descriptor &descriptor, Table_ref *table)
Definition: sql_parse.cc:6345
Table_ref * nest_last_join(THD *thd, size_t table_cnt=2)
Nest last join operations.
Definition: sql_parse.cc:6319
struct PSI_digest_locker PSI_digest_locker
Definition: psi_statement_bits.h:112
static int flags[50]
Definition: hp_test1.cc:40
static void start(mysql_harness::PluginFuncEnv *env)
Definition: http_auth_backend_plugin.cc:180
Item *(Item::* Item_transformer)(uchar *arg)
Type for transformers used by Item::transform and Item::compile.
Definition: item.h:727
Subquery_strategy
Classes that represent predicates over table subqueries: [NOT] EXISTS, [NOT] IN, ANY/SOME and ALL.
Definition: item_subselect.h:406
constexpr const LEX_CSTRING EMPTY_CSTR
Definition: lex_string.h:48
constexpr const LEX_CSTRING NULL_CSTR
Definition: lex_string.h:47
A better implementation of the UNIX ctype(3) library.
Various macros useful for communicating with memory debuggers, such as Valgrind.
void TRASH(void *ptr, size_t length)
Put bad content in memory to be sure it will segfault if dereferenced.
Definition: memory_debugging.h:71
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
std::unique_ptr< T, Destroy_only< T > > unique_ptr_destroy_only
std::unique_ptr, but only destroying.
Definition: my_alloc.h:477
This file includes constants used by all storage engines.
my_off_t ha_rows
Definition: my_base.h:1141
Header for compiler-dependent features.
#define MY_ASSERT_UNREACHABLE()
Definition: my_compiler.h:78
#define DBUG_EXECUTE_IF(keyword, a1)
Definition: my_dbug.h:171
#define DBUG_PRINT(keyword, arglist)
Definition: my_dbug.h:181
#define DBUG_TRACE
Definition: my_dbug.h:146
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:56
uint8_t uint8
Definition: my_inttypes.h:63
unsigned char uchar
Definition: my_inttypes.h:52
long long int longlong
Definition: my_inttypes.h:55
#define MYF(v)
Definition: my_inttypes.h:97
uint32_t uint32
Definition: my_inttypes.h:67
void my_free(void *ptr)
Frees the memory pointed by the ptr.
Definition: my_memory.cc:81
enum_sql_command
Definition: my_sqlcommand.h:46
@ SQLCOM_UPDATE
Definition: my_sqlcommand.h:51
@ SQLCOM_LOAD
Definition: my_sqlcommand.h:77
@ SQLCOM_INSERT
Definition: my_sqlcommand.h:52
@ SQLCOM_INSERT_SELECT
Definition: my_sqlcommand.h:53
@ SQLCOM_REPLACE
Definition: my_sqlcommand.h:87
@ SQLCOM_UPDATE_MULTI
Definition: my_sqlcommand.h:122
@ SQLCOM_REPLACE_SELECT
Definition: my_sqlcommand.h:88
Common header for many mysys elements.
uint64_t nesting_map
Definition: my_table_map.h:31
uint64_t table_map
Definition: my_table_map.h:30
uint32 my_thread_id
Definition: my_thread_local.h:34
static bool backup
Definition: myisampack.cc:198
static bool column_names
Definition: mysql.cc:173
static const CHARSET_INFO * charset_info
Definition: mysql.cc:247
Common definition between mysql server & client.
char * octet2hex(char *to, const char *str, unsigned int len)
static char * where
Definition: mysqldump.cc:152
static bool create_options
Definition: mysqldump.cc:126
const char * collation
Definition: audit_api_message_emit.cc:184
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1081
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
Definition: buf0block_hint.cc:30
Definition: commit_order_queue.h:34
bool length(const dd::Spatial_reference_system *srs, const Geometry *g1, double *length, bool *null) noexcept
Computes the length of linestrings and multilinestrings.
Definition: length.cc:76
Container::const_iterator find(const Container &c, Value &&value)
Definition: generic.h:39
size_t size(const char *const c)
Definition: base64.h:46
Definition: options.cc:57
const char * db_name
Definition: rules_table_service.cc:55
std::basic_ostringstream< char, std::char_traits< char >, ut::allocator< char > > ostringstream
Specialization of basic_ostringstream which uses ut::allocator.
Definition: ut0new.h:2871
std::map< Key, Value, Compare, ut::allocator< std::pair< const Key, Value > > > map
Specialization of map which uses ut_allocator.
Definition: ut0new.h:2893
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2879
olap_type
Definition: olap.h:31
@ UNSPECIFIED_OLAP_TYPE
Definition: olap.h:31
enum_parsing_context
Names for different query parse tree parts.
Definition: parse_tree_node_base.h:61
@ CTX_NONE
Empty value.
Definition: parse_tree_node_base.h:62
#define UNCACHEABLE_DEPENDENT
Definition: parse_tree_node_base.h:50
enum_yes_no_unknown
Definition: parser_yystype.h:166
struct result result
Definition: result.h:34
Performance schema instrumentation interface.
#define SELECT_DISTINCT
Definition: query_options.h:52
#define OPTION_NO_CONST_TABLES
Definition: query_options.h:78
Query_term_type
This class hierarchy is used to represent SQL structures between <query expression> and <query specif...
Definition: query_term.h:89
@ QT_UNARY
Represents a query primary with parentesized query expression body with order by clause and/or limit/...
Definition: query_term.h:96
@ QT_EXCEPT
Definition: query_term.h:100
@ QT_UNION
Definition: query_term.h:101
@ QT_INTERSECT
Represents the three set operations.
Definition: query_term.h:99
@ QT_QUERY_BLOCK
Represents Query specification, table value constructor and explicit table.
Definition: query_term.h:92
Visit_leaves
Query term iterator template argument type: whether to visit leaf nodes.
Definition: query_term.h:107
@ VL_VISIT_LEAVES
Definition: query_term.h:107
Visit_order
Query term iterator template argument type: how to visit nodes in tree.
Definition: query_term.h:105
@ QTC_POST_ORDER
Definition: query_term.h:105
required string type
Definition: replication_group_member_actions.proto:34
repeated Action action
Definition: replication_group_member_actions.proto:43
"public" interface to sys_var - server configuration variables.
enum_var_type
Definition: set_var.h:91
enum_tx_isolation
Definition: handler.h:3186
@ ISO_REPEATABLE_READ
Definition: handler.h:3189
index_hint_type
Definition: table.h:1397
role_enum
Definition: sql_admin.h:255
my_lex_states
Definition: sql_chars.h:37
File containing constants that can be used throughout the server.
constexpr const uint8_t CONTEXT_ANALYSIS_ONLY_PREPARE
Don't evaluate this subquery during statement prepare even if it's a constant one.
Definition: sql_const.h:172
enum_walk
Enumeration for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:287
bool(Item::*)(unsigned char *) Item_processor
Processor type for {Item,Query_block[_UNIT],Table_function}walk.
Definition: sql_const.h:305
constexpr const uint8_t CONTEXT_ANALYSIS_ONLY_VIEW
Special Query_block::prepare mode: changing of query is prohibited.
Definition: sql_const.h:180
enum_condition_context
Enumeration for Query_block::condition_context.
Definition: sql_const.h:311
Contains classes representing SQL-data change statements.
enum_duplicates
Definition: sql_data_change.h:48
bool walk_item(Item *item, Select_lex_visitor *visitor)
Definition: sql_lex.cc:3526
#define IL_GTE_REPEATABLE
Definition: sql_lex.h:3068
void get_select_options_str(ulonglong options, std::string *str)
Definition: sql_lex.cc:5261
#define TRX_CACHE_EMPTY
Definition: sql_lex.h:3062
#define IL_LT_REPEATABLE
Definition: sql_lex.h:3066
void assert_consistent_hidden_flags(const mem_root_deque< Item * > &fields, Item *item, bool hidden)
In debug mode, verify that we're not adding an item twice to the fields list with inconsistent hidden...
Definition: sql_lex.h:4965
#define BINLOG_DIRECT_OFF
Definition: sql_lex.h:3059
#define BINLOG_DIRECT_ON
Definition: sql_lex.h:3056
bool is_invalid_string(const LEX_CSTRING &string_val, const CHARSET_INFO *charset_info)
(End of group GROUP_PARSER)
Definition: sql_lex.h:4912
bool accept_for_order(SQL_I_List< ORDER > orders, Select_lex_visitor *visitor)
Definition: sql_lex.cc:3532
#define TRX_CACHE_NOT_EMPTY
Definition: sql_lex.h:3064
bool accept_for_join(mem_root_deque< Table_ref * > *tables, Select_lex_visitor *visitor)
Definition: sql_lex.cc:3554
bool accept_table(Table_ref *t, Select_lex_visitor *visitor)
Definition: sql_lex.cc:3562
enum_comment_state
The state of the lexical parser, when parsing comments.
Definition: sql_lexer_input_stream.h:47
enum_mdl_type
Type of metadata lock request.
Definition: sql_lexer_yacc_state.h:106
@ MDL_SHARED_READ
Definition: sql_lexer_yacc_state.h:169
static const Query_options options
Definition: sql_show_processlist.cc:69
Our own string classes, used pervasively throughout the executor.
size_t convert_to_printable(char *to, size_t to_len, const char *from, size_t from_len, const CHARSET_INFO *from_cs, size_t nbytes=0)
Convert string to printable ASCII string.
Definition: sql_string.cc:1025
bool validate_string(const CHARSET_INFO *cs, const char *str, size_t length, size_t *valid_length, bool *length_error)
Check if an input byte sequence is a valid character string of a given charset.
Definition: sql_string.cc:1132
case opt name
Definition: sslopt-case.h:29
#define STRING_WITH_LEN(X)
Definition: string_with_len.h:29
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:213
Definition: m_ctype.h:423
const char * csname
Definition: m_ctype.h:428
Definition: handler.h:3791
Struct to hold information about the table that should be created.
Definition: handler.h:3202
Minion class under Collect_scalar_subquery_info.
Definition: item.h:2915
Definition: item.h:3166
Definition: table.h:2687
Definition: sql_lex.h:460
bool all
Definition: sql_lex.h:461
Structure to hold parameters for CHANGE REPLICATION SOURCE, START REPLICA, and STOP REPLICA.
Definition: sql_lex.h:353
void initialize()
Initializes everything to zero/NULL/empty.
Definition: sql_lex.cc:5001
enum LEX_SOURCE_INFO::@179 auto_position
uint port
Definition: sql_lex.h:362
enum LEX_SOURCE_INFO::@181 assign_gtids_to_anonymous_transactions_type
const char * channel
Definition: sql_lex.h:369
bool replica_until
Definition: sql_lex.h:375
enum LEX_SOURCE_INFO::@179 m_gtid_only
char * bind_addr
Definition: sql_lex.h:361
enum LEX_SOURCE_INFO::@179 retry_count_opt
char * network_namespace
Definition: sql_lex.h:361
char * ssl_crl
Definition: sql_lex.h:391
char * public_key_path
Definition: sql_lex.h:402
char * view_id
Definition: sql_lex.h:368
ulong relay_log_pos
Definition: sql_lex.h:404
char * tls_version
Definition: sql_lex.h:391
char * relay_log_name
Definition: sql_lex.h:403
@ LEX_MI_UNCHANGED
Definition: sql_lex.h:383
@ LEX_MI_DISABLE
Definition: sql_lex.h:384
@ LEX_MI_ENABLE
Definition: sql_lex.h:385
@ LEX_MI_ANONYMOUS_TO_GTID_UUID
Definition: sql_lex.h:444
@ LEX_MI_ANONYMOUS_TO_GTID_LOCAL
Definition: sql_lex.h:443
@ LEX_MI_ANONYMOUS_TO_GTID_UNCHANGED
Definition: sql_lex.h:441
@ LEX_MI_ANONYMOUS_TO_GTID_OFF
Definition: sql_lex.h:442
int sql_delay
Definition: sql_lex.h:364
float heartbeat_period
Definition: sql_lex.h:363
char * tls_ciphersuites_string
Definition: sql_lex.h:401
enum LEX_SOURCE_INFO::@179 m_source_connection_auto_failover
enum LEX_SOURCE_INFO::@178 gtid_until_condition
ulong server_id
Definition: sql_lex.h:366
ulong retry_count
Definition: sql_lex.h:366
enum LEX_SOURCE_INFO::@180 require_table_primary_key_check
Identifies what is the slave policy on primary keys in tables.
char * ssl_ca
Definition: sql_lex.h:390
ulonglong pos
Definition: sql_lex.h:365
uint connect_retry
Definition: sql_lex.h:362
LEX_SOURCE_INFO & operator=(const LEX_SOURCE_INFO &)
char * ssl_cert
Definition: sql_lex.h:390
Prealloced_array< ulong, 2 > repl_ignore_server_ids
Definition: sql_lex.h:407
char * ssl_key
Definition: sql_lex.h:390
void set_unspecified()
Sets all fields to their "unspecified" value.
Definition: sql_lex.cc:5038
char * user
Definition: sql_lex.h:361
int require_row_format
Flag indicating if row format should be enforced for this channel event stream.
Definition: sql_lex.h:422
@ UNTIL_SQL_AFTER_GTIDS
Definition: sql_lex.h:372
@ UNTIL_SQL_BEFORE_GTIDS
Definition: sql_lex.h:371
uint zstd_compression_level
Definition: sql_lex.h:406
char * log_file_name
Definition: sql_lex.h:361
enum_tls_ciphersuites
Definition: sql_lex.h:395
@ SPECIFIED_NULL
Definition: sql_lex.h:397
@ SPECIFIED_STRING
Definition: sql_lex.h:398
@ UNSPECIFIED
Definition: sql_lex.h:396
enum LEX_SOURCE_INFO::@179 ssl_verify_server_cert
char * password
Definition: sql_lex.h:361
const char * privilege_checks_hostname
Definition: sql_lex.h:417
char * host
Definition: sql_lex.h:361
enum LEX_SOURCE_INFO::@179 port_opt
char * compression_algorithm
Definition: sql_lex.h:405
enum LEX_SOURCE_INFO::@179 get_public_key
bool privilege_checks_none
Flag that is set to true whenever PRIVILEGE_CHECKS_USER is set to NULL as a part of a CHANGE REPLICAT...
Definition: sql_lex.h:412
char * ssl_cipher
Definition: sql_lex.h:390
enum enum_tls_ciphersuites tls_ciphersuites
Definition: sql_lex.h:400
enum LEX_SOURCE_INFO::@179 ssl
char * gtid
Definition: sql_lex.h:367
LEX_SOURCE_INFO()
Definition: sql_lex.h:358
bool until_after_gaps
Definition: sql_lex.h:374
enum LEX_SOURCE_INFO::@179 heartbeat_opt
LEX_SOURCE_INFO(const LEX_SOURCE_INFO &)
const char * assign_gtids_to_anonymous_transactions_manual_uuid
Definition: sql_lex.h:447
char * ssl_crlpath
Definition: sql_lex.h:391
bool for_channel
Definition: sql_lex.h:376
@ LEX_MI_PK_CHECK_OFF
Definition: sql_lex.h:436
@ LEX_MI_PK_CHECK_STREAM
Definition: sql_lex.h:434
@ LEX_MI_PK_CHECK_UNCHANGED
Definition: sql_lex.h:433
@ LEX_MI_PK_CHECK_ON
Definition: sql_lex.h:435
@ LEX_MI_PK_CHECK_GENERATE
Definition: sql_lex.h:437
enum LEX_SOURCE_INFO::@179 repl_ignore_server_ids_opt
char * ssl_capath
Definition: sql_lex.h:390
const char * privilege_checks_username
Username and hostname parts of the PRIVILEGE_CHECKS_USER, when it's set to a user.
Definition: sql_lex.h:417
Definition: table.h:2731
The LEX object currently serves three different purposes:
Definition: sql_lex.h:3823
execute_only_in_secondary_reasons get_not_supported_in_primary_reason() const
Definition: sql_lex.h:3999
void set_uncacheable(Query_block *curr_query_block, uint8 cause)
Set the current query as uncacheable.
Definition: sql_lex.h:4462
LEX_USER * grant_user
Definition: sql_lex.h:3901
bool binlog_need_explicit_defaults_ts
Definition: sql_lex.h:4379
uint grant_tot_col
Definition: sql_lex.h:4139
LEX_STRING prepared_stmt_code
Definition: sql_lex.h:4203
const char * x509_issuer
Definition: sql_lex.h:3894
bool all_privileges
Definition: sql_lex.h:4211
bool is_exec_started() const
Definition: sql_lex.h:4291
bool use_only_table_context
During name resolution search only in the table list given by Name_resolution_context::first_name_res...
Definition: sql_lex.h:4364
bool ignore_unknown_user
refers to optional IGNORE UNKNOWN USER clause in REVOKE sql.
Definition: sql_lex.h:4169
std::vector< uint > reparse_derived_table_params_at
If currently re-parsing a condition that is being pushed down to a derived table, this has the positi...
Definition: sql_lex.h:4128
void restore_backup_query_tables_list(Query_tables_list *backup)
Definition: sql_lex.cc:4315
execute_only_in_secondary_reasons m_execute_only_in_secondary_engine_reason
Definition: sql_lex.h:3840
uint8 create_view_check
Definition: sql_lex.h:4150
Prealloced_array< plugin_ref, INITIAL_LEX_PLUGIN_LIST_SIZE > Plugins_array
Definition: sql_lex.h:3913
bool new_top_level_query()
Create top-level query expression and query block.
Definition: sql_lex.cc:776
bool need_correct_ident()
Definition: sql_lex.cc:3809
execute_only_in_hypergraph_reasons m_execute_only_in_hypergraph_reason
Definition: sql_lex.h:3848
bool can_execute_only_in_hypergraph_optimizer() const
Definition: sql_lex.h:4015
LEX_ALTER alter_password
Definition: sql_lex.h:3902
bool m_broken
see mark_broken()
Definition: sql_lex.h:4217
const char * ssl_cipher
Definition: sql_lex.h:3894
bool table_or_sp_used()
Definition: sql_lex.cc:4331
Query_block * new_set_operation_query(Query_block *curr_query_block)
Create query block and attach it to the current query expression.
Definition: sql_lex.cc:700
void first_lists_tables_same()
Definition: sql_lex.cc:4205
bool validate_use_in_old_optimizer()
Validates if a query can run with the old optimizer.
Definition: sql_lex.cc:5239
Secondary_engine_execution_context * m_secondary_engine_context
Context object used by secondary storage engines to store query state during optimization and executi...
Definition: sql_lex.h:4582
bool was_replication_command_executed() const
Definition: sql_lex.h:4616
LEX_CSTRING prepared_stmt_name
Definition: sql_lex.h:4198
List< Name_resolution_context > context_stack
Definition: sql_lex.h:4061
bool autocommit
Definition: sql_lex.h:4171
Table_ref * insert_table
Table being inserted into (may be a view)
Definition: sql_lex.h:3917
void destroy()
Destroy contained objects, but not the LEX object itself.
Definition: sql_lex.h:4392
Query_result * result
Definition: sql_lex.h:3897
void destroy_values_map()
Definition: sql_lex.h:3967
void set_was_replication_command_executed()
Definition: sql_lex.h:4620
void set_current_query_block(Query_block *select)
Definition: sql_lex.h:3861
uint start_transaction_opt
Definition: sql_lex.h:4147
void new_static_query(Query_expression *sel_query_expression, Query_block *select)
Create query expression and query block in existing memory objects.
Definition: sql_lex.cc:808
bool deny_window_function(Query_block *qb) const
We have detected the presence of an alias of a window function with a window on query block qb.
Definition: sql_lex.h:4325
HA_CHECK_OPT check_opt
Definition: sql_lex.h:4065
bool drop_if_exists
Definition: sql_lex.h:4156
Table_ref * unlink_first_table(bool *link_to_local)
Definition: sql_lex.cc:4155
bool is_metadata_used() const
Check if the current statement uses meta-data (uses a table or a stored routine).
Definition: sql_lex.h:4313
bool is_lex_started
Definition: sql_lex.h:4366
bool is_explain() const
Definition: sql_lex.h:3868
char * to_log
Definition: sql_lex.h:3893
bool no_write_to_binlog
Definition: sql_lex.h:4172
bool drop_temporary
Definition: sql_lex.h:4170
void insert_values_map(Item_field *f1, Field *f2)
Definition: sql_lex.h:3962
Plugins_array plugins
Definition: sql_lex.h:3914
List< LEX_USER > * default_roles
Definition: sql_lex.h:3936
bool m_has_udf
True if statement references UDF functions.
Definition: sql_lex.h:4187
void mark_broken(bool broken=true)
Certain permanent transformations (like in2exists), if they fail, may leave the LEX in an inconsisten...
Definition: sql_lex.h:4267
bool is_ignore() const
Definition: sql_lex.h:4191
Alter_info * alter_info
Definition: sql_lex.h:4196
const char * stmt_definition_end
Definition: sql_lex.h:4356
void set_exec_completed()
Definition: sql_lex.h:4304
List< LEX_CSTRING > dynamic_privileges
Definition: sql_lex.h:3935
ulonglong m_statement_options
Statement context for Query_block::make_active_options.
Definition: sql_lex.h:4237
List< LEX_COLUMN > columns
Definition: sql_lex.h:3934
void cleanup_after_one_table_open()
Definition: sql_lex.cc:4274
Query_expression * unit
Outer-most query expression.
Definition: sql_lex.h:3826
bool verbose
Definition: sql_lex.h:4172
enum_view_create_mode create_view_mode
Definition: sql_lex.h:4134
bool has_values_map() const
Definition: sql_lex.h:3979
Opt_hints_global * opt_hints_global
Definition: sql_lex.h:3909
bool make_sql_cmd(Parse_tree_root *parse_tree)
Uses parse_tree to instantiate an Sql_cmd object and assigns it to the Lex.
Definition: sql_lex.cc:5085
List< LEX_USER > users_list
Definition: sql_lex.h:3933
bool can_execute_only_in_secondary_engine() const
Definition: sql_lex.h:3986
List< Item_param > param_list
List of placeholders ('?') for parameters of a prepared statement.
Definition: sql_lex.h:3958
bool grant_if_exists
refers to optional IF EXISTS clause in REVOKE sql.
Definition: sql_lex.h:4162
dd::info_schema::Table_statistics m_IS_table_stats
IS schema queries read some dynamic table statistics from SE.
Definition: sql_lex.h:4567
LEX_RESET_REPLICA reset_replica_info
Definition: sql_lex.h:4072
enum enum_duplicates duplicates
Definition: sql_lex.h:4131
bool is_single_level_stmt()
check if the statement is a single-level join
Definition: sql_lex.h:4546
bool m_extended_show
Definition: sql_lex.h:4174
USER_RESOURCES mqh
Definition: sql_lex.h:4071
bool using_hypergraph_optimizer() const
Whether the currently-running statement should be prepared and executed with the hypergraph optimizer...
Definition: sql_lex.h:3879
bool only_view
Definition: sql_lex.h:4337
bool save_cmd_properties(THD *thd)
Definition: sql_lex.h:4488
sp_pcontext * sp_current_parsing_ctx
Current SP parsing context.
Definition: sql_lex.h:4232
bool will_contextualize
Used to inform the parser whether it should contextualize the parse tree.
Definition: sql_lex.h:4385
st_sp_chistics sp_chistics
Definition: sql_lex.h:4333
KEY_CREATE_INFO key_create_info
Definition: sql_lex.h:4067
enum enum_tx_isolation tx_isolation
Definition: sql_lex.h:4132
void set_sp_current_parsing_ctx(sp_pcontext *ctx)
Definition: sql_lex.h:4307
uint32 next_binlog_file_nr
Definition: sql_lex.h:4214
bool check_preparation_invalid(THD *thd)
Check whether preparation state for prepared statement is invalid.
Definition: sql_lex.cc:842
void set_execute_only_in_hypergraph_optimizer(bool execute_in_hypergraph_optimizer_param, execute_only_in_hypergraph_reasons reason)
Definition: sql_lex.h:4018
dd::info_schema::Tablespace_statistics m_IS_tablespace_stats
Definition: sql_lex.h:4568
const char * get_only_supported_in_hypergraph_reason_str() const
Definition: sql_lex.h:4026
sp_pcontext * get_sp_current_parsing_ctx()
Definition: sql_lex.h:4305
LEX_STRING binlog_stmt_arg
Argument of the BINLOG event statement.
Definition: sql_lex.h:3898
Query_block * new_query(Query_block *curr_query_block)
Create query expression object that contains one query block.
Definition: sql_lex.cc:641
THD * thd
Definition: sql_lex.h:3906
bool rewrite_required
Definition: sql_lex.h:4627
bool contains_plaintext_password
Definition: sql_lex.h:4212
LEX_STRING name
Definition: sql_lex.h:3891
uint8 create_view_algorithm
Definition: sql_lex.h:4149
LEX_SOURCE_INFO mi
Definition: sql_lex.h:4068
ulong max_execution_time
Definition: sql_lex.h:4373
void restore_cmd_properties()
Definition: sql_lex.h:4480
bool grant_privilege
Set to true when GRANT ... GRANT OPTION ... TO ... is used (vs.
Definition: sql_lex.h:4146
bool m_exec_completed
Set to true when execution is completed, ie optimization has been done and execution is successful or...
Definition: sql_lex.h:4227
LEX_STRING ident
Definition: sql_lex.h:3900
bool m_can_execute_only_in_secondary_engine
Definition: sql_lex.h:3838
ulonglong bulk_insert_row_cnt
Definition: sql_lex.h:3938
void set_has_udf()
Definition: sql_lex.h:4193
bool has_udf() const
Definition: sql_lex.h:4194
List< Item_func_set_user_var > set_var_list
Definition: sql_lex.h:3948
uint8 create_view_suid
Definition: sql_lex.h:4341
bool push_context(Name_resolution_context *context)
Definition: sql_lex.h:4520
void pop_context()
Definition: sql_lex.h:4524
bool m_was_replication_command_executed
Definition: sql_lex.h:4613
enum enum_yes_no_unknown tx_chain tx_release
Definition: sql_lex.h:4176
void clear_privileges()
Definition: sql_lex.cc:3604
LEX()
Definition: sql_lex.cc:3695
partition_info * part_info
Definition: sql_lex.h:3925
bool m_using_hypergraph_optimizer
Definition: sql_lex.h:3888
char * help_arg
Definition: sql_lex.h:3892
Server_options server_options
Definition: sql_lex.h:4070
bool copy_db_to(char const **p_db, size_t *p_db_length) const
This method should be called only during parsing.
Definition: sql_lex.cc:3840
enum_alter_user_attribute alter_user_attribute
Definition: sql_lex.h:3903
bool m_can_execute_only_in_hypergraph_optimizer
Definition: sql_lex.h:3847
std::map< Item_field *, Field * >::iterator end_values_map()
Definition: sql_lex.h:3983
List< Item > purge_value_list
Definition: sql_lex.h:3941
Query_block * current_query_block() const
Definition: sql_lex.h:3852
std::map< Item_field *, Field * > * insert_update_values_map
Definition: sql_lex.h:4045
bool ignore
Definition: sql_lex.h:4188
Name_resolution_context * current_context()
Definition: sql_lex.h:4532
enum SSL_type ssl_type
Definition: sql_lex.h:4130
bool is_explain_analyze
Definition: sql_lex.h:3869
HA_CREATE_INFO * create_info
Definition: sql_lex.h:4066
void set_using_hypergraph_optimizer(bool use_hypergraph)
Definition: sql_lex.h:3883
void assert_ok_set_current_query_block()
Definition: sql_lex.cc:386
Query_block * new_empty_query_block()
Create an empty query block within this LEX object.
Definition: sql_lex.cc:584
bool in_update_value_clause
Set to true while resolving values in ON DUPLICATE KEY UPDATE clause.
Definition: sql_lex.h:4368
Query_block * all_query_blocks_list
List of all query blocks.
Definition: sql_lex.h:3829
void release_plugins()
Definition: sql_lex.cc:543
uint reparse_common_table_expr_at
If currently re-parsing a CTE's definition, this is the offset in bytes of that definition in the ori...
Definition: sql_lex.h:4117
Event_parse_data * event_parse_data
Definition: sql_lex.h:4335
bool safe_to_cache_query
Whether this query will return the same answer every time, given unchanged data.
Definition: sql_lex.h:4183
sp_name * spname
Definition: sql_lex.h:4209
bool prepared_stmt_code_is_varref
Definition: sql_lex.h:4205
void set_ignore(bool ignore_param)
Definition: sql_lex.h:4192
my_thread_id show_profile_query_id
QUERY ID for SHOW PROFILE.
Definition: sql_lex.h:4137
List< set_var_base > var_list
Definition: sql_lex.h:3947
bool reparse_derived_table_condition
If currently re-parsing a condition which is pushed down to a derived table, this will be set to true...
Definition: sql_lex.h:4122
LEX_STRING alter_user_comment_text
Definition: sql_lex.h:3904
bool is_ps_or_view_context_analysis()
Definition: sql_lex.h:4440
Query_block * query_block
First query block.
Definition: sql_lex.h:3828
ulonglong statement_options()
Gets the options that have been set for this statement.
Definition: sql_lex.h:4247
bool which_check_option_applicable()
Definition: sql_lex.h:4503
void set_execute_only_in_secondary_engine(const bool execute_only_in_secondary_engine_param, execute_only_in_secondary_reasons reason)
Definition: sql_lex.h:3989
bool set_wild(LEX_STRING)
Definition: sql_lex.cc:4992
uint grant
Definition: sql_lex.h:4139
enum_keep_diagnostics keep_diagnostics
Definition: sql_lex.h:4213
bool is_rewrite_required()
Definition: sql_lex.h:4632
Table_ref * insert_table_leaf
Leaf table being inserted into (always a base table)
Definition: sql_lex.h:3919
LEX_USER * definer
Definition: sql_lex.h:3931
void set_rewrite_required()
Definition: sql_lex.h:4630
List< Item > kill_value_list
Definition: sql_lex.h:3944
const char * get_not_supported_in_primary_reason_str()
Definition: sql_lex.h:4004
uint replica_thd_opt
Definition: sql_lex.h:4147
void restore_properties_for_insert()
Definition: sql_lex.h:4482
void clear_values_map()
Definition: sql_lex.h:3974
void set_secondary_engine_execution_context(Secondary_engine_execution_context *context)
Sets the secondary engine execution context for this statement.
Definition: sql_lex.cc:5231
bool is_broken() const
Definition: sql_lex.h:4258
bool sp_lex_in_use
Definition: sql_lex.h:4210
List< LEX_STRING > prepared_stmt_params
Definition: sql_lex.h:4207
LEX_REPLICA_CONNECTION replica_connection
Definition: sql_lex.h:4069
Secondary_engine_execution_context * secondary_engine_execution_context() const
Gets the secondary engine execution context for this statement.
Definition: sql_lex.h:4588
st_parsing_options parsing_options
Definition: sql_lex.h:4195
int select_number
Number of query block (by EXPLAIN)
Definition: sql_lex.h:4148
void add_statement_options(ulonglong options)
Add options to values of m_statement_options.
Definition: sql_lex.h:4255
uint profile_options
Definition: sql_lex.h:4138
Query_expression * create_query_expr_and_block(THD *thd, Query_block *current_query_block, Item *where_clause, Item *having_clause, enum_parsing_context ctx)
Create query expression under current_query_block and a query block under the new query expression.
Definition: sql_lex.cc:594
nesting_map m_deny_window_func
Windowing functions are not allowed in HAVING - in contrast to grouped aggregate functions,...
Definition: sql_lex.h:4096
LEX_GRANT_AS grant_as
Definition: sql_lex.h:3905
String * wild
Definition: sql_lex.h:3896
bool expr_allows_subquery
Definition: sql_lex.h:4111
void reset()
Reset query context to initial state.
Definition: sql_lex.cc:409
bool m_exec_started
Set to true when execution has started (after parsing, tables opened and query preparation is complet...
Definition: sql_lex.h:4222
void clear_execution()
Clear execution state for a statement after it has been prepared or executed, and before it is (re-)e...
Definition: sql_lex.cc:555
bool locate_var_assignment(const Name_string &name)
Locate an assignment to a user variable with a given name, within statement.
Definition: sql_lex.cc:4348
Sql_cmd * m_sql_cmd
Definition: sql_lex.h:4103
execute_only_in_hypergraph_reasons get_only_supported_in_hypergraph_reason() const
Definition: sql_lex.h:4033
void reset_rewrite_required()
Definition: sql_lex.h:4631
LEX_STRING create_view_query_block
SELECT of CREATE VIEW statement.
Definition: sql_lex.h:3922
bool set_channel_name(LEX_CSTRING name={})
Set replication channel name.
Definition: sql_lex.cc:5104
bool accept(Select_lex_visitor *visitor)
Definition: sql_lex.cc:4988
void reset_exec_started()
Definition: sql_lex.h:4293
sp_head * sphead
Definition: sql_lex.h:4208
void reset_n_backup_query_tables_list(Query_tables_list *backup)
Definition: sql_lex.cc:4298
udf_func udf
Definition: sql_lex.h:4064
void set_trg_event_type_for_tables()
Set the initial purpose of this Table_ref object in the list of used tables.
Definition: sql_lex.cc:4020
void link_first_table_back(Table_ref *first, bool link_to_local)
Definition: sql_lex.cc:4241
const char * stmt_definition_begin
Intended to point to the next word after DEFINER-clause in the following statements:
Definition: sql_lex.h:4355
bool is_exec_completed() const
Check whether the statement has been executed (regardless of completion - successful or in error).
Definition: sql_lex.h:4303
enum enum_var_type option_type
Definition: sql_lex.h:4133
uint8 context_analysis_only
Definition: sql_lex.h:4155
bool can_use_merged()
check if command can use VIEW with MERGE algorithm (for top VIEWs)
Definition: sql_lex.cc:3733
bool can_not_use_merged()
Check if command can't use merged views in any part of command.
Definition: sql_lex.cc:3786
std::map< Item_field *, Field * >::iterator begin_values_map()
Definition: sql_lex.h:3980
bool m_subquery_to_derived_is_impossible
If true: during prepare, we did a subquery transformation (IN-to-EXISTS, SOME/ANY) that doesn't curre...
Definition: sql_lex.h:4101
void set_exec_started()
Definition: sql_lex.h:4292
Query_block * m_current_query_block
Definition: sql_lex.h:3832
Item_sum * in_sum_func
Definition: sql_lex.h:4063
virtual ~LEX()
Definition: sql_lex.cc:393
class Explain_format * explain_format
Definition: sql_lex.h:4370
void cleanup(bool full)
Definition: sql_lex.h:4283
nesting_map allow_sum_func
This field is used as a work field during resolving to validate the use of aggregate functions.
Definition: sql_lex.h:4085
const char * x509_subject
Definition: sql_lex.h:3894
friend bool lex_start(THD *thd)
Call lex_start() before every query that is to be prepared and executed.
Definition: sql_lex.cc:508
bool is_view_context_analysis()
Definition: sql_lex.h:4445
ulong type
Definition: sql_lex.h:4073
Helper singleton class used to track information needed to perform the transform of a correlated scal...
Definition: sql_resolver.cc:6688
Definition: thr_lock.h:99
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:83
void * Alloc(size_t length)
Allocate memory.
Definition: my_alloc.h:145
Definition: mysql_lex_string.h:40
const char * str
Definition: mysql_lex_string.h:41
size_t length
Definition: mysql_lex_string.h:42
Definition: mysql_lex_string.h:35
Bison "location" class.
Definition: parse_location.h:43
Definition: materialize_path_parameters.h:42
Struct NESTED_JOIN is used to represent how tables are connected through outer join operations and se...
Definition: nested_join.h:78
Definition: item.h:402
Definition: table.h:286
Environment data for the contextualization phase.
Definition: parse_tree_node_base.h:420
Input parameters to the parser.
Definition: sql_lexer_parser_input.h:32
Parser_input()
Definition: sql_lexer_parser_input.h:50
bool m_compute_digest
True if the caller needs to compute a digest.
Definition: sql_lexer_parser_input.h:48
bool m_has_digest
True if the text parsed corresponds to an actual query, and not another text artifact.
Definition: sql_lexer_parser_input.h:42
Definition: table.h:1406
Definition: simset.h:36
Definition: result.h:30
State data storage for digest_start, digest_add_token.
Definition: sql_digest_stream.h:36
Definition: sql_lex.h:4863
Definition: sql_lex.h:3235
void reset()
Definition: sql_lex.cc:169
bool allows_select_into
Definition: sql_lex.h:3237
bool allows_variable
Definition: sql_lex.h:3236
st_parsing_options()
Definition: sql_lex.h:3239
Definition: sql_lex.h:2555
LEX_CSTRING comment
Definition: sql_lex.h:2556
enum enum_sp_data_access daccess
Definition: sql_lex.h:2559
bool detistic
Definition: sql_lex.h:2558
enum enum_sp_suid_behaviour suid
Definition: sql_lex.h:2557
LEX_CSTRING language
CREATE|ALTER ... LANGUAGE <language>
Definition: sql_lex.h:2560
Definition: sql_lex.h:2565
enum enum_trigger_event_type event
Definition: sql_lex.h:2567
LEX_CSTRING anchor_trigger_name
Trigger name referenced in the FOLLOWS/PRECEDES clause of the CREATE TRIGGER statement.
Definition: sql_lex.h:2578
enum enum_trigger_order_type ordering_clause
FOLLOWS or PRECEDES as specified in the CREATE TRIGGER statement.
Definition: sql_lex.h:2572
enum enum_trigger_action_time_type action_time
Definition: sql_lex.h:2566
Definition: sql_lex.h:2546
void reset()
Cleans slave connection info.
Definition: sql_lex.cc:177
char * user
Definition: sql_lex.h:2547
char * plugin_dir
Definition: sql_lex.h:2550
char * plugin_auth
Definition: sql_lex.h:2549
char * password
Definition: sql_lex.h:2548
Definition: sql_udf.h:44
Definition: sql_connect.h:41
thr_lock_type
Definition: thr_lock.h:51
@ TL_UNLOCK
Definition: thr_lock.h:53
@ TL_READ_DEFAULT
Definition: thr_lock.h:61
This file defines all base public constants related to triggers in MySQL.
enum_trigger_event_type
Constants to enumerate possible event types on which triggers can be fired.
Definition: trigger_def.h:42
enum_trigger_order_type
Possible trigger ordering clause values:
Definition: trigger_def.h:64
enum_trigger_action_time_type
Constants to enumerate possible timings when triggers can be fired.
Definition: trigger_def.h:52
Definition: lexer_yystype.h:33
Definition: parser_yystype.h:341
Definition: dtoa.cc:588
#define PSI_NOT_INSTRUMENTED
Definition: validate_password_imp.cc:42
Vio Lite.
SSL_type
Definition: violite.h:307
An adapter class to support iteration over an iterator of Item * (typically mem_root_deque<Item *>),...
auto VisibleFields(mem_root_deque< Item * > &fields)
Definition: visible_fields.h:112
int n
Definition: xcom_base.cc:509