← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/loader.cc

Merged remove-dead-Item-save_in_field_no_warnings into fix-order_st-BY-comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/loader.cc
48
48
#endif
49
49
 
50
50
using namespace std;
51
 
using namespace drizzled;
 
51
 
 
52
typedef drizzled::plugin::Manifest drizzled_builtin_plugin[];
 
53
extern drizzled_builtin_plugin PANDORA_BUILTIN_LIST;
 
54
static drizzled::plugin::Manifest *drizzled_builtins[]=
 
55
{
 
56
  PANDORA_BUILTIN_LIST, NULL
 
57
};
 
58
 
 
59
namespace drizzled
 
60
{
52
61
 
53
 
typedef plugin::Manifest builtin_plugin[];
54
 
extern builtin_plugin PANDORA_BUILTIN_LIST;
55
 
static plugin::Manifest *drizzled_builtins[]=
56
 
{
57
 
  PANDORA_BUILTIN_LIST, NULL
58
 
};
59
62
 
60
63
class sys_var_pluginvar;
61
64
static vector<sys_var_pluginvar *> plugin_sysvar_vec;
62
65
 
63
66
char *opt_plugin_add= NULL;
64
67
char *opt_plugin_load= NULL;
65
 
const char *opt_plugin_load_default= PANDORA_PLUGIN_LIST;
66
68
char *opt_plugin_dir_ptr;
67
69
char opt_plugin_dir[FN_REFLEN];
 
70
const char *opt_plugin_load_default= PANDORA_PLUGIN_LIST;
68
71
 
69
72
/* Note that 'int version' must be the first field of every plugin
70
73
   sub-structure (plugin->info).
355
358
}
356
359
 
357
360
 
358
 
extern "C" unsigned char *get_bookmark_hash_key(const unsigned char *, size_t *, bool);
359
 
 
360
 
 
361
 
unsigned char *get_bookmark_hash_key(const unsigned char *buff, size_t *length, bool)
 
361
static unsigned char *get_bookmark_hash_key(const unsigned char *buff,
 
362
                                            size_t *length, bool)
362
363
{
363
364
  struct st_bookmark *var= (st_bookmark *)buff;
364
365
  *length= var->name_len + 1;
569
570
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_str_t, char *);
570
571
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_str_t, char *);
571
572
 
572
 
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_enum_t, unsigned long);
573
573
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_enum_t, unsigned long);
574
 
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_set_t, uint64_t);
575
574
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_set_t, uint64_t);
576
575
 
577
576
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int_t, int);
620
619
      goto err;
621
620
    if (tmp > 1)
622
621
    {
623
 
      llstr(tmp, buff);
 
622
      internal::llstr(tmp, buff);
624
623
      strvalue= buff;
625
624
      goto err;
626
625
    }
708
707
}
709
708
 
710
709
 
711
 
static int check_func_enum(Session *, drizzle_sys_var *var,
712
 
                           void *save, drizzle_value *value)
713
 
{
714
 
  char buff[STRING_BUFFER_USUAL_SIZE];
715
 
  const char *strvalue= "NULL", *str;
716
 
  TYPELIB *typelib;
717
 
  int64_t tmp;
718
 
  long result;
719
 
  int length;
720
 
 
721
 
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
722
 
    typelib= ((sessionvar_enum_t*) var)->typelib;
723
 
  else
724
 
    typelib= ((sysvar_enum_t*) var)->typelib;
725
 
 
726
 
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
727
 
  {
728
 
    length= sizeof(buff);
729
 
    if (!(str= value->val_str(value, buff, &length)))
730
 
      goto err;
731
 
    if ((result= (long)find_type(typelib, str, length, 1)-1) < 0)
732
 
    {
733
 
      strvalue= str;
734
 
      goto err;
735
 
    }
736
 
  }
737
 
  else
738
 
  {
739
 
    if (value->val_int(value, &tmp))
740
 
      goto err;
741
 
    if (tmp >= typelib->count)
742
 
    {
743
 
      llstr(tmp, buff);
744
 
      strvalue= buff;
745
 
      goto err;
746
 
    }
747
 
    result= (long) tmp;
748
 
  }
749
 
  *(long*)save= result;
750
 
  return 0;
751
 
err:
752
 
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
753
 
  return 1;
754
 
}
755
 
 
756
 
 
757
 
static int check_func_set(Session *, drizzle_sys_var *var,
758
 
                          void *save, drizzle_value *value)
759
 
{
760
 
  char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;
761
 
  const char *strvalue= "NULL", *str;
762
 
  TYPELIB *typelib;
763
 
  uint64_t result;
764
 
  uint32_t error_len;
765
 
  bool not_used;
766
 
  int length;
767
 
 
768
 
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
769
 
    typelib= ((sessionvar_set_t*) var)->typelib;
770
 
  else
771
 
    typelib= ((sysvar_set_t*)var)->typelib;
772
 
 
773
 
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
774
 
  {
775
 
    length= sizeof(buff);
776
 
    if (!(str= value->val_str(value, buff, &length)))
777
 
      goto err;
778
 
    result= find_set(typelib, str, length, NULL,
779
 
                     &error, &error_len, &not_used);
780
 
    if (error_len)
781
 
    {
782
 
      length= min((uint32_t)sizeof(buff), error_len);
783
 
      strncpy(buff, error, length);
784
 
      buff[length]= '\0';
785
 
      strvalue= buff;
786
 
      goto err;
787
 
    }
788
 
  }
789
 
  else
790
 
  {
791
 
    if (value->val_int(value, (int64_t *)&result))
792
 
      goto err;
793
 
    if (unlikely((result >= (1UL << typelib->count)) &&
794
 
                 (typelib->count < sizeof(long)*8)))
795
 
    {
796
 
      llstr(result, buff);
797
 
      strvalue= buff;
798
 
      goto err;
799
 
    }
800
 
  }
801
 
  *(uint64_t*)save= result;
802
 
  return 0;
803
 
err:
804
 
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
805
 
  return 1;
806
 
}
807
 
 
808
 
 
809
710
static void update_func_bool(Session *, drizzle_sys_var *,
810
711
                             void *tgt, const void *save)
811
712
{
953
854
    size= ALIGN_SIZE(sizeof(int));
954
855
    break;
955
856
  case PLUGIN_VAR_LONG:
956
 
  case PLUGIN_VAR_ENUM:
957
857
    size= ALIGN_SIZE(sizeof(long));
958
858
    break;
959
859
  case PLUGIN_VAR_LONGLONG:
960
 
  case PLUGIN_VAR_SET:
961
860
    size= ALIGN_SIZE(sizeof(uint64_t));
962
861
    break;
963
862
  case PLUGIN_VAR_STR:
1154
1053
  return (char **)intern_sys_var_ptr(a_session, offset, true);
1155
1054
}
1156
1055
 
1157
 
static uint64_t *mysql_sys_var_ptr_set(Session* a_session, int offset)
1158
 
{
1159
 
  return (uint64_t *)intern_sys_var_ptr(a_session, offset, true);
1160
 
}
1161
 
 
1162
 
static unsigned long *mysql_sys_var_ptr_enum(Session* a_session, int offset)
1163
 
{
1164
 
  return (unsigned long *)intern_sys_var_ptr(a_session, offset, true);
1165
 
}
1166
 
 
1167
 
 
1168
1056
void plugin_sessionvar_init(Session *session)
1169
1057
{
1170
1058
  session->variables.storage_engine= NULL;
1304
1192
    return SHOW_LONGLONG;
1305
1193
  case PLUGIN_VAR_STR:
1306
1194
    return SHOW_CHAR_PTR;
1307
 
  case PLUGIN_VAR_ENUM:
1308
 
  case PLUGIN_VAR_SET:
1309
 
    return SHOW_CHAR;
1310
1195
  default:
1311
1196
    assert(0);
1312
1197
    return SHOW_UNDEF;
1331
1216
TYPELIB* sys_var_pluginvar::plugin_var_typelib(void)
1332
1217
{
1333
1218
  switch (plugin_var->flags & (PLUGIN_VAR_TYPEMASK | PLUGIN_VAR_SessionLOCAL)) {
1334
 
  case PLUGIN_VAR_ENUM:
1335
 
    return ((sysvar_enum_t *)plugin_var)->typelib;
1336
 
  case PLUGIN_VAR_SET:
1337
 
    return ((sysvar_set_t *)plugin_var)->typelib;
1338
 
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
 
1219
  case PLUGIN_VAR_SessionLOCAL:
1339
1220
    return ((sessionvar_enum_t *)plugin_var)->typelib;
1340
 
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
1341
 
    return ((sessionvar_set_t *)plugin_var)->typelib;
1342
1221
  default:
1343
1222
    return NULL;
1344
1223
  }
1352
1231
 
1353
1232
  result= real_value_ptr(session, type);
1354
1233
 
1355
 
  if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_ENUM)
1356
 
    result= (unsigned char*) get_type(plugin_var_typelib(), *(ulong*)result);
1357
 
  else if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_SET)
1358
 
  {
1359
 
    char buffer[STRING_BUFFER_USUAL_SIZE];
1360
 
    String str(buffer, sizeof(buffer), system_charset_info);
1361
 
    TYPELIB *typelib= plugin_var_typelib();
1362
 
    uint64_t mask= 1, value= *(uint64_t*) result;
1363
 
    uint32_t i;
1364
 
 
1365
 
    str.length(0);
1366
 
    for (i= 0; i < typelib->count; i++, mask<<=1)
1367
 
    {
1368
 
      if (!(value & mask))
1369
 
        continue;
1370
 
      str.append(typelib->type_names[i], typelib->type_lengths[i]);
1371
 
      str.append(',');
1372
 
    }
1373
 
 
1374
 
    result= (unsigned char*) "";
1375
 
    if (str.length())
1376
 
      result= (unsigned char*) session->strmake(str.ptr(), str.length()-1);
1377
 
  }
1378
1234
  return result;
1379
1235
}
1380
1236
 
1424
1280
        case PLUGIN_VAR_LONGLONG:
1425
1281
          src= &((sessionvar_uint64_t_t*) plugin_var)->def_val;
1426
1282
          break;
1427
 
        case PLUGIN_VAR_ENUM:
1428
 
          src= &((sessionvar_enum_t*) plugin_var)->def_val;
1429
 
          break;
1430
 
        case PLUGIN_VAR_SET:
1431
 
          src= &((sessionvar_set_t*) plugin_var)->def_val;
1432
 
          break;
1433
1283
        case PLUGIN_VAR_BOOL:
1434
1284
          src= &((sessionvar_bool_t*) plugin_var)->def_val;
1435
1285
          break;
1523
1373
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED:
1524
1374
    OPTION_SET_LIMITS(GET_ULL, options, (sysvar_uint64_t_t*) opt);
1525
1375
    break;
1526
 
  case PLUGIN_VAR_ENUM:
1527
 
    options->var_type= GET_ENUM;
1528
 
    options->typelib= ((sysvar_enum_t*) opt)->typelib;
1529
 
    options->def_value= ((sysvar_enum_t*) opt)->def_val;
1530
 
    options->min_value= options->block_size= 0;
1531
 
    options->max_value= options->typelib->count - 1;
1532
 
    break;
1533
 
  case PLUGIN_VAR_SET:
1534
 
    options->var_type= GET_SET;
1535
 
    options->typelib= ((sysvar_set_t*) opt)->typelib;
1536
 
    options->def_value= ((sysvar_set_t*) opt)->def_val;
1537
 
    options->min_value= options->block_size= 0;
1538
 
    options->max_value= (1UL << options->typelib->count) - 1;
1539
 
    break;
1540
1376
  case PLUGIN_VAR_BOOL:
1541
1377
    options->var_type= GET_BOOL;
1542
1378
    options->def_value= ((sysvar_bool_t*) opt)->def_val;
1565
1401
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
1566
1402
    OPTION_SET_LIMITS(GET_ULL, options, (sessionvar_uint64_t_t*) opt);
1567
1403
    break;
1568
 
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
1569
 
    options->var_type= GET_ENUM;
1570
 
    options->typelib= ((sessionvar_enum_t*) opt)->typelib;
1571
 
    options->def_value= ((sessionvar_enum_t*) opt)->def_val;
1572
 
    options->min_value= options->block_size= 0;
1573
 
    options->max_value= options->typelib->count - 1;
1574
 
    break;
1575
 
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
1576
 
    options->var_type= GET_SET;
1577
 
    options->typelib= ((sessionvar_set_t*) opt)->typelib;
1578
 
    options->def_value= ((sessionvar_set_t*) opt)->def_val;
1579
 
    options->min_value= options->block_size= 0;
1580
 
    options->max_value= (1UL << options->typelib->count) - 1;
1581
 
    break;
1582
1404
  case PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL:
1583
1405
    options->var_type= GET_BOOL;
1584
1406
    options->def_value= ((sessionvar_bool_t*) opt)->def_val;
1598
1420
    options->arg_type= OPT_ARG;
1599
1421
}
1600
1422
 
1601
 
extern "C" bool get_one_plugin_option(int optid, const struct my_option *,
1602
 
                                         char *);
1603
 
 
1604
 
bool get_one_plugin_option(int, const struct my_option *, char *)
 
1423
static bool get_one_plugin_option(int, const struct my_option *, char *)
1605
1424
{
1606
1425
  return 0;
1607
1426
}
1690
1509
    case PLUGIN_VAR_STR:
1691
1510
      (((sessionvar_str_t *)opt)->resolve)= mysql_sys_var_ptr_str;
1692
1511
      break;
1693
 
    case PLUGIN_VAR_ENUM:
1694
 
      (((sessionvar_enum_t *)opt)->resolve)= mysql_sys_var_ptr_enum;
1695
 
      break;
1696
 
    case PLUGIN_VAR_SET:
1697
 
      (((sessionvar_set_t *)opt)->resolve)= mysql_sys_var_ptr_set;
1698
 
      break;
1699
1512
    default:
1700
1513
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
1701
1514
                      opt->flags, plugin_name);
1747
1560
        }
1748
1561
      }
1749
1562
      break;
1750
 
    case PLUGIN_VAR_ENUM:
1751
 
      if (!opt->check)
1752
 
        opt->check= check_func_enum;
1753
 
      if (!opt->update)
1754
 
        opt->update= update_func_long;
1755
 
      break;
1756
 
    case PLUGIN_VAR_SET:
1757
 
      if (!opt->check)
1758
 
        opt->check= check_func_set;
1759
 
      if (!opt->update)
1760
 
        opt->update= update_func_int64_t;
1761
 
      break;
1762
1563
    default:
1763
1564
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
1764
1565
                      opt->flags, plugin_name);
2058
1859
 
2059
1860
}
2060
1861
 
 
1862
} /* namespace drizzled */