← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/handler/data_dictionary.cc

[patch 112/129] Merge patch for revision 1925 from InnoDB SVN:
revno: 1925
revision-id: svn-v4:16c675df-0fcb-4bc9-8058-dcc011a37293:branches/zip:6169
parent: svn-v4:16c675df-0fcb-4bc9-8058-dcc011a37293:branches/zip:6163
committer: calvin
timestamp: Thu 2009-11-12 12:40:43 +0000
message:
  branches/zip: add test case for bug#46676
  
  This crash is reproducible with InnoDB plugin 1.0.4 + MySQL 5.1.37.
  But no longer reproducible after MySQL 5.1.38 (with plugin 1.0.5).
  Add test case to catch future regression.
added:
  mysql-test/innodb_bug46676.result 6169@16c675df-0fcb-4bc9-8058-dcc011a37293:branches%2Fzip%2Fmysql-test%2Finnodb_bug46676.result
  mysql-test/innodb_bug46676.test 6169@16c675df-0fcb-4bc9-8058-dcc011a37293:branches%2Fzip%2Fmysql-test%2Finnodb_bug46676.test
diff:
=== added file 'mysql-test/innodb_bug46676.result'

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/handler/data_dictionary.cc
29
29
#include "buf0buf.h" /* for buf_pool and PAGE_ZIP_MIN_SIZE */
30
30
#include "ha_prototypes.h" /* for innobase_convert_name() */
31
31
#include "srv0start.h" /* for srv_was_started */
32
 
#include "btr0pcur.h"   /* for file sys_tables related info. */
33
 
#include "btr0types.h"
34
 
#include "dict0load.h"  /* for file sys_tables related info. */
35
 
#include "dict0mem.h"
36
 
#include "dict0types.h"
37
32
}
38
33
#include "handler0vars.h"
39
34
 
40
35
using namespace drizzled;
41
36
 
42
 
InnodbSysTablesTool::InnodbSysTablesTool() :
43
 
  plugin::TableFunction("DATA_DICTIONARY", "INNODB_SYS_TABLES")
44
 
