← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/info_schema.cc

Renamed namespace slot to namespace service.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/info_schema.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 Sun Microsystems
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
 */
 
20
 
 
21
/**
 
22
 * @file 
 
23
 *   I_S plugin implementation.
 
24
 */
 
25
 
 
26
#include <drizzled/server_includes.h>
 
27
#include <drizzled/session.h>
 
28
#include <drizzled/show.h>
 
29
 
 
30
#include "info_schema_methods.h"
 
31
#include "info_schema_columns.h"
 
32
 
 
33
#include <vector>
 
34
 
 
35
using namespace drizzled;
 
36
using namespace std;
 
37
 
 
38
/*
 
39
 * Vectors of columns for various I_S tables.
 
40
 */
 
41
static vector<const plugin::ColumnInfo *> char_set_columns;
 
42
static vector<const plugin::ColumnInfo *> collation_columns;
 
43
static vector<const plugin::ColumnInfo *> coll_char_columns;
 
44
static vector<const plugin::ColumnInfo *> col_columns;
 
45
static vector<const plugin::ColumnInfo *> key_col_usage_columns;
 
46
static vector<const plugin::ColumnInfo *> open_tab_columns;
 
47
static vector<const plugin::ColumnInfo *> plugin_columns;
 
48
static vector<const plugin::ColumnInfo *> processlist_columns;
 
49
static vector<const plugin::ColumnInfo *> ref_constraint_columns;
 
50
static vector<const plugin::ColumnInfo *> schemata_columns;
 
51
static vector<const plugin::ColumnInfo *> stats_columns;
 
52
static vector<const plugin::ColumnInfo *> status_columns;
 
53
static vector<const plugin::ColumnInfo *> tab_constraints_columns;
 
54
static vector<const plugin::ColumnInfo *> tables_columns;
 
55
static vector<const plugin::ColumnInfo *> tab_names_columns;
 
56
 
 
57
/*
 
58
 * Methods for various I_S tables.
 
59
 */
 
60
static plugin::InfoSchemaMethods *char_set_methods= NULL;
 
61
static plugin::InfoSchemaMethods *collation_methods= NULL;
 
62
static plugin::InfoSchemaMethods *coll_char_methods= NULL;
 
63
static plugin::InfoSchemaMethods *columns_methods= NULL;
 
64
static plugin::InfoSchemaMethods *key_col_usage_methods= NULL;
 
65
static plugin::InfoSchemaMethods *open_tab_methods= NULL;
 
66
static plugin::InfoSchemaMethods *plugins_methods= NULL;
 
67
static plugin::InfoSchemaMethods *processlist_methods= NULL;
 
68
static plugin::InfoSchemaMethods *ref_constraint_methods= NULL;
 
69
static plugin::InfoSchemaMethods *schemata_methods= NULL;
 
70
static plugin::InfoSchemaMethods *stats_methods= NULL;
 
71
static plugin::InfoSchemaMethods *status_methods= NULL;
 
72
static plugin::InfoSchemaMethods *tab_constraints_methods= NULL;
 
73
static plugin::InfoSchemaMethods *tables_methods= NULL;
 
74
static plugin::InfoSchemaMethods *tab_names_methods= NULL;
 
75
static plugin::InfoSchemaMethods *variables_methods= NULL;
 
76
 
 
77
/*
 
78
 * I_S tables.
 
79
 */
 
80
static plugin::InfoSchemaTable *char_set_table= NULL;
 
81
static plugin::InfoSchemaTable *collation_table= NULL;
 
82
static plugin::InfoSchemaTable *coll_char_set_table= NULL;
 
83
static plugin::InfoSchemaTable *columns_table= NULL;
 
84
static plugin::InfoSchemaTable *key_col_usage_table= NULL;
 
85
static plugin::InfoSchemaTable *global_stat_table= NULL;
 
86
static plugin::InfoSchemaTable *global_var_table= NULL;
 
87
static plugin::InfoSchemaTable *open_tab_table= NULL;
 
88
static plugin::InfoSchemaTable *plugins_table= NULL;
 
89
static plugin::InfoSchemaTable *processlist_table= NULL;
 
