MySQL 8.3.0
Source Code Documentation
parse_tree_nodes.h
Go to the documentation of this file.
1/* Copyright (c) 2013, 2023, 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 also distributed 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 included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef PARSE_TREE_NODES_INCLUDED
24#define PARSE_TREE_NODES_INCLUDED
25
26#include <assert.h>
27#include <sys/types.h> // TODO: replace with cstdint
28
29#include <bit>
30#include <cctype> // std::isspace
31#include <cstddef>
32#include <memory>
33
34#include "lex_string.h"
35#include "my_alloc.h"
36#include "my_base.h"
37
38#include "my_inttypes.h" // TODO: replace with cstdint
39#include "my_sqlcommand.h"
40#include "my_sys.h"
41#include "my_thread_local.h"
42#include "my_time.h"
43#include "mysqld_error.h"
44#include "sql/check_stack.h"
45#include "sql/enum_query_type.h"
46#include "sql/handler.h"
47#include "sql/key_spec.h"
48#include "sql/mem_root_array.h"
49#include "sql/opt_explain.h" // Sql_cmd_explain_other_thread
50#include "sql/parse_location.h"
51#include "sql/parse_tree_helpers.h" // PT_item_list
53#include "sql/parser_yystype.h"
54#include "sql/partition_info.h"
57#include "sql/set_var.h"
58#include "sql/sql_admin.h" // Sql_cmd_shutdown etc.
59#include "sql/sql_alter.h"
60#include "sql/sql_check_constraint.h" // Sql_check_constraint_spec
61#include "sql/sql_cmd_srs.h"
62#include "sql/sql_exchange.h"
63#include "sql/sql_lex.h" // LEX
64#include "sql/sql_list.h"
65#include "sql/sql_load.h" // Sql_cmd_load_table
67#include "sql/sql_restart_server.h" // Sql_cmd_restart_server
68#include "sql/sql_tablespace.h" // Tablespace_options
69#include "sql/sql_truncate.h" // Sql_cmd_truncate_table
70#include "sql/table.h" // Common_table_expr
71#include "sql/window_lex.h"
72#include "string_with_len.h"
73#include "thr_lock.h"
74
75class Item;
76class Item_cache;
80class PT_hint_list;
83class PT_partition;
84class PT_subquery;
85class PT_type;
86class PT_window_list;
87class Sql_cmd;
88class String;
89class THD;
90class Window;
91class sp_head;
92class sp_name;
93struct CHARSET_INFO;
94
95/**
96 @defgroup ptn Parse tree nodes
97 @ingroup Parser
98*/
99/**
100 @defgroup ptn_stmt Nodes representing SQL statements
101 @ingroup ptn
102*/
103/**
104 @defgroup ptn_create_table CREATE TABLE statement
105 @ingroup ptn_stmt
106*/
107/**
108 @defgroup ptn_alter_table ALTER TABLE statement
109 @ingroup ptn_stmt
110*/
111/**
112 @defgroup ptn_create_table_stuff Clauses of CREATE TABLE statement
113 @ingroup ptn_create_table
114*/
115/**
116 @defgroup ptn_partitioning CREATE/ALTER TABLE partitioning-related stuff
117 @ingroup ptn_create_table ptn_alter_table
118*/
119/**
120 @defgroup ptn_part_options Partition options in CREATE/ALTER TABLE
121 @ingroup ptn_partitioning
122*/
123/**
124 @defgroup ptn_create_or_alter_table_options Table options of CREATE/ALTER
125 TABLE
126 @anchor ptn_create_or_alter_table_options
127 @ingroup ptn_create_table ptn_alter_table
128*/
129/**
130 @defgroup ptn_col_types Column types in CREATE/ALTER TABLE
131 @ingroup ptn_create_table ptn_alter_table
132*/
133/**
134 @defgroup ptn_col_attrs Column attributes in CREATE/ALTER TABLE
135 @ingroup ptn_create_table ptn_alter_table
136*/
137/**
138 @defgroup ptn_not_gcol_attr Non-generated column attributes in CREATE/ALTER
139 TABLE
140 @ingroup ptn_col_attrs ptn_alter_table
141*/
142
143/**
144 Calls contextualize() on every node in the array.
145*/
146template <class Node_type, class Parse_context_type>
148 Parse_context_type *pc) {
149 for (Node_type *i : nodes)
150 if (i->contextualize(pc)) return true;
151 return false;
152}
153
154/**
155 Base class for all top-level nodes of SQL statements
156
157 @ingroup ptn_stmt
158*/
161 void operator=(const Parse_tree_root &) = delete;
162
163 protected:
164 Parse_tree_root() = default;
165 explicit Parse_tree_root(const POS &pos) : m_pos(pos) {}
166 virtual ~Parse_tree_root() = default;
167
168 public:
169 /// Textual location of a token just parsed.
171
172 virtual Sql_cmd *make_cmd(THD *thd) = 0;
173
174 // Return Json parse tree generated by SHOW PARSE_TREE.
175 virtual std::string get_printable_parse_tree(THD *thd [[maybe_unused]]) {
176 my_error(ER_NOT_SUPPORTED_YET, MYF(0),
177 "Parse tree display of this statement");
178 return "";
179 }
180};
181
183 public:
186
187 ~PT_table_ddl_stmt_base() override = 0; // force abstract class
188
189 protected:
191};
192
194
195/**
196 Parse context for the table DDL (ALTER TABLE and CREATE TABLE) nodes.
197
198 For internal use in the contextualization code.
199*/
201 Table_ddl_parse_context(THD *thd_arg, Query_block *select_arg,
206};
207
208/**
209 Base class for all table DDL (ALTER TABLE and CREATE TABLE) nodes.
210*/
212
213class PT_order_expr : public Parse_tree_node, public ORDER {
215
216 public:
217 PT_order_expr(const POS &pos, Item *item_arg, enum_order dir) : super(pos) {
218 item_initial = item_arg;
220 }
221
222 bool do_contextualize(Parse_context *pc) override;
223
224 protected:
225 void add_json_info(Json_object *obj) override {
226 obj->add_alias("desc",
227 create_dom_ptr<Json_boolean>(direction == ORDER_DESC));
228 }
229};
230
233
234 public:
236
237 public:
238 explicit PT_order_list(const POS &pos) : super(pos) {}
239
240 bool do_contextualize(Parse_context *pc) override {
241 if (super::do_contextualize(pc)) return true;
242 for (ORDER *o = value.first; o != nullptr; o = o->next) {
243 if (static_cast<PT_order_expr *>(o)->contextualize(pc)) return true;
244 }
245 return false;
246 }
247
249 order->used_alias = nullptr;
250 order->used = 0;
251 value.link_in_list(order, &order->next);
252 }
253};
254
257
258 public:
259 explicit PT_gorder_list(const POS &pos) : super(pos) {}
260
261 bool do_contextualize(Parse_context *pc) override {
262 return super::do_contextualize(pc);
263 }
264};
265
266/**
267 Represents an element of the WITH list:
268 WITH [...], [...] SELECT ...,
269 ^ or ^
270 i.e. a Common Table Expression (CTE, or Query Name in SQL99 terms).
271*/
274
275 public:
276 explicit PT_common_table_expr(const POS &pos, const LEX_STRING &name,
277 const LEX_STRING &subq_text,
278 uint subq_text_offset, PT_subquery *sn,
281
282 /// The name after AS
283 const LEX_STRING &name() const { return m_name; }
284 /**
285 @param thd Thread handler
286 @param[out] node PT_subquery
287 @returns a PT_subquery to attach to a table reference for this CTE
288 */
289 bool make_subquery_node(THD *thd, PT_subquery **node);
290 /**
291 @param tl Table reference to match
292 @param in_self If this is a recursive reference
293 @param[out] found Is set to true/false if matches or not
294 @returns true if error
295 */
296 bool match_table_ref(Table_ref *tl, bool in_self, bool *found);
297 /**
298 @returns true if 'other' is the same instance as 'this'
299 */
300 bool is(const Common_table_expr *other) const {
301 return other == &m_postparse;
302 }
303 void print(const THD *thd, String *str, enum_query_type query_type);
304 bool do_contextualize(Parse_context *pc) override;
305
306 protected:
307 void add_json_info(Json_object *obj) override;
308
309 private:
311 /// Raw text of query expression (including parentheses)
313 /**
314 Offset in bytes of m_subq_text in original statement which had the WITH
315 clause.
316 */
318 /// Parsed version of subq_text
320 /// List of explicitly specified column names; if empty, no list.
322 /**
323 A Table_ref representing a CTE needs access to the WITH list
324 element it derives from. However, in order to:
325 - limit the members which Table_ref can access
326 - avoid including this header file everywhere Table_ref needs to
327 access these members, these members are relocated into a separate inferior
328 object whose declaration is in table.h, like that of Table_ref. It's
329 the "postparse" part. Table_ref accesses this inferior object only.
330 */
332
334};
335
336/**
337 Represents the WITH list.
338 WITH [...], [...] SELECT ...,
339 ^^^^^^^^^^^^
340*/
343
344 public:
345 /// @param pos Position of this clause in the SQL statement.
346 /// @param mem_root where interior objects are allocated
347 explicit PT_with_list(const POS &pos, MEM_ROOT *mem_root)
348 : super(pos), m_elements(mem_root) {}
351 return m_elements;
352 }
353
354 private:
356};
357
358/**
359 Represents the WITH clause:
360 WITH [...], [...] SELECT ...,
361 ^^^^^^^^^^^^^^^^^
362*/
365
366 public:
367 PT_with_clause(const POS &pos, const PT_with_list *l, bool r)
368 : super(pos),
369 m_list(l),
370 m_recursive(r),
372
373 bool do_contextualize(Parse_context *pc) override;
374
375 /**
376 Looks up a table reference into the list of CTEs.
377 @param tl Table reference to look up
378 @param[out] found Is set to true/false if found or not
379 @returns true if error
380 */
381 bool lookup(Table_ref *tl, PT_common_table_expr **found);
382 /**
383 Call this to record in the WITH clause that we are contextualizing the
384 CTE definition inserted in table reference 'tl'.
385 @returns information which the caller must provide to
386 leave_parsing_definition().
387 */
389 auto old = m_most_inner_in_parsing;
391 return old;
392 }
395 }
396 void print(const THD *thd, String *str, enum_query_type query_type);
397
398 protected:
399 void add_json_info(Json_object *obj) override {
400 obj->add_alias("recursive", create_dom_ptr<Json_boolean>(m_recursive));
401 }
402
403 private:
404 /// All CTEs of this clause
405 const PT_with_list *const m_list;
406 /// True if the user has specified the RECURSIVE keyword.
407 const bool m_recursive;
408 /**
409 The innermost CTE reference which we're parsing at the
410 moment. Used to detect forward references, loops and recursiveness.
411 */
413
415};
416
419
420 public:
421 explicit PT_select_item_list(const POS &pos) : super(pos) {}
422
423 bool do_contextualize(Parse_context *pc) override;
424};
425
428
430
431 protected:
432 void add_json_info(Json_object *obj) override {
433 obj->add_alias("is_offset_first",
434 create_dom_ptr<Json_boolean>(limit_options.is_offset_first));
435 }
436
437 public:
438 PT_limit_clause(const POS &pos, const Limit_options &limit_options_arg)
439 : super(pos), limit_options(limit_options_arg) {}
440
441 bool do_contextualize(Parse_context *pc) override;
443};
444
445class PT_cross_join;
446class PT_joined_table;
447
449 public:
450 explicit PT_table_reference(const POS &pos) : Parse_tree_node(pos) {}
451
453
454 /**
455 Lets us build a parse tree top-down, which is necessary due to the
456 context-dependent nature of the join syntax. This function adds
457 the @<table_ref@> cross join as the left-most leaf in this join tree
458 rooted at this node.
459
460 @todo: comment on non-join PT_table_reference objects
461
462 @param cj This @<table ref@> will be added if it represents a cross join.
463
464 @return The new top-level join.
465 */
467};
468
471
474 const char *const opt_table_alias;
476
477 public:
478 PT_table_factor_table_ident(const POS &pos, Table_ident *table_ident_arg,
479 List<String> *opt_use_partition_arg,
480 const LEX_CSTRING &opt_table_alias_arg,
481 List<Index_hint> *opt_key_definition_arg)
482 : super(pos),
483 table_ident(table_ident_arg),
484 opt_use_partition(opt_use_partition_arg),
485 opt_table_alias(opt_table_alias_arg.str),
486 opt_key_definition(opt_key_definition_arg) {}
487
488 protected:
489 bool do_contextualize(Parse_context *pc) override;
490 void add_json_info(Json_object *obj) override;
491};
492
494 protected:
495 explicit PT_json_table_column(const POS &pos) : Parse_tree_node(pos) {}
496
497 public:
499};
500
503
504 public:
507 const LEX_STRING &table_alias)
508 : super(pos),
509 m_expr(expr),
510 m_path(path),
511 m_nested_columns(nested_cols),
512 m_table_alias(table_alias) {}
513
514 bool do_contextualize(Parse_context *pc) override;
515
516 private:
521};
522
525
527
528 public:
531 : super(pos), table_list(table_list) {}
532
533 bool do_contextualize(Parse_context *pc) override;
534};
535
538
539 public:
540 PT_derived_table(const POS &pos, bool lateral, PT_subquery *subquery,
541 const LEX_CSTRING &table_alias,
543
544 bool do_contextualize(Parse_context *pc) override;
545
546 protected:
547 void add_json_info(Json_object *obj) override;
548
549 private:
552 const char *const m_table_alias;
553 /// List of explicitly specified column names; if empty, no list.
555};
556
559
560 public:
562 : super(pos), m_joined_table(joined_table) {}
563
564 bool do_contextualize(Parse_context *pc) override;
565
566 private:
568};
569
572
573 protected:
578
581
582 public:
583 PT_joined_table(const POS &pos, PT_table_reference *tab1_node_arg,
584 const POS &join_pos_arg, PT_joined_table_type type,
585 PT_table_reference *tab2_node_arg)
586 : super(pos),
587 m_left_pt_table(tab1_node_arg),
588 m_join_pos(join_pos_arg),
589 m_type(type),
590 m_right_pt_table(tab2_node_arg) {
591 using std::has_single_bit;
592 static_assert(has_single_bit(unsigned{JTT_INNER}), "not a single bit");
593 static_assert(has_single_bit(unsigned{JTT_STRAIGHT}), "not a single bit");
594 static_assert(has_single_bit(unsigned{JTT_NATURAL}), "not a single bit");
595 static_assert(has_single_bit(unsigned{JTT_LEFT}), "not a single bit");
596 static_assert(has_single_bit(unsigned{JTT_RIGHT}), "not a single bit");
597
598 assert(type == JTT_INNER || type == JTT_STRAIGHT_INNER ||
601 }
602
603 /**
604 Adds the cross join to this join operation. The cross join is nested as
605 the table reference on the left-hand side.
606 */
609 return this;
610 }
611
612 /// Adds the table reference as the right-hand side of this join.
614 assert(m_right_pt_table == nullptr);
616 }
617
618 bool do_contextualize(Parse_context *pc) override;
619
620 /// This class is being inherited, it should thus be abstract.
621 ~PT_joined_table() override = 0;
622
623 protected:
625 void add_json_info(Json_object *obj) override;
626};
627
628inline PT_joined_table::~PT_joined_table() = default;
629
632
633 public:
634 PT_cross_join(const POS &pos, PT_table_reference *tab1_node_arg,
635 const POS &join_pos_arg, PT_joined_table_type Type_arg,
636 PT_table_reference *tab2_node_arg)
637 : PT_joined_table(pos, tab1_node_arg, join_pos_arg, Type_arg,
638 tab2_node_arg) {}
639
640 bool do_contextualize(Parse_context *pc) override;
641};
642
646
647 public:
648 PT_joined_table_on(const POS &pos, PT_table_reference *tab1_node_arg,
649 const POS &join_pos_arg, PT_joined_table_type type,
650 PT_table_reference *tab2_node_arg, Item *on_arg)
651 : super(pos, tab1_node_arg, join_pos_arg, type, tab2_node_arg),
652 on(on_arg) {}
653
654 bool do_contextualize(Parse_context *pc) override;
655};
656
660
661 public:
662 PT_joined_table_using(const POS &pos, PT_table_reference *tab1_node_arg,
663 const POS &join_pos_arg, PT_joined_table_type type,
664 PT_table_reference *tab2_node_arg,
665 List<String> *using_fields_arg)
666 : super(pos, tab1_node_arg, join_pos_arg, type, tab2_node_arg),
667 using_fields(using_fields_arg) {}
668
669 /// A PT_joined_table_using without a list of columns denotes a natural join.
670 PT_joined_table_using(const POS &pos, PT_table_reference *tab1_node_arg,
671 const POS &join_pos_arg, PT_joined_table_type type,
672 PT_table_reference *tab2_node_arg)
673 : PT_joined_table_using(pos, tab1_node_arg, join_pos_arg, type,
674 tab2_node_arg, nullptr) {}
675
676 bool do_contextualize(Parse_context *pc) override;
677
678 protected:
679 void add_json_info(Json_object *obj) override;
680};
681
682class PT_group : public Parse_tree_node {
684
687
688 protected:
689 void add_json_info(Json_object *obj) override {
690 if (olap == ROLLUP_TYPE)
691 obj->add_alias("olap_options", create_dom_ptr<Json_string>("ROLLUP"));
692 // Only rollup type supported.
693 }
694
695 public:
696 PT_group(const POS &pos, PT_order_list *group_list_arg, olap_type olap_arg)
697 : super(pos), group_list(group_list_arg), olap(olap_arg) {}
698
699 bool do_contextualize(Parse_context *pc) override;
700};
701
702class PT_order : public Parse_tree_node {
704
705 public:
707 explicit PT_order(const POS &pos, PT_order_list *order_list_arg)
708 : super(pos), order_list(order_list_arg) {}
709
710 bool do_contextualize(Parse_context *pc) override;
711};
712
714 public:
715 PT_locking_clause(const POS &pos, Lock_strength strength,
717 : Parse_tree_node(pos),
718 m_lock_strength(strength),
720
721 bool do_contextualize(Parse_context *pc) final;
722
723 virtual bool set_lock_for_tables(Parse_context *pc) = 0;
724
726
727 protected:
729 thr_lock_type lock_type = TL_IGNORE;
730 switch (m_lock_strength) {
732 lock_type = TL_WRITE;
733 break;
735 lock_type = TL_READ_WITH_SHARED_LOCKS;
736 break;
737 }
738
739 return {lock_type, static_cast<thr_locked_row_action>(action())};
740 }
741
742 private:
745};
746
748 public:
750 const POS &pos, Lock_strength strength,
752 : PT_locking_clause(pos, strength, action) {}
753
754 bool set_lock_for_tables(Parse_context *pc) override;
755};
756
758 public:
760
764 : PT_locking_clause(pos, strength, action), m_tables(tables) {}
765
766 bool set_lock_for_tables(Parse_context *pc) override;
767
768 private:
769 bool raise_error(THD *thd, const Table_ident *name, int error);
770
771 bool raise_error(int error);
772
774};
775
777 public:
779 : Parse_tree_node(pos) {
781 }
782
783 bool push_back(PT_locking_clause *locking_clause) {
784 return m_locking_clauses.push_back(locking_clause);
785 }
786
787 bool do_contextualize(Parse_context *pc) override {
788 for (auto locking_clause : m_locking_clauses)
789 if (locking_clause->contextualize(pc)) return true;
790 return false;
791 }
792
793 private:
795};
796
798 public:
799 explicit PT_query_expression_body(const POS &pos) : Parse_tree_node(pos) {}
800
801 virtual bool is_set_operation() const = 0;
802
803 /**
804 True if this query expression can absorb an extraneous order by/limit
805 clause. The `ORDER BY`/`LIMIT` syntax is mostly consistestent, i.e. a
806 trailing clause may not refer to the tables in the `<query primary>`, with
807 one glaring exception:
808
809 (...( SELECT ... )...) ORDER BY ...
810
811 If the nested query expression doesn't contain `ORDER BY`, the statement
812 is interpreted as if the `ORDER BY` was absorbed by the innermost query
813 expression, i.e.:
814
815 (...( SELECT ... ORDER BY ... )...)
816
817 There is no rewriting of the parse tree nor AST happening here, the
818 transformation is done by the contextualizer (see
819 PT_query_expression::contextualize_order_and_limit), which interprets the
820 parse tree, and builds the AST according to this interpretation. This
821 interpretation is governed by the following rule: An `ORDER BY` can be
822 absorbed if none the nested query expressions contains an `ORDER BY` *or*
823 `LIMIT`. The rule is complex, so here are some examples for illustration:
824
825 In these cases the `ORDER BY` *is* absorbed:
826
827 ( SELECT * FROM t1 ) ORDER BY t1.a;
828 (( SELECT * FROM t1 )) ORDER BY t1.a;
829
830 In these cases the ORDER BY is *not* absorbed:
831
832 ( SELECT * FROM t1 ORDER BY 1 ) ORDER BY t1.a;
833 (( SELECT * FROM t1 ) ORDER BY 1 ) ORDER BY t1.a;
834 ( SELECT * FROM t1 LIMIT 1 ) ORDER BY t1.a;
835 (( SELECT * FROM t1 ) LIMIT 1 ) ORDER BY t1.a;
836
837 The same happens with `LIMIT`, obviously, but the optimizer is freeer to
838 choose when to apply the limit, and there are name no resolution issues
839 involved.
840
841 @param order True if the outer query block has the ORDER BY clause.
842 @param limit True if the outer query block has the LIMIT clause.
843 */
844 virtual bool can_absorb_order_and_limit(bool order, bool limit) const = 0;
845 virtual bool has_into_clause() const = 0;
846 virtual bool has_trailing_into_clause() const = 0;
847
848 virtual bool is_table_value_constructor() const = 0;
850};
851
854
855 public:
856 PT_set_scoped_system_variable(const POS &pos, const POS &var_pos,
857 const LEX_CSTRING &opt_prefix,
858 const LEX_CSTRING &name, Item *opt_expr)
859 : super(pos),
860 m_varpos(var_pos),
861 m_opt_prefix{opt_prefix},
862 m_name{name},
863 m_opt_expr{opt_expr} {}
864
865 bool do_contextualize(Parse_context *pc) override;
866
867 private:
872};
873
875 protected:
877 : Parse_tree_node(pos) {}
878};
879
882
883 public:
884 PT_set_variable(const POS &pos, const POS &varpos,
885 const LEX_CSTRING &opt_prefix, const LEX_CSTRING &name,
886 const POS &expr_pos, Item *opt_expr)
887 : super{pos},
888 m_varpos{varpos},
889 m_opt_prefix{opt_prefix},
890 m_name{name},
891 m_expr_pos{expr_pos},
892 m_opt_expr{opt_expr} {}
893
894 bool do_contextualize(Parse_context *pc) override;
895
896 private:
902};
903
907
910
911 public:
913 const LEX_STRING &name_arg,
914 Item *expr_arg)
915 : super(pos), name(name_arg), expr(expr_arg) {}
916
917 bool do_contextualize(Parse_context *pc) override;
918};
919
922
923 public:
925 const POS &name_pos, const LEX_CSTRING &opt_prefix,
926 const LEX_CSTRING &name, Item *opt_expr)
927 : super(pos),
928 m_scope{scope},
929 m_name_pos{name_pos},
930 m_opt_prefix{opt_prefix},
931 m_name{name},
932 m_opt_expr{opt_expr} {}
933
934 bool do_contextualize(Parse_context *pc) override;
935
936 private:
942};
943
947
949
950 public:
952 const CHARSET_INFO *opt_charset_arg)
953 : super(pos), opt_charset(opt_charset_arg) {}
954
955 bool do_contextualize(Parse_context *pc) override;
956};
957
961
963
964 public:
966 const POS &error_pos)
967 : super(pos), m_error_pos(error_pos) {}
968
969 bool do_contextualize(Parse_context *pc) override;
970};
971
974
977
978 public:
979 PT_set_names(const POS &pos, const CHARSET_INFO *opt_charset_arg,
980 const CHARSET_INFO *opt_collation_arg)
981 : super(pos),
982 opt_charset(opt_charset_arg),
983 opt_collation(opt_collation_arg) {}
984
985 bool do_contextualize(Parse_context *pc) override;
986};
987
989 protected:
990 explicit PT_start_option_value_list(const POS &pos) : Parse_tree_node(pos) {}
991};
992
996
997 const char *password;
998 const char *current_password;
1002
1003 public:
1005 const char *password_arg,
1006 const char *current_password_arg,
1007 bool retain_current,
1008 bool random_password,
1009 const POS &expr_pos_arg)
1010 : super(pos),
1011 password(password_arg),
1012 current_password(current_password_arg),
1013 retain_current_password(retain_current),
1014 random_password_generator(random_password),
1015 expr_pos(expr_pos_arg) {}
1016
1017 bool do_contextualize(Parse_context *pc) override;
1018};
1019
1023
1025 const char *password;
1026 const char *current_password;
1030
1031 public:
1033 const POS &pos, LEX_USER *user_arg, const char *password_arg,
1034 const char *current_password_arg, bool retain_current, bool random_pass,
1035 const POS &expr_pos_arg)
1036 : super(pos),
1037 user(user_arg),
1038 password(password_arg),
1039 current_password(current_password_arg),
1040 retain_current_password(retain_current),
1041 random_password_generator(random_pass),
1042 expr_pos(expr_pos_arg) {}
1043
1044 bool do_contextualize(Parse_context *pc) override;
1045};
1046
1049
1052
1053 public:
1056 : super(pos), type(type_arg), value(value_arg) {}
1057
1058 bool do_contextualize(Parse_context *pc) override;
1059};
1060
1063
1067
1068 public:
1069 PT_option_value_list_head(const POS &pos, const POS &delimiter_pos_arg,
1070 Parse_tree_node *value_arg,
1071 const POS &value_pos_arg)
1072 : super(pos),
1073 delimiter_pos(delimiter_pos_arg),
1074 value(value_arg),
1075 value_pos(value_pos_arg) {}
1076
1077 bool do_contextualize(Parse_context *pc) override;
1078};
1079
1082
1084
1085 public:
1087 const POS &delimiter_pos_arg, Parse_tree_node *tail,
1088 const POS &tail_pos)
1089 : super(pos, delimiter_pos_arg, tail, tail_pos), head(head_arg) {}
1090
1091 bool do_contextualize(Parse_context *pc) override {
1092 uchar dummy;
1093 if (check_stack_overrun(pc->thd, STACK_MIN_SIZE, &dummy)) return true;
1094 return head->contextualize(pc) || super::do_contextualize(pc);
1095 }
1096};
1097
1100
1104
1105 public:
1108 const POS &head_pos_arg,
1109 PT_option_value_list_head *tail_arg)
1110 : super(pos), head(head_arg), head_pos(head_pos_arg), tail(tail_arg) {}
1111
1112 bool do_contextualize(Parse_context *pc) override;
1113};
1114
1117
1118 const char *name;
1120
1121 public:
1122 PT_transaction_characteristic(const POS &pos, const char *name_arg,
1123 int32 value_arg)
1124 : super(pos), name(name_arg), value(value_arg) {}
1125
1126 bool do_contextualize(Parse_context *pc) override;
1127};
1128
1131
1132 public:
1133 explicit PT_transaction_access_mode(const POS &pos, bool is_read_only)
1134 : super(pos, "transaction_read_only", (int32)is_read_only) {}
1135};
1136
1139
1140 public:
1141 explicit PT_isolation_level(const POS &pos, enum_tx_isolation level)
1142 : super(pos, "transaction_isolation", (int32)level) {}
1143};
1144
1147
1150
1151 public:
1154 PT_transaction_characteristic *opt_tail_arg)
1155 : super(pos), head(head_arg), opt_tail(opt_tail_arg) {}
1156
1157 bool do_contextualize(Parse_context *pc) override {
1158 return (super::do_contextualize(pc) || head->contextualize(pc) ||
1159 (opt_tail != nullptr && opt_tail->contextualize(pc)));
1160 }
1161};
1162
1166
1169
1170 public:
1172 const POS &pos, PT_transaction_characteristics *characteristics_arg,
1173 const POS &end_pos_arg)
1174 : super(pos),
1175 characteristics(characteristics_arg),
1176 end_pos(end_pos_arg) {}
1177
1178 bool do_contextualize(Parse_context *pc) override;
1179};
1180
1182 : public Parse_tree_node {
1183 protected:
1185 : Parse_tree_node(pos) {}
1186};
1187
1191
1195
1196 public:
1198 const POS &pos, PT_set_scoped_system_variable *head_arg,
1199 const POS &head_pos_arg, PT_option_value_list_head *opt_tail_arg)
1200 : super(pos),
1201 head(head_arg),
1202 head_pos(head_pos_arg),
1203 opt_tail(opt_tail_arg) {}
1204
1205 bool do_contextualize(Parse_context *pc) override;
1206};
1207
1211
1214
1215 public:
1217 const POS &pos, PT_transaction_characteristics *characteristics_arg,
1218 const POS &characteristics_pos_arg)
1219 : super(pos),
1220 characteristics(characteristics_arg),
1221 characteristics_pos(characteristics_pos_arg) {}
1222
1223 bool do_contextualize(Parse_context *pc) override;
1224};
1225
1228
1231
1232 public:
1234 const POS &pos, enum_var_type type_arg,
1236 : super(pos), type(type_arg), list(list_arg) {}
1237
1238 bool do_contextualize(Parse_context *pc) override;
1239};
1240
1241class PT_set : public Parse_tree_node {
1243
1246
1247 public:
1248 PT_set(const POS &pos, const POS &set_pos_arg,
1250 : super(pos), set_pos(set_pos_arg), list(list_arg) {}
1251
1252 bool do_contextualize(Parse_context *pc) override;
1253};
1254
1257
1258 protected:
1259 explicit PT_into_destination(const POS &pos) : super(pos) {}
1260
1261 public:
1262 bool do_contextualize(Parse_context *pc) override;
1263};
1264
1267
1268 public:
1269 PT_into_destination_outfile(const POS &pos, const LEX_STRING &file_name_arg,
1270 const CHARSET_INFO *charset_arg,
1271 const Field_separators &field_term_arg,
1272 const Line_separators &line_term_arg)
1273 : PT_into_destination(pos), m_exchange(file_name_arg.str, false) {
1274 m_exchange.cs = charset_arg;
1275 m_exchange.field.merge_field_separators(field_term_arg);
1276 m_exchange.line.merge_line_separators(line_term_arg);
1277 }
1278
1279 bool do_contextualize(Parse_context *pc) override;
1280
1281 private:
1283};
1284
1287
1288 public:
1289 PT_into_destination_dumpfile(const POS &pos, const LEX_STRING &file_name_arg)
1290 : PT_into_destination(pos), m_exchange(file_name_arg.str, true) {}
1291
1292 bool do_contextualize(Parse_context *pc) override;
1293
1294 private:
1296};
1297
1299 public:
1301
1302 explicit PT_select_var(const POS &pos, const LEX_STRING &name_arg)
1303 : Parse_tree_node(pos), name(name_arg) {}
1304
1305 virtual bool is_local() const { return false; }
1306 virtual uint get_offset() const {
1307 assert(0);
1308 return 0;
1309 }
1310};
1311
1314
1315 uint offset = 0;
1316
1317#ifndef NDEBUG
1318 /*
1319 Routine to which this Item_splocal belongs. Used for checking if correct
1320 runtime context is used for variable handling.
1321 */
1322 sp_head *sp = nullptr;
1323#endif
1324
1325 public:
1326 PT_select_sp_var(const POS &pos, const LEX_STRING &name_arg)
1327 : super(pos, name_arg) {}
1328
1329 bool is_local() const override { return true; }
1330 uint get_offset() const override { return offset; }
1331
1332 bool do_contextualize(Parse_context *pc) override;
1333};
1334
1337
1338 public:
1339 explicit PT_select_var_list(const POS &pos) : PT_into_destination(pos) {}
1340
1342
1343 bool do_contextualize(Parse_context *pc) override;
1344
1345 bool push_back(PT_select_var *var) { return value.push_back(var); }
1346};
1347
1348/**
1349 Parse tree node for a single of a window extent's borders,
1350 cf. <window frame extent> in SQL 2003.
1351*/
1353 friend class Window;
1354 Item *m_value{nullptr}; ///< only relevant iff m_border_type == WBT_VALUE_*
1355 public:
1357 const bool m_date_time;
1358 interval_type m_int_type = INTERVAL_LAST; // clang-tidy needs initialization.
1359
1360 ///< For unbounded border
1364 }
1365
1366 ///< For bounded non-temporal border, e.g. 2 PRECEDING: 'value' is 2.
1368 : Parse_tree_node(pos),
1369 m_value(value),
1371 m_date_time(false) {}
1372
1373 ///< For bounded INTERVAL 2 DAYS, 'value' is 2, int_type is DAYS.
1375 interval_type int_type)
1376 : Parse_tree_node(pos),
1377 m_value(value),
1379 m_date_time(true),
1380 m_int_type(int_type) {}
1381
1382 ///< @returns the '2' in '2 PRECEDING' or 'INTERVAL 2 DAYS PRECEDING'
1383 Item *border() const { return m_value; }
1384 /// Need such low-level access so that fix_fields updates the right pointer
1385 Item **border_ptr() { return &m_value; }
1386
1387 /**
1388 @returns Addition operator for computation of frames, nullptr if error.
1389 @param order_expr Expression to add to/subtract from
1390 @param prec true if PRECEDING
1391 @param asc true if ASC
1392 @param window only used for error generation
1393 */
1394 Item *build_addop(Item_cache *order_expr, bool prec, bool asc,
1395 const Window *window);
1396
1397 bool do_contextualize(Parse_context *pc) override;
1398};
1399
1400/**
1401 Parse tree node for one or both of a window extent's borders, cf.
1402 <window frame extent> in SQL 2003.
1403*/
1406 friend class PT_frame;
1407
1408 public:
1409 /**
1410 Constructor.
1411
1412 Frames of the form "frame_start no_frame_end" are translated during
1413 parsing to "BETWEEN frame_start AND CURRENT ROW". So both 'start' and
1414 'end' are non-nullptr.
1415 */
1417 : Parse_tree_node(pos) {
1418 m_borders[0] = start;
1419 m_borders[1] = end;
1420 }
1421};
1422
1423/**
1424 Parse tree node for a window frame's exclusions, cf. the
1425 <window frame exclusion> clause in SQL 2003.
1426*/
1429
1430 public:
1432 : Parse_tree_node(pos), m_exclusion(e) {}
1433 // enum_window_frame_exclusion exclusion() { return m_exclusion; }
1434};
1435
1436/**
1437 Parse tree node for a window's frame, cf. the <window frame clause>
1438 in SQL 2003.
1439*/
1441 public:
1443
1446
1448
1449 /// If true, this is an artificial frame, not specified by the user
1451
1452 PT_frame(const POS &pos, enum_window_frame_unit unit, PT_borders *from_to,
1453 PT_exclusion *exclusion)
1454 : Parse_tree_node(pos),
1455 m_query_expression(unit),
1456 m_from(from_to->m_borders[0]),
1457 m_to(from_to->m_borders[1]),
1458 m_exclusion(exclusion) {}
1459
1460 bool do_contextualize(Parse_context *pc) override;
1461};
1462
1464 protected:
1465 explicit PT_query_primary(const POS &pos) : PT_query_expression_body(pos) {}
1466};
1467
1470
1482
1483 public:
1485 const POS &pos, PT_hint_list *opt_hints_arg,
1486 const Query_options &options_arg, PT_item_list *item_list_arg,
1487 PT_into_destination *opt_into1_arg,
1488 const Mem_root_array_YY<PT_table_reference *> &from_clause_arg,
1489 Item *opt_where_clause_arg, PT_group *opt_group_clause_arg,
1490 Item *opt_having_clause_arg, PT_window_list *opt_window_clause_arg,
1491 Item *opt_qualify_clause_arg, bool implicit_from_clause)
1492 : super(pos),
1493 opt_hints(opt_hints_arg),
1494 options(options_arg),
1495 item_list(item_list_arg),
1496 opt_into1(opt_into1_arg),
1497 m_is_from_clause_implicit{implicit_from_clause},
1498 from_clause(from_clause_arg),
1499 opt_where_clause(opt_where_clause_arg),
1500 opt_group_clause(opt_group_clause_arg),
1501 opt_having_clause(opt_having_clause_arg),
1502 opt_window_clause(opt_window_clause_arg),
1503 opt_qualify_clause(opt_qualify_clause_arg) {
1504 assert(implicit_from_clause ? from_clause.empty() : true);
1505 }
1506
1508 const POS &pos, const Query_options &options_arg,
1509 PT_item_list *item_list_arg,
1510 const Mem_root_array_YY<PT_table_reference *> &from_clause_arg,
1511 Item *opt_where_clause_arg)
1512 : super(pos),
1514 options(options_arg),
1515 item_list(item_list_arg),
1518 from_clause(from_clause_arg),
1519 opt_where_clause(opt_where_clause_arg),
1524
1525 PT_query_specification(const POS &pos, const Query_options &options_arg,
1526 PT_item_list *item_list_arg)
1527 : super(pos),
1529 options(options_arg),
1530 item_list(item_list_arg),
1533 from_clause{},
1539
1540 bool do_contextualize(Parse_context *pc) override;
1541
1542 bool has_into_clause() const override { return opt_into1 != nullptr; }
1543 bool has_trailing_into_clause() const override {
1545 opt_where_clause == nullptr && opt_group_clause == nullptr &&
1546 opt_having_clause == nullptr && opt_window_clause == nullptr &&
1547 opt_qualify_clause == nullptr);
1548 }
1549
1550 bool is_set_operation() const override { return false; }
1551
1552 bool can_absorb_order_and_limit(bool, bool) const override { return true; }
1553
1554 bool is_table_value_constructor() const override { return false; }
1555 PT_insert_values_list *get_row_value_list() const override { return nullptr; }
1556
1557 protected:
1558 void add_json_info(Json_object *obj) override;
1559
1560 private:
1562};
1563
1566
1568
1569 public:
1570 explicit PT_table_value_constructor(const POS &pos,
1571 PT_insert_values_list *row_value_list_arg)
1572 : super(pos), row_value_list(row_value_list_arg) {}
1573
1574 bool do_contextualize(Parse_context *pc) override;
1575
1576 bool has_into_clause() const override { return false; }
1577 bool has_trailing_into_clause() const override { return false; }
1578
1579 bool is_set_operation() const override { return false; }
1580
1581 bool can_absorb_order_and_limit(bool, bool) const override { return true; }
1582
1583 bool is_table_value_constructor() const override { return true; }
1584
1586 return row_value_list;
1587 }
1588};
1589
1592
1593 public:
1595 const POS &pos, const Query_options &options_arg,
1596 PT_item_list *item_list_arg,
1597 const Mem_root_array_YY<PT_table_reference *> &from_clause_arg)
1598 : super(pos, options_arg, item_list_arg, from_clause_arg, nullptr) {}
1599};
1600
1602 public:
1603 PT_query_expression(const POS &pos, PT_with_clause *with_clause,
1604 PT_query_expression_body *body, PT_order *order,
1605 PT_limit_clause *limit)
1607 m_body(body),
1608 m_order(order),
1609 m_limit(limit),
1610 m_with_clause(with_clause) {}
1611
1613 PT_order *order, PT_limit_clause *limit)
1614 : PT_query_expression(pos, nullptr, body, order, limit) {}
1615
1617 : PT_query_expression(pos, body, nullptr, nullptr) {}
1618
1619 bool do_contextualize(Parse_context *pc) override;
1620
1621 bool is_set_operation() const override { return m_body->is_set_operation(); }
1622
1623 bool has_into_clause() const override { return m_body->has_into_clause(); }
1624 bool has_trailing_into_clause() const override {
1625 return (m_body->has_trailing_into_clause() && m_order == nullptr &&
1626 m_limit == nullptr);
1627 }
1628
1629 bool can_absorb_order_and_limit(bool order, bool limit) const override {
1630 if (m_body->is_set_operation()) {
1631 return false;
1632 }
1633 if (m_order == nullptr && m_limit == nullptr) {
1634 /*
1635 It is safe to push ORDER and/or LIMIT down in:
1636
1637 (SELECT ...<no order or limit clauses>) ORDER BY ... LIMIT ...;
1638 (SELECT ...<no order or limit clauses>) ORDER BY ...;
1639 (SELECT ...<no order or limit clauses>) LIMIT ...;
1640 */
1641 return true;
1642 }
1643 if (m_limit != nullptr && !order && limit) {
1644 /*
1645 In MySQL, it is ok(*) to push LIMIT down in:
1646
1647 (SELECT ... [ORDER BY ...] LIMIT a) LIMIT b;
1648
1649 *) MySQL doesn't follow the standard when overwriting `LIMIT a` with
1650 `LIMIT b` if a < b. Moreover, the result of:
1651
1652 (SELECT ... ORDER BY order1 LIMIT a) ORDER BY order1 LIMIT b; (1)
1653
1654 can diverge from:
1655
1656 (SELECT ... ORDER BY order1 LIMIT a) LIMIT b; (2)
1657
1658 since the example (1) never overwrites `LIMIT a` with `LIMIT b`,
1659 while the example (2) does overwrite.
1660
1661 TODO: add a warning, deprecate and replace this behavior with the
1662 standard one.
1663 */
1664 return true;
1665 }
1666 if (m_order != nullptr && m_limit == nullptr && !order && limit) {
1667 /*
1668 Allow pushdown of LIMIT into body with ORDER BY, e.g
1669
1670 (SELECT ... ORDER BY order1) LIMIT a;
1671 */
1672 return true;
1673 }
1674 return false;
1675 }
1676
1677 bool is_table_value_constructor() const override {
1679 }
1680
1682 return m_body->get_row_value_list();
1683 }
1684
1685 private:
1686 /**
1687 Contextualizes the order and limit clauses, re-interpreting them according
1688 to the rules. If the `<query expression body>` can absorb the clauses,
1689 they are simply contextualized into the current Query_block. If not, we
1690 have to create the "fake" Query_block unless there is one already
1691 (Query_expression::new_set_operation_query() is known to do this.)
1692
1693 @see PT_query_expression::can_absorb_order_and_limit()
1694 */
1696
1701};
1702
1703/*
1704 After the removal of the `... <locking_clause> <into_clause>` syntax
1705 PT_locking will disappear.
1706*/
1709
1710 public:
1712 PT_locking_clause_list *locking_clauses)
1713 : super(pos),
1715 m_locking_clauses{locking_clauses} {}
1716
1717 bool do_contextualize(Parse_context *pc) override {
1718 return (super::do_contextualize(pc) ||
1721 }
1722
1723 bool is_set_operation() const override {
1725 }
1726
1727 bool has_into_clause() const override {
1729 }
1730 bool has_trailing_into_clause() const override { return false; }
1731
1732 bool can_absorb_order_and_limit(bool order, bool limit) const override {
1733 return m_query_expression->can_absorb_order_and_limit(order, limit);
1734 }
1735
1736 bool is_table_value_constructor() const override {
1738 }
1739
1742 }
1743
1744 private:
1747};
1748
1751
1754
1755 public:
1757
1758 PT_subquery(const POS &pos, PT_query_expression_body *query_expression)
1759 : super(pos),
1760 qe(query_expression),
1762 m_is_derived_table(false) {}
1763
1764 bool do_contextualize(Parse_context *pc) override;
1765
1767};
1768
1771
1772 public:
1774 bool is_distinct, PT_query_expression_body *rhs,
1775 bool is_rhs_in_parentheses = false)
1776 : super(pos),
1777 m_lhs(lhs),
1778 m_is_distinct(is_distinct),
1779 m_rhs(rhs),
1780 m_is_rhs_in_parentheses{is_rhs_in_parentheses} {}
1781
1783 QueryLevel &ql);
1784 bool is_set_operation() const override { return true; }
1785
1786 bool has_into_clause() const override {
1788 }
1789 bool has_trailing_into_clause() const override {
1791 }
1792
1793 bool can_absorb_order_and_limit(bool, bool) const override { return false; }
1794
1795 bool is_table_value_constructor() const override { return false; }
1796 PT_insert_values_list *get_row_value_list() const override { return nullptr; }
1797
1798 protected:
1800 Surrounding_context context);
1806
1807 void add_json_info(Json_object *obj) override {
1808 obj->add_alias("distinct", create_dom_ptr<Json_boolean>(m_is_distinct));
1809 obj->add_alias("rhs_in_parentheses",
1810 create_dom_ptr<Json_boolean>(m_is_rhs_in_parentheses));
1811 }
1812};
1813
1816
1817 public:
1819 bool do_contextualize(Parse_context *pc) override;
1820};
1821
1824
1825 public:
1827 bool do_contextualize(Parse_context *pc) override;
1828};
1829
1832
1833 public:
1835 bool do_contextualize(Parse_context *pc) override;
1836};
1837
1840
1841 public:
1842 /**
1843 @param pos Position of this clause in the SQL statement.
1844 @param qe The query expression.
1845 @param sql_command The type of SQL command.
1846 */
1847 PT_select_stmt(const POS &pos, enum_sql_command sql_command,
1849 : super(pos),
1850 m_sql_command(sql_command),
1851 m_qe(qe),
1852 m_into(nullptr),
1854
1855 /**
1856 Creates a SELECT command. Only SELECT commands can have into.
1857
1858 @param pos Position of this clause in the SQL
1859 statement.
1860 @param qe The query expression.
1861 @param into The own INTO destination.
1862 @param has_trailing_locking_clauses True if there are locking clauses (like
1863 `FOR UPDATE`) at the end of the
1864 statement.
1865 */
1867 PT_into_destination *into = nullptr,
1868 bool has_trailing_locking_clauses = false)
1869 : super(pos),
1871 m_qe{qe},
1872 m_into{into},
1873 m_has_trailing_locking_clauses{has_trailing_locking_clauses} {}
1874
1875 Sql_cmd *make_cmd(THD *thd) override;
1876 std::string get_printable_parse_tree(THD *thd) override;
1877
1878 private:
1883};
1884
1885/**
1886 Top-level node for the DELETE statement
1887
1888 @ingroup ptn_stmt
1889*/
1890class PT_delete final : public Parse_tree_root {
1892
1893 private:
1898 const char *const opt_table_alias;
1906
1907 public:
1908 // single-table DELETE node constructor:
1909 PT_delete(const POS &pos, PT_with_clause *with_clause_arg,
1910 PT_hint_list *opt_hints_arg, int opt_delete_options_arg,
1911 Table_ident *table_ident_arg,
1912 const LEX_CSTRING &opt_table_alias_arg,
1913 List<String> *opt_use_partition_arg, Item *opt_where_clause_arg,
1914 PT_order *opt_order_clause_arg, Item *opt_delete_limit_clause_arg)
1915 : super(pos),
1916 m_with_clause(with_clause_arg),
1917 opt_hints(opt_hints_arg),
1918 opt_delete_options(opt_delete_options_arg),
1919 table_ident(table_ident_arg),
1920 opt_table_alias(opt_table_alias_arg.str),
1921 opt_use_partition(opt_use_partition_arg),
1922 opt_where_clause(opt_where_clause_arg),
1923 opt_order_clause(opt_order_clause_arg),
1924 opt_delete_limit_clause(opt_delete_limit_clause_arg) {
1926 join_table_list.init_empty_const();
1927 }
1928
1929 // multi-table DELETE node constructor:
1930 PT_delete(const POS &pos, PT_with_clause *with_clause_arg,
1931 PT_hint_list *opt_hints_arg, int opt_delete_options_arg,
1932 const Mem_root_array_YY<Table_ident *> &table_list_arg,
1933 const Mem_root_array_YY<PT_table_reference *> &join_table_list_arg,
1934 Item *opt_where_clause_arg)
1935 : super(pos),
1936 m_with_clause(with_clause_arg),
1937 opt_hints(opt_hints_arg),
1938 opt_delete_options(opt_delete_options_arg),
1941 table_list(table_list_arg),
1943 join_table_list(join_table_list_arg),
1944 opt_where_clause(opt_where_clause_arg),
1947
1948 Sql_cmd *make_cmd(THD *thd) override;
1949
1950 private:
1951 bool is_multitable() const {
1952 assert((table_ident != nullptr) ^ (table_list.size() > 0));
1953 return table_ident == nullptr;
1954 }
1955
1957};
1958
1959/**
1960 Top-level node for the UPDATE statement
1961
1962 @ingroup ptn_stmt
1963*/
1966
1977
1978 public:
1979 PT_update(const POS &pos, PT_with_clause *with_clause_arg,
1980 PT_hint_list *opt_hints_arg, thr_lock_type opt_low_priority_arg,
1981 bool opt_ignore_arg,
1982 const Mem_root_array_YY<PT_table_reference *> &join_table_list_arg,
1983 PT_item_list *column_list_arg, PT_item_list *value_list_arg,
1984 Item *opt_where_clause_arg, PT_order *opt_order_clause_arg,
1985 Item *opt_limit_clause_arg)
1986 : super(pos),
1987 m_with_clause(with_clause_arg),
1988 opt_hints(opt_hints_arg),
1989 opt_low_priority(opt_low_priority_arg),
1990 opt_ignore(opt_ignore_arg),
1991 join_table_list(join_table_list_arg),
1992 column_list(column_list_arg),
1993 value_list(value_list_arg),
1994 opt_where_clause(opt_where_clause_arg),
1995 opt_order_clause(opt_order_clause_arg),
1996 opt_limit_clause(opt_limit_clause_arg) {}
1997
1998 Sql_cmd *make_cmd(THD *thd) override;
1999};
2000
2003
2005
2006 public:
2008 : super(pos), many_values(mem_root) {}
2009
2010 bool do_contextualize(Parse_context *pc) override;
2011
2013 many_values.push_back(x);
2014 return false;
2015 }
2016
2018 assert(is_contextualized());
2019 return many_values;
2020 }
2021};
2022
2023/**
2024 Top-level node for the INSERT statement
2025
2026 @ingroup ptn_stmt
2027*/
2028class PT_insert final : public Parse_tree_root {
2030
2031 const bool is_replace;
2034 const bool ignore;
2040 const char *const opt_values_table_alias;
2044
2045 public:
2046 PT_insert(const POS &pos, bool is_replace_arg, PT_hint_list *opt_hints_arg,
2047 thr_lock_type lock_option_arg, bool ignore_arg,
2048 Table_ident *table_ident_arg, List<String> *opt_use_partition_arg,
2049 PT_item_list *column_list_arg,
2050 PT_insert_values_list *row_value_list_arg,
2051 PT_query_expression_body *insert_query_expression_arg,
2052 const LEX_CSTRING &opt_values_table_alias_arg,
2053 Create_col_name_list *opt_values_column_list_arg,
2054 PT_item_list *opt_on_duplicate_column_list_arg,
2055 PT_item_list *opt_on_duplicate_value_list_arg)
2056 : super(pos),
2057 is_replace(is_replace_arg),
2058 opt_hints(opt_hints_arg),
2059 lock_option(lock_option_arg),
2060 ignore(ignore_arg),
2061 table_ident(table_ident_arg),
2062 opt_use_partition(opt_use_partition_arg),
2063 column_list(column_list_arg),
2064 row_value_list(row_value_list_arg),
2065 insert_query_expression(insert_query_expression_arg),
2066 opt_values_table_alias(opt_values_table_alias_arg.str),
2067 opt_values_column_list(opt_values_column_list_arg),
2068 opt_on_duplicate_column_list(opt_on_duplicate_column_list_arg),
2069 opt_on_duplicate_value_list(opt_on_duplicate_value_list_arg) {
2070 // REPLACE statement can't have IGNORE flag:
2071 assert(!is_replace || !ignore);
2072 // REPLACE statement can't have ON DUPLICATE KEY UPDATE clause:
2073 assert(!is_replace || opt_on_duplicate_column_list == nullptr);
2074 // INSERT/REPLACE ... SELECT can't have VALUES clause:
2075 assert((row_value_list != nullptr) ^ (insert_query_expression != nullptr));
2076 // ON DUPLICATE KEY UPDATE: column and value arrays must have same sizes:
2077 assert((opt_on_duplicate_column_list == nullptr &&
2078 opt_on_duplicate_value_list == nullptr) ||
2081 }
2082
2083 Sql_cmd *make_cmd(THD *thd) override;
2084
2085 private:
2086 bool has_query_block() const { return insert_query_expression != nullptr; }
2087};
2088
2089class PT_call final : public Parse_tree_root {
2092
2093 public:
2094 PT_call(const POS &pos, sp_name *proc_name_arg,
2095 PT_item_list *opt_expr_list_arg)
2096 : Parse_tree_root(pos),
2097 proc_name(proc_name_arg),
2098 opt_expr_list(opt_expr_list_arg) {}
2099
2100 Sql_cmd *make_cmd(THD *thd) override;
2101};
2102
2103/**
2104 Top-level node for the SHUTDOWN statement
2105
2106 @ingroup ptn_stmt
2107*/
2108class PT_shutdown final : public Parse_tree_root {
2110
2111 public:
2112 Sql_cmd *make_cmd(THD *) override { return &sql_cmd; }
2113};
2114
2115/**
2116 Top-level node for the CREATE [OR REPLACE] SPATIAL REFERENCE SYSTEM statement.
2117
2118 @ingroup ptn_stmt
2119*/
2120class PT_create_srs final : public Parse_tree_root {
2121 /// The SQL command object.
2123 /// Whether OR REPLACE is specified.
2125 /// Whether IF NOT EXISTS is specified.
2127 /// SRID of the SRS to create.
2128 ///
2129 /// The range is larger than that of gis::srid_t, so it must be
2130 /// verified to be less than the uint32 maximum value.
2131 unsigned long long m_srid;
2132 /// All attributes except SRID.
2134
2135 /// Check if a UTF-8 string contains control characters.
2136 ///
2137 /// @note This function only checks single byte control characters (U+0000 to
2138 /// U+001F, and U+007F). There are some control characters at U+0080 to U+00A0
2139 /// that are not detected by this function.
2140 ///
2141 /// @param str The string.
2142 /// @param length Length of the string.
2143 ///
2144 /// @retval false The string contains no control characters.
2145 /// @retval true The string contains at least one control character.
2146 bool contains_control_char(char *str, size_t length) {
2147 for (size_t pos = 0; pos < length; pos++) {
2148 if (std::iscntrl(str[pos])) return true;
2149 }
2150 return false;
2151 }
2152
2153 public:
2154 PT_create_srs(const POS &pos, unsigned long long srid,
2155 const Sql_cmd_srs_attributes &attributes, bool or_replace,
2156 bool if_not_exists)
2157 : Parse_tree_root(pos),
2158 m_or_replace(or_replace),
2159 m_if_not_exists(if_not_exists),
2160 m_srid(srid),
2161 m_attributes(attributes) {}
2162
2163 Sql_cmd *make_cmd(THD *thd) override;
2164};
2165
2166/**
2167 Top-level node for the DROP SPATIAL REFERENCE SYSTEM statement.
2168
2169 @ingroup ptn_stmt
2170*/
2171class PT_drop_srs final : public Parse_tree_root {
2172 /// The SQL command object.
2174 /// SRID of the SRS to drop.
2175 ///
2176 /// The range is larger than that of gis::srid_t, so it must be
2177 /// verified to be less than the uint32 maximum value.
2178 unsigned long long m_srid;
2179
2180 public:
2181 PT_drop_srs(const POS &pos, unsigned long long srid, bool if_exists)
2182 : Parse_tree_root(pos), sql_cmd(srid, if_exists), m_srid(srid) {}
2183
2184 Sql_cmd *make_cmd(THD *thd) override;
2185};
2186
2187/**
2188 Top-level node for the ALTER INSTANCE statement
2189
2190 @ingroup ptn_stmt
2191*/
2194
2195 public:
2197 const POS &pos, enum alter_instance_action_enum alter_instance_action,
2198 const LEX_CSTRING &channel)
2199 : Parse_tree_root(pos), sql_cmd(alter_instance_action, channel) {}
2200
2201 Sql_cmd *make_cmd(THD *thd) override;
2202};
2203
2204/**
2205 A template-free base class for index options that we can predeclare in
2206 sql_lex.h
2207*/
2209 protected:
2210 explicit PT_base_index_option(const POS &pos) : Table_ddl_node(pos) {}
2211};
2212
2213/**
2214 A key part specification.
2215
2216 This can either be a "normal" key part (a key part that points to a column),
2217 or this can be a functional key part (a key part that points to an
2218 expression).
2219*/
2222
2223 public:
2224 /**
2225 Constructor for a functional key part.
2226
2227 @param pos Position of this clause in the SQL statement.
2228 @param expression The expression to index.
2229 @param order The direction of the index.
2230 */
2231 PT_key_part_specification(const POS &pos, Item *expression, enum_order order);
2232
2233 /**
2234 Constructor for a "normal" key part. That is a key part that points to a
2235 column and not an expression.
2236
2237 @param pos Position of this clause in the SQL statement.
2238 @param column_name The column name that this key part points to.
2239 @param order The direction of the index.
2240 @param prefix_length How many bytes or characters this key part should
2241 index, or zero if it should index the entire column.
2242 */
2243 PT_key_part_specification(const POS &pos, const LEX_CSTRING &column_name,
2244 enum_order order, int prefix_length);
2245
2246 /**
2247 Contextualize this key part specification. This will also call itemize on
2248 the indexed expression if this is a functional key part.
2249
2250 @param pc The parse context
2251
2252 @retval true on error
2253 @retval false on success
2254 */
2255 bool do_contextualize(Parse_context *pc) override;
2256
2257 /**
2258 Get the indexed expression. The caller must ensure that has_expression()
2259 returns true before calling this.
2260
2261 @returns The indexed expression
2262 */
2264 assert(has_expression());
2265 return m_expression;
2266 }
2267
2268 /**
2269 @returns The direction of the index: ORDER_ASC, ORDER_DESC or
2270 ORDER_NOT_RELEVANT in case the user didn't explicitly specify a
2271 direction.
2272 */
2273 enum_order get_order() const { return m_order; }
2274
2275 /**
2276 @retval true if the user explicitly specified a direction (asc/desc).
2277 @retval false if the user didn't explicitly specify a direction.
2278 */
2279 bool is_explicit() const { return get_order() != ORDER_NOT_RELEVANT; }
2280
2281 /**
2282 @retval true if the key part contains an expression (and thus is a
2283 functional key part).
2284 @retval false if the key part doesn't contain an expression.
2285 */
2286 bool has_expression() const { return m_expression != nullptr; }
2287
2288 /**
2289 Get the column that this key part points to. This is only valid if this
2290 key part isn't a functional index. The caller must thus check the return
2291 value of has_expression() before calling this function.
2292
2293 @returns The column that this key part points to.
2294 */
2296 assert(!has_expression());
2297 return m_column_name;
2298 }
2299
2300 /**
2301 @returns The number of bytes that this key part should index. If the column
2302 this key part points to is a non-binary column, this is the number
2303 of characters. Returns zero if the entire column should be indexed.
2304 */
2305 int get_prefix_length() const { return m_prefix_length; }
2306
2307 private:
2308 /**
2309 The indexed expression in case this is a functional key part. Only valid if
2310 has_expression() returns true.
2311 */
2313
2314 /// The direction of the index.
2316
2317 /// The name of the column that this key part indexes.
2319
2320 /**
2321 If this is greater than zero, it represents how many bytes of the column
2322 that is indexed. Note that for non-binary columns (VARCHAR, TEXT etc), this
2323 is the number of characters.
2324 */
2326};
2327
2328/**
2329 A template for options that set a single `<alter option>` value in
2330 thd->lex->key_create_info.
2331
2332 @tparam Option_type The data type of the option.
2333 @tparam Property Pointer-to-member for the option of KEY_CREATE_INFO.
2334*/
2335template <typename Option_type, Option_type KEY_CREATE_INFO::*Property>
2337 public:
2338 /// @param pos Position of this clause in the SQL statement.
2339 /// @param option_value The value of the option.
2340 PT_index_option(const POS &pos, Option_type option_value)
2341 : PT_base_index_option(pos), m_option_value(option_value) {}
2342
2345 return false;
2346 }
2347
2348 private:
2349 Option_type m_option_value;
2350};
2351
2352/**
2353 A template for options that set a single property in a KEY_CREATE_INFO, and
2354 also records if the option was explicitly set.
2355*/
2356template <typename Option_type, Option_type KEY_CREATE_INFO::*Property,
2357 bool KEY_CREATE_INFO::*Property_is_explicit>
2359 public:
2360 PT_traceable_index_option(const POS &pos, Option_type option_value)
2361 : PT_base_index_option(pos), m_option_value(option_value) {}
2362
2365 pc->key_create_info->*Property_is_explicit = true;
2366 return false;
2367 }
2368
2369 private:
2370 Option_type m_option_value;
2371};
2372
2380
2381/**
2382 The data structure (B-tree, Hash, etc) used for an index is called
2383 'index_type' in the manual. Internally, this is stored in
2384 KEY_CREATE_INFO::algorithm, while what the manual calls 'algorithm' is
2385 stored in partition_info::key_algorithm. In an `<create_index_stmt>`
2386 it's ignored. The terminology is somewhat confusing, but we stick to the
2387 manual in the parser.
2388*/
2392
2394 public:
2396 const LEX_STRING &name_arg, PT_base_index_option *type,
2397 Table_ident *table_ident,
2403 m_keytype(type_par),
2404 m_name(name_arg),
2405 m_type(type),
2406 m_table_ident(table_ident),
2407 m_columns(cols),
2409 m_algo(algo),
2410 m_lock(lock) {}
2411
2412 Sql_cmd *make_cmd(THD *thd) override;
2413
2414 private:
2423};
2424
2425/**
2426 Base class for column/constraint definitions in CREATE %TABLE
2427
2428 @ingroup ptn_create_table_stuff
2429*/
2431 protected:
2432 explicit PT_table_element(const POS &pos) : Table_ddl_node(pos) {}
2433};
2434
2436 protected:
2437 explicit PT_table_constraint_def(const POS &pos) : PT_table_element(pos) {}
2438};
2439
2442
2443 public:
2445 const LEX_STRING &name_arg,
2449 : super(pos),
2450 m_keytype(type_par),
2451 m_name(name_arg),
2452 m_type(type),
2453 m_columns(cols),
2454 m_options(options) {}
2455
2456 bool do_contextualize(Table_ddl_parse_context *pc) override;
2457
2458 private:
2464};
2465
2468
2469 public:
2470 PT_foreign_key_definition(const POS &pos, const LEX_STRING &constraint_name,
2471 const LEX_STRING &key_name,
2473 Table_ident *referenced_table,
2474 List<Key_part_spec> *ref_list,
2475 fk_match_opt fk_match_option,
2476 fk_option fk_update_opt, fk_option fk_delete_opt)
2477 : super(pos),
2478 m_constraint_name(constraint_name),
2479 m_key_name(key_name),
2480 m_columns(columns),
2481 m_referenced_table(referenced_table),
2482 m_ref_list(ref_list),
2483 m_fk_match_option(fk_match_option),
2484 m_fk_update_opt(fk_update_opt),
2485 m_fk_delete_opt(fk_delete_opt) {}
2486
2487 bool do_contextualize(Table_ddl_parse_context *pc) override;
2488
2489 private:
2498};
2499
2500/**
2501 Common base class for CREATE TABLE and ALTER TABLE option nodes
2502
2503 @ingroup ptn_create_or_alter_table_options
2504*/
2506 protected:
2507 explicit PT_ddl_table_option(const POS &pos) : Table_ddl_node(pos) {}
2508
2509 public:
2510 ~PT_ddl_table_option() override = 0; // Force abstract class declaration
2511
2512 virtual bool is_rename_table() const { return false; }
2513};
2514
2516
2517/**
2518 Base class for CREATE TABLE option nodes
2519
2520 @ingroup ptn_create_or_alter_table_options
2521*/
2524
2525 protected:
2526 explicit PT_create_table_option(const POS &pos) : super(pos) {}
2527
2528 public:
2529 ~PT_create_table_option() override = 0; // Force abstract class declaration
2530
2532 if (super::do_contextualize(pc)) return true;
2534 return false;
2535 }
2536};
2537
2539
2540/**
2541 A template for options that set a single property in HA_CREATE_INFO, and
2542 also records if the option was explicitly set.
2543*/
2544template <typename Option_type, Option_type HA_CREATE_INFO::*Property,
2545 uint64_t Property_flag>
2548
2549 const Option_type value;
2550
2551 public:
2552 explicit PT_traceable_create_table_option(const POS &pos, Option_type value)
2553 : super(pos), value(value) {}
2554
2556 if (super::do_contextualize(pc)) return true;
2557 pc->create_info->*Property = value;
2558 pc->create_info->used_fields |= Property_flag;
2559 return false;
2560 }
2561};
2562
2563#define TYPE_AND_REF(x) decltype(x), &x
2564
2565/**
2566 Node for the @SQL{MAX_ROWS [=] @B{@<integer@>}} table option
2567
2568 @ingroup ptn_create_or_alter_table_options
2569*/
2573
2574/**
2575 Node for the @SQL{MIN_ROWS [=] @B{@<integer@>}} table option
2576
2577 @ingroup ptn_create_or_alter_table_options
2578*/
2582
2583/**
2584 Node for the @SQL{AVG_ROW_LENGTH_ROWS [=] @B{@<integer@>}} table option
2585
2586 @ingroup ptn_create_or_alter_table_options
2587*/
2591
2592/**
2593 Node for the @SQL{PASSWORD [=] @B{@<string@>}} table option
2594
2595 @ingroup ptn_create_or_alter_table_options
2596*/
2600
2601/**
2602 Node for the @SQL{COMMENT [=] @B{@<string@>}} table option
2603
2604 @ingroup ptn_create_or_alter_table_options
2605*/
2609
2610/**
2611 Node for the @SQL{COMPRESSION [=] @B{@<string@>}} table option
2612
2613 @ingroup ptn_create_or_alter_table_options
2614*/
2618
2619/**
2620 Node for the @SQL{ENGRYPTION [=] @B{@<string@>}} table option
2621
2622 @ingroup ptn_create_or_alter_table_options
2623*/
2627
2628/**
2629 Node for the @SQL{AUTO_INCREMENT [=] @B{@<integer@>}} table option
2630
2631 @ingroup ptn_create_or_alter_table_options
2632*/
2636
2640
2645
2649
2653
2657
2661
2665
2670
2675
2677
2678/**
2679 A template for options that set HA_CREATE_INFO::table_options and
2680 also records if the option was explicitly set.
2681*/
2682template <ulong Property_flag, table_options_t Default, table_options_t Yes,
2683 table_options_t No>
2686
2688
2689 public:
2691 : super(pos), value(value) {}
2692
2694 if (super::do_contextualize(pc)) return true;
2695 pc->create_info->table_options &= ~(Yes | No);
2696 switch (value) {
2697 case Ternary_option::ON:
2698 pc->create_info->table_options |= Yes;
2699 break;
2701 pc->create_info->table_options |= No;
2702 break;
2704 break;
2705 default:
2706 assert(false);
2707 }
2708 pc->create_info->used_fields |= Property_flag;
2709 return false;
2710 }
2711};
2712
2713/**
2714 Node for the @SQL{PACK_KEYS [=] @B{1|0|DEFAULT}} table option
2715
2716 @ingroup ptn_create_or_alter_table_options
2717
2718 PACK_KEYS | Constructor parameter
2719 ----------|----------------------
2720 1 | Ternary_option::ON
2721 0 | Ternary_option::OFF
2722 DEFAULT | Ternary_option::DEFAULT
2723*/
2725 0, // DEFAULT
2726 HA_OPTION_PACK_KEYS, // ON
2729
2730/**
2731 Node for the @SQL{STATS_PERSISTENT [=] @B{1|0|DEFAULT}} table option
2732
2733 @ingroup ptn_create_or_alter_table_options
2734
2735 STATS_PERSISTENT | Constructor parameter
2736 -----------------|----------------------
2737 1 | Ternary_option::ON
2738 0 | Ternary_option::OFF
2739 DEFAULT | Ternary_option::DEFAULT
2740*/
2742 0, // DEFAULT
2746
2747/**
2748 A template for options that set HA_CREATE_INFO::table_options and
2749 also records if the option was explicitly set.
2750*/
2751template <ulong Property_flag, table_options_t Yes, table_options_t No>
2754
2755 const bool value;
2756
2757 public:
2758 explicit PT_bool_create_table_option(const POS &pos, bool value)
2759 : super(pos), value(value) {}
2760
2762 if (super::do_contextualize(pc)) return true;
2763 pc->create_info->table_options &= ~(Yes | No);
2764 pc->create_info->table_options |= value ? Yes : No;
2765 pc->create_info->used_fields |= Property_flag;
2766 return false;
2767 }
2768};
2769
2770/**
2771 Node for the @SQL{CHECKSUM|TABLE_CHECKSUM [=] @B{0|@<not 0@>}} table option
2772
2773 @ingroup ptn_create_or_alter_table_options
2774
2775 TABLE_CHECKSUM | Constructor parameter
2776 ---------------|----------------------
2777 0 | false
2778 not 0 | true
2779*/
2781 HA_OPTION_CHECKSUM, // ON
2783 >
2785
2786/**
2787 Node for the @SQL{DELAY_KEY_WRITE [=] @B{0|@<not 0@>}} table option
2788
2789 @ingroup ptn_create_or_alter_table_options
2790
2791 TABLE_CHECKSUM | Constructor parameter
2792 ---------------|----------------------
2793 0 | false
2794 not 0 | true
2795*/
2800
2801/**
2802 Node for the @SQL{ENGINE [=] @B{@<identifier@>|@<string@>}} table option
2803
2804 @ingroup ptn_create_or_alter_table_options
2805*/
2808
2810
2811 public:
2812 /**
2813 @param pos Position of this clause in the SQL statement.
2814 @param engine Storage engine name.
2815 */
2817 const LEX_CSTRING &engine)
2818 : super(pos), engine(engine) {}
2819
2820 bool do_contextualize(Table_ddl_parse_context *pc) override;
2821};
2822
2823/**
2824 Node for the @SQL{SECONDARY_ENGINE [=] @B{@<identifier@>|@<string@>|NULL}}
2825 table option.
2826
2827 @ingroup ptn_create_or_alter_table_options
2828*/
2831
2832 public:
2834 : super(pos) {}
2836 const POS &pos, const LEX_CSTRING &secondary_engine)
2838
2839 bool do_contextualize(Table_ddl_parse_context *pc) override;
2840
2841 private:
2843};
2844
2845/**
2846 Node for the @SQL{STATS_AUTO_RECALC [=] @B{@<0|1|DEFAULT@>})} table option
2847
2848 @ingroup ptn_create_or_alter_table_options
2849*/
2852
2854
2855 public:
2856 /**
2857 @param pos Position of this clause in the SQL statement.
2858 @param value
2859 STATS_AUTO_RECALC | value
2860 ------------------|----------------------
2861 1 | Ternary_option::ON
2862 0 | Ternary_option::OFF
2863 DEFAULT | Ternary_option::DEFAULT
2864 */
2866 : super(pos), value(value) {}
2867
2868 bool do_contextualize(Table_ddl_parse_context *pc) override;
2869};
2870
2871/**
2872 Node for the @SQL{STATS_SAMPLE_PAGES [=] @B{@<integer@>|DEFAULT}} table option
2873
2874 @ingroup ptn_create_or_alter_table_options
2875*/
2879
2881
2882 public:
2883 /**
2884 Constructor for implicit number of pages
2885
2886 @param pos Position of this clause in the SQL statement.
2887 @param value Number of pages, 1@<=N@<=65535.
2888 */
2890 : super(pos), value(value) {
2891 assert(value != 0 && value <= 0xFFFF);
2892 }
2893 /**
2894 Constructor for the DEFAULT number of pages
2895 */
2897 : super(pos), value(0) {} // DEFAULT
2898
2899 bool do_contextualize(Table_ddl_parse_context *pc) override;
2900};
2901
2904
2906
2907 public:
2908 explicit PT_create_union_option(const POS &pos,
2910 : super(pos), tables(tables) {}
2911
2912 bool do_contextualize(Table_ddl_parse_context *pc) override;
2913};
2914
2917
2919
2920 public:
2922 : super(pos), value(value) {}
2923
2925 if (super::do_contextualize(pc)) return true;
2927 return false;
2928 }
2929};
2930
2933
2935
2936 public:
2938 const CHARSET_INFO *value)
2939 : super(pos), value(value) {
2940 assert(value != nullptr);
2941 }
2942
2943 bool do_contextualize(Table_ddl_parse_context *pc) override;
2944};
2945
2948
2950
2951 public:
2953 const CHARSET_INFO *value)
2954 : super(pos), value(value) {
2955 assert(value != nullptr);
2956 }
2957
2958 bool do_contextualize(Table_ddl_parse_context *pc) override;
2959};
2960
2964
2965 public:
2966 explicit PT_check_constraint(const POS &pos, LEX_STRING &name, Item *expr,
2967 bool is_enforced)
2968 : super(pos) {
2969 cc_spec.name = name;
2970 cc_spec.check_expr = expr;
2971 cc_spec.is_enforced = is_enforced;
2972 }
2974
2975 bool do_contextualize(Table_ddl_parse_context *pc) override;
2976};
2977
2980
2983 // Currently we ignore that constraint in the executor.
2985
2986 const char *opt_place;
2987
2988 public:
2992 const char *opt_place = nullptr)
2993 : super(pos),
2998
2999 bool do_contextualize(Table_ddl_parse_context *pc) override;
3000};
3001
3002/**
3003 Top-level node for the CREATE %TABLE statement
3004
3005 @ingroup ptn_create_table
3006*/
3017
3019
3020 public:
3021 /**
3022 @param pos Position of this clause in the SQL
3023 statement.
3024 @param mem_root MEM_ROOT to use for allocation
3025 @param is_temporary True if @SQL{CREATE @B{TEMPORARY} %TABLE}
3026 @param only_if_not_exists True if @SQL{CREATE %TABLE ... @B{IF NOT EXISTS}}
3027 @param table_name @SQL{CREATE %TABLE ... @B{@<table name@>}}
3028 @param opt_table_element_list NULL or a list of table column and
3029 constraint definitions.
3030 @param opt_create_table_options NULL or a list of
3031 @ref ptn_create_or_alter_table_options
3032 "table options".
3033 @param opt_partitioning NULL or the @SQL{PARTITION BY} clause.
3034 @param on_duplicate DUPLICATE, IGNORE or fail with an error
3035 on data duplication errors (relevant
3036 for @SQL{CREATE TABLE ... SELECT}
3037 statements).
3038 @param opt_query_expression NULL or the @SQL{@B{SELECT}} clause.
3039 */
3041 const POS &pos, MEM_ROOT *mem_root, bool is_temporary,
3057 /**
3058 @param pos Position of this clause in the SQL statement.
3059 @param mem_root MEM_ROOT to use for allocation
3060 @param is_temporary True if @SQL{CREATE @B{TEMPORARY} %TABLE}.
3061 @param only_if_not_exists True if @SQL{CREATE %TABLE ... @B{IF NOT EXISTS}}.
3062 @param table_name @SQL{CREATE %TABLE ... @B{@<table name@>}}.
3063 @param opt_like_clause NULL or the @SQL{@B{LIKE @<table name@>}} clause.
3064 */
3078
3079 Sql_cmd *make_cmd(THD *thd) override;
3080};
3081
3082class PT_create_role final : public Parse_tree_root {
3084
3085 public:
3086 PT_create_role(const POS &pos, bool if_not_exists,
3087 const List<LEX_USER> *roles)
3088 : Parse_tree_root(pos), sql_cmd(if_not_exists, roles) {}
3089
3090 Sql_cmd *make_cmd(THD *thd) override;
3091};
3092
3093class PT_drop_role final : public Parse_tree_root {
3095
3096 public:
3097 explicit PT_drop_role(const POS &pos, bool ignore_errors,
3098 const List<LEX_USER> *roles)
3099 : Parse_tree_root(pos), sql_cmd(ignore_errors, roles) {}
3100
3101 Sql_cmd *make_cmd(THD *thd) override;
3102};
3103
3106
3107 public:
3108 explicit PT_set_role(const POS &pos, role_enum role_type,
3109 const List<LEX_USER> *opt_except_roles = nullptr)
3110 : Parse_tree_root(pos), sql_cmd(role_type, opt_except_roles) {
3111 assert(role_type == role_enum::ROLE_ALL || opt_except_roles == nullptr);
3112 }
3113 explicit PT_set_role(const POS &pos, const List<LEX_USER> *roles)
3114 : Parse_tree_root(pos), sql_cmd(roles) {}
3115
3116 Sql_cmd *make_cmd(THD *thd) override;
3117};
3118
3119/**
3120 This class is used for representing both static and dynamic privileges on
3121 global as well as table and column level.
3122*/
3125
3128
3131 : type(type), columns(columns) {}
3132};
3133
3135 const uint grant;
3136
3138 : Privilege(STATIC, columns_arg), grant(grant) {}
3139};
3140
3143
3145 const Mem_root_array<LEX_CSTRING> *columns_arg)
3146 : Privilege(DYNAMIC, columns_arg), ident(ident) {}
3147};
3148
3150 private:
3152
3153 public:
3154 explicit PT_role_or_privilege(const POS &pos, const POS &errpos)
3155 : Parse_tree_node(pos), m_errpos(errpos) {}
3156 virtual LEX_USER *get_user(THD *thd);
3157 virtual Privilege *get_privilege(THD *thd);
3158};
3159
3163
3164 public:
3165 PT_role_at_host(const POS &pos, const POS &errpos, const LEX_STRING &role,
3166 const LEX_STRING &host)
3167 : PT_role_or_privilege(pos, errpos), role(role), host(host) {}
3168
3169 LEX_USER *get_user(THD *thd) override;
3170};
3171
3174
3175 public:
3176 PT_role_or_dynamic_privilege(const POS &pos, const POS &errpos,
3177 const LEX_STRING &ident)
3178 : PT_role_or_privilege(pos, errpos), ident(ident) {}
3179
3180 LEX_USER *get_user(THD *thd) override;
3181 Privilege *get_privilege(THD *thd) override;
3182};
3183
3185 const uint grant;
3187
3188 public:
3189 PT_static_privilege(const POS &pos, const POS &errpos, uint grant,
3190 const Mem_root_array<LEX_CSTRING> *columns = nullptr)
3191 : PT_role_or_privilege(pos, errpos), grant(grant), columns(columns) {}
3192
3193 Privilege *get_privilege(THD *thd) override;
3194};
3195
3198
3199 public:
3200 PT_dynamic_privilege(const POS &pos, const POS &errpos,
3201 const LEX_STRING &ident)
3202 : PT_role_or_privilege(pos, errpos), ident(ident) {}
3203
3204 Privilege *get_privilege(THD *thd) override;
3205};
3206
3207class PT_grant_roles final : public Parse_tree_root {
3211
3212 public:
3216 : Parse_tree_root(pos),
3217 roles(roles),
3218 users(users),
3220
3221 Sql_cmd *make_cmd(THD *thd) override;
3222};
3223
3224class PT_revoke_roles final : public Parse_tree_root {
3227
3228 public:
3230 const List<LEX_USER> *users)
3231 : Parse_tree_root(pos), roles(roles), users(users) {}
3232
3233 Sql_cmd *make_cmd(THD *thd) override;
3234};
3235
3238
3239 public:
3240 PT_alter_user_default_role(const POS &pos, bool if_exists,
3241 const List<LEX_USER> *users,
3242 const List<LEX_USER> *roles,
3243 const role_enum role_type)
3244 : Parse_tree_root(pos), sql_cmd(if_exists, users, roles, role_type) {}
3245
3246 Sql_cmd *make_cmd(THD *thd) override;
3247};
3248
3249/// Base class for Parse tree nodes of SHOW statements
3250
3252 protected:
3253 PT_show_base(const POS &pos, enum_sql_command sql_command)
3254 : Parse_tree_root(pos), m_sql_command(sql_command) {}
3255
3256 /// SQL command
3258};
3259
3260/// Base class for Parse tree nodes of SHOW statements with LIKE/WHERE parameter
3261
3263 protected:
3265 const LEX_STRING &wild, Item *where)
3266 : PT_show_base(pos, sql_command), m_wild(wild), m_where(where) {
3267 assert(m_wild.str == nullptr || m_where == nullptr);
3268 }
3269 /// Wild or where clause used in the statement.
3272};
3273
3274/// Base class for Parse tree nodes of SHOW statements with schema parameter.
3275
3277 protected:
3279 char *opt_db, const LEX_STRING &wild, Item *where)
3280 : PT_show_base(pos, sql_command),
3282 m_wild(wild),
3283 m_where(where) {
3284 assert(m_wild.str == nullptr || m_where == nullptr);
3285 }
3286 /// Optional schema name in FROM/IN clause.
3288 /// Wild or where clause used in the statement.
3291};
3292
3293/// Base class for Parse tree nodes of SHOW COLUMNS/SHOW INDEX statements.
3294
3296 protected:
3297 PT_show_table_base(const POS &pos, enum_sql_command sql_command,
3298 Table_ident *table_ident, const LEX_STRING &wild,
3299 Item *where)
3300 : PT_show_filter_base(pos, sql_command, wild, where),
3301 m_table_ident(table_ident) {}
3302
3303 bool make_table_base_cmd(THD *thd, bool *temporary);
3304
3305 /// Table used in the statement.
3307};
3308
3309/// Parse tree node for SHOW FUNCTION/PROCEDURE CODE statements.
3310
3312 protected:
3314 const sp_name *routine_name)
3315 : PT_show_base(pos, sql_command), m_sql_cmd(sql_command, routine_name) {}
3316
3317 Sql_cmd *make_cmd(THD *thd) override;
3318
3319 private:
3321};
3322
3323/// Parse tree node for SHOW BINLOG EVENTS statement
3324
3326 public:
3327 PT_show_binlog_events(const POS &pos, const LEX_STRING opt_log_file_name = {},
3328 PT_limit_clause *opt_limit_clause = nullptr)
3330 m_opt_log_file_name(opt_log_file_name),
3331 m_opt_limit_clause(opt_limit_clause) {}
3332
3333 Sql_cmd *make_cmd(THD *thd) override;
3334
3335 private:
3338
3340};
3341
3342/// Parse tree node for SHOW BINLOGS statement
3343
3344class PT_show_binlogs final : public PT_show_base {
3345 public:
3347
3348 Sql_cmd *make_cmd(THD *thd) override;
3349
3350 private:
3352};
3353
3354/// Parse tree node for SHOW CHARACTER SET statement
3355
3357 public:
3358 PT_show_charsets(const POS &pos, const LEX_STRING &wild, Item *where)
3360
3361 Sql_cmd *make_cmd(THD *thd) override;
3362
3363 private:
3365};
3366
3367/// Parse tree node for SHOW COLLATIONS statement
3368
3370 public:
3371 PT_show_collations(const POS &pos, const LEX_STRING &wild, Item *where)
3373
3374 Sql_cmd *make_cmd(THD *thd) override;
3375
3376 private:
3378};
3379
3380/// Base class for Parse tree nodes of SHOW COUNT(*) { WARNINGS | ERRORS }
3381/// statements.
3382
3384 public:
3385 explicit PT_show_count_base(const POS &pos)
3386 : PT_show_base{pos, SQLCOM_SELECT} {}
3387
3388 protected:
3389 Sql_cmd *make_cmd_generic(THD *thd, LEX_CSTRING diagnostic_variable_name);
3390};
3391
3392/// Parse tree node for SHOW COUNT(*) ERRORS
3393
3395 public:
3396 explicit PT_show_count_errors(const POS &pos) : PT_show_count_base(pos) {}
3397
3398 Sql_cmd *make_cmd(THD *thd) override {
3399 return make_cmd_generic(thd, LEX_CSTRING{STRING_WITH_LEN("error_count")});
3400 }
3401};
3402
3403/// Parse tree node for SHOW COUNT(*) WARNINGS
3404
3406 public:
3407 explicit PT_show_count_warnings(const POS &pos) : PT_show_count_base(pos) {}
3408
3409 Sql_cmd *make_cmd(THD *thd) override {
3410 return make_cmd_generic(thd, LEX_CSTRING{STRING_WITH_LEN("warning_count")});
3411 }
3412};
3413
3414/// Parse tree node for SHOW CREATE DATABASE statement
3415
3417 public:
3418 PT_show_create_database(const POS &pos, bool if_not_exists,
3419 const LEX_STRING &name)
3421 m_if_not_exists(if_not_exists),
3422 m_name(name) {}
3423
3424 Sql_cmd *make_cmd(THD *thd) override;
3425
3426 private:
3429
3431};
3432
3433/// Parse tree node for SHOW CREATE EVENT statement
3434
3436 public:
3437 PT_show_create_event(const POS &pos, sp_name *event_name)
3438 : PT_show_base(pos, SQLCOM_SHOW_CREATE_EVENT), m_spname(event_name) {}
3439
3440 Sql_cmd *make_cmd(THD *thd) override;
3441
3442 private:
3444
3446};
3447
3448/// Parse tree node for SHOW CREATE FUNCTION statement
3449
3451 public:
3452 PT_show_create_function(const POS &pos, sp_name *function_name)
3453 : PT_show_base(pos, SQLCOM_SHOW_CREATE_FUNC), m_spname(function_name) {}
3454
3455 Sql_cmd *make_cmd(THD *thd) override;
3456
3457 private:
3459
3461};
3462
3463/// Parse tree node for SHOW CREATE PROCEDURE statement
3464
3466 public:
3467 PT_show_create_procedure(const POS &pos, sp_name *procedure_name)
3468 : PT_show_base(pos, SQLCOM_SHOW_CREATE_PROC), m_spname(procedure_name) {}
3469
3470 Sql_cmd *make_cmd(THD *thd) override;
3471
3472 private:
3474
3476};
3477
3478/// Parse tree node for SHOW CREATE TABLE and VIEW statements
3479
3481 public:
3482 PT_show_create_table(const POS &pos, Table_ident *table_ident)
3483 : PT_show_base(pos, SQLCOM_SHOW_CREATE), m_sql_cmd(false, table_ident) {}
3484
3485 Sql_cmd *make_cmd(THD *thd) override;
3486
3487 private:
3489};
3490
3491/// Parse tree node for SHOW CREATE TRIGGER statement
3492
3494 public:
3495 PT_show_create_trigger(const POS &pos, sp_name *trigger_name)
3496 : PT_show_base(pos, SQLCOM_SHOW_CREATE_TRIGGER), m_spname(trigger_name) {}
3497
3498 Sql_cmd *make_cmd(THD *thd) override;
3499
3500 private:
3502
3504};
3505
3506/// Parse tree node for SHOW CREATE USER statement
3507
3508class PT_show_create_user final : public PT_show_base {
3509 public:
3512
3513 Sql_cmd *make_cmd(THD *thd) override;
3514
3515 private:
3517
3519};
3520
3521/// Parse tree node for SHOW CREATE VIEW statement
3522
3523class PT_show_create_view final : public PT_show_base {
3524 public:
3525 PT_show_create_view(const POS &pos, Table_ident *table_ident)
3526 : PT_show_base(pos, SQLCOM_SHOW_CREATE), m_sql_cmd(true, table_ident) {}
3527
3528 Sql_cmd *make_cmd(THD *thd) override;
3529
3530 private:
3532};
3533
3534/// Parse tree node for SHOW DATABASES statement
3535
3537 public:
3538 PT_show_databases(const POS &pos, const LEX_STRING &wild, Item *where)
3540
3541 Sql_cmd *make_cmd(THD *thd) override;
3542
3543 private:
3545};
3546
3547/// Parse tree node for SHOW ENGINE statements
3548
3550 protected:
3551 PT_show_engine_base(const POS &pos, enum enum_sql_command sql_command,
3552 const LEX_STRING opt_engine = {})
3553 : PT_show_base(pos, sql_command),
3554 m_engine(opt_engine),
3555 m_all(opt_engine.str == nullptr) {}
3556
3558 bool m_all;
3559};
3560
3561/// Parse tree node for SHOW ENGINE LOGS statement
3562
3564 public:
3565 PT_show_engine_logs(const POS &pos, LEX_STRING opt_engine = {})
3566 : PT_show_engine_base(pos, SQLCOM_SHOW_ENGINE_LOGS, opt_engine) {}
3567
3568 Sql_cmd *make_cmd(THD *thd) override;
3569
3570 private:
3572};
3573
3574/// Parse tree node for SHOW ENGINE MUTEX statement
3575
3577 public:
3578 PT_show_engine_mutex(const POS &pos, LEX_STRING opt_engine = {})
3579 : PT_show_engine_base(pos, SQLCOM_SHOW_ENGINE_MUTEX, opt_engine) {}
3580
3581 Sql_cmd *make_cmd(THD *thd) override;
3582
3583 private:
3585};
3586
3587/// Parse tree node for SHOW ENGINE STATUS statement
3588
3590 public:
3591 PT_show_engine_status(const POS &pos, LEX_STRING opt_engine = {})
3592 : PT_show_engine_base(pos, SQLCOM_SHOW_ENGINE_STATUS, opt_engine) {}
3593
3594 Sql_cmd *make_cmd(THD *thd) override;
3595
3596 private:
3598};
3599
3600/// Parse tree node for SHOW ENGINES statement
3601
3602class PT_show_engines final : public PT_show_base {
3603 public:
3606
3607 Sql_cmd *make_cmd(THD *thd) override;
3608
3609 private:
3611};
3612
3613/// Parse tree node for SHOW ERRORS statement
3614
3615class PT_show_errors final : public PT_show_base {
3616 public:
3617 PT_show_errors(const POS &pos, PT_limit_clause *opt_limit_clause = nullptr)
3619 m_opt_limit_clause(opt_limit_clause) {}
3620
3621 Sql_cmd *make_cmd(THD *thd) override;
3622
3623 private:
3625
3627};
3628
3629/// Parse tree node for SHOW EVENTS statement
3630
3632 public:
3633 PT_show_events(const POS &pos, char *opt_db, const LEX_STRING &wild,
3634 Item *where)
3636
3637 Sql_cmd *make_cmd(THD *thd) override;
3638
3639 private:
3641};
3642
3643/// Parse tree node for SHOW COLUMNS statement.
3644
3647
3648 public:
3649 PT_show_fields(const POS &pos, Show_cmd_type show_cmd_type,
3650 Table_ident *table, LEX_STRING opt_wild = {},
3651 Item *opt_where = nullptr)
3652 : PT_show_table_base(pos, SQLCOM_SHOW_FIELDS, table, opt_wild, opt_where),
3653 m_show_cmd_type(show_cmd_type) {}
3654
3655 Sql_cmd *make_cmd(THD *thd) override;
3656
3657 private:
3660};
3661
3662/// Parse tree node for SHOW FUNCTION CODE statement.
3663
3665 public:
3666 PT_show_function_code(const POS &pos, const sp_name *function_name)
3667 : PT_show_routine_code(pos, SQLCOM_SHOW_FUNC_CODE, function_name) {}
3668};
3669
3670/// Parse tree node for SHOW GRANTS statement.
3671
3672class PT_show_grants final : public PT_show_base {
3673 public:
3674 PT_show_grants(const POS &pos, const LEX_USER *opt_for_user,
3675 const List<LEX_USER> *opt_using_users)
3677 sql_cmd(opt_for_user, opt_using_users) {
3678 assert(opt_using_users == nullptr || opt_for_user != nullptr);
3679 }
3680
3681 Sql_cmd *make_cmd(THD *thd) override;
3682
3683 private:
3685};
3686
3687/// Parse tree node for SHOW INDEX statement.
3688
3689class PT_show_keys final : public PT_show_table_base {
3690 public:
3691 PT_show_keys(const POS &pos, bool extended_show, Table_ident *table,
3692 Item *where)
3694 m_extended_show(extended_show) {}
3695
3696 Sql_cmd *make_cmd(THD *thd) override;
3697
3698 private:
3700
3701 // Flag to indicate EXTENDED keyword usage in the statement.
3704};
3705
3706/// Parse tree node for SHOW BINARY LOG STATUS statement
3707
3709 public:
3712
3713 Sql_cmd *make_cmd(THD *thd) override;
3714
3715 private:
3717};
3718
3719/// Parse tree node for SHOW OPEN TABLES statement
3720
3722 public:
3723 PT_show_open_tables(const POS &pos, char *opt_db, const LEX_STRING &wild,
3724 Item *where)
3726 }
3727
3728 Sql_cmd *make_cmd(THD *thd) override;
3729
3730 private:
3732};
3733
3734/// Parse tree node for SHOW PLUGINS statement
3735
3736class PT_show_plugins final : public PT_show_base {
3737 public:
3739
3740 Sql_cmd *make_cmd(THD *thd) override;
3741
3742 private:
3744};
3745
3746/// Parse tree node for SHOW PRIVILEGES statement
3747
3748class PT_show_privileges final : public PT_show_base {
3749 public:
3752
3753 Sql_cmd *make_cmd(THD *thd) override;
3754
3755 private:
3757};
3758
3759/// Parse tree node for SHOW PARSE_TREE statement
3760
3761class PT_show_parse_tree final : public PT_show_base {
3762 public:
3763 PT_show_parse_tree(const POS &pos, Parse_tree_root *parse_tree_stmt)
3765 m_parse_tree_stmt(parse_tree_stmt) {}
3766
3767 Sql_cmd *make_cmd(THD *thd) override;
3768
3769 private:
3772};
3773
3774/// Parse tree node for SHOW FUNCTION CODE statement.
3775
3777 public:
3778 PT_show_procedure_code(const POS &pos, const sp_name *procedure_name)
3779 : PT_show_routine_code(pos, SQLCOM_SHOW_PROC_CODE, procedure_name) {}
3780};
3781
3782/// Parse tree node for SHOW PROCESSLIST statement
3783
3784class PT_show_processlist final : public PT_show_base {
3785 public:
3788
3789 Sql_cmd *make_cmd(THD *thd) override;
3790
3791 private:
3793};
3794
3795/// Parse tree node for SHOW PROFILE statement
3796
3797class PT_show_profile final : public PT_show_base {
3798 public:
3799 PT_show_profile(const POS &pos, uint opt_profile_options = 0,
3800 my_thread_id opt_query_id = 0,
3801 PT_limit_clause *opt_limit_clause = nullptr)
3803 m_opt_profile_options(opt_profile_options),
3804 m_opt_query_id(opt_query_id),
3805 m_opt_limit_clause(opt_limit_clause) {}
3806
3807 Sql_cmd *make_cmd(THD *thd) override;
3808
3809 private:
3813
3815};
3816
3817/// Parse tree node for SHOW PROFILES statement
3818
3819class PT_show_profiles final : public PT_show_base {
3820 public:
3822
3823 Sql_cmd *make_cmd(THD *thd) override;
3824
3825 private:
3827};
3828
3829/// Parse tree node for SHOW RELAYLOG EVENTS statement
3830
3832 public:
3834 const LEX_STRING opt_log_file_name = {},
3835 PT_limit_clause *opt_limit_clause = nullptr,
3836 LEX_CSTRING opt_channel_name = {})
3838 m_opt_log_file_name(opt_log_file_name),
3839 m_opt_limit_clause(opt_limit_clause),
3840 m_opt_channel_name(opt_channel_name) {}
3841
3842 Sql_cmd *make_cmd(THD *thd) override;
3843
3844 private:
3848
3850};
3851
3852/// Parse tree node for SHOW REPLICAS statement
3853
3854class PT_show_replicas final : public PT_show_base {
3855 public:
3858
3859 Sql_cmd *make_cmd(THD *thd) override;
3860
3861 private:
3863};
3864
3865/// Parse tree node for SHOW REPLICA STATUS statement
3866
3868 public:
3869 PT_show_replica_status(const POS &pos, LEX_CSTRING opt_channel_name = {})
3871 m_opt_channel_name(opt_channel_name) {}
3872
3873 Sql_cmd *make_cmd(THD *thd) override;
3874
3875 private:
3877
3879};
3880
3881/// Parse tree node for SHOW STATUS statement
3882
3884 public:
3885 PT_show_status(const POS &pos, enum_var_type var_type, const LEX_STRING &wild,
3886 Item *where)
3888 m_var_type(var_type) {
3890 }
3891
3892 Sql_cmd *make_cmd(THD *thd) override;
3893
3894 private:
3896
3898};
3899
3900/// Parse tree node for SHOW STATUS FUNCTION statement
3901
3903 public:
3904 PT_show_status_func(const POS &pos, const LEX_STRING &wild, Item *where)
3906
3907 Sql_cmd *make_cmd(THD *thd) override;
3908
3909 private:
3911};
3912
3913/// Parse tree node for SHOW STATUS PROCEDURE statement
3914
3916 public:
3917 PT_show_status_proc(const POS &pos, const LEX_STRING &wild, Item *where)
3919
3920 Sql_cmd *make_cmd(THD *thd) override;
3921
3922 private:
3924};
3925
3926/// Parse tree node for SHOW TABLE STATUS statement
3927
3929 public:
3930 PT_show_table_status(const POS &pos, char *opt_db, const LEX_STRING &wild,
3931 Item *where)
3933 where) {}
3934
3935 Sql_cmd *make_cmd(THD *thd) override;
3936
3937 private:
3939};
3940
3941/// Parse tree node for SHOW TABLES statement
3942
3944 public:
3945 PT_show_tables(const POS &pos, Show_cmd_type show_cmd_type, char *opt_db,
3946 const LEX_STRING &wild, Item *where)
3948 m_show_cmd_type(show_cmd_type) {}
3949
3950 Sql_cmd *make_cmd(THD *thd) override;
3951
3952 private:
3954
3956};
3957
3958/// Parse tree node for SHOW TRIGGERS statement
3959
3961 public:
3962 PT_show_triggers(const POS &pos, bool full, char *opt_db,
3963 const LEX_STRING &wild, Item *where)
3965 m_full(full) {}
3966
3967 Sql_cmd *make_cmd(THD *thd) override;
3968
3969 private:
3971
3973};
3974
3975/// Parse tree node for SHOW VARIABLES statement
3976
3978 public:
3980 const LEX_STRING &wild, Item *where)
3982 m_var_type(var_type) {
3984 }
3985
3986 Sql_cmd *make_cmd(THD *thd) override;
3987
3988 private:
3990
3992};
3993
3994/// Parse tree node for SHOW WARNINGS statement
3995
3996class PT_show_warnings final : public PT_show_base {
3997 public:
3998 PT_show_warnings(const POS &pos, PT_limit_clause *opt_limit_clause = nullptr)
4000 m_opt_limit_clause(opt_limit_clause) {}
4001
4002 Sql_cmd *make_cmd(THD *thd) override;
4003
4004 private:
4006
4008};
4009
4012
4013 protected:
4014 explicit PT_alter_table_action(const POS &pos,
4016 : super(pos), flag(flag) {}
4017
4018 public:
4019 bool do_contextualize(Table_ddl_parse_context *pc) override;
4020
4021 protected:
4022 /**
4023 A routine used by the parser to decide whether we are specifying a full
4024 partitioning or if only partitions to add or to reorganize.
4025
4026 @retval true ALTER TABLE ADD/REORGANIZE PARTITION.
4027 @retval false Something else.
4028 */
4032 }
4033
4034 public:
4036};
4037
4040
4041 public:
4042 PT_alter_table_add_column(const POS &pos, const LEX_STRING &field_ident,
4043 PT_field_def_base *field_def,
4044 PT_table_constraint_def *opt_column_constraint,
4045 const char *opt_place)
4046 : super(pos, Alter_info::ALTER_ADD_COLUMN),
4047 m_column_def(POS(), field_ident, field_def, opt_column_constraint,
4048 opt_place) {}
4049
4052 }
4053
4054 private:
4055 PT_column_def m_column_def; // TODO: Position is not set.
4056};
4057
4060
4061 public:
4063 const POS &pos, const Mem_root_array<PT_table_element *> *columns)
4064 : super(pos, Alter_info::ALTER_ADD_COLUMN), m_columns(columns) {}
4065
4067 if (super::do_contextualize(pc)) return true;
4068
4069 for (auto *column : *m_columns)
4070 if (column->contextualize(pc)) return true;
4071
4072 return false;
4073 }
4074
4075 private:
4077};
4078
4081
4082 public:
4084 PT_table_constraint_def *constraint)
4085 : super(pos, Alter_info::ALTER_ADD_INDEX), m_constraint(constraint) {}
4086
4089 }
4090
4091 private:
4093};
4094
4097
4098 public:
4099 PT_alter_table_change_column(const POS &pos, const LEX_STRING &old_name,
4100 const LEX_STRING &new_name,
4101 PT_field_def_base *field_def,
4102 const char *opt_place)
4103 : super(pos, Alter_info::ALTER_CHANGE_COLUMN),
4104 m_old_name(old_name),
4105 m_new_name(new_name),
4106 m_field_def(field_def),
4107 m_opt_place(opt_place) {}
4108
4110 PT_field_def_base *field_def,
4111 const char *opt_place)
4112 : PT_alter_table_change_column(pos, name, name, field_def, opt_place) {}
4113
4114 bool do_contextualize(Table_ddl_parse_context *pc) override;
4115
4116 private:
4120 const char *m_opt_place;
4121};
4122
4125
4126 protected:
4128 Alter_info::Alter_info_flag alter_info_flag,
4129 const char *name)
4130 : super(pos, alter_info_flag), m_alter_drop(drop_type, name) {}
4131
4132 public:
4134 return (super::do_contextualize(pc) ||
4135 pc->alter_info->drop_list.push_back(&m_alter_drop));
4136 }
4137
4138 private:
4140};
4141
4143 public:
4144 explicit PT_alter_table_drop_column(const POS &pos, const char *name)
4145 : PT_alter_table_drop(pos, Alter_drop::COLUMN,
4146 Alter_info::ALTER_DROP_COLUMN, name) {}
4147};
4148
4150 public:
4151 explicit PT_alter_table_drop_foreign_key(const POS &pos, const char *name)
4153 Alter_info::DROP_FOREIGN_KEY, name) {}
4154};
4155
4157 public:
4158 explicit PT_alter_table_drop_key(const POS &pos, const char *name)
4159 : PT_alter_table_drop(pos, Alter_drop::KEY, Alter_info::ALTER_DROP_INDEX,
4160 name) {}
4161};
4162
4164 public:
4166 const char *name)
4167 : PT_alter_table_drop(pos, Alter_drop::CHECK_CONSTRAINT,
4168 Alter_info::DROP_CHECK_CONSTRAINT, name) {}
4169};
4170
4172 public:
4173 explicit PT_alter_table_drop_constraint(const POS &pos, const char *name)
4174 : PT_alter_table_drop(pos, Alter_drop::ANY_CONSTRAINT,
4175 Alter_info::DROP_ANY_CONSTRAINT, name) {}
4176};
4177
4180
4181 protected:
4183 const POS &pos, Alter_constraint_enforcement::Type alter_type,
4184 Alter_info::Alter_info_flag alter_info_flag, const char *name,
4185 bool is_enforced)
4186 : super(pos, alter_info_flag),
4187 m_constraint_enforcement(alter_type, name, is_enforced) {}
4188
4189 public:
4190 explicit PT_alter_table_enforce_constraint(const POS &pos, const char *name,
4191 bool is_enforced)
4192 : super(pos, is_enforced ? Alter_info::ENFORCE_ANY_CONSTRAINT
4193 : Alter_info::SUSPEND_ANY_CONSTRAINT),
4195 Alter_constraint_enforcement::Type::ANY_CONSTRAINT, name,
4196 is_enforced) {}
4197
4199 return (super::do_contextualize(pc) ||
4202 }
4203
4204 private: