← 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-03-24 17:44:41 UTC
  • mto: (960.5.2 mordred)
  • mto: This revision was merged to the branch mainline in revision 964.
  • Revision ID: mordred@inaugust.com-20090324174441-nmsq0gwjlgf7f0mt
Changed handlerton to StorageEngine.

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.
65
33
/*
66
34
  The allowable types of plugins
67
35
*/
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 */
 
36
enum drizzle_plugin_type {
 
37
  DRIZZLE_DAEMON_PLUGIN,                /* Daemon / Raw */
 
38
  DRIZZLE_STORAGE_ENGINE_PLUGIN,        /* Storage Engine */
 
39
  DRIZZLE_INFORMATION_SCHEMA_PLUGIN,    /* Information Schema */
 
40
  DRIZZLE_UDF_PLUGIN,                   /* User-Defined Function */
 
41
  DRIZZLE_UDA_PLUGIN,                   /* User-Defined Aggregate Function */
 
42
  DRIZZLE_AUDIT_PLUGIN,                 /* Audit */
 
43
  DRIZZLE_LOGGER_PLUGIN,                /* Query Logging */
 
44
  DRIZZLE_ERRMSG_PLUGIN,                /* Error Messages */
 
45
  DRIZZLE_AUTH_PLUGIN,                  /* Authorization */
 
46
  DRIZZLE_CONFIGVAR_PLUGIN,             /* Configuration Variables */
 
47
  DRIZZLE_QCACHE_PLUGIN,                /* Query Cache */
 
48
  DRIZZLE_PARSER_PLUGIN,                /* Language Parser */
 
49
  DRIZZLE_SCHEDULING_PLUGIN,            /* Thread and Session Scheduling */
 
50
  DRIZZLE_REPLICATOR_PLUGIN,            /* Database Replication */
 
51
  DRIZZLE_PLUGIN_MAX=DRIZZLE_REPLICATOR_PLUGIN
 
52
};
76
53
 
77
 
#define DRIZZLE_MAX_PLUGIN_TYPE_NUM    8  /* The number of plugin types */
 
54
/* The number of plugin types */
 
55
const uint32_t DRIZZLE_MAX_PLUGIN_TYPE_NUM=DRIZZLE_PLUGIN_MAX+1;
78
56
 
79
57
/* 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
 
58
enum plugin_license_type {
 
59
  PLUGIN_LICENSE_PROPRIETARY,
 
60
  PLUGIN_LICENSE_GPL,
 
61
  PLUGIN_LICENSE_BSD,
 
62
  PLUGIN_LICENSE_LGPL,
 
63
  PLUGIN_LICENSE_MAX=PLUGIN_LICENSE_LGPL
 
64
};
83
65
 
84
 
#define PLUGIN_LICENSE_PROPRIETARY_STRING "PROPRIETARY"
85
 
#define PLUGIN_LICENSE_GPL_STRING "GPL"
86
 
#define PLUGIN_LICENSE_BSD_STRING "BSD"
 
66
const char * const PLUGIN_LICENSE_PROPRIETARY_STRING="PROPRIETARY";
 
67
const char * const PLUGIN_LICENSE_GPL_STRING="GPL";
 
68
const char * const PLUGIN_LICENSE_BSD_STRING="BSD";
 
69
const char * const PLUGIN_LICENSE_LGPL_STRING="LGPL";
87
70
 
88
71
/*
89
 
  Macros for beginning and ending plugin declarations.  Between
90
 
  mysql_declare_plugin and mysql_declare_plugin_end there should
 
72
  Macros for beginning and ending plugin declarations. Between
 
73
  drizzle_declare_plugin and drizzle_declare_plugin_end there should
91
74
  be a st_mysql_plugin struct for each plugin to be declared.
92
75
*/
93
76
 
100
83
struct st_mysql_plugin _mysql_plugin_declarations_[]= {
101
84
#endif
102
85
 
103
 
#define mysql_declare_plugin(NAME) \
 
86
#define drizzle_declare_plugin(NAME) \
104
87
__DRIZZLE_DECLARE_PLUGIN(NAME, \
105
88
                 builtin_ ## NAME ## _plugin)
106
89
 
107
 
#define mysql_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0,0}}
 
90
#define drizzle_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0,0}}
108
91
 
109
92
/*
110
93
  declarations for SHOW STATUS support in plugins
113
96
{
114
97
  SHOW_UNDEF, SHOW_BOOL, SHOW_INT, SHOW_LONG,
115
98
  SHOW_LONGLONG, SHOW_CHAR, SHOW_CHAR_PTR,
116
 
  SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE
 
99
  SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE, SHOW_SIZE
117
100
};
118
101
 
119
102
struct st_mysql_show_var {
124
107
 
125
108
 
126
109
#define SHOW_VAR_FUNC_BUFF_SIZE 1024
127
 
typedef int (*mysql_show_var_func)(DRIZZLE_THD, struct st_mysql_show_var*, char *);
 
110
typedef int (*mysql_show_var_func)(Session *, struct st_mysql_show_var *, char *);
128
111
 
129
112
struct st_show_var_func_container {
130
113
  mysql_show_var_func func;
142
125
#define PLUGIN_VAR_ENUM         0x0006
143
126
#define PLUGIN_VAR_SET          0x0007
144
127
#define PLUGIN_VAR_UNSIGNED     0x0080
145
 
#define PLUGIN_VAR_THDLOCAL     0x0100 /* Variable is per-connection */
 
128
#define PLUGIN_VAR_SessionLOCAL     0x0100 /* Variable is per-connection */
146
129
#define PLUGIN_VAR_READONLY     0x0200 /* Server variable is read only */
147
130
#define PLUGIN_VAR_NOSYSVAR     0x0400 /* Not a server variable */
148
131
#define PLUGIN_VAR_NOCMDOPT     0x0800 /* Not a command line option */
157
140
/*
158
141
  SYNOPSIS
159
142
    (*mysql_var_check_func)()
160
 
      thd               thread handle
 
143
      session               thread handle
161
144
      var               dynamic variable being altered
162
145
      save              pointer to temporary storage
163
146
      value             user provided value
164
147
  RETURN
165
148
    0   user provided value is OK and the update func may be called.
166
149
    any other value indicates error.
167
 
  
 
150
 
168
151
  This function should parse the user provided value and store in the
169
152
  provided temporary storage any data as required by the update func.
170
153
  There is sufficient space in the temporary storage to store a double.
173
156
  automatically at the end of the statement.
174
157
*/
175
158
 
176
 
typedef int (*mysql_var_check_func)(DRIZZLE_THD thd,
 
159
typedef int (*mysql_var_check_func)(Session *session,
177
160
                                    struct st_mysql_sys_var *var,
178
161
                                    void *save, struct st_mysql_value *value);
179
162
 
180
163
/*
181
164
  SYNOPSIS
182
165
    (*mysql_var_update_func)()
183
 
      thd               thread handle
 
166
      session               thread handle
184
167
      var               dynamic variable being altered
185
168
      var_ptr           pointer to dynamic variable
186
169
      save              pointer to temporary storage
187
170
   RETURN
188
171
     NONE
189
 
   
 
172
 
190
173
   This function should use the validated value stored in the temporary store
191
174
   and persist it in the provided pointer to the dynamic variable.
192
175
   For example, strings may require memory to be allocated.
193
176
*/
194
 
typedef void (*mysql_var_update_func)(DRIZZLE_THD thd,
 
177
typedef void (*mysql_var_update_func)(Session *session,
195
178
                                      struct st_mysql_sys_var *var,
196
179
                                      void *var_ptr, const void *save);
197
180
 
221
204
  for thread variables, the value offset is the first
222
205
  element after the header, the default value is the second.
223
206
*/
224
 
   
 
207
 
225
208
 
226
209
#define DECLARE_DRIZZLE_SYSVAR_BASIC(name, type) struct { \
227
210
  DRIZZLE_PLUGIN_VAR_HEADER;      \
242
225
  TYPELIB *typelib;             \
243
226
} DRIZZLE_SYSVAR_NAME(name)
244
227
 
245
 
#define DECLARE_THDVAR_FUNC(type) \
246
 
  type *(*resolve)(DRIZZLE_THD thd, int offset)
 
228
#define DECLARE_SessionVAR_FUNC(type) \
 
229
  type *(*resolve)(Session *session, int offset)
247
230
 
248
 
#define DECLARE_DRIZZLE_THDVAR_BASIC(name, type) struct { \
 
231
#define DECLARE_DRIZZLE_SessionVAR_BASIC(name, type) struct { \
249
232
  DRIZZLE_PLUGIN_VAR_HEADER;      \
250
233
  int offset;                   \
251
234
  const type def_val;           \
252
 
  DECLARE_THDVAR_FUNC(type);    \
 
235
  DECLARE_SessionVAR_FUNC(type);    \
253
236
} DRIZZLE_SYSVAR_NAME(name)
254
237
 
255
 
#define DECLARE_DRIZZLE_THDVAR_SIMPLE(name, type) struct { \
 
238
#define DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, type) struct { \
256
239
  DRIZZLE_PLUGIN_VAR_HEADER;      \
257
240
  int offset;                   \
258
241
  type def_val; type min_val;   \
259
242
  type max_val; type blk_sz;    \
260
 
  DECLARE_THDVAR_FUNC(type);    \
 
243
  DECLARE_SessionVAR_FUNC(type);    \
261
244
} DRIZZLE_SYSVAR_NAME(name)
262
245
 
263
 
#define DECLARE_DRIZZLE_THDVAR_TYPELIB(name, type) struct { \
 
246
#define DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, type) struct { \
264
247
  DRIZZLE_PLUGIN_VAR_HEADER;      \
265
248
  int offset;                   \
266
249
  type def_val;                 \
267
 