90
static plugin::InfoSchemaTable *ref_constraint_table= NULL;
 
91
static plugin::InfoSchemaTable *schemata_table= NULL;
 
92
static plugin::InfoSchemaTable *sess_stat_table= NULL;
 
93
static plugin::InfoSchemaTable *sess_var_table= NULL;
 
94
static plugin::InfoSchemaTable *stats_table= NULL;
 
95
static plugin::InfoSchemaTable *status_table= NULL;
 
96
static plugin::InfoSchemaTable *tab_constraints_table= NULL;
 
97
static plugin::InfoSchemaTable *tables_table= NULL;
 
98
static plugin::InfoSchemaTable *tab_names_table= NULL;
 
99
static plugin::InfoSchemaTable *var_table= NULL;
 
100
 
 
101
/**
 
102
 * Populate the vectors of columns for each I_S table.
 
103
 *
 
104
 * @return false on success; true on failure.
 
105
 */
 
106
static bool initTableColumns()
 
107
{
 
108
  bool retval= false;
 
109
 
 
110
  if ((retval= createCharSetColumns(char_set_columns)) == true)
 
111
  {
 
112
    return true;
 
113
  }
 
114
 
 
115
  if ((retval= createCollationColumns(collation_columns)) == true)
 
116
  {
 
117
    return true;
 
118
  }
 
119
 
 
120
  if ((retval= createCollCharSetColumns(coll_char_columns)) == true)
 
121
  {
 
122
    return true;
 
123
  }
 
124
 
 
125
  if ((retval= createColColumns(col_columns)) == true)
 
126
  {
 
127
    return true;
 
128
  }
 
129
 
 
130
  if ((retval= createKeyColUsageColumns(key_col_usage_columns)) == true)
 
131
  {
 
132
    return true;
 
133
  }
 
134
 
 
135
  if ((retval= createOpenTabColumns(open_tab_columns)) == true)
 
136
  {
 
137
    return true;
 
138
  }
 
139
 
 
140
  if ((retval= createPluginsColumns(plugin_columns)) == true)
 
141
  {
 
142
    return true;
 
143
  }
 
144
 
 
145
  if ((retval= createProcessListColumns(processlist_columns)) == true)
 
146
  {
 
147
    return true;
 
148
  }
 
149
 
 
150
  if ((retval= createRefConstraintColumns(ref_constraint_columns)) == true)
 
151
  {
 
152
    return true;
 
153
  }
 
154
 
 
155
  if ((retval= createSchemataColumns(schemata_columns)) == true)
 
156
  {
 
157
    return true;
 
158
  }
 
159
 
 
160
  if ((retval= createStatsColumns(stats_columns)) == true)
 
161
  {
 
162
    return true;
 
163
  }
 
164
 
 
165
  if ((retval= createStatusColumns(status_columns)) == true)
 
166
  {
 
167
    return true;
 
168
  }
 
169
 
 
170
  if ((retval= createTabConstraintsColumns(tab_constraints_columns)) == true)
 
171
  {
 
172
    return true;
 
173
  }
 
174
 
 
175
  if ((retval= createTablesColumns(tables_columns)) == true)
 
176
  {
 
177
    return true;
 
178
  }
 
179
 
 
180
  if ((retval= createTabNamesColumns(tab_names_columns)) == true)
 
181
  {
 
182
    return true;
 
183
  }
 
184
 
 
185
  return false;
 
186
}
 
187
 
 
188
/**
 
189
 * Clear the vectors of columns for each I_S table.
 
190
 */
 
191
static void cleanupTableColumns()
 
192
{
 
193
  clearColumns(char_set_columns);
 
194
  clearColumns(collation_columns);
 
195
  clearColumns(coll_char_columns);
 
196
  clearColumns(col_columns);
 
197
  clearColumns(key_col_usage_columns);
 
198
  clearColumns(open_tab_columns);
 
199
  clearColumns(plugin_columns);
 
200
  clearColumns(processlist_columns);
 
201
  clearColumns(ref_constraint_columns);
 
202
  clearColumns(schemata_columns);
 
203
  clearColumns(stats_columns);
 
204
  clearColumns(status_columns);
 
205
  clearColumns(tab_constraints_columns);
 
206
  clearColumns(tables_columns);
 
207
  clearColumns(tab_names_columns);
 
208
}
 
