← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_udf.cc

  • Committer: Monty Taylor
  • Date: 2009-04-25 20:29:54 UTC
  • mto: (997.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 1003.
  • Revision ID: mordred@inaugust.com-20090425202954-slopmkjj7vxal5lk
Migrated archive.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_udf.cc
15
15
 
16
16
/* This implements 'user defined functions' */
17
17
#include <drizzled/server_includes.h>
18
 
#include <libdrizzle/gettext.h>
19
 
 
20
 
static bool udf_startup= false; /* We do not lock because startup is single threaded */
21
 
static MEM_ROOT mem;
22
 
static HASH udf_hash;
23
 
 
24
 
extern "C" unsigned char* get_hash_key(const unsigned char *buff, size_t *length,
25
 
                               bool not_used __attribute__((unused)))
26
 
{
27
 
  udf_func *udf= (udf_func*) buff;
28
 
  *length= (uint) udf->name.length;
29
 
  return (unsigned char*) udf->name.str;
30
 
}
31
 
 
32
 
 
33
 
void udf_init()
34
 
{
35
 
  init_sql_alloc(&mem, UDF_ALLOC_BLOCK_SIZE, 0);
36
 
 
37
 
  if (hash_init(&udf_hash, system_charset_info, 32, 0, 0, get_hash_key, NULL, 0))
38
 
  {
39
 
    sql_print_error(_("Can't allocate memory for udf structures"));
40
 
    hash_free(&udf_hash);
41
 
    free_root(&mem, MYF(0));
42
 
    return;
43
 
  }
44
 
}
45
 
 
46
 
/* called by mysqld.cc clean_up() */
47
 
void udf_free()
48
 
{
49
 
  hash_free(&udf_hash);
50
 
  free_root(&mem, MYF(0));
51
 
}
 
18
#include <drizzled/gettext.h>
 
19
#include <drizzled/sql_udf.h>
 
20
#include <drizzled/registry.h>
 
21
#include "drizzled/plugin_registry.h"
 
22
 
 
23
#include <string>
 
24
 
 
25
using namespace std;
 
26
 
 
27
static drizzled::Registry<Function_builder *> udf_registry;
52
28
 
53
29
/* This is only called if using_udf_functions != 0 */
54
 
udf_func *find_udf(const char *name, uint32_t length)
55
 
{
56
 
  udf_func *udf;
57
 
 
58
 
  if (udf_startup == false)
59
 
    return NULL;
60
 
 
61
 
  udf= (udf_func*) hash_search(&udf_hash,
62
 
                               (unsigned char*) name,
63
 
                               length ? length : (uint) strlen(name));
64
 
 
65
 
  return (udf);
66
 
}
67
 
 
68
 
static bool add_udf(udf_func *udf)
69
 
{
70
 
  if (my_hash_insert(&udf_hash, (unsigned char*) udf))
71
 
    return false;
72
 
 
73
 
  using_udf_functions= 1;
74
 
 
75
 
  return true;
76
 
}
77
 
 
78
 
int initialize_udf(st_plugin_int *plugin)
79
 
{
80
 
  udf_func *f;
81
 
 
82
 
  if (udf_startup == false)
83
 
  {
84
 
    udf_init();
85
 
    udf_startup= true;
86
 
  }
87
 
 
88
 
  if (plugin->plugin->init)
89
 
  {
90
 
    int r;
91
 
    if ((r= plugin->plugin->init((void *)&f)))
92
 
    {
93
 
      sql_print_error("Plugin '%s' init function returned error %d.",
94
 
                      plugin->name.str, r);
95
 
      return r;
96
 
    }
97
 
  }
98
 
  else
99
 
    return 1;
100
 
 
101
 
  if(!add_udf(f))
102
 
    return 2;
103
 
 
104
 
  return 0;
105
 
 
106
 
}
107
 
 
108
 
int finalize_udf(st_plugin_int *plugin)
109
 
{ 
110
 
  udf_func *udff = (udf_func *)plugin->data;
111
 
 
112
 
  /* TODO: Issue warning on failure */
113
 
  if (udff && plugin->plugin->deinit)
114
 
    (void)plugin->plugin->deinit(udff);
115
 
 
116
 
  if (udff)
117
 
    free(udff);
118
 
 
119
 
  return 0;
120
 
}
 
30
Function_builder *find_udf(const char *name, uint32_t length)
 
31
{
 
32
  return udf_registry.find(name, length);
 
33
}
 
34
 
 
35
void add_udf(Function_builder *udf)
 
36
{
 
37
  udf_registry.add(udf);
 
38
}
 
39
 
 
40
void remove_udf(Function_builder *udf)
 
41
{
 
42
  udf_registry.remove(udf);
 
43
}
 
44
 
121
45