← 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: 2009-06-08 13:39:05 UTC
  • mto: This revision was merged to the branch mainline in revision 1060.
  • Revision ID: mordred@inaugust.com-20090608133905-3hogrrafmfg6e5hs
Removed CHARSET_INFO stuff from protocol plugin interface - it makes no sense.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin.h
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#ifndef _my_plugin_h
21
 
#define _my_plugin_h
22
 
 
23
 
#include <drizzled/global.h>
24
 
 
25
 
#ifdef __cplusplus
26
 
class THD;
 
20
#ifndef DRIZZLED_PLUGIN_H
 
21
#define DRIZZLED_PLUGIN_H
 
22
 
 
23
#include <drizzled/lex_string.h>
 
24
#include <drizzled/xid.h>
 
25
 
 
26
class Session;
27
27
class Item;
28
 
#define DRIZZLE_THD THD*
29
 
#else
30
 
#define DRIZZLE_THD void*
31
 
#endif
32
 
 
33
 
 
34
 
#ifndef _m_string_h
35
 
/* This definition must match the one given in m_string.h */
36
 
struct st_mysql_lex_string
37
 
{
38
 
  char *str;
39
 
  unsigned int length;
40
 
};
41
 
#endif /* _m_string_h */
42
 
typedef struct st_mysql_lex_string DRIZZLE_LEX_STRING;
43
 
 
44
 
#define DRIZZLE_XIDDATASIZE 128
45
 
/**
46
 
  struct st_mysql_xid is binary compatible with the XID structure as
47
 
  in the X/Open CAE Specification, Distributed Transaction Processing:
48
 
  The XA Specification, X/Open Company Ltd., 1991.
49
 
  http://www.opengroup.org/bookstore/catalog/c193.htm
50
 
 
51
 
  @see XID in sql/handler.h
52
 
*/
53
 
struct st_mysql_xid {
54
 
  long formatID;
55
 
  long gtrid_length;
56
 
  long bqual_length;
57
 
  char data[DRIZZLE_XIDDATASIZE];  /* Not \0-terminated */
58
 
};
59
 
typedef struct st_mysql_xid DRIZZLE_XID;
60
28
 
61
29
/*************************************************************************
62
30
  Plugin API. Common for all plugin types.
63
31
*/
64
32
 
65
 
/*
66
 
  The allowable types of plugins
67
 
*/
68
 
#define DRIZZLE_DAEMON_PLUGIN          0  /* Daemon / Raw */
69
 
#define DRIZZLE_STORAGE_ENGINE_PLUGIN  1  /* Storage Engine */
70
 
#define DRIZZLE_INFORMATION_SCHEMA_PLUGIN  2  /* Information Schema */
71
 
#define DRIZZLE_UDF_PLUGIN             3  /* User-Defined Function */
72
 
#define DRIZZLE_UDA_PLUGIN             4  /* User-Defined Aggregate function */
73
 
#define DRIZZLE_AUDIT_PLUGIN           5  /* Audit */
74
 
#define DRIZZLE_LOGGER_PLUGIN          6  /* Logging */
75
 
#define DRIZZLE_AUTH_PLUGIN            7  /* Authorization */
76
 
 
77
 
#define DRIZZLE_MAX_PLUGIN_TYPE_NUM    8  /* The number of plugin types */
78
33
 
79
34
/* We use the following strings to define licenses for plugins */
80
 
#define PLUGIN_LICENSE_PROPRIETARY 0
81
 
#define PLUGIN_LICENSE_GPL 1
82
 
#define PLUGIN_LICENSE_BSD 2
 
35
enum plugin_license_type {
 
36
  PLUGIN_LICENSE_PROPRIETARY,
 
37
  PLUGIN_LICENSE_GPL,
 
38
  PLUGIN_LICENSE_BSD,
 
39
  PLUGIN_LICENSE_LGPL,
 
40
  PLUGIN_LICENSE_MAX=PLUGIN_LICENSE_LGPL
 
41
};
83
42
 
