← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/info_schema.cc

Merged in plugin-slot-reorg patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/info_schema.cc
32
32
 
33
33
#include <vector>
34
34
 
 
35
using namespace drizzled;
35
36
using namespace std;
36
37
 
37
38
/*
38
39
 * Vectors of columns for various I_S tables.
39
40
 */
40
 
static vector<const ColumnInfo *> char_set_columns;
41
 
static vector<const ColumnInfo *> collation_columns;
42
 
static vector<const ColumnInfo *> coll_char_columns;
43
 
static vector<const ColumnInfo *> col_columns;
44
 
static vector<const ColumnInfo *> key_col_usage_columns;
45
 
static vector<const ColumnInfo *> open_tab_columns;
46
 
static vector<const ColumnInfo *> plugin_columns;
47
 
static vector<const ColumnInfo *> processlist_columns;
48
 
static vector<const ColumnInfo *> ref_constraint_columns;
49
 
static vector<const ColumnInfo *> schemata_columns;
50
 
static vector<const ColumnInfo *> stats_columns;
51
 
static vector<const ColumnInfo *> status_columns;
52
 
static vector<const ColumnInfo *> tab_constraints_columns;
53
 
static vector<const ColumnInfo *> tables_columns;
54
 
static vector<const ColumnInfo *> tab_names_columns;
 
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;
55
56
 
56
57
/*
57
58
 * Methods for various I_S tables.
58
59
 */
59
 
static InfoSchemaMethods *char_set_methods= NULL;
60
 
static InfoSchemaMethods *collation_methods= NULL;
61
 
static InfoSchemaMethods *coll_char_methods= NULL;
62
 
static InfoSchemaMethods *columns_methods= NULL;
63
 
static InfoSchemaMethods *key_col_usage_methods= NULL;
64
 
static InfoSchemaMethods *open_tab_methods= NULL;
65
 
static InfoSchemaMethods *plugins_methods= NULL;
66
 
static InfoSchemaMethods *processlist_methods= NULL;
67
 
static InfoSchemaMethods *ref_constraint_methods= NULL;
68
 
static InfoSchemaMethods *schemata_methods= NULL;
69
 
static InfoSchemaMethods *stats_methods= NULL;
70
 
static InfoSchemaMethods *status_methods= NULL;
71
 
static InfoSchemaMethods *tab_constraints_methods= NULL;
72
 
static InfoSchemaMethods *tables_methods= NULL;
73
 
static InfoSchemaMethods *tab_names_methods= NULL;
74
 
static InfoSchemaMethods *variables_methods= NULL;
 
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;
75
76
 
76
77
/*
77
78
 * I_S tables.
78
79
 */
79
 
static InfoSchemaTable *char_set_table= NULL;
80
 
static InfoSchemaTable *collation_table= NULL;
81
 
static InfoSchemaTable *coll_char_set_table= NULL;
82
 
static InfoSchemaTable *columns_table= NULL;
83
 
static InfoSchemaTable *key_col_usage_table= NULL;
84
 
static InfoSchemaTable *global_stat_table= NULL;
85
 
static InfoSchemaTable *global_var_table= NULL;
86
 
static InfoSchemaTable *open_tab_table= NULL;
87
 
static InfoSchemaTable *plugins_table= NULL;
88
 
static InfoSchemaTable *processlist_table= NULL;
89
 
static InfoSchemaTable *ref_constraint_table= NULL;
90
 
static InfoSchemaTable *schemata_table= NULL;
91
 
static InfoSchemaTable *sess_stat_table= NULL;
92
 
static InfoSchemaTable *sess_var_table= NULL;
93
 
static InfoSchemaTable *stats_table= NULL;
94
 
static InfoSchemaTable *status_table= NULL;
95
 
static InfoSchemaTable *tab_constraints_table= NULL;
96
 
static InfoSchemaTable *tables_table= NULL;
97
 
static InfoSchemaTable *tab_names_table= NULL;
98
 
static InfoSchemaTable *var_table= NULL;
 
80
static plugin::InfoSchema *char_set_table= NULL;
 
81
static plugin::InfoSchema *collation_table= NULL;
 
82
static plugin::InfoSchema *coll_char_set_table= NULL;
 
