diff options
Diffstat (limited to 'storage/perfschema/pfs_engine_table.cc')
| -rw-r--r-- | storage/perfschema/pfs_engine_table.cc | 281 |
1 files changed, 185 insertions, 96 deletions
diff --git a/storage/perfschema/pfs_engine_table.cc b/storage/perfschema/pfs_engine_table.cc index 304e837fa84..8f6f0fa3bcd 100644 --- a/storage/perfschema/pfs_engine_table.cc +++ b/storage/perfschema/pfs_engine_table.cc @@ -20,6 +20,7 @@ #include "my_global.h" #include "my_pthread.h" +#include "hostname.h" /* For Host_entry */ #include "pfs_engine_table.h" #include "table_events_waits.h" @@ -69,6 +70,8 @@ #include "table_socket_instances.h" #include "table_socket_summary_by_instance.h" #include "table_socket_summary_by_event_name.h" +#include "table_session_connect_attrs.h" +#include "table_session_account_connect_attrs.h" /* For show status */ #include "pfs_column_values.h" @@ -145,6 +148,8 @@ static PFS_engine_table_share *all_shares[]= &table_socket_instances::m_share, &table_socket_summary_by_instance::m_share, &table_socket_summary_by_event_name::m_share, + &table_session_connect_attrs::m_share, + &table_session_account_connect_attrs::m_share, NULL }; @@ -683,20 +688,22 @@ PFS_unknown_acl pfs_unknown_acl; ACL_internal_access_result PFS_unknown_acl::check(ulong want_access, ulong *save_priv) const { - const ulong always_forbidden= INSERT_ACL | UPDATE_ACL | DELETE_ACL - | CREATE_ACL | REFERENCES_ACL | INDEX_ACL | ALTER_ACL - | CREATE_VIEW_ACL | TRIGGER_ACL | LOCK_TABLES_ACL; + const ulong always_forbidden= CREATE_ACL + | REFERENCES_ACL | INDEX_ACL | ALTER_ACL + | CREATE_VIEW_ACL | TRIGGER_ACL; if (unlikely(want_access & always_forbidden)) return ACL_INTERNAL_ACCESS_DENIED; /* - There is no point in hidding (by enforcing ACCESS_DENIED for SELECT_ACL + There is no point in hiding (by enforcing ACCESS_DENIED for SELECT_ACL on performance_schema.*) tables that do not exist anyway. When SELECT_ACL is granted on performance_schema.* or *.*, SELECT * from performance_schema.wrong_table will fail with a more understandable ER_NO_SUCH_TABLE error, instead of ER_TABLEACCESS_DENIED_ERROR. + The same goes for other DML (INSERT_ACL | UPDATE_ACL | DELETE_ACL), + for ease of use: error messages will be less surprising. */ return ACL_INTERNAL_ACCESS_CHECK_GRANT; } @@ -978,363 +985,445 @@ bool pfs_show_status(handlerton *hton, THD *thd, total_memory+= size; break; case 56: - name= "events_waits_summary_global_by_event_name.row_size"; - size= sizeof(PFS_single_stat); - break; - case 57: - name= "events_waits_summary_global_by_event_name.row_count"; - size= wait_class_max; - break; - case 58: - name= "events_waits_summary_global_by_event_name.memory"; - size= wait_class_max * sizeof(PFS_single_stat); - total_memory+= size; - break; - case 59: name= "(pfs_account).row_size"; size= sizeof(PFS_account); break; - case 60: + case 57: name= "(pfs_account).row_count"; size= account_max; break; - case 61: + case 58: name= "(pfs_account).memory"; size= account_max * sizeof(PFS_account); total_memory+= size; break; - case 62: + case 59: name= "events_waits_summary_by_account_by_event_name.row_size"; size= sizeof(PFS_single_stat); break; - case 63: + case 60: name= "events_waits_summary_by_account_by_event_name.row_count"; size= account_max * wait_class_max; break; - case 64: + case 61: name= "events_waits_summary_by_account_by_event_name.memory"; size= account_max * wait_class_max * sizeof(PFS_single_stat); total_memory+= size; break; - case 65: + case 62: name= "events_waits_summary_by_user_by_event_name.row_size"; size= sizeof(PFS_single_stat); break; - case 66: + case 63: name= "events_waits_summary_by_user_by_event_name.row_count"; size= user_max * wait_class_max; break; - case 67: + case 64: name= "events_waits_summary_by_user_by_event_name.memory"; size= user_max * wait_class_max * sizeof(PFS_single_stat); total_memory+= size; break; - case 68: + case 65: name= "events_waits_summary_by_host_by_event_name.row_size"; size= sizeof(PFS_single_stat); break; - case 69: + case 66: name= "events_waits_summary_by_host_by_event_name.row_count"; size= host_max * wait_class_max; break; - case 70: + case 67: name= "events_waits_summary_by_host_by_event_name.memory"; size= host_max * wait_class_max * sizeof(PFS_single_stat); total_memory+= size; break; - case 71: + case 68: name= "(pfs_user).row_size"; size= sizeof(PFS_user); break; - case 72: + case 69: name= "(pfs_user).row_count"; size= user_max; break; - case 73: + case 70: name= "(pfs_user).memory"; size= user_max * sizeof(PFS_user); total_memory+= size; break; - case 74: + case 71: name= "(pfs_host).row_size"; size= sizeof(PFS_host); break; - case 75: + case 72: name= "(pfs_host).row_count"; size= host_max; break; - case 76: + case 73: name= "(pfs_host).memory"; size= host_max * sizeof(PFS_host); total_memory+= size; break; - case 77: + case 74: name= "(pfs_stage_class).row_size"; size= sizeof(PFS_stage_class); break; - case 78: + case 75: name= "(pfs_stage_class).row_count"; size= stage_class_max; break; - case 79: + case 76: name= "(pfs_stage_class).memory"; size= stage_class_max * sizeof(PFS_stage_class); total_memory+= size; break; - case 80: + case 77: name= "events_stages_history.row_size"; size= sizeof(PFS_events_stages); break; - case 81: + case 78: name= "events_stages_history.row_count"; size= events_stages_history_per_thread * thread_max; break; - case 82: + case 79: name= "events_stages_history.memory"; size= events_stages_history_per_thread * thread_max * sizeof(PFS_events_stages); total_memory+= size; break; - case 83: + case 80: name= "events_stages_history_long.row_size"; size= sizeof(PFS_events_stages); break; - case 84: + case 81: name= "events_stages_history_long.row_count"; size= events_stages_history_long_size; break; - case 85: + case 82: name= "events_stages_history_long.memory"; size= events_stages_history_long_size * sizeof(PFS_events_stages); total_memory+= size; break; - case 86: + case 83: name= "events_stages_summary_by_thread_by_event_name.row_size"; size= sizeof(PFS_stage_stat); break; - case 87: + case 84: name= "events_stages_summary_by_thread_by_event_name.row_count"; size= thread_max * stage_class_max; break; - case 88: + case 85: name= "events_stages_summary_by_thread_by_event_name.memory"; size= thread_max * stage_class_max * sizeof(PFS_stage_stat); total_memory+= size; break; - case 89: + case 86: name= "events_stages_summary_global_by_event_name.row_size"; size= sizeof(PFS_stage_stat); break; - case 90: + case 87: name= "events_stages_summary_global_by_event_name.row_count"; size= stage_class_max; break; - case 91: + case 88: name= "events_stages_summary_global_by_event_name.memory"; size= stage_class_max * sizeof(PFS_stage_stat); total_memory+= size; break; - case 92: + case 89: name= "events_stages_summary_by_account_by_event_name.row_size"; size= sizeof(PFS_stage_stat); break; - case 93: + case 90: name= "events_stages_summary_by_account_by_event_name.row_count"; size= account_max * stage_class_max; break; - case 94: + case 91: name= "events_stages_summary_by_account_by_event_name.memory"; size= account_max * stage_class_max * sizeof(PFS_stage_stat); total_memory+= size; break; - case 95: + case 92: name= "events_stages_summary_by_user_by_event_name.row_size"; size= sizeof(PFS_stage_stat); break; - case 96: + case 93: name= "events_stages_summary_by_user_by_event_name.row_count"; size= user_max * stage_class_max; break; - case 97: + case 94: name= "events_stages_summary_by_user_by_event_name.memory"; size= user_max * stage_class_max * sizeof(PFS_stage_stat); total_memory+= size; break; - case 98: + case 95: name= "events_stages_summary_by_host_by_event_name.row_size"; size= sizeof(PFS_stage_stat); break; - case 99: + case 96: name= "events_stages_summary_by_host_by_event_name.row_count"; size= host_max * stage_class_max; break; - case 100: + case 97: name= "events_stages_summary_by_host_by_event_name.memory"; size= host_max * stage_class_max * sizeof(PFS_stage_stat); total_memory+= size; break; - case 101: + case 98: name= "(pfs_statement_class).row_size"; size= sizeof(PFS_statement_class); break; - case 102: + case 99: name= "(pfs_statement_class).row_count"; size= statement_class_max; break; - case 103: + case 100: name= "(pfs_statement_class).memory"; size= statement_class_max * sizeof(PFS_statement_class); total_memory+= size; break; - case 104: + case 101: name= "events_statements_history.row_size"; size= sizeof(PFS_events_statements); break; - case 105: + case 102: name= "events_statements_history.row_count"; size= events_statements_history_per_thread * thread_max; break; - case 106: + case 103: name= "events_statements_history.memory"; size= events_statements_history_per_thread * thread_max * sizeof(PFS_events_statements); total_memory+= size; break; - case 107: + case 104: name= "events_statements_history_long.row_size"; size= sizeof(PFS_events_statements); break; - case 108: + case 105: name= "events_statements_history_long.row_count"; size= events_statements_history_long_size; break; - case 109: + case 106: name= "events_statements_history_long.memory"; size= events_statements_history_long_size * sizeof(PFS_events_statements); total_memory+= size; break; - case 110: + case 107: name= "events_statements_summary_by_thread_by_event_name.row_size"; size= sizeof(PFS_statement_stat); break; - case 111: + case 108: name= "events_statements_summary_by_thread_by_event_name.row_count"; size= thread_max * statement_class_max; break; - case 112: + case 109: name= "events_statements_summary_by_thread_by_event_name.memory"; size= thread_max * statement_class_max * sizeof(PFS_statement_stat); total_memory+= size; break; - case 113: + case 110: name= "events_statements_summary_global_by_event_name.row_size"; size= sizeof(PFS_statement_stat); break; - case 114: + case 111: name= "events_statements_summary_global_by_event_name.row_count"; size= statement_class_max; break; - case 115: + case 112: name= "events_statements_summary_global_by_event_name.memory"; size= statement_class_max * sizeof(PFS_statement_stat); total_memory+= size; break; - case 116: + case 113: name= "events_statements_summary_by_account_by_event_name.row_size"; size= sizeof(PFS_statement_stat); break; - case 117: + case 114: name= "events_statements_summary_by_account_by_event_name.row_count"; size= account_max * statement_class_max; break; - case 118: + case 115: name= "events_statements_summary_by_account_by_event_name.memory"; size= account_max * statement_class_max * sizeof(PFS_statement_stat); total_memory+= size; break; - case 119: + case 116: name= "events_statements_summary_by_user_by_event_name.row_size"; size= sizeof(PFS_statement_stat); break; - case 120: + case 117: name= "events_statements_summary_by_user_by_event_name.row_count"; size= user_max * statement_class_max; break; - case 121: + case 118: name= "events_statements_summary_by_user_by_event_name.memory"; size= user_max * statement_class_max * sizeof(PFS_statement_stat); total_memory+= size; break; - case 122: + case 119: name= "events_statements_summary_by_host_by_event_name.row_size"; size= sizeof(PFS_statement_stat); break; - case 123: + case 120: name= "events_statements_summary_by_host_by_event_name.row_count"; size= host_max * statement_class_max; break; - case 124: + case 121: name= "events_statements_summary_by_host_by_event_name.memory"; size= host_max * statement_class_max * sizeof(PFS_statement_stat); total_memory+= size; break; - case 125: + case 122: name= "events_statements_current.row_size"; size= sizeof(PFS_events_statements); break; - case 126: + case 123: name= "events_statements_current.row_count"; size= thread_max * statement_stack_max; break; - case 127: + case 124: name= "events_statements_current.memory"; size= thread_max * statement_stack_max * sizeof(PFS_events_statements); total_memory+= size; break; - case 128: + case 125: name= "(pfs_socket_class).row_size"; size= sizeof(PFS_socket_class); break; - case 129: + case 126: name= "(pfs_socket_class).row_count"; size= socket_class_max; break; - case 130: + case 127: name= "(pfs_socket_class).memory"; size= socket_class_max * sizeof(PFS_socket_class); total_memory+= size; break; - case 131: + case 128: name= "socket_instances.row_size"; size= sizeof(PFS_socket); break; - case 132: + case 129: name= "socket_instances.row_count"; size= socket_max; break; - case 133: + case 130: name= "socket_instances.memory"; size= socket_max * sizeof(PFS_socket); total_memory+= size; break; - case 134: + case 131: name= "events_statements_summary_by_digest.row_size"; size= sizeof(PFS_statements_digest_stat); break; - case 135: + case 132: name= "events_statements_summary_by_digest.row_count"; size= digest_max; break; - case 136: + case 133: name= "events_statements_summary_by_digest.memory"; size= digest_max * sizeof(PFS_statements_digest_stat); total_memory+= size; - break; + break; + case 134: + name= "session_connect_attrs.row_size"; + size= thread_max; + break; + case 135: + name= "session_connect_attrs.row_count"; + size= session_connect_attrs_size_per_thread; + break; + case 136: + name= "session_connect_attrs.memory"; + size= thread_max * session_connect_attrs_size_per_thread; + total_memory+= size; + break; + + case 137: + name= "(account_hash).count"; + size= account_hash.count; + break; + case 138: + name= "(account_hash).size"; + size= account_hash.size; + break; + case 139: + name= "(digest_hash).count"; + size= digest_hash.count; + break; + case 140: + name= "(digest_hash).size"; + size= digest_hash.size; + break; + case 141: + name= "(filename_hash).count"; + size= filename_hash.count; + break; + case 142: + name= "(filename_hash).size"; + size= filename_hash.size; + break; + case 143: + name= "(host_hash).count"; + size= host_hash.count; + break; + case 144: + name= "(host_hash).size"; + size= host_hash.size; + break; + case 145: + name= "(setup_actor_hash).count"; + size= setup_actor_hash.count; + break; + case 146: + name= "(setup_actor_hash).size"; + size= setup_actor_hash.size; + break; + case 147: + name= "(setup_object_hash).count"; + size= setup_object_hash.count; + break; + case 148: + name= "(setup_object_hash).size"; + size= setup_object_hash.size; + break; + case 149: + name= "(table_share_hash).count"; + size= table_share_hash.count; + break; + case 150: + name= "(table_share_hash).size"; + size= table_share_hash.size; + break; + case 151: + name= "(user_hash).count"; + size= user_hash.count; + break; + case 152: + name= "(user_hash).size"; + size= user_hash.size; + break; + case 153: + /* + This is not a performance_schema buffer, + the data is maintained in the server, + in hostname_cache. + Print the size only, there are: + - no host_cache.count + - no host_cache.memory + */ + name= "host_cache.size"; +#ifdef NOT_YET_IMPLEMENTED + size= sizeof(Host_entry); +#else + size= 0; +#endif + break; + /* This case must be last, for aggregation in total_memory. */ - case 137: + case 154: name= "performance_schema.memory"; size= total_memory; /* This will fail if something is not advertised here */ |