← 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: 2008-10-29 13:46:43 UTC
  • Revision ID: brian@tangent.org-20081029134643-z6jcwjvyruhk2vlu
Updates for ignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
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
 
#include <drizzled/visibility.h>
37
 
 
38
 
namespace drizzled
39
 
{
 
23
#include <drizzled/global.h>
40
24
 
41
25
class Session;
42
26
class Item;
43
 
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;
44
44
 
45
45
/*************************************************************************
46
46
  Plugin API. Common for all plugin types.
47
47
*/
48
48
 
49
 
 
50
 
class sys_var;
51
 
struct option;
52
 
 
53
 
extern boost::filesystem::path plugin_dir;
54
 
 
55
 
namespace plugin { class StorageEngine; }
56
 
 
57
 
/*
58
 
  Macros for beginning and ending plugin declarations. Between
59
 
  DRIZZLE_DECLARE_PLUGIN and DRIZZLE_DECLARE_PLUGIN_END there should
60
 
  be a module::Manifest for each plugin to be declared.
61
 
*/
62
 
 
63
 
 
64
 
#define PANDORA_CPP_NAME(x) _drizzled_ ## x ## _plugin_
65
 
#define PANDORA_PLUGIN_NAME(x) PANDORA_CPP_NAME(x)
66
 
#define DRIZZLE_DECLARE_PLUGIN \
67
 
  DRIZZLED_API ::drizzled::module::Manifest PANDORA_PLUGIN_NAME(PANDORA_MODULE_NAME)= 
68
 
 
69
 
 
70
 
#define DRIZZLE_DECLARE_PLUGIN_END
71
 
#define DRIZZLE_PLUGIN(init,system,options) \
72
 
  DRIZZLE_DECLARE_PLUGIN \
73
 
  { \
74
 
    DRIZZLE_VERSION_ID, \
75
 
    STRINGIFY_ARG(PANDORA_MODULE_NAME), \
76
 
    STRINGIFY_ARG(PANDORA_MODULE_VERSION), \
77
 
    STRINGIFY_ARG(PANDORA_MODULE_AUTHOR), \
78
 
    STRINGIFY_ARG(PANDORA_MODULE_TITLE), \
79
 
    PANDORA_MODULE_LICENSE, \
80
 
    init, \
81
 
    STRINGIFY_ARG(PANDORA_MODULE_DEPENDENCIES), \
82
 
    options \
83
 
  } 
84
 
 
85
 
 
 
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
};
86
128
/*
87
129
  declarations for server variables and command line options
88
130
*/
93
135
#define PLUGIN_VAR_LONG         0x0003
94
136
#define PLUGIN_VAR_LONGLONG     0x0004
95
137
#define PLUGIN_VAR_STR          0x0005
 
138
#define PLUGIN_VAR_ENUM         0x0006
 
139
#define PLUGIN_VAR_SET          0x0007
96
140
#define PLUGIN_VAR_UNSIGNED     0x0080
97
141
#define PLUGIN_VAR_SessionLOCAL     0x0100 /* Variable is per-connection */
98
142
#define PLUGIN_VAR_READONLY     0x0200 /* Server variable is read only */
103
147
#define PLUGIN_VAR_OPCMDARG     0x2000 /* Argument optional for cmd line */
104
148
#define PLUGIN_VAR_MEMALLOC     0x8000 /* String needs memory allocated */
105
149
 
106
 
struct drizzle_sys_var;
107
 
struct drizzle_value;
 
150
struct st_mysql_sys_var;
 
151
struct st_mysql_value;
108
152
 
109
153
/*
110
154
  SYNOPSIS
111
 
    (*var_check_func)()
 
155
    (*mysql_var_check_func)()
112
156
      session               thread handle
113
157
      var               dynamic variable being altered
114
158
      save              pointer to temporary storage
116
160
  RETURN
117
161
    0   user provided value is OK and the update func may be called.
118
162
    any other value indicates error.
119
 
 
 
163
  
120
164
  This function should parse the user provided value and store in the
121
165
  provided temporary storage any data as required by the update func.
122
166
  There is sufficient space in the temporary storage to store a double.
125
169
  automatically at the end of the statement.
126
170
*/
127
171
 