83
static plugin::InfoSchema *columns_table= NULL;
 
84
static plugin::InfoSchema *key_col_usage_table= NULL;
 
85
static plugin::InfoSchema *global_stat_table= NULL;
 
86
static plugin::InfoSchema *global_var_table= NULL;
 
87
static plugin::InfoSchema *open_tab_table= NULL;
 
88
static plugin::InfoSchema *plugins_table= NULL;
 
89
static plugin::InfoSchema *processlist_table= NULL;
 
90
static plugin::InfoSchema *ref_constraint_table= NULL;
 
91
static plugin::InfoSchema *schemata_table= NULL;
 
92
static plugin::InfoSchema *sess_stat_table= NULL;
 
93
static plugin::InfoSchema *sess_var_table= NULL;
 
94
static plugin::InfoSchema *stats_table= NULL;
 
95
static plugin::InfoSchema *status_table= NULL;
 
96
static plugin::InfoSchema *tab_constraints_table= NULL;
 
97
static plugin::InfoSchema *tables_table= NULL;
 
98
static plugin::InfoSchema *tab_names_table= NULL;
 
99
static plugin::InfoSchema *var_table= NULL;
99
100
 
100
101
/**
101
102
 * Populate the vectors of columns for each I_S table.
213
214
 */
214
215
static bool initTableMethods()
215
216
{
216
 
  if ((char_set_methods= new(std::nothrow) CharSetISMethods()) == NULL)
217
 
  {
218
 
    return true;
219
 
  }
220
 
 
221
 
  if ((collation_methods= new(std::nothrow) CollationISMethods()) == NULL)
222
 
  {
223
 
    return true;
224
 
  }
225
 
 
226
 
  if ((coll_char_methods= new(std::nothrow) CollCharISMethods()) == NULL)
227
 
  {
228
 
    return true;
229
 
  }
230
 
 
231
 
  if ((columns_methods= new(std::nothrow) ColumnsISMethods()) == NULL)
232
 
  {
233
 
    return true;
234
 
  }
235
 
 
236
 
  if ((key_col_usage_methods= new(std::nothrow) KeyColUsageISMethods()) == NULL)
237
 
  {
238
 
    return true;
239
 
  }
240
 
 
241
 
  if ((open_tab_methods= new(std::nothrow) OpenTablesISMethods()) == NULL)
242
 
  {
243
 
    return true;
244
 
  }
245
 
 
246
 
  if ((plugins_methods= new(std::nothrow) PluginsISMethods()) == NULL)
247
 
  {
248
 
    return true;
249
 
  }
250
 
 
251
 
  if ((processlist_methods= new(std::nothrow) ProcessListISMethods()) == NULL)
252
 
  {
253
 
    return true;
254
 
  }
255
 
 
256
 
  if ((ref_constraint_methods= new(std::nothrow) RefConstraintsISMethods()) == NULL)
257
 
  {
258
 
    return true;
259
 
  }
260
 
 
261
 
  if ((schemata_methods= new(std::nothrow) SchemataISMethods()) == NULL)
262
 
  {
263
 
    return true;
264
 
  }
265
 
 
266
 
  if ((stats_methods= new(std::nothrow) StatsISMethods()) == NULL)
267
 
  {
268
 
    return true;
269
 
  }
270
 
 
271
 
  if ((status_methods= new(std::nothrow) StatusISMethods()) == NULL)
272
 
  {
273
 
    return true;
274
 
  }
275
 
 
276
 
  if ((tab_constraints_methods= new(std::nothrow) TabConstraintsISMethods()) == NULL)
277
 
  {
278
 
    return true;
279
 
  }
280
 
 
281
 
  if ((tables_methods= new(std::nothrow) TablesISMethods()) == NULL)
282
 
  {
283
 
    return true;
284
 
  }
285
 
 
286
 
  if ((tab_names_methods= new(std::nothrow) TabNamesISMethods()) == NULL)
287
 
  {
288
 
    return true;
289
 
  }
290
 
 
291
 
  if ((variables_methods= new(std::nothrow) VariablesISMethods()) == NULL)
 
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)
292
293
  {
293
294
    return true;
294
295
  }
