← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/tables.cc

  • Committer: Brian Aker
  • Date: 2008-07-28 18:01:38 UTC
  • Revision ID: brian@tangent.org-20080728180138-q2pxlq0qiapvqsdn
Remove YEAR field type

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/tables.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
 
 *   tables I_S table methods.
24
 
 */
25
 
 
26
 
#include "config.h"
27
 
#include "drizzled/session.h"
28
 
#include "drizzled/show.h"
29
 
#include "drizzled/tztime.h"
30
 
#include "drizzled/internal/m_string.h"
31
 
 
32
 
#include "helper_methods.h"
33
 
#include "tables.h"
34
 
 
35
 
#include <vector>
36
 
 
37
 
using namespace drizzled;
38
 
using namespace std;
39
 
 
40
 
/*
41
 
 * Vectors of columns for the tables I_S table.
42
 
 */
43
 
static vector<const plugin::ColumnInfo *> *columns= NULL;
44
 
 
45
 
/*
46
 
 * Methods for the tables I_S table.
47
 
 */
48
 
static plugin::InfoSchemaMethods *methods= NULL;
49
 
 
50
 
/*
51
 
 * tables I_S table.
52
 
 */
53
 
static plugin::InfoSchemaTable *tbls_table= NULL;
54
 
 
55
 
/**
56
 
 * Populate the vectors of columns for the I_S table.
57
 
 *
58
 
 * @return a pointer to a std::vector of Columns.
59
 
 */
60
 
vector<const plugin::ColumnInfo *> *TablesIS::createColumns()
61
 