209
 
 
210
/**
 
211
 * Initialize the methods for each I_S table.
 
212
 *
 
213
 * @return false on success; true on failure
 
214
 */
 
215
static bool initTableMethods()
 
216
{
 
217
  if ((char_set_methods= new(nothrow) CharSetISMethods()) == NULL)
 
218
  {
 
219
    return true;
 
220
  }
 
221
 
 
222
  if ((collation_methods= new(nothrow) CollationISMethods()) == NULL)
 
223
  {
 
224
    return true;
 
225
  }
 
226
 
 
227
  if ((coll_char_methods= new(nothrow) CollCharISMethods()) == NULL)
 
228
  {
 
229
    return true;
 
230
  }
 
231
 
 
232
  if ((columns_methods= new(nothrow) ColumnsISMethods()) == NULL)
 
233
  {
 
234
    return true;
 
235
  }
 
236
 
 
237
  if ((key_col_usage_methods= new(nothrow) KeyColUsageISMethods()) == NULL)
 
238
  {
 
239
    return true;
 
240
  }
 
241
 
 
242
  if ((open_tab_methods= new(nothrow) OpenTablesISMethods()) == NULL)
 
243
  {
 
244
    return true;
 
245
  }
 
246
 
 
247
  if ((plugins_methods= new(nothrow) PluginsISMethods()) == NULL)
 
248
  {
 
249
    return true;
 
250
  }
 
251
 
 
252
  if ((processlist_methods= new(nothrow) ProcessListISMethods()) == NULL)
 
253
  {
 
254
    return true;
 
255
  }
 
256
 
 
257
  if ((ref_constraint_methods= new(nothrow) RefConstraintsISMethods()) == NULL)
 
258
  {
 
259
    return true;
 
260
  }
 
261
 
 
262
  if ((schemata_methods= new(nothrow) SchemataISMethods()) == NULL)
 
263
  {
 
264
    return true;
 
265
  }
 
266
 
 
267
  if ((stats_methods= new(nothrow) StatsISMethods()) == NULL)
 
268
  {
 
269
    return true;
 
270
  }
 
271
 
 
272
  if ((status_methods= new(nothrow) StatusISMethods()) == NULL)
 
273
  {
 
274
    return true;
 
275
  }
 
276
 
 
277
  if ((tab_constraints_methods= new(nothrow) TabConstraintsISMethods()) == NULL)
 
278
  {
 
279
    return true;
 
280
  }
 
281
 
 
282
  if ((tables_methods= new(nothrow) TablesISMethods()) == NULL)
 
283
  {
 
284
    return true;
 
285
  }
 
286
 
 
287
  if ((tab_names_methods= new(nothrow) TabNamesISMethods()) == NULL)
 
288
  {
 
289
    return true;
 
290
  }
 
291
 
 
292
  if ((variables_methods= new(nothrow) VariablesISMethods()) == NULL)
 
293
  {
 
294
    return true;
 
295
  }
 
296
 
 
297
  return false;
 
298
}
 
299
 
 
300
/**
 
301
 * Delete memory allocated for the I_S table methods.
 
302
 */
 
303
static void cleanupTableMethods()
 
304
{
 
305
  delete char_set_methods;
 
306
  delete collation_methods;
 
307
  delete coll_char_methods;
 
308
  delete columns_methods;
 
309
  delete key_col_usage_methods;
 
310
  delete open_tab_methods;
 
311
  delete plugins_methods;
 
312
  delete processlist_methods;
 
313
  delete ref_constraint_methods;
 
314
  delete schemata_methods;
 
315
  delete stats_methods;
 
316
  delete status_methods;
 
317
  delete tab_constraints_methods;
 
318
  delete tables_methods;
 
319
  delete tab_names_methods;
 
320
  delete variables_methods;
 
321
}
 
322
 
 
323
/**
 
324
 * Initialize the I_S tables.
 
325
 *
 
326
 * @return false on success; true on failure
 
327
 */
 
