mirror of
https://github.com/MariaDB/server.git
synced 2025-10-31 02:46:29 +01:00
718 lines
23 KiB
C++
718 lines
23 KiB
C++
/* -*- 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 ¶ms,
|
|
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;
|
|
}
|
|
|
|
static bool eq_routine_name(const LEX_CSTRING &name1,
|
|
const LEX_CSTRING &name2)
|
|
{
|
|
return system_charset_info->strnncoll(name1.str, name1.length,
|
|
name2.str, name2.length) == 0;
|
|
}
|
|
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 ¶ms,
|
|
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 ¶ms,
|
|
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 ¶ms,
|
|
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" const uchar *sp_sroutine_key(const void *ptr, size_t *plen,
|
|
my_bool);
|
|
|
|
/*
|
|
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);
|
|
|
|
void sp_returns_type(THD *thd,
|
|
String &result,
|
|
const sp_head *sp);
|
|
|
|
#endif /* _SP_H_ */
|