{
45
 
  add_field("TABLE_ID", plugin::TableFunction::NUMBER, 0, false);
46
 
  add_field("NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
47
 
  add_field("FLAG", plugin::TableFunction::NUMBER, 0, false);
48
 
  add_field("N_COLS", plugin::TableFunction::NUMBER, 0, false);
49
 
  add_field("SPACE", plugin::TableFunction::NUMBER, 0, false);
50
 
}
51
 
 
52
 
InnodbSysTablesTool::Generator::Generator(Field **arg) :
53
 
  plugin::TableFunction::Generator(arg)
54
 
{
55
 
  heap= NULL;
56
 
}
57
 
 
58
 
bool InnodbSysTablesTool::Generator::populate()
59
 
{
60
 
  if (heap == NULL)
61
 
  {
62
 
    heap = mem_heap_create(1000);
63
 
    mutex_enter(&(dict_sys->mutex));
64
 
    mtr_start(&mtr);
65
 
 
66
 
    rec = dict_startscan_system(&pcur, &mtr, SYS_TABLES);
67
 
  }
68
 
  else
69
 
  {
70
 
    /* Get the next record */
71
 
    mutex_enter(&dict_sys->mutex);
72
 
    mtr_start(&mtr);
73
 
    rec = dict_getnext_system(&pcur, &mtr);
74
 
  }
75
 
 
76
 
  if (! rec)
77
 
  {
78
 
    mtr_commit(&mtr);
79
 
    mutex_exit(&dict_sys->mutex);
80
 
    mem_heap_free(heap);
81
 
    return false;
82
 
  }
83
 
 
84
 
  const char*   err_msg;
85
 
  dict_table_t* table_rec;
86
 
 
87
 
  /* Create and populate a dict_table_t structure with
88
 
     information from SYS_TABLES row */
89
 
  err_msg = dict_process_sys_tables_rec(heap, rec, &table_rec,
90
 
                                        DICT_TABLE_LOAD_FROM_RECORD);
91
 
 
92
 
  mtr_commit(&mtr);
93
 
  mutex_exit(&dict_sys->mutex);
94
 
 
95
 
  if (!err_msg) {
96
 
    push(table_rec->id);
97
 
    push(table_rec->name);
98
 
    push(static_cast<uint64_t>(table_rec->flags));
99
 
    push(static_cast<uint64_t>(table_rec->n_cols));
100
 
    push(static_cast<uint64_t>(table_rec->space));
101
 
  } else {
102
 
/*    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
103
 
                        ER_CANT_FIND_SYSTEM_REC,
104
 
                        err_msg);
105
 
*/  }
106
 
 
107
 
  /* Since dict_process_sys_tables_rec() is called with
108
 
     DICT_TABLE_LOAD_FROM_RECORD, the table_rec is created in
109
 
     dict_process_sys_tables_rec(), we will need to free it */
110
 
  if (table_rec) {
111
 
    dict_mem_table_free(table_rec);
112
 
  }
113
 
 
114
 
  mem_heap_empty(heap);
115
 
 
116
 
  return true;
117
 
}
118
 
 
119
 
InnodbSysTableStatsTool::InnodbSysTableStatsTool() :
120
 
  plugin::TableFunction("DATA_DICTIONARY", "INNODB_SYS_TABLESTATS")
121
 
{
122
 
  add_field("TABLE_ID", plugin::TableFunction::NUMBER, 0, false);
123
 
  add_field("NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
124
 
  add_field("STATS_INITIALIZED", plugin::TableFunction::STRING, NAME_LEN + 1, false);
125
 
  add_field("NUM_ROWS", plugin::TableFunction::NUMBER, 0, false);
126
 
  add_field("CLUST_INDEX_SIZE", plugin::TableFunction::NUMBER, 0, false);
127
 
  add_field("OTHER_INDEX_SIZE", plugin::TableFunction::NUMBER, 0, false);
128
 
  add_field("MODIFIED_COUNTER", plugin::TableFunction::NUMBER, 0, false);
129
 
  add_field("AUTOINC", plugin::TableFunction::NUMBER, 0, false);
130
 
  add_field("HANDLES_OPENED", plugin::TableFunction::NUMBER, 0, false);
131
 
}
132
 
 
133
 
InnodbSysTableStatsTool::Generator::Generator(Field **arg) :
134
 
  plugin::TableFunction::Generator(arg)
135
 
{
136
 
  heap= NULL;
137
 
}
138
 
 
139
 
bool InnodbSysTableStatsTool::Generator::populate()
140
 
{
141
 
  if (heap == NULL)
142
 
  {
143
 
    heap = mem_heap_create(1000);
144
 
    mutex_enter(&dict_sys->mutex);
145
 
    mtr_start(&mtr);
146
 
    rec = dict_startscan_system(&pcur, &mtr, SYS_TABLES);
147
 
  }
148
 
  else
149
 
  {
150
 
    /* Get the next record */
151
 
    mutex_enter(&dict_sys->mutex);
152
 
    mtr_start(&mtr);
153
 
    rec = dict_getnext_system(&pcur, &mtr);
154
 
  }
155
 
 
156
 
  if (!rec)
157
 
  {
158
 
    mtr_commit(&mtr);
159
 
    mutex_exit(&dict_sys->mutex);
160
 
    mem_heap_free(heap);
161
 
    return false;
162
 
  }
163
 
 
164
 
  const char*   err_msg;
165
 
  dict_table_t* table_rec;
166
 
 
167
 
  /* Fetch the dict_table_t structure corresponding to
168
 
     this SYS_TABLES record */
169
 
  err_msg = dict_process_sys_tables_rec(heap, rec, &table_rec,
170
 
                                        DICT_TABLE_LOAD_FROM_CACHE);
171
 
 
172
 
  mtr_commit(&mtr);
173
 
  mutex_exit(&dict_sys->mutex);
174
 
 
175
 
  if (!err_msg) {
176
 
    push(table_rec->id);
177
 
    push(table_rec->name);
178
 
    if (table_rec->stat_initialized)
179
 
      push("Initialized");
180
 
    else
181
 
      push("Uninitialized");
182
 
    push(table_rec->stat_n_rows);
183
 
    push(static_cast<uint64_t>(table_rec->stat_clustered_index_size));
184
 
    push(static_cast<uint64_t>(table_rec->stat_sum_of_other_index_sizes));
185
 
    push(static_cast<uint64_t>(table_rec->stat_modified_counter));
186
 
    push(table_rec->autoinc);
187
 
    push(static_cast<uint64_t>(table_rec->n_mysql_handles_opened));
188
 
  } else {
189
 
    /*    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
190
 
                        ER_CANT_FIND_SYSTEM_REC,
191
 
                        err_msg);*/
192
 
  }
193
 
 
194
 
  mem_heap_empty(heap);
195
 
 
196
 
  return true;
197
 
}
198
 
 
199
 
InnodbSysIndexesTool::InnodbSysIndexesTool() :
200
 
  plugin::TableFunction("DATA_DICTIONARY", "INNODB_SYS_INDEXES")
201
 
{
202
 
  add_field("INDEX_ID", plugin::TableFunction::NUMBER, 0, false);
203
 
  add_field("NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
204
 
  add_field("TABLE_ID", plugin::TableFunction::NUMBER, 0, false);
205
 
  add_field("TYPE", plugin::TableFunction::NUMBER, 0, false);
206
 
  add_field("N_FIELDS", plugin::TableFunction::NUMBER, 0, false);
207
 
  add_field("PAGE_NO", plugin::TableFunction::NUMBER, 0, false);
208
 
  add_field("SPACE", plugin::TableFunction::NUMBER, 0, false);
209
 
}
210
 
 
211
 
InnodbSysIndexesTool::Generator::Generator(Field **arg) :
212
 
  plugin::TableFunction::Generator(arg)
213
 
{
214
 
  heap= NULL;
215
 
}
216
 
 
217
 
bool InnodbSysIndexesTool::Generator::populate()
218
 
{
219
 
  if (heap == NULL)
220
 
  {
221
 
    heap = mem_heap_create(1000);
222
 
    mutex_enter(&dict_sys->mutex);
223
 
    mtr_start(&mtr);
224
 
 
225
 
    /* Start scan the SYS_INDEXES table */
226
 
    rec = dict_startscan_system(&pcur, &mtr, SYS_INDEXES);
227
 
  }
228
 
  else
229
 
  {
230
 
    /* Get the next record */
231
 
    mutex_enter(&dict_sys->mutex);
232
 
    mtr_start(&mtr);
233
 
    rec = dict_getnext_system(&pcur, &mtr);
234
 
  }
235
 
 
236
 
  if (! rec)
237
 
  {
238
 
    mtr_commit(&mtr);
239
 
    mutex_exit(&dict_sys->mutex);
240
 
    mem_heap_free(heap);
241
 
    return false;
242
 
  }
243
 
 
244
 
  const char*   err_msg;;
245
 
  table_id_t    table_id;
246
 
  dict_index_t  index_rec;
247
 
 
248
 
  /* Populate a dict_index_t structure with information from
249
 
     a SYS_INDEXES row */
250
 
  err_msg = dict_process_sys_indexes_rec(heap, rec, &index_rec,
251
 
                                         &table_id);
252
 
 
253
 
  mtr_commit(&mtr);
254
 
  mutex_exit(&dict_sys->mutex);
255
 
  if (!err_msg) {
256
 
    push(index_rec.id);
257
 
    push(index_rec.name);
258
 
    push(static_cast<uint64_t>(table_id));
259
 
    push(static_cast<uint64_t>(index_rec.type));
260
 
    push(static_cast<uint64_t>(index_rec.n_fields));
261
 
    push(static_cast<uint64_t>(index_rec.page));
262
 
    push(static_cast<uint64_t>(index_rec.space));
263
 
  } else {
264
 
/*    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
265
 
                        ER_CANT_FIND_SYSTEM_REC,
266
 
                        err_msg);*/
267
 
  }
268
 
 
269
 
  mem_heap_empty(heap);
270
 
 
271
 
  if (!rec)
272
 
  {
273
 
    mtr_commit(&mtr);
274
 
    mutex_exit(&dict_sys->mutex);
275
 
    mem_heap_free(heap);
276
 
    return false;
277
 
  }
278
 
 
279
 
  return true;
280
 
}
281
 
 
282
 
InnodbSysColumnsTool::InnodbSysColumnsTool() :
283
 
  plugin::TableFunction("DATA_DICTIONARY", "INNODB_SYS_COLUMNS")
284
 
{
285
 
  add_field("TABLE_ID", plugin::TableFunction::NUMBER, 0, false);
286
 
  add_field("NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
287
 
  add_field("POS", plugin::TableFunction::NUMBER, 0, false);
288
 
  add_field("MTYPE", plugin::TableFunction::NUMBER, 0, false);
289
 
  add_field("PRTYPE", plugin::TableFunction::NUMBER, 0, false);
290
 
  add_field("LEN", plugin::TableFunction::NUMBER, 0, false);
291
 
}
292
 
 
293
 
InnodbSysColumnsTool::Generator::Generator(Field **arg) :
294
 
  plugin::TableFunction::Generator(arg)
295
 
{
296
 
  heap= NULL;
297
 
}
298
 
 
299
 
bool InnodbSysColumnsTool::Generator::populate()
300
 
{
301
 
  if (heap == NULL)
302
 
  {
303
 
    heap = mem_heap_create(1000);
304
 
    mutex_enter(&dict_sys->mutex);
305
 
    mtr_start(&mtr);
306
 
    rec = dict_startscan_system(&pcur, &mtr, SYS_COLUMNS);
307
 
  }
308
 
  else
309
 
  {
310
 
    /* Get the next record */
311
 
    mutex_enter(&dict_sys->mutex);
312
 
    mtr_start(&mtr);
313
 
    rec = dict_getnext_system(&pcur, &mtr);
314
 
  }
315
 
 
316
 
  if (! rec)
317
 
  {
318
 
    mtr_commit(&mtr);
319
 
    mutex_exit(&dict_sys->mutex);
320
 
    mem_heap_free(heap);
321
 
    return false;
322
 
  }
323
 
 
324
 
  const char*   err_msg;
325
 
  dict_col_t    column_rec;
326
 
  table_id_t    table_id;
327
 
  const char*   col_name;
328
 
 
329
 
  /* populate a dict_col_t structure with information from
330
 
     a SYS_COLUMNS row */
331
 
  err_msg = dict_process_sys_columns_rec(heap, rec, &column_rec,
332
 
                                                       &table_id, &col_name);
333
 
 
334
 
  mtr_commit(&mtr);
335
 
  mutex_exit(&dict_sys->mutex);
336
 
 
337
 
  if (!err_msg) {
338
 
    push(table_id);
339
 
    push(col_name);
340
 
    push(static_cast<uint64_t>(column_rec.ind));
341
 
    push(static_cast<uint64_t>(column_rec.mtype));
342
 
    push(static_cast<uint64_t>(column_rec.prtype));
343
 
    push(static_cast<uint64_t>(column_rec.len));
344
 
  } else {
345
 
/*    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
346
 
                        ER_CANT_FIND_SYSTEM_REC,
347
 
                        err_msg);*/
348
 
  }
349
 
 
350
 
  mem_heap_empty(heap);
351
 
 
352
 
  return true;
353
 
}
354
 
 
355
 
InnodbSysFieldsTool::InnodbSysFieldsTool() :
356
 
  plugin::TableFunction("DATA_DICTIONARY", "INNODB_SYS_FIELDS")
357
 
{
358
 
  add_field("INDEX_ID", plugin::TableFunction::NUMBER, 0, false);
359
 
  add_field("NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
360
 
  add_field("POS", plugin::TableFunction::NUMBER, 0, false);
361
 
}
362
 
 
363
 
InnodbSysFieldsTool::Generator::Generator(Field **arg) :
364
 
  plugin::TableFunction::Generator(arg)
365
 
{
366
 
  heap= NULL;
367
 
}
368
 
 
369
 
bool InnodbSysFieldsTool::Generator::populate()
370
 
{
371
 
  if (heap == NULL)
372
 
  {
373
 
    heap = mem_heap_create(1000);
374
 
    mutex_enter(&dict_sys->mutex);
375
 
    mtr_start(&mtr);
376
 
 
377
 
    /* will save last index id so that we know whether we move to
378
 
       the next index. This is used to calculate prefix length */
379
 
    last_id = 0;
380
 
 
381
 
    rec = dict_startscan_system(&pcur, &mtr, SYS_FIELDS);
382
 
  }
383
 
  else
384
 
  {
385
 
    /* Get the next record */
386
 
    mutex_enter(&dict_sys->mutex);
387
 
    mtr_start(&mtr);
388
 
    rec = dict_getnext_system(&pcur, &mtr);
389
 
  }
390
 
 
391
 
  if (! rec)
392
 
  {
393
 
    mtr_commit(&mtr);
394
 
    mutex_exit(&dict_sys->mutex);
395
 
    mem_heap_free(heap);
396
 
 
397
 
    return false;
398
 
  }
399
 
 
400
 
  ulint         pos;
401
 
  const char*   err_msg;
402
 
  index_id_t    index_id;
403
 
  dict_field_t  field_rec;
404
 
 
405
 
  /* Populate a dict_field_t structure with information from
406
 
     a SYS_FIELDS row */
407
 
  err_msg = dict_process_sys_fields_rec(heap, rec, &field_rec,
408
 
                                        &pos, &index_id, last_id);
409
 
 
410
 
  mtr_commit(&mtr);
411
 
  mutex_exit(&dict_sys->mutex);
412
 
 
413
 
  if (!err_msg) {
414
 
    push(index_id);
415
 
    push(field_rec.name);
416
 
    push(static_cast<uint64_t>(pos));
417
 
 
418
 
    last_id = index_id;
419
 
  } else {
420
 
/*    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
421
 
                        ER_CANT_FIND_SYSTEM_REC,
422
 
                        err_msg);*/
423
 
  }
424
 
 
425
 
  mem_heap_empty(heap);
426
 
 
427
 
  return true;
428
 
}
429
 
 
430
 
InnodbSysForeignTool::InnodbSysForeignTool() :
431
 
  plugin::TableFunction("DATA_DICTIONARY", "INNODB_SYS_FOREIGN")
432
 
{
433
 
  add_field("ID", plugin::TableFunction::STRING, NAME_LEN + 1, false);
434
 
  add_field("FOR_NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
435
 
  add_field("REF_NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
436
 
  add_field("N_COLS", plugin::TableFunction::NUMBER, 0, false);
437
 
  add_field("TYPE", plugin::TableFunction::NUMBER, 0, false);
438
 
}
439
 
 
440
 
InnodbSysForeignTool::Generator::Generator(Field **arg) :
441
 
  plugin::TableFunction::Generator(arg)
442
 
{
443
 
  heap= NULL;
444
 
}
445
 
 
446
 
bool InnodbSysForeignTool::Generator::populate()
447
 
{
448
 
  if (heap == NULL)
449
 
  {
450
 
    heap = mem_heap_create(1000);
451
 
    mutex_enter(&dict_sys->mutex);
452
 
    mtr_start(&mtr);
453
 
 
454
 
    rec = dict_startscan_system(&pcur, &mtr, SYS_FOREIGN);
455
 
  }
456
 
  else
457
 
  {
458
 
    /* Get the next record */
459
 
    mtr_start(&mtr);
460
 
    mutex_enter(&dict_sys->mutex);
461
 
    rec = dict_getnext_system(&pcur, &mtr);
462
 
  }
463
 
 
464
 
  if (! rec)
465
 
  {
466
 
    mtr_commit(&mtr);
467
 
    mutex_exit(&dict_sys->mutex);
468
 
    mem_heap_free(heap);
469
 
    return false;
470
 
  }
471
 
 
472
 
  const char*   err_msg;
473
 
  dict_foreign_t        foreign_rec;
474
 
 
475
 
  /* Populate a dict_foreign_t structure with information from
476
 
     a SYS_FOREIGN row */
477
 
  err_msg = dict_process_sys_foreign_rec(heap, rec, &foreign_rec);
478
 
 
479
 
  mtr_commit(&mtr);
480
 
  mutex_exit(&dict_sys->mutex);
481
 
 
482
 
  if (!err_msg) {
483
 
    push(foreign_rec.id);
484
 
    push(foreign_rec.foreign_table_name);
485
 
    push(foreign_rec.referenced_table_name);
486
 
    push(static_cast<uint64_t>(foreign_rec.n_fields));
487
 
    push(static_cast<uint64_t>(foreign_rec.type));
488
 
  } else {
489
 
/*    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
490
 
                        ER_CANT_FIND_SYSTEM_REC,
491
 
                        err_msg);
492
 
*/  }
493
 
 
494
 
  mem_heap_empty(heap);
495
 
 
496
 
  return true;
497
 
}
498
 
 
499
 
InnodbSysForeignColsTool::InnodbSysForeignColsTool() :
500
 
  plugin::TableFunction("DATA_DICTIONARY", "INNODB_SYS_FOREIGN_COLS")
501
 
{
502
 
  add_field("ID", plugin::TableFunction::STRING, NAME_LEN + 1, false);
503
 
  add_field("FOR_COL_NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
504
 
  add_field("REF_COL_NAME", plugin::TableFunction::STRING, NAME_LEN + 1, false);
505
 
  add_field("POS", plugin::TableFunction::NUMBER, 0, false);
506
 
}
507
 
 
508
 
InnodbSysForeignColsTool::Generator::Generator(Field **arg) :
509
 
  plugin::TableFunction::Generator(arg)
510
 
{
511
 
  heap= NULL;
512
 
}
513
 
 
514
 
bool InnodbSysForeignColsTool::Generator::populate()
515
 
{
516
 
  if (heap == NULL)
517
 
  {
518
 
    heap = mem_heap_create(1000);
519
 
    mutex_enter(&dict_sys->mutex);
520
 
    mtr_start(&mtr);
521
 
 
522
 
    rec = dict_startscan_system(&pcur, &mtr, SYS_FOREIGN_COLS);
523
 
  }
524
 
  else
525
 
  {
526
 
    /* Get the next record */
527
 
    mutex_enter(&dict_sys->mutex);
528
 
    mtr_start(&mtr);
529
 
    rec = dict_getnext_system(&pcur, &mtr);
530
 
  }
531
 
 
532
 
  if (! rec)
533
 
  {
534
 
    mtr_commit(&mtr);
535
 
    mutex_exit(&dict_sys->mutex);
536
 
    mem_heap_free(heap);
537
 
 
538
 
    return false;
539
 
  }
540
 
 
541
 
  const char*   err_msg;
542
 
  const char*   name;
543
 
  const char*   for_col_name;
544
 
  const char*   ref_col_name;
545
 
  ulint         pos;
546
 
 
547
 
  /* Extract necessary information from a SYS_FOREIGN_COLS row */
548
 
  err_msg = dict_process_sys_foreign_col_rec(heap, rec, &name, &for_col_name,
549
 
                                             &ref_col_name, &pos);
550
 
 
551
 
  mtr_commit(&mtr);
552
 
  mutex_exit(&dict_sys->mutex);
553
 
 
554
 
  if (!err_msg) {
555
 
    push(name);
556
 
    push(for_col_name);
557
 
    push(ref_col_name);
558
 
    push(static_cast<uint64_t>(pos));
559
 
  } else {
560
 
/*    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
561
 
                        ER_CANT_FIND_SYSTEM_REC,
562
 
                        err_msg);
563
 
*/
564
 
  }
565
 
 
566
 
  mem_heap_empty(heap);
567
 
 
568
 
  return true;
569
 
}
570
 
 
571
37
/*
572
38
 * Fill the dynamic table data_dictionary.INNODB_CMP and INNODB_CMP_RESET
573
39
 *
632
98
  plugin::TableFunction("DATA_DICTIONARY", in_reset ? "INNODB_CMPMEM_RESET" : "INNODB_CMPMEM"),
633
99
  outer_reset(in_reset)
634
100
{
635
 
  add_field("BUF_POOL", plugin::TableFunction::NUMBER, 0, false);
636
101
  add_field("PAGE_SIZE", plugin::TableFunction::NUMBER, 0, false);
637
102
  add_field("PAGES_USED", plugin::TableFunction::NUMBER, 0, false);
638
103
  add_field("PAGES_FREE", plugin::TableFunction::NUMBER, 0, false);
645
110
  record_number(0),
646
111
  inner_reset(in_reset)
647
112
{
 
113
  buf_pool_mutex_enter();
648
114
}
649
115
 
650
116
CmpmemTool::Generator::~Generator()
651
117
{
 
118
  buf_pool_mutex_exit();
652
119
}
653
120
 
654
121
bool CmpmemTool::Generator::populate()
655
122
{
656
 
  if (record_number >= (BUF_BUDDY_SIZES+1)*srv_buf_pool_instances)
 
123
  if (record_number > BUF_BUDDY_SIZES)
657
124
  {
658
125
    return false;
659
126
  }
660
127
 
661
 
  uint32_t buddy_nr= record_number % (BUF_BUDDY_SIZES+1);
662
 
  uint32_t buf_pool_nr= (record_number/(BUF_BUDDY_SIZES+1));
663
 
 
664
 
  buf_pool_t *buf_pool= buf_pool_from_array(buf_pool_nr);
665
 
 
666
 
  buf_pool_mutex_enter(buf_pool);
667
 
 
668
 
  buf_buddy_stat_t* buddy_stat = &buf_pool->buddy_stat[buddy_nr];
669
 
 
670
 
 
671
 
  push(static_cast<uint64_t>(buf_pool_nr));
672
 
  push(static_cast<uint64_t>(BUF_BUDDY_LOW << buddy_nr));
 
128
  buf_buddy_stat_t* buddy_stat = &buf_buddy_stat[record_number];
 
129
 
 
130
  push(static_cast<uint64_t>(BUF_BUDDY_LOW << record_number));
673
131
  push(static_cast<uint64_t>(buddy_stat->used));
674
 
 
675
 
 
676
 
  uint64_t pages_free= (UNIV_LIKELY(buddy_nr < BUF_BUDDY_SIZES) ? UT_LIST_GET_LEN(buf_pool->zip_free[buddy_nr]) : 0);
 
132
  uint64_t pages_free= (UNIV_LIKELY(record_number < BUF_BUDDY_SIZES) ? UT_LIST_GET_LEN(buf_pool->zip_free[record_number]) : 0);
677
133
  push(pages_free);
678
134
 
679
135
  push(buddy_stat->relocated);
686
142
    buddy_stat->relocated_usec = 0;
687
143
  }
688
144
 
689
 
  buf_pool_mutex_exit(buf_pool);
690
145
  record_number++;
691
146
 
692
147
  return true;
710
165
    add_field("TRX_WEIGHT", plugin::TableFunction::NUMBER, 0, false);
711
166
    add_field("TRX_DRIZZLE_THREAD_ID", plugin::TableFunction::NUMBER, 0, false);
712
167
    add_field("TRX_QUERY", plugin::TableFunction::STRING, TRX_I_S_TRX_QUERY_MAX_LEN, true);
713
 
    add_field("TRX_OPERATION_STATE", plugin::TableFunction::STRING, TRX_I_S_TRX_OP_STATE_MAX_LEN, true);
714
 
//    add_field("TRX_TABLES_IN_USE", plugin::TableFunction::NUMBER, 0, false);
715
 
    add_field("TRX_TABLES_LOCKED", plugin::TableFunction::NUMBER, 0, false);
716
 
    add_field("TRX_LOCK_STRUCTS", plugin::TableFunction::NUMBER, 0, false);
717
 
    add_field("TRX_LOCK_MEMORY_BYTES", plugin::TableFunction::NUMBER, 0, false);
718
 
    add_field("TRX_ROWS_LOCKED", plugin::TableFunction::NUMBER, 0, false);
719
 
    add_field("TRX_ROWS_MODIFIED", plugin::TableFunction::NUMBER, 0, false);
720
 
    add_field("TRX_CONCURRENCY_TICKETS", plugin::TableFunction::NUMBER, 0, false);
721
 
    add_field("TRX_ISOLATION_LEVEL", plugin::TableFunction::STRING, TRX_I_S_TRX_ISOLATION_LEVEL_MAX_LEN, false);
722
 
    add_field("TRX_UNIQUE_CHECKS", plugin::TableFunction::NUMBER, 0, false);
723
 
    add_field("TRX_FOREIGN_KEY_CHECKS", plugin::TableFunction::NUMBER, 0, false);
724
 
    add_field("TRX_LAST_FOREIGN_KEY_ERROR", plugin::TableFunction::STRING,
725
 
              TRX_I_S_TRX_FK_ERROR_MAX_LEN, true);
726
 
    add_field("TRX_ADAPTIVE_HASH_LATCHED", plugin::TableFunction::NUMBER, 0, false);
727
 
    add_field("TRX_ADAPTIVE_HASH_TIMEOUT", plugin::TableFunction::NUMBER, 0, false);
728
168
  }
729
169
  else if (innobase_strcasecmp(table_name, "INNODB_LOCKS") == 0)
730
170
  {
765
205
 
766
206
  trx_i_s_cache_start_read(trx_i_s_cache);
767
207
 
768
 
  if (innobase_strcasecmp(table_name, "INNODB_TRX") == 0)
769
 
    number_rows= trx_i_s_cache_get_rows_used(trx_i_s_cache, I_S_INNODB_TRX);
770
 
  else if (innobase_strcasecmp(table_name, "INNODB_LOCKS") == 0)
771
 
    number_rows= trx_i_s_cache_get_rows_used(trx_i_s_cache, I_S_INNODB_LOCKS);
772
 
  else if (innobase_strcasecmp(table_name, "INNODB_LOCK_WAITS") == 0)
773
 
    number_rows= trx_i_s_cache_get_rows_used(trx_i_s_cache, I_S_INNODB_LOCK_WAITS);
 
208
  number_rows= trx_i_s_cache_get_rows_used(trx_i_s_cache, I_S_INNODB_TRX);
774
209
 
775
210
  record_number= 0;
776
211
}
897
332
    push(static_cast<int64_t>(row->trx_weight));
898
333
    push(static_cast<uint64_t>(row->trx_mysql_thread_id));
899
334
    if (row->trx_query)
 
335
    {
900
336
      push(row->trx_query);
901
 
    else
902
 
      push();
903
 
 
904
 
    if (row->trx_operation_state)
905
 
      push(row->trx_operation_state);
906
 
    else
907
 
      push();
908
 
 
909
 
//    push(row->trx_tables_in_use);
910
 
    push(static_cast<uint64_t>(row->trx_tables_locked));
911
 
    push(static_cast<uint64_t>(row->trx_lock_structs));
912
 
    push(static_cast<uint64_t>(row->trx_lock_memory_bytes));
913
 
    push(static_cast<uint64_t>(row->trx_rows_locked));
914
 
    push(static_cast<uint64_t>(row->trx_rows_modified));
915
 
    push(static_cast<uint64_t>(row->trx_concurrency_tickets));
916
 
    push(row->trx_isolation_level);
917
 
    push(static_cast<uint64_t>(row->trx_unique_checks));
918
 
    push(static_cast<uint64_t>(row->trx_foreign_key_checks));
919
 
    if (row->trx_foreign_key_error)
920
 
      push(row->trx_foreign_key_error);
921
 
    else
922
 
      push();
923
 
 
924
 
    push(static_cast<uint64_t>(row->trx_has_search_latch));
925
 
    push(static_cast<uint64_t>(row->trx_search_latch_timeout));
 
337
    }
 
338
    else
 
339
    {
 
340
      push();
 
341
    }
926
342
}
927
343
 
928
344
void InnodbTrxTool::Generator::populate_innodb_lock_waits()