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