  DECLARE_THDVAR_FUNC(type);    \
 
250
  DECLARE_SessionVAR_FUNC(type);    \
268
251
  TYPELIB *typelib;             \
269
252
} DRIZZLE_SYSVAR_NAME(name)
270
253
 
323
306
  PLUGIN_VAR_SET | ((opt) & PLUGIN_VAR_MASK), \
324
307
  #name, comment, check, update, &varname, def, typelib }
325
308
 
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), \
 
309
#define DRIZZLE_SessionVAR_BOOL(name, opt, comment, check, update, def) \
 
310
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char) = { \
 
311
  PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
312
  #name, comment, check, update, -1, def, NULL}
 
313
 
 
314
#define DRIZZLE_SessionVAR_STR(name, opt, comment, check, update, def) \
 
315
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char *) = { \
 
316
  PLUGIN_VAR_STR | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
317
  #name, comment, check, update, -1, def, NULL}
 
318
 
 
319
#define DRIZZLE_SessionVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
 
320
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int) = { \
 
321
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
322
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
323
 
 
324
#define DRIZZLE_SessionVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
 
325
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned int) = { \
 
326
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
327
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
328
 
 
329
#define DRIZZLE_SessionVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
 
330
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, long) = { \
 
331
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
332
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
333
 
 
334
#define DRIZZLE_SessionVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
 
335
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned long) = { \
 
336
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
337
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
338
 
 
339
#define DRIZZLE_SessionVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
340
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int64_t) = { \
 
341
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
342
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
343
 
 
344
#define DRIZZLE_SessionVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
345
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, uint64_t) = { \
 
346
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
347
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
348
 
 
349
#define DRIZZLE_SessionVAR_ENUM(name, opt, comment, check, update, def, typelib) \
 
350
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, unsigned long) = { \
 
351
  PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
369
352
  #name, comment, check, update, -1, def, NULL, typelib }
370
353
 
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), \
 
354
#define DRIZZLE_SessionVAR_SET(name, opt, comment, check, update, def, typelib) \
 
355
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, uint64_t) = { \
 
356
  PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
374
357
  #name, comment, check, update, -1, def, NULL, typelib }
375
358
 
376
359
/* accessor macros */
378
361
#define SYSVAR(name) \
379
362
  (*(DRIZZLE_SYSVAR_NAME(name).value))
380
363
 
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)))
 
364
/* when session == null, result points to global value */
 
365
#define SessionVAR(session, name) \
 
366
  (*(DRIZZLE_SYSVAR_NAME(name).resolve(session, DRIZZLE_SYSVAR_NAME(name).offset)))
384
367
 
385
368
 
386
369
/*
389
372
 
390
373
struct st_mysql_plugin
391
374
{
392
 
  int type;             /* the plugin type (a DRIZZLE_XXX_PLUGIN value)   */
 
375
  uint32_t type;        /* the plugin type (a DRIZZLE_XXX_PLUGIN value)   */
393
376
  const char *name;     /* plugin name (for SHOW PLUGINS)               */
394
377
  const char *version;  /* plugin version (for SHOW PLUGINS)            */
395
378
  const char *author;   /* plugin author (for SHOW PLUGINS)             */
399
382
  int (*deinit)(void *);/* the function to invoke when plugin is unloaded */
400
383
  struct st_mysql_show_var *status_vars;
401
384
  struct st_mysql_sys_var **system_vars;
402
 
  void * __reserved1;   /* reserved for dependency checking             */
403
 
};
404
 
 
405
 
struct handlerton;
406
 
 
 
385
  void *reserved1;   /* reserved for dependency checking             */
 
386
};
 
387
 
 
388
struct StorageEngine;
 
389
 
 
390
 
 
391
class Plugin
 
392
{
 
393
private:
 
394
  std::string name;
 
395
  std::string version;
 
396
  std::string author;
 
397
  std::string description;
 
398
 
 
399
public:
 
400
  Plugin(std::string in_name, std::string in_version,
 
401
         std::string in_author, std::string in_description)
 
402
    : name(in_name), version(in_version),
 
403
    author(in_author), description(in_description)
 
404
  {}
 
405
 
 
406
  virtual ~Plugin() {}
 
407
 
 
408
  virtual void add_functions() {}
 
409
 
 
410
};
407
411
 
