23.2.4.2. Plugin Data Structures

mysql_declare_client_plugin(plugin_type)   ... members common to all client plugins ...   ... type-specific extra members ...mysql_end_client_plugin;

Every plugin library that contains server plugins must include a library descriptor that contains the general plugin descriptor for each server plugin in the file. This section discusses how to write the library and general descriptors for server plugins.

The library descriptor must define two symbols:

If the server does not find those two symbols in a library, it does not accept it as a legal plugin library and rejects it with an error. This prevents use of a library for plugin purposes unless it was built specifically as a plugin library.

The conventional way to define the two required symbols is by using the mysql_declare_plugin() and mysql_declare_plugin_end macros from the plugin.h file:

mysql_declare_plugin(name) ... one or more server plugin descriptors here ...mysql_declare_plugin_end;

Each server plugin must have a general descriptor that provides information to the server plugin API. The general descriptor has the same structure for all plugin types. The st_mysql_plugin structure in the plugin.h file defines this descriptor:

struct st_mysql_plugin{  int type;             /* the plugin type (a MYSQL_XXX_PLUGIN value)   */  void *info;           /* pointer to type-specific plugin descriptor   */  const char *name;     /* plugin name                                  */  const char *author;   /* plugin author (for I_S.PLUGINS)              */  const char *descr;    /* general descriptive text (for I_S.PLUGINS)   */  int license;          /* the plugin license (PLUGIN_LICENSE_XXX)      */  int (*init)(void *);  /* the function to invoke when plugin is loaded */  int (*deinit)(void *);/* the function to invoke when plugin is unloaded */  unsigned int version; /* plugin version (for I_S.PLUGINS)             */  struct st_mysql_show_var *status_vars;  struct st_mysql_sys_var **system_vars;  void * __reserved1;   /* reserved for dependency checking             */  unsigned long flags;  /* flags for plugin */};

The st_mysql_plugin descriptor structure members are used as follows. char * members should be specified as null-terminated strings.

The server invokes the init and deinit functions in the general plugin descriptor only when loading and unloading the plugin. They have nothing to do with use of the plugin such as happens when an SQL statement causes the plugin to be invoked.

For example, the descriptor information for a library that contains a single full-text parser plugin named simple_parser looks like this:

mysql_declare_plugin(ftexample){  MYSQL_FTPARSER_PLUGIN,      /* type                            */  &simple_parser_descriptor,  /* descriptor                      */  "simple_parser",            /* name                            */  "Oracle Corporation",       /* author                          */  "Simple Full-Text Parser",  /* description                     */  PLUGIN_LICENSE_GPL,         /* plugin license                  */  simple_parser_plugin_init,  /* init function (when loaded)     */  simple_parser_plugin_deinit,/* deinit function (when unloaded) */  0x0001,                     /* version                         */  simple_status,              /* status variables                */  simple_system_variables,    /* system variables                */  NULL,  0}mysql_declare_plugin_end;

For a full-text parser plugin, the type must be MYSQL_FTPARSER_PLUGIN. This is the value that identifies the plugin as being legal for use in a WITH PARSER clause when creating a FULLTEXT index. (No other plugin type is legal for this clause.)

plugin.h defines the mysql_declare_plugin() and mysql_declare_plugin_end macros like this:

#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[]= {#else#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_[]= {#endif#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}}

When the macros are used as just shown, they expand to the following code, which defines both of the required symbols (_mysql_plugin_interface_version_ and _mysql_plugin_declarations_):

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,  /* descriptor                      */  "simple_parser",            /* name                            */  "Oracle Corporation",       /* author                          */  "Simple Full-Text Parser",  /* description                     */  PLUGIN_LICENSE_GPL,         /* plugin license                  */  simple_parser_plugin_init,  /* init function (when loaded)     */  simple_parser_plugin_deinit,/* deinit function (when unloaded) */  0x0001,                     /* version                         */  simple_status,              /* status variables                */  simple_system_variables,    /* system variables                */  NULL,  0}  ,{0,0,0,0,0,0,0,0,0,0,0,0}}};

The preceding example declares a single plugin in the general descriptor, but it is possible to declare multiple plugins. List the declarations one after the other between mysql_declare_plugin() and mysql_declare_plugin_end, separated by commas.

MySQL server plugins can be written in C or C++ (or another language that can use C calling conventions). If you write a C++ plugin, one C++ feature that you should not use is nonconstant variables to initialize global structures. Members of structures such as the st_mysql_plugin structure should be initialized only with constant variables. The simple_parser descriptor shown earlier is permissible in a C++ plugin because it satisfies that requirement:

