This section describes how to write an INFORMATION_SCHEMA table server plugin. For example code that implements such plugins, see the sql/sql_show.cc file of a MySQL source distribution. You can also look at the example plugins found in the InnoDB source. See the handler/i_s.cc and handler/ha_innodb.cc files within the InnoDB source tree (in the storage/innobase directory).

To write an INFORMATION_SCHEMA table plugin, include the following header files in the plugin source file. Other MySQL or general header files might also be needed.

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

These header files are located in the sql directory of MySQL source distributions. They contain C++ structures, so the source file for an INFORMATION_SCHEMA plugin must be compiled as C++ (not C) code.

The source file for the example plugin developed here is named simple_i_s_table.cc. It creates a simple INFORMATION_SCHEMA table named SIMPLE_I_S_TABLE that has two columns named NAME and VALUE. The general descriptor for a plugin library that implements the table looks like this:

mysql_declare_plugin(simple_i_s_library){  MYSQL_INFORMATION_SCHEMA_PLUGIN,  &simple_table_info,                /* type-specific descriptor */  "SIMPLE_I_S_TABLE",                /* table name */  "Author Name",                     /* author */  "Simple INFORMATION_SCHEMA table", /* description */  PLUGIN_LICENSE_GPL,                /* license type */  simple_table_init,                 /* init function */  NULL,  0x0100,                            /* version = 1.0 */  NULL,                              /* no status variables */  NULL,                              /* no system variables */  NULL,                              /* no reserved information */  0                                  /* no flags */}mysql_declare_plugin_end;

The name member (SIMPLE_I_S_TABLE) indicates the name to use for references to the plugin in statements such as INSTALL PLUGIN or UNINSTALL PLUGIN. This is also the name displayed by SHOW PLUGINS or INFORMATION_SCHEMA.PLUGINS.

The simple_table_info member of the general descriptor points to the type-specific descriptor, which consists only of the type-specific API version number:

static struct st_mysql_information_schema simple_table_info ={ MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION };

The general descriptor points to the initialization and deinitialization functions:

The initialization function should return 0 for success, 1 if an error occurs. The function receives a generic pointer, which it should interpret as a pointer to the table structure:

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;  return 0;}

The function should set these two members of the table structure:

The array pointed to by fields_info should contain one element per column of the INFORMATION_SCHEMA plus a terminating element. The following simple_table_fields array for the example plugin indicates that SIMPLE_I_S_TABLE has two columns. NAME is string-valued with a length of 10 and VALUE is integer-valued with a display width of 20. The last structure marks the end of the array.

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}};

For more information about the column information structure, see the definition of ST_FIELD_INFO in the table.h header file. The permissible MYSQL_TYPE_xxx type values are those used in the C API; see Section 22.8.5, "C API Data Structures".

The fill_table member should be set to a function that populates the table and returns 0 for success, 1 if an error occurs. For the example plugin, the simple_fill_table() function looks like this:

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);  table->field[1]->store(1);  if (schema_table_store_record(thd, table))    return 1;  table->field[0]->store("Name 2", 6, system_charset_info);  table->field[1]->store(2);  if (schema_table_store_record(thd, table))    return 1;  return 0;}

For each row of the INFORMATION_SCHEMA table, this function initializes each column, then calls schema_table_store_record() to install the row. The store() method arguments depend on the type of value to be stored. For column 0 (NAME, a string), store() takes a pointer to a string, its length, and information about the character set of the string:

store(const char *to, uint length, CHARSET_INFO *cs);

For column 1 (VALUE, an integer), store() takes the value and a flag indicating whether it is unsigned:

store(longlong nr, bool unsigned_value);

For other examples of how to populate INFORMATION_SCHEMA tables, search for instances of schema_table_store_record() in sql_show.cc.

To compile and install a plugin library object file, see the instructions in Section 23.2.4.3, "Compiling and Installing Plugin Libraries". To use the library file, it must be installed in the plugin directory (the directory named by the plugin_dir system variable).

To test the plugin, install it:

mysql> INSTALL PLUGIN SIMPLE_I_S_TABLE SONAME
        'simple_i_s_table.so';

Verify that the table is present:

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

Try to select from it:

mysql> SELECT * FROM
        INFORMATION_SCHEMA.SIMPLE_I_S_TABLE;+--------+-------+| NAME   | VALUE |+--------+-------+| Name 1 |     1 || Name 2 |     2 |+--------+-------+

Uninstall it:

mysql> UNINSTALL PLUGIN
        SIMPLE_I_S_TABLE;