84
 
#define PLUGIN_LICENSE_PROPRIETARY_STRING "PROPRIETARY"
85
 
#define PLUGIN_LICENSE_GPL_STRING "GPL"
86
 
#define PLUGIN_LICENSE_BSD_STRING "BSD"
 
43
const char * const PLUGIN_LICENSE_PROPRIETARY_STRING="PROPRIETARY";
 
44
const char * const PLUGIN_LICENSE_GPL_STRING="GPL";
 
45
const char * const PLUGIN_LICENSE_BSD_STRING="BSD";
 
46
const char * const PLUGIN_LICENSE_LGPL_STRING="LGPL";
87
47
 
88
48
/*
89
 
  Macros for beginning and ending plugin declarations.  Between
90
 
  mysql_declare_plugin and mysql_declare_plugin_end there should
91
 
  be a st_mysql_plugin struct for each plugin to be declared.
 
49
  Macros for beginning and ending plugin declarations. Between
 
50
  drizzle_declare_plugin and drizzle_declare_plugin_end there should
 
51
  be a drizzled_plugin_manifest struct for each plugin to be declared.
92
52
*/
93
53
 
94
54
 
95
55
#ifndef DRIZZLE_DYNAMIC_PLUGIN
96
56
#define __DRIZZLE_DECLARE_PLUGIN(NAME, DECLS) \
97
 
