← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin.h

  • Committer: Monty Taylor
  • Date: 2008-10-22 21:31:15 UTC
  • Revision ID: monty@inaugust.com-20081022213115-xuxc80r939tl88p1
Renamed drizzle_common again. Removed sql_common. (empty) 
Now all we need to do is merge/disect base.h, common.h, common_includes.h, server_includes.h and globa.h (good grief)

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