{
62
 
  if (columns == NULL)
63
 
  {
64
 
    columns= new vector<const plugin::ColumnInfo *>;
65
 
  }
66
 
  else
67
 
  {
68
 
    clearColumns(*columns);
69
 
  }
70
 
 
71
 
  columns->push_back(new plugin::ColumnInfo("TABLE_CATALOG",
72
 
                                            FN_REFLEN,
73
 
                                            DRIZZLE_TYPE_VARCHAR,
74
 
                                            0,
75
 
                                            1,
76
 
                                            ""));
77
 
 
78
 
  columns->push_back(new plugin::ColumnInfo("TABLE_SCHEMA",
79
 
                                            NAME_CHAR_LEN,
80
 
                                            DRIZZLE_TYPE_VARCHAR,
81
 
                                            0,
82
 
                                            0,
83
 
                                            ""));
84
 
 
85
 
  columns->push_back(new plugin::ColumnInfo("TABLE_NAME",
86
 
                                            NAME_CHAR_LEN,
87
 
                                            DRIZZLE_TYPE_VARCHAR,
88
 
                                            0,
89
 
                                            0,
90
 
                                            "Name"));
91
 
 
92
 
  columns->push_back(new plugin::ColumnInfo("TABLE_TYPE",
93
 
                                            NAME_CHAR_LEN,
94
 
                                            DRIZZLE_TYPE_VARCHAR,
95
 
                                            0,
96
 
                                            0,
97
 
                                            ""));
98
 
 
99
 
  columns->push_back(new plugin::ColumnInfo("ENGINE",
100
 
                                            NAME_CHAR_LEN,
101
 
                                            DRIZZLE_TYPE_VARCHAR,
102
 
                                            0,
103
 
                                            1,
104
 
                                            "Engine"));
105
 
 
106
 
  columns->push_back(new plugin::ColumnInfo("VERSION",
107
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
108
 
                                            DRIZZLE_TYPE_LONGLONG,
109
 
                                            0,
110
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
111
 
                                            "Version"));
112
 
 
113
 
  columns->push_back(new plugin::ColumnInfo("ROW_FORMAT",
114
 
                                            10,
115
 
                                            DRIZZLE_TYPE_VARCHAR,
116
 
                                            0,
117
 
                                            1,
118
 
                                            "Row_format"));
119
 
 
120
 
  columns->push_back(new plugin::ColumnInfo("TABLE_ROWS",
121
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
122
 
                                            DRIZZLE_TYPE_LONGLONG,
123
 
                                            0,
124
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
125
 
                                            "Rows"));
126
 
 
127
 
  columns->push_back(new plugin::ColumnInfo("AVG_ROW_LENGTH",
128
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
129
 
                                            DRIZZLE_TYPE_LONGLONG,
130
 
                                            0,
131
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
132
 
                                            "Avg_row_length"));
133
 
 
134
 
  columns->push_back(new plugin::ColumnInfo("DATA_LENGTH",
135
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
136
 
                                            DRIZZLE_TYPE_LONGLONG,
137
 
                                            0,
138
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
139
 
                                            "Data_length"));
140
 
 
141
 
  columns->push_back(new plugin::ColumnInfo("MAX_DATA_LENGTH",
142
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
143
 
                                            DRIZZLE_TYPE_LONGLONG,
144
 
                                            0,
145
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
146
 
                                            "Max_data_length"));
147
 
 
148
 
  columns->push_back(new plugin::ColumnInfo("INDEX_LENGTH",
149
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
150
 
                                            DRIZZLE_TYPE_LONGLONG,
151
 
                                            0,
152
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
153
 
                                            "Index_length"));
154
 
 
155
 
  columns->push_back(new plugin::ColumnInfo("DATA_FREE",
156
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
157
 
                                            DRIZZLE_TYPE_LONGLONG,
158
 
                                            0,
159
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
160
 
                                            "Data_free"));
161
 
 
162
 
  columns->push_back(new plugin::ColumnInfo("AUTO_INCREMENT",
163
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
164
 
                                            DRIZZLE_TYPE_LONGLONG,
165
 
                                            0,
166
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
167
 
                                            "Auto_increment"));
168
 
 
169
 
  columns->push_back(new plugin::ColumnInfo("CREATE_TIME",
170
 
                                            0,
171
 
                                            DRIZZLE_TYPE_DATETIME,
172
 
                                            0,
173
 
                                            1,
174
 
                                            "Create_time"));
175
 
 
176
 
  columns->push_back(new plugin::ColumnInfo("UPDATE_TIME",
177
 
                                            0,
178
 
                                            DRIZZLE_TYPE_DATETIME,
179
 
                                            0,
180
 
                                            1,
181
 
                                            "Update_time"));
182
 
 
183
 
  columns->push_back(new plugin::ColumnInfo("CHECK_TIME",
184
 
                                            0,
185
 
                                            DRIZZLE_TYPE_DATETIME,
186
 
                                            0,
187
 
                                            1,
188
 
                                            "Check_time"));
189
 
 
190
 
  columns->push_back(new plugin::ColumnInfo("TABLE_COLLATION",
191
 
                                            64,
192
 
                                            DRIZZLE_TYPE_VARCHAR,
193
 
                                            0,
194
 
                                            1,
195
 
                                            "Collation"));
196
 
 
197
 
  columns->push_back(new plugin::ColumnInfo("CHECKSUM",
198
 
                                            MY_INT64_NUM_DECIMAL_DIGITS,
199
 
                                            DRIZZLE_TYPE_LONGLONG,
200
 
                                            0,
201
 
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
202
 
                                            "Checksum"));
203
 
 
204
 
  columns->push_back(new plugin::ColumnInfo("CREATE_OPTIONS",
205
 
                                            255,
206
 
                                            DRIZZLE_TYPE_VARCHAR,
207
 
                                            0,
208
 
                                            1,
209
 
                                            "Create_options"));
210
 
 
211
 
  columns->push_back(new plugin::ColumnInfo("TABLE_COMMENT",
212
 
                                            TABLE_COMMENT_MAXLEN,
213
 
                                            DRIZZLE_TYPE_VARCHAR,
214
 
                                            0,
215
 
                                            0,
216
 
                                            "Comment"));
217
 
 
218
 
  return columns;
219
 
}
220
 
 
221
 
/**
222
 
 * Initialize the I_S table.
223
 
 *
224
 
 * @return a pointer to an I_S table
225
 
 */
226
 
plugin::InfoSchemaTable *TablesIS::getTable()
227
 
{
228
 
  columns= createColumns();
229
 
 
230
 
  if (methods == NULL)
231
 
  {
232
 
    methods= new TablesISMethods();
233
 
  }
234
 
 
235
 
  if (tbls_table == NULL)
236
 
  {
237
 
    tbls_table= new plugin::InfoSchemaTable("TABLES",
238
 
                                            *columns,
239
 
                                            1, 2, false, true,
240
 
                                            OPTIMIZE_I_S_TABLE,
241
 
                                            methods);
242
 
  }
243
 
 
244
 
  return tbls_table;
245
 
}
246
 
 
247
 
/**
248
 
 * Delete memory allocated for the table, columns and methods.
249
 
 */
250
 
