这些条件适用于插件编写：

以下过程概述了创建插件库所需的步骤。 接下来的部分提供了有关设置插件数据结构和编写特定类型插件的其他详细信息。

插件库文件包括描述符信息以指示它包含哪些插件。

如果插件库包含任何服务器插件，则它必须包含以下描述符信息：

插件库还包含接口函数，这些函数由库中每个插件的常规描述符和特定于类型的描述符引用。

如果插件库包含客户端插件，则必须包含插件的描述符。 描述符以所有客户端插件通用的固定成员集开头，后跟任何特定于插件类型的成员。 要提供描述符框架，请从头 client_plugin.h 文件中 调用两个宏 ：

mysql_declare_client_plugin（plugin_type）
   ... members common to all client plugins...
   ... type-specific extra members...
mysql_end_client_plugin;

插件库还包含客户端描述符引用的任何接口函数。

在 mysql_declare_plugin() 和 mysql_declare_client_plugin() 宏在它们如何被调用，这对插件库的内容含义有所不同。 以下指南总结了规则：

当客户端程序查找插件库中没有内置的客户端插件时 libmysqlclient ，它会查找一个基本名称与插件名称相同的文件。 例如，如果程序需要使用 auth_xxx 在 .so 用作库后缀 的系统上 命名的客户端身份验证插件 ，则它会查找名为的文件 auth_xxx.so 。 （在OS X上，程序首先查找 auth_xxx.dylib ，然后查找 auth_xxx.so 。）因此，如果插件库包含客户端插件，则库必须具有与该插件相同的基本名称。

对于包含服务器插件的库，情况也是如此。 该 --plugin-load 选项和 INSTALL PLUGIN 声明明确提供的库文件名，所以有需要的库名，它包含的任何服务器插件的名称之间没有明确的关系。

mysql_declare_plugin（name）
 ... one or more server plugin descriptors here ...
mysql_declare_plugin_end;

struct st_mysql_plugin
{
  int类型; / *插件类型（MYSQL_XXX_PLUGIN值）* /
  void * info; / *指向特定于类型的插件描述符的指针* /
  const char * name; / *插件名称* /
  const char * author; / *插件作者（适用于I_S.PLUGINS）* /
  const char * descr; / *一般描述性文字（适用于I_S.PLUGINS）* /
  int license; / *插件许可证（PLUGIN_LICENSE_XXX）* /
  int（* init）（void *）; / *加载插件时调用的函数* /
  int（* deinit）（void *）; / *卸载插件时调用的函数* /
  unsigned int版本; / *插件版本（适用于I_S.PLUGINS）* /
  struct st_mysql_show_var * status_vars;
  struct st_mysql_sys_var ** system_vars;
  void * __reserved1; / *保留用于依赖性检查* /
  无符号长旗; 插件的/ *标志* /
};

mysql_declare_plugin（ftexample）
{
  MYSQL_FTPARSER_PLUGIN，/ * type * /
  ＆simple_parser_descriptor，/ *描述符* /
  “simple_parser”，/ * name * /
  “Oracle Corporation”，/ * author * /
  “简单的全文解析器”，/ *描述* /
  PLUGIN_LICENSE_GPL，/ *插件许可证* /
  simple_parser_plugin_init，/ * init函数（加载时）* /
  simple_parser_plugin_deinit，/ * deinit函数（卸载时）* /
  0x0001，/ *版本* /
  simple_status，/ *状态变量* /
  simple_system_variables，/ *系统变量* /
  空值，
  0
}
mysql_declare_plugin_end;

