← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/info_schema/tables.cc

Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/info_schema/tables.cc
72
72
                                            DRIZZLE_TYPE_VARCHAR,
73
73
                                            0,
74
74
                                            1,
75
 
                                            "",
76
 
                                            SKIP_OPEN_TABLE));
 
75
                                            ""));
77
76
 
78
77
  columns->push_back(new plugin::ColumnInfo("TABLE_SCHEMA",
79
78
                                            NAME_CHAR_LEN,
80
79
                                            DRIZZLE_TYPE_VARCHAR,
81
80
                                            0,
82
81
                                            0,
83
 
                                            "",
84
 
                                            SKIP_OPEN_TABLE));
 
82
                                            ""));
85
83
 
86
84
  columns->push_back(new plugin::ColumnInfo("TABLE_NAME",
87
85
                                            NAME_CHAR_LEN,
88
86
                                            DRIZZLE_TYPE_VARCHAR,
89
87
                                            0,
90
88
                                            0,
91
 
                                            "Name",
92
 
                                            SKIP_OPEN_TABLE));
 
89
                                            "Name"));
93
90
 
94
91
  columns->push_back(new plugin::ColumnInfo("TABLE_TYPE",
95
92
                                            NAME_CHAR_LEN,
96
93
                                            DRIZZLE_TYPE_VARCHAR,
97
94
                                            0,
98
95
                                            0,
99
 
                                            "",
100
 
                                            OPEN_FRM_ONLY));
 
96
                                            ""));
101
97
 
102
98
  columns->push_back(new plugin::ColumnInfo("ENGINE",
103
99
                                            NAME_CHAR_LEN,
104
100
                                            DRIZZLE_TYPE_VARCHAR,
105
101
                                            0,
106
102
                                            1,
107
 
                                            "Engine",
108
 
                                            OPEN_FRM_ONLY));
 
103
                                            "Engine"));
109
104
 
110
105
  columns->push_back(new plugin::ColumnInfo("VERSION",
111
106
                                            MY_INT64_NUM_DECIMAL_DIGITS,
112
107
                                            DRIZZLE_TYPE_LONGLONG,
113
108
                                            0,
114
109
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
115
 
                                            "Version",
116
 
                                            OPEN_FRM_ONLY));
 
110
                                            "Version"));
117
111
 
118
112
  columns->push_back(new plugin::ColumnInfo("ROW_FORMAT",
119
113
                                            10,
120
114
                                            DRIZZLE_TYPE_VARCHAR,
121
115
                                            0,
122
116
                                            1,
123
 
                                            "Row_format",
124
 
                                            OPEN_FULL_TABLE));
 
117
                                            "Row_format"));
125
118
 
126
119
  columns->push_back(new plugin::ColumnInfo("TABLE_ROWS",
127
120
                                            MY_INT64_NUM_DECIMAL_DIGITS,
128
121
                                            DRIZZLE_TYPE_LONGLONG,
129
122
                                            0,
130
123
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
131
 
                                            "Rows",
132
 
                                            OPEN_FULL_TABLE));
 
124
                                            "Rows"));
133
125
 
134
126
  columns->push_back(new plugin::ColumnInfo("AVG_ROW_LENGTH",
135
127
                                            MY_INT64_NUM_DECIMAL_DIGITS,
136
128
                                            DRIZZLE_TYPE_LONGLONG,
137
129
                                            0,
138
130
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
139
 
                                            "Avg_row_length",
140
 
                                            OPEN_FULL_TABLE));
 
131
                                            "Avg_row_length"));
141
132
 
142
133
  columns->push_back(new plugin::ColumnInfo("DATA_LENGTH",
143
134
                                            MY_INT64_NUM_DECIMAL_DIGITS,
144
135
                                            DRIZZLE_TYPE_LONGLONG,
145
136
                                            0,
146
137
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
147
 
                                            "Data_length",
148
 
                                            OPEN_FULL_TABLE));
 
138
                                            "Data_length"));
149
139
 
