1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

MDEV-20764 Add MariaDB_FUNCTION_COLLECTION_PLUGIN

Browse Source
This commit is contained in:
Alexander Barkov 2019-10-07 10:46:25 +04:00
parent 3616175fdd
commit cbf6beba40
14 changed files with 1072 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cmake/abi_check.cmake
View File

@ -46,6 +46,7 @@ IF(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang" AND RUN_ABI_CHECK)
${CMAKE_SOURCE_DIR}/include/mysql/plugin_password_validation.h ${CMAKE_SOURCE_DIR}/include/mysql/plugin_password_validation.h
${CMAKE_SOURCE_DIR}/include/mysql/plugin_encryption.h ${CMAKE_SOURCE_DIR}/include/mysql/plugin_encryption.h
${CMAKE_SOURCE_DIR}/include/mysql/plugin_data_type.h ${CMAKE_SOURCE_DIR}/include/mysql/plugin_data_type.h
${CMAKE_SOURCE_DIR}/include/mysql/plugin_function_collection.h
) )
ADD_CUSTOM_TARGET(abi_check ALL ADD_CUSTOM_TARGET(abi_check ALL

3
include/mysql/plugin.h
View File

@ -90,12 +90,13 @@ typedef struct st_mysql_xid MYSQL_XID;
#define MYSQL_AUDIT_PLUGIN 5 #define MYSQL_AUDIT_PLUGIN 5
#define MYSQL_REPLICATION_PLUGIN 6 #define MYSQL_REPLICATION_PLUGIN 6
#define MYSQL_AUTHENTICATION_PLUGIN 7 #define MYSQL_AUTHENTICATION_PLUGIN 7
#define MYSQL_MAX_PLUGIN_TYPE_NUM 11 /* The number of plugin types */ #define MYSQL_MAX_PLUGIN_TYPE_NUM 12 /* The number of plugin types */
/* MariaDB plugin types */ /* MariaDB plugin types */
#define MariaDB_PASSWORD_VALIDATION_PLUGIN 8 #define MariaDB_PASSWORD_VALIDATION_PLUGIN 8
#define MariaDB_ENCRYPTION_PLUGIN 9 #define MariaDB_ENCRYPTION_PLUGIN 9
#define MariaDB_DATA_TYPE_PLUGIN 10 #define MariaDB_DATA_TYPE_PLUGIN 10
#define MariaDB_FUNCTION_COLLECTION_PLUGIN 11
/* We use the following strings to define licenses for plugins */ /* We use the following strings to define licenses for plugins */
#define PLUGIN_LICENSE_PROPRIETARY 0 #define PLUGIN_LICENSE_PROPRIETARY 0

101
include/mysql/plugin_function_collection.h Normal file
View File

@ -0,0 +1,101 @@
#ifndef MARIADB_PLUGIN_FUNCTION_COLLECTION_INCLUDED
#define MARIADB_PLUGIN_FUNCTION_COLLECTION_INCLUDED
/* Copyright (C) 2019, Alexander Barkov and MariaDB
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 */
/**
@file
Data Type Plugin API.
This file defines the API for server plugins that manage function collections.
*/
#ifdef __cplusplus
#include <mysql/plugin.h>
/*
API for data type plugins. (MariaDB_FUNCTION_COLLECTION_PLUGIN)
*/
#define MariaDB_FUNCTION_COLLECTION_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
class Native_func_registry_array
{
const Native_func_registry *m_elements;
size_t m_count;
public:
Native_func_registry_array()
:m_elements(NULL),
m_count(0)
{ }
Native_func_registry_array(const Native_func_registry *elements, size_t count)
:m_elements(elements),
m_count(count)
{ }
const Native_func_registry& element(size_t i) const
{
DBUG_ASSERT(i < m_count);
return m_elements[i];
}
size_t count() const { return m_count; }
};
class Plugin_function_collection
{
int m_interface_version;
const Native_func_registry_array m_native_func_registry_array;
HASH m_hash;
public:
bool init();
void deinit()
{
my_hash_free(&m_hash);
}
static int init_plugin(st_plugin_int *plugin)
{
Plugin_function_collection *coll=
reinterpret_cast<Plugin_function_collection*>(plugin->plugin->info);
return coll->init();
}
static int deinit_plugin(st_plugin_int *plugin)
{
Plugin_function_collection *coll=
reinterpret_cast<Plugin_function_collection*>(plugin->plugin->info);
coll->deinit();
return 0;
}
public:
Plugin_function_collection(int interface_version,
const Native_func_registry_array &nfra)
:m_interface_version(interface_version),
m_native_func_registry_array(nfra)
{
bzero((void*) &m_hash, sizeof(m_hash));
}
Create_func *find_native_function_builder(THD *thd,
const LEX_CSTRING &name) const;
};
/**
Data type plugin descriptor
*/
#endif /* __cplusplus */
#endif /* MARIADB_PLUGIN_FUNCTION_COLLECTION_INCLUDED */

679
include/mysql/plugin_function_collection.h.pp Normal file
View File

@ -0,0 +1,679 @@
class THD;
class Item;
typedef char my_bool;
typedef void * MYSQL_PLUGIN;
extern "C" {
extern "C" {
extern struct base64_service_st {
int (*base64_needed_encoded_length_ptr)(int length_of_data);
int (*base64_encode_max_arg_length_ptr)(void);
int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
int (*base64_decode_max_arg_length_ptr)();
int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
int (*base64_decode_ptr)(const char *src, size_t src_len,
void *dst, const char **end_ptr, int flags);
} *base64_service;
int my_base64_needed_encoded_length(int length_of_data);
int my_base64_encode_max_arg_length(void);
int my_base64_needed_decoded_length(int length_of_encoded_data);
int my_base64_decode_max_arg_length();
int my_base64_encode(const void *src, size_t src_len, char *dst);
int my_base64_decode(const char *src, size_t src_len,
void *dst, const char **end_ptr, int flags);
}
extern "C" {
extern void (*debug_sync_C_callback_ptr)(THD*, const char *, size_t);
}
extern "C" {
struct encryption_service_st {
unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
unsigned char* buffer, unsigned int* length);
unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen,
int flags, unsigned int key_id,
unsigned int key_version);
int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen);
int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
};
extern struct encryption_service_st encryption_handler;
static inline unsigned int encryption_key_id_exists(unsigned int id)
{
return encryption_handler.encryption_key_get_latest_version_func(id) != (~(unsigned int)0);
}
static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
{
unsigned int unused;
return encryption_handler.encryption_key_get_func((id),(version),(NULL),(&unused)) != (~(unsigned int)0);
}
static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen,
int flags, unsigned int key_id, unsigned int key_version)
{
void *ctx= alloca(encryption_handler.encryption_ctx_size_func((key_id),(key_version)));
int res1, res2;
unsigned int d1, d2;
if ((res1= encryption_handler.encryption_ctx_init_func((ctx),(key),(klen),(iv),(ivlen),(flags),(key_id),(key_version))))
return res1;
res1= encryption_handler.encryption_ctx_update_func((ctx),(src),(slen),(dst),(&d1));
res2= encryption_handler.encryption_ctx_finish_func((ctx),(dst + d1),(&d2));
*dlen= d1 + d2;
return res1 ? res1 : res2;
}
}
extern "C" {
struct st_encryption_scheme_key {
unsigned int version;
unsigned char key[16];
};
struct st_encryption_scheme {
unsigned char iv[16];
struct st_encryption_scheme_key key[3];
unsigned int keyserver_requests;
unsigned int key_id;
unsigned int type;
void (*locker)(struct st_encryption_scheme *self, int release);
};
extern struct encryption_scheme_service_st {
int (*encryption_scheme_encrypt_func)
(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
int (*encryption_scheme_decrypt_func)
(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
} *encryption_scheme_service;
int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
}
extern "C" {
enum thd_kill_levels {
THD_IS_NOT_KILLED=0,
THD_ABORT_SOFTLY=50,
THD_ABORT_ASAP=100,
};
extern struct kill_statement_service_st {
enum thd_kill_levels (*thd_kill_level_func)(const THD*);
} *thd_kill_statement_service;
enum thd_kill_levels thd_kill_level(const THD*);
}
extern "C" {
typedef struct logger_handle_st LOGGER_HANDLE;
extern struct logger_service_st {
void (*logger_init_mutexes)();
LOGGER_HANDLE* (*open)(const char *path,
unsigned long long size_limit,
unsigned int rotations);
int (*close)(LOGGER_HANDLE *log);
int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
int (*rotate)(LOGGER_HANDLE *log);
} *logger_service;
void logger_init_mutexes();
LOGGER_HANDLE *logger_open(const char *path,
unsigned long long size_limit,
unsigned int rotations);
int logger_close(LOGGER_HANDLE *log);
int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
int logger_rotate(LOGGER_HANDLE *log);
}
extern "C" {
extern struct my_md5_service_st {
void (*my_md5_type)(unsigned char*, const char*, size_t);
void (*my_md5_multi_type)(unsigned char*, ...);
size_t (*my_md5_context_size_type)();
void (*my_md5_init_type)(void *);
void (*my_md5_input_type)(void *, const unsigned char *, size_t);
void (*my_md5_result_type)(void *, unsigned char *);
} *my_md5_service;
void my_md5(unsigned char*, const char*, size_t);
void my_md5_multi(unsigned char*, ...);
size_t my_md5_context_size();
void my_md5_init(void *context);
void my_md5_input(void *context, const unsigned char *buf, size_t len);
void my_md5_result(void *context, unsigned char *digest);
}
extern "C" {
enum my_aes_mode {
MY_AES_ECB, MY_AES_CBC
};
extern struct my_crypt_service_st {
int (*my_aes_crypt_init)(void *ctx, enum my_aes_mode mode, int flags,
const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen);
int (*my_aes_crypt_update)(void *ctx, const unsigned char *src, unsigned int slen,
unsigned char *dst, unsigned int *dlen);
int (*my_aes_crypt_finish)(void *ctx, unsigned char *dst, unsigned int *dlen);
int (*my_aes_crypt)(enum my_aes_mode mode, int flags,
const unsigned char *src, unsigned int slen, unsigned char *dst, unsigned int *dlen,
const unsigned char *key, unsigned int klen, const unsigned char *iv, unsigned int ivlen);
unsigned int (*my_aes_get_size)(enum my_aes_mode mode, unsigned int source_length);
unsigned int (*my_aes_ctx_size)(enum my_aes_mode mode);
int (*my_random_bytes)(unsigned char* buf, int num);
} *my_crypt_service;
int my_aes_crypt_init(void *ctx, enum my_aes_mode mode, int flags,
const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen);
int my_aes_crypt_update(void *ctx, const unsigned char *src, unsigned int slen,
unsigned char *dst, unsigned int *dlen);
int my_aes_crypt_finish(void *ctx, unsigned char *dst, unsigned int *dlen);
int my_aes_crypt(enum my_aes_mode mode, int flags,
const unsigned char *src, unsigned int slen, unsigned char *dst, unsigned int *dlen,
const unsigned char *key, unsigned int klen, const unsigned char *iv, unsigned int ivlen);
int my_random_bytes(unsigned char* buf, int num);
unsigned int my_aes_get_size(enum my_aes_mode mode, unsigned int source_length);
unsigned int my_aes_ctx_size(enum my_aes_mode mode);
}
extern "C" {
extern struct my_print_error_service_st {
void (*my_error_func)(unsigned int nr, unsigned long MyFlags, ...);
void (*my_printf_error_func)(unsigned int nr, const char *fmt, unsigned long MyFlags,...);
void (*my_printv_error_func)(unsigned int error, const char *format, unsigned long MyFlags, va_list ap);
} *my_print_error_service;
extern void my_error(unsigned int nr, unsigned long MyFlags, ...);
extern void my_printf_error(unsigned int my_err, const char *format, unsigned long MyFlags, ...);
extern void my_printv_error(unsigned int error, const char *format, unsigned long MyFlags,va_list ap);
}
extern "C" {
extern struct my_snprintf_service_st {
size_t (*my_snprintf_type)(char*, size_t, const char*, ...);
size_t (*my_vsnprintf_type)(char *, size_t, const char*, va_list);
} *my_snprintf_service;
size_t my_snprintf(char* to, size_t n, const char* fmt, ...);
size_t my_vsnprintf(char *to, size_t n, const char* fmt, va_list ap);
}
extern "C" {
extern struct progress_report_service_st {
void (*thd_progress_init_func)(THD* thd, unsigned int max_stage);
void (*thd_progress_report_func)(THD* thd,
unsigned long long progress,
unsigned long long max_progress);
void (*thd_progress_next_stage_func)(THD* thd);
void (*thd_progress_end_func)(THD* thd);
const char *(*set_thd_proc_info_func)(THD*, const char *info,
const char *func,
const char *file,
unsigned int line);
} *progress_report_service;
void thd_progress_init(THD* thd, unsigned int max_stage);
void thd_progress_report(THD* thd,
unsigned long long progress,
unsigned long long max_progress);
void thd_progress_next_stage(THD* thd);
void thd_progress_end(THD* thd);
const char *set_thd_proc_info(THD*, const char * info, const char *func,
const char *file, unsigned int line);
}
extern "C" {
extern struct my_sha1_service_st {
void (*my_sha1_type)(unsigned char*, const char*, size_t);
void (*my_sha1_multi_type)(unsigned char*, ...);
size_t (*my_sha1_context_size_type)();
void (*my_sha1_init_type)(void *);
void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
void (*my_sha1_result_type)(void *, unsigned char *);
} *my_sha1_service;
void my_sha1(unsigned char*, const char*, size_t);
void my_sha1_multi(unsigned char*, ...);
size_t my_sha1_context_size();
void my_sha1_init(void *context);
void my_sha1_input(void *context, const unsigned char *buf, size_t len);
void my_sha1_result(void *context, unsigned char *digest);
}
extern "C" {
extern struct my_sha2_service_st {
void (*my_sha224_type)(unsigned char*, const char*, size_t);
void (*my_sha224_multi_type)(unsigned char*, ...);
size_t (*my_sha224_context_size_type)();
void (*my_sha224_init_type)(void *);
void (*my_sha224_input_type)(void *, const unsigned char *, size_t);
void (*my_sha224_result_type)(void *, unsigned char *);
void (*my_sha256_type)(unsigned char*, const char*, size_t);
void (*my_sha256_multi_type)(unsigned char*, ...);
size_t (*my_sha256_context_size_type)();
void (*my_sha256_init_type)(void *);
void (*my_sha256_input_type)(void *, const unsigned char *, size_t);
void (*my_sha256_result_type)(void *, unsigned char *);
void (*my_sha384_type)(unsigned char*, const char*, size_t);
void (*my_sha384_multi_type)(unsigned char*, ...);
size_t (*my_sha384_context_size_type)();
void (*my_sha384_init_type)(void *);
void (*my_sha384_input_type)(void *, const unsigned char *, size_t);
void (*my_sha384_result_type)(void *, unsigned char *);
void (*my_sha512_type)(unsigned char*, const char*, size_t);
void (*my_sha512_multi_type)(unsigned char*, ...);
size_t (*my_sha512_context_size_type)();
void (*my_sha512_init_type)(void *);
void (*my_sha512_input_type)(void *, const unsigned char *, size_t);
void (*my_sha512_result_type)(void *, unsigned char *);
} *my_sha2_service;
void my_sha224(unsigned char*, const char*, size_t);
void my_sha224_multi(unsigned char*, ...);
size_t my_sha224_context_size();
void my_sha224_init(void *context);
void my_sha224_input(void *context, const unsigned char *buf, size_t len);
void my_sha224_result(void *context, unsigned char *digest);
void my_sha256(unsigned char*, const char*, size_t);
void my_sha256_multi(unsigned char*, ...);
size_t my_sha256_context_size();
void my_sha256_init(void *context);
void my_sha256_input(void *context, const unsigned char *buf, size_t len);
void my_sha256_result(void *context, unsigned char *digest);
void my_sha384(unsigned char*, const char*, size_t);
void my_sha384_multi(unsigned char*, ...);
size_t my_sha384_context_size();
void my_sha384_init(void *context);
void my_sha384_input(void *context, const unsigned char *buf, size_t len);
void my_sha384_result(void *context, unsigned char *digest);
void my_sha512(unsigned char*, const char*, size_t);
void my_sha512_multi(unsigned char*, ...);
size_t my_sha512_context_size();
void my_sha512_init(void *context);
void my_sha512_input(void *context, const unsigned char *buf, size_t len);
void my_sha512_result(void *context, unsigned char *digest);
}
extern "C" {
struct st_mysql_lex_string
{
char *str;
size_t length;
};
typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
struct st_mysql_const_lex_string
{
const char *str;
size_t length;
};
typedef struct st_mysql_const_lex_string MYSQL_CONST_LEX_STRING;
extern struct thd_alloc_service_st {
void *(*thd_alloc_func)(THD*, size_t);
void *(*thd_calloc_func)(THD*, size_t);
char *(*thd_strdup_func)(THD*, const char *);
char *(*thd_strmake_func)(THD*, const char *, size_t);
void *(*thd_memdup_func)(THD*, const void*, size_t);
MYSQL_CONST_LEX_STRING *(*thd_make_lex_string_func)(THD*,
MYSQL_CONST_LEX_STRING *,
const char *, size_t, int);
} *thd_alloc_service;
void *thd_alloc(THD* thd, size_t size);
void *thd_calloc(THD* thd, size_t size);
char *thd_strdup(THD* thd, const char *str);
char *thd_strmake(THD* thd, const char *str, size_t size);
void *thd_memdup(THD* thd, const void* str, size_t size);
MYSQL_CONST_LEX_STRING
*thd_make_lex_string(THD* thd, MYSQL_CONST_LEX_STRING *lex_str,
const char *str, size_t size,
int allocate_lex_string);
}
extern "C" {
extern struct thd_autoinc_service_st {
void (*thd_get_autoinc_func)(const THD* thd,
unsigned long* off, unsigned long* inc);
} *thd_autoinc_service;
void thd_get_autoinc(const THD* thd,
unsigned long* off, unsigned long* inc);
}
extern "C" {
extern struct thd_error_context_service_st {
const char *(*thd_get_error_message_func)(const THD* thd);
unsigned int (*thd_get_error_number_func)(const THD* thd);
unsigned long (*thd_get_error_row_func)(const THD* thd);
void (*thd_inc_error_row_func)(THD* thd);
char *(*thd_get_error_context_description_func)(THD* thd,
char *buffer,
unsigned int length,
unsigned int max_query_length);
} *thd_error_context_service;
const char *thd_get_error_message(const THD* thd);
unsigned int thd_get_error_number(const THD* thd);
unsigned long thd_get_error_row(const THD* thd);
void thd_inc_error_row(THD* thd);
char *thd_get_error_context_description(THD* thd,
char *buffer, unsigned int length,
unsigned int max_query_length);
}
extern "C" {
extern struct thd_rnd_service_st {
double (*thd_rnd_ptr)(THD* thd);
void (*thd_c_r_p_ptr)(THD* thd, char *to, size_t length);
} *thd_rnd_service;
double thd_rnd(THD* thd);
void thd_create_random_password(THD* thd, char *to, size_t length);
}
extern "C" {
typedef int MYSQL_THD_KEY_T;
extern struct thd_specifics_service_st {
int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
void (*thd_key_delete_func)(MYSQL_THD_KEY_T *key);
void *(*thd_getspecific_func)(THD* thd, MYSQL_THD_KEY_T key);
int (*thd_setspecific_func)(THD* thd, MYSQL_THD_KEY_T key, void *value);
} *thd_specifics_service;
int thd_key_create(MYSQL_THD_KEY_T *key);
void thd_key_delete(MYSQL_THD_KEY_T *key);
void* thd_getspecific(THD* thd, MYSQL_THD_KEY_T key);
int thd_setspecific(THD* thd, MYSQL_THD_KEY_T key, void *value);
}
typedef long my_time_t;
enum enum_mysql_timestamp_type
{
MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
};
typedef struct st_mysql_time
{
unsigned int year, month, day, hour, minute, second;
unsigned long second_part;
my_bool neg;
enum enum_mysql_timestamp_type time_type;
} MYSQL_TIME;
extern "C" {
extern struct thd_timezone_service_st {
my_time_t (*thd_TIME_to_gmt_sec)(THD* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
void (*thd_gmt_sec_to_TIME)(THD* thd, MYSQL_TIME *ltime, my_time_t t);
} *thd_timezone_service;
my_time_t thd_TIME_to_gmt_sec(THD* thd, const MYSQL_TIME *ltime, unsigned int *errcode);
void thd_gmt_sec_to_TIME(THD* thd, MYSQL_TIME *ltime, my_time_t t);
}
extern "C" {
typedef enum _thd_wait_type_e {
THD_WAIT_SLEEP= 1,
THD_WAIT_DISKIO= 2,
THD_WAIT_ROW_LOCK= 3,
THD_WAIT_GLOBAL_LOCK= 4,
THD_WAIT_META_DATA_LOCK= 5,
THD_WAIT_TABLE_LOCK= 6,
THD_WAIT_USER_LOCK= 7,
THD_WAIT_BINLOG= 8,
THD_WAIT_GROUP_COMMIT= 9,
THD_WAIT_SYNC= 10,
THD_WAIT_NET= 11,
THD_WAIT_LAST= 12
} thd_wait_type;
extern struct thd_wait_service_st {
void (*thd_wait_begin_func)(THD*, int);
void (*thd_wait_end_func)(THD*);
} *thd_wait_service;
void thd_wait_begin(THD* thd, int wait_type);
void thd_wait_end(THD* thd);
}
extern "C" {
enum json_types
{
JSV_BAD_JSON=-1,
JSV_NOTHING=0,
JSV_OBJECT=1,
JSV_ARRAY=2,
JSV_STRING=3,
JSV_NUMBER=4,
JSV_TRUE=5,
JSV_FALSE=6,
JSV_NULL=7
};
extern struct json_service_st {
enum json_types (*json_type)(const char *js, const char *js_end,
const char **value, int *value_len);
enum json_types (*json_get_array_item)(const char *js, const char *js_end,
int n_item,
const char **value, int *value_len);
enum json_types (*json_get_object_key)(const char *js, const char *js_end,
const char *key,
const char **value, int *value_len);
enum json_types (*json_get_object_nkey)(const char *js,const char *js_end,
int nkey,
const char **keyname, const char **keyname_end,
const char **value, int *value_len);
int (*json_escape_string)(const char *str,const char *str_end,
char *json, char *json_end);
int (*json_unescape_json)(const char *json_str, const char *json_end,
char *res, char *res_end);
} *json_service;
enum json_types json_type(const char *js, const char *js_end,
const char **value, int *value_len);
enum json_types json_get_array_item(const char *js, const char *js_end,
int n_item,
const char **value, int *value_len);
enum json_types json_get_object_key(const char *js, const char *js_end,
const char *key,
const char **value, int *value_len);
enum json_types json_get_object_nkey(const char *js,const char *js_end, int nkey,
const char **keyname, const char **keyname_end,
const char **value, int *value_len);
int json_escape_string(const char *str,const char *str_end,
char *json, char *json_end);
int json_unescape_json(const char *json_str, const char *json_end,
char *res, char *res_end);
}
}
struct st_mysql_xid {
long formatID;
long gtrid_length;
long bqual_length;
char data[128];
};
typedef struct st_mysql_xid MYSQL_XID;
enum enum_mysql_show_type
{
SHOW_UNDEF, SHOW_BOOL, SHOW_UINT, SHOW_ULONG,
SHOW_ULONGLONG, SHOW_CHAR, SHOW_CHAR_PTR,
SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE,
SHOW_SINT, SHOW_SLONG, SHOW_SLONGLONG, SHOW_SIMPLE_FUNC,
SHOW_SIZE_T, SHOW_always_last
};
enum enum_var_type
{
SHOW_OPT_DEFAULT= 0, SHOW_OPT_SESSION, SHOW_OPT_GLOBAL
};
struct st_mysql_show_var {
const char *name;
void *value;
enum enum_mysql_show_type type;
};
struct system_status_var;
typedef int (*mysql_show_var_func)(THD*, struct st_mysql_show_var*, void *, struct system_status_var *status_var, enum enum_var_type);
struct st_mysql_sys_var;
struct st_mysql_value;
typedef int (*mysql_var_check_func)(THD* thd,
struct st_mysql_sys_var *var,
void *save, struct st_mysql_value *value);
typedef void (*mysql_var_update_func)(THD* thd,
struct st_mysql_sys_var *var,
void *var_ptr, const void *save);
struct st_mysql_plugin
{
int type;
void *info;
const char *name;
const char *author;
const char *descr;
int license;
int (*init)(void *);
int (*deinit)(void *);
unsigned int version;
struct st_mysql_show_var *status_vars;
struct st_mysql_sys_var **system_vars;
void * __reserved1;
unsigned long flags;
};
struct st_maria_plugin
{
int type;
void *info;
const char *name;
const char *author;
const char *descr;
int license;
int (*init)(void *);
int (*deinit)(void *);
unsigned int version;
struct st_mysql_show_var *status_vars;
struct st_mysql_sys_var **system_vars;
const char *version_info;
unsigned int maturity;
};
extern "C" {
enum enum_ftparser_mode
{
MYSQL_FTPARSER_SIMPLE_MODE= 0,
MYSQL_FTPARSER_WITH_STOPWORDS= 1,
MYSQL_FTPARSER_FULL_BOOLEAN_INFO= 2
};
enum enum_ft_token_type
{
FT_TOKEN_EOF= 0,
FT_TOKEN_WORD= 1,
FT_TOKEN_LEFT_PAREN= 2,
FT_TOKEN_RIGHT_PAREN= 3,
FT_TOKEN_STOPWORD= 4
};
typedef struct st_mysql_ftparser_boolean_info
{
enum enum_ft_token_type type;
int yesno;
int weight_adjust;
char wasign;
char trunc;
char prev;
char *quot;
} MYSQL_FTPARSER_BOOLEAN_INFO;
typedef struct st_mysql_ftparser_param
{
int (*mysql_parse)(struct st_mysql_ftparser_param *,
const char *doc, int doc_len);
int (*mysql_add_word)(struct st_mysql_ftparser_param *,
const char *word, int word_len,
MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info);
void *ftparser_state;
void *mysql_ftparam;
const struct charset_info_st *cs;
const char *doc;
int length;
unsigned int flags;
enum enum_ftparser_mode mode;
} MYSQL_FTPARSER_PARAM;
struct st_mysql_ftparser
{
int interface_version;
int (*parse)(MYSQL_FTPARSER_PARAM *param);
int (*init)(MYSQL_FTPARSER_PARAM *param);
int (*deinit)(MYSQL_FTPARSER_PARAM *param);
};
}
struct st_mysql_daemon
{
int interface_version;
};
struct st_mysql_information_schema
{
int interface_version;
};
struct st_mysql_storage_engine
{
int interface_version;
};
struct handlerton;
struct Mysql_replication {
int interface_version;
};
struct st_mysql_value
{
int (*value_type)(struct st_mysql_value *);
const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
int (*val_real)(struct st_mysql_value *, double *realbuf);
int (*val_int)(struct st_mysql_value *, long long *intbuf);
int (*is_unsigned)(struct st_mysql_value *);
};
extern "C" {
int thd_in_lock_tables(const THD* thd);
int thd_tablespace_op(const THD* thd);
long long thd_test_options(const THD* thd, long long test_options);
int thd_sql_command(const THD* thd);
void thd_storage_lock_wait(THD* thd, long long value);
int thd_tx_isolation(const THD* thd);
int thd_tx_is_read_only(const THD* thd);
int mysql_tmpfile(const char *prefix);
unsigned long thd_get_thread_id(const THD* thd);
void thd_get_xid(const THD* thd, MYSQL_XID *xid);
void mysql_query_cache_invalidate4(THD* thd,
const char *key, unsigned int key_length,
int using_trx);
void *thd_get_ha_data(const THD* thd, const struct handlerton *hton);
void thd_set_ha_data(THD* thd, const struct handlerton *hton,
const void *ha_data);
void thd_wakeup_subsequent_commits(THD* thd, int wakeup_error);
}
class Native_func_registry_array
{
const Native_func_registry *m_elements;
size_t m_count;
public:
Native_func_registry_array()
:m_elements(NULL),
m_count(0)
{ }
Native_func_registry_array(const Native_func_registry *elements, size_t count)
:m_elements(elements),
m_count(count)
{ }
const Native_func_registry& element(size_t i) const
{
DBUG_ASSERT(i < m_count);
return m_elements[i];
}
size_t count() const { return m_count; }
};
class Plugin_function_collection
{
int m_interface_version;
const Native_func_registry_array m_native_func_registry_array;
HASH m_hash;
public:
bool init();
void deinit()
{
my_hash_free(&m_hash);
}
static int init_plugin(st_plugin_int *plugin)
{
Plugin_function_collection *coll=
reinterpret_cast<Plugin_function_collection*>(plugin->plugin->info);
return coll->init();
}
static int deinit_plugin(st_plugin_int *plugin)
{
Plugin_function_collection *coll=
reinterpret_cast<Plugin_function_collection*>(plugin->plugin->info);
coll->deinit();
return 0;
}
public:
Plugin_function_collection(int interface_version,
const Native_func_registry_array &nfra)
:m_interface_version(interface_version),
m_native_func_registry_array(nfra)
{
bzero((void*) &m_hash, sizeof(m_hash));
}
Create_func *find_native_function_builder(THD *thd,
const LEX_CSTRING &name) const;
};

17
plugin/func_test/CMakeLists.txt Normal file
View File

@ -0,0 +1,17 @@
# Copyright (c) 2019, MariaDB corporation. All rights reserved.
#
# 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 Street, Fifth Floor, Boston, MA 02110-1335 USA
MYSQL_ADD_PLUGIN(func_test plugin.cc RECOMPILE_FOR_EMBEDDED
MODULE_ONLY COMPONENT Test)

28
plugin/func_test/mysql-test/func_test/func_test.result Normal file
View File

@ -0,0 +1,28 @@
SELECT
PLUGIN_NAME,
PLUGIN_VERSION,
PLUGIN_STATUS,
PLUGIN_TYPE,
PLUGIN_AUTHOR,
PLUGIN_DESCRIPTION,
PLUGIN_LICENSE,
PLUGIN_MATURITY,
PLUGIN_AUTH_VERSION
FROM INFORMATION_SCHEMA.PLUGINS
WHERE PLUGIN_TYPE='FUNCTION COLLECTION'
AND PLUGIN_NAME='func_test';
PLUGIN_NAME func_test
PLUGIN_VERSION 1.0
PLUGIN_STATUS ACTIVE
PLUGIN_TYPE FUNCTION COLLECTION
PLUGIN_AUTHOR MariaDB Corporation
PLUGIN_DESCRIPTION Function collection test
PLUGIN_LICENSE GPL
PLUGIN_MATURITY Experimental
PLUGIN_AUTH_VERSION 1.0
SELECT sysconst_test();
sysconst_test()
sysconst_test
SELECT sysconst_test();
sysconst_test()
sysconst_test

23
plugin/func_test/mysql-test/func_test/func_test.test Normal file
View File

@ -0,0 +1,23 @@
#--echo #
#--echo #
#--echo #
--vertical_results
SELECT
PLUGIN_NAME,
PLUGIN_VERSION,
PLUGIN_STATUS,
PLUGIN_TYPE,
PLUGIN_AUTHOR,
PLUGIN_DESCRIPTION,
PLUGIN_LICENSE,
PLUGIN_MATURITY,
PLUGIN_AUTH_VERSION
FROM INFORMATION_SCHEMA.PLUGINS
WHERE PLUGIN_TYPE='FUNCTION COLLECTION'
AND PLUGIN_NAME='func_test';
--horizontal_results
SELECT sysconst_test();
SELECT sysconst_test();

1
plugin/func_test/mysql-test/func_test/suite.opt Normal file
View File

@ -0,0 +1 @@
--plugin-load-add=$FUNC_TEST_SO

9
plugin/func_test/mysql-test/func_test/suite.pm Normal file
View File

@ -0,0 +1,9 @@
package My::Suite::Func_test;
@ISA = qw(My::Suite);
return "No FUNC_TEST plugin" unless $ENV{FUNC_TEST_SO};
sub is_default { 1 }
bless { };

96
plugin/func_test/plugin.cc Normal file
View File

@ -0,0 +1,96 @@
/*
Copyright (c) 2000, 2015, Oracle and/or its affiliates.
Copyright (c) 2009, 2019, MariaDB
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-1301 USA */
#define MYSQL_SERVER
#include <my_global.h>
#include <sql_class.h>
#include <mysql/plugin_function_collection.h>
class Item_func_sysconst_test :public Item_func_sysconst
{
public:
Item_func_sysconst_test(THD *thd): Item_func_sysconst(thd) {}
String *val_str(String *str)
{
null_value= str->copy(STRING_WITH_LEN("sysconst_test"), system_charset_info);
return null_value ? NULL : str;
}
bool fix_length_and_dec()
{
max_length= MAX_FIELD_NAME * system_charset_info->mbmaxlen;
maybe_null= true;
return false;
}
const char *func_name() const { return "sysconst_test"; }
const char *fully_qualified_func_name() const { return "sysconst_test()"; }
Item *get_copy(THD *thd)
{ return get_item_copy<Item_func_sysconst_test>(thd, this); }
};
class Create_func_sysconst_test : public Create_func_arg0
{
public:
Item *create_builder(THD *thd) override;
static Create_func_sysconst_test s_singleton;
protected:
Create_func_sysconst_test() {}
};
Create_func_sysconst_test Create_func_sysconst_test::s_singleton;
Item* Create_func_sysconst_test::create_builder(THD *thd)
{
return new (thd->mem_root) Item_func_sysconst_test(thd);
}
#define BUILDER(F) & F::s_singleton
static Native_func_registry func_array[] =
{
{{STRING_WITH_LEN("SYSCONST_TEST")}, BUILDER(Create_func_sysconst_test)}
};
static Plugin_function_collection
plugin_descriptor_function_collection_test(
MariaDB_FUNCTION_COLLECTION_INTERFACE_VERSION,
Native_func_registry_array(func_array, array_elements(func_array)));
/*************************************************************************/
maria_declare_plugin(type_test)
{
MariaDB_FUNCTION_COLLECTION_PLUGIN, // the plugin type (see include/mysql/plugin.h)
&plugin_descriptor_function_collection_test, // pointer to type-specific plugin descriptor
"func_test", // plugin name
"MariaDB Corporation", // plugin author
"Function collection test", // the plugin description
PLUGIN_LICENSE_GPL, // the plugin license (see include/mysql/plugin.h)
0, // Pointer to plugin initialization function
0, // Pointer to plugin deinitialization function
0x0100, // Numeric version 0xAABB means AA.BB veriosn
NULL, // Status variables
NULL, // System variables
"1.0", // String version representation
MariaDB_PLUGIN_MATURITY_EXPERIMENTAL // Maturity(see include/mysql/plugin.h)*/
}
maria_declare_plugin_end;

114
sql/item_create.cc
View File

@ -36,6 +36,94 @@
#include "item_inetfunc.h" #include "item_inetfunc.h"
#include "sql_time.h" #include "sql_time.h"
#include "sql_type_geom.h" #include "sql_type_geom.h"
#include <mysql/plugin_function_collection.h>
extern "C" uchar*
get_native_fct_hash_key(const uchar *buff, size_t *length,
my_bool /* unused */)
{
Native_func_registry *func= (Native_func_registry*) buff;
*length= func->name.length;
return (uchar*) func->name.str;
}
bool Plugin_function_collection::init()
{
DBUG_ENTER("Plugin_function_collection::init");
if (my_hash_init(&m_hash,
system_charset_info,
(ulong) m_native_func_registry_array.count(),
0,
0,
(my_hash_get_key) get_native_fct_hash_key,
NULL, /* Nothing to free */
MYF(0)))
DBUG_RETURN(true);
for (size_t i= 0; i < m_native_func_registry_array.count(); i++)
{
const Native_func_registry &func= m_native_func_registry_array.element(i);
DBUG_ASSERT(func.builder != NULL);
if (my_hash_insert(&m_hash, (uchar*) &func))
DBUG_RETURN(true);
}
DBUG_RETURN(false);
}
Create_func *
Plugin_function_collection::find_native_function_builder(THD *thd,
const LEX_CSTRING &name)
const
{
const Native_func_registry *func;
func= (const Native_func_registry*) my_hash_search(&m_hash,
(uchar*) name.str,
name.length);
return func ? func->builder : NULL;
}
class Plugin_find_native_func_builder_param
{
bool find_native_function_builder(THD *thd,
const Plugin_function_collection *pfc)
{
return ((builder= pfc->find_native_function_builder(thd, name))) == NULL;
}
static my_bool find_in_plugin(THD *thd, plugin_ref plugin, void *data)
{
Plugin_find_native_func_builder_param *param=
reinterpret_cast<Plugin_find_native_func_builder_param*>(data);
const Plugin_function_collection *fc=
reinterpret_cast<Plugin_function_collection*>
(plugin_decl(plugin)->info);
return param->find_native_function_builder(thd, fc);
}
public:
LEX_CSTRING name;
Create_func *builder;
Plugin_find_native_func_builder_param(const LEX_CSTRING &name_arg)
:name(name_arg), builder(NULL)
{ }
Create_func *find(THD *thd)
{
if (plugin_foreach(thd,
Plugin_find_native_func_builder_param::find_in_plugin,
MariaDB_FUNCTION_COLLECTION_PLUGIN, this))
return NULL;
return builder;
}
};
#ifdef HAVE_SPATIAL
extern Plugin_function_collection plugin_function_collection_geometry;
#endif
/* /*
============================================================================= =============================================================================
@ -5735,15 +5823,6 @@ static Native_func_registry func_array[] =
static HASH native_functions_hash; static HASH native_functions_hash;
extern "C" uchar*
get_native_fct_hash_key(const uchar *buff, size_t *length,
my_bool /* unused */)
{
Native_func_registry *func= (Native_func_registry*) buff;
*length= func->name.length;
return (uchar*) func->name.str;
}
/* /*
Load the hash table for native functions. Load the hash table for native functions.
Note: this code is not thread safe, and is intended to be used at server Note: this code is not thread safe, and is intended to be used at server
@ -5768,7 +5847,7 @@ int item_create_init()
DBUG_RETURN(1); DBUG_RETURN(1);
#ifdef HAVE_SPATIAL #ifdef HAVE_SPATIAL
if (function_collection_geometry.init()) if (plugin_function_collection_geometry.init())
DBUG_RETURN(1); DBUG_RETURN(1);
#endif #endif
@ -5810,7 +5889,7 @@ void item_create_cleanup()
DBUG_ENTER("item_create_cleanup"); DBUG_ENTER("item_create_cleanup");
my_hash_free(& native_functions_hash); my_hash_free(& native_functions_hash);
#ifdef HAVE_SPATIAL #ifdef HAVE_SPATIAL
function_collection_geometry.cleanup(); plugin_function_collection_geometry.deinit();
#endif #endif
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -5826,15 +5905,16 @@ find_native_function_builder(THD *thd, const LEX_CSTRING *name)
(uchar*) name->str, (uchar*) name->str,
name->length); name->length);
if (func) if (func && (builder= func->builder))
{ return builder;
builder= func->builder;
} if ((builder= Plugin_find_native_func_builder_param(*name).find(thd)))
return builder;
#ifdef HAVE_SPATIAL #ifdef HAVE_SPATIAL
if (!builder) if (!builder)
builder= function_collection_geometry.find_native_function_builder(thd, builder= plugin_function_collection_geometry.
*name); find_native_function_builder(thd, *name);
#endif #endif
return builder; return builder;

63
sql/item_geofunc.cc
View File

@ -39,6 +39,7 @@
#include <m_ctype.h> #include <m_ctype.h>
#include "opt_range.h" #include "opt_range.h"
#include "item_geofunc.h" #include "item_geofunc.h"
#include <mysql/plugin_function_collection.h>
bool Item_geometry_func::fix_length_and_dec() bool Item_geometry_func::fix_length_and_dec()
@ -3906,62 +3907,10 @@ static Native_func_registry func_array_geom[] =
}; };
extern "C" uchar* Plugin_function_collection
get_native_fct_hash_key_geom(const uchar *buff, size_t *length, plugin_function_collection_geometry(
my_bool /* unused */) MariaDB_FUNCTION_COLLECTION_INTERFACE_VERSION,
{ Native_func_registry_array(func_array_geom,
Native_func_registry *func= (Native_func_registry*) buff; array_elements(func_array_geom)));
*length= func->name.length;
return (uchar*) func->name.str;
}
Function_collection_geometry function_collection_geometry;
static FHash hash_funcn;
Create_func *
Function_collection_geometry::find_native_function_builder(THD *thd,
const LEX_CSTRING &f)
const
{
Native_func_registry *func;
func= (Native_func_registry*) my_hash_search(&hash_funcn,
(uchar*) f.str, f.length);
return func ? func->builder : NULL;
}
bool Function_collection_geometry::init()
{
DBUG_ENTER("Type_collection_geometry::init_functions");
if (my_hash_init(&hash_funcn,
system_charset_info,
array_elements(func_array_geom),
0,
0,
(my_hash_get_key) get_native_fct_hash_key_geom,
NULL, /* Nothing to free */
MYF(0)))
DBUG_RETURN(true);
for (uint i= 0; i < array_elements(func_array_geom); i++)
{
Native_func_registry *func= &func_array_geom[i];
DBUG_ASSERT(func->builder != NULL);
if (my_hash_insert(&hash_funcn, (uchar*) func))
DBUG_RETURN(1);
}
DBUG_RETURN(false);
}
void Function_collection_geometry::cleanup()
{
my_hash_free(&hash_funcn);
}
#endif /*HAVE_SPATIAL*/ #endif /*HAVE_SPATIAL*/