#ifndef MYSQL_DYNAMIC_PLUGIN
#define __MYSQL_DECLARE_PLUGIN（NAME，VERSION，PSIZE，DECLS）\
MYSQL_PLUGIN_EXPORT int VERSION = MYSQL_PLUGIN_INTERFACE_VERSION; \
MYSQL_PLUGIN_EXPORT int PSIZE = sizeof（struct st_mysql_plugin）; \
MYSQL_PLUGIN_EXPORT struct st_mysql_plugin DECLS [] = {
＃其他
#define __MYSQL_DECLARE_PLUGIN（NAME，VERSION，PSIZE，DECLS）\
MYSQL_PLUGIN_EXPORT int _mysql_plugin_interface_version_ = MYSQL_PLUGIN_INTERFACE_VERSION; \
MYSQL_PLUGIN_EXPORT int _mysql_sizeof_struct_st_plugin_ = sizeof（struct st_mysql_plugin）; \
MYSQL_PLUGIN_EXPORT struct st_mysql_plugin _mysql_plugin_declarations _ [] = {
＃万一

#define mysql_declare_plugin（NAME）\
__MYSQL_DECLARE_PLUGIN（NAME，\
                 builtin_ ## NAME ## _plugin_interface_version，\
                 builtin_ ## NAME ## _sizeof_struct_st_plugin，\
                 builtin_ ## NAME ## _plugin）

#define mysql_declare_plugin_end，{0,0,0,0,0,0,0,0,0,0,0,0,0}}

int _mysql_plugin_interface_version_ = MYSQL_PLUGIN_INTERFACE_VERSION;
int _mysql_sizeof_struct_st_plugin_ = sizeof（struct st_mysql_plugin）;
struct st_mysql_plugin _mysql_plugin_declarations _ [] = {
{
  MYSQL_FTPARSER_PLUGIN，/ * type * /
  ＆simple_parser_descriptor，/ *描述符* /
  “simple_parser”，/ * name * /
  “Oracle Corporation”，/ * author * /
  “简单的全文解析器”，/ *描述* /
  PLUGIN_LICENSE_GPL，/ *插件许可证* /
  simple_parser_plugin_init，/ * init函数（加载时）* /
  simple_parser_plugin_deinit，/ * deinit函数（卸载时）* /
  0x0001，/ *版本* /
  simple_status，/ *状态变量* /
  simple_system_variables，/ *系统变量* /
  空值，
  0
}
  {0,0,0,0,0,0,0,0,0,0,0,0}}
};

mysql_declare_plugin（ftexample）
{
  MYSQL_FTPARSER_PLUGIN，/ * type * /
  ＆simple_parser_descriptor，/ *描述符* /
  “simple_parser”，/ * name * /
  “Oracle Corporation”，/ * author * /
  “简单的全文解析器”，/ *描述* /
  PLUGIN_LICENSE_GPL，/ *插件许可证* /
  simple_parser_plugin_init，/ * init函数（加载时）* /
  simple_parser_plugin_deinit，/ * deinit函数（卸载时）* /
  0x0001，/ *版本* /
  simple_status，/ *状态变量* /
  simple_system_variables，/ *系统变量* /
  空值，
  0
}
mysql_declare_plugin_end;

const char * simple_parser_name =“simple_parser”;
const char * simple_parser_author =“Oracle Corporation”;
const char * simple_parser_description =“简单的全文解析器”;

mysql_declare_plugin（ftexample）
{
  MYSQL_FTPARSER_PLUGIN，/ * type * /
  ＆simple_parser_descriptor，/ *描述符* /
  simple_parser_name，/ * name * /
  simple_parser_author，/ * author * /
  simple_parser_description，/ * description * /
  PLUGIN_LICENSE_GPL，/ *插件许可证* /
  simple_parser_plugin_init，/ * init函数（加载时）* /
  simple_parser_plugin_deinit，/ * deinit函数（卸载时）* /
  0x0001，/ *版本* /
  simple_status，/ *状态变量* /
  simple_system_variables，/ *系统变量* /
  空值，
  0
}
mysql_declare_plugin_end;

typedef结构
{
  const char * name;
  const char * author;
  const char * description;
} plugin_info;

plugin_info parser_info = {
  “simple_parser”
  “甲骨文公司”，
  “简单的全文解析器”
};

mysql_declare_plugin（ftexample）
{
  MYSQL_FTPARSER_PLUGIN，/ * type * /
  ＆simple_parser_descriptor，/ *描述符* /
  parser_info.name，/ * name * /
  parser_info.author，/ * author * /
  parser_info.description，/ * description * /
  PLUGIN_LICENSE_GPL，/ *插件许可证* /
  simple_parser_plugin_init，/ * init函数（加载时）* /
  simple_parser_plugin_deinit，/ * deinit函数（卸载时）* /
  0x0001，/ *版本* /
  simple_status，/ *状态变量* /
  simple_system_variables，/ *系统变量* /
  空值，
  0
}
mysql_declare_plugin_end;

struct st_mysql_show_var {
  const char * name;
  char *值;
  枚举enum_mysql_show_type类型;
};

#define SHOW_VAR_FUNC_BUFF_SIZE 1024

typedef int（* mysql_show_var_func）（void * thd，
                                    struct st_mysql_show_var * out，
                                    char * buf）;

struct st_mysql_sys_var {
 int标志;
 const char * name，* comment;
 int（* check）（THD *，struct st_mysql_sys_var *，void *，st_mysql_value *）;
 void（* update）（THD *，struct st_mysql_sys_var *，void *，const void *）;
};

static int my_foo;
static MYSQL_SYSVAR_INT（foo_var，my_foo，
                        PLUGIN_VAR_RQCMDARG，“foo评论”，
                        NULL，NULL，0,0，INT_MAX，0）;
 ...
   SYSVAR（foo_var）=值;
   value = SYSVAR（foo_var）;
   my_foo = value;
   value = my_foo;

static MYSQL_THDVAR_BOOL（some_flag，
                         PLUGIN_VAR_NOCMDARG，“旗帜评论”，
                         NULL，NULL，FALSE）;
 ...
   if（THDVAR（thd，some_flag））
   {
     做一点事（）;
     THDVAR（thd，some_flag）= FALSE;
   }

static struct st_mysql_sys_var * my_plugin_vars [] = {
  MYSQL_SYSVAR（foo_var）
  MYSQL_SYSVAR（some_flag）
  空值
};
mysql_declare_plugin（fooplug）
{
  MYSQL _..._插件，
  ＆plugin_data，
  “fooplug”
  “foo作者”，
  “这确实很棒！”，
  PLUGIN_LICENSE_GPL，
  foo_init，
  foo_fini，
  0×0001，
  空值，
  my_plugin_vars，
  空值，
  0
}
mysql_declare_plugin_end;

struct st_mysql_client_plugin
{
  int类型;
  unsigned int interface_version;
  const char * name;
  const char * author;
  const char * desc;
  unsigned int version [3];
  const char * license;
  void * mysql_api;
  int（* init）（char *，size_t，int，va_list）;
  int（* deinit）（）;
  int（* options）（const char * option，const void *）;
};

mysql_declare_client_plugin（plugin_type）
   ... members common to all client plugins...
   ... type-specific extra members...
mysql_end_client_plugin;

mysql_declare_client_plugin（认证）
  “my_auth_plugin”
  “作者姓名”，
  “我的客户端身份验证插件”，
  {1,0,0}，
  “GPL”
  空值，
  my_auth_init，
  my_auth_deinit，
  my_auth_options，
  my_auth_main
mysql_end_client_plugin;

char * plugin_dir =“ path_to_plugin_dir”;
char * default_auth =“ plugin_name”;

/ * ...进程命令行选项... * /

mysql_options（＆mysql，MYSQL_PLUGIN_DIR，plugin_dir）;
mysql_options（＆mysql，MYSQL_DEFAULT_AUTH，default_auth）;

编写插件后，必须编译并安装它。 编译共享对象的过程因系统而异。 如果使用构建库 CMake ，它应该能够为您的系统生成正确的编译命令。 如果库已命名 somepluglib ，则应该使用名称类似的共享库文件 somepluglib.so 。 （ .so 文件名后缀可能与您的系统不同。）

要使用 CMake ，您需要设置配置文件以启用插件的编译和安装。 使用 plugin MySQL源代码分发目录 下的插件示例 作为指导。

创建 CMakeLists.txt ，应该看起来像这样：

MYSQL_ADD_PLUGIN（somepluglib somepluglib.c
  MODULE_ONLY MODULE_OUTPUT_NAME“somepluglib”）

当 CMake 生成时 Makefile ，它应该注意将 -DMYSQL_DYNAMIC_PLUGIN 标志 传递给编译命令 ，并向链接器传递 -lmysqlservices 标志，该标志是通过插件服务接口提供的服务链接任何函数所需的。 请参见 第29.3节“用于插件的MySQL服务” 。

运行 CMake ，然后运行 make ：

shell> cmake .
shell>make

如果需要为 CMake 指定配置选项 ，请参见 第2.9.4节“MySQL源配置选项” 以获取列表。 例如，您可能希望指定 CMAKE_INSTALL_PREFIX 指示应安装插件的MySQL基本目录。 您可以通过以下方式查看此选项使用的值 SHOW VARIABLES ：

MySQL的> SHOW VARIABLES LIKE 'basedir';
+ --------------- + ------------------ +
| Variable_name | 价值|
+ --------------- + ------------------ +
| 基地| / usr / local / mysql |
+ --------------- + ------------------ +

您应该安装库的插件目录的位置由 plugin_dir 系统变量 给出 。 例如：

MySQL的> SHOW VARIABLES LIKE 'plugin_dir';
+ --------------- + --------------------------------- -  +
| Variable_name | 价值|
+ --------------- + --------------------------------- -  +
| plugin_dir | / usr / local / mysql / lib / mysql / plugin |
+ --------------- + --------------------------------- -  +

要安装插件库，请使用 make ：

外壳> make install

验证 make install 是否 在正确的目录中安装了插件库。 安装后，请确保库权限允许服务器执行它。

MySQL支持服务器端全文解析器插件 MyISAM 和 InnoDB 。 有关全文解析器插件的介绍性信息，请参阅 全文解析器插件 。

全文解析器插件可用于替换或修改内置的全文解析器。 本节介绍如何编写名为的全文解析器插件 simple_parser 。 此插件基于比MySQL内置全文解析器使用的规则更简单的规则执行解析：单词是空白字符的非空运行。

说明使用 plugin/fulltext MySQL源代码分发目录中 的源代码 ，因此将位置更改为该目录。 以下过程描述了如何创建插件库：

守护程序插件是一种简单类型的插件，用于应由服务器运行但不与之通信的代码。 本节介绍如何使用 plugin/daemon_example MySQL源代码分发目录中 的示例插件编写守护程序服务器插件 。 该目录包含 daemon_example.cc 名为守护进程插件 的 源文件，该守护进程插件以固定 daemon_example 间隔将心跳字符串写入 mysql-heartbeat.log 数据目录中 指定的文件 。

要编写守护程序插件，请在插件源文件中包含以下头文件。 根据插件的功能和要求，可能还需要其他MySQL或通用头文件。

#include <mysql / plugin.h>

plugin.h 定义 MYSQL_DAEMON_PLUGIN 服务器插件类型和声明插件所需的数据结构。

该 daemon_example.cc 文件设置库描述符如下。 库描述符包括单个通用服务器插件描述符。

mysql_declare_plugin（daemon_example）
{
  MYSQL_DAEMON_PLUGIN，
  ＆daemon_example_plugin，
  “daemon_example”
  “Brian Aker”，
  “守护进程示例，在mysql-heartbeat.log中创建一个心跳节拍文件”，
  PLUGIN_LICENSE_GPL，
  daemon_example_plugin_init，/ *插件初始化* /
  daemon_example_plugin_deinit，/ *插件Deinit * /
  0x0100 / * 1.0 * /，
  NULL，/ *状态变量* /
  NULL，/ *系统变量* /
  NULL，/ * config选项* /
  0，/ *标志* /
}
mysql_declare_plugin_end;

所述 name 构件（ daemon_example ）指示要用于如在语句中的插件的引用名称 INSTALL PLUGIN 或 UNINSTALL PLUGIN 。 这也是由 SHOW PLUGINS 或 显示的名称 INFORMATION_SCHEMA.PLUGINS 。

插件描述符的第二个成员 daemon_example_plugin 指向特定于类型的守护程序插件描述符。 此结构仅包含特定于类型的API版本号：

struct st_mysql_daemon daemon_example_plugin =
{MYSQL_DAEMON_INTERFACE_VERSION};

特定于类型的结构没有接口功能。 服务器和插件之间没有通信，除了服务器从通用插件描述符调用初始化和取消初始化函数来启动和停止插件：

要编译和安装插件库文件，请使用 第29.2.4.3节“编译和安装插件库”中的说明 。 要使库文件可供使用，请将其安装在plugin目录（ plugin_dir 系统变量 指定的目录 ）中。 对于 daemon_example 插件，它是从源代码构建MySQL时编译和安装的。 它也包含在二进制分发中。 构建过程生成一个名称为的共享对象库 libdaemon_example.so （ .so 后缀可能因您的平台而异）。

要使用该插件，请将其注册到服务器。 例如，要在运行时注册插件，请使用此语句（ .so 根据需要 调整 平台 的 后缀）：

INSTALL PLUGIN daemon_example SONAME'ibdaemon_example.so';

有关插件加载的其他信息，请参见 第5.6.1节“安装和卸载插件” 。

要验证插件安装，请检查 INFORMATION_SCHEMA.PLUGINS 表或使用该 SHOW PLUGINS 语句。 请参见 第5.6.2节“获取服务器插件信息” 。

在加载插件时，它会定期将心跳字符串写入 mysql-heartbeat.log 数据目录中 指定的文件 。 此文件无限制地增长，因此在您满意自己插件正常运行后，请将其卸载：

UNINSTALL PLUGIN daemon_example;

本节介绍如何编写服务器端 INFORMATION_SCHEMA 表插件。 例如，实现此类插件的代码，请参阅 sql/sql_show.cc MySQL源代码分发 的 文件。 您还可以查看 InnoDB 源代码 中的示例插件 。 请参阅 源树中 的 handler/i_s.cc 和 handler/ha_innodb.cc 文件 InnoDB （在 storage/innobase 目录中）。

要编写 INFORMATION_SCHEMA 表插件，请在插件源文件中包含以下头文件。 根据插件的功能和要求，可能还需要其他MySQL或通用头文件。

#include <sql_class.h>
#include <table.h>

这些头文件位于 sql MySQL源代码分发目录中。 它们包含C ++结构，因此 INFORMATION_SCHEMA 插件 的源文件 必须编译为C ++代码。

这里开发的示例插件的源文件名为 simple_i_s_table.cc 。 它创建一个 INFORMATION_SCHEMA 名为 的简单 表 SIMPLE_I_S_TABLE ，其中有两列名为 NAME 和 VALUE 。 实现该表的插件库的一般描述符如下所示：

mysql_declare_plugin（simple_i_s_library）
{
  MYSQL_INFORMATION_SCHEMA_PLUGIN，
  ＆simple_table_info，/ *特定于类型的描述符* /
  “SIMPLE_I_S_TABLE”，/ *表名* /
  “作者姓名”，/ *作者* /
  “简单INFORMATION_SCHEMA表”，/ *说明* /
  PLUGIN_LICENSE_GPL，/ *许可证类型* /
  simple_table_init，/ * init函数* /
  空值，
  0x0100，/ *版本= 1.0 * /
  NULL，/ *没有状态变量* /
  NULL，/ *没有系统变量* /
  NULL，/ *没有保留信息* /
  0 / *没有标志* /
}
mysql_declare_plugin_end;

所述 name 构件（ SIMPLE_I_S_TABLE ）指示要用于如在语句中的插件的引用名称 INSTALL PLUGIN 或 UNINSTALL PLUGIN 。 这也是由 SHOW PLUGINS 或 显示的名称 INFORMATION_SCHEMA.PLUGINS 。

simple_table_info 通用描述符 的 成员指向特定于类型的描述符，该描述符仅包含特定于类型的API版本号：

static struct st_mysql_information_schema simple_table_info =
{MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION};

通用描述符指向初始化和取消初始化函数：

初始化函数应该返回0表示成功，如果发生错误则返回1。 该函数接收一个通用指针，它应该解释为指向表结构的指针：

static int table_init（void * ptr）
{
  ST_SCHEMA_TABLE * schema_table =（ST_SCHEMA_TABLE *）ptr;

  schema_table-> fields_info = simple_table_fields;
  schema_table-> fill_table = simple_fill_table;
  返回0;
}

该函数应该设置表结构的这两个成员：

指向的数组 fields_info 应该包含每个列的一个元素 INFORMATION_SCHEMA 加上一个终止元素。 simple_table_fields 示例插件 的以下 数组表示它 SIMPLE_I_S_TABLE 有两列。 NAME 是字符串值，长度为10， VALUE 是整数值，显示宽度为20.最后一个结构标记数组的结尾。

static ST_FIELD_INFO simple_table_fields [] =
{
  {“NAME”，10，MYSQL_TYPE_STRING，0,0 0,0}，
  {“VALUE”，6，MYSQL_TYPE_LONG，0，MY_I_S_UNSIGNED，0,0}，
  {0,0，MYSQL_TYPE_NULL，0,0,0,0}
};

有关列的信息结构的更多信息，请参阅的定义 ST_FIELD_INFO 在 table.h 头文件中。 允许的 类型值是C API中使用的值; 请参见 第28.7.5节“C API数据结构” 。 MYSQL_TYPE_xxx

该 fill_table 成员应设置为填充表的函数，并返回0表示成功，如果发生错误则返回1。 对于示例插件，该 simple_fill_table() 函数如下所示：

static int simple_fill_table（THD * thd，TABLE_LIST * tables，Item * cond）
{
  TABLE * table = tables-> table;

  table-> field [0]  - > store（“Name 1”，6，system_charset_info）;
  表 - >字段[1]  - >存储（1）;
  if（schema_table_store_record（thd，table））
    返回1;
  table-> field [0]  - > store（“Name 2”，6，system_charset_info）;
  表 - >字段[1]  - >存储器（2）;
  if（schema_table_store_record（thd，table））
    返回1;
  返回0;
}

对于 INFORMATION_SCHEMA 表的 每一行 ，此函数初始化每列，然后调用 schema_table_store_record() 以安装该行。 该 store() 参数取决于的值的类型的方法来被存储。 对于第0列（ NAME ，字符串）， store() 获取指向字符串的指针，其长度以及有关字符串字符集的信息：

store（const char * to，uint length，CHARSET_INFO * cs）;

对于第1列（ VALUE ，整数）， store() 取值和一个标志，指示它是否为无符号：

store（longlong nr，bool unsigned_value）;

有关如何填充 INFORMATION_SCHEMA 表的 其他示例 ，请搜索 schema_table_store_record() in的 实例 sql_show.cc 。

要编译和安装插件库文件，请使用 第29.2.4.3节“编译和安装插件库”中的说明 。 要使库文件可供使用，请将其安装在plugin目录（ plugin_dir 系统变量 指定的目录 ）中。

要测试插件，请安装它：

MySQL的> INSTALL PLUGIN SIMPLE_I_S_TABLE SONAME 'simple_i_s_table.so';

验证表是否存在：

mysql> SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES
    - >WHERE TABLE_NAME = 'SIMPLE_I_S_TABLE';
+ ------------------ +
| TABLE_NAME |
+ ------------------ +
| SIMPLE_I_S_TABLE |
+ ------------------ +

尝试从中进行选择：

MySQL的> SELECT * FROM INFORMATION_SCHEMA.SIMPLE_I_S_TABLE;
+ -------- + ------- +
| NAME | 价值|
+ -------- + ------- +
| 名称1 | 1 |
| 名称2 | 2 |
+ -------- + ------- +

卸载它：

MySQL的> UNINSTALL PLUGIN SIMPLE_I_S_TABLE;

本节介绍如何使用 plugin/semisync MySQL源代码分发目录中 的示例插件编写服务器端半同步复制插件 。 该目录包含名为 rpl_semi_sync_master 和的 主插件和从属插件的源文件 rpl_semi_sync_slave 。 这里的信息仅包括如何设置插件框架。 有关插件如何实现复制功能的详细信息，请参阅源代码。

要编写半同步复制插件，请在插件源文件中包含以下头文件。 根据插件的功能和要求，可能还需要其他MySQL或通用头文件。

#include <mysql / plugin.h>

plugin.h 定义 MYSQL_REPLICATION_PLUGIN 服务器插件类型和声明插件所需的数据结构。

对于主端， semisync_master_plugin.cc 包含一个名为的插件的通用描述符 rpl_semi_sync_master ：

mysql_declare_plugin（semi_sync_master）
{
  MYSQL_REPLICATION_PLUGIN，
  ＆semi_sync_master_plugin，
  “rpl_semi_sync_master”
  “何振兴”，
  “半同步复制主机”，
  PLUGIN_LICENSE_GPL，
  semi_sync_master_plugin_init，/ * Plugin Init * /
  semi_sync_master_plugin_deinit，/ *插件Deinit * /
  0x0100 / * 1.0 * /，
  semi_sync_master_status_vars，/ *状态变量* /
  semi_sync_master_system_vars，/ *系统变量* /
  NULL，/ * config选项* /
  0，/ *标志* /
}
mysql_declare_plugin_end;

对于slave端， semisync_slave_plugin.cc 包含一个名为的插件的通用描述符 rpl_semi_sync_slave ：

mysql_declare_plugin（semi_sync_slave）
{
  MYSQL_REPLICATION_PLUGIN，
  ＆semi_sync_slave_plugin，
  “rpl_semi_sync_slave”
  “何振兴”，
  “半同步复制从属”，
  PLUGIN_LICENSE_GPL，
  semi_sync_slave_plugin_init，/ * Plugin Init * /
  semi_sync_slave_plugin_deinit，/ *插件Deinit * /
  0x0100 / * 1.0 * /，
  semi_sync_slave_status_vars，/ *状态变量* /
  semi_sync_slave_system_vars，/ *系统变量* /
  NULL，/ * config选项* /
  0，/ *标志* /
}
mysql_declare_plugin_end;

对于主插件和从插件，通用描述符具有指向特定于类型的描述符，初始化和取消初始化函数以及插件实现的状态和系统变量的指针。 有关变量设置的信息，请参见 第29.2.4.2.2节“服务器插件状态和系统变量” 。 以下注释讨论了类型特定的描述符以及主插件的初始化和取消初始化函数，但类似地应用于从插件。

semi_sync_master_plugin 主通用描述符 的 成员指向特定于类型的描述符，该描述符仅包含特定于类型的API版本号：

struct Mysql_replication semi_sync_master_plugin = {
  MYSQL_REPLICATION_INTERFACE_VERSION
};

初始化和取消初始化函数声明如下所示：

static int semi_sync_master_plugin_init（void * p）;
static int semi_sync_master_plugin_deinit（void * p）;

初始化函数使用指针向服务器注册事务和二进制日志 “ 观察者 ” 。 成功初始化后，服务器负责在适当的时间调用观察者。 （有关观察者的详细信息，请参阅源文件。）通过取消注册观察者来清除取消初始化函数。 每个函数返回0表示成功，如果发生错误则返回1。

要编译和安装插件库文件，请使用 第29.2.4.3节“编译和安装插件库”中的说明 。 要使库文件可供使用，请将其安装在plugin目录（ plugin_dir 系统变量 指定的目录 ）中。 对于 rpl_semi_sync_master 和 rpl_semi_sync_slave 插件，从源代码构建MySQL时会编译和安装它们。 它们也包含在二进制分发中。 构建过程生成名称为 semisync_master.so 和的 共享对象库 semisync_slave.so （ .so 后缀可能因您的平台而异）。

本节介绍如何使用 plugin/audit_null MySQL源代码分发目录中 的示例插件编写服务器端审计插件 。 该 目录中的源文件 audit_null.c 和 audit_null_variables.h 文件实现了一个名为的审计插件 NULL_AUDIT 。

在服务器内，可插拔审计接口在 MySQL源代码分发目录 中的 sql_audit.h 和 sql_audit.cc 文件中 实现 sql 。 此外，当发生可审计事件时，服务器中的多个位置会调用审计接口，以便在必要时通知已注册的审计插件。 要查看此类调用发生的位置，请在服务器源文件中搜索具有表单名称的函数调用 。 服务器操作发生审核通知，例如： mysql_audit_xxx()

要编写审计插件，请在插件源文件中包含以下头文件。 根据插件的功能和要求，可能还需要其他MySQL或通用头文件。

#include <mysql / plugin_audit.h>

plugin_audit.h 包含 plugin.h ，因此您无需明确包含后一个文件。 plugin.h 定义 MYSQL_AUDIT_PLUGIN 服务器插件类型和声明插件所需的数据结构。 plugin_audit.h 定义特定于审计插件的数据结构。

mysql_declare_plugin（audit_null）
{
  MYSQL_AUDIT_PLUGIN，/ * type * /
  ＆audit_null_descriptor，/ *描述符* /
  “NULL_AUDIT”，/ * name * /
  “甲骨文公司”，/ *作者* /
  “Simple NULL Audit”，/ * description * /
  PLUGIN_LICENSE_GPL，
  audit_null_plugin_init，/ * init函数（加载时）* /
  audit_null_plugin_deinit，/ * deinit函数（卸载时）* /
  0x0003，/ *版本* /
  simple_status，/ *状态变量* /
  system_variables，/ *系统变量* /
  空值，
  0，
}
mysql_declare_plugin_end;

struct st_mysql_audit
{
  int interface_version;
  void（* release_thd）（MYSQL_THD）;
  int（* event_notify）（MYSQL_THD，mysql_event_class_t，const void *）;
  unsigned long class_mask [MYSQL_AUDIT_CLASS_MASK_SIZE];
};

event_notify函数：
  如果需要内存来服务线程
    分配内存
  ...其余的通知处理......

release_thd函数：
  如果分配了内存
    释放记忆
  ...其余的发布处理......

static struct st_mysql_audit audit_null_descriptor =
{
  MYSQL_AUDIT_INTERFACE_VERSION，/ *接口版本* /
  NULL，/ * release_thd函数* /
  audit_null_notify，/ * notify function * /
  {（unsigned long）MYSQL_AUDIT_GENERAL_ALL，
    （unsigned long）MYSQL_AUDIT_CONNECTION_ALL，
    （unsigned long）MYSQL_AUDIT_PARSE_ALL，
    （unsigned long）MYSQL_AUDIT_AUTHORIZATION_ALL，
    （unsigned long）MYSQL_AUDIT_TABLE_ACCESS_ALL，
    （unsigned long）MYSQL_AUDIT_GLOBAL_VARIABLE_ALL，
    （unsigned long）MYSQL_AUDIT_SERVER_STARTUP_ALL，
    （unsigned long）MYSQL_AUDIT_SERVER_SHUTDOWN_ALL，
    （unsigned long）MYSQL_AUDIT_COMMAND_ALL，
    （unsigned long）MYSQL_AUDIT_QUERY_ALL，
    （unsigned long）MYSQL_AUDIT_STORED_PROGRAM_ALL}
};

typedef enum
{
  MYSQL_AUDIT_GENERAL_CLASS = 0，
  MYSQL_AUDIT_CONNECTION_CLASS = 1，
  MYSQL_AUDIT_PARSE_CLASS = 2，
  MYSQL_AUDIT_AUTHORIZATION_CLASS = 3，
  MYSQL_AUDIT_TABLE_ACCESS_CLASS = 4，
  MYSQL_AUDIT_GLOBAL_VARIABLE_CLASS = 5，
  MYSQL_AUDIT_SERVER_STARTUP_CLASS = 6，
  MYSQL_AUDIT_SERVER_SHUTDOWN_CLASS = 7，
  MYSQL_AUDIT_COMMAND_CLASS = 8，
  MYSQL_AUDIT_QUERY_CLASS = 9，
  MYSQL_AUDIT_STORED_PROGRAM_CLASS = 10，
  / *此项必须在列表的最后。* /
  MYSQL_AUDIT_CLASS_MASK_SIZE
} mysql_event_class_t;

typedef enum
{
  认证阶段完成后发生/ **。* /
  MYSQL_AUDIT_CONNECTION_CONNECT = 1 << 0，
  连接终止后发生/ **。* /
  MYSQL_AUDIT_CONNECTION_DISCONNECT = 1 << 1，
  / **在COM_CHANGE_USER RPC完成后发生。* /
  MYSQL_AUDIT_CONNECTION_CHANGE_USER = 1 << 2，
  / **在认证之前发生。* /
  MYSQL_AUDIT_CONNECTION_PRE_AUTHENTICATE = 1 << 3
} mysql_event_connection_subclass_t;

#define MYSQL_AUDIT_CONNECTION_ALL（MYSQL_AUDIT_CONNECTION_CONNECT | \
                                    MYSQL_AUDIT_CONNECTION_DISCONNECT | \
                                    MYSQL_AUDIT_CONNECTION_CHANGE_USER | \
                                    MYSQL_AUDIT_CONNECTION_PRE_AUTHENTICATE）

MYSQL_AUDIT_CONNECTION_CONNECT | MYSQL_AUDIT_CONNECTION_CHANGE_USER

int（* event_notify）（MYSQL_THD，mysql_event_class_t，const void *）;

static int audit_null_notify（MYSQL_THD thd __attribute __（（unused）），
                             mysql_event_class_t event_class，
                             const void * event）
{
  ...

  number_of_calls ++;

  if（event_class == MYSQL_AUDIT_GENERAL_CLASS）
  {
    const struct mysql_event_general * event_general =
                                    （const struct mysql_event_general *）事件;
    ...
  }
  else if（event_class == MYSQL_AUDIT_CONNECTION_CLASS）
  {
    const struct mysql_event_connection * event_connection =
                                （const struct mysql_event_connection *）事件;
    ...

  }
  else if（event_class == MYSQL_AUDIT_PARSE_CLASS）
  {
    const struct mysql_event_parse * event_parse =
                                      （const struct mysql_event_parse *）事件;
    ...
  }
  ...
}

else if（event_class == MYSQL_AUDIT_CONNECTION_CLASS）
{
  const struct mysql_event_connection * event_connection =
                              （const struct mysql_event_connection *）事件;

  switch（event_connection-> event_subclass）
  {
  case MYSQL_AUDIT_CONNECTION_CONNECT：
    number_of_calls_connection_connect ++;
    打破;
  case MYSQL_AUDIT_CONNECTION_DISCONNECT：
    number_of_calls_connection_disconnect ++;
    打破;
  case MYSQL_AUDIT_CONNECTION_CHANGE_USER：
    number_of_calls_connection_change_user ++;
    打破;
  case MYSQL_AUDIT_CONNECTION_PRE_AUTHENTICATE：
    number_of_calls_connection_pre_authenticate ++;
      打破;
  默认：
    打破;
  }
}