« back to all changes in this revision
Viewing changes to plugin/info_schema/info_schema_columns.cc
- browse files at revision 1030.3.4
- compare with another revision
- compare with revision 1030.3.4
- download diff
- download tarball
- view history from revision 1030.3.4
- Committer: devananda
- Date: 2009-06-30 14:27:54 UTC
- mfrom: (1030.2.4 trunk)
- mto: (1093.1.7 captain)
- mto: This revision was merged to the branch mainline in revision 1095.
- Revision ID: devananda.vdv@gmail.com-20090630142754-vm9w374yxkf1pikc
merge from lp
- files added:
- drizzled/info_schema.h
- plugin/info_schema
- files removed:
- drizzled/protocol.cc
- tests/suite/bugs
- tests/suite/bugs/data
- tests/suite/bugs/r
- tests/suite/bugs/t
- tests/suite/csv
- tests/suite/csv/r
- tests/suite/csv/t
- tests/suite/manual
- tests/suite/manual/r
- tests/suite/manual/t
- files renamed:
- tests/suite/broken/t/csv.test => tests/t/csv.test
- files modified:
- client/drizzle.cc
added
removed
plugin/info_schema/info_schema_columns.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
* Contains methods for creating the various columns for
24
* each I_S table.
25
*/
26
27
#include <drizzled/server_includes.h>
28
#include <drizzled/session.h>
29
#include <drizzled/show.h>
30
31
#include "info_schema_columns.h"
32
33
#define LIST_PROCESS_HOST_LEN 64
34
35
using namespace std;
36
37
bool createCharSetColumns(vector<const ColumnInfo *>& cols)
38
{
39
/*
40
* Create each column for the CHARACTER_SET table.
41
*/
42
const ColumnInfo *name_col= new(std::nothrow) ColumnInfo("CHARACTER_SET_NAME",
43
64,
44
DRIZZLE_TYPE_VARCHAR,
45
0,
46
0,
47
"Charset",
48
SKIP_OPEN_TABLE);
49
if (name_col == NULL)
50
{
51
return true;
52
}
53
54
const ColumnInfo *collate_col= new(std::nothrow) ColumnInfo("DEFAULT_COLLATE_NAME",
55
64,
56
DRIZZLE_TYPE_VARCHAR,
57
0,
58
0,
59
"Default collation",
60
SKIP_OPEN_TABLE);
61
if (collate_col == NULL)
62
{
63
return true;
64
}
65
66
const ColumnInfo *descrip_col= new(std::nothrow) ColumnInfo("DESCRIPTION",
67
60,
68
DRIZZLE_TYPE_VARCHAR,
69
0,
70
0,
71
"Description",
72
SKIP_OPEN_TABLE);
73
if (descrip_col == NULL)
74
{
75
return true;
76
}
77
78
const ColumnInfo *len_col= new(std::nothrow) ColumnInfo("MAXLEN",
79
3,
80
DRIZZLE_TYPE_LONGLONG,
81
0,
82
0,
83
"Maxlen",
84
SKIP_OPEN_TABLE);
85
if (len_col == NULL)
86
{
87
return true;
88
}
89
90
/*
91
* Add the columns to the vector.
92
*/
93
cols.push_back(name_col);
94
cols.push_back(collate_col);
95
cols.push_back(descrip_col);
96
cols.push_back(len_col);
97
98
return false;
99
}
100
101
bool createCollationColumns(vector<const ColumnInfo *>& cols)
102
{
103
/*
104
* Create each column for the COLLATION table.
105
*/
106
const ColumnInfo *name_col= new(std::nothrow) ColumnInfo("COLLATION_NAME",
107
64,
108
DRIZZLE_TYPE_VARCHAR,
109
0,
110
0,
111
"Collation",
112
SKIP_OPEN_TABLE);
113
if (name_col == NULL)
114
{
115
return true;
116
}
117
118
const ColumnInfo *char_set_col= new(std::nothrow) ColumnInfo("CHARACTER_SET_NAME",
119
64,
120
DRIZZLE_TYPE_VARCHAR,
121
0,
122
0,
123
"Default collation",
124
SKIP_OPEN_TABLE);
125
if (char_set_col == NULL)
126
{
127
return true;
128
}
129
130
const ColumnInfo *descrip_col= new(std::nothrow) ColumnInfo("DESCRIPTION",
131
60,
132
DRIZZLE_TYPE_VARCHAR,
133
0,
134
0,
135
"Charset",
136
SKIP_OPEN_TABLE);
137
if (descrip_col == NULL)
138
{
139
return true;
140
}
141
142
const ColumnInfo *id_col= new(std::nothrow) ColumnInfo("ID",
143
MY_INT32_NUM_DECIMAL_DIGITS,
144
DRIZZLE_TYPE_LONGLONG,
145
0,
146
0,
147
"Id",
148
SKIP_OPEN_TABLE);
149
if (id_col == NULL)
150
{
151
return true;
152
}
153
154
const ColumnInfo *default_col= new(std::nothrow) ColumnInfo("IS_DEFAULT",
155
3,
156
DRIZZLE_TYPE_VARCHAR,
157
0,
158
0,
159
"Default",
160
SKIP_OPEN_TABLE);
161
if (default_col == NULL)
162
{
163
return true;
164
}
165
166
const ColumnInfo *compiled_col= new(std::nothrow) ColumnInfo("IS_COMPILED",
167
3,
168
DRIZZLE_TYPE_VARCHAR,
169
0,
170
0,
171
"Compiled",
172
SKIP_OPEN_TABLE);
173
if (compiled_col == NULL)
174
{
175
return true;
176
}
177
178
const ColumnInfo *sortlen_col= new(std::nothrow) ColumnInfo("SORTLEN",
179
3,
180
DRIZZLE_TYPE_LONGLONG,
181
0,
182
0,
183
"Sortlen",
184
SKIP_OPEN_TABLE);
185
if (sortlen_col == NULL)
186
{
187
return true;
188
}
189
190
/*
191
* Add the columns to the vector.
192
*/
193
cols.push_back(name_col);
194
cols.push_back(char_set_col);
195
cols.push_back(descrip_col);
196
cols.push_back(id_col);
197
cols.push_back(default_col);
198
cols.push_back(compiled_col);
199
cols.push_back(sortlen_col);
200
201
return false;
202
}
203
204
bool createCollCharSetColumns(vector<const ColumnInfo *>& cols)
205
{
206
/*
207
* Create each column for the table.
208
*/
209
const ColumnInfo *name_col= new(std::nothrow) ColumnInfo("COLLATION_NAME",
210
64,
211
DRIZZLE_TYPE_VARCHAR,
212
0,
213
0,
214
"",
215
SKIP_OPEN_TABLE);
216
if (name_col == NULL)
217
{
218
return true;
219
}
220
221
const ColumnInfo *char_set_col= new(std::nothrow) ColumnInfo("CHARACTER_SET_NAME",
222
64,
223
DRIZZLE_TYPE_VARCHAR,
224
0,
225
0,
226
"",
227
SKIP_OPEN_TABLE);
228
if (char_set_col == NULL)
229
{
230
return true;
231
}
232
233
/*
234
* Add the columns to the vector.
235
*/
236
cols.push_back(name_col);
237
cols.push_back(char_set_col);
238
239
return false;
240
}
241
242
bool createKeyColUsageColumns(vector<const ColumnInfo *>& cols)
243
{
244
const ColumnInfo *cat= new(std::nothrow) ColumnInfo("CONSTRAINT_CATALOG",
245
FN_REFLEN,
246
DRIZZLE_TYPE_VARCHAR,
247
0,
248
1,
249
"",
250
OPEN_FULL_TABLE);
251
if (cat == NULL)
252
{
253
return true;
254
}
255
256
const ColumnInfo *sch= new(std::nothrow) ColumnInfo("CONSTRAINT_SCHEMA",
257
NAME_CHAR_LEN,
258
DRIZZLE_TYPE_VARCHAR,
259
0,
260
0,
261
"",
262
OPEN_FULL_TABLE);
263
if (sch == NULL)
264
{
265
return true;
266
}
267
268
const ColumnInfo *name= new(std::nothrow) ColumnInfo("CONSTRAINT_NAME",
269
NAME_CHAR_LEN,
270
DRIZZLE_TYPE_VARCHAR,
271
0,
272
0,
273
"",
274
OPEN_FULL_TABLE);
275
if (name == NULL)
276
{
277
return true;
278
}
279
280
const ColumnInfo *tab_cat= new(std::nothrow) ColumnInfo("TABLE_CATALOG",
281
FN_REFLEN,
282
DRIZZLE_TYPE_VARCHAR,
283
0,
284
1,
285
"",
286
OPEN_FULL_TABLE);
287
if (tab_cat == NULL)
288
{
289
return true;
290
}
291
292
const ColumnInfo *tab_sch= new(std::nothrow) ColumnInfo("TABLE_SCHEMA",
293
NAME_CHAR_LEN,
294
DRIZZLE_TYPE_VARCHAR,
295
0,
296
0,
297
"",
298
OPEN_FULL_TABLE);
299
if (tab_sch == NULL)
300
{
301
return true;
302
}
303
304
const ColumnInfo *tab_name= new(std::nothrow) ColumnInfo("TABLE_NAME",
305
NAME_CHAR_LEN,
306
DRIZZLE_TYPE_VARCHAR,
307
0,
308
0,
309
"",
310
OPEN_FULL_TABLE);
311
if (tab_name == NULL)
312
{
313
return true;
314
}
315
316
const ColumnInfo *col_name= new(std::nothrow) ColumnInfo("COLUMN_NAME",
317
NAME_CHAR_LEN,
318
DRIZZLE_TYPE_VARCHAR,
319
0,
320
0,
321
"",
322
OPEN_FULL_TABLE);
323
if (col_name == NULL)
324
{
325
return true;
326
}
327
const ColumnInfo *ord_pos= new(std::nothrow) ColumnInfo("ORDINAL_POSITION",
328
10,
329
DRIZZLE_TYPE_LONGLONG,
330
0,
331
0,
332
"",
333
OPEN_FULL_TABLE);
334
if (ord_pos == NULL)
335
{
336
return true;
337
}
338
339
const ColumnInfo *pos_in_uniq= new(std::nothrow) ColumnInfo("POSITION_IN_UNIQUE_CONSTRAINT",
340
10,
341
DRIZZLE_TYPE_LONGLONG,
342
0,
343
1,
344
"",
345
OPEN_FULL_TABLE);
346
if (pos_in_uniq == NULL)
347
{
348
return true;
349
}
350
351
const ColumnInfo *ref_tab_sch= new(std::nothrow) ColumnInfo("REFERENCED_TABLE_SCHEMA",
352
NAME_CHAR_LEN,
353
DRIZZLE_TYPE_VARCHAR,
354
0,
355
1,
356
"",
357
OPEN_FULL_TABLE);
358
if (ref_tab_sch == NULL)
359
{
360
return true;
361
}
362
363
const ColumnInfo *ref_tab_name= new(std::nothrow) ColumnInfo("REFERENCED_TABLE_NAME",
364
NAME_CHAR_LEN,
365
DRIZZLE_TYPE_VARCHAR,
366
0,
367
1,
368
"",
369
OPEN_FULL_TABLE);
370
if (ref_tab_name == NULL)
371
{
372
return true;
373
}
374
375
const ColumnInfo *ref_col_name= new(std::nothrow) ColumnInfo("REFERENCED_COLUMN_NAME",
376
NAME_CHAR_LEN,
377
DRIZZLE_TYPE_VARCHAR,
378
0,
379
1,
380
"",
381
OPEN_FULL_TABLE);
382
if (ref_col_name == NULL)
383
{
384
return true;
385
}
386
387
cols.push_back(cat);
388
cols.push_back(sch);
389
cols.push_back(name);
390
cols.push_back(tab_cat);
391
cols.push_back(tab_sch);
392
cols.push_back(tab_name);
393
cols.push_back(col_name);
394
cols.push_back(ord_pos);
395
cols.push_back(pos_in_uniq);
396
cols.push_back(ref_tab_sch);
397
cols.push_back(ref_tab_name);
398
cols.push_back(ref_col_name);
399
400
return false;
401
}
402
403
bool createPluginsColumns(vector<const ColumnInfo *>& cols)
404
{
405
const ColumnInfo *name= new(std::nothrow) ColumnInfo("PLUGIN_NAME",
406
NAME_CHAR_LEN,
407
DRIZZLE_TYPE_VARCHAR,
408
0,
409
0,
410
"Name",
411
SKIP_OPEN_TABLE);
412
if (name == NULL)
413
{
414
return true;
415
}
416
417
const ColumnInfo *ver= new(std::nothrow) ColumnInfo("PLUGIN_VERSION",
418
20,
419
DRIZZLE_TYPE_VARCHAR,
420
0,
421
0,
422
"",
423
SKIP_OPEN_TABLE);
424
if (ver == NULL)
425
{
426
return true;
427
}
428
429
const ColumnInfo *stat= new(std::nothrow) ColumnInfo("PLUGIN_STATUS",
430
10,
431
DRIZZLE_TYPE_VARCHAR,
432
0,
433
0,
434
"Status",
435
SKIP_OPEN_TABLE);
436
if (stat == NULL)
437
{
438
return true;
439
}
440
441
const ColumnInfo *aut= new(std::nothrow) ColumnInfo("PLUGIN_AUTHOR",
442
NAME_CHAR_LEN,
443
DRIZZLE_TYPE_VARCHAR,
444
0,
445
1,
446
"",
447
SKIP_OPEN_TABLE);
448
if (aut == NULL)
449
{
450
return true;
451
}
452
453
const ColumnInfo *descrip= new(std::nothrow) ColumnInfo("PLUGIN_DESCRIPTION",
454
65535,
455
DRIZZLE_TYPE_VARCHAR,
456
0,
457
1,
458
"",
459
SKIP_OPEN_TABLE);
460
if (descrip == NULL)
461
{
462
return true;
463
}
464
465
const ColumnInfo *lic= new(std::nothrow) ColumnInfo("PLUGIN_LICENSE",
466
80,
467
DRIZZLE_TYPE_VARCHAR,
468
0,
469
1,
470
"License",
471
SKIP_OPEN_TABLE);
472
if (lic == NULL)
473
{
474
return true;
475
}
476
477
cols.push_back(name);
478
cols.push_back(ver);
479
cols.push_back(stat);
480
cols.push_back(aut);
481
cols.push_back(descrip);
482
cols.push_back(lic);
483
484
return false;
485
}
486
487
bool createProcessListColumns(vector<const ColumnInfo *>& cols)
488
{
489
/*
490
* Create each column for the PROCESSLIST table.
491
*/
492
const ColumnInfo *id_col= new(std::nothrow) ColumnInfo("ID",
493
4,
494
DRIZZLE_TYPE_LONGLONG,
495
0,
496
0,
497
"Id",
498
SKIP_OPEN_TABLE);
499
if (id_col == NULL)
500
{
501
return true;
502
}
503
504
const ColumnInfo *user_col= new(std::nothrow) ColumnInfo("USER",
505
16,
506
DRIZZLE_TYPE_VARCHAR,
507
0,
508
0,
509
"User",
510
SKIP_OPEN_TABLE);
511
if (user_col == NULL)
512
{
513
return true;
514
}
515
516
const ColumnInfo *host_col= new(std::nothrow) ColumnInfo("HOST",
517
LIST_PROCESS_HOST_LEN,
518
DRIZZLE_TYPE_VARCHAR,
519
0,
520
0,
521
"Host",
522
SKIP_OPEN_TABLE);
523
if (host_col == NULL)
524
{
525
return true;
526
}
527
528
const ColumnInfo *db_col= new(std::nothrow) ColumnInfo("DB",
529
NAME_CHAR_LEN,
530
DRIZZLE_TYPE_VARCHAR,
531
0,
532
1,
533
"Db",
534
SKIP_OPEN_TABLE);
535
if (db_col == NULL)
536
{
537
return true;
538
}
539
540
const ColumnInfo *command_col= new(std::nothrow) ColumnInfo("COMMAND",
541
16,
542
DRIZZLE_TYPE_VARCHAR,
543
0,
544
0,
545
"Command",
546
SKIP_OPEN_TABLE);
547
if (command_col == NULL)
548
{
549
return true;
550
}
551
552
const ColumnInfo *time_col= new(std::nothrow) ColumnInfo("TIME",
553
7,
554
DRIZZLE_TYPE_LONGLONG,
555
0,
556
0,
557
"Time",
558
SKIP_OPEN_TABLE);
559
if (time_col == NULL)
560
{
561
return true;
562
}
563
564
const ColumnInfo *state_col= new(std::nothrow) ColumnInfo("STATE",
565
64,
566
DRIZZLE_TYPE_VARCHAR,
567
0,
568
1,
569
"State",
570
SKIP_OPEN_TABLE);
571
if (state_col == NULL)
572
{
573
return true;
574
}
575
576
const ColumnInfo *info_col= new(std::nothrow) ColumnInfo("INFO",
577
PROCESS_LIST_INFO_WIDTH,
578
DRIZZLE_TYPE_VARCHAR,
579
0,
580
1,
581
"Info",
582
SKIP_OPEN_TABLE);
583
if (info_col == NULL)
584
{
585
return true;
586
}
587
588
/*
589
* Add the columns to the vector.
590
*/
591
cols.push_back(id_col);
592
cols.push_back(user_col);
593
cols.push_back(host_col);
594
cols.push_back(db_col);
595
cols.push_back(command_col);
596
cols.push_back(time_col);
597
cols.push_back(state_col);
598
cols.push_back(info_col);
599
600
return false;
601
}
602
603
bool createRefConstraintColumns(vector<const ColumnInfo *>& cols)
604
{
605
/*
606
* Create the columns for the table.
607
*/
608
const ColumnInfo *cat= new(std::nothrow) ColumnInfo("CONSTRAINT_CATALOG",
609
FN_REFLEN,
610
DRIZZLE_TYPE_VARCHAR,
611
0,
612
1,
613
"",
614
OPEN_FULL_TABLE);
615
616
if (cat == NULL)
617
{
618
return true;
619
}
620
621
const ColumnInfo *sch= new(std::nothrow) ColumnInfo("CONSTRAINT_SCHEMA",
622
NAME_CHAR_LEN,
623
DRIZZLE_TYPE_VARCHAR,
624
0,
625
0,
626
"",
627
OPEN_FULL_TABLE);
628
if (sch == NULL)
629
{
630
return true;
631
}
632
633
const ColumnInfo *name= new(std::nothrow) ColumnInfo("CONSTRAINT_NAME",
634
NAME_CHAR_LEN,
635
DRIZZLE_TYPE_VARCHAR,
636
0,
637
0,
638
"",
639
OPEN_FULL_TABLE);
640
if (name == NULL)
641
{
642
return true;
643
}
644
645
const ColumnInfo *uniq_cat= new(std::nothrow) ColumnInfo("UNIQUE_CONSTRAINT_CATALOG",
646
FN_REFLEN,
647
DRIZZLE_TYPE_VARCHAR,
648
0,
649
1,
650
"",
651
OPEN_FULL_TABLE);
652
if (uniq_cat == NULL)
653
{
654
return true;
655
}
656
657
const ColumnInfo *uniq_sch= new(std::nothrow) ColumnInfo("UNIQUE_CONSTRAINT_SCHEMA",
658
NAME_CHAR_LEN,
659
DRIZZLE_TYPE_VARCHAR,
660
0,
661
0,
662
"",
663
OPEN_FULL_TABLE);
664
if (uniq_sch == NULL)
665
{
666
return true;
667
}
668
669
const ColumnInfo *uniq_name= new(std::nothrow) ColumnInfo("UNIQUE_CONSTRAINT_NAME",
670
NAME_CHAR_LEN,
671
DRIZZLE_TYPE_VARCHAR,
672
0,
673
MY_I_S_MAYBE_NULL,
674
"",
675
OPEN_FULL_TABLE);
676
if (uniq_name == NULL)
677
{
678
return true;
679
}
680
681
const ColumnInfo *match= new(std::nothrow) ColumnInfo("MATCH_OPTION",
682
NAME_CHAR_LEN,
683
DRIZZLE_TYPE_VARCHAR,
684
0,
685
0,
686
"",
687
OPEN_FULL_TABLE);
688
if (match == NULL)
689
{
690
return true;
691
}
692
693
const ColumnInfo *update= new(std::nothrow) ColumnInfo("UPDATE_RULE",
694
NAME_CHAR_LEN,
695
DRIZZLE_TYPE_VARCHAR,
696
0,
697
0,
698
"",
699
OPEN_FULL_TABLE);
700
if (update == NULL)
701
{
702
return true;
703
}
704
705
const ColumnInfo *del_rule= new(std::nothrow) ColumnInfo("DELETE_RULE",
706
NAME_CHAR_LEN,
707
DRIZZLE_TYPE_VARCHAR,
708
0,
709
0,
710
"",
711
OPEN_FULL_TABLE);
712
if (del_rule == NULL)
713
{
714
return true;
715
}
716
717
const ColumnInfo *tab_name= new(std::nothrow) ColumnInfo("TABLE_NAME",
718
NAME_CHAR_LEN,
719
DRIZZLE_TYPE_VARCHAR,
720
0,
721
0,
722
"",
723
OPEN_FULL_TABLE);
724
if (tab_name == NULL)
725
{
726
return true;
727
}
728
729
const ColumnInfo *ref_name= new(std::nothrow) ColumnInfo("REFERENCED_TABLE_NAME",
730
NAME_CHAR_LEN,
731
DRIZZLE_TYPE_VARCHAR,
732
0,
733
0,
734
"",
735
OPEN_FULL_TABLE);
736
if (ref_name == NULL)
737
{
738
return true;
739
}
740
741
/*
742
* Add the columns to the vector.
743
*/
744
cols.push_back(cat);
745
cols.push_back(sch);
746
cols.push_back(name);
747
cols.push_back(uniq_cat);
748
cols.push_back(uniq_sch);
749
cols.push_back(uniq_name);
750
cols.push_back(match);
751
cols.push_back(update);
752
cols.push_back(del_rule);
753
cols.push_back(tab_name);
754
cols.push_back(ref_name);
755
756
return false;
757
}
758
759
bool createTabConstraintsColumns(vector<const ColumnInfo *>& cols)
760
{
761
const ColumnInfo *cat= new(std::nothrow) ColumnInfo("CONSTRAINT_CATALOG",
762
FN_REFLEN,
763
DRIZZLE_TYPE_VARCHAR,
764
0,
765
1,
766
"",
767
OPEN_FULL_TABLE);
768
if (cat == NULL)
769
{
770
return true;
771
}
772
773
const ColumnInfo *sch= new(std::nothrow) ColumnInfo("CONSTRAINT_SCHEMA",
774
NAME_CHAR_LEN,
775
DRIZZLE_TYPE_VARCHAR,
776
0,
777
0,
778
"",
779
OPEN_FULL_TABLE);
780
if (sch == NULL)
781
{
782
return true;
783
}
784
785
const ColumnInfo *name= new(std::nothrow) ColumnInfo("CONSTRAINT_NAME",
786
NAME_CHAR_LEN,
787
DRIZZLE_TYPE_VARCHAR,
788
0,
789
0,
790
"",
791
OPEN_FULL_TABLE);
792
if (name == NULL)
793
{
794
return true;
795
}
796
797
const ColumnInfo *tab_sch= new(std::nothrow) ColumnInfo("TABLE_SCHEMA",
798
NAME_CHAR_LEN,
799
DRIZZLE_TYPE_VARCHAR,
800
0,
801
0,
802
"",
803
OPEN_FULL_TABLE);
804
if (tab_sch == NULL)
805
{
806
return true;
807
}
808
809
const ColumnInfo *tab_name= new(std::nothrow) ColumnInfo("TABLE_NAME",
810
NAME_CHAR_LEN,
811
DRIZZLE_TYPE_VARCHAR,
812
0,
813
0,
814
"",
815
OPEN_FULL_TABLE);
816
if (tab_name == NULL)
817
{
818
return true;
819
}
820
821
const ColumnInfo *type= new(std::nothrow) ColumnInfo("CONSTRAINT_TYPE",
822
NAME_CHAR_LEN,
823
DRIZZLE_TYPE_VARCHAR,
824
0,
825
0,
826
"",
827
OPEN_FULL_TABLE);
828
if (type == NULL)
829
{
830
return true;
831
}
832
833
cols.push_back(cat);
834
cols.push_back(sch);
835
cols.push_back(name);
836
cols.push_back(tab_sch);
837
cols.push_back(tab_name);
838
cols.push_back(type);
839
840
return false;
841
}
842
843
/*
844
* Function object used for deleting the memory allocated
845
* for the columns contained with the vector of columns.
846
*/
847
class DeleteColumns
848
{
849
public:
850
template<typename T>
851
inline void operator()(const T *ptr) const
852
{
853
delete ptr;
854
}
855
};
856
857
void clearColumns(vector<const ColumnInfo *>& cols)
858
{
859
for_each(cols.begin(), cols.end(), DeleteColumns());
860
cols.clear();
861
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1