← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin.h

  • Committer: mordred
  • Date: 2008-11-01 00:46:20 UTC
  • mto: (572.1.1 devel) (575.1.1 devel)
  • mto: This revision was merged to the branch mainline in revision 573.
  • Revision ID: mordred@opensolaris-20081101004620-vd0kzsl9k40hvf4p
Some updates to dtrace support.

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
 
20
#ifndef DRIZZLED_PLUGIN_H
 
21
#define DRIZZLED_PLUGIN_H
22
22
 
23
23
#include <drizzled/global.h>
 
24
#include <drizzled/lex_string.h>
 
25
#include <drizzled/xid.h>
24
26
 
25
 
#ifdef __cplusplus
26
 
class THD;
 
27
class Session;
27
28
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
29
 
61
30
/*************************************************************************
62
31
  Plugin API. Common for all plugin types.
65
34
/*
66
35
  The allowable types of plugins
67
36
*/
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 */
 
37
enum drizzle_plugin_type {
 
38
  DRIZZLE_DAEMON_PLUGIN,                /* Daemon / Raw */
 
39
  DRIZZLE_STORAGE_ENGINE_PLUGIN,        /* Storage Engine */
 
40
  DRIZZLE_INFORMATION_SCHEMA_PLUGIN,    /* Information Schema */
 
41
  DRIZZLE_UDF_PLUGIN,                   /* User-Defined Function */
 
42
  DRIZZLE_UDA_PLUGIN,                   /* User-Defined Aggregate Function */
 
43
  DRIZZLE_AUDIT_PLUGIN,                 /* Audit */
 
44
  DRIZZLE_LOGGER_PLUGIN,                /* Query Logging */
 
45
  DRIZZLE_ERRMSG_PLUGIN,                /* Error Messages */
 
46
  DRIZZLE_AUTH_PLUGIN,                  /* Authorization */
 
47
  DRIZZLE_CONFIGVAR_PLUGIN,             /* Configuration Variables */
 
48
  DRIZZLE_QCACHE_PLUGIN,                /* Query Cache */
 
49
  DRIZZLE_PARSER_PLUGIN,                /* Language Parser */
 
50
  DRIZZLE_SCHEDULING_PLUGIN,            /* Thread and Session Scheduling */
 
51
  DRIZZLE_PLUGIN_MAX=DRIZZLE_SCHEDULING_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_MAX=PLUGIN_LICENSE_BSD
 
63
};
83
64
 
84
 
#define PLUGIN_LICENSE_PROPRIETARY_STRING "PROPRIETARY"
85
 
#define PLUGIN_LICENSE_GPL_STRING "GPL"
86
 
#define PLUGIN_LICENSE_BSD_STRING "BSD"
 
65
const char * const PLUGIN_LICENSE_PROPRIETARY_STRING="PROPRIETARY";
 
66
const char * const PLUGIN_LICENSE_GPL_STRING="GPL";
 
67
const char * const PLUGIN_LICENSE_BSD_STRING="BSD";
87
68
 
88
69
/*
89
70
  Macros for beginning and ending plugin declarations.  Between
124
105
 
125
106
 
126
107
#define SHOW_VAR_FUNC_BUFF_SIZE 1024
127
 
typedef int (*mysql_show_var_func)(DRIZZLE_THD, struct st_mysql_show_var*, char *);
 
108
typedef int (*mysql_show_var_func)(Session *, struct st_mysql_show_var *, char *);
128
109
 
129
110
struct st_show_var_func_container {
130
111
  mysql_show_var_func func;
142
123
#define PLUGIN_VAR_ENUM         0x0006
143
124
#define PLUGIN_VAR_SET          0x0007
144
125
#define PLUGIN_VAR_UNSIGNED     0x0080
145
 
#define PLUGIN_VAR_THDLOCAL     0x0100 /* Variable is per-connection */
 