408
412
/*************************************************************************
409
413
  st_mysql_value struct for reading values from mysqld.
436
440
extern "C" {
437
441
#endif
438
442
 
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);
 
443
int session_in_lock_tables(const Session *session);
 
444
int session_tablespace_op(const Session *session);
 
445
void set_session_proc_info(Session *session, const char *info);
 
446
const char *get_session_proc_info(Session *session);
 
447
int64_t session_test_options(const Session *session, int64_t test_options);
 
448
int session_sql_command(const Session *session);
 
449
void **session_ha_data(const Session *session, const struct StorageEngine *hton);
 
450
int session_tx_isolation(const Session *session);
 
451
/* Increments the row counter, see Session::row_count */
 
452
void session_inc_row_count(Session *session);
 
453
 
 
454
LEX_STRING *session_make_lex_string(Session *session, LEX_STRING *lex_str,
 
455
                                    const char *str, unsigned int size,
 
456
                                    int allocate_lex_string);
 
457
 
 
458
 
448
459
 
449
460
/**
450
461
  Create a temporary file.
470
481
  time-consuming loops, and gracefully abort the operation if it is
471
482
  non-zero.
472
483
 
473
 
  @param thd  user thread connection handle
 
484
  @param session  user thread connection handle
474
485
  @retval 0  the connection is active
475
486
  @retval 1  the connection has been killed
476
487
*/
477
 
int thd_killed(const DRIZZLE_THD thd);
 
488
int session_killed(const Session *session);
478
489
 
479
490
 
480
491
/**
481
492
  Return the thread id of a user thread
482
493
 
483
 
  @param thd  user thread connection handle
 
494
  @param session  user thread connection handle
484
495
  @return  thread id
485
496
*/
486
 
unsigned long thd_get_thread_id(const DRIZZLE_THD thd);
 
497
unsigned long session_get_thread_id(const Session *session);
487
498
 
488
499
 
489
500
/**
490
501
  Allocate memory in the connection's local memory pool
491
502
 
492
503
  @details
493
 
  When properly used in place of @c my_malloc(), this can significantly
 
504
  When properly used in place of @c malloc(), this can significantly
494
505
  improve concurrency. Don't use this or related functions to allocate
495
506
  large chunks of memory. Use for temporary storage only. The memory
496
507
  will be freed automatically at the end of the statement; no explicit
498
509
 
499
510
  @see alloc_root()
500
511
*/
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);
 
512
void *session_alloc(Session *session, unsigned int size);
 
513
/**
 
514
  @see session_alloc()
 
515
*/
 
516
void *session_calloc(Session *session, unsigned int size);
 
517
/**
 
518
  @see session_alloc()
 
519
*/
 
520
char *session_strdup(Session *session, const char *str);
 
521
/**
 
522
  @see session_alloc()
 
523
*/
 
524
char *session_strmake(Session *session, const char *str, unsigned int size);
 
525
/**
 
526
  @see session_alloc()
 
527
*/
 
528
void *session_memdup(Session *session, const void* str, unsigned int size);
535
529
 
536
530
/**
537
531
  Get the XID for this connection's transaction
538
532
 
539
 
  @param thd  user thread connection handle
 
533
  @param session  user thread connection handle
540
534
  @param xid  location where identifier is stored
541
535
*/
542
 
void thd_get_xid(const DRIZZLE_THD thd, DRIZZLE_XID *xid);
 
536
void session_get_xid(const Session *session, DRIZZLE_XID *xid);
543
537
 
544
538
/**
545
539
  Invalidate the query cache for a given table.
546
540
 
547
 
  @param thd         user thread connection handle
 
541
  @param session         user thread connection handle
548
542
  @param key         databasename\\0tablename\\0
549
543
  @param key_length  length of key in bytes, including the NUL bytes
550
544
  @param using_trx   flag: TRUE if using transactions, FALSE otherwise
551
545
*/
552
 
void mysql_query_cache_invalidate4(DRIZZLE_THD thd,
 
546
void mysql_query_cache_invalidate4(Session *session,
553
547
                                   const char *key, unsigned int key_length,
554
548
                                   int using_trx);
555
549
 
563
557
*/
564
558
inline
565
559
void *
566
 
thd_get_ha_data(const DRIZZLE_THD thd, const struct handlerton *hton)
 
560
session_get_ha_data(const Session *session, const struct StorageEngine *hton)
567
561
{
568
 
  return *thd_ha_data(thd, hton);
 
562
  return *session_ha_data(session, hton);
569
563
}
570
564
 
571
565
/**
573
567
*/
574
568
inline
575
569
void
576
 
thd_set_ha_data(const DRIZZLE_THD thd, const struct handlerton *hton,
 
570
session_set_ha_data(const Session *session, const struct StorageEngine *hton,
577
571
                const void *ha_data)
578
572
{
579
 
  *thd_ha_data(thd, hton)= (void*) ha_data;
 
573
  *session_ha_data(session, hton)= (void*) ha_data;
580
574
}
581
575
#endif
582
576
 
583
 
#endif
 
577
#endif /* _my_plugin_h */
584
578