← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/memcached_functions/memcached_functions.cc

  • Committer: Jay Pipes
  • Date: 2009-03-13 23:42:05 UTC
  • mto: This revision was merged to the branch mainline in revision 937.
  • Revision ID: jpipes@serialcoder-20090313234205-fmr8bd072nvfa28v
Forgot to add the new files...

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/memcached_functions/memcached_functions.cc
1
 
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 * Copyright (c) 2009, Patrick "CaptTofu" Galbraith, Padraig O'Sullivan
5
 
 * All rights reserved.
6
 
 *
7
 
 * Redistribution and use in source and binary forms, with or without
8
 
 * modification, are permitted provided that the following conditions are met:
9
 
 *
10
 
 *   * Redistributions of source code must retain the above copyright notice,
11
 
 *     this list of conditions and the following disclaimer.
12
 
 *   * Redistributions in binary form must reproduce the above copyright notice,
13
 
 *     this list of conditions and the following disclaimer in the documentation
14
 
 *     and/or other materials provided with the distribution.
15
 
 *   * Neither the name of Patrick Galbraith nor the names of its contributors
16
 
 *     may be used to endorse or promote products derived from this software
17
 
 *     without specific prior written permission.
18
 
 *
19
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20
 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23
 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24
 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25
 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26
 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27
 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28
 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
29
 
 * THE POSSIBILITY OF SUCH DAMAGE.
30
 
 */
31
 
 
32
 
#include "config.h"
33
 
#include <drizzled/function/str/strfunc.h>
34
 
#include <drizzled/plugin/function.h>
35
 
 
36
 
#include "memcached_functions.h"
37
 
#include "memc_servers_set.h"
38
 
#include "memc_behavior_set.h"
39
 
#include "memc_behavior_get.h"
40
 
#include "memc_stats.h"
41
 
#include "memc_get.h"
42
 
#include "memc_get_by_key.h"
43
 
#include "memc_set.h"
44
 
#include "memc_set_by_key.h"
45
 
#include "memc_add.h"
46
 
#include "memc_add_by_key.h"
47
 
#include "memc_replace.h"
48
 
#include "memc_replace_by_key.h"
49
 
#include "memc_delete.h"
50
 
#include "memc_delete_by_key.h"
51
 
#include "memc_append.h"
52
 
#include "memc_append_by_key.h"
53
 
#include "memc_prepend.h"
54
 
#include "memc_prepend_by_key.h"
55
 
#include "memc_cas.h"
56
 
#include "memc_cas_by_key.h"
57
 
#include "memc_increment.h"
58
 
#include "memc_decrement.h"
59
 
#include "memc_misc.h"
60
 
 
61
 
#include <libmemcached/memcached.h>
62
 
 
63
 
#include <string>
64
 
 
65
 
using namespace std;
66
 
using namespace drizzled;
67
 
 
68
 
/*
69
 
 * A global memcached data structure needed by
70
 
 * the various libmemcached API functions.
71
 
 */
72
 
memcached_st *memc= NULL;
73
 
 
74
 
/*
75
 
 * The memcached UDF's.
76
 
 */
77
 
plugin::Create_function<MemcachedServersSet> *memc_servers_set= NULL;
78
 
plugin::Create_function<MemcachedBehaviorSet> *memc_behavior_set= NULL;
79
 
plugin::Create_function<MemcachedBehaviorGet> *memc_behavior_get= NULL;
80
 
plugin::Create_function<MemcachedStats> *memc_stats= NULL;
81
 
plugin::Create_function<MemcachedGet> *memc_get= NULL;
82
 
plugin::Create_function<MemcachedGetByKey> *memc_get_by_key= NULL;
83
 
plugin::Create_function<MemcachedSet> *memc_set= NULL;
84
 
plugin::Create_function<MemcachedSetByKey> *memc_set_by_key= NULL;
85
 
