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