126
#define PLUGIN_VAR_SessionLOCAL     0x0100 /* Variable is per-connection */
146
127
#define PLUGIN_VAR_READONLY     0x0200 /* Server variable is read only */
147
128
#define PLUGIN_VAR_NOSYSVAR     0x0400 /* Not a server variable */
148
129
#define PLUGIN_VAR_NOCMDOPT     0x0800 /* Not a command line option */
157
138
/*
158
139
  SYNOPSIS
159
140
    (*mysql_var_check_func)()
160
 
      thd               thread handle
 
141
      session               thread handle
161
142
      var               dynamic variable being altered
162
143
      save              pointer to temporary storage
163
144
      value             user provided value
173
154
  automatically at the end of the statement.
174
155
*/
175
156
 
176
 
typedef int (*mysql_var_check_func)(DRIZZLE_THD thd,
 
157
typedef int (*mysql_var_check_func)(Session *session,
177
158
                                    struct st_mysql_sys_var *var,
178
159
                                    void *save, struct st_mysql_value *value);
179
160
 
180
161
/*
181
162
  SYNOPSIS
182
163
    (*mysql_var_update_func)()
183
 
      thd               thread handle
 
164
      session               thread handle
184
165
      var               dynamic variable being altered
185
166
      var_ptr           pointer to dynamic variable
186
167
      save              pointer to temporary storage
191
172
   and persist it in the provided pointer to the dynamic variable.
192
173
   For example, strings may require memory to be allocated.
193
174
*/
194
 
typedef void (*mysql_var_update_func)(DRIZZLE_THD thd,
 
175
typedef void (*mysql_var_update_func)(Session *session,
195
176
                                      struct st_mysql_sys_var *var,
196
177
                                      void *var_ptr, const void *save);
197
178
 
242
223
  TYPELIB *typelib;             \
243
224
} DRIZZLE_SYSVAR_NAME(name)
244
225
 
245
 
#define DECLARE_THDVAR_FUNC(type) \
246
 
  type *(*resolve)(DRIZZLE_THD thd, int offset)
 
226
#define DECLARE_SessionVAR_FUNC(type) \
 
227
  type *(*resolve)(Session *session, int offset)
247
228
 
248
 
#define DECLARE_DRIZZLE_THDVAR_BASIC(name, type) struct { \
 
229
#define DECLARE_DRIZZLE_SessionVAR_BASIC(name, type) struct { \
249
230
  DRIZZLE_PLUGIN_VAR_HEADER;      \
250
231
  int offset;                   \
251
232
  const type def_val;           \
252
 
  DECLARE_THDVAR_FUNC(type);    \
 
233
  DECLARE_SessionVAR_FUNC(type);    \
253
234
} DRIZZLE_SYSVAR_NAME(name)
254
235
 
255
 
#define DECLARE_DRIZZLE_THDVAR_SIMPLE(name, type) struct { \
 
236
#define DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, type) struct { \
256
237
  DRIZZLE_PLUGIN_VAR_HEADER;      \
257
238
  int offset;                   \
258
239
  type def_val; type min_val;   \
259
240
  type max_val; type blk_sz;    \
260
 
  DECLARE_THDVAR_FUNC(type);    \
 
241
  DECLARE_SessionVAR_FUNC(type);    \
261
242
} DRIZZLE_SYSVAR_NAME(name)
262
243
 
263
 
#define DECLARE_DRIZZLE_THDVAR_TYPELIB(name, type) struct { \
 
244
#define DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, type) struct { \
264
245
  DRIZZLE_PLUGIN_VAR_HEADER;      \
265
246
  int offset;                   \
266
247
  type def_val;                 \
267
 
  DECLARE_THDVAR_FUNC(type);    \
 
248
  DECLARE_SessionVAR_FUNC(type);    \
268
249
  TYPELIB *typelib;             \
269
250
} DRIZZLE_SYSVAR_NAME(name)
270
251
 
323
304
  PLUGIN_VAR_SET | ((opt) & PLUGIN_VAR_MASK), \