plugin::Create_function<MemcachedAdd> *memc_add= NULL;
86
 
plugin::Create_function<MemcachedAddByKey> *memc_add_by_key= NULL;
87
 
plugin::Create_function<MemcachedReplace> *memc_replace= NULL;
88
 
plugin::Create_function<MemcachedReplaceByKey> *memc_replace_by_key= NULL;
89
 
plugin::Create_function<MemcachedIncrement> *memc_increment= NULL;
90
 
plugin::Create_function<MemcachedDecrement> *memc_decrement= NULL;
91
 
plugin::Create_function<MemcachedDelete> *memc_delete= NULL;
92
 
plugin::Create_function<MemcachedDeleteByKey> *memc_delete_by_key= NULL;
93
 
plugin::Create_function<MemcachedAppend> *memc_append= NULL;
94
 
plugin::Create_function<MemcachedAppendByKey> *memc_append_by_key= NULL;
95
 
plugin::Create_function<MemcachedPrepend> *memc_prepend= NULL;
96
 
plugin::Create_function<MemcachedPrependByKey> *memc_prepend_by_key= NULL;
97
 
plugin::Create_function<MemcachedCas> *memc_cas= NULL;
98
 
plugin::Create_function<MemcachedCasByKey> *memc_cas_by_key= NULL;
99
 
plugin::Create_function<MemcachedServerCount> *memc_serv_count= NULL;
100
 
plugin::Create_function<MemcachedVersion> *memc_version= NULL;
101
 
 
102
 
bool initMemcUDF()
103
 
