← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_plugin.cc

  • Committer: Brian Aker
  • Date: 2009-03-03 18:50:34 UTC
  • mfrom: (908.1.17 mordred)
  • Revision ID: brian@tangent.org-20090303185034-obr7tiwx8vyn0i7j
Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_plugin.cc
31
31
#include <drizzled/set_var.h>
32
32
#include <drizzled/session.h>
33
33
#include <drizzled/item/null.h>
 
34
#include <drizzled/plugin_registry.h>
34
35
 
35
36
#include <string>
36
37
#include <vector>
131
132
 
132
133
static DYNAMIC_ARRAY plugin_dl_array;
133
134
static DYNAMIC_ARRAY plugin_array;
134
 
static map<string, st_plugin_int *> plugin_map[DRIZZLE_MAX_PLUGIN_TYPE_NUM];
 
135
 
135
136
static bool reap_needed= false;
136
137
static int plugin_array_version=0;
137
138
 
470
471
}
471
472
 
472
473
 
473
 
static struct st_plugin_int *plugin_find_internal(const LEX_STRING *name, int type)
474
 
{
475
 
  uint32_t i;
476
 
  if (! initialized)
477
 
    return(0);
478
 
  string find_str(name->str,name->length);
479
 
  transform(find_str.begin(), find_str.end(), find_str.begin(), ::tolower);
480
 
 
481
 
  map<string, st_plugin_int *>::iterator map_iter;
482
 
  if (type == DRIZZLE_ANY_PLUGIN)
483
 
  {
484
 
    for (i= 0; i < DRIZZLE_MAX_PLUGIN_TYPE_NUM; i++)
485
 
    {
486
 
      map_iter= plugin_map[i].find(find_str);
487
 
      if (map_iter != plugin_map[i].end())
488
 
        return (*map_iter).second;
489
 
    }
490
 
  }
491
 
  else
492
 
  {
493
 
    map_iter= plugin_map[type].find(find_str);
494
 
    if (map_iter != plugin_map[type].end())
495
 
      return (*map_iter).second;
496
 
  }
497
 
  return(0);
498
 
}
499
 
 
500
474
 
501
475
static SHOW_COMP_OPTION plugin_status(const LEX_STRING *name, int type)
502
476
{
 
477
  Plugin_registry registry= Plugin_registry::get_plugin_registry();
 
478
 
503
479
  SHOW_COMP_OPTION rc= SHOW_OPTION_NO;
504
480
  struct st_plugin_int *plugin;
505
 
  if ((plugin= plugin_find_internal(name, type)))
 
481
 
 
482
  if (! initialized)
 
483
    return(rc);
 
484
 
 
485
  if ((plugin= registry.find(name, type)))
506
486
  {
507
487
    rc= SHOW_OPTION_DISABLED;
508
488
    if (plugin->state == PLUGIN_IS_READY)
563
543
 
564
544
plugin_ref plugin_lock_by_name(Session *session, const LEX_STRING *name, int type)
565
545
{
 
546
  Plugin_registry registry= Plugin_registry::get_plugin_registry();
 
547
 
566
548
  LEX *lex= session ? session->lex : 0;
567
549
  plugin_ref rc= NULL;
568
550
  st_plugin_int *plugin;
569
 
  if ((plugin= plugin_find_internal(name, type)))
 
551
  if (! initialized)
 
552
    return(0);
 
553
 
 
554
  if ((plugin= registry.find(name, type)))
570
555
    rc= my_intern_plugin_lock_ci(lex, plugin_int_to_ref(plugin));
571
556
  return(rc);
572
557
}
603
588
                       const LEX_STRING *name, const LEX_STRING *dl,
604
589
                       int *argc, char **argv, int report)
605
590
{
 
591
  Plugin_registry registry= Plugin_registry::get_plugin_registry();
 
592
 
606
593
  struct st_plugin_int tmp;
607
594
  struct st_mysql_plugin *plugin;
608
 
  if (plugin_find_internal(name, DRIZZLE_ANY_PLUGIN))
 
595
  if (! initialized)
 
596
    return(0);
 
597
 
 
598
  if (registry.find(name, DRIZZLE_ANY_PLUGIN))
609
599
  {
610
600
    if (report & REPORT_TO_USER)
611
601
      my_error(ER_UDF_EXISTS, MYF(0), name->str);
639
629
        if ((tmp_plugin_ptr= plugin_insert_or_reuse(&tmp)))
640
630
        {
641
631
          plugin_array_version++;
642
 
          string add_str(plugin->name);
643
 
          transform(add_str.begin(), add_str.end(),
644
 
                    add_str.begin(), ::tolower);
645
 
 
646
 
          plugin_map[plugin->type][add_str]= tmp_plugin_ptr;
 
632
          registry.add(plugin, tmp_plugin_ptr);
647
633
          init_alloc_root(&tmp_plugin_ptr->mem_root, 4096, 4096);
648
634
          return(false);
649
635
        }
981
967
                             struct st_plugin_int **ptr)
982
968
{
983
969
 
 
970
  Plugin_registry registry= Plugin_registry::get_plugin_registry();
 
971
 
984
972
  tmp->state= PLUGIN_IS_UNINITIALIZED;
985
973
  tmp->ref_count= 0;
986
974
  tmp->plugin_dl= 0;
993
981
        (struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)tmp,
994
982
                                             sizeof(struct st_plugin_int));
995
983
 
996
 
  string add_str(plugin->name);
997
 
  transform(add_str.begin(), add_str.end(),
998
 
            add_str.begin(), ::tolower);
999
 
 
1000
 
  plugin_map[plugin->type][add_str]= *ptr;
 
984
  registry.add(plugin, *ptr);
1001
985
 
1002
986
  return(0);
1003
987
}
1234
1218
  }
1235
1219
  else
1236
1220
  {
1237
 
    plugins.reserve(plugin_map[type].size());
1238
 
    map<string, st_plugin_int *>::iterator map_iter;
1239
 
 
1240
 
    for (map_iter= plugin_map[type].begin();
1241
 
         map_iter != plugin_map[type].end();
1242
 
         map_iter++)
1243
 
    {
1244
 
      plugin= (*map_iter).second;
1245
 
      plugins.push_back(!(plugin->state & state_mask) ? plugin : NULL);
1246
 
    }
 
1221
    Plugin_registry registry= Plugin_registry::get_plugin_registry();
 
1222
    registry.get_mask_list(type, plugins, state_mask);
1247
1223
  }
1248
1224
 
1249
1225
  vector<st_plugin_int *>::iterator plugin_iter;