← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_plugin.cc

  • Committer: Grant Limberg
  • Date: 2008-08-12 21:13:01 UTC
  • mto: (322.1.1 codestyle)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: grant@glsoftware.net-20080812211301-ym3wsowelkgp16s2
renamed all instances of MYSQL_ to DRIZZLE_

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_plugin.cc
32
32
  When you ad a new plugin type, add both a string and make sure that the
33
33
  init and deinit array are correctly updated.
34
34
*/
35
 
const LEX_STRING plugin_type_names[MYSQL_MAX_PLUGIN_TYPE_NUM]=
 
35
const LEX_STRING plugin_type_names[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=
36
36
{
37
37
  { C_STRING_WITH_LEN("DAEMON") },
38
38
  { C_STRING_WITH_LEN("STORAGE ENGINE") },
55
55
  plugin_type_deinitialize should equal to the number of plugins
56
56
  defined.
57
57
*/
58
 
plugin_type_init plugin_type_initialize[MYSQL_MAX_PLUGIN_TYPE_NUM]=
 
58
plugin_type_init plugin_type_initialize[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=
59
59
{
60
60
  0,  /* Daemon */
61
61
  ha_initialize_handlerton,  /* Storage Engine */
67
67
  authentication_initializer  /* Auth */
68
68
};
69
69
 
70
 
plugin_type_init plugin_type_deinitialize[MYSQL_MAX_PLUGIN_TYPE_NUM]=
 
70
plugin_type_init plugin_type_deinitialize[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=
71
71
{
72
72
  0,  /* Daemon */
73
73
  ha_finalize_handlerton,  /* Storage Engine */
89
89
 
90
90
static DYNAMIC_ARRAY plugin_dl_array;
91
91
static DYNAMIC_ARRAY plugin_array;
92
 
static HASH plugin_hash[MYSQL_MAX_PLUGIN_TYPE_NUM];
 
92
static HASH plugin_hash[DRIZZLE_MAX_PLUGIN_TYPE_NUM];
93
93
static bool reap_needed= false;
94
94
static int plugin_array_version=0;
95
95
 
137
137
*/
138
138
struct st_mysql_sys_var
139
139
{
140
 
  MYSQL_PLUGIN_VAR_HEADER;
 
140
  DRIZZLE_PLUGIN_VAR_HEADER;
141
141
};
142
142
 
143
143
 
210
210
{
211
211
  switch (((st_item_value_holder*)value)->item->result_type()) {
212
212
  case INT_RESULT:
213
 
    return MYSQL_VALUE_TYPE_INT;
 
213
    return DRIZZLE_VALUE_TYPE_INT;
214
214
  case REAL_RESULT:
215
 
    return MYSQL_VALUE_TYPE_REAL;
 
215
    return DRIZZLE_VALUE_TYPE_REAL;
216
216
  default:
217
 
    return MYSQL_VALUE_TYPE_STRING;
 
217
    return DRIZZLE_VALUE_TYPE_STRING;
218
218
  }
219
219
}
220
220
 
432
432
  if (! initialized)
433
433
    return(0);
434
434
 
435
 
  if (type == MYSQL_ANY_PLUGIN)
 
435
  if (type == DRIZZLE_ANY_PLUGIN)
436
436
  {
437
 
    for (i= 0; i < MYSQL_MAX_PLUGIN_TYPE_NUM; i++)
 
437
    for (i= 0; i < DRIZZLE_MAX_PLUGIN_TYPE_NUM; i++)
438
438
    {
439
439
      struct st_plugin_int *plugin= (st_plugin_int *)
440
440
        hash_search(&plugin_hash[i], (const uchar *)name->str, name->length);
559
559
{
560
560
  struct st_plugin_int tmp;
561
561
  struct st_mysql_plugin *plugin;
562
 
  if (plugin_find_internal(name, MYSQL_ANY_PLUGIN))
 
562
  if (plugin_find_internal(name, DRIZZLE_ANY_PLUGIN))
563
563
  {
564
564
    if (report & REPORT_TO_USER)
565
565
      my_error(ER_UDF_EXISTS, MYF(0), name->str);
575
575
  for (plugin= tmp.plugin_dl->plugins; plugin->name; plugin++)
576
576
  {
577
577
    uint name_len= strlen(plugin->name);
578
 
    if (plugin->type >= 0 && plugin->type < MYSQL_MAX_PLUGIN_TYPE_NUM &&
 
578
    if (plugin->type >= 0 && plugin->type < DRIZZLE_MAX_PLUGIN_TYPE_NUM &&
579
579
        ! my_strnncoll(system_charset_info,
580
580
                       (const uchar *)name->str, name->length,
581
581
                       (const uchar *)plugin->name,
892
892
                            sizeof(struct st_plugin_int *),16,16))
893
893
    goto err;
894
894
 
895
 
  for (i= 0; i < MYSQL_MAX_PLUGIN_TYPE_NUM; i++)
 
895
  for (i= 0; i < DRIZZLE_MAX_PLUGIN_TYPE_NUM; i++)
896
896
  {
897
897
    if (hash_init(&plugin_hash[i], system_charset_info, 16, 0, 0,
898
898
                  get_plugin_hash_key, NULL, HASH_UNIQUE))
1200
1200
 
1201
1201
  /* Dispose of the memory */
1202
1202
 
1203
 
  for (i= 0; i < MYSQL_MAX_PLUGIN_TYPE_NUM; i++)
 
1203
  for (i= 0; i < DRIZZLE_MAX_PLUGIN_TYPE_NUM; i++)
1204
1204
    hash_free(&plugin_hash[i]);
1205
1205
  delete_dynamic(&plugin_array);
1206
1206
 
1234
1234
 
1235
1235
  state_mask= ~state_mask; // do it only once
1236
1236
 
1237
 
  total= type == MYSQL_ANY_PLUGIN ? plugin_array.elements
 
1237
  total= type == DRIZZLE_ANY_PLUGIN ? plugin_array.elements
1238
1238
                                  : plugin_hash[type].records;
1239
1239
  /*
1240
1240
    Do the alloca out here in case we do have a working alloca:
1241
1241
        leaving the nested stack frame invalidates alloca allocation.
1242
1242
  */
1243
1243
  plugins=(struct st_plugin_int **)my_alloca(total*sizeof(plugin));
1244
 
  if (type == MYSQL_ANY_PLUGIN)
 
1244
  if (type == DRIZZLE_ANY_PLUGIN)
1245
1245
  {
1246
1246
    for (idx= 0; idx < total; idx++)
1247
1247
    {
1284
1284
  Internal type declarations for variables support
1285
1285
****************************************************************************/
1286
1286
 
1287
 
#undef MYSQL_SYSVAR_NAME
1288
 
#define MYSQL_SYSVAR_NAME(name) name
 
1287
#undef DRIZZLE_SYSVAR_NAME
 
1288
#define DRIZZLE_SYSVAR_NAME(name) name
1289
1289
#define PLUGIN_VAR_TYPEMASK 0x007f
1290
1290
 
1291
1291
#define EXTRA_OPTIONS 3 /* options for: 'foo', 'plugin-foo' and NULL */
1292
1292
 
1293
 
typedef DECLARE_MYSQL_SYSVAR_BASIC(sysvar_bool_t, bool);
1294
 
typedef DECLARE_MYSQL_THDVAR_BASIC(thdvar_bool_t, bool);
1295
 
typedef DECLARE_MYSQL_SYSVAR_BASIC(sysvar_str_t, char *);
1296
 
typedef DECLARE_MYSQL_THDVAR_BASIC(thdvar_str_t, char *);
1297
 
 
1298
 
typedef DECLARE_MYSQL_SYSVAR_TYPELIB(sysvar_enum_t, unsigned long);
1299
 
typedef DECLARE_MYSQL_THDVAR_TYPELIB(thdvar_enum_t, unsigned long);
1300
 
typedef DECLARE_MYSQL_SYSVAR_TYPELIB(sysvar_set_t, uint64_t);
1301
 
typedef DECLARE_MYSQL_THDVAR_TYPELIB(thdvar_set_t, uint64_t);
1302
 
 
1303
 
typedef DECLARE_MYSQL_SYSVAR_SIMPLE(sysvar_int_t, int);
1304
 
typedef DECLARE_MYSQL_SYSVAR_SIMPLE(sysvar_long_t, long);
1305
 
typedef DECLARE_MYSQL_SYSVAR_SIMPLE(sysvar_int64_t_t, int64_t);
1306
 
typedef DECLARE_MYSQL_SYSVAR_SIMPLE(sysvar_uint_t, uint);
1307
 
typedef DECLARE_MYSQL_SYSVAR_SIMPLE(sysvar_ulong_t, ulong);
1308
 
typedef DECLARE_MYSQL_SYSVAR_SIMPLE(sysvar_uint64_t_t, uint64_t);
1309
 
 
1310
 
typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_int_t, int);
1311
 
typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_long_t, long);
1312
 
typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_int64_t_t, int64_t);
1313
 
typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_uint_t, uint);
1314
 
typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_ulong_t, ulong);
1315
 
typedef DECLARE_MYSQL_THDVAR_SIMPLE(thdvar_uint64_t_t, uint64_t);
 
1293
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_bool_t, bool);
 
1294
typedef DECLARE_DRIZZLE_THDVAR_BASIC(thdvar_bool_t, bool);
 
1295
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_str_t, char *);
 
1296
typedef DECLARE_DRIZZLE_THDVAR_BASIC(thdvar_str_t, char *);
 
1297
 
 
1298
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_enum_t, unsigned long);
 
1299
typedef DECLARE_DRIZZLE_THDVAR_TYPELIB(thdvar_enum_t, unsigned long);
 
1300
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_set_t, uint64_t);
 
1301
typedef DECLARE_DRIZZLE_THDVAR_TYPELIB(thdvar_set_t, uint64_t);
 
1302
 
 
1303
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int_t, int);
 
1304
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_long_t, long);
 
1305
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int64_t_t, int64_t);
 
1306
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_uint_t, uint);
 
1307
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_ulong_t, ulong);
 
