← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin.h

  • Committer: Brian Aker
  • Date: 2009-03-20 18:52:05 UTC
  • mfrom: (950.1.1 mordred)
  • Revision ID: brian@tangent.org-20090320185205-g7o6kq17r25b6odf
Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin.h
20
20
#ifndef DRIZZLED_PLUGIN_H
21
21
#define DRIZZLED_PLUGIN_H
22
22
 
23
 
#include <boost/program_options.hpp>
24
 
#include <boost/filesystem.hpp>
25
 
 
26
 
#include "drizzled/module/manifest.h"
27
 
#include "drizzled/module/module.h"
28
 
#include "drizzled/plugin/version.h"
29
 
#include "drizzled/module/context.h"
30
 
#include "drizzled/definitions.h"
31
 
 
32
 
#include "drizzled/lex_string.h"
33
 
#include "drizzled/sys_var.h"
34
 
#include "drizzled/xid.h"
35
 
 
36
 
namespace drizzled
37
 
{
 
23
#include <drizzled/global.h>
 
24
#include <drizzled/lex_string.h>
 
25
#include <drizzled/xid.h>
38
26
 
39
27
class Session;
40
28
class Item;
41
 
struct charset_info_st;
42
29
 
43
30
/*************************************************************************
44
31
  Plugin API. Common for all plugin types.
45
32
*/
46
33
 
47
 
 
48
 
class sys_var;
49
 
typedef drizzle_lex_string LEX_STRING;
50
 
struct option;
51
 
 
52
 
extern boost::filesystem::path plugin_dir;
53
 
 
54
 
namespace plugin { class StorageEngine; }
 
34
/*
 
35
  The allowable types of plugins
 
36
*/
 
37
enum drizzle_plugin_type {
 
38
  DRIZZLE_DAEMON_PLUGIN,                /* Daemon / Raw */
 
39
  DRIZZLE_STORAGE_ENGINE_PLUGIN,        /* Storage Engine */
 
40
  DRIZZLE_INFORMATION_SCHEMA_PLUGIN,    /* Information Schema */
 
41
  DRIZZLE_UDF_PLUGIN,                   /* User-Defined Function */
 
42
  DRIZZLE_UDA_PLUGIN,                   /* User-Defined Aggregate Function */
 
43
  DRIZZLE_AUDIT_PLUGIN,                 /* Audit */
 
44
  DRIZZLE_LOGGER_PLUGIN,                /* Query Logging */
 
45
  DRIZZLE_ERRMSG_PLUGIN,                /* Error Messages */
 
46
  DRIZZLE_AUTH_PLUGIN,                  /* Authorization */
 
47
  DRIZZLE_CONFIGVAR_PLUGIN,             /* Configuration Variables */
 
48
  DRIZZLE_QCACHE_PLUGIN,                /* Query Cache */
 
49
  DRIZZLE_PARSER_PLUGIN,                /* Language Parser */
 
50
  DRIZZLE_SCHEDULING_PLUGIN,            /* Thread and Session Scheduling */
 
51
  DRIZZLE_REPLICATOR_PLUGIN,            /* Database Replication */
 
52
  DRIZZLE_PLUGIN_MAX=DRIZZLE_REPLICATOR_PLUGIN
 
53
};
 
54
 
 
55
/* The number of plugin types */
 
56
const uint32_t DRIZZLE_MAX_PLUGIN_TYPE_NUM=DRIZZLE_PLUGIN_MAX+1;
 
57
 
 
58
/* We use the following strings to define licenses for plugins */
 
59
enum plugin_license_type {
 
60
  PLUGIN_LICENSE_PROPRIETARY,
 
61
  PLUGIN_LICENSE_GPL,
 
62
  PLUGIN_LICENSE_BSD,
 
63
  PLUGIN_LICENSE_LGPL,
 
64
  PLUGIN_LICENSE_MAX=PLUGIN_LICENSE_LGPL
 
65
};
 
66
 
 
67
const char * const PLUGIN_LICENSE_PROPRIETARY_STRING="PROPRIETARY";
 
68
const char * const PLUGIN_LICENSE_GPL_STRING="GPL";
 
69
const char * const PLUGIN_LICENSE_BSD_STRING="BSD";
 
70
const char * const PLUGIN_LICENSE_LGPL_STRING="LGPL";
55
71
 
56
72
/*
57
73
  Macros for beginning and ending plugin declarations. Between
58
 
  DRIZZLE_DECLARE_PLUGIN and DRIZZLE_DECLARE_PLUGIN_END there should
59
 
  be a module::Manifest for each plugin to be declared.
60
 
*/
61
 
 
62
 
 
63
 
#define PANDORA_CPP_NAME(x) _drizzled_ ## x ## _plugin_
64
 
#define PANDORA_PLUGIN_NAME(x) PANDORA_CPP_NAME(x)
65
 
#define DRIZZLE_DECLARE_PLUGIN \
66
 
  ::drizzled::module::Manifest PANDORA_PLUGIN_NAME(PANDORA_MODULE_NAME)= 
67
 
 
68
 
 
69
 
#define DRIZZLE_DECLARE_PLUGIN_END
70
 
#define DRIZZLE_PLUGIN(init,system,options) \
71
 
  DRIZZLE_DECLARE_PLUGIN \
72
 
  { \
73
 
    DRIZZLE_VERSION_ID, \
74
 
    STRINGIFY_ARG(PANDORA_MODULE_NAME), \
75
 
    STRINGIFY_ARG(PANDORA_MODULE_VERSION), \
76
 
    STRINGIFY_ARG(PANDORA_MODULE_AUTHOR), \
77
 
    STRINGIFY_ARG(PANDORA_MODULE_TITLE), \
78
 
    PANDORA_MODULE_LICENSE, \
79
 
    init, system, options \
80
 
  } 
81
 
 
82
 
 
 
74
  drizzle_declare_plugin and drizzle_declare_plugin_end there should
 
75
  be a st_mysql_plugin struct for each plugin to be declared.
 
76
*/
 
77
 
 
78
 
 
79
#ifndef DRIZZLE_DYNAMIC_PLUGIN
 
80
#define __DRIZZLE_DECLARE_PLUGIN(NAME, DECLS) \
 
81
struct st_mysql_plugin DECLS[]= {
 
82
#else
 
83
#define __DRIZZLE_DECLARE_PLUGIN(NAME, DECLS) \
 
84
struct st_mysql_plugin _mysql_plugin_declarations_[]= {
 
85
#endif
 
86
 
 
87
#define drizzle_declare_plugin(NAME) \
 
88
__DRIZZLE_DECLARE_PLUGIN(NAME, \
 
89
                 builtin_ ## NAME ## _plugin)
 
90
 
 
91
#define drizzle_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0,0}}
 
92
 
 
93
/*
 
94
  declarations for SHOW STATUS support in plugins
 
95
*/
 
96
enum enum_mysql_show_type
 
97
{
 
98
  SHOW_UNDEF, SHOW_BOOL, SHOW_INT, SHOW_LONG,
 
99
  SHOW_LONGLONG, SHOW_CHAR, SHOW_CHAR_PTR,
 
100
  SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE, SHOW_SIZE
 
101
};
 
102
 
 
103
struct st_mysql_show_var {
 
104
  const char *name;
 
105
  char *value;
 
106
  enum enum_mysql_show_type type;
 
107
};
 
108
 
 
109
 
 
110
#define SHOW_VAR_FUNC_BUFF_SIZE 1024
 
111
typedef int (*mysql_show_var_func)(Session *, struct st_mysql_show_var *, char *);
 
112
 
 
113
struct st_show_var_func_container {
 
114
  mysql_show_var_func func;
 
115
};
83
116
/*
84
117
  declarations for server variables and command line options
85
118
*/
90
123
#define PLUGIN_VAR_LONG         0x0003
91
124
#define PLUGIN_VAR_LONGLONG     0x0004
92
125
#define PLUGIN_VAR_STR          0x0005
 
126
#define PLUGIN_VAR_ENUM         0x0006
 
127
#define PLUGIN_VAR_SET          0x0007
93
128
#define PLUGIN_VAR_UNSIGNED     0x0080
94
129
#define PLUGIN_VAR_SessionLOCAL     0x0100 /* Variable is per-connection */
95
130
#define PLUGIN_VAR_READONLY     0x0200 /* Server variable is read only */
100
135
#define PLUGIN_VAR_OPCMDARG     0x2000 /* Argument optional for cmd line */
101
136
#define PLUGIN_VAR_MEMALLOC     0x8000 /* String needs memory allocated */
102
137
 
103
 
struct drizzle_sys_var;
104
 
struct drizzle_value;
 
138
struct st_mysql_sys_var;
 
139
struct st_mysql_value;
105
140
 
106
141
/*
107
142
  SYNOPSIS
123
158
*/
124
159
 
125
160
typedef int (*mysql_var_check_func)(Session *session,
126
 
                                    drizzle_sys_var *var,
127
 
                                    void *save, drizzle_value *value);
 
161
                                    struct st_mysql_sys_var *var,
 
162
                                    void *save, struct st_mysql_value *value);
128
163
 
129
164
/*
130
165
  SYNOPSIS
141
176
   For example, strings may require memory to be allocated.
142
177
*/
143
178
typedef void (*mysql_var_update_func)(Session *session,
144
 
                                      drizzle_sys_var *var,
 
179
                                      struct st_mysql_sys_var *var,
145
180
                                      void *var_ptr, const void *save);
146
181
 
147
182
 
148
 
 
149
 
/*
150
 
  skeleton of a plugin variable - portion of structure common to all.
151
 
*/
152
 
struct drizzle_sys_var
153
 
{
154
 
};
155
 
 
156
 
void plugin_opt_set_limits(option *options, const drizzle_sys_var *opt);
157
 
 
158
 
struct drizzle_value
159
 
{
160
 
  int (*value_type)(drizzle_value *);
161
 
  const char *(*val_str)(drizzle_value *, char *buffer, int *length);
162
 
  int (*val_real)(drizzle_value *, double *realbuf);
163
 
  int (*val_int)(drizzle_value *, int64_t *intbuf);
 
183
/* the following declarations are for internal use only */
 
184
 
 
185
 
 
186
#define PLUGIN_VAR_MASK \
 
187
        (PLUGIN_VAR_READONLY | PLUGIN_VAR_NOSYSVAR | \
 
188
         PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_NOCMDARG | \
 
189
         PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC)
 
190
 
 
191
#define DRIZZLE_PLUGIN_VAR_HEADER \
 
192
  int flags;                    \
 
193
  const char *name;             \
 
194
  const char *comment;          \
 
195
  mysql_var_check_func check;   \
 
196
  mysql_var_update_func update
 
197
 
 
198
#define DRIZZLE_SYSVAR_NAME(name) mysql_sysvar_ ## name
 
199
#define DRIZZLE_SYSVAR(name) \
 
200
  ((struct st_mysql_sys_var *)&(DRIZZLE_SYSVAR_NAME(name)))
 
201
 
 
202
/*
 
203
  for global variables, the value pointer is the first
 
204
  element after the header, the default value is the second.
 
205
  for thread variables, the value offset is the first
 
206
  element after the header, the default value is the second.
 
207
*/
 
208
 
 
209
 
 
210
#define DECLARE_DRIZZLE_SYSVAR_BASIC(name, type) struct { \
 
211
  DRIZZLE_PLUGIN_VAR_HEADER;      \
 
212
  type *value;                  \
 
213
  const type def_val;           \
 
214
} DRIZZLE_SYSVAR_NAME(name)
 
215
 
 
216
#define DECLARE_DRIZZLE_SYSVAR_SIMPLE(name, type) struct { \
 
217
  DRIZZLE_PLUGIN_VAR_HEADER;      \
 
218
  type *value; type def_val;    \
 
219
  type min_val; type max_val;   \
 
220
  type blk_sz;                  \
 
221
} DRIZZLE_SYSVAR_NAME(name)
 
222
 
 
223
#define DECLARE_DRIZZLE_SYSVAR_TYPELIB(name, type) struct { \
 
224
  DRIZZLE_PLUGIN_VAR_HEADER;      \
 
225
  type *value; type def_val;    \
 
226
  TYPELIB *typelib;             \
 
227
} DRIZZLE_SYSVAR_NAME(name)
 
228
 
 
229
#define DECLARE_SessionVAR_FUNC(type) \
 
230
  type *(*resolve)(Session *session, int offset)
 
231
 
 
232
#define DECLARE_DRIZZLE_SessionVAR_BASIC(name, type) struct { \
 
233
  DRIZZLE_PLUGIN_VAR_HEADER;      \
 
234
  int offset;                   \
 
235
  const type def_val;           \
 
236
  DECLARE_SessionVAR_FUNC(type);    \
 
237
} DRIZZLE_SYSVAR_NAME(name)
 