struct st_mysql_plugin DECLS[]= {
 
57
struct drizzled_plugin_manifest DECLS[]= {
98
58
#else
99
59
#define __DRIZZLE_DECLARE_PLUGIN(NAME, DECLS) \
100
 
struct st_mysql_plugin _mysql_plugin_declarations_[]= {
 
60
struct drizzled_plugin_manifest _mysql_plugin_declarations_[]= {
101
61
#endif
102
62
 
103
 
#define mysql_declare_plugin(NAME) \
 
63
#define drizzle_declare_plugin(NAME) \
104
64
__DRIZZLE_DECLARE_PLUGIN(NAME, \
105
65
                 builtin_ ## NAME ## _plugin)
106
66
 
107
 
#define mysql_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0,0}}
 
67
#define drizzle_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0}}
 
68
 
 
69
/*
 
70
  the following flags are valid for plugin_init()
 
71
*/
 
72
#define PLUGIN_INIT_SKIP_DYNAMIC_LOADING 1
 
73
#define PLUGIN_INIT_SKIP_PLUGIN_TABLE    2
 
74
#define PLUGIN_INIT_SKIP_INITIALIZATION  4
 
75
 
 
76
#define INITIAL_LEX_PLUGIN_LIST_SIZE    16
108
77
 
109
78
/*
110
79
  declarations for SHOW STATUS support in plugins
113
82
{
114
83
  SHOW_UNDEF, SHOW_BOOL, SHOW_INT, SHOW_LONG,
115
84
  SHOW_LONGLONG, SHOW_CHAR, SHOW_CHAR_PTR,
116
 
  SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE
 
85
  SHOW_ARRAY, SHOW_FUNC, SHOW_KEY_CACHE_LONG, SHOW_KEY_CACHE_LONGLONG,
 
86
  SHOW_LONG_STATUS, SHOW_DOUBLE_STATUS, SHOW_HAVE, 
 
87
  SHOW_MY_BOOL, SHOW_HA_ROWS, SHOW_SYS, SHOW_INT_NOFLUSH,
 
88
  SHOW_LONGLONG_STATUS, SHOW_DOUBLE, SHOW_SIZE
117
89
};
118
90
 
119
91
struct st_mysql_show_var {
122
94
  enum enum_mysql_show_type type;
123
95
};
124
96
 
 
97
typedef enum enum_mysql_show_type SHOW_TYPE;
 
98
typedef struct st_mysql_show_var SHOW_VAR;
 
99
 
125
100
 
126
101
#define SHOW_VAR_FUNC_BUFF_SIZE 1024
127
 
typedef int (*mysql_show_var_func)(DRIZZLE_THD, struct st_mysql_show_var*, char *);
 
102
typedef int (*mysql_show_var_func)(struct st_mysql_show_var *, char *);
128
103
 
129
104
struct st_show_var_func_container {
130
105
  mysql_show_var_func func;
142
117
#define PLUGIN_VAR_ENUM         0x0006
143
118
#define PLUGIN_VAR_SET          0x0007
144
119
#define PLUGIN_VAR_UNSIGNED     0x0080
145
 
#define PLUGIN_VAR_THDLOCAL     0x0100 /* Variable is per-connection */
 
120
#define PLUGIN_VAR_SessionLOCAL     0x0100 /* Variable is per-connection */
146
121
#define PLUGIN_VAR_READONLY     0x0200 /* Server variable is read only */
147
122
#define PLUGIN_VAR_NOSYSVAR     0x0400 /* Not a server variable */
148
123
#define PLUGIN_VAR_NOCMDOPT     0x0800 /* Not a command line option */
157
132
/*
158
133
  SYNOPSIS
159
134
    (*mysql_var_check_func)()
160
 
      thd               thread handle
 
135
      session               thread handle
161
136
      var               dynamic variable being altered
162
137
      save              pointer to temporary storage
163
138
      value             user provided value
164
139
  RETURN
165
140
    0   user provided value is OK and the update func may be called.
166
141
    any other value indicates error.
167
 
  
 
142
 
168
143
  This function should parse the user provided value and store in the
169
144
  provided temporary storage any data as required by the update func.
170
145
  There is sufficient space in the temporary storage to store a double.
173
148
  automatically at the end of the statement.
174
149
*/
175
150
 
176
 
typedef int (*mysql_var_check_func)(DRIZZLE_THD thd,
 
151
typedef int (*mysql_var_check_func)(Session *session,
177
152
                                    struct st_mysql_sys_var *var,
178
153
                                    void *save, struct st_mysql_value *value);
179
154
 
180
155
/*
181
156
  SYNOPSIS
182
157
    (*mysql_var_update_func)()
183
 
      thd               thread handle
 
158
      session               thread handle
184
159
      var               dynamic variable being altered
185
160
      var_ptr           pointer to dynamic variable
186
161
      save              pointer to temporary storage
187
162
   RETURN
188
163
     NONE
189
 
   
 
164
 
190
165
   This function should use the validated value stored in the temporary store
191
166
   and persist it in the provided pointer to the dynamic variable.
192
167
   For example, strings may require memory to be allocated.
193
168
*/
194
 
typedef void (*mysql_var_update_func)(DRIZZLE_THD thd,
 
169
typedef void (*mysql_var_update_func)(Session *session,
195
170
                                      struct st_mysql_sys_var *var,
196
171
                                      void *var_ptr, const void *save);
197
172
 
221
196
  for thread variables, the value offset is the first
222
197
  element after the header, the default value is the second.
223
198
*/
224
 
   
 
199
 
225
200
 
226
201
#define DECLARE_DRIZZLE_SYSVAR_BASIC(name, type) struct { \
227
202
  DRIZZLE_PLUGIN_VAR_HEADER;      \
242
217
  TYPELIB *typelib;             \
243
218
} DRIZZLE_SYSVAR_NAME(name)
244
219
 
245
 
#define DECLARE_THDVAR_FUNC(type) \
246
 
  type *(*resolve)(DRIZZLE_THD thd, int offset)
 
220
#define DECLARE_SessionVAR_FUNC(type) \
 
221
  type *(*resolve)(Session *session, int offset)
247
222
 
248
 
#define DECLARE_DRIZZLE_THDVAR_BASIC(name, type) struct { \
 
223
#define DECLARE_DRIZZLE_SessionVAR_BASIC(name, type) struct { \
249
224
  DRIZZLE_PLUGIN_VAR_HEADER;      \
250
225
  int offset;                   \
251
226
  const type def_val;           \
252
 
  DECLARE_THDVAR_FUNC(type);    \
 
227
  DECLARE_SessionVAR_FUNC(type);    \
253
228
} DRIZZLE_SYSVAR_NAME(name)
254
229
 
255
 
#define DECLARE_DRIZZLE_THDVAR_SIMPLE(name, type) struct { \
 
230
#define DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, type) struct { \
256
231
  DRIZZLE_PLUGIN_VAR_HEADER;      \
257
232
  int offset;                   \
258
233
  type def_val; type min_val;   \
259
234
  type max_val; type blk_sz;    \
260
 
  DECLARE_THDVAR_FUNC(type);    \
 
235
  DECLARE_SessionVAR_FUNC(type);    \
261
236
} DRIZZLE_SYSVAR_NAME(name)
262
237
 
263
 
#define DECLARE_DRIZZLE_THDVAR_TYPELIB(name, type) struct { \
 
238
#define DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, type) struct { \
264
239
  DRIZZLE_PLUGIN_VAR_HEADER;      \
265
240
  int offset;                   \
266
241
  type def_val;                 \
267
 
