1 /* Copyright (c) 2010, 2021, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
22
23 /**
24 @file storage/perfschema/table_helper.cc
25 Performance schema table helpers (implementation).
26 */
27
28 #include "my_global.h"
29 #include "my_thread.h"
30 #include "pfs_engine_table.h"
31 #include "table_helper.h"
32 #include "pfs_host.h"
33 #include "pfs_user.h"
34 #include "pfs_account.h"
35 #include "pfs_instr.h"
36 #include "pfs_program.h"
37 #include "field.h"
38 #include "pfs_variable.h"
39
make_row(PFS_host * pfs)40 int PFS_host_row::make_row(PFS_host *pfs)
41 {
42 m_hostname_length= pfs->m_hostname_length;
43 if (m_hostname_length > sizeof(m_hostname))
44 return 1;
45 if (m_hostname_length > 0)
46 memcpy(m_hostname, pfs->m_hostname, sizeof(m_hostname));
47 return 0;
48 }
49
set_field(Field * f)50 void PFS_host_row::set_field(Field *f)
51 {
52 if (m_hostname_length > 0)
53 PFS_engine_table::set_field_char_utf8(f, m_hostname, m_hostname_length);
54 else
55 f->set_null();
56 }
57
make_row(PFS_user * pfs)58 int PFS_user_row::make_row(PFS_user *pfs)
59 {
60 m_username_length= pfs->m_username_length;
61 if (m_username_length > sizeof(m_username))
62 return 1;
63 if (m_username_length > 0)
64 memcpy(m_username, pfs->m_username, sizeof(m_username));
65 return 0;
66 }
67
set_field(Field * f)68 void PFS_user_row::set_field(Field *f)
69 {
70 if (m_username_length > 0)
71 PFS_engine_table::set_field_char_utf8(f, m_username, m_username_length);
72 else
73 f->set_null();
74 }
75
make_row(PFS_account * pfs)76 int PFS_account_row::make_row(PFS_account *pfs)
77 {
78 m_username_length= pfs->m_username_length;
79 if (m_username_length > sizeof(m_username))
80 return 1;
81 if (m_username_length > 0)
82 memcpy(m_username, pfs->m_username, sizeof(m_username));
83
84 m_hostname_length= pfs->m_hostname_length;
85 if (m_hostname_length > sizeof(m_hostname))
86 return 1;
87 if (m_hostname_length > 0)
88 memcpy(m_hostname, pfs->m_hostname, sizeof(m_hostname));
89
90 return 0;
91 }
92
set_field(uint index,Field * f)93 void PFS_account_row::set_field(uint index, Field *f)
94 {
95 switch (index)
96 {
97 case 0: /* USER */
98 if (m_username_length > 0)
99 PFS_engine_table::set_field_char_utf8(f, m_username, m_username_length);
100 else
101 f->set_null();
102 break;
103 case 1: /* HOST */
104 if (m_hostname_length > 0)
105 PFS_engine_table::set_field_char_utf8(f, m_hostname, m_hostname_length);
106 else
107 f->set_null();
108 break;
109 default:
110 assert(false);
111 break;
112 }
113 }
114
make_row(PFS_statements_digest_stat * pfs)115 int PFS_digest_row::make_row(PFS_statements_digest_stat* pfs)
116 {
117 m_schema_name_length= pfs->m_digest_key.m_schema_name_length;
118 if (m_schema_name_length > sizeof(m_schema_name))
119 m_schema_name_length= 0;
120 if (m_schema_name_length > 0)
121 memcpy(m_schema_name, pfs->m_digest_key.m_schema_name, m_schema_name_length);
122
123 size_t safe_byte_count= pfs->m_digest_storage.m_byte_count;
124 if (safe_byte_count > pfs_max_digest_length)
125 safe_byte_count= 0;
126
127 /*
128 "0" value for byte_count indicates special entry i.e. aggregated
129 stats at index 0 of statements_digest_stat_array. So do not calculate
130 digest/digest_text as it should always be "NULL".
131 */
132 if (safe_byte_count > 0)
133 {
134 /*
135 Calculate digest from MD5 HASH collected to be shown as
136 DIGEST in this row.
137 */
138 MD5_HASH_TO_STRING(pfs->m_digest_storage.m_md5, m_digest);
139 m_digest_length= MD5_HASH_TO_STRING_LENGTH;
140
141 /*
142 Calculate digest_text information from the token array collected
143 to be shown as DIGEST_TEXT column.
144 */
145 compute_digest_text(&pfs->m_digest_storage, &m_digest_text);
146
147 if (m_digest_text.length() == 0)
148 m_digest_length= 0;
149 }
150 else
151 {
152 m_digest_length= 0;
153 }
154
155 return 0;
156 }
157
set_field(uint index,Field * f)158 void PFS_digest_row::set_field(uint index, Field *f)
159 {
160 switch (index)
161 {
162 case 0: /* SCHEMA_NAME */
163 if (m_schema_name_length > 0)
164 PFS_engine_table::set_field_varchar_utf8(f, m_schema_name,
165 m_schema_name_length);
166 else
167 f->set_null();
168 break;
169 case 1: /* DIGEST */
170 if (m_digest_length > 0)
171 PFS_engine_table::set_field_varchar_utf8(f, m_digest,
172 m_digest_length);
173 else
174 f->set_null();
175 break;
176 case 2: /* DIGEST_TEXT */
177 if (m_digest_text.length() > 0)
178 PFS_engine_table::set_field_longtext_utf8(f, m_digest_text.ptr(),
179 m_digest_text.length());
180 else
181 f->set_null();
182 break;
183 default:
184 assert(false);
185 break;
186 }
187 }
188
make_row(PFS_table_share * pfs)189 int PFS_object_row::make_row(PFS_table_share *pfs)
190 {
191 m_object_type= pfs->get_object_type();
192
193 m_schema_name_length= pfs->m_schema_name_length;
194 if (m_schema_name_length > sizeof(m_schema_name))
195 return 1;
196 if (m_schema_name_length > 0)
197 memcpy(m_schema_name, pfs->m_schema_name, sizeof(m_schema_name));
198
199 m_object_name_length= pfs->m_table_name_length;
200 if (m_object_name_length > sizeof(m_object_name))
201 return 1;
202 if (m_object_name_length > 0)
203 memcpy(m_object_name, pfs->m_table_name, sizeof(m_object_name));
204
205 return 0;
206 }
207
make_row(PFS_program * pfs)208 int PFS_object_row::make_row(PFS_program *pfs)
209 {
210 m_object_type= pfs->m_type;
211
212 m_schema_name_length= pfs->m_schema_name_length;
213 if (m_schema_name_length > sizeof(m_schema_name))
214 return 1;
215 if (m_schema_name_length > 0)
216 memcpy(m_schema_name, pfs->m_schema_name, sizeof(m_schema_name));
217
218 m_object_name_length= pfs->m_object_name_length;
219 if (m_object_name_length > sizeof(m_object_name))
220 return 1;
221 if (m_object_name_length > 0)
222 memcpy(m_object_name, pfs->m_object_name, sizeof(m_object_name));
223
224 return 0;
225 }
226
make_row(const MDL_key * mdl)227 int PFS_object_row::make_row(const MDL_key *mdl)
228 {
229 switch(mdl->mdl_namespace())
230 {
231 case MDL_key::GLOBAL:
232 m_object_type= OBJECT_TYPE_GLOBAL;
233 m_schema_name_length= 0;
234 m_object_name_length= 0;
235 break;
236 case MDL_key::BACKUP:
237 m_object_type= OBJECT_TYPE_BACKUP;
238 m_schema_name_length= 0;
239 m_object_name_length= 0;
240 break;
241 case MDL_key::SCHEMA:
242 m_object_type= OBJECT_TYPE_SCHEMA;
243 m_schema_name_length= mdl->db_name_length();
244 m_object_name_length= 0;
245 break;
246 case MDL_key::TABLE:
247 m_object_type= OBJECT_TYPE_TABLE;
248 m_schema_name_length= mdl->db_name_length();
249 m_object_name_length= mdl->name_length();
250 break;
251 case MDL_key::FUNCTION:
252 m_object_type= OBJECT_TYPE_FUNCTION;
253 m_schema_name_length= mdl->db_name_length();
254 m_object_name_length= mdl->name_length();
255 break;
256 case MDL_key::PROCEDURE:
257 m_object_type= OBJECT_TYPE_PROCEDURE;
258 m_schema_name_length= mdl->db_name_length();
259 m_object_name_length= mdl->name_length();
260 break;
261 case MDL_key::TRIGGER:
262 m_object_type= OBJECT_TYPE_TRIGGER;
263 m_schema_name_length= mdl->db_name_length();
264 m_object_name_length= mdl->name_length();
265 break;
266 case MDL_key::EVENT:
267 m_object_type= OBJECT_TYPE_EVENT;
268 m_schema_name_length= mdl->db_name_length();
269 m_object_name_length= mdl->name_length();
270 break;
271 case MDL_key::COMMIT:
272 m_object_type= OBJECT_TYPE_COMMIT;
273 m_schema_name_length= 0;
274 m_object_name_length= 0;
275 break;
276 case MDL_key::USER_LEVEL_LOCK:
277 m_object_type= OBJECT_TYPE_USER_LEVEL_LOCK;
278 m_schema_name_length= 0;
279 m_object_name_length= mdl->name_length();
280 break;
281 case MDL_key::BINLOG:
282 m_object_type= OBJECT_TYPE_BINLOG;
283 m_schema_name_length= 0;
284 m_object_name_length= 0;
285 break;
286 case MDL_key::TABLESPACE:
287 m_object_type= OBJECT_TYPE_TABLESPACE;
288 m_schema_name_length= 0;
289 m_object_name_length= mdl->name_length();
290 break;
291 case MDL_key::LOCKING_SERVICE:
292 m_object_type= OBJECT_TYPE_LOCKING_SERVICE;
293 m_schema_name_length= mdl->db_name_length();
294 m_object_name_length= mdl->name_length();
295 break;
296 case MDL_key::NAMESPACE_END:
297 default:
298 m_object_type= NO_OBJECT_TYPE;
299 m_schema_name_length= 0;
300 m_object_name_length= 0;
301 break;
302 }
303
304 if (m_schema_name_length > sizeof(m_schema_name))
305 return 1;
306 if (m_schema_name_length > 0)
307 memcpy(m_schema_name, mdl->db_name(), m_schema_name_length);
308
309 if (m_object_name_length > sizeof(m_object_name))
310 return 1;
311 if (m_object_name_length > 0)
312 memcpy(m_object_name, mdl->name(), m_object_name_length);
313
314 return 0;
315 }
316
set_field(uint index,Field * f)317 void PFS_object_row::set_field(uint index, Field *f)
318 {
319 switch(index)
320 {
321 case 0: /* OBJECT_TYPE */
322 set_field_object_type(f, m_object_type);
323 break;
324 case 1: /* SCHEMA_NAME */
325 PFS_engine_table::set_field_varchar_utf8(f, m_schema_name, m_schema_name_length);
326 break;
327 case 2: /* OBJECT_NAME */
328 PFS_engine_table::set_field_varchar_utf8(f, m_object_name, m_object_name_length);
329 break;
330 default:
331 assert(false);
332 }
333 }
334
set_nullable_field(uint index,Field * f)335 void PFS_object_row::set_nullable_field(uint index, Field *f)
336 {
337 switch(index)
338 {
339 case 0: /* OBJECT_TYPE */
340 if (m_object_type != NO_OBJECT_TYPE)
341 set_field_object_type(f, m_object_type);
342 else
343 f->set_null();
344 break;
345 case 1: /* SCHEMA_NAME */
346 if (m_schema_name_length > 0)
347 PFS_engine_table::set_field_varchar_utf8(f, m_schema_name, m_schema_name_length);
348 else
349 f->set_null();
350 break;
351 case 2: /* OBJECT_NAME */
352 if (m_object_name_length > 0)
353 PFS_engine_table::set_field_varchar_utf8(f, m_object_name, m_object_name_length);
354 else
355 f->set_null();
356 break;
357 default:
358 assert(false);
359 }
360 }
361
make_row(PFS_table_share * pfs,PFS_table_share_index * pfs_index,uint table_index)362 int PFS_index_row::make_row(PFS_table_share *pfs,
363 PFS_table_share_index *pfs_index,
364 uint table_index)
365 {
366 if (m_object_row.make_row(pfs))
367 return 1;
368
369 if (pfs_index == NULL)
370 {
371 if (table_index < MAX_INDEXES)
372 {
373 m_index_name_length= sprintf(m_index_name, "(index %d)", table_index);
374 }
375 else
376 {
377 m_index_name_length= 0;
378 }
379 return 0;
380 }
381
382 if (table_index < MAX_INDEXES)
383 {
384 m_index_name_length= pfs_index->m_key.m_name_length;
385 if (m_index_name_length > sizeof(m_index_name))
386 return 1;
387
388 memcpy(m_index_name, pfs_index->m_key.m_name, sizeof(m_index_name));
389 }
390 else
391 {
392 m_index_name_length= 0;
393 }
394
395 return 0;
396 }
397
set_field(uint index,Field * f)398 void PFS_index_row::set_field(uint index, Field *f)
399 {
400 switch(index)
401 {
402 case 0: /* OBJECT_TYPE */
403 case 1: /* SCHEMA_NAME */
404 case 2: /* OBJECT_NAME */
405 m_object_row.set_field(index, f);
406 break;
407 case 3: /* INDEX_NAME */
408 if (m_index_name_length > 0)
409 PFS_engine_table::set_field_varchar_utf8(f, m_index_name, m_index_name_length);
410 else
411 f->set_null();
412 break;
413 default:
414 assert(false);
415 }
416 }
417
set_field(uint index,Field * f)418 void PFS_statement_stat_row::set_field(uint index, Field *f)
419 {
420 switch (index)
421 {
422 case 0: /* COUNT_STAR */
423 case 1: /* SUM_TIMER_WAIT */
424 case 2: /* MIN_TIMER_WAIT */
425 case 3: /* AVG_TIMER_WAIT */
426 case 4: /* MAX_TIMER_WAIT */
427 m_timer1_row.set_field(index, f);
428 break;
429 case 5: /* SUM_LOCK_TIME */
430 PFS_engine_table::set_field_ulonglong(f, m_lock_time);
431 break;
432 case 6: /* SUM_ERRORS */
433 PFS_engine_table::set_field_ulonglong(f, m_error_count);
434 break;
435 case 7: /* SUM_WARNINGS */
436 PFS_engine_table::set_field_ulonglong(f, m_warning_count);
437 break;
438 case 8: /* SUM_ROWS_AFFECTED */
439 PFS_engine_table::set_field_ulonglong(f, m_rows_affected);
440 break;
441 case 9: /* SUM_ROWS_SENT */
442 PFS_engine_table::set_field_ulonglong(f, m_rows_sent);
443 break;
444 case 10: /* SUM_ROWS_EXAMINED */
445 PFS_engine_table::set_field_ulonglong(f, m_rows_examined);
446 break;
447 case 11: /* SUM_CREATED_TMP_DISK_TABLES */
448 PFS_engine_table::set_field_ulonglong(f, m_created_tmp_disk_tables);
449 break;
450 case 12: /* SUM_CREATED_TMP_TABLES */
451 PFS_engine_table::set_field_ulonglong(f, m_created_tmp_tables);
452 break;
453 case 13: /* SUM_SELECT_FULL_JOIN */
454 PFS_engine_table::set_field_ulonglong(f, m_select_full_join);
455 break;
456 case 14: /* SUM_SELECT_FULL_RANGE_JOIN */
457 PFS_engine_table::set_field_ulonglong(f, m_select_full_range_join);
458 break;
459 case 15: /* SUM_SELECT_RANGE */
460 PFS_engine_table::set_field_ulonglong(f, m_select_range);
461 break;
462 case 16: /* SUM_SELECT_RANGE_CHECK */
463 PFS_engine_table::set_field_ulonglong(f, m_select_range_check);
464 break;
465 case 17: /* SUM_SELECT_SCAN */
466 PFS_engine_table::set_field_ulonglong(f, m_select_scan);
467 break;
468 case 18: /* SUM_SORT_MERGE_PASSES */
469 PFS_engine_table::set_field_ulonglong(f, m_sort_merge_passes);
470 break;
471 case 19: /* SUM_SORT_RANGE */
472 PFS_engine_table::set_field_ulonglong(f, m_sort_range);
473 break;
474 case 20: /* SUM_SORT_ROWS */
475 PFS_engine_table::set_field_ulonglong(f, m_sort_rows);
476 break;
477 case 21: /* SUM_SORT_SCAN */
478 PFS_engine_table::set_field_ulonglong(f, m_sort_scan);
479 break;
480 case 22: /* SUM_NO_INDEX_USED */
481 PFS_engine_table::set_field_ulonglong(f, m_no_index_used);
482 break;
483 case 23: /* SUM_NO_GOOD_INDEX_USED */
484 PFS_engine_table::set_field_ulonglong(f, m_no_good_index_used);
485 break;
486 default:
487 assert(false);
488 break;
489 }
490 }
491
set_field(uint index,Field * f)492 void PFS_transaction_stat_row::set_field(uint index, Field *f)
493 {
494 switch (index)
495 {
496 case 0: /* COUNT_STAR */
497 case 1: /* SUM_TIMER_WAIT */
498 case 2: /* MIN_TIMER_WAIT */
499 case 3: /* AVG_TIMER_WAIT */
500 case 4: /* MAX_TIMER_WAIT */
501 m_timer1_row.set_field(index, f);
502 break;
503 case 5: /* COUNT_READ_WRITE */
504 case 6: /* SUM_TIMER_READ_WRITE */
505 case 7: /* MIN_TIMER_READ_WRITE */
506 case 8: /* AVG_TIMER_READ_WRITE */
507 case 9: /* MAX_TIMER_READ_WRITE */
508 m_read_write_row.set_field(index-5, f);
509 break;
510 case 10: /* COUNT_READ_ONLY */
511 case 11: /* SUM_TIMER_READ_ONLY */
512 case 12: /* MIN_TIMER_READ_ONLY */
513 case 13: /* AVG_TIMER_READ_ONLY */
514 case 14: /* MAX_TIMER_READ_ONLY */
515 m_read_only_row.set_field(index-10, f);
516 break;
517 default:
518 assert(false);
519 break;
520 }
521 }
522
set_field(uint index,Field * f)523 void PFS_connection_stat_row::set_field(uint index, Field *f)
524 {
525 switch (index)
526 {
527 case 0: /* CURRENT_CONNECTIONS */
528 PFS_engine_table::set_field_ulonglong(f, m_current_connections);
529 break;
530 case 1: /* TOTAL_CONNECTIONS */
531 PFS_engine_table::set_field_ulonglong(f, m_total_connections);
532 break;
533 default:
534 assert(false);
535 break;
536 }
537 }
538
set_field_object_type(Field * f,enum_object_type object_type)539 void set_field_object_type(Field *f, enum_object_type object_type)
540 {
541 switch (object_type)
542 {
543 case OBJECT_TYPE_EVENT:
544 PFS_engine_table::set_field_varchar_utf8(f, "EVENT", 5);
545 break;
546 case OBJECT_TYPE_FUNCTION:
547 PFS_engine_table::set_field_varchar_utf8(f, "FUNCTION", 8);
548 break;
549 case OBJECT_TYPE_PROCEDURE:
550 PFS_engine_table::set_field_varchar_utf8(f, "PROCEDURE", 9);
551 break;
552 case OBJECT_TYPE_TABLE:
553 PFS_engine_table::set_field_varchar_utf8(f, "TABLE", 5);
554 break;
555 case OBJECT_TYPE_TEMPORARY_TABLE:
556 PFS_engine_table::set_field_varchar_utf8(f, "TEMPORARY TABLE", 15);
557 break;
558 case OBJECT_TYPE_TRIGGER:
559 PFS_engine_table::set_field_varchar_utf8(f, "TRIGGER", 7);
560 break;
561 case OBJECT_TYPE_GLOBAL:
562 PFS_engine_table::set_field_varchar_utf8(f, "GLOBAL", 6);
563 break;
564 case OBJECT_TYPE_SCHEMA:
565 PFS_engine_table::set_field_varchar_utf8(f, "SCHEMA", 6);
566 break;
567 case OBJECT_TYPE_COMMIT:
568 PFS_engine_table::set_field_varchar_utf8(f, "COMMIT", 6);
569 break;
570 case OBJECT_TYPE_USER_LEVEL_LOCK:
571 PFS_engine_table::set_field_varchar_utf8(f, "USER LEVEL LOCK", 15);
572 break;
573 case OBJECT_TYPE_BACKUP:
574 PFS_engine_table::set_field_varchar_utf8(f, "BACKUP", 6);
575 break;
576 case OBJECT_TYPE_BINLOG:
577 PFS_engine_table::set_field_varchar_utf8(f, "BINLOG", 6);
578 break;
579 case OBJECT_TYPE_TABLESPACE:
580 PFS_engine_table::set_field_varchar_utf8(f, "TABLESPACE", 10);
581 break;
582 case OBJECT_TYPE_LOCKING_SERVICE:
583 PFS_engine_table::set_field_varchar_utf8(f, "LOCKING SERVICE", 15);
584 break;
585 case NO_OBJECT_TYPE:
586 default:
587 assert(false);
588 PFS_engine_table::set_field_varchar_utf8(f, "", 0);
589 break;
590 }
591 }
592
set_field_lock_type(Field * f,PFS_TL_LOCK_TYPE lock_type)593 void set_field_lock_type(Field *f, PFS_TL_LOCK_TYPE lock_type)
594 {
595 switch (lock_type)
596 {
597 case PFS_TL_READ:
598 PFS_engine_table::set_field_varchar_utf8(f, "READ", 4);
599 break;
600 case PFS_TL_READ_WITH_SHARED_LOCKS:
601 PFS_engine_table::set_field_varchar_utf8(f, "READ WITH SHARED LOCKS", 22);
602 break;
603 case PFS_TL_READ_HIGH_PRIORITY:
604 PFS_engine_table::set_field_varchar_utf8(f, "READ HIGH PRIORITY", 18);
605 break;
606 case PFS_TL_READ_NO_INSERT:
607 PFS_engine_table::set_field_varchar_utf8(f, "READ NO INSERT", 14);
608 break;
609 case PFS_TL_WRITE_ALLOW_WRITE:
610 PFS_engine_table::set_field_varchar_utf8(f, "WRITE ALLOW WRITE", 17);
611 break;
612 case PFS_TL_WRITE_CONCURRENT_INSERT:
613 PFS_engine_table::set_field_varchar_utf8(f, "WRITE CONCURRENT INSERT", 23);
614 break;
615 case PFS_TL_WRITE_LOW_PRIORITY:
616 PFS_engine_table::set_field_varchar_utf8(f, "WRITE LOW PRIORITY", 18);
617 break;
618 case PFS_TL_WRITE:
619 PFS_engine_table::set_field_varchar_utf8(f, "WRITE", 5);
620 break;
621 case PFS_TL_READ_EXTERNAL:
622 PFS_engine_table::set_field_varchar_utf8(f, "READ EXTERNAL", 13);
623 break;
624 case PFS_TL_WRITE_EXTERNAL:
625 PFS_engine_table::set_field_varchar_utf8(f, "WRITE EXTERNAL", 14);
626 break;
627 case PFS_TL_NONE:
628 f->set_null();
629 break;
630 default:
631 assert(false);
632 }
633 }
634
set_field_mdl_type(Field * f,opaque_mdl_type mdl_type)635 void set_field_mdl_type(Field *f, opaque_mdl_type mdl_type)
636 {
637 enum_mdl_type e= (enum_mdl_type) mdl_type;
638 switch (e)
639 {
640 case MDL_INTENTION_EXCLUSIVE:
641 PFS_engine_table::set_field_varchar_utf8(f, "INTENTION_EXCLUSIVE", 19);
642 break;
643 case MDL_SHARED:
644 PFS_engine_table::set_field_varchar_utf8(f, "SHARED", 6);
645 break;
646 case MDL_SHARED_HIGH_PRIO:
647 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_HIGH_PRIO", 16);
648 break;
649 case MDL_SHARED_READ:
650 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_READ", 11);
651 break;
652 case MDL_SHARED_WRITE:
653 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_WRITE", 12);
654 break;
655 case MDL_SHARED_WRITE_LOW_PRIO:
656 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_WRITE_LOW_PRIO", 21);
657 break;
658 case MDL_SHARED_UPGRADABLE:
659 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_UPGRADABLE", 17);
660 break;
661 case MDL_SHARED_READ_ONLY:
662 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_READ_ONLY", 16);
663 break;
664 case MDL_SHARED_NO_WRITE:
665 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_NO_WRITE", 15);
666 break;
667 case MDL_SHARED_NO_READ_WRITE:
668 PFS_engine_table::set_field_varchar_utf8(f, "SHARED_NO_READ_WRITE", 20);
669 break;
670 case MDL_EXCLUSIVE:
671 PFS_engine_table::set_field_varchar_utf8(f, "EXCLUSIVE", 9);
672 break;
673 default:
674 assert(false);
675 }
676 }
677
set_field_mdl_duration(Field * f,opaque_mdl_duration mdl_duration)678 void set_field_mdl_duration(Field *f, opaque_mdl_duration mdl_duration)
679 {
680 enum_mdl_duration e= (enum_mdl_duration) mdl_duration;
681 switch (e)
682 {
683 case MDL_STATEMENT:
684 PFS_engine_table::set_field_varchar_utf8(f, "STATEMENT", 9);
685 break;
686 case MDL_TRANSACTION:
687 PFS_engine_table::set_field_varchar_utf8(f, "TRANSACTION", 11);
688 break;
689 case MDL_EXPLICIT:
690 PFS_engine_table::set_field_varchar_utf8(f, "EXPLICIT", 8);
691 break;
692 case MDL_DURATION_END:
693 default:
694 assert(false);
695 }
696 }
697
set_field_mdl_status(Field * f,opaque_mdl_status mdl_status)698 void set_field_mdl_status(Field *f, opaque_mdl_status mdl_status)
699 {
700 MDL_ticket::enum_psi_status e=
701 static_cast<MDL_ticket::enum_psi_status>(mdl_status);
702 switch (e)
703 {
704 case MDL_ticket::PENDING:
705 PFS_engine_table::set_field_varchar_utf8(f, "PENDING", 7);
706 break;
707 case MDL_ticket::GRANTED:
708 PFS_engine_table::set_field_varchar_utf8(f, "GRANTED", 7);
709 break;
710 case MDL_ticket::PRE_ACQUIRE_NOTIFY:
711 PFS_engine_table::set_field_varchar_utf8(f, "PRE_ACQUIRE_NOTIFY", 18);
712 break;
713 case MDL_ticket::POST_RELEASE_NOTIFY:
714 PFS_engine_table::set_field_varchar_utf8(f, "POST_RELEASE_NOTIFY", 19);
715 break;
716 default:
717 assert(false);
718 }
719 }
720
set_field(uint index,Field * f)721 void PFS_memory_stat_row::set_field(uint index, Field *f)
722 {
723 ssize_t val;
724
725 switch (index)
726 {
727 case 0: /* COUNT_ALLOC */
728 PFS_engine_table::set_field_ulonglong(f, m_stat.m_alloc_count);
729 break;
730 case 1: /* COUNT_FREE */
731 PFS_engine_table::set_field_ulonglong(f, m_stat.m_free_count);
732 break;
733 case 2: /* SUM_NUMBER_OF_BYTES_ALLOC */
734 PFS_engine_table::set_field_ulonglong(f, m_stat.m_alloc_size);
735 break;
736 case 3: /* SUM_NUMBER_OF_BYTES_FREE */
737 PFS_engine_table::set_field_ulonglong(f, m_stat.m_free_size);
738 break;
739 case 4: /* LOW_COUNT_USED */
740 val= m_stat.m_alloc_count - m_stat.m_free_count - m_stat.m_free_count_capacity;
741 PFS_engine_table::set_field_longlong(f, val);
742 break;
743 case 5: /* CURRENT_COUNT_USED */
744 val= m_stat.m_alloc_count - m_stat.m_free_count;
745 PFS_engine_table::set_field_longlong(f, val);
746 break;
747 case 6: /* HIGH_COUNT_USED */
748 val= m_stat.m_alloc_count - m_stat.m_free_count + m_stat.m_alloc_count_capacity;
749 PFS_engine_table::set_field_longlong(f, val);
750 break;
751 case 7: /* LOW_NUMBER_OF_BYTES_USED */
752 val= m_stat.m_alloc_size - m_stat.m_free_size - m_stat.m_free_size_capacity;
753 PFS_engine_table::set_field_longlong(f, val);
754 break;
755 case 8: /* CURRENT_NUMBER_OF_BYTES_USED */
756 val= m_stat.m_alloc_size - m_stat.m_free_size;
757 PFS_engine_table::set_field_longlong(f, val);
758 break;
759 case 9: /* HIGH_NUMBER_OF_BYTES_USED */
760 val= m_stat.m_alloc_size - m_stat.m_free_size + m_stat.m_alloc_size_capacity;
761 PFS_engine_table::set_field_longlong(f, val);
762 break;
763 default:
764 assert(false);
765 break;
766 }
767 }
768
set_field_isolation_level(Field * f,enum_isolation_level iso_level)769 void set_field_isolation_level(Field *f, enum_isolation_level iso_level)
770 {
771 switch (iso_level)
772 {
773 case TRANS_LEVEL_READ_UNCOMMITTED:
774 PFS_engine_table::set_field_varchar_utf8(f, "READ UNCOMMITTED", 16);
775 break;
776 case TRANS_LEVEL_READ_COMMITTED:
777 PFS_engine_table::set_field_varchar_utf8(f, "READ COMMITTED", 14);
778 break;
779 case TRANS_LEVEL_REPEATABLE_READ:
780 PFS_engine_table::set_field_varchar_utf8(f, "REPEATABLE READ", 15);
781 break;
782 case TRANS_LEVEL_SERIALIZABLE:
783 PFS_engine_table::set_field_varchar_utf8(f, "SERIALIZABLE", 12);
784 break;
785 default:
786 assert(false);
787 }
788 }
789
set_field_xa_state(Field * f,enum_xa_transaction_state xa_state)790 void set_field_xa_state(Field *f, enum_xa_transaction_state xa_state)
791 {
792 switch (xa_state)
793 {
794 case TRANS_STATE_XA_NOTR:
795 PFS_engine_table::set_field_varchar_utf8(f, "NOTR", 4);
796 break;
797 case TRANS_STATE_XA_ACTIVE:
798 PFS_engine_table::set_field_varchar_utf8(f, "ACTIVE", 6);
799 break;
800 case TRANS_STATE_XA_IDLE:
801 PFS_engine_table::set_field_varchar_utf8(f, "IDLE", 4);
802 break;
803 case TRANS_STATE_XA_PREPARED:
804 PFS_engine_table::set_field_varchar_utf8(f, "PREPARED", 8);
805 break;
806 case TRANS_STATE_XA_ROLLBACK_ONLY:
807 PFS_engine_table::set_field_varchar_utf8(f, "ROLLBACK ONLY", 13);
808 break;
809 case TRANS_STATE_XA_COMMITTED:
810 PFS_engine_table::set_field_varchar_utf8(f, "COMMITTED", 9);
811 break;
812 default:
813 assert(false);
814 }
815 }
816
make_row(const char * str,size_t length)817 void PFS_variable_name_row::make_row(const char* str, size_t length)
818 {
819 assert(length <= sizeof(m_str));
820 assert(length <= NAME_CHAR_LEN);
821
822 m_length= MY_MIN(length, NAME_CHAR_LEN); /* enforce max name length */
823 if (m_length > 0)
824 memcpy(m_str, str, length);
825 m_str[m_length]= '\0';
826 }
827
make_row(const Status_variable * var)828 void PFS_variable_value_row::make_row(const Status_variable *var)
829 {
830 make_row(var->m_charset, var->m_value_str, var->m_value_length);
831 }
832
make_row(const System_variable * var)833 void PFS_variable_value_row::make_row(const System_variable *var)
834 {
835 make_row(var->m_charset, var->m_value_str, var->m_value_length);
836 }
837
make_row(const CHARSET_INFO * cs,const char * str,size_t length)838 void PFS_variable_value_row::make_row(const CHARSET_INFO *cs, const char* str, size_t length)
839 {
840 assert(cs != NULL);
841 assert(length <= sizeof(m_str));
842 if (length > 0)
843 {
844 memcpy(m_str, str, length);
845 }
846 m_length= length;
847 m_charset= cs;
848 }
849
set_field(Field * f)850 void PFS_variable_value_row::set_field(Field *f)
851 {
852 PFS_engine_table::set_field_varchar(f, m_charset, m_str, m_length);
853 }
854
clear()855 void PFS_user_variable_value_row::clear()
856 {
857 my_free(m_value);
858 m_value= NULL;
859 m_value_length= 0;
860 }
861
make_row(const char * val,size_t length)862 void PFS_user_variable_value_row::make_row(const char* val, size_t length)
863 {
864 if (length > 0)
865 {
866 m_value= (char*) my_malloc(PSI_NOT_INSTRUMENTED, length, MYF(0));
867 m_value_length= length;
868 memcpy(m_value, val, length);
869 }
870 else
871 {
872 m_value= NULL;
873 m_value_length= 0;
874 }
875 }
876
877