328
static bool initTables()
 
329
{
 
330
 
 
331
  char_set_table= new(nothrow) plugin::InfoSchemaTable("CHARACTER_SETS",
 
332
                                                    char_set_columns,
 
333
                                                    -1, -1, false, false, 0,
 
334
                                                    char_set_methods);
 
335
  if (char_set_table == NULL)
 
336
  {
 
337
    return true;
 
338
  }
 
339
 
 
340
  collation_table= new(nothrow) plugin::InfoSchemaTable("COLLATIONS",
 
341
                                                     collation_columns,
 
342
                                                     -1, -1, false, false, 0,
 
343
                                                     collation_methods);
 
344
  if (collation_table == NULL)
 
345
  {
 
346
    return true;
 
347
  }
 
348
 
 
349
  coll_char_set_table= new(nothrow) plugin::InfoSchemaTable("COLLATION_CHARACTER_SET_APPLICABILITY",
 
350
                                                         coll_char_columns,
 
351
                                                         -1, -1, false, false, 0,
 
352
                                                         coll_char_methods);
 
353
  if (coll_char_set_table == NULL)
 
354
  {
 
355
    return true;
 
356
  }
 
357
 
 
358
  columns_table= new(nothrow) plugin::InfoSchemaTable("COLUMNS",
 
359
                                                   col_columns,
 
360
                                                   1, 2, false, true,
 
361
                                                   OPTIMIZE_I_S_TABLE,
 
362
                                                   columns_methods);
 
363
  if (columns_table == NULL)
 
364
  {
 
365
    return true;
 
366
  }
 
367
 
 
368
  key_col_usage_table= new(nothrow) plugin::InfoSchemaTable("KEY_COLUMN_USAGE",
 
369
                                                         key_col_usage_columns,
 
370
                                                         4, 5, false, true,
 
371
                                                         OPEN_TABLE_ONLY,
 
372
                                                         key_col_usage_methods);
 
373
  if (key_col_usage_table == NULL)
 
374
  {
 
375
    return true;
 
376
  }
 
377
 
 
378
  global_stat_table= new(nothrow) plugin::InfoSchemaTable("GLOBAL_STATUS",
 
379
                                                       status_columns,
 
380
                                                       -1, -1, false, false,
 
381
                                                       0, status_methods);
 
382
  if (global_stat_table == NULL)
 
383
  {
 
384
    return true;
 
385
  }
 
386
 
 
387
  global_var_table= new(nothrow) plugin::InfoSchemaTable("GLOBAL_VARIABLES",
 
388
                                                      status_columns,
 
389
                                                      -1, -1, false, false,
 
390
                                                      0, variables_methods);
 
391
  if (global_var_table == NULL)
 
392
  {
 
393
    return true;
 
394
  }
 
395
  
 
396
  open_tab_table= new(nothrow) plugin::InfoSchemaTable("OPEN_TABLES",
 
397
                                                    open_tab_columns,
 
398
                                                    -1, -1, true, false, 0,
 
399
                                                    open_tab_methods);
 
400
  if (open_tab_table == NULL)
 
401
  {
 
402
    return true;
 
403
  }
 
404
 
 
405
  plugins_table= new(nothrow) plugin::InfoSchemaTable("PLUGINS",
 
406
                                                   plugin_columns,
 
407
                                                   -1, -1, false, false, 0,
 
408
                                                   plugins_methods);
 
409
  if (plugins_table == NULL)
 
410
  {
 
411
    return true;
 
412
  }
 
413
 
 
414
  processlist_table= new(nothrow) plugin::InfoSchemaTable("PROCESSLIST",
 
415
                                                       processlist_columns,
 
416
                                                       -1, -1, false, false, 0,
 
417
                                                       processlist_methods);
 
418
  if (processlist_table == NULL)
 
419
  {
 
420
    return true;
 
421
  }
 
422
 
 
423
  ref_constraint_table= new(nothrow) plugin::InfoSchemaTable("REFERENTIAL_CONSTRAINTS",
 
424
                                                          ref_constraint_columns,
 
425
                                                          1, 9, false, true,
 
426
                                                          OPEN_TABLE_ONLY,
 
427
                                                          ref_constraint_methods);
 
428
  if (ref_constraint_table == NULL)
 
429
  {
 
430
    return true;
 
431
  }
 
432
 
 
433
  schemata_table= new(nothrow) plugin::InfoSchemaTable("SCHEMATA",
 
434
                                                    schemata_columns,
 
435
                                                    1, -1, false, false, 0,
 
436
                                                    schemata_methods);
 
437
  if (schemata_table == NULL)
 
438
  {
 
439
    return true;
 
440
  }
 
441
 
 
442
  sess_stat_table= new(nothrow) plugin::InfoSchemaTable("SESSION_STATUS",
 
443
                                                     status_columns,
 
444
                                                     -1, -1, false, false,
 
445
                                                     0, status_methods);
 
446
  if (sess_stat_table == NULL)
 
447
  {
 
448
    return true;
 
449
  }
 
450
 
 
451
  sess_var_table= new(nothrow) plugin::InfoSchemaTable("SESSION_VARIABLES",
 
452
                                                    status_columns,
 
453
                                                    -1, -1, false, false, 0,
 
454
                                                    variables_methods);
 
455
  if (sess_var_table == NULL)
 
456
  {
 
457
    return true;
 
458
  }
 
459
 
 
460
  stats_table= new(nothrow) plugin::InfoSchemaTable("STATISTICS",
 
461
                                                 stats_columns,
 
462
                                                 1, 2, false, true,
 
463
                                                 OPEN_TABLE_ONLY | OPTIMIZE_I_S_TABLE,
 
464
                                                 stats_methods);
 
465
  if (stats_table == NULL)
 
466
  {
 
467
    return true;
 
468
  }
 
469
 
 
470
  status_table= new(nothrow) plugin::InfoSchemaTable("STATUS",
 
471
                                                  status_columns,
 
472
                                                  -1, -1, true, false, 0,
 
473
                                                  status_methods);
 
474
  if (status_table == NULL)
 
475
  {
 
476
    return true;
 
477
  }
 
478
 
 
479
  tab_constraints_table= new(nothrow) plugin::InfoSchemaTable("TABLE_CONSTRAINTS",
 
480
                                                           tab_constraints_columns,
 
481
                                                           3, 4, false, true,
 
482
                                                           OPEN_TABLE_ONLY,
 
483
                                                           tab_constraints_methods);
 
484
  if (tab_constraints_table == NULL)
 
485
  {
 
486
    return true;
 
487
  }
 
488
 
 
489
  tables_table= new(nothrow) plugin::InfoSchemaTable("TABLES",
 
490
                                                  tables_columns,
 
491
                                                  1, 2, false, true,
 
492
                                                  OPTIMIZE_I_S_TABLE,
 
493
                                                  tables_methods);
 
494
  if (tables_table == NULL)
 
495
  {
 
496
    return true;
 
497
  }
 
498
 
 
499
  tab_names_table= new(nothrow) plugin::InfoSchemaTable("TABLE_NAMES",
 
500
                                                     tab_names_columns,
 
501
                                                     1, 2, true, true, 0,
 
502
                                                     tab_names_methods);
 
503
  if (tab_names_table == NULL)
 
504
  {
 
505
    return true;
 
506
  }
 
507
 
 
508
  var_table= new(nothrow) plugin::InfoSchemaTable("VARIABLES",
 
509
                                               status_columns,
 
510
                                               -1, -1, true, false, 0,
 
511
                                               variables_methods);
 
512
  if (var_table == NULL)
 
513
  {
 
514
    return true;
 
515
  }
 
516
 
 
517
  return false;
 
518
}
 