128
 
typedef int (*var_check_func)(Session *session,
129
 
                                    drizzle_sys_var *var,
130
 
                                    void *save, drizzle_value *value);
 
172
typedef int (*mysql_var_check_func)(Session *session,
 
173
                                    struct st_mysql_sys_var *var,
 
174
                                    void *save, struct st_mysql_value *value);
131
175
 
132
176
/*
133
177
  SYNOPSIS
134
 
    (*var_update_func)()
 
178
    (*mysql_var_update_func)()
135
179
      session               thread handle
136
180
      var               dynamic variable being altered
137
181
      var_ptr           pointer to dynamic variable
138
182
      save              pointer to temporary storage
139
183
   RETURN
140
184
     NONE
141
 
 
 
185
   
142
186
   This function should use the validated value stored in the temporary store
143
187
   and persist it in the provided pointer to the dynamic variable.
144
188
   For example, strings may require memory to be allocated.
145
189
*/
146
 
typedef void (*var_update_func)(Session *session,
147
 
                                      drizzle_sys_var *var,
 
190
typedef void (*mysql_var_update_func)(Session *session,
 
191
                                      struct st_mysql_sys_var *var,
148
192
                                      void *var_ptr, const void *save);
149
193
 
150
194
 
151
 
 
152
 
/*
153
 
  skeleton of a plugin variable - portion of structure common to all.
154
 
*/
155
 
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
156
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             */
157
399
};
158
400
 
159
 
void plugin_opt_set_limits(option *options, const drizzle_sys_var *opt);
160
 
 
161
 
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
162
419
{
163
 
  int (*value_type)(drizzle_value *);
164
 
  const char *(*val_str)(drizzle_value *, char *buffer, int *length);
165
 
  int (*val_real)(drizzle_value *, double *realbuf);
166
 
  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);
167
424
};
168
425
 
169
426
 
171
428
  Miscellaneous functions for plugin implementors
172
429
*/
173
430
 
174
 
extern bool plugin_init(module::Registry &registry,
175
 
                        boost::program_options::options_description &long_options);
176
 
extern bool plugin_finalize(module::Registry &registry);
177
 
extern void plugin_startup_window(module::Registry &registry, drizzled::Session &session);
178
 
extern void my_print_help_inc_plugins(option *options);
179
 
extern bool plugin_is_ready(const LEX_STRING *name, int type);
180
 
extern void plugin_sessionvar_init(Session *session);
181
 
extern void plugin_sessionvar_cleanup(Session *session);
 
431
#ifdef __cplusplus
 
432
extern "C" {
 
433
#endif
182
434
 
183
435
int session_in_lock_tables(const Session *session);
184
 
DRIZZLED_API int64_t session_test_options(const Session *session, int64_t test_options);
185
 
void compose_plugin_add(std::vector<std::string> options);
186
 
void compose_plugin_remove(std::vector<std::string> options);
187
 
void notify_plugin_load(std::string in_plugin_load);
188
 
 
 
436
int session_tablespace_op(const Session *session);
 
437
int64_t session_test_options(const Session *session, int64_t test_options);
 
438
int session_sql_command(const Session *session);
 
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);
189
443
 
190
444
/**
191
445
  Create a temporary file.
197
451
 
198
452
  @param prefix  prefix for temporary file name
199
453
  @retval -1    error
200
 
  @retval >= 0  a file handle that can be passed to dup or internal::my_close
201
 
*/
202
 
DRIZZLED_API int tmpfile(const char *prefix);
203
 
 
204
 
} /* namespace drizzled */
205
 
 
206
 
#endif /* DRIZZLED_PLUGIN_H */
 
454
  @retval >= 0  a file handle that can be passed to dup or my_close
 
455
*/
 
456
int mysql_tmpfile(const char *prefix);
 
457
 
 
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 */
207
562