{
104
 
  memc_servers_set= new plugin::Create_function<MemcachedServersSet>("memc_servers_set");
105
 
  if (memc_servers_set == NULL)
106
 
  {
107
 
    return true;
108
 
  }
109
 
 
110
 
  memc_behavior_set= new plugin::Create_function<MemcachedBehaviorSet>("memc_behavior_set");
111
 
  if (memc_behavior_set == NULL)
112
 
  {
113
 
    return true;
114
 
  }
115
 
 
116
 
  memc_behavior_get= new plugin::Create_function<MemcachedBehaviorGet>("memc_behavior_get");
117
 
  if (memc_behavior_get == NULL)
118
 
  {
119
 
    return true;
120
 
  }
121
 
 
122
 
  memc_stats= new plugin::Create_function<MemcachedStats>("memc_stats");
123
 
  if (memc_stats == NULL)
124
 
  {
125
 
    return true;
126
 
  }
127
 
 
128
 
  memc_get= new plugin::Create_function<MemcachedGet>("memc_get");
129
 
  if (memc_get == NULL)
130
 
  {
131
 
    return true;
132
 
  }
133
 
 
134
 
  memc_get_by_key= new plugin::Create_function<MemcachedGetByKey>("memc_get_by_key");
135
 
  if (memc_get_by_key == NULL)
136
 
  {
137
 
    return true;
138
 
  }
139
 
 
140
 
  memc_set= new plugin::Create_function<MemcachedSet>("memc_set");
141
 
  if (memc_set == NULL)
142
 
  {
143
 
    return true;
144
 
  }
145
 
  memc_set_by_key= new plugin::Create_function<MemcachedSetByKey>("memc_set_by_key");
146
 
  if (memc_set_by_key == NULL)
147
 
  {
148
 
    return true;
149
 
  }
150
 
 
151
 
  memc_add= new plugin::Create_function<MemcachedAdd>("memc_add");
152
 
  if (memc_add== NULL)
153
 
  {
154
 
    return true;
155
 
  }
156
 
 
157
 
  memc_add_by_key= new plugin::Create_function<MemcachedAddByKey>("memc_add_by_key");
158
 
  if (memc_add_by_key == NULL)
159
 
  {
160
 
    return true;
161
 
  }
162
 
 
163
 
  memc_replace= new plugin::Create_function<MemcachedReplace>("memc_replace");
164
 
  if (memc_replace== NULL)
165
 
  {
166
 
    return true;
167
 
  }
168
 
 
169
 
  memc_replace_by_key= new plugin::Create_function<MemcachedReplaceByKey>("memc_replace_by_key");
170
 
  if (memc_replace_by_key == NULL)
171
 
  {
172
 
    return true;
173
 
  }
174
 
 
175
 
  memc_delete= new plugin::Create_function<MemcachedDelete>("memc_delete");
176
 
  if (memc_delete == NULL)
177
 
  {
178
 
    return true;
179
 
  }
180
 
 
181
 
  memc_delete_by_key= new plugin::Create_function<MemcachedDeleteByKey>("memc_delete_by_key");
182
 
  if (memc_delete_by_key == NULL)
183
 
  {
184
 
    return true;
185
 
  }
186
 
 
187
 
  memc_append= new plugin::Create_function<MemcachedAppend>("memc_append");
188
 
  if (memc_append == NULL)
189
 
  {
190
 
    return true;
191
 
  }
192
 
 
193
 
  memc_append_by_key= new plugin::Create_function<MemcachedAppendByKey>("memc_append_by_key");
194
 
  if (memc_append_by_key == NULL)
195
 
  {
196
 
    return true;
197
 
  }
198
 
 
199
 
  memc_prepend= new plugin::Create_function<MemcachedPrepend>("memc_prepend");
200
 
  if (memc_prepend == NULL)
201
 
  {
202
 
    return true;
203
 
  }
204
 
 
205
 
  memc_prepend_by_key= new plugin::Create_function<MemcachedPrependByKey>("memc_prepend_by_key");
206
 
  if (memc_prepend_by_key == NULL)
207
 
  {
208
 
    return true;
209
 
  }
210
 
 
211
 
  memc_cas= new plugin::Create_function<MemcachedCas>("memc_cas");
212
 
  if (memc_cas == NULL)
213
 
  {
214
 
    return true;
215
 
  }
216
 
 
217
 
  memc_cas_by_key= new plugin::Create_function<MemcachedCasByKey>("memc_cas_by_key");
218
 
  if (memc_cas_by_key == NULL)
219
 
  {
220
 
    return true;
221
 
  }
222
 
 
223
 
  memc_serv_count= new plugin::Create_function<MemcachedServerCount>("memc_server_count");
224
 
  if (memc_serv_count == NULL)
225
 
  {
226
 
    return true;
227
 
  }
228
 
 
229
 
  memc_version= new plugin::Create_function<MemcachedVersion>("memc_libmemcached_version");
230
 
  if (memc_version == NULL)
231
 
  {
232
 
    return true;
233
 
  }
234
 
 
235
 
  memc_increment= new plugin::Create_function<MemcachedIncrement>("memc_increment");
236
 
  if (memc_increment == NULL)
237
 
  {
238
 
    return true;
239
 
  }
240
 
 
241
 
  memc_decrement= new plugin::Create_function<MemcachedDecrement>("memc_decrement");
242
 
  if (memc_decrement == NULL)
243
 
  {
244
 
    return true;
245
 
  }
246
 
 
247
 
  return false;
248
 
}
249
 
 
250
 
void cleanupMemcUDF()
251
 
{
252
 
  delete memc_servers_set;
253
 
  delete memc_behavior_set;
254
 
  delete memc_behavior_get;
255
 
  delete memc_stats;
256
 
  delete memc_get;
257
 
  delete memc_get_by_key;
258
 
  delete memc_set;
259
 
  delete memc_set_by_key;
260
 
  delete memc_add;
261
 
  delete memc_add_by_key;
262
 
  delete memc_replace;
263
 
  delete memc_replace_by_key;
264
 
  delete memc_delete;
265
 
  delete memc_delete_by_key;
266
 
  delete memc_append;
267
 
  delete memc_append_by_key;
268
 
  delete memc_prepend;
269
 
  delete memc_prepend_by_key;
270
 
  delete memc_cas;
271
 
  delete memc_cas_by_key;
272
 
  delete memc_serv_count;
273
 
  delete memc_version;
274
 
  delete memc_increment;
275
 
  delete memc_decrement;
276
 
}
277
 
 
278
 
