← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/info_schema.h

Merge Padraig

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/info_schema.h
37
37
 * @brief
38
38
 *   Represents a field (column) in an I_S table.
39
39
 */
40
 
class ColumnInfo
41
 
{
42
 
public:
43
 
  ColumnInfo(const char *in_name,
44
 
             uint32_t in_length,
 
40
class ColumnInfo 
 
41
{ 
 
42
public: 
 
43
  ColumnInfo(const std::string& in_name, 
 
44
             uint32_t in_length, 
45
45
             enum enum_field_types in_type,
46
46
             int32_t in_value,
47
47
             uint32_t in_flags,
48
 
             const char *in_old_name,
 
48
             const std::string& in_old_name,
49
49
             uint32_t in_open_method)
50
50
    :
51
51
      name(in_name),
59
59
 
60
60
  ColumnInfo()
61
61
    :
62
 
      name(NULL),
 
62
      name(),
63
63
      length(0),
64
64
      type(DRIZZLE_TYPE_VARCHAR),
65
65
      flags(0),
66
 
      old_name(NULL),
 
66
      old_name(),
67
67
      open_method(SKIP_OPEN_TABLE)
68
68
  {}
69
69
 
70
70
  /**
71
71
   * @return the name of this column.
72
72
   */
73
 
  const char *getName() const
 
73
  const std::string &getName() const
74
74
  {
75
75
    return name;
76
76
  }
85
85
   *
86
86
   * @return the old name of this column.
87
87
   */
88
 
  const char *getOldName() const
 
88
  const std::string &getOldName() const
89
89
  {
90
90
    return old_name;
91
91
  }
135
135
  /**
136
136
   * This is used as column name.
137
137
   */
138
 
  const char *name;
 
138
  const std::string name;
139
139
 
140
140
  /**
141
141
   * For string-type columns, this is the maximum number of
166
166
   * The name of this column which is used for old SHOW
167
167
   * compatability.
168
168
   */
169
 
  const char *old_name;
 
169
  const std::string old_name;
170
170
 
171
171
  /**
172
172
   * This should be one of @c SKIP_OPEN_TABLE,
199
199
                        InfoSchemaTable *schema_table) const;
200
200
};
201
201
 
202
 
class CharSetISMethods : public InfoSchemaMethods
203
 
{
204
 
public:
205
 
  virtual int fillTable(Session *session, 
206
 
                        TableList *tables,
207
 
                        COND *cond);
208
 
  virtual int oldFormat(Session *session, InfoSchemaTable *schema_table) const;
209
 
};
210
 
 
211
 
class CollationISMethods : public InfoSchemaMethods
212
 
{
213
 
public:
214
 
  virtual int fillTable(Session *session, 
215
 
                        TableList *tables,
216
 
                        COND *cond);
217
 
};
218
 
 
219
 
class CollCharISMethods : public InfoSchemaMethods
220
 
{
221
 
public:
222
 
  virtual int fillTable(Session *session, 
223
 
                        TableList *tables,
224
 
                        COND *cond);
225
 
};
226
 
 
227
202
class ColumnsISMethods : public InfoSchemaMethods
228
203
{
229
204
public:
329
304
 
330
305
  typedef std::vector<const ColumnInfo *> Columns;
331
306
  
332
 
  InfoSchemaTable(const char *tab_name,
 
307
  InfoSchemaTable(const std::string& tab_name,
333
308
                  ColumnInfo *in_column_info,
334
309
                  int32_t idx_col1,
335
310
                  int32_t idx_col2,
350
325
    setColumnInfo(in_column_info);
351
326
  }
352
327
 
353
 
  InfoSchemaTable(const char *tab_name,
 
328
  InfoSchemaTable(const std::string& tab_name,
354
329
                  Columns& in_column_info,
355
330
                  int idx_col1,
356
331
                  int idx_col2,
371
346
 
372
347
  InfoSchemaTable()
373
348
    :
374
 
      table_name(NULL),
 
349
      table_name(),
375
350
      hidden(false),
376
351
      is_opt_possible(false),
377
352
      first_column_index(0),
457
432
   * Set the I_S tables name.
458
433
   * @param[in] new_name the name to set the table to
459
434
   */
460
 
  void setTableName(const char *new_name)
 
435
  void setTableName(const std::string &new_name)
461
436
  {
462
437
    table_name= new_name;
463
438
  }
484
459
  void setColumnInfo(ColumnInfo *in_column_info)
485
460
  {
486
461
    ColumnInfo *tmp= in_column_info;
487
 
    for (; tmp->getName(); tmp++)
 
462
    for (; tmp->getName().length() != 0; tmp++)
488
463
    {
489
464
      column_info.push_back(tmp);
490
465
    }
493
468
  /**
494
469
   * @return the name of the I_S table.
495
470
   */
496
 
  const char *getTableName() const
 
471
  const std::string &getTableName() const
497
472
  {
498
473
    return table_name;
499
474
  }
552
527
   * @param[in] index the index of this column
553
528
   * @return the name for the column at the given index
554
529
   */
555
 
  const char *getColumnName(int index) const
 
530
  const std::string &getColumnName(int index) const
556
531
  {
557
532
    return column_info[index]->getName();
558
533
  }
570
545
  /**
571
546
   * I_S table name.
572
547
   */
573
 
  const char *table_name;
 
548
  std::string table_name;
574
549
 
575
550
  /**
576
551
   * Boolean which indicates whether this I_S table