void TablesIS::cleanup()
251
 
{
252
 
  clearColumns(*columns);
253
 
  delete tbls_table;
254
 
  delete methods;
255
 
  delete columns;
256
 
}
257
 
 
258
 
int TablesISMethods::processTable(plugin::InfoSchemaTable *store_table,
259
 
                                  Session *session, 
260
 
                                  TableList *tables,
261
 
                                  Table *table, 
262
 
                                  bool res,
263
 
                                  LEX_STRING *db_name,
264
 
                                  LEX_STRING *table_name)
265
 
{
266
 
  const char *tmp_buff= NULL;
267
 
  DRIZZLE_TIME time;
268
 
  const CHARSET_INFO * const cs= system_charset_info;
269
 
 
270
 
  table->restoreRecordAsDefault();
271
 
  table->setWriteSet(1);
272
 
  table->setWriteSet(2);
273
 
  table->setWriteSet(3);
274
 
  table->setWriteSet(4);
275
 
  table->setWriteSet(5);
276
 
  table->setWriteSet(6);
277
 
  table->setWriteSet(7);
278
 
  table->setWriteSet(8);
279
 
  table->setWriteSet(9);
280
 
  table->setWriteSet(11);
281
 
  table->setWriteSet(12);
282
 
  table->setWriteSet(13);
283
 
  table->setWriteSet(14);
284
 
  table->setWriteSet(15);
285
 
  table->setWriteSet(16);
286
 
  table->setWriteSet(17);
287
 
  table->setWriteSet(18);
288
 
  table->setWriteSet(19);
289
 
  table->setWriteSet(20);
290
 
  table->field[1]->store(db_name->str, db_name->length, cs);
291
 
  table->field[2]->store(table_name->str, table_name->length, cs);
292
 
  if (res)
293
 
  {
294
 
    /*
295
 
      there was errors during opening tables
296
 
    */
297
 
    const char *error= session->is_error() ? session->main_da.message() : "";
298
 
    table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
299
 
    table->field[20]->store(error, strlen(error), cs);
300
 
    session->clear_error();
301
 
  }
302
 
  else
303
 
  {
304
 
    char option_buff[400];
305
 
    char *ptr= NULL;
306
 
    Table *show_table= tables->table;
307
 
    TableShare *share= show_table->s;
308
 
    Cursor *cursor= show_table->cursor;
309
 
    drizzled::plugin::StorageEngine *tmp_db_type= share->db_type();
310
 
 
311
 
    if (share->tmp_table == SYSTEM_TMP_TABLE)
312
 
    {
313
 
      table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"), cs);
314
 
    }
315
 
    else if (share->tmp_table)
316
 
    {
317
 
      table->field[3]->store(STRING_WITH_LEN("LOCAL TEMPORARY"), cs);
318
 
    }
319
 
    else
320
 
    {
321
 
      table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
322
 
    }
323
 
 
324
 
    for (int i= 4; i < 20; i++)
325
 
    {
326
 
      if (i == 7 || (i > 12 && i < 17) || i == 18)
327
 
      {
328
 
        continue;
329
 
      }
330
 
      table->field[i]->set_notnull();
331
 
    }
332
 
    const string &engine_name= drizzled::plugin::StorageEngine::resolveName(tmp_db_type);
333
 
    table->field[4]->store(engine_name.c_str(), engine_name.size(), cs);
334
 
    table->field[5]->store((int64_t) 0, true);
335
 
 
336
 
    ptr=option_buff;
337
 
 
338
 
    if (share->db_create_options & HA_OPTION_PACK_KEYS)
339
 
    {
340
 
      ptr= strcpy(ptr," pack_keys=1")+12;
341
 
    }
342
 
    if (share->db_create_options & HA_OPTION_NO_PACK_KEYS)
343
 
    {
344
 
      ptr= strcpy(ptr," pack_keys=0")+12;
345
 
    }
346
 
    if (share->row_type != ROW_TYPE_DEFAULT)
347
 
    {
348
 
      ptr+= sprintf(ptr, " row_format=%s", ha_row_type[(uint32_t)share->row_type]);
349
 
    }
350
 
    if (share->block_size)
351
 
    {
352
 
      ptr= strcpy(ptr, " block_size=")+12;
353
 
      ptr= int64_t10_to_str(share->block_size, ptr, 10);
354
 
    }
355
 
 
356
 
    table->field[19]->store(option_buff+1,
357
 
                            (ptr == option_buff ? 0 :
358
 
                             (uint32_t) (ptr-option_buff)-1), cs);
359
 
 
360
 
    tmp_buff= (share->table_charset ?
361
 
               share->table_charset->name : "default");
362
 
    table->field[17]->store(tmp_buff, strlen(tmp_buff), cs);
363
 
 
364
 
    if (share->hasComment())
365
 
      table->field[20]->store(share->getComment(),
366
 
                              share->getCommentLength(), cs);
367
 
 
368
 
    if (cursor)
369
 
    {
370
 
      cursor->info(HA_STATUS_VARIABLE | 
371
 
                   HA_STATUS_TIME | 
372
 
                   HA_STATUS_AUTO |
373
 
                   HA_STATUS_NO_LOCK);
374
 
      enum row_type row_type = cursor->get_row_type();
375
 
      switch (row_type) 
376
 
      {
377
 
      case ROW_TYPE_NOT_USED:
378
 
      case ROW_TYPE_DEFAULT:
379
 
        tmp_buff= ((share->db_options_in_use &
380
 
                    HA_OPTION_COMPRESS_RECORD) ? "Compressed" :
381
 
                   (share->db_options_in_use & HA_OPTION_PACK_RECORD) ?
382
 
                   "Dynamic" : "Fixed");
383
 
        break;
384
 
      case ROW_TYPE_FIXED:
385
 
        tmp_buff= "Fixed";
386
 
        break;
387
 
      case ROW_TYPE_DYNAMIC:
388
 
        tmp_buff= "Dynamic";
389
 
        break;
390
 
      case ROW_TYPE_COMPRESSED:
391
 
        tmp_buff= "Compressed";
392
 
        break;
393
 
      case ROW_TYPE_REDUNDANT:
394
 
        tmp_buff= "Redundant";
395
 
        break;
396
 
      case ROW_TYPE_COMPACT:
397
 
        tmp_buff= "Compact";
398
 
        break;
399
 
      case ROW_TYPE_PAGE:
400
 
        tmp_buff= "Paged";
401
 
        break;
402
 
      }
403
 
      table->field[6]->store(tmp_buff, strlen(tmp_buff), cs);
404
 
      table->field[7]->store((int64_t) cursor->stats.records, true);
405
 
      table->field[7]->set_notnull();
406
 
      table->field[8]->store((int64_t) cursor->stats.mean_rec_length, true);
407
 
      table->field[9]->store((int64_t) cursor->stats.data_file_length, true);
408
 
      if (cursor->stats.max_data_file_length)
409
 
      {
410
 
        table->field[10]->store((int64_t) cursor->stats.max_data_file_length,
411
 
                                true);
412
 
      }
413
 
      table->field[11]->store((int64_t) cursor->stats.index_file_length, true);
414
 
      table->field[12]->store((int64_t) cursor->stats.delete_length, true);
415
 
      if (show_table->found_next_number_field)
416
 
      {
417
 
        table->field[13]->store((int64_t) cursor->stats.auto_increment_value, true);
418
 
        table->field[13]->set_notnull();
419
 
      }
420
 
      if (cursor->stats.create_time)
421
 
      {
422
 
        session->variables.time_zone->gmt_sec_to_TIME(&time,
423
 
                                                  (time_t) cursor->stats.create_time);
424
 
        table->field[14]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
425
 
        table->field[14]->set_notnull();
426
 
      }
427
 
      if (cursor->stats.update_time)
428
 
      {
429
 
        session->variables.time_zone->gmt_sec_to_TIME(&time,
430
 
                                                  (time_t) cursor->stats.update_time);
431
 
        table->field[15]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
432
 
        table->field[15]->set_notnull();
433
 
      }
434
 
      if (cursor->stats.check_time)
435
 
      {
436
 
        session->variables.time_zone->gmt_sec_to_TIME(&time,
437
 
                                                  (time_t) cursor->stats.check_time);
438
 
        table->field[16]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
439
 
        table->field[16]->set_notnull();
440
 
      }
441
 
      if (cursor->getEngine()->check_flag(HTON_BIT_HAS_CHECKSUM))
442
 
      {
443
 
        table->field[18]->store((int64_t) cursor->checksum(), true);
444
 
        table->field[18]->set_notnull();
445
 
      }
446
 
    }
447
 
  }
448
 
  store_table->addRow(table->record[0], table->s->reclength);
449
 
  return false;
450
 
}
451