  DECLARE_THDVAR_FUNC(type);    \
 
242
  DECLARE_SessionVAR_FUNC(type);    \
268
243
  TYPELIB *typelib;             \
269
244
} DRIZZLE_SYSVAR_NAME(name)
270
245
 
323
298
  PLUGIN_VAR_SET | ((opt) & PLUGIN_VAR_MASK), \
324
299
  #name, comment, check, update, &varname, def, typelib }
325
300
 
326
 
#define DRIZZLE_THDVAR_BOOL(name, opt, comment, check, update, def) \
327
 
DECLARE_DRIZZLE_THDVAR_BASIC(name, char) = { \
328
 
  PLUGIN_VAR_BOOL | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
329
 
  #name, comment, check, update, -1, def, NULL}
330
 
 
331
 
#define DRIZZLE_THDVAR_STR(name, opt, comment, check, update, def) \
332
 
DECLARE_DRIZZLE_THDVAR_BASIC(name, char *) = { \
333
 
  PLUGIN_VAR_STR | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
334
 
  #name, comment, check, update, -1, def, NULL}
335
 
 
336
 
#define DRIZZLE_THDVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
337
 
DECLARE_DRIZZLE_THDVAR_SIMPLE(name, int) = { \
338
 
  PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
339
 
  #name, comment, check, update, -1, def, min, max, blk, NULL }
340
 
 
341
 
#define DRIZZLE_THDVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
342
 
DECLARE_DRIZZLE_THDVAR_SIMPLE(name, unsigned int) = { \
343
 
  PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
344
 
  #name, comment, check, update, -1, def, min, max, blk, NULL }
345
 
 
346
 
#define DRIZZLE_THDVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
347
 
DECLARE_DRIZZLE_THDVAR_SIMPLE(name, long) = { \
348
 
  PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
349
 
  #name, comment, check, update, -1, def, min, max, blk, NULL }
350
 
 
351
 
#define DRIZZLE_THDVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
352
 
DECLARE_DRIZZLE_THDVAR_SIMPLE(name, unsigned long) = { \
353
 
  PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
354
 
  #name, comment, check, update, -1, def, min, max, blk, NULL }
355
 
 
356
 
#define DRIZZLE_THDVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
357
 
DECLARE_DRIZZLE_THDVAR_SIMPLE(name, int64_t) = { \
358
 
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
359
 
  #name, comment, check, update, -1, def, min, max, blk, NULL }
360
 
 
361
 
#define DRIZZLE_THDVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
362
 
DECLARE_DRIZZLE_THDVAR_SIMPLE(name, uint64_t) = { \
363
 
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
364
 
  #name, comment, check, update, -1, def, min, max, blk, NULL }
365
 
 
366
 
#define DRIZZLE_THDVAR_ENUM(name, opt, comment, check, update, def, typelib) \
367
 
DECLARE_DRIZZLE_THDVAR_TYPELIB(name, unsigned long) = { \
368
 
  PLUGIN_VAR_ENUM | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
301
#define DRIZZLE_SessionVAR_BOOL(name, opt, comment, check, update, def) \
 
302
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char) = { \
 
303
  PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
304
  #name, comment, check, update, -1, def, NULL}
 
305
 
 
306
#define DRIZZLE_SessionVAR_STR(name, opt, comment, check, update, def) \
 
307
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char *) = { \
 
308
  PLUGIN_VAR_STR | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
309
  #name, comment, check, update, -1, def, NULL}
 
310
 
 
311
#define DRIZZLE_SessionVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
 
312
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int) = { \
 
313
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
314
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
315
 
 
316
#define DRIZZLE_SessionVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
 
317
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned int) = { \
 
318
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
319
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
320
 
 
321
#define DRIZZLE_SessionVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
 
322
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, long) = { \
 
323
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
324
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
325
 
 
326
#define DRIZZLE_SessionVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
 
327
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned long) = { \
 
328
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
329
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
330
 
 
331
#define DRIZZLE_SessionVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
332
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int64_t) = { \
 
333
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
334
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
335
 
 
336
#define DRIZZLE_SessionVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
337
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, uint64_t) = { \
 
338
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
339
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
340
 
 
341
#define DRIZZLE_SessionVAR_ENUM(name, opt, comment, check, update, def, typelib) \
 
342
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, unsigned long) = { \
 
343
  PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
369
344
  #name, comment, check, update, -1, def, NULL, typelib }
370
345
 
371
 
#define DRIZZLE_THDVAR_SET(name, opt, comment, check, update, def, typelib) \
372
 
DECLARE_DRIZZLE_THDVAR_TYPELIB(name, uint64_t) = { \
373
 
  PLUGIN_VAR_SET | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
346
#define DRIZZLE_SessionVAR_SET(name, opt, comment, check, update, def, typelib) \
 
347
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, uint64_t) = { \
 
348
  PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
374
349
  #name, comment, check, update, -1, def, NULL, typelib }
375
350
 
376
351
/* accessor macros */
378
353
#define SYSVAR(name) \
379
354
  (*(DRIZZLE_SYSVAR_NAME(name).value))
380
355
 
381
 
/* when thd == null, result points to global value */
382
 
#define THDVAR(thd, name) \
383
 
  (*(DRIZZLE_SYSVAR_NAME(name).resolve(thd, DRIZZLE_SYSVAR_NAME(name).offset)))
384
 
 
385
 
 
386
 
/*
387
 
  Plugin description structure.
388
 
*/
389
 
 
390
 
struct st_mysql_plugin
 
356
/* when session == null, result points to global value */
 
357
#define SessionVAR(session, name) \
 
358
  (*(DRIZZLE_SYSVAR_NAME(name).resolve(session, DRIZZLE_SYSVAR_NAME(name).offset)))
 
359
 
 
360
 
 
361
struct StorageEngine;
 
362
 
 
363
 
 
364
class Plugin
391
365
{
392
 
  int type;             /* the plugin type (a DRIZZLE_XXX_PLUGIN value)   */
393
 
  const char *name;     /* plugin name (for SHOW PLUGINS)               */
394
 
  const char *version;  /* plugin version (for SHOW PLUGINS)            */
395
 
  const char *author;   /* plugin author (for SHOW PLUGINS)             */
396
 
  const char *descr;    /* general descriptive text (for SHOW PLUGINS ) */
397
 
  int license;          /* the plugin license (PLUGIN_LICENSE_XXX)      */
398
 
  int (*init)(void *);  /* the function to invoke when plugin is loaded */
399
 
  int (*deinit)(void *);/* the function to invoke when plugin is unloaded */
400
 
  struct st_mysql_show_var *status_vars;
401
 
  struct st_mysql_sys_var **system_vars;
402
 
  void * __reserved1;   /* reserved for dependency checking             */
 
366
private:
 
367
  std::string name;
 
368
  std::string version;
 
369
  std::string author;
 
370
  std::string description;
 
371
 
 
372
public:
 
373
  Plugin(std::string in_name, std::string in_version,
 
374
         std::string in_author, std::string in_description)
 
375
    : name(in_name), version(in_version),
 
376
    author(in_author), description(in_description)
 
377
  {}
 
378
 
 
379
  virtual ~Plugin() {}
 
380
 
 
381
  virtual void add_functions() {}
 
382
 
403
383
};
404
384
 
405
 
struct handlerton;
406
 
 
407
 
 
408
385
/*************************************************************************
409
386
  st_mysql_value struct for reading values from mysqld.
410
387
  Used by server variables framework to parse user-provided values.
436
413
extern "C" {
437
414
#endif
438
415
 
439
 
int thd_in_lock_tables(const DRIZZLE_THD thd);
440
 
int thd_tablespace_op(const DRIZZLE_THD thd);
441
 
int64_t thd_test_options(const DRIZZLE_THD thd, int64_t test_options);
442
 
int thd_sql_command(const DRIZZLE_THD thd);
443
 
const char *thd_proc_info(DRIZZLE_THD thd, const char *info);
444
 
void **thd_ha_data(const DRIZZLE_THD thd, const struct handlerton *hton);
445
 
int thd_tx_isolation(const DRIZZLE_THD thd);
446
 
/* Increments the row counter, see THD::row_count */
447
 
void thd_inc_row_count(DRIZZLE_THD thd);
 
416
int session_in_lock_tables(const Session *session);
 
417
int session_tablespace_op(const Session *session);
 
418
void set_session_proc_info(Session *session, const char *info);
 
419
const char *get_session_proc_info(Session *session);
 
420
int64_t session_test_options(const Session *session, int64_t test_options);
 
421
int session_sql_command(const Session *session);
 
422
void **session_ha_data(const Session *session, const struct StorageEngine *engine);
 
423
int session_tx_isolation(const Session *session);
 
424
/* Increments the row counter, see Session::row_count */
 
425
void session_inc_row_count(Session *session);
 
426
 
 
427
LEX_STRING *session_make_lex_string(Session *session, LEX_STRING *lex_str,
 
428
                                    const char *str, unsigned int size,
 
429
                                    int allocate_lex_string);
 
430
 
 
431
 
448
432
 
449
433
/**
450
434
  Create a temporary file.
470
454
  time-consuming loops, and gracefully abort the operation if it is
471
455
  non-zero.
472
456
 
473
 
  @param thd  user thread connection handle
 
457
  @param session  user thread connection handle
474
458
  @retval 0  the connection is active
475
459
  @retval 1  the connection has been killed
476
460
*/
477
 
int thd_killed(const DRIZZLE_THD thd);
 
461
int session_killed(const Session *session);
478
462
 
479
463
 
480
464
/**
481
465
  Return the thread id of a user thread
482
466
 
483
 
  @param thd  user thread connection handle
 
467
  @param session  user thread connection handle
484
468
  @return  thread id
485
469
*/
486
 
unsigned long thd_get_thread_id(const DRIZZLE_THD thd);
 
470
unsigned long session_get_thread_id(const Session *session);
487
471
 
488
472
 
489
473
/**
490
474
  Allocate memory in the connection's local memory pool
491
475
 
492
476
  @details
493
 
  When properly used in place of @c my_malloc(), this can significantly
 
477
  When properly used in place of @c malloc(), this can significantly
494
478
  improve concurrency. Don't use this or related functions to allocate
495
479
  large chunks of memory. Use for temporary storage only. The memory
496
480
  will be freed automatically at the end of the statement; no explicit
498
482
 
499
483
  @see alloc_root()
500
484
*/
501
 
void *thd_alloc(DRIZZLE_THD thd, unsigned int size);
502
 
/**
503
 
  @see thd_alloc()
504
 
*/
505
 
void *thd_calloc(DRIZZLE_THD thd, unsigned int size);
506
 
/**
507
 
  @see thd_alloc()
508
 
*/
509
 
char *thd_strdup(DRIZZLE_THD thd, const char *str);
510
 
/**
511
 
  @see thd_alloc()
512
 
*/
513
 
char *thd_strmake(DRIZZLE_THD thd, const char *str, unsigned int size);
514
 
/**
515
 
  @see thd_alloc()
516
 
*/
517
 
void *thd_memdup(DRIZZLE_THD thd, const void* str, unsigned int size);
518
 
 
519
 
/**
520
 
  Create a LEX_STRING in this connection's local memory pool
521
 
 
522
 
  @param thd      user thread connection handle
523
 
  @param lex_str  pointer to LEX_STRING object to be initialized
524
 
  @param str      initializer to be copied into lex_str
525
 
  @param size     length of str, in bytes
526
 
  @param allocate_lex_string  flag: if TRUE, allocate new LEX_STRING object,
527
 
                              instead of using lex_str value
528
 
  @return  NULL on failure, or pointer to the LEX_STRING object
529
 
 
530
 
  @see thd_alloc()
531
 
*/
532
 
DRIZZLE_LEX_STRING *thd_make_lex_string(DRIZZLE_THD thd, DRIZZLE_LEX_STRING *lex_str,
533
 
                                      const char *str, unsigned int size,
534
 
                                      int allocate_lex_string);
 
485
void *session_alloc(Session *session, unsigned int size);
 
486
/**
 
487
  @see session_alloc()
 
488
*/
 
489
void *session_calloc(Session *session, unsigned int size);
 
490
/**
 
491
  @see session_alloc()
 
492
*/
 
493
char *session_strdup(Session *session, const char *str);
 
494
/**
 
495
  @see session_alloc()
 
496
*/
 
497
char *session_strmake(Session *session, const char *str, unsigned int size);
 
498
/**
 
499
  @see session_alloc()
 
500
*/
 
501
void *session_memdup(Session *session, const void* str, unsigned int size);
535
502
 
536
503
/**
537
504
  Get the XID for this connection's transaction
538
505
 
539
 
  @param thd  user thread connection handle
 
506
  @param session  user thread connection handle
540
507
  @param xid  location where identifier is stored
541
508
*/
542
 
void thd_get_xid(const DRIZZLE_THD thd, DRIZZLE_XID *xid);
 
509
void session_get_xid(const Session *session, DRIZZLE_XID *xid);
543
510
 
544
511
/**
545
512
  Invalidate the query cache for a given table.
546
513
 
547
 
  @param thd         user thread connection handle
 
514
  @param session         user thread connection handle
548
515
  @param key         databasename\\0tablename\\0
549
516
  @param key_length  length of key in bytes, including the NUL bytes
550
517
  @param using_trx   flag: TRUE if using transactions, FALSE otherwise
551
518
*/
552
 
void mysql_query_cache_invalidate4(DRIZZLE_THD thd,
 
519
void mysql_query_cache_invalidate4(Session *session,
553
520
                                   const char *key, unsigned int key_length,
554
521
                                   int using_trx);
555
522
 
563
530
*/
564
531
inline
565
532
void *
566
 
thd_get_ha_data(const DRIZZLE_THD thd, const struct handlerton *hton)
 
533
session_get_ha_data(const Session *session, const struct StorageEngine *engine)
567
534
{
568
 
  return *thd_ha_data(thd, hton);
 
535
  return *session_ha_data(session, engine);
569
536
}
570
537
 
571
538
/**
573
540
*/
574
541
inline
575
542
void
576
 
thd_set_ha_data(const DRIZZLE_THD thd, const struct handlerton *hton,
 
543
session_set_ha_data(const Session *session, const struct StorageEngine *engine,
577
544
                const void *ha_data)
578
545
{
579
 
  *thd_ha_data(thd, hton)= (void*) ha_data;
 
546
  *session_ha_data(session, engine)= (void*) ha_data;
580
547
}
581
548
#endif
582
549
 
583
 
#endif
 
550
#endif /* _my_plugin_h */
584
551