519
 
 
520
/**
 
521
 * Delete memory allocated for the I_S tables.
 
522
 */
 
523
static void cleanupTables()
 
524
{
 
525
  delete char_set_table;
 
526
  delete collation_table;
 
527
  delete coll_char_set_table;
 
528
  delete columns_table;
 
529
  delete key_col_usage_table;
 
530
  delete global_stat_table;
 
531
  delete global_var_table;
 
532
  delete open_tab_table;
 
533
  delete plugins_table;
 
534
  delete processlist_table;
 
535
  delete ref_constraint_table;
 
536
  delete schemata_table;
 
537
  delete sess_stat_table;
 
538
  delete sess_var_table;
 
539
  delete stats_table;
 
540
  delete status_table;
 
541
  delete tab_constraints_table;
 
542
  delete tables_table;
 
543
  delete tab_names_table;
 
544
  delete var_table;
 
545
}
 
546
 
 
547
/**
 
548
 * Initialize the I_S plugin.
 
549
 *
 
550
 * @param[in] registry the drizzled::plugin::Registry singleton
 
551
 * @return 0 on success; 1 on failure.
 
552
 */
 
553
static int infoSchemaInit(drizzled::plugin::Registry& registry)
 
554
{
 
555
  bool retval= false;
 
556
 
 
557
  if ((retval= initTableMethods()) == true)
 
558
  {
 
559
    return 1;
 
560
  }
 
561
 
 
562
  if ((retval= initTableColumns()) == true)
 
563
  {
 
564
    return 1;
 
565
  }
 
566
 
 
567
  if ((retval= initTables()) == true)
 
568
  {
 
569
    return 1;
 
570
  }
 
571
 
 
572
  registry.add(char_set_table);
 
573
  registry.add(collation_table);
 
574
  registry.add(coll_char_set_table);
 
575
  registry.add(columns_table);
 
576
  registry.add(key_col_usage_table);
 
577
  registry.add(global_stat_table);
 
578
  registry.add(global_var_table);
 
579
  registry.add(open_tab_table);
 
580
  registry.add(plugins_table);
 
581
  registry.add(processlist_table);
 
582
  registry.add(ref_constraint_table);
 
583
  registry.add(schemata_table);
 
584
  registry.add(sess_stat_table);
 
585
  registry.add(sess_var_table);
 
586
  registry.add(stats_table);
 
587
  registry.add(status_table);
 
588
  registry.add(tab_constraints_table);
 
589
  registry.add(tables_table);
 
590
  registry.add(tab_names_table);
 
591
  registry.add(var_table);
 
592
 
 
593
  return 0;
 
594
}
 