static int memcachedInit(drizzled::plugin::Registry &registry)
279
 
{
280
 
  if (initMemcUDF())
281
 
  {
282
 
    return 1;
283
 
  }
284
 
 
285
 
  memc= memcached_create(NULL);
286
 
 
287
 
  registry.add(memc_servers_set);
288
 
  registry.add(memc_behavior_set);
289
 
  registry.add(memc_behavior_get);
290
 
  registry.add(memc_stats);
291
 
  registry.add(memc_get);
292
 
  registry.add(memc_get_by_key);
293
 
  registry.add(memc_set);
294
 
  registry.add(memc_set_by_key);
295
 
  registry.add(memc_add);
296
 
  registry.add(memc_add_by_key);
297
 
  registry.add(memc_replace);
298
 
  registry.add(memc_replace_by_key);
299
 
  registry.add(memc_delete);
300
 
  registry.add(memc_delete_by_key);
301
 
  registry.add(memc_append);
302
 
  registry.add(memc_append_by_key);
303
 
  registry.add(memc_prepend);
304
 
  registry.add(memc_prepend_by_key);
305
 
  registry.add(memc_cas);
306
 
  registry.add(memc_cas_by_key);
307
 
  registry.add(memc_serv_count);
308
 
  registry.add(memc_version);
309
 
  registry.add(memc_increment);
310
 
  registry.add(memc_decrement);
311
 
 
312
 
  return 0;
313
 
}
314
 
 
315
 
static int memcachedDone(drizzled::plugin::Registry &registry)
316
 
{
317
 
 
318
 
  memcached_free(memc);
319
 
 
320
 
  registry.remove(memc_servers_set);
321
 
  registry.remove(memc_behavior_set);
322
 
  registry.remove(memc_behavior_get);
323
 
  registry.remove(memc_stats);
324
 
  registry.remove(memc_get);
325
 
  registry.remove(memc_get_by_key);
326
 
  registry.remove(memc_set);
327
 
  registry.remove(memc_set_by_key);
328
 
  registry.remove(memc_add);
329
 
  registry.remove(memc_add_by_key);
330
 
  registry.remove(memc_replace);
331
 
  registry.remove(memc_replace_by_key);
332
 
  registry.remove(memc_delete);
333
 
  registry.remove(memc_delete_by_key);
334
 
  registry.remove(memc_append);
335
 
  registry.remove(memc_append_by_key);
336
 
  registry.remove(memc_prepend);
337
 
  registry.remove(memc_prepend_by_key);
338
 
  registry.remove(memc_cas);
339
 
  registry.remove(memc_cas_by_key);
340
 
  registry.remove(memc_serv_count);
341
 
  registry.remove(memc_version);
342
 
  registry.remove(memc_increment);
343
 
  registry.remove(memc_decrement);
344
 
 
345
 
  cleanupMemcUDF();
346
 
 
347
 
  return 0;
348
 
}
349
 
 
350
 
DRIZZLE_DECLARE_PLUGIN
351
 
{
352
 
  DRIZZLE_VERSION_ID,
353
 
  "memcached_functions",
354
 
  "0.1",
355
 
  "Patrick Galbraith, Ronald Bradford, Padraig O'Sullivan",
356
 
  "Memcached UDF Plugin",
357
 
  PLUGIN_LICENSE_GPL,
358
 
  memcachedInit,
359
 
  memcachedDone,
360
 
  NULL,
361
 
  NULL,
362
 
  NULL
363
 
}
364
 
DRIZZLE_DECLARE_PLUGIN_END;