mysql_declare_plugin(ftexample){  MYSQL_FTPARSER_PLUGIN,      /* type                            */  &simple_parser_descriptor,  /* descriptor                      */  "simple_parser",            /* name                            */  "Oracle Corporation",       /* author                          */  "Simple Full-Text Parser",  /* description                     */  PLUGIN_LICENSE_GPL,         /* plugin license                  */  simple_parser_plugin_init,  /* init function (when loaded)     */  simple_parser_plugin_deinit,/* deinit function (when unloaded) */  0x0001,                     /* version                         */  simple_status,              /* status variables                */  simple_system_variables,    /* system variables                */  NULL,  0}mysql_declare_plugin_end;

Here is another valid way to write the general descriptor. It uses constant variables to indicate the plugin name, author, and description:

const char *simple_parser_name = "simple_parser";const char *simple_parser_author = "Oracle Corporation";const char *simple_parser_description = "Simple Full-Text Parser";mysql_declare_plugin(ftexample){  MYSQL_FTPARSER_PLUGIN,      /* type                            */  &simple_parser_descriptor,  /* descriptor                      */  simple_parser_name,         /* name                            */  simple_parser_author,       /* author                          */  simple_parser_description,  /* description                     */  PLUGIN_LICENSE_GPL,         /* plugin license                  */  simple_parser_plugin_init,  /* init function (when loaded)     */  simple_parser_plugin_deinit,/* deinit function (when unloaded) */  0x0001,                     /* version                         */  simple_status,              /* status variables                */  simple_system_variables,    /* system variables                */  NULL,  0}mysql_declare_plugin_end;

However, the following general descriptor is invalid. It uses structure members to indicate the plugin name, author, and description, but structures are not considered constant initializers in C++:

typedef struct{  const char *name;  const char *author;  const char *description;} plugin_info;plugin_info parser_info = {  "simple_parser",  "Oracle Corporation",  "Simple Full-Text Parser"};mysql_declare_plugin(ftexample){  MYSQL_FTPARSER_PLUGIN,      /* type                            */  &simple_parser_descriptor,  /* descriptor                      */  parser_info.name,           /* name                            */  parser_info.author,         /* author                          */  parser_info.description,    /* description                     */  PLUGIN_LICENSE_GPL,         /* plugin license                  */  simple_parser_plugin_init,  /* init function (when loaded)     */  simple_parser_plugin_deinit,/* deinit function (when unloaded) */  0x0001,                     /* version                         */  simple_status,              /* status variables                */  simple_system_variables,    /* system variables                */  NULL,  0}mysql_declare_plugin_end;

The server plugin interface enables plugins to expose status and system variables using the status_vars and system_vars members of the general plugin descriptor.

The status_vars member of the general plugin descriptor, if not 0, points to an array of st_mysql_show_var structures, each of which describes one status variable, followed by a structure with all members set to 0. The st_mysql_show_var structure has this definition:

struct st_mysql_show_var {  const char *name;  char *value;  enum enum_mysql_show_type type;};

When the plugin is installed, the plugin name and the name value are joined with an underscore to form the name displayed by SHOW STATUS.

The following table shows the permissible status variable type values and what the corresponding variable should be.

For the SHOW_FUNC type, the function is called and fills in its out parameter, which then provides information about the variable to be displayed. The function has this signature:

#define SHOW_VAR_FUNC_BUFF_SIZE 1024typedef int (*mysql_show_var_func) (void *thd,                                    struct st_mysql_show_var *out,                                    char *buf);

The system_vars member, if not 0, points to an array of st_mysql_sys_var structures, each of which describes one system variable (which can also be set from the command-line or configuration file), followed by a structure with all members set to 0. The st_mysql_sys_var structure is defined as follows:

struct st_mysql_sys_var { int flags; 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*);};

Additional fields are append as required depending upon the flags.

For convenience, a number of macros are defined that make creating new system variables within a plugin much simpler.

Throughout the macros, the following fields are available:

A system variable may be accessed either by using the static variable directly or by using the SYSVAR()accessor macro. The SYSVAR() macro is provided for completeness. Usually it should be used only when the code cannot directly access the underlying variable.

For example:

