MySQL 8.0.31
Source Code Documentation
parse_tree_helpers.h
Go to the documentation of this file.
1/* Copyright (c) 2013, 2022, 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_HELPERS_INCLUDED
24#define PARSE_TREE_HELPERS_INCLUDED
25
26#include <assert.h>
27#include <sys/types.h> // TODO: replace with cstdint
28#include <new>
29
30#include "lex_string.h"
31#include "m_ctype.h"
32
33#include "my_inttypes.h" // TODO: replace with cstdint
34#include "mysql_time.h"
35#include "sql/item.h"
36#include "sql/item_func.h" // Item etc.
37#include "sql/parse_location.h" // POS
39#include "sql/resourcegroups/resource_group_basic_types.h" // resourcegroups::Range
40#include "sql/set_var.h" // enum_var_type
41#include "sql/sql_error.h"
42#include "sql/sql_list.h"
43
46class String;
47class THD;
48class my_decimal;
49enum class Set_operator;
51struct MEM_ROOT;
52struct handlerton;
53
54template <typename Element_type>
55class Mem_root_array;
56
57/**
58 Base class for parse-time Item objects
59
60 Parse-time Item objects are placeholders for real Item objects: in some
61 cases it is not easy or even possible to decide what exact Item class object
62 we need to allocate in the parser. Parse-time Item objects are intended
63 to defer real Item object allocation to the contextualization phase (see
64 the Item::itemize() function).
65
66 This wrapper class overrides abstract virtual functions of the parent
67 class with dummy wrappers to make C++ compiler happy.
68*/
69class Parse_tree_item : public Item {
70 public:
71 explicit Parse_tree_item(const POS &pos) : Item(pos) {}
72
73 enum Type type() const override { return INVALID_ITEM; }
74 double val_real() override {
75 assert(0);
76 return 0;
77 }
78 longlong val_int() override {
79 assert(0);
80 return 0;
81 }
82 String *val_str(String *) override {
83 assert(0);
84 return nullptr;
85 }
87 assert(0);
88 return nullptr;
89 }
90 bool get_date(MYSQL_TIME *, uint) override {
91 assert(0);
92 return false;
93 }
94 bool get_time(MYSQL_TIME *) override {
95 assert(0);
96 return false;
97 }
98};
99
100/**
101 Wrapper class for an Item list head, used to allocate Item lists in the parser
102 in a context-independent way
103*/
106
107 public:
109
111
112 bool contextualize(Parse_context *pc) override {
113 if (super::contextualize(pc)) return true;
114 for (Item *&item : value) {
115 if (item->itemize(pc, &item)) return true;
116 }
117 return false;
118 }
119
120 bool is_empty() const { return value.empty(); }
121 uint elements() const { return value.size(); }
122
123 bool push_back(Item *item) {
124 /*
125 Item may be NULL in case of OOM: just ignore it and check thd->is_error()
126 in the caller code.
127 */
128 if (item == nullptr) return true;
129 value.push_back(item);
130 return false;
131 }
132
133 bool push_front(Item *item) {
134 /*
135 Item may be NULL in case of OOM: just ignore it and check thd->is_error()
136 in the caller code.
137 */
138 if (item == nullptr) return true;
139 value.push_front(item);
140 return false;
141 }
142
144 assert(!is_empty());
145 Item *ret = value.front();
146 value.pop_front();
147 return ret;
148 }
149
150 Item *operator[](uint index) const { return value[index]; }
151};
152
153/**
154 Contextualize a Mem_root_array of parse tree nodes of the type PTN
155
156 @tparam Context Parse context.
157 @tparam Array Array of parse tree nodes.
158
159 @param[in,out] pc Parse context.
160 @param[in,out] array Array of nodes to contextualize.
161
162 @return false on success.
163*/
164template <typename Context, typename Array>
165bool contextualize_array(Context *pc, Array *array) {
166 for (auto it : *array) {
167 if (pc->thd->lex->will_contextualize && it->contextualize(pc)) return true;
168 }
169 return false;
170}
171
172/**
173 Helper function to imitate dynamic_cast for Item_cond hierarchy.
174
175 Template parameter @p To is the destination type (@c Item_cond_and etc.)
176 Template parameter @p Tag is the Functype tag to compare from->functype() with
177
178 @param from source item
179
180 @return typecasted item of the type To or NULL
181*/
182template <class To, Item_func::Functype Tag>
183To *item_cond_cast(Item *const from) {
184 return ((from->type() == Item::COND_ITEM &&
185 static_cast<Item_func *>(from)->functype() == Tag)
186 ? static_cast<To *>(from)
187 : nullptr);
188}
189
190/**
191 Flatten associative operators at parse time
192
193 This function flattens AND and OR operators at parse time if applicable,
194 otherwise it creates new Item_cond_and or Item_cond_or respectively.
195
196 Template parameter @p Class is @c Item_cond_and or @c Item_cond_or
197 Template parameter @p Tag is @c COND_AND_FUNC (for @c Item_cond_and) or @c
198 COND_OR_FUNC otherwise
199
200 @param mem_root MEM_ROOT
201 @param pos parse location
202 @param left left argument of the operator
203 @param right right argument of the operator
204
205 @return resulting parse tree Item
206*/
207template <class Class, Item_func::Functype Tag>
209 Item *left, Item *right) {
210 if (left == nullptr || right == nullptr) return nullptr;
211 Class *left_func = item_cond_cast<Class, Tag>(left);
212 Class *right_func = item_cond_cast<Class, Tag>(right);
213 if (left_func) {
214 if (right_func) {
215 // (X1 op X2) op (Y1 op Y2) ==> op (X1, X2, Y1, Y2)
216 right_func->add_at_head(left_func->argument_list());
217 return right;
218 } else {
219 // (X1 op X2) op Y ==> op (X1, X2, Y)
220 left_func->add(right);
221 return left;
222 }
223 } else if (right_func) {
224 // X op (Y1 op Y2) ==> op (X, Y1, Y2)
225 right_func->add_at_head(left);
226 return right;
227 } else {
228 /* X op Y */
229 return new (mem_root) Class(pos, left, right);
230 }
231}
232
234 class sp_variable *spv,
235 const char *query_start_ptr,
236 const char *start, const char *end);
237
238LEX_CSTRING make_string(THD *thd, const char *start_ptr, const char *end_ptr);
239void sp_create_assignment_lex(THD *thd, const char *option_ptr);
240bool sp_create_assignment_instr(THD *thd, const char *expr_end_ptr);
241bool resolve_engine(THD *thd, const LEX_CSTRING &name, bool is_temp_table,
242 bool strict, handlerton **ret);
245
246inline bool is_identifier(const char *str, const char *ident) {
247 return !my_strcasecmp(system_charset_info, str, ident);
248}
249
250inline bool is_identifier(const LEX_STRING &str, const char *ident) {
251 return is_identifier(str.str, ident);
252}
253
256 const LEX_CSTRING &name,
261
263
264#endif /* PARSE_TREE_HELPERS_INCLUDED */
Definition: item_func.h:93
virtual enum Functype functype() const
Definition: item_func.h:310
Definition: item.h:3581
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:802
Type
Definition: item.h:838
@ INVALID_ITEM
Definition: item.h:839
@ COND_ITEM
Definition: item.h:852
virtual enum Type type() const =0
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:425
Wrapper class for an Item list head, used to allocate Item lists in the parser in a context-independe...
Definition: parse_tree_helpers.h:104
bool is_empty() const
Definition: parse_tree_helpers.h:120
Item * operator[](uint index) const
Definition: parse_tree_helpers.h:150
mem_root_deque< Item * > value
Definition: parse_tree_helpers.h:110
Parse_tree_node super
Definition: parse_tree_helpers.h:105
Item * pop_front()
Definition: parse_tree_helpers.h:143
PT_item_list()
Definition: parse_tree_helpers.h:108
bool push_front(Item *item)
Definition: parse_tree_helpers.h:133
bool contextualize(Parse_context *pc) override
Definition: parse_tree_helpers.h:112
bool push_back(Item *item)
Definition: parse_tree_helpers.h:123
uint elements() const
Definition: parse_tree_helpers.h:121
Definition: parse_tree_nodes.h:728
Definition: parse_tree_nodes.h:1345
Base class for parse-time Item objects.
Definition: parse_tree_helpers.h:69
enum Type type() const override
Definition: parse_tree_helpers.h:73
Parse_tree_item(const POS &pos)
Definition: parse_tree_helpers.h:71
double val_real() override
Definition: parse_tree_helpers.h:74
my_decimal * val_decimal(my_decimal *) override
Definition: parse_tree_helpers.h:86
bool get_date(MYSQL_TIME *, uint) override
Definition: parse_tree_helpers.h:90
String * val_str(String *) override
Definition: parse_tree_helpers.h:82
bool get_time(MYSQL_TIME *) override
Definition: parse_tree_helpers.h:94
longlong val_int() override
Definition: parse_tree_helpers.h:78
Base class for parse tree nodes (excluding the Parse_tree_root hierarchy)
Definition: parse_tree_node_base.h:138
virtual bool contextualize(Context *pc)
Do all context-sensitive things and mark the node as contextualized.
Definition: parse_tree_node_base.h:186
enum_severity_level
Enumeration value describing the severity of the condition.
Definition: sql_error.h:62
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:166
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:922
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:109
my_decimal class limits 'decimal_t' type to what we need in MySQL.
Definition: my_decimal.h:93
This class represents a stored program variable or a parameter (also referenced as 'SP-variable').
Definition: sp_pcontext.h:48
static MEM_ROOT mem_root
Definition: client_plugin.cc:109
char * pos
Definition: do_ctype.cc:76
static void start(mysql_harness::PluginFuncEnv *env)
Definition: http_auth_backend_plugin.cc:176
A better implementation of the UNIX ctype(3) library.
MYSQL_PLUGIN_IMPORT CHARSET_INFO * system_charset_info
Definition: mysqld.cc:1534
#define my_strcasecmp(s, a, b)
Definition: m_ctype.h:711
Some integer typedefs for easier portability.
long long int longlong
Definition: my_inttypes.h:54
Time declarations shared between the server and client API: you should not add anything to this heade...
thread_local MEM_ROOT ** THR_MALLOC
Definition: mysqld.cc:1549
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1063
bool is_temp_table(const HA_CREATE_INFO &ci)
Definition: sql_table.cc:212
Type
Definition: resource_group_basic_types.h:32
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:191
LEX_CSTRING make_string(THD *thd, const char *start_ptr, const char *end_ptr)
Make a new string allocated on THD's mem-root.
Definition: parse_tree_helpers.cc:134
Item_splocal * create_item_for_sp_var(THD *thd, LEX_CSTRING name, class sp_variable *spv, const char *query_start_ptr, const char *start, const char *end)
Create an object to represent a SP variable in the Item-hierarchy.
Definition: parse_tree_helpers.cc:79
bool sp_create_assignment_instr(THD *thd, const char *expr_end_ptr)
Create a SP instruction for a SET assignment.
Definition: parse_tree_helpers.cc:202
bool apply_privileges(THD *thd, const Mem_root_array< class PT_role_or_privilege * > &privs)
This helper function is responsible for aggregating grants from parser tokens to containers and masks...
Definition: parse_tree_helpers.cc:317
void sp_create_assignment_lex(THD *thd, const char *option_ptr)
Definition: parse_tree_helpers.cc:139
Item * flatten_associative_operator(MEM_ROOT *mem_root, const POS &pos, Item *left, Item *right)
Flatten associative operators at parse time.
Definition: parse_tree_helpers.h:208
bool validate_vcpu_range(const resourcegroups::Range &range)
Definition: parse_tree_helpers.cc:373
bool check_resource_group_name_len(const LEX_CSTRING &name, Sql_condition::enum_severity_level severity)
Definition: parse_tree_helpers.cc:421
bool resolve_engine(THD *thd, const LEX_CSTRING &name, bool is_temp_table, bool strict, handlerton **ret)
Resolve engine by its name.
Definition: parse_tree_helpers.cc:288
bool contextualize_array(Context *pc, Array *array)
Contextualize a Mem_root_array of parse tree nodes of the type PTN.
Definition: parse_tree_helpers.h:165
To * item_cond_cast(Item *const from)
Helper function to imitate dynamic_cast for Item_cond hierarchy.
Definition: parse_tree_helpers.h:183
bool validate_resource_group_priority(THD *thd, int *priority, const LEX_CSTRING &name, const resourcegroups::Type &type)
Definition: parse_tree_helpers.cc:384
bool check_resource_group_support()
Definition: parse_tree_helpers.cc:411
bool is_identifier(const char *str, const char *ident)
Definition: parse_tree_helpers.h:246
void move_cf_appliers(Parse_context *tddlpc, Column_parse_context *cpc)
Definition: parse_tree_helpers.cc:436
Set_operator
Definition: parser_yystype.h:341
required uint32 priority
Definition: replication_group_member_actions.proto:34
required string type
Definition: replication_group_member_actions.proto:33
"public" interface to sys_var - server configuration variables.
case opt name
Definition: sslopt-case.h:32
Parse context for column type attribute specific parse tree nodes.
Definition: parse_tree_column_attrs.h:72
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:82
Definition: mysql_lex_string.h:39
Definition: mysql_lex_string.h:34
Definition: mysql_time.h:81
Environment data for the contextualization phase.
Definition: parse_tree_node_base.h:120
Bison "location" class.
Definition: parse_location.h:42
handlerton is a singleton structure - one instance per storage engine - to provide access to storage ...
Definition: handler.h:2594
Definition: gen_lex_token.cc:151
Definition: resource_group_basic_types.h:33
unsigned int uint
Definition: uca-dump.cc:29