17
sql/sql_plugin.cc
View File

@ -39,6 +39,7 @@
#include <mysql/plugin_password_validation.h> #include <mysql/plugin_password_validation.h>
#include <mysql/plugin_encryption.h> #include <mysql/plugin_encryption.h>
#include <mysql/plugin_data_type.h> #include <mysql/plugin_data_type.h>
#include <mysql/plugin_function_collection.h>
#include "sql_plugin_compat.h" #include "sql_plugin_compat.h"
#ifdef HAVE_LINK_H #ifdef HAVE_LINK_H
@ -92,7 +93,8 @@ const LEX_CSTRING plugin_type_names[MYSQL_MAX_PLUGIN_TYPE_NUM]=
{ STRING_WITH_LEN("AUTHENTICATION") }, { STRING_WITH_LEN("AUTHENTICATION") },
{ STRING_WITH_LEN("PASSWORD VALIDATION") }, { STRING_WITH_LEN("PASSWORD VALIDATION") },
{ STRING_WITH_LEN("ENCRYPTION") }, { STRING_WITH_LEN("ENCRYPTION") },
{ STRING_WITH_LEN("DATA TYPE") } { STRING_WITH_LEN("DATA TYPE") },
{ STRING_WITH_LEN("FUNCTION COLLECTION") }
}; };
extern int initialize_schema_table(st_plugin_int *plugin); extern int initialize_schema_table(st_plugin_int *plugin);
@ -112,13 +114,15 @@ extern int finalize_encryption_plugin(st_plugin_int *plugin);
plugin_type_init plugin_type_initialize[MYSQL_MAX_PLUGIN_TYPE_NUM]= plugin_type_init plugin_type_initialize[MYSQL_MAX_PLUGIN_TYPE_NUM]=
{ {
0, ha_initialize_handlerton, 0, 0,initialize_schema_table, 0, ha_initialize_handlerton, 0, 0,initialize_schema_table,
initialize_audit_plugin, 0, 0, 0, initialize_encryption_plugin, 0 initialize_audit_plugin, 0, 0, 0, initialize_encryption_plugin, 0,
Plugin_function_collection::init_plugin
}; };
plugin_type_init plugin_type_deinitialize[MYSQL_MAX_PLUGIN_TYPE_NUM]= plugin_type_init plugin_type_deinitialize[MYSQL_MAX_PLUGIN_TYPE_NUM]=
{ {
0, ha_finalize_handlerton, 0, 0, finalize_schema_table, 0, ha_finalize_handlerton, 0, 0, finalize_schema_table,
finalize_audit_plugin, 0, 0, 0, finalize_encryption_plugin, 0 finalize_audit_plugin, 0, 0, 0, finalize_encryption_plugin, 0,
Plugin_function_collection::deinit_plugin
}; };
/* /*
@ -131,6 +135,7 @@ static int plugin_type_initialization_order[MYSQL_MAX_PLUGIN_TYPE_NUM]=
MYSQL_DAEMON_PLUGIN, MYSQL_DAEMON_PLUGIN,
MariaDB_ENCRYPTION_PLUGIN, MariaDB_ENCRYPTION_PLUGIN,
MariaDB_DATA_TYPE_PLUGIN, MariaDB_DATA_TYPE_PLUGIN,
MariaDB_FUNCTION_COLLECTION_PLUGIN,
MYSQL_STORAGE_ENGINE_PLUGIN, MYSQL_STORAGE_ENGINE_PLUGIN,
MYSQL_INFORMATION_SCHEMA_PLUGIN, MYSQL_INFORMATION_SCHEMA_PLUGIN,
MYSQL_FTPARSER_PLUGIN, MYSQL_FTPARSER_PLUGIN,
@ -173,7 +178,8 @@ static int min_plugin_info_interface_version[MYSQL_MAX_PLUGIN_TYPE_NUM]=
MIN_AUTHENTICATION_INTERFACE_VERSION, MIN_AUTHENTICATION_INTERFACE_VERSION,
MariaDB_PASSWORD_VALIDATION_INTERFACE_VERSION, MariaDB_PASSWORD_VALIDATION_INTERFACE_VERSION,
MariaDB_ENCRYPTION_INTERFACE_VERSION, MariaDB_ENCRYPTION_INTERFACE_VERSION,
MariaDB_DATA_TYPE_INTERFACE_VERSION MariaDB_DATA_TYPE_INTERFACE_VERSION,
MariaDB_FUNCTION_COLLECTION_INTERFACE_VERSION
}; };
static int cur_plugin_info_interface_version[MYSQL_MAX_PLUGIN_TYPE_NUM]= static int cur_plugin_info_interface_version[MYSQL_MAX_PLUGIN_TYPE_NUM]=
{ {
@ -187,7 +193,8 @@ static int cur_plugin_info_interface_version[MYSQL_MAX_PLUGIN_TYPE_NUM]=
MYSQL_AUTHENTICATION_INTERFACE_VERSION, MYSQL_AUTHENTICATION_INTERFACE_VERSION,
MariaDB_PASSWORD_VALIDATION_INTERFACE_VERSION, MariaDB_PASSWORD_VALIDATION_INTERFACE_VERSION,
MariaDB_ENCRYPTION_INTERFACE_VERSION, MariaDB_ENCRYPTION_INTERFACE_VERSION,
MariaDB_DATA_TYPE_INTERFACE_VERSION MariaDB_DATA_TYPE_INTERFACE_VERSION,
MariaDB_FUNCTION_COLLECTION_INTERFACE_VERSION
}; };
static struct static struct

14
sql/sql_type_geom.h
View File

@ -263,17 +263,6 @@ extern MYSQL_PLUGIN_IMPORT Type_handler_multipolygon type_handler_multipolygo
extern MYSQL_PLUGIN_IMPORT Type_handler_geometrycollection type_handler_geometrycollection; extern MYSQL_PLUGIN_IMPORT Type_handler_geometrycollection type_handler_geometrycollection;
class Function_collection_geometry: public Function_collection
{
public:
bool init() override;
void cleanup() override;
Create_func *find_native_function_builder(THD *thd,
const LEX_CSTRING &name)
const override;
};
class Type_collection_geometry: public Type_collection class Type_collection_geometry: public Type_collection
{ {
const Type_handler *aggregate_common(const Type_handler *a, const Type_handler *aggregate_common(const Type_handler *a,
@ -326,9 +315,6 @@ public:
}; };
extern MYSQL_PLUGIN_IMPORT
Function_collection_geometry function_collection_geometry;
extern MYSQL_PLUGIN_IMPORT Type_collection_geometry type_collection_geometry; extern MYSQL_PLUGIN_IMPORT Type_collection_geometry type_collection_geometry;