← 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: 2009-12-29 01:38:38 UTC
  • mfrom: (1251.1.1 drizzle)
  • Revision ID: brian@gaz-20091229013838-03kb2z5xbqw03ddt
Merge of Diego fix.

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