324
305
  #name, comment, check, update, &varname, def, typelib }
325
306
 
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), \
 
307
#define DRIZZLE_SessionVAR_BOOL(name, opt, comment, check, update, def) \
 
308
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char) = { \
 
309
  PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
310
  #name, comment, check, update, -1, def, NULL}
 
311
 
 
312
#define DRIZZLE_SessionVAR_STR(name, opt, comment, check, update, def) \
 
313
DECLARE_DRIZZLE_SessionVAR_BASIC(name, char *) = { \
 
314
  PLUGIN_VAR_STR | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
315
  #name, comment, check, update, -1, def, NULL}
 
316
 
 
317
#define DRIZZLE_SessionVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
 
318
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int) = { \
 
319
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
320
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
321
 
 
322
#define DRIZZLE_SessionVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
 
323
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned int) = { \
 
324
  PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
325
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
326
 
 
327
#define DRIZZLE_SessionVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
 
328
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, long) = { \
 
329
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
330
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
331
 
 
332
#define DRIZZLE_SessionVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
 
333
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, unsigned long) = { \
 
334
  PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
335
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
336
 
 
337
#define DRIZZLE_SessionVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
338
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, int64_t) = { \
 
339
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
 
340
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
341
 
 
342
#define DRIZZLE_SessionVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
 
343
DECLARE_DRIZZLE_SessionVAR_SIMPLE(name, uint64_t) = { \
 
344
  PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
 
345
  #name, comment, check, update, -1, def, min, max, blk, NULL }
 
346
 
 
347
#define DRIZZLE_SessionVAR_ENUM(name, opt, comment, check, update, def, typelib) \
 
348
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, unsigned long) = { \
 
349
  PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
369
350
  #name, comment, check, update, -1, def, NULL, typelib }
370
351
 
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), \
 
352
#define DRIZZLE_SessionVAR_SET(name, opt, comment, check, update, def, typelib) \
 
353
DECLARE_DRIZZLE_SessionVAR_TYPELIB(name, uint64_t) = { \
 
354
  PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL | ((opt) & PLUGIN_VAR_MASK), \
374
355
  #name, comment, check, update, -1, def, NULL, typelib }
375
356
 
376
357
/* accessor macros */
378
359
#define SYSVAR(name) \
379
360
  (*(DRIZZLE_SYSVAR_NAME(name).value))
380
361
 
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)))
 
362
/* when session == null, result points to global value */
 
363
#define SessionVAR(session, name) \
 
364
  (*(DRIZZLE_SYSVAR_NAME(name).resolve(session, DRIZZLE_SYSVAR_NAME(name).offset)))
384
365
 
385
366
 
386
367
/*
389
370
 
390
371
struct st_mysql_plugin
391
372
{
392
 
  int type;             /* the plugin type (a DRIZZLE_XXX_PLUGIN value)   */
 
373
  uint32_t type;        /* the plugin type (a DRIZZLE_XXX_PLUGIN value)   */
393
374
  const char *name;     /* plugin name (for SHOW PLUGINS)               */
394
375
  const char *version;  /* plugin version (for SHOW PLUGINS)            */
395
376
  const char *author;   /* plugin author (for SHOW PLUGINS)             */
436
417
extern "C" {
437
418
#endif
438
419
 
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);
 
420
int session_in_lock_tables(const Session *session);
 
421
int session_tablespace_op(const Session *session);
 
422
void set_session_proc_info(Session *session, const char *info);
 
423
const char *get_session_proc_info(Session *session);
 
424
int64_t session_test_options(const Session *session, int64_t test_options);
 
425
int session_sql_command(const Session *session);
 
426
void **session_ha_data(const Session *session, const struct handlerton *hton);
 
427
int session_tx_isolation(const Session *session);
 
428
/* Increments the row counter, see Session::row_count */
 
429
void session_inc_row_count(Session *session);
 