static int my_foo;static MYSQL_SYSVAR_INT(foo_var, my_foo,                         PLUGIN_VAR_RQCMDARG, "foo comment",                         NULL, NULL, 0, 0, INT_MAX, 0); ...   SYSVAR(foo_var)= value;   value= SYSVAR(foo_var);   my_foo= value;    value= my_foo;

Session variables may be accessed only through the THDVAR() accessor macro. For example:

static MYSQL_THDVAR_BOOL(some_flag,                          PLUGIN_VAR_NOCMDARG, "flag comment",                         NULL, NULL, FALSE); ...   if (THDVAR(thd, some_flag))   {     do_something();     THDVAR(thd, some_flag)= FALSE;   }

All global and session system variables must be published to mysqld before use. This is done by constructing a NULL-terminated array of the variables and linking to it in the plugin public interface. For example:

static struct st_mysql_sys_var *my_plugin_vars[]= {  MYSQL_SYSVAR(foo_var),  MYSQL_SYSVAR(some_flag),  NULL};mysql_declare_plugin(fooplug){  MYSQL_..._PLUGIN,  &plugin_data,  "fooplug",  "foo author",  "This does foo!",  PLUGIN_LICENSE_GPL,  foo_init,  foo_fini,  0x0001,  NULL,  my_plugin_vars,  NULL,  0}mysql_declare_plugin_end;

The following convenience macros enable you to declare different types of system variables:

Internally, all mutable and plugin system variables are stored in a HASH structure.

Display of the server command-line help text is handled by compiling a DYNAMIC_ARRAY of all variables relevant to command-line options, sorting them, and then iterating through them to display each option.

When a command-line option has been handled, it is then removed from the argv by the handle_option() function (my_getopt.c); in effect, it is consumed.

The server processes command-line options during the plugin installation process, immediately after the plugin has been successfully loaded but before the plugin initialization function has been called

Plugins loaded at runtime do not benefit from any configuration options and must have usable defaults. Once they are installed, they are loaded at mysqld initialization time and configuration options can be set at the command line or within my.cnf.

Plugins should consider the thd parameter to be read only.

Each client plugin must have a descriptor that provides information to the client plugin API. The descriptor structure begins with a fixed set of members common to all client plugins, followed by any members specific to the plugin type.

The st_mysql_client_plugin structure in the client_plugin.h file defines a "generic" descriptor that contains the common members:

struct st_mysql_client_plugin{  int type;  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 *);};

The common st_mysql_client_plugin descriptor structure members are used as follows. char * members should be specified as null-terminated strings.

For a given client plugin type, the common descriptor members may be followed by additional members necessary to implement plugins of that type. For example, the st_mysql_client_plugin_AUTHENTICATION structure for authentication plugins has a function at the end that the client library calls to perform authentication.

To declare a plugin, use the mysql_declare_client_plugin() and mysql_end_client_plugin macros:

mysql_declare_client_plugin(plugin_type)   ... members common to all client plugins ...   ... type-specific extra members ...mysql_end_client_plugin;

Do not specify the type or interface_version member explicitly. The mysql_declare_client_plugin() macro uses the plugin_type argument to generate their values automatically. For example, declare an authentication client plugin like this:

mysql_declare_client_plugin(AUTHENTICATION)  "my_auth_plugin",  "Author Name",  "My Client Authentication Plugin",  {1,0,0},  "GPL",  NULL,  my_auth_init,  my_auth_deinit,  my_auth_options,  my_auth_mainmysql_end_client_plugin;

This declaration uses the AUTHENTICATION argument to set the type and interface_version members to MYSQL_CLIENT_AUTHENTICATION_PLUGIN and MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION.

Depending on the plugin type, the descriptor may have other members following the common members. For example, for an authentication plugin, there is a function (my_auth_main() in the descriptor just shown) that handles communication with the server. See Section 23.2.4.9, "Writing Authentication Plugins".

Normally, a client program that supports the use of authentication plugins causes a plugin to be loaded by calling mysql_options() to set the MYSQL_DEFAULT_AUTH and MYSQL_PLUGIN_DIR options:

char *plugin_dir = "path_to_plugin_dir";char *default_auth = "plugin_name";/* ... process command-line options ... */mysql_options(&mysql, MYSQL_PLUGIN_DIR, plugin_dir);mysql_options(&mysql, MYSQL_DEFAULT_AUTH, default_auth);

Typically, the program will also accept --plugin-dir and --default-auth options that enable users to override the default values.

Should a client program require lower-level plugin management, the client library contains functions that take an st_mysql_client_plugin argument. See Section 22.8.14, "C API Client Plugin Functions".