1 /* Copyright (c) 2002, 2019, Oracle and/or its affiliates. All rights reserved.
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 <stddef.h>
27 #include <sys/types.h>
28 #include <string>
29
30 #include "field_types.h"
31 #include "lex_string.h"
32 #include "map_helpers.h"
33 #include "my_dbug.h"
34 #include "my_inttypes.h"
35 #include "mysql/udf_registration_types.h"
36 #include "sql/item.h" // Item::Type
37 #include "sql/sp_head.h" // Stored_program_creation_ctx
38 #include "sql/sql_lex.h"
39
40 class Object_creation_ctx;
41 class Query_arena;
42 class THD;
43 struct CHARSET_INFO;
44 struct LEX_USER;
45 struct MEM_ROOT;
46
47 namespace dd {
48 class Routine;
49 class Schema;
50 } // namespace dd
51
52 class Field;
53 class Sroutine_hash_entry;
54 class String;
55 class sp_cache;
56 struct TABLE;
57 struct TABLE_LIST;
58
59 typedef ulonglong sql_mode_t;
60 template <typename T>
61 class SQL_I_List;
62
63 enum class enum_sp_type;
64
65 /* Tells what SP_DEFAULT_ACCESS should be mapped to */
66 #define SP_DEFAULT_ACCESS_MAPPING SP_CONTAINS_SQL
67
68 /* Tells what SP_IS_DEFAULT_SUID should be mapped to */
69 #define SP_DEFAULT_SUID_MAPPING SP_IS_SUID
70
71 /* Max length(LONGBLOB field type length) of stored routine body */
72 static const uint MYSQL_STORED_ROUTINE_BODY_LENGTH = 4294967295U;
73
74 /* Max length(TEXT field type length) of stored routine comment */
75 static const int MYSQL_STORED_ROUTINE_COMMENT_LENGTH = 65535;
76
77 enum enum_sp_return_code {
78 SP_OK = 0,
79
80 // Schema does not exists
81 SP_NO_DB_ERROR,
82
83 // Routine does not exists
84 SP_DOES_NOT_EXISTS,
85
86 // Routine already exists
87 SP_ALREADY_EXISTS,
88
89 // Create routine failed
90 SP_STORE_FAILED,
91
92 // Drop routine failed
93 SP_DROP_FAILED,
94
95 // Routine load failed
96 SP_LOAD_FAILED,
97
98 // Routine parse failed
99 SP_PARSE_ERROR,
100
101 // Internal errors
102 SP_INTERNAL_ERROR
103 };
104
105 /*
106 Fields in mysql.proc table in 5.7. This enum is used to read and
107 update mysql.routines dictionary table during upgrade scenario.
108
109 Note: This enum should not be used for other purpose
110 as it will be removed eventually.
111 */
112 enum {
113 MYSQL_PROC_FIELD_DB = 0,
114 MYSQL_PROC_FIELD_NAME,
115 MYSQL_PROC_MYSQL_TYPE,
116 MYSQL_PROC_FIELD_SPECIFIC_NAME,
117 MYSQL_PROC_FIELD_LANGUAGE,
118 MYSQL_PROC_FIELD_ACCESS,
119 MYSQL_PROC_FIELD_DETERMINISTIC,
120 MYSQL_PROC_FIELD_SECURITY_TYPE,
121 MYSQL_PROC_FIELD_PARAM_LIST,
122 MYSQL_PROC_FIELD_RETURNS,
123 MYSQL_PROC_FIELD_BODY,
124 MYSQL_PROC_FIELD_DEFINER,
125 MYSQL_PROC_FIELD_CREATED,
126 MYSQL_PROC_FIELD_MODIFIED,
127 MYSQL_PROC_FIELD_SQL_MODE,
128 MYSQL_PROC_FIELD_COMMENT,
129 MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT,
130 MYSQL_PROC_FIELD_COLLATION_CONNECTION,
131 MYSQL_PROC_FIELD_DB_COLLATION,
132 MYSQL_PROC_FIELD_BODY_UTF8,
133 MYSQL_PROC_FIELD_COUNT
134 };
135
136 /*************************************************************************/
137
138 /**
139 Stored_routine_creation_ctx -- creation context of stored routines
140 (stored procedures and functions).
141 */
142
143 class Stored_routine_creation_ctx : public Stored_program_creation_ctx {
144 public:
145 static Stored_routine_creation_ctx *create_routine_creation_ctx(
146 const dd::Routine *routine);
147
148 static Stored_routine_creation_ctx *load_from_db(THD *thd,
149 const sp_name *name,
150 TABLE *proc_tbl);
151
152 public:
153 Stored_program_creation_ctx *clone(MEM_ROOT *mem_root) override;
154
155 protected:
156 Object_creation_ctx *create_backup_ctx(THD *thd) const override;
157 void delete_backup_ctx() override;
158
159 private:
Stored_routine_creation_ctx(THD * thd)160 explicit Stored_routine_creation_ctx(THD *thd)
161 : Stored_program_creation_ctx(thd) {}
162
Stored_routine_creation_ctx(const CHARSET_INFO * client_cs,const CHARSET_INFO * connection_cl,const CHARSET_INFO * db_cl)163 Stored_routine_creation_ctx(const CHARSET_INFO *client_cs,
164 const CHARSET_INFO *connection_cl,
165 const CHARSET_INFO *db_cl)
166 : Stored_program_creation_ctx(client_cs, connection_cl, db_cl) {}
167 };
168
169 /* Drop all routines in database 'db' */
170 enum_sp_return_code sp_drop_db_routines(THD *thd, const dd::Schema &schema);
171
172 /**
173 Acquires exclusive metadata lock on all stored routines in the
174 given database.
175
176 @param thd Thread handler
177 @param schema Schema object
178
179 @retval false Success
180 @retval true Failure
181 */
182 bool lock_db_routines(THD *thd, const dd::Schema &schema);
183
184 sp_head *sp_find_routine(THD *thd, enum_sp_type type, sp_name *name,
185 sp_cache **cp, bool cache_only);
186
187 sp_head *sp_setup_routine(THD *thd, enum_sp_type type, sp_name *name,
188 sp_cache **cp);
189
190 enum_sp_return_code sp_cache_routine(THD *thd, Sroutine_hash_entry *rt,
191 bool lookup_only, sp_head **sp);
192
193 enum_sp_return_code sp_cache_routine(THD *thd, enum_sp_type type, sp_name *name,
194 bool lookup_only, sp_head **sp);
195
196 bool sp_exist_routines(THD *thd, TABLE_LIST *procs, bool is_proc);
197
198 bool sp_show_create_routine(THD *thd, enum_sp_type type, sp_name *name);
199
200 enum_sp_return_code db_load_routine(
201 THD *thd, enum_sp_type type, const char *sp_db, size_t sp_db_len,
202 const char *sp_name, size_t sp_name_len, sp_head **sphp,
203 sql_mode_t sql_mode, const char *params, const char *returns,
204 const char *body, st_sp_chistics *chistics, const char *definer_user,
205 const char *definer_host, longlong created, longlong modified,
206 Stored_program_creation_ctx *creation_ctx);
207
208 bool sp_create_routine(THD *thd, sp_head *sp, const LEX_USER *definer);
209
210 bool sp_update_routine(THD *thd, enum_sp_type type, sp_name *name,
211 st_sp_chistics *chistics);
212
213 enum_sp_return_code sp_drop_routine(THD *thd, enum_sp_type type, sp_name *name);
214
215 /**
216 Structure that represents element in the set of stored routines
217 used by statement or routine.
218 */
219
220 class Sroutine_hash_entry {
221 public:
222 /**
223 Key identifying routine or other object added to the set.
224
225 Key format: "@<1-byte entry type@>@<db name@>\0@<routine/object name@>\0".
226
227 @note We use binary comparison for these keys as the @<db name@> component
228 requires case-sensitive comparison on --lower-case-table-names=0
229 systems. On systems where --lower-case-table-names > 0 database
230 names which passed to functions working with this set are already
231 lowercased. So binary comparison is equivalent to case-insensitive
232 comparison for them.
233 Routine names are case and accent insensitive. To achieve such
234 comparison we normalize routine names by converting their characters
235 to their sort weights (according to case and accent insensitive
236 collation). In this case, the actual routine name is also stored in
237 the member m_object_name.
238
239 @note For Foreign Key objects, '@<db name@>\0@<object name@>\0' part of the
240 key is compatible with keys used by MDL. So one can easily construct
241 MDL_key from this key.
242 */
243 char *m_key;
244 LEX_CSTRING m_object_name;
245 uint16 m_key_length;
246 uint16 m_db_length;
247
248 enum entry_type {
249 FUNCTION,
250 PROCEDURE,
251 TRIGGER,
252 /**
253 Parent table in a foreign key on which child table there was insert
254 or update. We will lookup new values in parent, so need to acquire
255 SR lock on it.
256 */
257 FK_TABLE_ROLE_PARENT_CHECK,
258 /**
259 Child table in a foreign key with RESTRICT/NO ACTION as corresponding
260 rule and on which parent table there was delete or update.
261 We will check if old parent key is referenced by child table,
262 so need to acquire SR lock on it.
263 */
264 FK_TABLE_ROLE_CHILD_CHECK,
265 /**
266 Child table in a foreign key with CASCADE/SET NULL/SET DEFAULT as
267 'on update' rule, on which parent there was update, or with SET NULL/
268 SET DEFAULT as 'on delete' rule, on which parent there was delete.
269 We might need to update rows in child table, so we need to acquire
270 SW lock on it. We also need to take into account that child table
271 might be parent for some other FKs, so such update needs
272 to be handled recursively.
273 */
274 FK_TABLE_ROLE_CHILD_UPDATE,
275 /**
276 Child table in a foreign key with CASCADE as 'on delete' rule for
277 which there was delete from the parent table.
278 We might need to delete rows from the child table, so we need to
279 acquire SW lock on it.
280 We also need to take into account that child table might be parent
281 for some other FKs, so such delete needs to be handled recursively
282 (and even might result in updates).
283 */
284 FK_TABLE_ROLE_CHILD_DELETE
285 };
286
type()287 entry_type type() const { return (entry_type)m_key[0]; }
db()288 const char *db() const { return (char *)m_key + 1; }
db_length()289 size_t db_length() const { return m_db_length; }
name()290 const char *name() const {
291 return use_normalized_key() ? m_object_name.str
292 : (char *)m_key + 1 + m_db_length + 1;
293 }
name_length()294 size_t name_length() const {
295 return use_normalized_key() ? m_object_name.length
296 : m_key_length - 1U - m_db_length - 1U - 1U;
297 }
use_normalized_key()298 bool use_normalized_key() const {
299 return (type() == FUNCTION || type() == PROCEDURE || type() == TRIGGER);
300 }
301
part_mdl_key()302 const char *part_mdl_key() {
303 DBUG_ASSERT(!use_normalized_key());
304 return (char *)m_key + 1;
305 }
part_mdl_key_length()306 size_t part_mdl_key_length() {
307 DBUG_ASSERT(!use_normalized_key());
308 return m_key_length - 1U;
309 }
310
311 /**
312 Next element in list linking all routines in set. See also comments
313 for LEX::sroutine/sroutine_list and sp_head::m_sroutines.
314 */
315 Sroutine_hash_entry *next;
316 /**
317 Uppermost view which directly or indirectly uses this routine.
318 0 if routine is not used in view. Note that it also can be 0 if
319 statement uses routine both via view and directly.
320 */
321 TABLE_LIST *belong_to_view;
322 /**
323 This is for prepared statement validation purposes.
324 A statement looks up and pre-loads all its stored functions
325 at prepare. Later on, if a function is gone from the cache,
326 execute may fail. Similarly, tables involved in referential
327 constraints are also prelocked.
328 Remember the version of the cached item at prepare to be able to
329 invalidate the prepared statement at execute if it
330 changes.
331 */
332 int64 m_cache_version;
333 };
334
335 /*
336 Enum to indicate SP name normalization required when constructing a key
337 in sp_add_used_routine method.
338 */
339 enum class Sp_name_normalize_type {
340 LEAVE_AS_IS = 0, // No normalization needed.
341 LOWERCASE_NAME, // Lower case SP name.
342 UNACCENT_AND_LOWERCASE_NAME, // Lower case SP name and remove accent.
343 };
344
345 /*
346 Procedures for handling sets of stored routines used by statement or routine.
347 */
348 bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
349 Sroutine_hash_entry::entry_type type, const char *db,
350 size_t db_length, const char *name, size_t name_length,
351 bool lowercase_db,
352 Sp_name_normalize_type name_normalize_type,
353 bool own_routine, TABLE_LIST *belong_to_view);
354
355 /**
356 Convenience wrapper around sp_add_used_routine() for most common case -
357 stored procedure or function which are explicitly used by the statement.
358 */
359
sp_add_own_used_routine(Query_tables_list * prelocking_ctx,Query_arena * arena,Sroutine_hash_entry::entry_type type,sp_name * sp_name)360 inline bool sp_add_own_used_routine(Query_tables_list *prelocking_ctx,
361 Query_arena *arena,
362 Sroutine_hash_entry::entry_type type,
363 sp_name *sp_name) {
364 DBUG_ASSERT(type == Sroutine_hash_entry::FUNCTION ||
365 type == Sroutine_hash_entry::PROCEDURE);
366
367 return sp_add_used_routine(
368 prelocking_ctx, arena, type, sp_name->m_db.str, sp_name->m_db.length,
369 sp_name->m_name.str, sp_name->m_name.length, false,
370 Sp_name_normalize_type::UNACCENT_AND_LOWERCASE_NAME, true, nullptr);
371 }
372
373 void sp_remove_not_own_routines(Query_tables_list *prelocking_ctx);
374 void sp_update_stmt_used_routines(
375 THD *thd, Query_tables_list *prelocking_ctx,
376 malloc_unordered_map<std::string, Sroutine_hash_entry *> *src,
377 TABLE_LIST *belong_to_view);
378 void sp_update_stmt_used_routines(THD *thd, Query_tables_list *prelocking_ctx,
379 SQL_I_List<Sroutine_hash_entry> *src,
380 TABLE_LIST *belong_to_view);
381
382 const uchar *sp_sroutine_key(const uchar *ptr, size_t *plen);
383
384 sp_head *sp_load_for_information_schema(THD *thd, LEX_CSTRING db_name,
385 const dd::Routine *routine,
386 bool *free_sp_head);
387
388 bool load_charset(MEM_ROOT *mem_root, Field *field, const CHARSET_INFO *dflt_cs,
389 const CHARSET_INFO **cs);
390
391 bool load_collation(MEM_ROOT *mem_root, Field *field,
392 const CHARSET_INFO *dflt_cl, const CHARSET_INFO **cl);
393
394 ///////////////////////////////////////////////////////////////////////////
395
396 sp_head *sp_start_parsing(THD *thd, enum_sp_type sp_type, sp_name *sp_name);
397
398 void sp_finish_parsing(THD *thd);
399
400 ///////////////////////////////////////////////////////////////////////////
401
402 Item_result sp_map_result_type(enum enum_field_types type);
403 Item::Type sp_map_item_type(enum enum_field_types type);
404 uint sp_get_flags_for_command(LEX *lex);
405
406 bool sp_check_name(LEX_STRING *ident);
407
408 TABLE_LIST *sp_add_to_query_tables(THD *thd, LEX *lex, const char *db,
409 const char *name);
410
411 Item *sp_prepare_func_item(THD *thd, Item **it_addr);
412
413 bool sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr);
414
415 String *sp_get_item_value(THD *thd, Item *item, String *str);
416
417 ///////////////////////////////////////////////////////////////////////////
418
419 #endif /* _SP_H_ */
420