430
 
 
431
LEX_STRING *session_make_lex_string(Session *session, LEX_STRING *lex_str,
 
432
                                    const char *str, unsigned int size,
 
433
                                    int allocate_lex_string);
 
434
 
 
435
 
448
436
 
449
437
/**
450
438
  Create a temporary file.
470
458
  time-consuming loops, and gracefully abort the operation if it is
471
459
  non-zero.
472
460
 
473
 
  @param thd  user thread connection handle
 
461
  @param session  user thread connection handle
474
462
  @retval 0  the connection is active
475
463
  @retval 1  the connection has been killed
476
464
*/
477
 
int thd_killed(const DRIZZLE_THD thd);
 
465
int session_killed(const Session *session);
478
466
 
479
467
 
480
468
/**
481
469
  Return the thread id of a user thread
482
470
 
483
 
  @param thd  user thread connection handle
 
471
  @param session  user thread connection handle
484
472
  @return  thread id
485
473
*/
486
 
unsigned long thd_get_thread_id(const DRIZZLE_THD thd);
 
474
unsigned long session_get_thread_id(const Session *session);
487
475
 
488
476
 
489
477
/**
498
486
 
499
487
  @see alloc_root()
500
488
*/
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);
 
489
void *session_alloc(Session *session, unsigned int size);
 
490
/**
 
491
  @see session_alloc()
 
492
*/
 
493
void *session_calloc(Session *session, unsigned int size);
 
494
/**
 
495
  @see session_alloc()
 
496
*/
 
497
char *session_strdup(Session *session, const char *str);
 
498
/**
 
499
  @see session_alloc()
 
500
*/
 
501
char *session_strmake(Session *session, const char *str, unsigned int size);
 
502
/**
 
503
  @see session_alloc()
 
504
*/
 
505
void *session_memdup(Session *session, const void* str, unsigned int size);
535
506
 
536
507
/**
537
508
  Get the XID for this connection's transaction
538
509
 
539
 
  @param thd  user thread connection handle
 
510
  @param session  user thread connection handle
540
511
  @param xid  location where identifier is stored
541
512
*/
542
 
void thd_get_xid(const DRIZZLE_THD thd, DRIZZLE_XID *xid);
 
513
void session_get_xid(const Session *session, DRIZZLE_XID *xid);
543
514
 
544
515
/**
545
516
  Invalidate the query cache for a given table.
546
517
 
547
 
  @param thd         user thread connection handle
 
518
  @param session         user thread connection handle
548
519
  @param key         databasename\\0tablename\\0
549
520
  @param key_length  length of key in bytes, including the NUL bytes
550
521
  @param using_trx   flag: TRUE if using transactions, FALSE otherwise
551
522
*/
552
 
void mysql_query_cache_invalidate4(DRIZZLE_THD thd,
 
523
void mysql_query_cache_invalidate4(Session *session,
553
524
                                   const char *key, unsigned int key_length,
554
525
                                   int using_trx);
555
526
 
563
534
*/
564
535
inline
565
536
void *
566
 
thd_get_ha_data(const DRIZZLE_THD thd, const struct handlerton *hton)
 
537
session_get_ha_data(const Session *session, const struct handlerton *hton)
567
538
{
568
 
  return *thd_ha_data(thd, hton);
 
539
  return *session_ha_data(session, hton);
569
540
}
570
541
 
571
542
/**
573
544
*/
574
545
inline
575
546
void
576
 
thd_set_ha_data(const DRIZZLE_THD thd, const struct handlerton *hton,
 
547
session_set_ha_data(const Session *session, const struct handlerton *hton,
577
548
                const void *ha_data)
578
549
{
579
 
  *thd_ha_data(thd, hton)= (void*) ha_data;
 
550
  *session_ha_data(session, hton)= (void*) ha_data;
580
551
}
581
552
#endif
582
553
 
583
 
#endif
 
554
#endif /* _my_plugin_h */
584
555