1308
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_uint64_t_t, uint64_t);
 
1309
 
 
1310
typedef DECLARE_DRIZZLE_THDVAR_SIMPLE(thdvar_int_t, int);
 
1311
typedef DECLARE_DRIZZLE_THDVAR_SIMPLE(thdvar_long_t, long);
 
1312
typedef DECLARE_DRIZZLE_THDVAR_SIMPLE(thdvar_int64_t_t, int64_t);
 
1313
typedef DECLARE_DRIZZLE_THDVAR_SIMPLE(thdvar_uint_t, uint);
 
1314
typedef DECLARE_DRIZZLE_THDVAR_SIMPLE(thdvar_ulong_t, ulong);
 
1315
typedef DECLARE_DRIZZLE_THDVAR_SIMPLE(thdvar_uint64_t_t, uint64_t);
1316
1316
 
1317
1317
typedef bool *(*mysql_sys_var_ptr_p)(THD* a_thd, int offset);
1318
1318
 
1330
1330
  int result, length;
1331
1331
  int64_t tmp;
1332
1332
 
1333
 
  if (value->value_type(value) == MYSQL_VALUE_TYPE_STRING)
 
1333
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
1334
1334
  {
1335
1335
    length= sizeof(buff);
1336
1336
    if (!(str= value->val_str(value, buff, &length)) ||
1452
1452
  else
1453
1453
    typelib= ((sysvar_enum_t*) var)->typelib;
1454
1454
 
1455
 
  if (value->value_type(value) == MYSQL_VALUE_TYPE_STRING)
 
1455
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
1456
1456
  {
1457
1457
    length= sizeof(buff);
1458
1458
    if (!(str= value->val_str(value, buff, &length)))
1500
1500
  else
1501
1501
    typelib= ((sysvar_set_t*)var)->typelib;
1502
1502
 
1503
 
  if (value->value_type(value) == MYSQL_VALUE_TYPE_STRING)
 
1503
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
1504
1504
  {
1505
1505
    length= sizeof(buff);
1506
1506
    if (!(str= value->val_str(value, buff, &length)))