327
328
static bool initTables()
328
329
{
329
330
 
330
 
  char_set_table= new(std::nothrow) InfoSchemaTable("CHARACTER_SETS",
 
331
  char_set_table= new(nothrow) plugin::InfoSchema("CHARACTER_SETS",
331
332
                                                    char_set_columns,
332
333
                                                    -1, -1, false, false, 0,
333
334
                                                    char_set_methods);
336
337
    return true;
337
338
  }
338
339
 
339
 
  collation_table= new(std::nothrow) InfoSchemaTable("COLLATIONS",
 
340
  collation_table= new(nothrow) plugin::InfoSchema("COLLATIONS",
340
341
                                                     collation_columns,
341
342
                                                     -1, -1, false, false, 0,
342
343
                                                     collation_methods);
345
346
    return true;
346
347
  }
347
348
 
348
 
  coll_char_set_table= new(std::nothrow) InfoSchemaTable("COLLATION_CHARACTER_SET_APPLICABILITY",
 
349
  coll_char_set_table= new(nothrow) plugin::InfoSchema("COLLATION_CHARACTER_SET_APPLICABILITY",
349
350
                                                         coll_char_columns,
350
351
                                                         -1, -1, false, false, 0,
351
352
                                                         coll_char_methods);
354
355
    return true;
355
356
  }
356
357
 
357
 
  columns_table= new(std::nothrow) InfoSchemaTable("COLUMNS",
 
358
  columns_table= new(nothrow) plugin::InfoSchema("COLUMNS",
358
359
                                                   col_columns,
359
360
                                                   1, 2, false, true,
360
361
                                                   OPTIMIZE_I_S_TABLE,
364
365
    return true;
365
366
  }
366
367
 
367
 
  key_col_usage_table= new(std::nothrow) InfoSchemaTable("KEY_COLUMN_USAGE",
 
368
  key_col_usage_table= new(nothrow) plugin::InfoSchema("KEY_COLUMN_USAGE",
368
369
                                                         key_col_usage_columns,
369
370
                                                         4, 5, false, true,
370
371
                                                         OPEN_TABLE_ONLY,
374
375
    return true;
375
376
  }
376
377
 
377
 
  global_stat_table= new(std::nothrow) InfoSchemaTable("GLOBAL_STATUS",
 
378
  global_stat_table= new(nothrow) plugin::InfoSchema("GLOBAL_STATUS",
378
379
                                                       status_columns,
379
380
                                                       -1, -1, false, false,
380
381
                                                       0, status_methods);
383
384
    return true;
384
385
  }
385
386
 
386
 
  global_var_table= new(std::nothrow) InfoSchemaTable("GLOBAL_VARIABLES",
 
387
  global_var_table= new(nothrow) plugin::InfoSchema("GLOBAL_VARIABLES",
387
388
                                                      status_columns,
388
389
                                                      -1, -1, false, false,
389
390
                                                      0, variables_methods);
392
393
    return true;
393
394
  }
394
395
  
395
 
  open_tab_table= new(std::nothrow) InfoSchemaTable("OPEN_TABLES",
 
396
  open_tab_table= new(nothrow) plugin::InfoSchema("OPEN_TABLES",
396
397
                                                    open_tab_columns,
397
398
                                                    -1, -1, true, false, 0,
398
399
                                                    open_tab_methods);
401
402
    return true;
402
403
  }
403
404
 
404
 
  plugins_table= new(std::nothrow) InfoSchemaTable("PLUGINS",
 
405
  plugins_table= new(nothrow) plugin::InfoSchema("PLUGINS",
405
406
                                                   plugin_columns,
406
407
                                                   -1, -1, false, false, 0,
407
408
                                                   plugins_methods);
410
411
    return true;
411
412
  }
412
413
 
413
 
  processlist_table= new(std::nothrow) InfoSchemaTable("PROCESSLIST",
 
414
  processlist_table= new(nothrow) plugin::InfoSchema("PROCESSLIST",
414
415
                                                       processlist_columns,
415
416
                                                       -1, -1, false, false, 0,
416
417
                                                       processlist_methods);
419
420
    return true;
420
421
  }
421
422
 
422
 
  ref_constraint_table= new(std::nothrow) InfoSchemaTable("REFERENTIAL_CONSTRAINTS",
 
423
  ref_constraint_table= new(nothrow) plugin::InfoSchema("REFERENTIAL_CONSTRAINTS",
423
424
                                                          ref_constraint_columns,
424
425
                                                          1, 9, false, true,
425
426
                                                          OPEN_TABLE_ONLY,
429
430
    return true;
430
431
  }
431
432
 
432
 
  schemata_table= new(std::nothrow) InfoSchemaTable("SCHEMATA",
 
433
  schemata_table= new(nothrow) plugin::InfoSchema("SCHEMATA",
433
434
                                                    schemata_columns,
434
435
                                                    1, -1, false, false, 0,
435
436
                                                    schemata_methods);
438
439
    return true;
439
440
  }
440
441
 
441
 
  sess_stat_table= new(std::nothrow) InfoSchemaTable("SESSION_STATUS",
 
442
  sess_stat_table= new(nothrow) plugin::InfoSchema("SESSION_STATUS",
442
443
                                                     status_columns,
443
444
                                                     -1, -1, false, false,
444
445
                                                     0, status_methods);
447
448
    return true;
448
449
  }
449
450
 
450
 
  sess_var_table= new(std::nothrow) InfoSchemaTable("SESSION_VARIABLES",
 
451
  sess_var_table= new(nothrow) plugin::InfoSchema("SESSION_VARIABLES",
451
452
                                                    status_columns,
452
453
                                                    -1, -1, false, false, 0,
453
454
                                                    variables_methods);
456
457
    return true;
457
458
  }
458
459
 
459
 
  stats_table= new(std::nothrow) InfoSchemaTable("STATISTICS",
 
460
  stats_table= new(nothrow) plugin::InfoSchema("STATISTICS",
460
461
                                                 stats_columns,
461
462
                                                 1, 2, false, true,
462
463
                                                 OPEN_TABLE_ONLY | OPTIMIZE_I_S_TABLE,
466
467
    return true;
467
468
  }
468
469
 
469
 
  status_table= new(std::nothrow) InfoSchemaTable("STATUS",
 
470
  status_table= new(nothrow) plugin::InfoSchema("STATUS",
470
471
                                                  status_columns,
471
472
                                                  -1, -1, true, false, 0,
472
473
                                                  status_methods);
475
476
    return true;
476
477
  }
477
478
 
478
 
  tab_constraints_table= new(std::nothrow) InfoSchemaTable("TABLE_CONSTRAINTS",
 
479
  tab_constraints_table= new(nothrow) plugin::InfoSchema("TABLE_CONSTRAINTS",
479
480
                                                           tab_constraints_columns,
480
481
                                                           3, 4, false, true,
481
482
                                                           OPEN_TABLE_ONLY,
485
486
    return true;
486
487
  }
487
488
 
488
 
  tables_table= new(std::nothrow) InfoSchemaTable("TABLES",
 
489
  tables_table= new(nothrow) plugin::InfoSchema("TABLES",
489
490
                                                  tables_columns,
490
491
                                                  1, 2, false, true,
491
492
                                                  OPTIMIZE_I_S_TABLE,
495
496
    return true;
496
497
  }
497
498
 
498
 
  tab_names_table= new(std::nothrow) InfoSchemaTable("TABLE_NAMES",
 
499
  tab_names_table= new(nothrow) plugin::InfoSchema("TABLE_NAMES",
499
500
                                                     tab_names_columns,
500
501
                                                     1, 2, true, true, 0,
501
502
                                                     tab_names_methods);
504
505
    return true;
505
506
  }
506
507
 
507
 
  var_table= new(std::nothrow) InfoSchemaTable("VARIABLES",
 
508
  var_table= new(nothrow) plugin::InfoSchema("VARIABLES",
508
509
                                               status_columns,
509
510
                                               -1, -1, true, false, 0,
510
511
                                               variables_methods);
568
569
    return 1;
569
570
  }
570
571
 
571
 
  registry.add(char_set_table);
572
 
  registry.add(collation_table);
573
 
  registry.add(coll_char_set_table);
574
 
  registry.add(columns_table);
575
 
  registry.add(key_col_usage_table);
576
 
  registry.add(global_stat_table);
577
 
  registry.add(global_var_table);
578
 
  registry.add(open_tab_table);
579
 
  registry.add(plugins_table);
580
 
  registry.add(processlist_table);
581
 
  registry.add(ref_constraint_table);
582
 
  registry.add(schemata_table);
583
 
  registry.add(sess_stat_table);
584
 
  registry.add(sess_var_table);
585
 
  registry.add(stats_table);
586
 
  registry.add(status_table);
587
 
  registry.add(tab_constraints_table);
588
 
  registry.add(tables_table);
589
 
  registry.add(tab_names_table);
590
 
  registry.add(var_table);
 
572
  registry.info_schema.add(char_set_table);
 
573
  registry.info_schema.add(collation_table);
 
574
  registry.info_schema.add(coll_char_set_table);
 
575
  registry.info_schema.add(columns_table);
 
576
  registry.info_schema.add(key_col_usage_table);
 
577
  registry.info_schema.add(global_stat_table);
 
578
  registry.info_schema.add(global_var_table);
 
579
  registry.info_schema.add(open_tab_table);
 
580
  registry.info_schema.add(plugins_table);
 
581
  registry.info_schema.add(processlist_table);
 
582
  registry.info_schema.add(ref_constraint_table);
 
583
  registry.info_schema.add(schemata_table);
 
584
  registry.info_schema.add(sess_stat_table);
 
585
  registry.info_schema.add(sess_var_table);
 
586
  registry.info_schema.add(stats_table);
 
587
  registry.info_schema.add(status_table);
 
588
  registry.info_schema.add(tab_constraints_table);
 
589
  registry.info_schema.add(tables_table);
 
590
  registry.info_schema.add(tab_names_table);
 
591
  registry.info_schema.add(var_table);
591
592
 
592
593
  return 0;
593
594
}
600
601
 */
601
602
static int infoSchemaDone(drizzled::plugin::Registry& registry)
602
603
{
603
 
  registry.remove(char_set_table);
604
 
  registry.remove(collation_table);
605
 
  registry.remove(coll_char_set_table);
606
 
  registry.remove(columns_table);
607
 
  registry.remove(key_col_usage_table);
608
 
  registry.remove(global_stat_table);
609
 
  registry.remove(global_var_table);
610
 
  registry.remove(open_tab_table);
611
 
  registry.remove(plugins_table);
612
 
  registry.remove(processlist_table);
613
 
  registry.remove(ref_constraint_table);
614
 
  registry.remove(schemata_table);
615
 
  registry.remove(sess_stat_table);
616
 
  registry.remove(sess_var_table);
617
 
  registry.remove(stats_table);
618
 
  registry.remove(status_table);
619
 
  registry.remove(tab_constraints_table);
620
 
  registry.remove(tables_table);
621
 
  registry.remove(tab_names_table);
622
 
  registry.remove(var_table);
 
604
  registry.info_schema.remove(char_set_table);
 
605
  registry.info_schema.remove(collation_table);
 
606
  registry.info_schema.remove(coll_char_set_table);
 
607
  registry.info_schema.remove(columns_table);
 
608
  registry.info_schema.remove(key_col_usage_table);
 
609
  registry.info_schema.remove(global_stat_table);
 
610
  registry.info_schema.remove(global_var_table);
 
611
  registry.info_schema.remove(open_tab_table);
 
612
  registry.info_schema.remove(plugins_table);
 
613
  registry.info_schema.remove(processlist_table);
 
614
  registry.info_schema.remove(ref_constraint_table);
 
615
  registry.info_schema.remove(schemata_table);
 
616
  registry.info_schema.remove(sess_stat_table);
 
617
  registry.info_schema.remove(sess_var_table);
 
618
  registry.info_schema.remove(stats_table);
 
619
  registry.info_schema.remove(status_table);
 
620
  registry.info_schema.remove(tab_constraints_table);
 
621
  registry.info_schema.remove(tables_table);
 
622
  registry.info_schema.remove(tab_names_table);
 
623
  registry.info_schema.remove(var_table);
623
624
 
624
625
  cleanupTableMethods();
625
626
  cleanupTableColumns();