mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-16 12:02:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/sql/sp.h
Alexander Barkov e1cd3c4033 MDEV-12252 ROW data type for stored function return values 
Adding support for the ROW data type in the stored function RETURNS clause:

- explicit ROW(..members...) for both sql_mode=DEFAULT and sql_mode=ORACLE

  CREATE FUNCTION f1() RETURNS ROW(a INT, b VARCHAR(32)) ...

- anchored "ROW TYPE OF [db1.]table1" declarations for sql_mode=DEFAULT

  CREATE FUNCTION f1() RETURNS ROW TYPE OF test.t1 ...

- anchored "[db1.]table1%ROWTYPE" declarations for sql_mode=ORACLE

  CREATE FUNCTION f1() RETURN test.t1%ROWTYPE ...

Adding support for anchored scalar data types in RETURNS clause:

- "TYPE OF [db1.]table1.column1" for sql_mode=DEFAULT

  CREATE FUNCTION f1() RETURNS TYPE OF test.t1.column1;

- "[db1.]table1.column1" for sql_mode=ORACLE

  CREATE FUNCTION f1() RETURN test.t1.column1%TYPE;

Details:

- Adding a new sql_mode_t parameter to
    sp_head::create()
    sp_head::sp_head()
    sp_package::create()
    sp_package::sp_package()
  to guarantee early initialization of sp_head::m_sql_mode.
  Before this change, this member was not initialized at all during
  CREATE FUNCTION/PROCEDURE/PACKAGE statements, and was not used.
  Now it needs to be initialized to write properly the
  mysql.proc.returns column, according to the create time sql_mode.

- Code refactoring to make the things simpler and functions smaller:

  * Adding a new method
    Field_row::row_create_fields(THD *thd, List<Spvar_definition> *list)
    to make a Virtual_tmp_table with Fields for ROW members
    from an explicit definition.

  * Adding a new method
    Field_row::row_create_fields(THD *thd, const Spvar_definition &def)
    to make a Virtual_tmp_table with Fields for ROW members
    from an explicit or a table anchored definition.

  * Adding a new method
    Item_args::add_array_of_item_field(THD *thd, const Virtual_tmp_table &vtable)
    to create and array of Item_field corresponding to all Field instances
    in a Virtual_tmp_table

  * Removing Item_field_row::row_create_items(). It was decomposed
    into the new methods described above.

  * Moving the code from the loop body in sp_rcontext::init_var_items()
    into a separate method Spvar_definition::make_item_field_row(),
    to make the code clearer (smaller functions).
    make_item_field_row() itself uses the new methods described above.

- Changing the data type of sp_head::m_return_field_def
  from Column_definition to Spvar_definition.
  So now it supports not only SQL column field types,
  but also explicit ROW and anchored ROW data types,
  as well as anchored column types.

- Adding a new Column_definition parameter to sp_head::create_result_field().
  Before this patch, create_result_field() took the definition only
  from m_return_field_def. Now it's also called with a local Column_definition
  variable which contains the explicit definition resolved from an
  anchored defition.

- Modifying sql_yacc.yy to support the new grammar.
  Adding new helper methods:
    * sf_return_fill_definition_row()
    * sf_return_fill_definition_rowtype_of()
    * sf_return_fill_definition_type_of()

- Fixing tests in:
  * Virtual_tmp_table::setup_field_pointers() in sql_select.cc
  * Send_field::normalize() in field.h
  * store_column_type()
  to prevent calling Type_handler_row::field_type(),
  which is implemented a DBUG_ASSERT(0).
  Before this patch the affected methods and functions were called only
  for scalar data types. Now ROW is also possible.

- Adding a new virtual method Field::cols()

- Overriding methods:
   Item_func_sp::cols()
   Item_func_sp::element_index()
   Item_func_sp::check_cols()
   Item_func_sp::bring_value()
  to support the ROW data type.

