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