MySQL 8.3.0
Source Code Documentation
sp.h
Go to the documentation of this file.
1/* Copyright (c) 2002, 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 _SP_H_
24#define _SP_H_
25
26#include <assert.h>
27#include <stddef.h>
28#include <stdint.h>
29#include <sys/types.h>
30
31#include <string>
32
33#include "field_types.h"
34#include "lex_string.h"
35#include "map_helpers.h"
36#include "my_inttypes.h"
38#include "sql/item.h" // Item::Type
39#include "sql/sp_head.h" // Stored_program_creation_ctx
40#include "sql/sql_lex.h"
41
43class Query_arena;
44class THD;
45struct CHARSET_INFO;
46struct LEX_USER;
47struct MEM_ROOT;
48
49namespace dd {
50class Routine;
51class Schema;
52} // namespace dd
53
54class Field;
56class String;
57class sp_cache;
58struct TABLE;
59class Table_ref;
60
61using sql_mode_t = uint64_t;
62template <typename T>
63class SQL_I_List;
64
65enum class enum_sp_type;
66
67/* Tells what SP_DEFAULT_ACCESS should be mapped to */
68#define SP_DEFAULT_ACCESS_MAPPING SP_CONTAINS_SQL
69
70/* Tells what SP_IS_DEFAULT_SUID should be mapped to */
71#define SP_DEFAULT_SUID_MAPPING SP_IS_SUID
72
73/* Max length(LONGBLOB field type length) of stored routine body */
74static const uint MYSQL_STORED_ROUTINE_BODY_LENGTH = 4294967295U;
75
76/* Max length(TEXT field type length) of stored routine comment */
77static const int MYSQL_STORED_ROUTINE_COMMENT_LENGTH = 65535;
78
80 SP_OK = 0,
81
82 // Schema does not exists
84
85 // Routine does not exists
87
88 // Routine already exists
90
91 // Create routine failed
93
94 // Drop routine failed
96
97 // Routine load failed
99
100 // Routine parse failed
102
103 // Internal errors
106
107/*
108 Fields in mysql.proc table in 5.7. This enum is used to read and
109 update mysql.routines dictionary table during upgrade scenario.
110
111 Note: This enum should not be used for other purpose
112 as it will be removed eventually.
113*/
114enum {
137
138/*************************************************************************/
139
140/**
141 Stored_routine_creation_ctx -- creation context of stored routines
142 (stored procedures and functions).
143*/
144
146 public:
148 const dd::Routine *routine);
149
151 const sp_name *name,
152 TABLE *proc_tbl);
153
154 public:
156
157 protected:
158 Object_creation_ctx *create_backup_ctx(THD *thd) const override;
159 void delete_backup_ctx() override;
160
161 private:
164
166 const CHARSET_INFO *connection_cl,
167 const CHARSET_INFO *db_cl)
168 : Stored_program_creation_ctx(client_cs, connection_cl, db_cl) {}
169};
170
171/* Drop all routines in database 'db' */
172bool sp_drop_db_routines(THD *thd, const dd::Schema &schema);
173
174/**
175 Acquires exclusive metadata lock on all stored routines in the
176 given database.
177
178 @param thd Thread handler
179 @param schema Schema object
180
181 @retval false Success
182 @retval true Failure
183 */
184bool lock_db_routines(THD *thd, const dd::Schema &schema);
185
187 sp_cache **cp, bool cache_only);
188
190 sp_cache **cp);
191
193 bool lookup_only, sp_head **sp);
194
196 const sp_name *name, bool lookup_only,
197 sp_head **sp);
198
199bool sp_exist_routines(THD *thd, Table_ref *procs, bool is_proc);
200
202
204 THD *thd, enum_sp_type type, const char *sp_db, size_t sp_db_len,
205 const char *sp_name, size_t sp_name_len, sp_head **sphp,
206 sql_mode_t sql_mode, const char *params, const char *returns,
207 const char *body, st_sp_chistics *chistics, const char *definer_user,
208 const char *definer_host, longlong created, longlong modified,
209 Stored_program_creation_ctx *creation_ctx);
210
211bool sp_create_routine(THD *thd, sp_head *sp, const LEX_USER *definer,
212 bool if_not_exists, bool &sp_already_exists);
213
215 st_sp_chistics *chistics);
216
218
219/**
220 Structure that represents element in the set of stored routines
221 used by statement or routine.
222*/
223
225 public:
226 /**
227 Key identifying routine or other object added to the set.
228
229 Key format: "@<1-byte entry type@>@<db name@>\0@<routine/object name@>\0".
230
231 @note We use binary comparison for these keys as the @<db name@> component
232 requires case-sensitive comparison on --lower-case-table-names=0
233 systems. On systems where --lower-case-table-names > 0 database
234 names which passed to functions working with this set are already
235 lowercased. So binary comparison is equivalent to case-insensitive
236 comparison for them.
237 Routine names are case and accent insensitive. To achieve such
238 comparison we normalize routine names by converting their characters
239 to their sort weights (according to case and accent insensitive
240 collation). In this case, the actual routine name is also stored in
241 the member m_object_name.
242
243 @note For Foreign Key objects, '@<db name@>\0@<object name@>\0' part of the
244 key is compatible with keys used by MDL. So one can easily construct
245 MDL_key from this key.
246 */
247 char *m_key;
251
256 /**
257 Parent table in a foreign key on which child table there was insert
258 or update. We will lookup new values in parent, so need to acquire
259 SR lock on it.
260 */
262 /**
263 Child table in a foreign key with RESTRICT/NO ACTION as corresponding
264 rule and on which parent table there was delete or update.
265 We will check if old parent key is referenced by child table,
266 so need to acquire SR lock on it.
267 */
269 /**
270 Child table in a foreign key with CASCADE/SET NULL/SET DEFAULT as
271 'on update' rule, on which parent there was update, or with SET NULL/
272 SET DEFAULT as 'on delete' rule, on which parent there was delete.
273 We might need to update rows in child table, so we need to acquire
274 SW lock on it. We also need to take into account that child table
275 might be parent for some other FKs, so such update needs
276 to be handled recursively.
277 */
279 /**
280 Child table in a foreign key with CASCADE as 'on delete' rule for
281 which there was delete from the parent table.
282 We might need to delete rows from the child table, so we need to
283 acquire SW lock on it.
284 We also need to take into account that child table might be parent
285 for some other FKs, so such delete needs to be handled recursively
286 (and even might result in updates).
287 */
289 };
290
291 entry_type type() const { return (entry_type)m_key[0]; }
292 const char *db() const { return (char *)m_key + 1; }
293 size_t db_length() const { return m_db_length; }
294 const char *name() const {
296 : (char *)m_key + 1 + m_db_length + 1;
297 }
298 size_t name_length() const {
300 : m_key_length - 1U - m_db_length - 1U - 1U;
301 }
302 bool use_normalized_key() const {
303 return (type() == FUNCTION || type() == PROCEDURE || type() == TRIGGER);
304 }
305
306 const char *part_mdl_key() {
307 assert(!use_normalized_key());
308 return (char *)m_key + 1;
309 }
311 assert(!use_normalized_key());
312 return m_key_length - 1U;
313 }
314
315 /**
316 Next element in list linking all routines in set. See also comments
317 for LEX::sroutine/sroutine_list and sp_head::m_sroutines.
318 */
320 /**
321 Uppermost view which directly or indirectly uses this routine.
322 0 if routine is not used in view. Note that it also can be 0 if
323 statement uses routine both via view and directly.
324 */
326 /**
327 This is for prepared statement validation purposes.
328 A statement looks up and pre-loads all its stored functions
329 at prepare. Later on, if a function is gone from the cache,
330 execute may fail. Similarly, tables involved in referential
331 constraints are also prelocked.
332 Remember the version of the cached item at prepare to be able to
333 invalidate the prepared statement at execute if it
334 changes.
335 */
337};
338
339/*
340 Enum to indicate SP name normalization required when constructing a key
341 in sp_add_used_routine method.
342*/
344 LEAVE_AS_IS = 0, // No normalization needed.
345 LOWERCASE_NAME, // Lower case SP name.
346 UNACCENT_AND_LOWERCASE_NAME, // Lower case SP name and remove accent.
347};
348
349/*
350 Procedures for handling sets of stored routines used by statement or routine.
351*/
352bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
354 size_t db_length, const char *name, size_t name_length,
355 bool lowercase_db,
356 Sp_name_normalize_type name_normalize_type,
357 bool own_routine, Table_ref *belong_to_view);
358
359/**
360 Convenience wrapper around sp_add_used_routine() for most common case -
361 stored procedure or function which are explicitly used by the statement.
362*/
363
364inline bool sp_add_own_used_routine(Query_tables_list *prelocking_ctx,
365 Query_arena *arena,
367 sp_name *sp_name) {
370
371 return sp_add_used_routine(
372 prelocking_ctx, arena, type, sp_name->m_db.str, sp_name->m_db.length,
375}
376
379 THD *thd, Query_tables_list *prelocking_ctx,
381 Table_ref *belong_to_view);
382void sp_update_stmt_used_routines(THD *thd, Query_tables_list *prelocking_ctx,
384 Table_ref *belong_to_view);
385
386const uchar *sp_sroutine_key(const uchar *ptr, size_t *plen);
387
388bool load_charset(MEM_ROOT *mem_root, Field *field, const CHARSET_INFO *dflt_cs,
389 const CHARSET_INFO **cs);
390
392 const CHARSET_INFO *dflt_cl, const CHARSET_INFO **cl);
393
394///////////////////////////////////////////////////////////////////////////
395
397
398void sp_finish_parsing(THD *thd);
399
400///////////////////////////////////////////////////////////////////////////
401
405
406bool sp_check_name(LEX_STRING *ident);
407
408Table_ref *sp_add_to_query_tables(THD *thd, LEX *lex, const char *db,
409 const char *name);
410
411Item *sp_prepare_func_item(THD *thd, Item **it_addr);
412
413bool sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr);
414
415String *sp_get_item_value(THD *thd, Item *item, String *str);
416
417///////////////////////////////////////////////////////////////////////////
418
419#endif /* _SP_H_ */
Definition: field.h:574
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:933
Type
Definition: item.h:968
Object_creation_ctx – interface for creation context of database objects (views, stored routines,...
Definition: table.h:198
Definition: sql_class.h:347
Definition: sql_lex.h:2565
Simple intrusive linked list.
Definition: sql_list.h:46
Structure that represents element in the set of stored routines used by statement or routine.
Definition: sp.h:224
bool use_normalized_key() const
Definition: sp.h:302
entry_type type() const
Definition: sp.h:291
LEX_CSTRING m_object_name
Definition: sp.h:248
Table_ref * belong_to_view
Uppermost view which directly or indirectly uses this routine.
Definition: sp.h:325
Sroutine_hash_entry * next
Next element in list linking all routines in set.
Definition: sp.h:319
int64 m_cache_version
This is for prepared statement validation purposes.
Definition: sp.h:336
uint16 m_db_length
Definition: sp.h:250
const char * name() const
Definition: sp.h:294
const char * db() const
Definition: sp.h:292
size_t part_mdl_key_length()
Definition: sp.h:310
char * m_key
Key identifying routine or other object added to the set.
Definition: sp.h:247
entry_type
Definition: sp.h:252
@ FUNCTION
Definition: sp.h:253
@ FK_TABLE_ROLE_CHILD_UPDATE
Child table in a foreign key with CASCADE/SET NULL/SET DEFAULT as 'on update' rule,...
Definition: sp.h:278
@ FK_TABLE_ROLE_CHILD_DELETE
Child table in a foreign key with CASCADE as 'on delete' rule for which there was delete from the par...
Definition: sp.h:288
@ FK_TABLE_ROLE_PARENT_CHECK
Parent table in a foreign key on which child table there was insert or update.
Definition: sp.h:261
@ TRIGGER
Definition: sp.h:255
@ PROCEDURE
Definition: sp.h:254
@ FK_TABLE_ROLE_CHILD_CHECK
Child table in a foreign key with RESTRICT/NO ACTION as corresponding rule and on which parent table ...
Definition: sp.h:268
const char * part_mdl_key()
Definition: sp.h:306
uint16 m_key_length
Definition: sp.h:249
size_t db_length() const
Definition: sp.h:293
size_t name_length() const
Definition: sp.h:298
Stored_program_creation_ctx – base class for creation context of stored programs (stored routines,...
Definition: sp_head.h:91
Stored_routine_creation_ctx – creation context of stored routines (stored procedures and functions).
Definition: sp.h:145
Object_creation_ctx * create_backup_ctx(THD *thd) const override
Definition: sp.cc:248
static Stored_routine_creation_ctx * load_from_db(THD *thd, const sp_name *name, TABLE *proc_tbl)
Definition: sp.cc:185
static Stored_routine_creation_ctx * create_routine_creation_ctx(const dd::Routine *routine)
Definition: sp.cc:164
Stored_routine_creation_ctx(const CHARSET_INFO *client_cs, const CHARSET_INFO *connection_cl, const CHARSET_INFO *db_cl)
Definition: sp.h:165
Stored_program_creation_ctx * clone(MEM_ROOT *mem_root) override
Definition: sp.cc:242
void delete_backup_ctx() override
Definition: sp.cc:254
Stored_routine_creation_ctx(THD *thd)
Definition: sp.h:162
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
Definition: table.h:2853
Abstract base class for functions and procedures.
Definition: routine.h:60
Definition: schema.h:62
std::unordered_map, but with my_malloc, so that you can track the memory used using PSI memory keys.
Definition: map_helpers.h:156
Definition: sp_cache.cc:41
sp_head represents one instance of a stored program.
Definition: sp_head.h:382
Definition: sp_head.h:122
LEX_STRING m_name
Definition: sp_head.h:125
LEX_CSTRING m_db
Definition: sp_head.h:124
static MEM_ROOT mem_root
Definition: client_plugin.cc:113
uint64_t sql_mode_t
Definition: dd_event.h:38
This file contains the field type.
enum_field_types
Column types for MySQL Note: Keep include/mysql/components/services/bits/stored_program_bits....
Definition: field_types.h:54
enum_sp_type
enum_sp_type defines type codes of stored programs.
Definition: sql_lex.h:223
Some integer typedefs for easier portability.
unsigned char uchar
Definition: my_inttypes.h:51
int64_t int64
Definition: my_inttypes.h:67
long long int longlong
Definition: my_inttypes.h:54
uint16_t uint16
Definition: my_inttypes.h:64
static const char * sql_mode
Definition: mysqlslap.cc:198
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1065
borrowable::session_track::Schema< true > Schema
Definition: classic_protocol_session_track.h:288
Definition: commit_order_queue.h:33
The version of the current data dictionary table definitions.
Definition: dictionary_client.h:42
required string type
Definition: replication_group_member_actions.proto:33
Item_result sp_map_result_type(enum enum_field_types type)
Definition: sp.cc:2283
bool sp_check_name(LEX_STRING *ident)
Check that the name 'ident' is ok.
Definition: sp.cc:2495
bool sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr)
Evaluate an expression and store the result in the field.
Definition: sp.cc:2558
Table_ref * sp_add_to_query_tables(THD *thd, LEX *lex, const char *db, const char *name)
enum_sp_return_code sp_drop_routine(THD *thd, enum_sp_type type, sp_name *name)
Drops a stored routine.
Definition: sp.cc:925
void sp_update_stmt_used_routines(THD *thd, Query_tables_list *prelocking_ctx, malloc_unordered_map< std::string, Sroutine_hash_entry * > *src, Table_ref *belong_to_view)
Add contents of hash representing set of routines to the set of routines used by statement.
Definition: sp.cc:1915
sp_head * sp_setup_routine(THD *thd, enum_sp_type type, sp_name *name, sp_cache **cp)
Setup a cached routine for execution.
Definition: sp.cc:1569
void sp_remove_not_own_routines(Query_tables_list *prelocking_ctx)
Remove routines which are only indirectly used by statement from the set of routines used by this sta...
Definition: sp.cc:1882
Sp_name_normalize_type
Definition: sp.h:343
uint sp_get_flags_for_command(LEX *lex)
Definition: sp.cc:2335
bool load_charset(MEM_ROOT *mem_root, Field *field, const CHARSET_INFO *dflt_cs, const CHARSET_INFO **cs)
Definition: sp.cc:119
sp_head * sp_start_parsing(THD *thd, enum_sp_type sp_type, sp_name *sp_name)
Start parsing of a stored program.
Definition: sp.cc:2236
bool sp_show_create_routine(THD *thd, enum_sp_type type, sp_name *name)
Implement SHOW CREATE statement for stored routines.
Definition: sp.cc:1471
bool sp_create_routine(THD *thd, sp_head *sp, const LEX_USER *definer, bool if_not_exists, bool &sp_already_exists)
Creates a stored routine.
Definition: sp.cc:796
String * sp_get_item_value(THD *thd, Item *item, String *str)
Return a string representation of the Item value.
Definition: sp.cc:2626
Item * sp_prepare_func_item(THD *thd, Item **it_addr)
Prepare an Item for evaluation (call of fix_fields).
Definition: sp.cc:2524
bool lock_db_routines(THD *thd, const dd::Schema &schema)
Acquires exclusive metadata lock on all stored routines in the given database.
Definition: sp.cc:1177
Item::Type sp_map_item_type(enum enum_field_types type)
Definition: sp.cc:2305
enum_sp_return_code
Definition: sp.h:79
@ SP_ALREADY_EXISTS
Definition: sp.h:89
@ SP_INTERNAL_ERROR
Definition: sp.h:104
@ SP_NO_DB_ERROR
Definition: sp.h:83
@ SP_LOAD_FAILED
Definition: sp.h:98
@ SP_PARSE_ERROR
Definition: sp.h:101
@ SP_DOES_NOT_EXISTS
Definition: sp.h:86
@ SP_DROP_FAILED
Definition: sp.h:95
@ SP_STORE_FAILED
Definition: sp.h:92
@ SP_OK
Definition: sp.h:80
static const uint MYSQL_STORED_ROUTINE_BODY_LENGTH
Definition: sp.h:74
bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena, Sroutine_hash_entry::entry_type type, const char *db, size_t db_length, const char *name, size_t name_length, bool lowercase_db, Sp_name_normalize_type name_normalize_type, bool own_routine, Table_ref *belong_to_view)
Add routine or trigger which is used by statement to the set of stored routines used by this statemen...
Definition: sp.cc:1788
bool sp_drop_db_routines(THD *thd, const dd::Schema &schema)
Drop all routines in database 'db'.
Definition: sp.cc:1241
bool sp_update_routine(THD *thd, enum_sp_type type, sp_name *name, st_sp_chistics *chistics)
Updates(Alter) a stored routine.
Definition: sp.cc:1055
bool sp_exist_routines(THD *thd, Table_ref *procs, bool is_proc)
This is used by sql_acl.cc:mysql_routine_grant() and is used to find the routines in 'routines'.
Definition: sp.cc:1650
@ MYSQL_PROC_FIELD_PARAM_LIST
Definition: sp.h:123
@ MYSQL_PROC_FIELD_DETERMINISTIC
Definition: sp.h:121
@ MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT
Definition: sp.h:131
@ MYSQL_PROC_FIELD_RETURNS
Definition: sp.h:124
@ MYSQL_PROC_FIELD_SECURITY_TYPE
Definition: sp.h:122
@ MYSQL_PROC_FIELD_NAME
Definition: sp.h:116
@ MYSQL_PROC_FIELD_COUNT
Definition: sp.h:135
@ MYSQL_PROC_FIELD_LANGUAGE
Definition: sp.h:119
@ MYSQL_PROC_MYSQL_TYPE
Definition: sp.h:117
@ MYSQL_PROC_FIELD_SPECIFIC_NAME
Definition: sp.h:118
@ MYSQL_PROC_FIELD_COMMENT
Definition: sp.h:130
@ MYSQL_PROC_FIELD_SQL_MODE
Definition: sp.h:129
@ MYSQL_PROC_FIELD_DB_COLLATION
Definition: sp.h:133
@ MYSQL_PROC_FIELD_BODY
Definition: sp.h:125
@ MYSQL_PROC_FIELD_CREATED
Definition: sp.h:127
@ MYSQL_PROC_FIELD_ACCESS
Definition: sp.h:120
@ MYSQL_PROC_FIELD_COLLATION_CONNECTION
Definition: sp.h:132
@ MYSQL_PROC_FIELD_DB
Definition: sp.h:115
@ MYSQL_PROC_FIELD_MODIFIED
Definition: sp.h:128
@ MYSQL_PROC_FIELD_BODY_UTF8
Definition: sp.h:134
@ MYSQL_PROC_FIELD_DEFINER
Definition: sp.h:126
enum_sp_return_code sp_cache_routine(THD *thd, Sroutine_hash_entry *rt, bool lookup_only, sp_head **sp)
A helper wrapper around sp_cache_routine() to use from prelocking until 'sp_name' is eradicated as a ...
Definition: sp.cc:1957
enum_sp_return_code db_load_routine(THD *thd, enum_sp_type type, const char *sp_db, size_t sp_db_len, const char *sp_name, size_t sp_name_len, sp_head **sphp, sql_mode_t sql_mode, const char *params, const char *returns, const char *body, st_sp_chistics *chistics, const char *definer_user, const char *definer_host, longlong created, longlong modified, Stored_program_creation_ctx *creation_ctx)
Definition: sp.cc:497
bool sp_add_own_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena, Sroutine_hash_entry::entry_type type, sp_name *sp_name)
Convenience wrapper around sp_add_used_routine() for most common case - stored procedure or function ...
Definition: sp.h:364
void sp_finish_parsing(THD *thd)
Finish parsing of a stored program.
Definition: sp.cc:2272
bool load_collation(MEM_ROOT *mem_root, Field *field, const CHARSET_INFO *dflt_cl, const CHARSET_INFO **cl)
Definition: sp.cc:140
const uchar * sp_sroutine_key(const uchar *ptr, size_t *plen)
static const int MYSQL_STORED_ROUTINE_COMMENT_LENGTH
Definition: sp.h:77
sp_head * sp_find_routine(THD *thd, enum_sp_type type, sp_name *name, sp_cache **cp, bool cache_only)
Obtain object representing stored procedure/function by its name from stored procedures cache and loo...
Definition: sp.cc:1534
case opt name
Definition: sslopt-case.h:32
Definition: m_ctype.h:422
Definition: table.h:2720
The LEX object currently serves three different purposes:
Definition: sql_lex.h:3787
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
const char * str
Definition: mysql_lex_string.h:40
size_t length
Definition: mysql_lex_string.h:41
Definition: mysql_lex_string.h:34
char * str
Definition: mysql_lex_string.h:35
size_t length
Definition: mysql_lex_string.h:36
Definition: table.h:1403
Definition: sql_lex.h:2523
Item_result
Type of the user defined function return slot and arguments.
Definition: udf_registration_types.h:38