238
 
 
239
#define DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, type) struct { \
 
240
  DRIZZLE_PLUGIN_VAR_HEADER;      \
 
241
  int offset;                   \
 
242
  type def_val; type min_val;   \
 
243
  type max_val; type blk_sz;    \
 
244
  DECLARE_SessionVAR_FUNC(type);    \
 
245
} DRIZZLE_SYSVAR_NAME(name)
 
246
 
 
247
#define DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, type) struct { \
 
248
  DRIZZLE_PLUGIN_VAR_HEADER;      \
 
249
  int offset;                   \
 
250
  type def_val;                 \
 
251
  DECLARE_SessionVAR_FUNC(type);    \
 
252
  TYPELIB *typelib;             \
 
253
} DRIZZLE_SYSVAR_NAME(name)
 
254
 
 
255
 
 
256
/*
 
257
  the following declarations are for use by plugin implementors
 
258
*/
 
259
 
 
260
#define DRIZZLE_SYSVAR_BOOL(name, varname, opt, comment, check, update, def) \
 
261
DECLARE_DRIZZLE_SYSVAR_BASIC(name, bool) = { \
 
262
  PLUGIN_VAR_BOOL | ((opt) & PLUGIN_VAR_MASK), \
 
263
  #name, comment, check, update, &varname, def}
 
264
 
 
265
#define DRIZZLE_SYSVAR_STR(name, varname, opt, comment, check, update, def) \
 
266
DECLARE_DRIZZLE_SYSVAR_BASIC(name, char *) = { \
 
267
  PLUGIN_VAR_STR | ((opt) & PLUGIN_VAR_MASK), \
 
268
  #name, comment, check, update, &varname, def}
 
269
 
 
270
#define DRIZZLE_SYSVAR_INT(name, varname, opt, comment, check, update, def, min, max, blk) \
 
271
DECLARE_DRIZZLE_SYSVAR_SIMPLE(name, int) = { \
 
272
  PLUGIN_VAR_INT | ((opt) & PLUGIN_VAR_MASK), \
 
273
  #name, comment, check, update, &varname, def, min, max, blk }
 
274
 
 
275
#define DRIZZLE_SYSVAR_UINT(name, varname, opt, comment, check, update, def, min, max, blk) \
 
276
DECLARE_DRIZZLE_SYSVAR_SIMPLE(name, unsigned int) = { \
 
277
  PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
278
  #name, comment, check, update, &varname, def, min, max, blk }
 
279
 
 
280
#define DRIZZLE_SYSVAR_LONG(name, varname, opt, comment, check, update, def, min, max, blk) \
 
281
DECLARE_DRIZZLE_SYSVAR_SIMPLE(name, long) = { \
 
282
  PLUGIN_VAR_LONG | ((opt) & PLUGIN_VAR_MASK), \
 
283
  #name, comment, check, update, &varname, def, min, max, blk }
 
284
 
 
285
#define DRIZZLE_SYSVAR_ULONG(name, varname, opt, comment, check, update, def, min, max, blk) \
 
286
DECLARE_DRIZZLE_SYSVAR_SIMPLE(name, unsigned long) = { \
 
287
  PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
288
  #name, comment, check, update, &varname, def, min, max, blk }
 
289
 
 
290
#define DRIZZLE_SYSVAR_LONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
 
291
DECLARE_DRIZZLE_SYSVAR_SIMPLE(name, int64_t) = { \
 
292
  PLUGIN_VAR_LONGLONG | ((opt) & PLUGIN_VAR_MASK), \
 
293
  #name, comment, check, update, &varname, def, min, max, blk }
 
294
 
 
295
#define DRIZZLE_SYSVAR_ULONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
 
296
DECLARE_DRIZZLE_SYSVAR_SIMPLE(name, uint64_t) = { \
 
297
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
298
  #name, comment, check, update, &varname, def, min, max, blk }
 
299
 
 
300
#define DRIZZLE_SYSVAR_ENUM(name, varname, opt, comment, check, update, def, typelib) \
 
301
DECLARE_DRIZZLE_SYSVAR_TYPELIB(name, unsigned long) = { \
 
302
  PLUGIN_VAR_ENUM | ((opt) & PLUGIN_VAR_MASK), \
 
303
  #name, comment, check, update, &varname, def, typelib }
 
304
 
 
305
#define DRIZZLE_SYSVAR_SET(name, varname, opt, comment, check, update, def, typelib) \
 
306
DECLARE_DRIZZLE_SYSVAR_TYPELIB(name, uint64_t) = { \
 
307
  PLUGIN_VAR_SET | ((opt) & PLUGIN_VAR_MASK), \
 
308
  #name, comment, check, update, &varname, def, typelib }
 
309
 
 
310
#define DRIZZLE_SessionVAR_BOOL(name, opt, comment, check, update, def) \
 
311
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char) = { \
 
312
  PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
313
  #name, comment, check, update, -1, def, NULL}
 
314
 
 
315
#define DRIZZLE_SessionVAR_STR(name, opt, comment, check, update, def) \
 
316
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char *) = { \
 
317
  PLUGIN_VAR_STR | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
318
  #name, comment, check, update, -1, def, NULL}
 
319
 
 
320
#define DRIZZLE_SessionVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
 
321
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int) = { \
 
322
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
323
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
324
 
 
325
#define DRIZZLE_SessionVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
 
326
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned int) = { \
 
327
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
328
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
329
 
 
330
#define DRIZZLE_SessionVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
 
331
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, long) = { \
 
332
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
333
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
334
 
 
335
#define DRIZZLE_SessionVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
 
336
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned long) = { \
 
337
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
338
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
339
 
 
340
#define DRIZZLE_SessionVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
341
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int64_t) = { \
 
342
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
343
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
344
 
 
345
#define DRIZZLE_SessionVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
346
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, uint64_t) = { \
 
347
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
348
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
349
 
 
350
#define DRIZZLE_SessionVAR_ENUM(name, opt, comment, check, update, def, typelib) \
 
351
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, unsigned long) = { \
 
352
  PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
353
  #name, comment, check, update, -1, def, NULL, typelib }
 
354
 
 
355
#define DRIZZLE_SessionVAR_SET(name, opt, comment, check, update, def, typelib) \
 
356
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, uint64_t) = { \
 
357
  PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
358
  #name, comment, check, update, -1, def, NULL, typelib }
 
359
 
 
360
/* accessor macros */
 
361
 
 
362
#define SYSVAR(name) \
 
363
  (*(DRIZZLE_SYSVAR_NAME(name).value))
 
364
 
 
365
/* when session == null, result points to global value */
 
366
#define SessionVAR(session, name) \
 
367
  (*(DRIZZLE_SYSVAR_NAME(name).resolve(session, DRIZZLE_SYSVAR_NAME(name).offset)))
 
368
 
 
369
 
 
370
/*
 
371
  Plugin description structure.
 
372
*/
 
373
 
 
374
struct st_mysql_plugin
 
375
{
 
376
  uint32_t type;        /* the plugin type (a DRIZZLE_XXX_PLUGIN value)   */
 
377
  const char *name;     /* plugin name (for SHOW PLUGINS)               */
 
378
  const char *version;  /* plugin version (for SHOW PLUGINS)            */
 
379
  const char *author;   /* plugin author (for SHOW PLUGINS)             */
 
380
  const char *descr;    /* general descriptive text (for SHOW PLUGINS ) */
 
381
  int license;          /* the plugin license (PLUGIN_LICENSE_XXX)      */
 
382
  int (*init)(void *);  /* the function to invoke when plugin is loaded */
 
383
  int (*deinit)(void *);/* the function to invoke when plugin is unloaded */
 
384
  struct st_mysql_show_var *status_vars;
 
385
  struct st_mysql_sys_var **system_vars;
 
386
  void *reserved1;   /* reserved for dependency checking             */
 
387
};
 
388
 
 
389
struct handlerton;
 
390
 
 
391
 
 
392
class Plugin
 
393
{
 
394
private:
 
395
  std::string name;
 
396
  std::string version;
 
397
  std::string author;
 
398
  std::string description;
 
399
 
 
400
public:
 
401
  Plugin(std::string in_name, std::string in_version,
 
402
         std::string in_author, std::string in_description)
 
403
    : name(in_name), version(in_version),
 
404
    author(in_author), description(in_description)
 
405
  {}
 
406
 
 
407
  virtual ~Plugin() {}
 
408
 
 
409
  virtual void add_functions() {}
 
410
 
 
411
};
 
412
 
 
413
/*************************************************************************
 
414
  st_mysql_value struct for reading values from mysqld.
 
415
  Used by server variables framework to parse user-provided values.
 
416
  Will be used for arguments when implementing UDFs.
 
417
 
 
418
  Note that val_str() returns a string in temporary memory
 
419
  that will be freed at the end of statement. Copy the string
 
420
  if you need it to persist.
 
421
*/
 
422
 
 
423
#define DRIZZLE_VALUE_TYPE_STRING 0
 
424
#define DRIZZLE_VALUE_TYPE_REAL   1
 
425
#define DRIZZLE_VALUE_TYPE_INT    2
 
426
 
 
427
struct st_mysql_value
 
428
{
 
429
  int (*value_type)(struct st_mysql_value *);
 
430
  const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
 
431
  int (*val_real)(struct st_mysql_value *, double *realbuf);
 
432
  int (*val_int)(struct st_mysql_value *, int64_t *intbuf);
164
433
};
165
434
 
166
435
 
168
437
  Miscellaneous functions for plugin implementors
169
438
*/
170
439
 
171
 
extern bool plugin_init(module::Registry &registry,
172
 
                        boost::program_options::options_description &long_options);
173
 
extern bool plugin_finalize(module::Registry &registry);
174
 
extern void my_print_help_inc_plugins(option *options);
175
 
extern bool plugin_is_ready(const LEX_STRING *name, int type);
176
 
extern void plugin_sessionvar_init(Session *session);
177
 
extern void plugin_sessionvar_cleanup(Session *session);
178
 
extern sys_var *intern_find_sys_var(const char *str, uint32_t, bool no_error);
 
440
#ifdef __cplusplus
 
441
extern "C" {
 
442
#endif
179
443
 
180
444
int session_in_lock_tables(const Session *session);
181
445
int session_tablespace_op(const Session *session);
183
447
const char *get_session_proc_info(Session *session);
184
448
int64_t session_test_options(const Session *session, int64_t test_options);
185
449
int session_sql_command(const Session *session);
186
 
enum_tx_isolation session_tx_isolation(const Session *session);
187
 
 
188
 
void compose_plugin_add(std::vector<std::string> options);
189
 
void compose_plugin_remove(std::vector<std::string> options);
190
 
void notify_plugin_load(std::string in_plugin_load);
 
450
void **session_ha_data(const Session *session, const struct handlerton *hton);
 
451
int session_tx_isolation(const Session *session);
 
452
/* Increments the row counter, see Session::row_count */
 
453
void session_inc_row_count(Session *session);
 
454
 
 
455
LEX_STRING *session_make_lex_string(Session *session, LEX_STRING *lex_str,
 
456
                                    const char *str, unsigned int size,
 
457
                                    int allocate_lex_string);
 
458
 
191
459
 
192
460
 
193
461
/**
200
468
 
201
469
  @param prefix  prefix for temporary file name
202
470
  @retval -1    error
203
 
  @retval >= 0  a file handle that can be passed to dup or internal::my_close
 
471
  @retval >= 0  a file handle that can be passed to dup or my_close
204
472
*/
205
473
int mysql_tmpfile(const char *prefix);
206
474
 
207
 
} /* namespace drizzled */
208
 
 
209
 
#endif /* DRIZZLED_PLUGIN_H */
 
475
/**
 
476
  Check the killed state of a connection
 
477
 
 
478
  @details
 
479
  In MySQL support for the KILL statement is cooperative. The KILL
 
480
  statement only sets a "killed" flag. This function returns the value
 
481
  of that flag.  A thread should check it often, especially inside
 
482
  time-consuming loops, and gracefully abort the operation if it is
 
483
  non-zero.
 
484
 
 
485
  @param session  user thread connection handle
 
486
  @retval 0  the connection is active
 
487
  @retval 1  the connection has been killed
 
488
*/
 
489
int session_killed(const Session *session);
 
490
 
 
491
 
 
492
/**
 
493
  Return the thread id of a user thread
 
494
 
 
495
  @param session  user thread connection handle
 
496
  @return  thread id
 
497
*/
 
498
unsigned long session_get_thread_id(const Session *session);
 
499
 
 
500
 
 
501
/**
 
502
  Allocate memory in the connection's local memory pool
 
503
 
 
504
  @details
 
505
  When properly used in place of @c malloc(), this can significantly
 
506
  improve concurrency. Don't use this or related functions to allocate
 
507
  large chunks of memory. Use for temporary storage only. The memory
 
508
  will be freed automatically at the end of the statement; no explicit
 
509
  code is required to prevent memory leaks.
 
510
 
 
511
  @see alloc_root()
 
512
*/
 
513
void *session_alloc(Session *session, unsigned int size);
 
514
/**
 
515
  @see session_alloc()
 
516
*/
 
517
void *session_calloc(Session *session, unsigned int size);
 
518
/**
 
519
  @see session_alloc()
 
520
*/
 
521
char *session_strdup(Session *session, const char *str);
 
522
/**
 
523
  @see session_alloc()
 
524
*/
 
525
char *session_strmake(Session *session, const char *str, unsigned int size);
 
526
/**
 
527
  @see session_alloc()
 
528
*/
 
529
void *session_memdup(Session *session, const void* str, unsigned int size);
 
530
 
 
531
/**
 
532
  Get the XID for this connection's transaction
 
533
 
 
534
  @param session  user thread connection handle
 
535
  @param xid  location where identifier is stored
 
536
*/
 
537
void session_get_xid(const Session *session, DRIZZLE_XID *xid);
 
538
 
 
539
/**
 
540
  Invalidate the query cache for a given table.
 
541
 
 
542
  @param session         user thread connection handle
 
543
  @param key         databasename\\0tablename\\0
 
544
  @param key_length  length of key in bytes, including the NUL bytes
 
545
  @param using_trx   flag: TRUE if using transactions, FALSE otherwise
 
546
*/
 
547
void mysql_query_cache_invalidate4(Session *session,
 
548
                                   const char *key, unsigned int key_length,
 
549
                                   int using_trx);
 
550
 
 
551
#ifdef __cplusplus
 
552
}
 
553
#endif
 
554
 
 
555
#ifdef __cplusplus
 
556
/**
 
557
  Provide a handler data getter to simplify coding
 
558
*/
 
559
inline
 
560
void *
 
561
session_get_ha_data(const Session *session, const struct handlerton *hton)
 
562
{
 
563
  return *session_ha_data(session, hton);
 
564
}
 
565
 
 
566
/**
 
567
  Provide a handler data setter to simplify coding
 
568
*/
 
569
inline
 
570
void
 
571
session_set_ha_data(const Session *session, const struct handlerton *hton,
 
572
                const void *ha_data)
 
573
{
 
574
  *session_ha_data(session, hton)= (void*) ha_data;
 
575
}
 
576
#endif
 
577
 
 
578
#endif /* _my_plugin_h */
210
579