- Extending the rule sp_return_type to support
  * explicit ROW and anchored ROW data types
  * anchored scalar data types

- Overriding Field_row::sql_type() to print
  the data type of an explicit ROW.
2024-10-21 07:59:29 +04:00

708 lines
23 KiB
C++
Raw Blame History

/* -*- C++ -*- */
/* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
Copyright (c) 2009, 2020, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _SP_H_
#define _SP_H_
#include "my_global.h" /* NO_EMBEDDED_ACCESS_CHECKS */
#include "sql_string.h" // LEX_STRING
#include "sql_cmd.h"
#include "mdl.h"
class Field;
class Open_tables_backup;
class Open_tables_state;
class Query_arena;
class Query_tables_list;
class Sroutine_hash_entry;
class THD;
class sp_cache;
class sp_head;
class sp_package;
class sp_pcontext;
class sp_name;
class sp_expr_lex;
class Database_qualified_name;
struct st_sp_chistics;
class Stored_program_creation_ctx;
struct LEX;
struct TABLE;
struct TABLE_LIST;
typedef struct st_hash HASH;
template <typename T> class SQL_I_List;
/*
Values for the type enum. This reflects the order of the enum declaration
in the CREATE TABLE command.
See also storage/perfschema/my_thread.h
*/
enum enum_sp_type
{
SP_TYPE_FUNCTION=1,
SP_TYPE_PROCEDURE=2,
SP_TYPE_PACKAGE=3,
SP_TYPE_PACKAGE_BODY=4,
SP_TYPE_TRIGGER=5,
SP_TYPE_EVENT=6,
};
class Sp_handler
{
bool sp_resolve_package_routine_explicit(THD *thd,
sp_head *caller,
sp_name *name,
const Sp_handler **pkg_routine_hndlr,
Database_qualified_name *pkgname)
const;
bool sp_resolve_package_routine_implicit(THD *thd,
sp_head *caller,
sp_name *name,
const Sp_handler **pkg_routine_hndlr,
Database_qualified_name *pkgname)
const;
protected:
int db_find_routine_aux(THD *thd, const Database_qualified_name *name,
TABLE *table) const;
int db_find_routine(THD *thd, const Database_qualified_name *name,
sp_head **sphp) const;
int db_find_and_cache_routine(THD *thd,
const Database_qualified_name *name,
sp_head **sp) const;
int db_load_routine(THD *thd, const Database_qualified_name *name,
sp_head **sphp,
sql_mode_t sql_mode,
const LEX_CSTRING &params,
const LEX_CSTRING &returns,
const LEX_CSTRING &body,
const st_sp_chistics &chistics,
const AUTHID &definer,
longlong created, longlong modified,
sp_package *parent,
Stored_program_creation_ctx *creation_ctx) const;
int sp_drop_routine_internal(THD *thd,
const Database_qualified_name *name,
TABLE *table) const;
sp_head *sp_clone_and_link_routine(THD *thd,
const Database_qualified_name *name,
sp_head *sp) const;
int sp_cache_package_routine(THD *thd,
const LEX_CSTRING &pkgname_cstr,
const Database_qualified_name *name,
sp_head **sp) const;
int sp_cache_package_routine(THD *thd,
const Database_qualified_name *name,
sp_head **sp) const;
sp_head *sp_find_package_routine(THD *thd,
const LEX_CSTRING pkgname_str,
const Database_qualified_name *name,
bool cache_only) const;
sp_head *sp_find_package_routine(THD *thd,
const Database_qualified_name *name,
bool cache_only) const;
public: // TODO: make it private or protected
virtual int sp_find_and_drop_routine(THD *thd, TABLE *table,
const Database_qualified_name *name)
const;
public:
virtual ~Sp_handler() = default;
static const Sp_handler *handler(enum enum_sql_command cmd);
static const Sp_handler *handler(enum_sp_type type);
static const Sp_handler *handler(MDL_key::enum_mdl_namespace ns);
/*
Return a handler only those SP objects that store
definitions in the mysql.proc system table
*/
static const Sp_handler *handler_mysql_proc(enum_sp_type type)
{
const Sp_handler *sph= handler(type);
return sph ? sph->sp_handler_mysql_proc() : NULL;
}
const char *type_str() const { return type_lex_cstring().str; }
virtual const char *show_create_routine_col1_caption() const
{
DBUG_ASSERT(0);
return "";
}
virtual const char *show_create_routine_col3_caption() const
{
DBUG_ASSERT(0);
return "";
}
virtual const Sp_handler *package_routine_handler() const
{
return this;
}
virtual enum_sp_type type() const= 0;
virtual LEX_CSTRING type_lex_cstring() const= 0;
virtual enum_sql_command sqlcom_create() const= 0;
virtual enum_sql_command sqlcom_drop() const= 0;
virtual LEX_CSTRING empty_body_lex_cstring(sql_mode_t mode) const
{
static LEX_CSTRING m_empty_body= {STRING_WITH_LEN("???")};
DBUG_ASSERT(0);
return m_empty_body;
}
virtual MDL_key::enum_mdl_namespace get_mdl_type() const= 0;
virtual const Sp_handler *sp_handler_mysql_proc() const { return this; }
virtual sp_cache **get_cache(THD *) const { return NULL; }
#ifndef NO_EMBEDDED_ACCESS_CHECKS
virtual HASH *get_priv_hash() const { return NULL; }
#endif
virtual ulong recursion_depth(THD *thd) const { return 0; }
/**
Return appropriate error about recursion limit reaching
@param thd Thread handle
@param sp SP routine
@remark For functions and triggers we return error about
prohibited recursion. For stored procedures we
return about reaching recursion limit.
*/
virtual void recursion_level_error(THD *thd, const sp_head *sp) const
{
my_error(ER_SP_NO_RECURSION, MYF(0));
}
virtual bool add_instr_freturn(THD *thd, sp_head *sp,
sp_pcontext *spcont,
Item *item, sp_expr_lex *lex) const;
virtual bool add_instr_preturn(THD *thd, sp_head *sp,
sp_pcontext *spcont) const;
void add_used_routine(Query_tables_list *prelocking_ctx,
Query_arena *arena,
const Database_qualified_name *name) const;
bool sp_resolve_package_routine(THD *thd,
sp_head *caller,
sp_name *name,
const Sp_handler **pkg_routine_handler,
Database_qualified_name *pkgname) const;
virtual sp_head *sp_find_routine(THD *thd,
const Database_qualified_name *name,
bool cache_only) const;
virtual int sp_cache_routine(THD *thd, const Database_qualified_name *name,
sp_head **sp) const;
int sp_cache_routine_reentrant(THD *thd,
const Database_qualified_name *nm,
sp_head **sp) const;
bool sp_exist_routines(THD *thd, TABLE_LIST *procs) const;
bool sp_show_create_routine(THD *thd,
const Database_qualified_name *name) const;
bool sp_create_routine(THD *thd, const sp_head *sp) const;
int sp_update_routine(THD *thd, const Database_qualified_name *name,
const st_sp_chistics *chistics) const;
int sp_drop_routine(THD *thd, const Database_qualified_name *name) const;
sp_head *sp_load_for_information_schema(THD *thd, TABLE *proc_table,
const LEX_CSTRING &db,
const LEX_CSTRING &name,
const LEX_CSTRING &params,
const LEX_CSTRING &returns,
sql_mode_t sql_mode,
bool *free_sp_head) const;
/*
Make a SHOW CREATE statement.
@retval true on error
@retval false on success
*/
virtual bool show_create_sp(THD *thd, String *buf,
const LEX_CSTRING &db,
const LEX_CSTRING &name,
const LEX_CSTRING &params,
const LEX_CSTRING &returns,
const LEX_CSTRING &body,
const st_sp_chistics &chistics,
const AUTHID &definer,
const DDL_options_st ddl_options,
sql_mode_t sql_mode) const;
};
class Sp_handler_procedure: public Sp_handler
{
public:
enum_sp_type type() const override { return SP_TYPE_PROCEDURE; }
LEX_CSTRING type_lex_cstring() const override
{
static LEX_CSTRING m_type_str= { STRING_WITH_LEN("PROCEDURE")};
return m_type_str;
}
enum_sql_command sqlcom_create() const override
{
return SQLCOM_CREATE_PROCEDURE;
}
enum_sql_command sqlcom_drop() const override
{
return SQLCOM_DROP_PROCEDURE;
}
LEX_CSTRING empty_body_lex_cstring(sql_mode_t mode) const override;
const char *show_create_routine_col1_caption() const override
{
return "Procedure";
}
const char *show_create_routine_col3_caption() const override
{
return "Create Procedure";
}
MDL_key::enum_mdl_namespace get_mdl_type() const override
{
return MDL_key::PROCEDURE;
}
const Sp_handler *package_routine_handler() const override;
sp_cache **get_cache(THD *) const override;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
HASH *get_priv_hash() const override;
#endif
ulong recursion_depth(THD *thd) const override;
void recursion_level_error(THD *thd, const sp_head *sp) const override;
bool add_instr_preturn(THD *thd, sp_head *sp, sp_pcontext *spcont) const override;
};
class Sp_handler_package_procedure: public Sp_handler_procedure
{
public:
int sp_cache_routine(THD *thd, const Database_qualified_name *name,
sp_head **sp) const override
{
return sp_cache_package_routine(thd, name, sp);
}
sp_head *sp_find_routine(THD *thd,
const Database_qualified_name *name,
bool cache_only) const override
{
return sp_find_package_routine(thd, name, cache_only);
}
};
class Sp_handler_function: public Sp_handler
{
public:
enum_sp_type type() const override { return SP_TYPE_FUNCTION; }
LEX_CSTRING type_lex_cstring() const override
{
static LEX_CSTRING m_type_str= { STRING_WITH_LEN("FUNCTION")};
return m_type_str;
}
enum_sql_command sqlcom_create() const override
{
return SQLCOM_CREATE_FUNCTION;
}
enum_sql_command sqlcom_drop() const override
{
return SQLCOM_DROP_FUNCTION;
}
LEX_CSTRING empty_body_lex_cstring(sql_mode_t mode) const override;
const char *show_create_routine_col1_caption() const override
{
return "Function";
}
const char *show_create_routine_col3_caption() const override
{
return "Create Function";
}
MDL_key::enum_mdl_namespace get_mdl_type() const override
{
return MDL_key::FUNCTION;
}
const Sp_handler *package_routine_handler() const override;
sp_cache **get_cache(THD *) const override;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
HASH *get_priv_hash() const override;
#endif
bool add_instr_freturn(THD *thd, sp_head *sp, sp_pcontext *spcont,
Item *item, sp_expr_lex *lex) const override;
};
class Sp_handler_package_function: public Sp_handler_function
{
public:
int sp_cache_routine(THD *thd, const Database_qualified_name *name,
sp_head **sp) const override
{
return sp_cache_package_routine(thd, name, sp);
}
sp_head *sp_find_routine(THD *thd,
const Database_qualified_name *name,
bool cache_only) const override
{
return sp_find_package_routine(thd, name, cache_only);
}
};
class Sp_handler_package: public Sp_handler
{
public:
bool show_create_sp(THD *thd, String *buf,
const LEX_CSTRING &db,
const LEX_CSTRING &name,
const LEX_CSTRING &params,
const LEX_CSTRING &returns,
const LEX_CSTRING &body,
const st_sp_chistics &chistics,
const AUTHID &definer,
const DDL_options_st ddl_options,
sql_mode_t sql_mode) const override;
};
class Sp_handler_package_spec: public Sp_handler_package
{
public: // TODO: make it private or protected
int sp_find_and_drop_routine(THD *thd, TABLE *table,
const Database_qualified_name *name)
const override;
public:
enum_sp_type type() const override { return SP_TYPE_PACKAGE; }
LEX_CSTRING type_lex_cstring() const override
{
static LEX_CSTRING m_type_str= {STRING_WITH_LEN("PACKAGE")};
return m_type_str;
}
enum_sql_command sqlcom_create() const override
{
return SQLCOM_CREATE_PACKAGE;
}
enum_sql_command sqlcom_drop() const override
{
return SQLCOM_DROP_PACKAGE;
}
LEX_CSTRING empty_body_lex_cstring(sql_mode_t mode) const override
{
static LEX_CSTRING m_empty_body= {STRING_WITH_LEN("BEGIN END")};
return m_empty_body;
}
const char *show_create_routine_col1_caption() const override
{
return "Package";
}
const char *show_create_routine_col3_caption() const override
{
return "Create Package";
}
MDL_key::enum_mdl_namespace get_mdl_type() const override
{
return MDL_key::PACKAGE_BODY;
}
sp_cache **get_cache(THD *) const override;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
HASH *get_priv_hash() const override;
#endif
};
class Sp_handler_package_body: public Sp_handler_package
{
public:
enum_sp_type type() const override { return SP_TYPE_PACKAGE_BODY; }
LEX_CSTRING type_lex_cstring() const override
{
static LEX_CSTRING m_type_str= {STRING_WITH_LEN("PACKAGE BODY")};
return m_type_str;
}
enum_sql_command sqlcom_create() const override
{
return SQLCOM_CREATE_PACKAGE_BODY;
}
enum_sql_command sqlcom_drop() const override
{
return SQLCOM_DROP_PACKAGE_BODY;
}
LEX_CSTRING empty_body_lex_cstring(sql_mode_t mode) const override
{
static LEX_CSTRING m_empty_body= {STRING_WITH_LEN("BEGIN END")};
return m_empty_body;
}
const char *show_create_routine_col1_caption() const override
{
return "Package body";
}
const char *show_create_routine_col3_caption() const override
{
return "Create Package Body";
}
MDL_key::enum_mdl_namespace get_mdl_type() const override
{
return MDL_key::PACKAGE_BODY;
}
sp_cache **get_cache(THD *) const override;
#ifndef NO_EMBEDDED_ACCESS_CHECKS
HASH *get_priv_hash() const override;
#endif
};
class Sp_handler_trigger: public Sp_handler
{
public:
enum_sp_type type() const override { return SP_TYPE_TRIGGER; }
LEX_CSTRING type_lex_cstring() const override
{
static LEX_CSTRING m_type_str= { STRING_WITH_LEN("TRIGGER")};
return m_type_str;
}
enum_sql_command sqlcom_create() const override
{
return SQLCOM_CREATE_TRIGGER;
}
enum_sql_command sqlcom_drop() const override
{
return SQLCOM_DROP_TRIGGER;
}
MDL_key::enum_mdl_namespace get_mdl_type() const override
{
DBUG_ASSERT(0);
return MDL_key::TRIGGER;
}
const Sp_handler *sp_handler_mysql_proc() const override { return NULL; }
};
extern MYSQL_PLUGIN_IMPORT Sp_handler_function sp_handler_function;
extern MYSQL_PLUGIN_IMPORT Sp_handler_procedure sp_handler_procedure;
extern MYSQL_PLUGIN_IMPORT Sp_handler_package_spec sp_handler_package_spec;
extern MYSQL_PLUGIN_IMPORT Sp_handler_package_body sp_handler_package_body;
extern MYSQL_PLUGIN_IMPORT Sp_handler_package_function sp_handler_package_function;
extern MYSQL_PLUGIN_IMPORT Sp_handler_package_procedure sp_handler_package_procedure;
extern MYSQL_PLUGIN_IMPORT Sp_handler_trigger sp_handler_trigger;
inline const Sp_handler *Sp_handler::handler(enum_sql_command cmd)
{
switch (cmd) {
case SQLCOM_CREATE_PROCEDURE:
case SQLCOM_ALTER_PROCEDURE:
case SQLCOM_DROP_PROCEDURE:
case SQLCOM_SHOW_PROC_CODE:
case SQLCOM_SHOW_CREATE_PROC:
case SQLCOM_SHOW_STATUS_PROC:
return &sp_handler_procedure;
case SQLCOM_CREATE_SPFUNCTION:
case SQLCOM_ALTER_FUNCTION:
case SQLCOM_DROP_FUNCTION:
case SQLCOM_SHOW_FUNC_CODE:
case SQLCOM_SHOW_CREATE_FUNC:
case SQLCOM_SHOW_STATUS_FUNC:
return &sp_handler_function;
case SQLCOM_CREATE_PACKAGE:
case SQLCOM_DROP_PACKAGE:
case SQLCOM_SHOW_CREATE_PACKAGE:
case SQLCOM_SHOW_STATUS_PACKAGE:
return &sp_handler_package_spec;
case SQLCOM_CREATE_PACKAGE_BODY:
case SQLCOM_DROP_PACKAGE_BODY:
case SQLCOM_SHOW_CREATE_PACKAGE_BODY:
case SQLCOM_SHOW_STATUS_PACKAGE_BODY:
case SQLCOM_SHOW_PACKAGE_BODY_CODE:
return &sp_handler_package_body;
default:
break;
}
return NULL;
}
inline const Sp_handler *Sp_handler::handler(enum_sp_type type)
{
switch (type) {
case SP_TYPE_PROCEDURE:
return &sp_handler_procedure;
case SP_TYPE_FUNCTION:
return &sp_handler_function;
case SP_TYPE_PACKAGE:
return &sp_handler_package_spec;
case SP_TYPE_PACKAGE_BODY:
return &sp_handler_package_body;
case SP_TYPE_TRIGGER:
return &sp_handler_trigger;
case SP_TYPE_EVENT:
break;
}
return NULL;
}
inline const Sp_handler *Sp_handler::handler(MDL_key::enum_mdl_namespace type)
{
switch (type) {
case MDL_key::FUNCTION:
return &sp_handler_function;
case MDL_key::PROCEDURE:
return &sp_handler_procedure;
case MDL_key::PACKAGE_BODY:
return &sp_handler_package_body;
case MDL_key::BACKUP:
case MDL_key::SCHEMA:
case MDL_key::TABLE:
case MDL_key::TRIGGER:
case MDL_key::EVENT:
case MDL_key::USER_LOCK:
case MDL_key::NAMESPACE_END:
break;
}
return NULL;
}
/* Tells what SP_DEFAULT_ACCESS should be mapped to */
#define SP_DEFAULT_ACCESS_MAPPING SP_CONTAINS_SQL
// Return codes from sp_create_*, sp_drop_*, and sp_show_*:
#define SP_OK 0
#define SP_KEY_NOT_FOUND -1
#define SP_OPEN_TABLE_FAILED -2
#define SP_WRITE_ROW_FAILED -3
#define SP_DELETE_ROW_FAILED -4
#define SP_GET_FIELD_FAILED -5
#define SP_PARSE_ERROR -6
#define SP_INTERNAL_ERROR -7
#define SP_NO_DB_ERROR -8
#define SP_BAD_IDENTIFIER -9
#define SP_BODY_TOO_LONG -10
#define SP_FLD_STORE_FAILED -11
/* DB storage of Stored PROCEDUREs and FUNCTIONs */
enum
{
MYSQL_PROC_FIELD_DB = 0,
MYSQL_PROC_FIELD_NAME,
MYSQL_PROC_MYSQL_TYPE,
MYSQL_PROC_FIELD_SPECIFIC_NAME,
MYSQL_PROC_FIELD_LANGUAGE,
MYSQL_PROC_FIELD_ACCESS,
MYSQL_PROC_FIELD_DETERMINISTIC,
MYSQL_PROC_FIELD_SECURITY_TYPE,
MYSQL_PROC_FIELD_PARAM_LIST,
MYSQL_PROC_FIELD_RETURNS,
MYSQL_PROC_FIELD_BODY,
MYSQL_PROC_FIELD_DEFINER,
MYSQL_PROC_FIELD_CREATED,
MYSQL_PROC_FIELD_MODIFIED,
MYSQL_PROC_FIELD_SQL_MODE,
MYSQL_PROC_FIELD_COMMENT,
MYSQL_PROC_FIELD_CHARACTER_SET_CLIENT,
MYSQL_PROC_FIELD_COLLATION_CONNECTION,
MYSQL_PROC_FIELD_DB_COLLATION,
MYSQL_PROC_FIELD_BODY_UTF8,
MYSQL_PROC_FIELD_AGGREGATE,
MYSQL_PROC_FIELD_COUNT
};
/* Drop all routines in database 'db' */
int
sp_drop_db_routines(THD *thd, const LEX_CSTRING &db);
/**
Acquires exclusive metadata lock on all stored routines in the
given database.
@param thd Thread handler
@param db Database name
@retval false Success
@retval true Failure
*/
bool lock_db_routines(THD *thd, const Lex_ident_db_normalized &db);
/**
Structure that represents element in the set of stored routines
used by statement or routine.
*/
class Sroutine_hash_entry
{
public:
/**
Metadata lock request for routine.
MDL_key in this request is also used as a key for set.
*/
MDL_request mdl_request;
/**
Next element in list linking all routines in set. See also comments
for LEX::sroutine/sroutine_list and sp_head::m_sroutines.
*/
Sroutine_hash_entry *next;
/**
Uppermost view which directly or indirectly uses this routine.
0 if routine is not used in view. Note that it also can be 0 if
statement uses routine both via view and directly.
*/
TABLE_LIST *belong_to_view;
/**
This is for prepared statement validation purposes.
A statement looks up and pre-loads all its stored functions
at prepare. Later on, if a function is gone from the cache,
execute may fail.
Remember the version of sp_head at prepare to be able to
invalidate the prepared statement at execute if it
changes.
*/
ulong m_sp_cache_version;
const Sp_handler *m_handler;
int sp_cache_routine(THD *thd, sp_head **sp) const;
};
bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
const MDL_key *key,
const Sp_handler *handler,
TABLE_LIST *belong_to_view);
void sp_remove_not_own_routines(Query_tables_list *prelocking_ctx);
bool sp_update_sp_used_routines(HASH *dst, HASH *src);
void sp_update_stmt_used_routines(THD *thd, Query_tables_list *prelocking_ctx,
HASH *src, TABLE_LIST *belong_to_view);
void sp_update_stmt_used_routines(THD *thd, Query_tables_list *prelocking_ctx,
SQL_I_List<Sroutine_hash_entry> *src,
TABLE_LIST *belong_to_view);
extern "C" uchar* sp_sroutine_key(const uchar *ptr, size_t *plen,
my_bool first);
/*
Routines which allow open/lock and close mysql.proc table even when
we already have some tables open and locked.
*/
TABLE *open_proc_table_for_read(THD *thd);
bool load_charset(THD *thd,
MEM_ROOT *mem_root,
Field *field,
CHARSET_INFO *dflt_cs,
CHARSET_INFO **cs);
bool load_collation(THD *thd,MEM_ROOT *mem_root,
Field *field,
CHARSET_INFO *dflt_cl,
CHARSET_INFO **cl);
#endif /* _SP_H_ */
Reference in a new issue View git blame Copy permalink