150
140
  columns->push_back(new plugin::ColumnInfo("MAX_DATA_LENGTH",
151
141
                                            MY_INT64_NUM_DECIMAL_DIGITS,
152
142
                                            DRIZZLE_TYPE_LONGLONG,
153
143
                                            0,
154
144
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
155
 
                                            "Max_data_length",
156
 
                                            OPEN_FULL_TABLE));
 
145
                                            "Max_data_length"));
157
146
 
158
147
  columns->push_back(new plugin::ColumnInfo("INDEX_LENGTH",
159
148
                                            MY_INT64_NUM_DECIMAL_DIGITS,
160
149
                                            DRIZZLE_TYPE_LONGLONG,
161
150
                                            0,
162
151
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
163
 
                                            "Index_length",
164
 
                                            OPEN_FULL_TABLE));
 
152
                                            "Index_length"));
165
153
 
166
154
  columns->push_back(new plugin::ColumnInfo("DATA_FREE",
167
155
                                            MY_INT64_NUM_DECIMAL_DIGITS,
168
156
                                            DRIZZLE_TYPE_LONGLONG,
169
157
                                            0,
170
158
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
171
 
                                            "Data_free",
172
 
                                            OPEN_FULL_TABLE));
 
159
                                            "Data_free"));
173
160
 
174
161
  columns->push_back(new plugin::ColumnInfo("AUTO_INCREMENT",
175
162
                                            MY_INT64_NUM_DECIMAL_DIGITS,
176
163
                                            DRIZZLE_TYPE_LONGLONG,
177
164
                                            0,
178
165
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
179
 
                                            "Auto_increment",
180
 
                                            OPEN_FULL_TABLE));
 
166
                                            "Auto_increment"));
181
167
 
182
168
  columns->push_back(new plugin::ColumnInfo("CREATE_TIME",
183
169
                                            0,
184
170
                                            DRIZZLE_TYPE_DATETIME,
185
171
                                            0,
186
172
                                            1,
187
 
                                            "Create_time",
188
 
                                            OPEN_FULL_TABLE));
 
173
                                            "Create_time"));
189
174
 
190
175
  columns->push_back(new plugin::ColumnInfo("UPDATE_TIME",
191
176
                                            0,
192
177
                                            DRIZZLE_TYPE_DATETIME,
193
178
                                            0,
194
179
                                            1,
195
 
                                            "Update_time",
196
 
                                            OPEN_FULL_TABLE));
 
180
                                            "Update_time"));
197
181
 
198
182
  columns->push_back(new plugin::ColumnInfo("CHECK_TIME",
199
183
                                            0,
200
184
                                            DRIZZLE_TYPE_DATETIME,
201
185
                                            0,
202
186
                                            1,
203
 
                                            "Check_time",
204
 
                                            OPEN_FULL_TABLE));
 
187
                                            "Check_time"));
205
188
 
206
189
  columns->push_back(new plugin::ColumnInfo("TABLE_COLLATION",
207
190
                                            64,
208
191
                                            DRIZZLE_TYPE_VARCHAR,
209
192
                                            0,
210
193
                                            1,
211
 
                                            "Collation",
212
 
                                            OPEN_FRM_ONLY));
 
194
                                            "Collation"));
213
195
 
214
196
  columns->push_back(new plugin::ColumnInfo("CHECKSUM",
215
197
                                            MY_INT64_NUM_DECIMAL_DIGITS,
216
198
                                            DRIZZLE_TYPE_LONGLONG,
217
199
                                            0,
218
200
                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
219
 
                                            "Checksum",
220
 
                                            OPEN_FULL_TABLE));
 
201
                                            "Checksum"));
221
202
 
222
203
  columns->push_back(new plugin::ColumnInfo("CREATE_OPTIONS",
223
204
                                            255,
224
205
                                            DRIZZLE_TYPE_VARCHAR,
225
206
                                            0,
226
207
                                            1,
227
 
                                            "Create_options",
228
 
                                            OPEN_FRM_ONLY));
 
208
                                            "Create_options"));
229
209
 
