← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/info_schema_table.h

Merged in changes. 
Edited a the comment test case so deal with our version bump.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/info_schema_table.h
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
 
#ifndef DRIZZLED_PLUGIN_INFO_SCHEMA_TABLE_H
22
 
#define DRIZZLED_PLUGIN_INFO_SCHEMA_TABLE_H
23
 
 
24
 
#include "drizzled/plugin/plugin.h"
25
 
#include "drizzled/hash/crc32.h"
26
 
#include "drizzled/common.h"
27
 
 
28
 
#include <cstring>
29
 
#include <string>
30
 
#include <set>
31
 
#include <algorithm>
32
 
 
33
 
class Session;
34
 
class TableList;
35
 
class Table;
36
 
 
37
 
typedef struct drizzle_lex_string LEX_STRING;
38
 
 
39
 
extern const std::string INFORMATION_SCHEMA_NAME;
40
 
 
41
 
namespace drizzled
42
 
{
43
 
namespace plugin
44
 
{
45
 
 
46
 
/**
47
 
 * @file
48
 
 *   info_schema.h
49
 
 * @brief 
50
 
 *   Header file which contains all classes related to I_S
51
 
 */
52
 
 
53
 
typedef class Item COND;
54
 
class InfoSchemaTable;
55
 
 
56
 
 
57
 
/**
58
 
 * @class ColumnInfo
59
 
 * @brief
60
 
 *   Represents a field (column) in an I_S table.
61
 
 */
62
 
class ColumnInfo 
63
 
{ 
64
 
public: 
65
 
  ColumnInfo(const std::string& in_name, 
66
 
             uint32_t in_length, 
67
 
             enum enum_field_types in_type,
68
 
             int32_t in_value,
69
 
             uint32_t in_flags,
70
 
             const std::string& in_old_name)
71
 
    :
72
 
      name(in_name),
73
 
      length(in_length),
74
 
      type(in_type),
75
 
      value(in_value),
76
 
      flags(in_flags),
77
 
      old_name(in_old_name)
78
 
  {}
79
 
 
80
 
  ColumnInfo()
81
 
    :
82
 
      name(),
83
 
      length(0),
84
 
      type(DRIZZLE_TYPE_VARCHAR),
85
 
      flags(0),
86
 
      old_name()
87
 
  {}
88
 
 
89
 
  /**
90
 
   * @return the name of this column.
91
 
   */
92
 
  const std::string &getName() const
93
 
  {
94
 
    return name;
95
 
  }
96
 
 
97
 
  /**
98
 
   * This method is only ever called from the
99
 
   * InfoSchemaMethods::oldFormat() methods. It is mostly
100
 
   * for old SHOW compatability. It is used when a list
101
 
   * of fields need to be generated for SHOW. The names
102
 
   * for those fields (or columns) are found by calling
103
 
   * this method on each column in the I_S table.
104
 
   *
105
 
   * @return the old name of this column.
106
 
   */
107
 
  const std::string &getOldName() const
108
 
  {
109
 
    return old_name;
110
 
  }
111
 
 
112
 
  /**
113
 
   * @return the flags for this column.
114
 
   */
115
 
  uint32_t getFlags() const
116
 
  {
117
 
    return flags;
118
 
  }
119
 
 
120
 
  /**
121
 
   * @return the length of this column.
122
 
   */
123
 
  uint32_t getLength() const
124
 
  {
125
 
    return length;
126
 
  }
127
 
 
128
 
  /**
129
 
   * @return the value of this column.
130
 
   */
131
 
  int32_t getValue() const
132
 
  {
133
 
    return value;
134
 
  }
135
 
 
136
 
  /**
137
 
   * @return this column's type.
138
 
   */
139
 
  enum enum_field_types getType() const
140
 
  {
141
 
    return type;
142
 
  }
143
 
 
144
 
private:
145
 
 
146
 
  /**
147
 
   * This is used as column name.
148
 
   */
149
 
  const std::string name;
150
 
 
151
 
  /**
152
 
   * For string-type columns, this is the maximum number of
153
 
   * characters. Otherwise, it is the 'display-length' for the column.
154
 
   */
155
 
  uint32_t length;
156
 
 
157
 
  /**
158
 
   * This denotes data type for the column. For the most part, there seems to
159
 
   * be one entry in the enum for each SQL data type, although there seem to
160
 
   * be a number of additional entries in the enum.
161
 
   */
162
 
  enum enum_field_types type;
163
 
 
164
 
  int32_t value;
165
 
 
166
 
  /**
167
 
   * This is used to set column attributes. By default, columns are @c NOT
168
 
   * @c NULL and @c SIGNED, and you can deviate from the default
169
 
   * by setting the appopriate flags. You can use either one of the flags
170
 
   * @c MY_I_S_MAYBE_NULL and @cMY_I_S_UNSIGNED or
171
 
   * combine them using the bitwise or operator @c |. Both flags are
172
 
   * defined in table.h.
173
 
   */
174
 
  uint32_t flags;
175
 
 
176
 
  /**
177
 
   * The name of this column which is used for old SHOW
178
 
   * compatability.
179
 
   */
180
 
  const std::string old_name;
181
 
 
182
 
};
183
 
 
184
 
/**
185
 
 * @class InfoSchemaMethods
186
 
 * @brief
187
 
 *   The methods that an I_S table can support
188
 
 */
189
 
class InfoSchemaMethods
190
 
{
191
 
public:
192
 
  virtual ~InfoSchemaMethods() {}
193
 
 
194
 
  virtual int fillTable(Session *session, 
195
 
                        Table *table,
196
 
                        InfoSchemaTable *schema_table);
197
 
  virtual int processTable(InfoSchemaTable *store_table, 
198
 
                           Session *session, TableList *tables,
199
 
                           Table *table, bool res, LEX_STRING *db_name,
200
 
                           LEX_STRING *table_name);
201
 
  virtual int oldFormat(Session *session, 
202
 
                        InfoSchemaTable *schema_table) const;
203
 
};
204
 
 
205
 
/**
206
 
 * @class InfoSchemaRecord
207
 
 * @brief represents a row in an I_S table
208
 
 */
209
 
class InfoSchemaRecord
210
 
{
211
 
public:
212
 
  InfoSchemaRecord();
213
 
  InfoSchemaRecord(unsigned char *buf, size_t in_len);
214
 
  InfoSchemaRecord(const InfoSchemaRecord &rhs);
215
 
 
216
 
  ~InfoSchemaRecord()
217
 
  {
218
 
    if (record)
219
 
    {
220
 
      delete [] record;
221
 
    }
222
 
  }
223
 
 
224
 
  /**
225
 
   * Copy this record into the memory passed to this function.
226
 
   *
227
 
   * @param[out] buf copy the record into this memory
228
 
   */
229
 
  void copyRecordInto(unsigned char *buf)
230
 
  {
231
 
    memcpy(buf, record, rec_len);
232
 
  }
233
 
 
234
 
  /**
235
 
   * @return the length of this record
236
 
   */
237
 
  size_t getRecordLength() const
238
 
  {
239
 
    return rec_len;
240
 
  }
241
 
 
242
 
  /**
243
 
   * @return the checksum of the data in this record
244
 
   */
245
 
  uint32_t getChecksum() const
246
 
  {
247
 
    return checksum;
248
 
  }
249
 
 
250
 
  /**
251
 
   * @param[in] crc a checksum to compare
252
 
   * @return true if the input checksum matches the checksum for this record; false otherwise
253
 
   */
254
 
  bool checksumMatches(uint32_t crc) const
255
 
  {
256
 
    return (checksum == crc);
257
 
  }
258
 
 
259
 
private:
260
 
 
261
 
  unsigned char *record;
262
 
 
263
 
  size_t rec_len;
264
 
 
265
 
  uint32_t checksum;
266
 
 
267
 
};
268
 
 
269
 
class DeleteRows
270
 
{
271
 
public:
272
 
  template<typename T>
273
 
  inline void operator()(const T *ptr) const
274
 
  {
275
 
    delete ptr;
276
 
  }
277
 
};
278
 
 
279
 
class FindRowByChecksum
280
 
{
281
 
  uint32_t cs;
282
 
public:
283
 
  FindRowByChecksum(uint32_t in_cs)
284
 
    :
285
 
      cs(in_cs)
286
 
  {}
287
 
 
288
 
  inline bool operator()(const InfoSchemaRecord *rec) const
289
 
  {
290
 
    return (cs == rec->getChecksum());
291
 
  }
292
 
};
293
 
 
294
 
/**
295
 
 * @class InfoSchemaTable
296
 
 * @brief 
297
 
 *   Represents an I_S table.
298
 
 */
299
 
class InfoSchemaTable : public Plugin
300
 
{
301
 
  InfoSchemaTable();
302
 
  InfoSchemaTable(const InfoSchemaTable &);
303
 
  InfoSchemaTable& operator=(const InfoSchemaTable &);
304
 
public:
305
 
 
306
 
  typedef std::vector<const ColumnInfo *> Columns;
307
 
  typedef std::vector<InfoSchemaRecord *> Rows;
308
 
  
309
 
  InfoSchemaTable(const std::string& tab_name,
310
 
                  Columns& in_column_info,
311
 
                  int idx_col1,
312
 
                  int idx_col2,
313
 
                  bool in_hidden,
314
 
                  bool in_opt_possible,
315
 
                  uint32_t req_object,
316
 
                  InfoSchemaMethods *in_methods)
317
 
    :
318
 
      Plugin(tab_name, "InfoSchemaTable"),
319
 
      hidden(in_hidden),
320
 
      is_opt_possible(in_opt_possible),
321
 
      first_column_index(idx_col1),
322
 
      second_column_index(idx_col2),
323
 
      requested_object(req_object),
324
 
      column_info(in_column_info),
325
 
      rows(),
326
 
      i_s_methods(in_methods)
327
 
  {}
328
 
 
329
 
  explicit InfoSchemaTable(const std::string& tab_name)
330
 
    :
331
 
      Plugin(tab_name, "InfoSchemaTable"),
332
 
      hidden(false),
333
 
      is_opt_possible(false),
334
 
      first_column_index(0),
335
 
      second_column_index(0),
336
 
      requested_object(0),
337
 
      column_info(),
338
 
      rows(),
339
 
      i_s_methods(NULL)
340
 
  {}
341
 
 
342
 
  virtual ~InfoSchemaTable()
343
 
  {
344
 
    std::for_each(rows.begin(),
345
 
                  rows.end(),
346
 
                  DeleteRows());
347
 
    rows.clear();
348
 
  }
349
 
 
350
 
  /**
351
 
   * Set the methods available on this I_S table.
352
 
   * @param[in] new_methods the methods to use
353
 
   */
354
 
  void setInfoSchemaMethods(InfoSchemaMethods *new_methods)
355
 
  {
356
 
    i_s_methods= new_methods;
357
 
  }
358
 
 
359
 
  /**
360
 
   * Fill I_S table.
361
 
   *
362
 
   * @param[in] session a session handler
363
 
   * @return 0 on success; 1 on error
364
 
   */
365
 
  int fillTable(Session *session, Table *table)
366
 
  {
367
 
    int retval= i_s_methods->fillTable(session, table, this);
368
 
    return retval;
369
 
  }
370
 
 
371
 
  /**
372
 
   * Fill and store records into an I_S table.
373
 
   *
374
 
   * @param[in] session a session handler
375
 
   * @param[in] tables table list (processed table)
376
 
   * @param[in] table I_S table
377
 
   * @param[in] res 1 means error during opening of the processed table
378
 
   *                0 means processed table opened without error
379
 
   * @param[in] db_name database name
380
 
   * @param[in] tab_name table name
381
 
   * @return 0 on success; 1 on error
382
 
   */
383
 
  int processTable(Session *session, TableList *tables, Table *table,
384
 
                   bool res, LEX_STRING *db_name, LEX_STRING *tab_name)
385
 
  {
386
 
    int retval= i_s_methods->processTable(this, session, tables, table,
387
 
                                          res, db_name, tab_name);
388
 
    return retval;
389
 
  }
390
 
 
391
 
  /**
392
 
   * For old SHOW compatibility. It is used when old SHOW doesn't
393
 
   * have generated column names. Generates the list of fields
394
 
   * for SHOW.
395
 
   *
396
 
   * @param[in] session a session handler
397
 
   * @param[in] schema_table pointer to element of the I_S tables list
398
 
   */
399
 
  int oldFormat(Session *session, InfoSchemaTable *schema_table) const
400
 
  {
401
 
    int retval= i_s_methods->oldFormat(session, schema_table);
402
 
    return retval;
403
 
  }
404
 
 
405
 
  /**
406
 
   * @param[in] new_first_index value to set first column index to
407
 
   */
408
 
  void setFirstColumnIndex(int32_t new_first_index)
409
 
  {
410
 
    first_column_index= new_first_index;
411
 
  }
412
 
 
413
 
  /**
414
 
   * @param[in] new_second_index value to set second column index to
415
 
   */
416
 
  void setSecondColumnIndex(int32_t new_second_index)
417
 
  {
418
 
    second_column_index= new_second_index;
419
 
  }
420
 
 
421
 
  /**
422
 
   * @param[in] in_column_info the columns info to use for this I_S table
423
 
   */
424
 
  void setColumnInfo(ColumnInfo *in_column_info)
425
 
  {
426
 
    ColumnInfo *tmp= in_column_info;
427
 
    for (; tmp->getName().length() != 0; tmp++)
428
 
    {
429
 
      column_info.push_back(tmp);
430
 
    }
431
 
  }
432
 
 
433
 
  /**
434
 
   * @return the name of the I_S table.
435
 
   */
436
 
  const std::string &getTableName() const
437
 
  {
438
 
    return getName();
439
 
  }
440
 
 
441
 
  /**
442
 
   * @return the names of the I_S tables.
443
 
   */
444
 
  static void getTableNames(std::set<std::string>& tables_names);
445
 
 
446
 
  /**
447
 
   * @return true if this I_S table is hidden; false otherwise.
448
 
   */
449
 
  bool isHidden() const
450
 
  {
451
 
    return hidden;
452
 
  }
453
 
 
454
 
  /**
455
 
   * @return true if I_S optimizations can be performed on this
456
 
   *         I_S table when running the fillTable method; false
457
 
   *         otherwise.
458
 
   */
459
 
  bool isOptimizationPossible() const
460
 
  {
461
 
    return is_opt_possible;
462
 
  }
463
 
 
464
 
  /**
465
 
   * @return the index for the first field.
466
 
   */
467
 
  int32_t getFirstColumnIndex() const
468
 
  {
469
 
    return first_column_index;
470
 
  }
471
 
 
472
 
  /**
473
 
   * @return the index the second field.
474
 
   */
475
 
  int32_t getSecondColumnIndex() const
476
 
  {
477
 
    return second_column_index;
478
 
  }
479
 
 
480
 
  /**
481
 
   * @return the requested object.
482
 
   */
483
 
  uint32_t getRequestedObject() const
484
 
  {
485
 
    return requested_object;
486
 
  }
487
 
 
488
 
  /**
489
 
   * @return the columns for this I_S table
490
 
   */
491
 
  const Columns &getColumns() const
492
 
  {
493
 
    return column_info;
494
 
  }
495
 
 
496
 
  /**
497
 
   * @return the rows for this I_S table.
498
 
   */
499
 
  Rows &getRows()
500
 
  {
501
 
    return rows;
502
 
  }
503
 
 
504
 
  /**
505
 
   * Clear the rows for this table and de-allocate all memory for this rows.
506
 
   */
507
 
  void clearRows()
508
 
  {
509
 
    std::for_each(rows.begin(),
510
 
                  rows.end(),
511
 
                  DeleteRows());
512
 
    rows.clear();
513
 
  }
514
 
 
515
 
  /**
516
 
   * Add a row to the std::vector of rows for this I_S table. For the moment, we check to make sure
517
 
   * that we do not add any duplicate rows. This is done in a niave manner for the moment by
518
 
   * checking the crc of the raw data for each row. We will not add this row to the std::vector of
519
 
   * rows for this I_S table is a duplicate row already exists in the std::vector.
520
 
   *
521
 
   * @param[in] buf raw data for the record to add
522
 
   * @param[in] len size of the raw data for the record to add
523
 
   */
524
 
  void addRow(unsigned char *buf, size_t len)
525
 
  {
526
 
    uint32_t cs= drizzled::hash::crc32((const char *) buf, len);
527
 
    Rows::iterator it= std::find_if(rows.begin(),
528
 
                                    rows.end(),
529
 
                                    FindRowByChecksum(cs));
530
 
    if (it == rows.end())
531
 
    {
532
 
      InfoSchemaRecord *record= new InfoSchemaRecord(buf, len);
533
 
      rows.push_back(record);
534
 
    }
535
 
  }
536
 
 
537
 
  /**
538
 
   * @param[in] index the index of this column
539
 
   * @return the name for the column at the given index
540
 
   */
541
 
  const std::string &getColumnName(int index) const
542
 
  {
543
 
    return column_info[index]->getName();
544
 
  }
545
 
 
546
 
private:
547
 
 
548
 
  /**
549
 
   * Boolean which indicates whether this I_S table
550
 
   * is hidden or not. If it is hidden, it will not show
551
 
   * up in the list of I_S tables.
552
 
   */
553
 
  bool hidden;
554
 
 
555
 
  /**
556
 
   * Boolean which indicates whether optimizations are
557
 
   * possible on this I_S table when performing the
558
 
   * fillTable method.
559
 
   */
560
 
  bool is_opt_possible;
561
 
 
562
 
  /**
563
 
   * The index of the first column.
564
 
   */
565
 
  int32_t first_column_index;
566
 
 
567
 
  /**
568
 
   * The index of the second column.
569
 
   */
570
 
  int32_t second_column_index;
571
 
 
572
 
  /**
573
 
   * The object to open (TABLE | VIEW).
574
 
   */
575
 
  uint32_t requested_object;
576
 
 
577
 
  /**
578
 
   * The columns for this I_S table.
579
 
   */
580
 
  Columns column_info;
581
 
 
582
 
  /**
583
 
   * The rows for this I_S table.
584
 
   */
585
 
  Rows rows;
586
 
 
587
 
  /**
588
 
   * Contains the methods available on this I_S table.
589
 
   */
590
 
  InfoSchemaMethods *i_s_methods;
591
 
 
592
 
public:
593
 
  static bool addPlugin(plugin::InfoSchemaTable *schema_table);
594
 
  static void removePlugin(plugin::InfoSchemaTable *table);
595
 
 
596
 
  static plugin::InfoSchemaTable *getTable(const char *table_name);
597
 
  static int addTableToList(Session *session, std::vector<LEX_STRING*> &files,
598
 
                            const char *wild);
599
 
};
600
 
 
601
 
} /* namespace plugin */
602
 
} /* namespace drizzled */
603
 
 
604
 
#endif /* DRIZZLED_PLUGIN_INFO_SCHEMA_TABLE_H */