Rechercher dans le manuel MySQL
29.2.4.6 Writing INFORMATION_SCHEMA Plugins
This section describes how to write a server-side
INFORMATION_SCHEMA
table 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, depending on the plugin capabilities and requirements.
#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++ 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 provides information about the table structure and a function that populates the table.
The deinitialization function performs any required cleanup. If no cleanup is needed, this descriptor member can be
NULL
(as in the example shown).
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:
fields_info
: An array ofST_FIELD_INFO
structures that contain information about each column.fill_table
: A function that populates the table.
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_
type values are those used in the C API; see
Section 28.7.5, “C API Data Structures”.
xxx
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 file, use the
instructions in Section 29.2.4.3, “Compiling and Installing Plugin Libraries”.
To make the library file available for use, install it in the
plugin directory (the directory named by the
plugin_dir
system variable).
To test the plugin, install it:
Verify that the table is present:
- +------------------+
- | TABLE_NAME |
- +------------------+
- | SIMPLE_I_S_TABLE |
- +------------------+
Try to select from it:
- +--------+-------+
- +--------+-------+
- | Name 1 | 1 |
- | Name 2 | 2 |
- +--------+-------+
Uninstall it:
- mysql> UNINSTALL PLUGIN SIMPLE_I_S_TABLE;
Traduction non disponible
Le manuel MySQL n'est pas encore traduit en français sur l'infobrol. Seule la version anglaise est disponible pour l'instant.
Document créé le 26/06/2006, dernière modification le 26/10/2018
Source du document imprimé : https://www.gaudry.be/mysql-rf-writing-information-schema-plugins.html
L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.
Références
Ces références et liens indiquent des documents consultés lors de la rédaction de cette page, ou qui peuvent apporter un complément d'information, mais les auteurs de ces sources ne peuvent être tenus responsables du contenu de cette page.
L'auteur de ce site est seul responsable de la manière dont sont présentés ici les différents concepts, et des libertés qui sont prises avec les ouvrages de référence. N'oubliez pas que vous devez croiser les informations de sources multiples afin de diminuer les risques d'erreurs.