595
 
 
596
/**
 
597
 * Clean up the I_S plugin.
 
598
 *
 
599
 * @param[in] registry the drizzled::plugin::Registry singleton
 
600
 * @return 0 on success; 1 on failure
 
601
 */
 
602
static int infoSchemaDone(drizzled::plugin::Registry& registry)
 
603
{
 
604
  registry.remove(char_set_table);
 
605
  registry.remove(collation_table);
 
606
  registry.remove(coll_char_set_table);
 
607
  registry.remove(columns_table);
 
608
  registry.remove(key_col_usage_table);
 
609
  registry.remove(global_stat_table);
 
610
  registry.remove(global_var_table);
 
611
  registry.remove(open_tab_table);
 
612
  registry.remove(plugins_table);
 
613
  registry.remove(processlist_table);
 
614
  registry.remove(ref_constraint_table);
 
615
  registry.remove(schemata_table);
 
616
  registry.remove(sess_stat_table);
 
617
  registry.remove(sess_var_table);
 
618
  registry.remove(stats_table);
 
619
  registry.remove(status_table);
 
620
  registry.remove(tab_constraints_table);
 
621
  registry.remove(tables_table);
 
622
  registry.remove(tab_names_table);
 
623
  registry.remove(var_table);
 
624
 
 
625
  cleanupTableMethods();
 
626
  cleanupTableColumns();
 
627
  cleanupTables();
 
628
 
 
629
  return 0;
 
630
}
 
631
 
 
632
drizzle_declare_plugin(info_schema)
 
633
{
 
634
  "info_schema",
 
635
  "0.1",
 
636
  "Padraig O'Sullivan",
 
637
  "I_S plugin",
 
638
  PLUGIN_LICENSE_GPL,
 
639
  infoSchemaInit,
 
640
  infoSchemaDone,
 
641
  NULL,
 
642
  NULL,
 
643
  NULL
 
644
}
 
645
drizzle_declare_plugin_end;