230
210
  columns->push_back(new plugin::ColumnInfo("TABLE_COMMENT",
231
211
                                            TABLE_COMMENT_MAXLEN,
232
212
                                            DRIZZLE_TYPE_VARCHAR,
233
213
                                            0,
234
214
                                            0,
235
 
                                            "Comment",
236
 
                                            OPEN_FRM_ONLY));
 
215
                                            "Comment"));
237
216
 
238
217
  return columns;
239
218
}
275
254
  delete columns;
276
255
}
277
256
 
278
 
int TablesISMethods::processTable(Session *session, 
 
257
int TablesISMethods::processTable(plugin::InfoSchemaTable *store_table,
 
258
                                  Session *session, 
279
259
                                  TableList *tables,
280
260
                                  Table *table, 
281
261
                                  bool res,
282
262
                                  LEX_STRING *db_name,
283
 
                                  LEX_STRING *table_name) const
 
263
                                  LEX_STRING *table_name)
284
264
{
285
265
  const char *tmp_buff= NULL;
286
266
  DRIZZLE_TIME time;
287
267
  const CHARSET_INFO * const cs= system_charset_info;
288
268
 
289
269
  table->restoreRecordAsDefault();
 
270
  table->setWriteSet(1);
 
271
  table->setWriteSet(2);
 
272
  table->setWriteSet(3);
 
273
  table->setWriteSet(4);
 
274
  table->setWriteSet(5);
 
275
  table->setWriteSet(6);
 
276
  table->setWriteSet(7);
 
277
  table->setWriteSet(8);
 
278
  table->setWriteSet(9);
 
279
  table->setWriteSet(11);
 
280
  table->setWriteSet(12);
 
281
  table->setWriteSet(13);
 
282
  table->setWriteSet(14);
 
283
  table->setWriteSet(15);
 
284
  table->setWriteSet(16);
 
285
  table->setWriteSet(17);
 
286
  table->setWriteSet(18);
 
287
  table->setWriteSet(19);
 
288
  table->setWriteSet(20);
290
289
  table->field[1]->store(db_name->str, db_name->length, cs);
291
290
  table->field[2]->store(table_name->str, table_name->length, cs);
292
291
  if (res)
295
294
      there was errors during opening tables
296
295
    */
297
296
    const char *error= session->is_error() ? session->main_da.message() : "";
298
 
    if (tables->schema_table)
299
 
    {
300
 
      table->field[3]->store(STRING_WITH_LEN("SYSTEM VIEW"), cs);
301
 
    }
302
 
    else
303
 
    {
304
 
      table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
305
 
    }
 
297
    table->field[3]->store(STRING_WITH_LEN("BASE Table"), cs);
306
298
    table->field[20]->store(error, strlen(error), cs);
307
299
    session->clear_error();
308
300
  }
408
400
        break;
409
401
      }
410
402
      table->field[6]->store(tmp_buff, strlen(tmp_buff), cs);
411
 
      if (! tables->schema_table)
412
 
      {
413
 
        table->field[7]->store((int64_t) cursor->stats.records, true);
414
 
        table->field[7]->set_notnull();
415
 
      }
 
403
      table->field[7]->store((int64_t) cursor->stats.records, true);
 
404
      table->field[7]->set_notnull();
416
405
      table->field[8]->store((int64_t) cursor->stats.mean_rec_length, true);
417
406
      table->field[9]->store((int64_t) cursor->stats.data_file_length, true);
418
407
      if (cursor->stats.max_data_file_length)
448
437
        table->field[16]->store_time(&time, DRIZZLE_TIMESTAMP_DATETIME);
449
438
        table->field[16]->set_notnull();
450
439
      }
451
 
      if (cursor->ha_table_flags() & (ulong) HA_HAS_CHECKSUM)
 
440
      if (cursor->getEngine()->check_flag(HTON_BIT_HAS_CHECKSUM))
452
441
      {
453
442
        table->field[18]->store((int64_t) cursor->checksum(), true);
454
443
        table->field[18]->set_notnull();
455
444
      }
456
445
    }
457
446
  }
458
 
  return (schema_table_store_record(session, table));
 
447
  store_table->addRow(table->record[0], table->s->reclength);
 
448
  return false;
459
449
}
460
450