MySQL 8.2.0
Source Code Documentation
parse_tree_helpers.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_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
32#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:
108 explicit PT_item_list(const POS &pos) : super(pos), value(*THR_MALLOC) {}
109 explicit PT_item_list(const POS &start_pos, const POS &end_pos)
110 : super(start_pos, end_pos), value(*THR_MALLOC) {}
111
113
114 bool do_contextualize(Parse_context *pc) override {
115 if (super::do_contextualize(pc)) return true;
116 for (Item *&item : value) {
117 if (item->itemize(pc, &item)) return true;
118 }
119 return false;
120 }
121
122 bool is_empty() const { return value.empty(); }
123 uint elements() const { return value.size(); }
124
125 bool push_back(Item *item) {
126 /*
127 Item may be NULL in case of OOM: just ignore it and check thd->is_error()
128 in the caller code.
129 */
130 if (item == nullptr) return true;
131 value.push_back(item);
132 return false;
133 }
134
135 bool push_front(Item *item) {
136 /*
137 Item may be NULL in case of OOM: just ignore it and check thd->is_error()
138 in the caller code.
139 */
140 if (item == nullptr) return true;
141 value.push_front(item);
142 return false;
143 }
144
146 assert(!is_empty());
147 Item *ret = value.front();
148 value.pop_front();
149 return ret;
150 }
151
152 Item *operator[](uint index) const { return value[index]; }
153};
154
155/**
156 Contextualize a Mem_root_array of parse tree nodes of the type PTN
157
158 @tparam Context Parse context.
159 @tparam Array Array of parse tree nodes.
160
161 @param[in,out] pc Parse context.
162 @param[in,out] array Array of nodes to contextualize.
163
164 @return false on success.
165*/
166template <typename Context, typename Array>
167bool contextualize_array(Context *pc, Array *array) {
168 for (auto it : *array) {
169 if (pc->thd->lex->will_contextualize && it->contextualize(pc)) return true;
170 }
171 return false;
172}
173
174/**
175 Helper function to imitate dynamic_cast for Item_cond hierarchy.
176
177 Template parameter @p To is the destination type (@c Item_cond_and etc.)
178 Template parameter @p Tag is the Functype tag to compare from->functype() with
179
180 @param from source item
181
182 @return typecasted item of the type To or NULL
183*/
184template <class To, Item_func::Functype Tag>
185To *item_cond_cast(Item *const from) {
186 return ((from->type() == Item::COND_ITEM &&
187 static_cast<Item_func *>(from)->functype() == Tag)
188 ? static_cast<To *>(from)
189 : nullptr);
190}
191
192/**
193 Flatten associative operators at parse time
194
195 This function flattens AND and OR operators at parse time if applicable,
196 otherwise it creates new Item_cond_and or Item_cond_or respectively.
197
198 Template parameter @p Class is @c Item_cond_and or @c Item_cond_or
199 Template parameter @p Tag is @c COND_AND_FUNC (for @c Item_cond_and) or @c
200 COND_OR_FUNC otherwise
201
202 @param mem_root MEM_ROOT
203 @param pos parse location
204 @param left left argument of the operator
205 @param right right argument of the operator
206
207 @return resulting parse tree Item
208*/
209template <class Class, Item_func::Functype Tag>
211 Item *left, Item *right) {
212 if (left == nullptr || right == nullptr) return nullptr;
213 Class *left_func = item_cond_cast<Class, Tag>(left);
214 Class *right_func = item_cond_cast<Class, Tag>(right);
215 if (left_func) {
216 if (right_func) {
217 // (X1 op X2) op (Y1 op Y2) ==> op (X1, X2, Y1, Y2)
218 right_func->add_at_head(left_func->argument_list());
219 return right;
220 } else {
221 // (X1 op X2) op Y ==> op (X1, X2, Y)
222 left_func->add(right);
223 return left;
224 }
225 } else if (right_func) {
226 // X op (Y1 op Y2) ==> op (X, Y1, Y2)
227 right_func->add_at_head(left);
228 return right;
229 } else {
230 /* X op Y */
231 return new (mem_root) Class(pos, left, right);
232 }
233}
234
236 class sp_variable *spv,
237 const char *query_start_ptr,
238 const char *start, const char *end);
239
240LEX_CSTRING make_string(THD *thd, const char *start_ptr, const char *end_ptr);
241void sp_create_assignment_lex(THD *thd, const char *option_ptr);
242bool sp_create_assignment_instr(THD *thd, const char *expr_end_ptr);
243bool resolve_engine(THD *thd, const LEX_CSTRING &name, bool is_temp_table,
244 bool strict, handlerton **ret);
247
248inline bool is_identifier(const char *str, const char *ident) {
249 return !my_strcasecmp(system_charset_info, str, ident);
250}
251
252inline bool is_identifier(const LEX_STRING &str, const char *ident) {
253 return is_identifier(str.str, ident);
254}
255
258 const LEX_CSTRING &name,
263
265
266#endif /* PARSE_TREE_HELPERS_INCLUDED */
Definition: item_func.h:100
virtual enum Functype functype() const
Definition: item_func.h:323
Definition: item.h:3865
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:932
Type
Definition: item.h:967
@ INVALID_ITEM
Definition: item.h:968
@ COND_ITEM
Definition: item.h:981
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:122
Item * operator[](uint index) const
Definition: parse_tree_helpers.h:152
mem_root_deque< Item * > value
Definition: parse_tree_helpers.h:112
Parse_tree_node super
Definition: parse_tree_helpers.h:105
Item * pop_front()
Definition: parse_tree_helpers.h:145
PT_item_list(const POS &pos)
Definition: parse_tree_helpers.h:108
bool push_front(Item *item)
Definition: parse_tree_helpers.h:135
bool push_back(Item *item)
Definition: parse_tree_helpers.h:125
PT_item_list(const POS &start_pos, const POS &end_pos)
Definition: parse_tree_helpers.h:109
uint elements() const
Definition: parse_tree_helpers.h:123
bool do_contextualize(Parse_context *pc) override
Definition: parse_tree_helpers.h:114
Definition: parse_tree_nodes.h:796
Definition: parse_tree_nodes.h:1462
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:229
virtual bool do_contextualize(Context *pc)
Do all context-sensitive things and mark the node as contextualized.
Definition: parse_tree_node_base.h:281
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_lexer_thd.h:35
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:94
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:113
static void start(mysql_harness::PluginFuncEnv *env)
Definition: http_auth_backend_plugin.cc:176
A better implementation of the UNIX ctype(3) library.
int my_strcasecmp(const CHARSET_INFO *cs, const char *s1, const char *s2)
Definition: m_ctype.h:655
MYSQL_PLUGIN_IMPORT CHARSET_INFO * system_charset_info
Definition: mysqld.cc:1558
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:1573
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1085
bool is_temp_table(const HA_CREATE_INFO &ci)
Definition: sql_table.cc:220
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:136
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:81
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:204
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:319
void sp_create_assignment_lex(THD *thd, const char *option_ptr)
Definition: parse_tree_helpers.cc:141
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:210
bool validate_vcpu_range(const resourcegroups::Range &range)
Definition: parse_tree_helpers.cc:375
bool check_resource_group_name_len(const LEX_CSTRING &name, Sql_condition::enum_severity_level severity)
Definition: parse_tree_helpers.cc:423
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:290
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:167
To * item_cond_cast(Item *const from)
Helper function to imitate dynamic_cast for Item_cond hierarchy.
Definition: parse_tree_helpers.h:185
bool validate_resource_group_priority(THD *thd, int *priority, const LEX_CSTRING &name, const resourcegroups::Type &type)
Definition: parse_tree_helpers.cc:386
bool check_resource_group_support()
Definition: parse_tree_helpers.cc:413
bool is_identifier(const char *str, const char *ident)
Definition: parse_tree_helpers.h:248
void move_cf_appliers(Parse_context *tddlpc, Column_parse_context *cpc)
Definition: parse_tree_helpers.cc:438
Set_operator
Definition: parser_yystype.h:337
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
Bison "location" class.
Definition: parse_location.h:42
Environment data for the contextualization phase.
Definition: parse_tree_node_base.h:418
handlerton is a singleton structure - one instance per storage engine - to provide access to storage ...
Definition: handler.h:2692
Definition: gen_lex_token.cc:148
Definition: resource_group_basic_types.h:33