 |
MySQL 9.1.0
Source Code Documentation
|
|
MySQL 9.1.0
Source Code Documentation
|
| ►Nacl_table | |
| Nanonymous_namespace{acl_table_user.cc} | |
| CAcl_table | Base class to handle ACL table manipulation |
| CAcl_table_user_reader | Mysql.user table reader |
| CAcl_table_user_writer | |
| CAcl_table_user_writer_status | Mysql.user table writer |
| CAcl_user_attributes | Class to handle information stored in mysql.user.user_attributes |
| CPassword_lock | |
| CPod_user_what_to_update | |
| NAdaptive_flush | |
| ►Nanonymous_namespace{access_path.cc} | |
| CIteratorToBeCreated | |
| Nanonymous_namespace{arg_handler.cc} | |
| Nanonymous_namespace{audit_api_message_emit.cc} | |
| ►Nanonymous_namespace{binlog.cc} | |
| CRow_data_memory | Class to handle temporary allocation of memory for row data |
| Nanonymous_namespace{bootstrapper.cc} | |
| ►Nanonymous_namespace{certificate_generator.cc} | |
| COsslDeleter | |
| COsslDeleter< BIO > | |
| COsslDeleter< OSSL_DECODER_CTX > | |
| COsslDeleter< OSSL_ENCODER_CTX > | |
| COsslDeleter< X509_EXTENSION > | |
| Nanonymous_namespace{certifier.cc} | |
| ►Nanonymous_namespace{charset.cc} | |
| CMysys_charset_loader | |
| Nanonymous_namespace{check_stack.cc} | |
| Nanonymous_namespace{classic_command.cc} | |
| Nanonymous_namespace{classic_connect.cc} | |
| ►Nanonymous_namespace{classic_lazy_connect.cc} | |
| CFailedQueryHandler | |
| CIsTrueHandler | |
| CSelectSessionVariablesHandler | Capture the system-variables |
| ►Nanonymous_namespace{classic_query_forwarder.cc} | |
| CFailedQueryHandler | |
| CForwardedShowWarningCountHandler | |
| CForwardedShowWarningsHandler | |
| CInterceptedStatementsParser | |
| CName_string | |
| ►Nanonymous_namespace{classic_reset_connection_forwarder.cc} | |
| CFailedQueryHandler | |
| CSelectSessionVariablesHandler | Capture the system-variables |
| Nanonymous_namespace{classic_stmt_prepare_forwarder.cc} | |
| ►Nanonymous_namespace{clone0api.cc} | |
| CFixup_data | Fix schema, table and tablespace |
| Nanonymous_namespace{cluster_metadata_dynamic_state.cc} | |
| Nanonymous_namespace{cluster_metadata_gr.cc} | |
| Nanonymous_namespace{cluster_metadata_instance_attributes.cc} | |
| ►Nanonymous_namespace{collations_internal.cc} | |
| CCharset_loader | |
| Nanonymous_namespace{columns_extensions.cc} | |
| ►Nanonymous_namespace{command_mapping.cc} | |
| CCommand_maps | |
| Nanonymous_namespace{common_subexpression_elimination.cc} | |
| ►Nanonymous_namespace{composite_iterators.cc} | |
| ►CDummyIteratorProfiler | This is a no-op class with a public interface identical to that of the IteratorProfilerImpl class |
| CTimeStamp | |
| CImmutableStringHasher | Calculates a hash for an ImmutableStringWithLength so that it can be used as a key in a hash map |
| ►CMaterializeIterator | Handles materialization; the first call to Init() will scan the given iterator to the end, store the results in a temporary table (optionally with deduplication), and then Read() will allow you to read that table repeatedly without the cost of executing the given subquery many times (unless you ask for rematerialization) |
| CInvalidator | |
| ►CSpillState | Contains spill state for set operations' use of in-memory hash map |
| CCountPair | For a given chunk file pair {HF, IF}, the count of rows in each chunk respectively |
| ►Nanonymous_namespace{config_generator.cc} | |
| Caccount_exists | |
| CChangeRouterAccountPlugin | |
| CConfigSectionPrinter | |
| Cpassword_too_weak | |
| ►Nanonymous_namespace{connection_pool_plugin.cc} | |
| CConnectionPoolConfigExposer | |
| ►Nanonymous_namespace{cost_model.cc} | |
| ►CAggregateRowEstimator | This class finds disjoint sets of aggregation terms that form prefixes of some non-hash index, and makes row estimates for those sets based on index metadata |
| CPrefix | A prefix of some key where each key_part corresponds to an aggregation term |
| ►Nanonymous_namespace{ctype-czech.cc} | |
| Cwordvalue | |
| Nanonymous_namespace{ctype-utf8.cc} | |
| ►Nanonymous_namespace{ctype-win1250ch.cc} | |
| Cwordvalue | |
| Nanonymous_namespace{dd_tablespace.cc} | |
| Nanonymous_namespace{decimal.cc} | |
| ►Nanonymous_namespace{derived_keys.cc} | |
| CGetDerivedKeyResult | Result type for GetDerivedKey |
| CTableShareInfo | The set of used keys for a TABLE_SHARE |
| Nanonymous_namespace{dest_metadata_cache.cc} | |
| ►Nanonymous_namespace{destination_status_plugin.cc} | |
| CDestinationStatusConfigExposer | |
| Nanonymous_namespace{dh_ecdh_config.h} | |
| ►Nanonymous_namespace{dictionary_client.cc} | |
| CMDL_checker | Helper class providing overloaded functions asserting that we have proper MDL locks in place |
| CSPI_lru_cache_templ | |
| ►Nanonymous_namespace{dynamic_state.cc} | |
| CSchemaVersion | |
| ►Nanonymous_namespace{estimate_selectivity.cc} | |
| CKeySelectivityResult | Return type for EstimateSelectivityFromIndexStatistics() |
| ►Nanonymous_namespace{event_parse_data.cc} | |
| CSql_cmd_event | Override Sql_cmd for EVENTs to get a customization point for prepare |
| CSql_cmd_event_base | Base class which holds the Event_parse_data object |
| ►Nanonymous_namespace{explain_access_path.cc} | |
| CColumnNameCollector | Functor that can be passed to WalkItem() to collect the names of all the columns referenced by an Item |
| Nanonymous_namespace{field.cc} | Function to compare two unsigned integers for their relative order |
| ►Nanonymous_namespace{filesort.cc} | |
| CMem_compare_queue_key | |
| ►Nanonymous_namespace{filesort_utils.cc} | |
| CEquality_from_less | |
| CMem_compare | |
| CMem_compare_longkey | |
| CMem_compare_varlen_key | |
| Nanonymous_namespace{filesystem-posix.cc} | |
| Nanonymous_namespace{filesystem-windows.cc} | |
| Nanonymous_namespace{finalize_plan.cc} | |
| ►Nanonymous_namespace{gr_notifications_listener.cc} | |
| CNodeId | |
| ►Nanonymous_namespace{graph_simplification.cc} | |
| CJoinStatus | |
| ►Nanonymous_namespace{ha_mock.cc} | |
| CLoadedTables | |
| CMock_execution_context | Execution context class for the MOCK engine |
| CMock_statement_context | Statement context class for the MOCK engine |
| CMockShare | |
| Nanonymous_namespace{ha_myisammrg.cc} | |
| ►Nanonymous_namespace{handler.cc} | |
| CStorage_engine_identifier | |
| ►Nanonymous_namespace{http_auth_backend_plugin.cc} | |
| CHtpasswdPluginConfig | |
| CHttpAuthBackendConfigExposer | |
| CHttpAuthBackendFactory | |
| CPluginConfig | |
| ►Nanonymous_namespace{http_auth_realm_plugin.cc} | |
| CHttpAuthRealmConfigExposer | |
| ►Nanonymous_namespace{http_server_plugin.cc} | |
| CHttpServerConfigExposer | |
| Nanonymous_namespace{init.cc} | |
| ►Nanonymous_namespace{interesting_orders.cc} | |
| CDFSMStateEqual | |
| CDFSMStateHash | |
| ►Nanonymous_namespace{io_plugin.cc} | |
| CIoConfigExposer | |
| ►Nanonymous_namespace{item_cmpfunc.cc} | |
| CCmp_string | |
| ►Nanonymous_namespace{item_create.cc} | |
| CBin_instantiator | |
| CDatediff_instantiator | |
| CDayofweek_instantiator | |
| CEven_argcount_function_factory | |
| CFrom_unixtime_instantiator | |
| CFunction_factory | Factory for creating function objects |
| CGeometry_instantiator | |
| CInstantiator | Instantiates a function class with the list of arguments |
| CInstantiator< Function_class, 0 > | Instantiates a function class with no arguments |
| CInstantiator< Function_class, 0, 1 > | Instantiates a function class with zero or one arguments |
| CInstantiator< Function_class, 1 > | Instantiates a function class with one argument |
| CInstantiator< Function_class, 1, 2 > | Instantiates a function class with one or two arguments |
| CInstantiator< Function_class, 1, 3 > | Instantiates a function class with between one and three arguments |
| CInstantiator< Function_class, 2 > | Instantiates a function class with two arguments |
| CInstantiator< Function_class, 2, 3 > | Instantiates a function class with two or three arguments |
| CInstantiator< Function_class, 2, 4 > | Instantiates a function class with between two and four arguments |
| CInstantiator< Function_class, 2, 6 > | Instantiates a function class with between two and six arguments |
| CInstantiator< Function_class, 3 > | Instantiates a function class with three arguments |
| CInstantiator< Function_class, 3, 5 > | Instantiates a function class with two or three arguments |
| CInstantiator< Function_class, 4 > | Instantiates a function class with four arguments |
| CInstantiator< Function_class, 5 > | Instantiates a function class with five arguments |
| CInstantiator_with_functype | |
| CInstantiator_with_functype< Function_class, Function_type, 1, 1 > | |
| CInstantiator_with_functype< Function_class, Function_type, 2, 2 > | |
| CInstantiator_with_thd | |
| CInstantiator_with_thd< Function_class, 1, 2 > | Instantiates a function class taking a thd and one or two arguments |
| CInstantiator_with_thd< Function_class, 1, 3 > | Instantiates a function class taking between one and three arguments |
| CInternal_function_factory | Factory for internal functions that should be invoked from the system views only |
| CJson_length_instantiator | Instantiates a call to JSON_LENGTH, which may take either one or two arguments |
| CLatitude_instantiator | |
| CList_instantiator | |
| CList_instantiator_with_thd | |
| CLocate_instantiator | |
| CLongitude_instantiator | |
| CMake_set_instantiator | |
| COct_instantiator | |
| COdd_argcount_function_factory | |
| CRound_instantiator | |
| CSrid_instantiator | |
| CSubtime_instantiator | |
| CTime_format_instantiator | |
| CWeekday_instantiator | |
| CWeekofyear_instantiator | |
| CX_instantiator | |
| CY_instantiator | |
| CYearweek_instantiator | |
| ►Nanonymous_namespace{item_strfunc.cc} | |
| CParse_error_anonymizer | Error handler that wraps parse error messages, removes details and silences warnings |
| CThd_parse_modifier | Because it's not possible to disentangle the state of the parser from the THD, we have to destructively modify the current THD object in order to parse |
| Nanonymous_namespace{item_sum.cc} | |
| ►Nanonymous_namespace{join_optimizer.cc} | |
| CApplyDistinctParameters | This struct implements a builder pattern for creating paths that do DISTINCT (sort with duplicate removal) and adding them as parent of the current candidate paths (except for candidate paths that do DISTINCT already) |
| ►CCostingReceiver | CostingReceiver contains the main join planning logic, selecting access paths based on cost |
| CAccessPathSet | Besides the access paths for a set of nodes (see m_access_paths), AccessPathSet contains information that is common between all access paths for that set |
| CFindRangeScansResult | Return type for FindRangeScans() |
| CProposeRefsResult | Return value of ProposeRefs |
| CKeypartForRef | |
| CPossibleIndexMerge | Represents a candidate index merge, ie |
| CPossibleIndexSkipScan | Represents a candidate index skip scan, i.e |
| CPossibleRangeScan | |
| CPossibleRORScan | |
| ►CRefAccessBuilder | A builder class for constructing REF (or EQ_REF) AccessPath objects |
| CKeyMatch | Result type for FindKeyMatch() |
| CLookup | Result type for BuildLookup() |
| CPredicateAnalysis | Result type of AnalyzePredicates() |
| Nanonymous_namespace{json_binary.cc} | |
| ►Nanonymous_namespace{json_client_library_main.cc} | |
| CCoutJsonSchemaDefaultErrorHandler | |
| CCoutSerializationErrorHandler | |
| ►Nanonymous_namespace{json_dom.cc} | |
| CCmp_json | |
| CEq_json | |
| CJson_child_equal | Functor which compares a child DOM of a JSON array or JSON object for equality |
| CJson_seek_params | Input and output parameters to seek_no_dup_elimination that remain constant in recursive calls |
| CRapid_json_handler | This class implements rapidjson's Handler concept to make our own handler which will construct our DOM from the parsing of the JSON text |
| CWrapper_hash_key | Helper class for building a hash key |
| CWrapper_sort_key | Wrapper around a sort key buffer |
| ►Nanonymous_namespace{json_path.cc} | |
| CMemberNameHandler | A RapidJSON handler which accepts a scalar string and nothing else |
| CStream | A simple input stream class for the JSON path parser |
| Nanonymous_namespace{keepalive.cc} | |
| Nanonymous_namespace{libmysql.cc} | |
| ►Nanonymous_namespace{locked_tables_list.cc} | |
| CMDL_ticket_same_lock_eq | |
| CMDL_ticket_same_lock_hash | |
| ►Nanonymous_namespace{logger_plugin.cc} | |
| CLoggerConfigExposer | |
| CLoggingPluginConfig | |
| Nanonymous_namespace{make_join_hypergraph.cc} | |
| ►Nanonymous_namespace{metadata.cc} | |
| CUpdate_context | |
| CView_metadata_update_ctx | Holds context during I_S table referencing view's status/column metadata update |
| Nanonymous_namespace{metadata_cache_gr.cc} | |
| ►Nanonymous_namespace{mock_server_plugin.cc} | |
| CSslModeOption | |
| CStringsOption | |
| ►Nanonymous_namespace{my_file.cc} | |
| CFileInfo | Rule of 5 class |
| Nanonymous_namespace{my_fopen.cc} | |
| Nanonymous_namespace{my_fstream.cc} | |
| Nanonymous_namespace{my_getpwnam.cc} | |
| Nanonymous_namespace{my_hex_tools.cc} | |
| ►Nanonymous_namespace{my_winfile.cc} | |
| CHandleInfo | |
| CWindowsErrorGuard | RAII guard which ensures that: |
| Nanonymous_namespace{mysql_routing.cc} | |
| Nanonymous_namespace{mysql_server_event_tracking_bridge_imp.cc} | |
| ►Nanonymous_namespace{mysql_session.cc} | |
| CSSLSessionsCache | |
| ►Nanonymous_namespace{mysql_string_service.cc} | The string functions as a service to the mysql_server component |
| Cst_string_iterator | Mysql_string_itrerator structure to provide service to components |
| ►Nanonymous_namespace{mysql_thd_store_imp.cc} | |
| CThd_store_data_service | |
| Nanonymous_namespace{mysqld.cc} | |
| Nanonymous_namespace{mysqld_daemon.cc} | |
| ►Nanonymous_namespace{opt_explain.cc} | |
| ►CExplain | A base for all Explain_* classes |
| CLazy_condition | |
| CExplain_join | Explain_join class produces EXPLAIN output for JOINs |
| CExplain_no_table | Explain_no_table class outputs a trivial EXPLAIN row with "extra" column |
| CExplain_secondary_engine | This class outputs an empty plan for queries that use a secondary engine |
| CExplain_setop_result | Explain_union_result class outputs EXPLAIN row for UNION |
| CExplain_table | Explain_table class produce EXPLAIN output for queries without top-level JOIN |
| CExplain_table_base | Common base class for Explain_join and Explain_table |
| ►Nanonymous_namespace{opt_trace.cc} | |
| CBuffer | A wrapper of class String, for storing query or trace |
| Nanonymous_namespace{opt_trace2server.cc} | |
| ►Nanonymous_namespace{p_s.cc} | |
| Cparsed_table_path | |
| Nanonymous_namespace{parse_tree_nodes.cc} | |
| ►Nanonymous_namespace{parser_service.cc} | |
| Cthread_args | |
| Nanonymous_namespace{persisted_variable.cc} | |
| ►Nanonymous_namespace{plugin_config.cc} | |
| CMetadataCacheConfigExposer | |
| CRoutingConfigExposer | |
| CRoutingRulesConfigExposer | |
| Nanonymous_namespace{print_utils.cc} | |
| Nanonymous_namespace{recovery.cc} | |
| Nanonymous_namespace{registry.cc} | |
| ►Nanonymous_namespace{relational_expression.cc} | |
| CStringJoiner | A class for formatting a list into a string where elements are separated by a separator |
| ►Nanonymous_namespace{resource_group_sql_cmd.cc} | |
| CMove_thread_to_default_group | This class represents a functional call to move a thread specified by pfs_thread_id to a resource group specified in class' constructor |
| ►Nanonymous_namespace{rest_api_plugin.cc} | |
| CRestApiConfigExposer | |
| ►Nanonymous_namespace{rest_connection_pool_plugin.cc} | |
| CRestConnectionPoolConfigExposer | |
| ►Nanonymous_namespace{rest_metadata_cache_plugin.cc} | |
| CRestMetadataCacheConfigExposer | |
| ►Nanonymous_namespace{rest_router_plugin.cc} | |
| CRestRouterConfigExposer | |
| ►Nanonymous_namespace{rest_routing_plugin.cc} | |
| CRestRoutingConfigExposer | |
| ►Nanonymous_namespace{rewriter.cc} | |
| CRefresh_callback_args | |
| ►Nanonymous_namespace{router_app.cc} | |
| CRouterAppConfigExposer | |
| ►Nanonymous_namespace{router_options.cc} | |
| CMetadataJsonOptions | |
| ►Nanonymous_namespace{router_require.cc} | |
| CSelectUserAttributesHandler | Capture the user-attributes |
| Nanonymous_namespace{rpl_group_replication.cc} | |
| Nanonymous_namespace{rpl_gtid_set.cc} | |
| Nanonymous_namespace{sdi.cc} | |
| ►Nanonymous_namespace{sdi_file.cc} | |
| CDir_pat_tuple | |
| Nanonymous_namespace{sdi_tablespace.cc} | |
| Nanonymous_namespace{signal_handler.cc} | |
| ►Nanonymous_namespace{socket_connection.cc} | |
| CFreeAddrInfoDeleter | |
| ►Nanonymous_namespace{sp.cc} | |
| CSilence_deprecated_warning | Silence DEPRECATED SYNTAX warnings when loading a stored procedure into the cache |
| ►Nanonymous_namespace{sql_audit.cc} | |
| CEvent_tracking_error_handler | Error handler that controls error reporting by plugin |
| CIgnore_command_start_error_handler | Ignore error for specified commands |
| CIgnore_event_tracking_error_handler | Ignore all errors notified from within plugin |
| ►Nanonymous_namespace{sql_base.cc} | |
| Cschema_hash | |
| Cschema_key_equal | |
| ►Nanonymous_namespace{sql_delete.cc} | |
| CQuery_result_delete | |
| Nanonymous_namespace{sql_import.cc} | |
| Nanonymous_namespace{sql_load.cc} | |
| ►Nanonymous_namespace{sql_planner.cc} | |
| CJoin_tab_compare_embedded_first | |
| CJoin_tab_compare_straight | "Less than" comparison function object used to compare two JOIN_TAB objects that are joined using STRAIGHT JOIN |
| ►Nanonymous_namespace{sql_prepare.cc} | |
| CQuery_fetch_protocol_binary | A result class used to send cursor rows using the binary protocol |
| ►Nanonymous_namespace{sql_rename.cc} | |
| Ctable_list_equal | |
| Ctable_list_hash | |
| Nanonymous_namespace{sql_rewrite.cc} | |
| ►Nanonymous_namespace{sql_select.cc} | |
| Cstore_key_const_item | |
| Cstore_key_json_item | |
| ►Nanonymous_namespace{sql_table.cc} | |
| CHandlerton_pair | |
| CReplace_field_processor_arg | This class is used as an input argument to Item::walk, and takes care of replacing the field pointer in Item_field with pointers to a Create_field_wrapper |
| Csort_keys | |
| CViability | |
| ►Nanonymous_namespace{sql_tablespace.cc} | |
| CRollback_guard | |
| Nanonymous_namespace{sql_user.cc} | |
| Nanonymous_namespace{sql_value.cc} | |
| Nanonymous_namespace{sql_xa_commit.cc} | |
| Nanonymous_namespace{sql_xa_prepare.cc} | |
| ►Nanonymous_namespace{sys_vars.cc} | Warn usage of restrict_fk_on_non_standard_key variable |
| CGet_csname | |
| CGet_locale_name | |
| CGet_name | |
| Nanonymous_namespace{system_registry.cc} | |
| Nanonymous_namespace{table.cc} | |
| Nanonymous_namespace{table_constraints_extensions.cc} | |
| Nanonymous_namespace{table_keyring_component_status.cc} | |
| Nanonymous_namespace{table_keyring_keys.cc} | |
| ►Nanonymous_namespace{table_stats.cc} | |
| CUpdate_I_S_statistics_ctx | A RAII to used to allow updates in the DD tables mysql.index_stats and mysql.index_stats |
| Nanonymous_namespace{tables_extensions.cc} | |
| Nanonymous_namespace{tablespaces_extensions.cc} | |
| Nanonymous_namespace{tc_log.cc} | |
| Nanonymous_namespace{tls_ciphers.h} | |
| Nanonymous_namespace{tls_client_context.cc} | |
| ►Nanonymous_namespace{tls_server_context.cc} | |
| COsslDeleter | |
| COsslDeleter< BIO > | |
| COsslDeleter< EVP_PKEY > | |
| COsslDeleter< EVP_PKEY_CTX > | |
| COsslDeleter< OSSL_DECODER_CTX > | |
| Nanonymous_namespace{tree.cc} | |
| Nanonymous_namespace{unhex.cc} | |
| ►Nanonymous_namespace{uniques.cc} | |
| CMerge_chunk_compare_context | |
| CMerge_chunk_less | |
| CUniq_param | |
| Nanonymous_namespace{view_impl.cc} | |
| Nanonymous_namespace{webauthn_assertion.cc} | |
| Nanonymous_namespace{webauthn_registration.cc} | |
| Nanonymous_namespace{window_iterators.cc} | |
| ►Nauth_kerberos_context | |
| CKerberos | |
| ►Nauth_ldap_sasl_client | |
| CKerberos | Kerberos class is built around kerberos library |
| CKrb5_interface | Class representing interface to KRB5 functions |
| CLdap_log_writer_error | Log writer class |
| CLdap_logger | Class representing logger for LDAP plugins |
| CSasl_client | Class representing SASL client |
| CSasl_mechanism | Base class representing SASL mechanism |
| CSasl_mechanism_kerberos | Class representing GSSAPI/Kerberos mechanism |
| CSasl_mechanism_scram | Class representing SCRAM family of SASL mechanisms (currently SCRAM-SHA-1 and SCRAM-SHA-256) |
| ►Nauthentication_policy | Namespace for authentication policy |
| CFactor | Class representing authenticalion policy factor |
| CPolicy | Class representing authentication policy |
| NBackup_comp_constants | |
| ►NBase64Alphabet | |
| Ndetail | |
| CBase64 | |
| CBase64Url | |
| CBcrypt | |
| CCrypt | |
| CMcf | Base64 alphabet for MCF |
| CUuencode | |
| ►Nbinary_log | |
| ►Ncodecs | |
| Nbinary | |
| Ngtids | |
| ►Ntransaction | |
| Ncompression | |
| Nbinary_log_debug | |
| ►Nbinlog | |
| ►Nmonitoring | |
| CCompression_stats | This class represents the compression stats collected for a given combination of log type and compression type |
| CContext | The global context for binary/relay log monitoring |
| CTransaction_compression | |
| ►Nservice | |
| ►Niterators | |
| ►Ntests | |
| CCs_entries_table | |
| CRow | |
| ►Nservices | |
| ►Niterator | |
| CFileStorage | |
| CAtomicBgcTicket | Implements atomic ops on BgcTicket object |
| CAtomicBgcTicketGuard | RAII opaque for AtomicBgcTicket (set in use/set used synchronization operations in constructor/destructor) |
| CBgc_ticket_manager | Singleton class that manages the grouping of sessions for the Binlog Group Commit (BGC), using a ticketing system |
| CBgcTicket | Represents the Binlog Group Commit Ticket - BGC Ticket |
| CBinlog_recovery | Recovers from last crashed binlog at server start |
| CContext | Global context for binary logging |
| CDecompressing_event_object_istream | Stream class that yields Log_event objects from a source |
| CLog_sanitizer | Class used to recover binary / relay log file |
| ►Nboost | Tag dispatch for custom Role_properties |
| ►Ngeometry | |
| Ncs | |
| ►Ntraits | |
| Caccess< gis::Cartesian_point, Dimension > | |
| Caccess< gis::Geographic_point, Dimension > | |
| Caccess< Gis_point, Dimension > | |
| Cclosure< gis::Cartesian_linearring > | |
| Cclosure< gis::Geographic_linearring > | |
| Cclosure< Gis_polygon_ring > | |
| Ccoordinate_system< gis::Cartesian_point > | |
| Ccoordinate_system< gis::Geographic_point > | |
| Ccoordinate_system< Gis_point > | |
| Ccoordinate_type< gis::Cartesian_point > | |
| Ccoordinate_type< gis::Geographic_point > | |
| Ccoordinate_type< Gis_point > | |
| Cdimension< gis::Cartesian_point > | |
| Cdimension< gis::Geographic_point > | |
| Cdimension< Gis_point > | |
| Cexterior_ring< gis::Cartesian_polygon > | |
| Cexterior_ring< gis::Geographic_polygon > | |
| Cexterior_ring< Gis_polygon > | |
| Cindexed_access< gis::Cartesian_box, max_corner, Dimension > | |
| Cindexed_access< gis::Cartesian_box, min_corner, Dimension > | |
| Cindexed_access< gis::Geographic_box, max_corner, Dimension > | |
| Cindexed_access< gis::Geographic_box, min_corner, Dimension > | |
| Cinterior_const_type< gis::Cartesian_polygon > | |
| Cinterior_const_type< gis::Geographic_polygon > | |
| Cinterior_const_type< Gis_polygon > | |
| Cinterior_mutable_type< gis::Cartesian_polygon > | |
| Cinterior_mutable_type< gis::Geographic_polygon > | |
| Cinterior_mutable_type< Gis_polygon > | |
| Cinterior_rings< gis::Cartesian_polygon > | |
| Cinterior_rings< gis::Geographic_polygon > | |
| Cinterior_rings< Gis_polygon > | |
| Cpoint_order< gis::Cartesian_linearring > | |
| Cpoint_order< gis::Geographic_linearring > | |
| Cpoint_order< Gis_polygon_ring > | |
| Cpoint_type< gis::Cartesian_box > | |
| Cpoint_type< gis::Geographic_box > | |
| Cring_const_type< gis::Cartesian_polygon > | |
| Cring_const_type< gis::Geographic_polygon > | |
| Cring_const_type< Gis_polygon > | |
| Cring_mutable_type< gis::Cartesian_polygon > | |
| Cring_mutable_type< gis::Geographic_polygon > | |
| Cring_mutable_type< Gis_polygon > | |
| Ctag< gis::Cartesian_box > | |
| Ctag< gis::Cartesian_linearring > | |
| Ctag< gis::Cartesian_linestring > | |
| Ctag< gis::Cartesian_multilinestring > | |
| Ctag< gis::Cartesian_multipoint > | |
| Ctag< gis::Cartesian_multipolygon > | |
| Ctag< gis::Cartesian_point > | |
| Ctag< gis::Cartesian_polygon > | |
| Ctag< gis::Geographic_box > | |
| Ctag< gis::Geographic_linearring > | |
| Ctag< gis::Geographic_linestring > | |
| Ctag< gis::Geographic_multilinestring > | |
| Ctag< gis::Geographic_multipoint > | |
| Ctag< gis::Geographic_multipolygon > | |
| Ctag< gis::Geographic_point > | |
| Ctag< gis::Geographic_polygon > | |
| Ctag< Gis_line_string > | |
| Ctag< Gis_multi_line_string > | |
| Ctag< Gis_multi_point > | |
| Ctag< Gis_multi_polygon > | |
| Ctag< Gis_point > | |
| Ctag< Gis_polygon > | |
| Ctag< Gis_polygon_ring > | |
| ►Nbootstrap | |
| CCommand_iterator | Abstract interface to reading bootstrap commands |
| CFile_command_iterator | File bootstrap command reader |
| Chandle_bootstrap_args | |
| ►NBtree_multi | |
| ►Nbulk | |
| CBlob_handle | Used to insert a single blob into InnoDB |
| CBlob_inserter | Used to insert many blobs into InnoDB |
| ►CBtree_load | |
| CMerger | |
| CWait_callbacks | Helper to set wait callbacks for the current scope |
| CBtree_load_compare | Function object to compare two Btree_load objects |
| ►CBulk_extent_allocator | |
| CExtent_cache | |
| CBulk_flusher | |
| CLevel_ctx | Context information for each level |
| CPage_extent | Allocate, use, manage and flush one extent pages (FSP_EXTENT_SIZE) |
| CPage_load | The proper function call sequence of Page_load is as below: – Page_load::init – Page_load::insert – Page_load::finish – Page_load::commit |
| CPage_load_compare | |
| CPage_stat | Information about a buffer page |
| ►Nbuf | |
| CBlock_hint | |
| Nbulk | Used for bulk load of data |
| ►NBulk_data_convert | |
| CRow_header | |
| NBulk_data_load | |
| ►NBulk_load | |
| CJson_serialization_error_handler | |
| CStat_callbacks | Callbacks for collecting time statistics |
| ►Nclassic_protocol | |
| Nbinary | |
| ►Nborrowable | |
| ►Nbinary | |
| CBit | |
| CBlob | |
| CDate | |
| CDateTime | |
| CDatetimeBase | POD base-type for Datetime, Timestamp, Date |
| CDecimal | |
| CDouble | |
| CEnum | |
| CFloat | |
| CGeometry | |
| CInt24 | |
| CJson | |
| CLong | |
| CLongBlob | |
| CLongLong | |
| CMediumBlob | |
| CNewDecimal | |
| CNull | |
| CSet | |
| CShort | |
| CString | |
| CTime | |
| CTimestamp | |
| CTiny | |
| CTinyBlob | |
| CTypeBase | Base type of all binary scalar value types |
| CVarchar | |
| CVarString | |
| CYear | |
| ►Nmessage | |
| ►Nclient | |
| CAuthMethodData | |
| CBinlogDump | |
| CBinlogDumpGtid | |
| CChangeUser | |
| CClone | |
| CDebug | |
| CGreeting | |
| CInitSchema | |
| CKill | |
| CListFields | |
| CPing | |
| ►CQuery | |
| CParam | |
| CQuit | |
| CRegisterReplica | |
| CReload | |
| CResetConnection | |
| CSendFile | |
| CSetOption | Set options on the current connection |
| CStatistics | |
| CStmtClose | Close a prepared statement |
| ►CStmtExecute | Execute a prepared statement |
| CParamDef | |
| CStmtFetch | Fetch rows from an executed statement |
| CStmtParamAppendData | Append data to a parameter of a prepared statement |
| CStmtPrepare | |
| CStmtReset | Reset a prepared statement |
| ►Nserver | |
| CAuthMethodData | Opaque auth-method-data message |
| CAuthMethodSwitch | |
| CColumnCount | ColumnCount message |
| CColumnMeta | |
| CEof | End of Resultset message |
| CError | Error message |
| CGreeting | |
| COk | Ok message |
| CResultSet | |
| CRow | Row in a resultset |
| CSendFileRequest | |
| CStatistics | |
| CStmtPrepareOk | StmtPrepareOk message |
| CStmtRow | StmtRow message |
| ►Nsession_track | |
| CField | Field of a session-track array |
| CGtid | Gtid changed |
| CSchema | Schema changed |
| CState | State changed |
| CSystemVariable | System-variable changed |
| CTransactionCharacteristics | TransactionCharacteristics changed |
| CTransactionState | TransactionState changed |
| ►Nwire | |
| CBasicInt | |
| CFixedInt | |
| CFixedInt< 1 > | |
| CFixedInt< 2 > | |
| CFixedInt< 3 > | |
| CFixedInt< 4 > | |
| CFixedInt< 8 > | |
| CNull | |
| CNulTermString | |
| CString | |
| CVarInt | |
| CVarString | |
| CAuthMethod | AuthMethod of classic protocol |
| ►Nborrowed | |
| Nbinary | |
| ►Nmessage | |
| Nclient | |
| Nserver | |
| Nsession_track | |
| Nwire | |
| ►Ncapabilities | |
| Npos | |
| ►Nclone | |
| ►Nclient | |
| CAck | |
| CAttach | |
| CExecute | |
| CExit | |
| CInit | |
| CReinit | |
| ►Nserver | |
| CComplete | |
| CData | |
| CDataDescriptor | |
| CError | |
| CLocators | |
| CLocator | |
| Ncollation | |
| ►Ncolumn_def | |
| Npos | |
| ►Ncursor | |
| Npos | |
| Nfield_type | |
| ►Nframe | |
| CCompressedHeader | Header of a compressed frame |
| CFrame | |
| CHeader | |
| ►Nimpl | |
| CBinaryTypeBase | |
| CBinaryTypeBase< borrowable::binary::Bit< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Blob< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Date > | |
| CBinaryTypeBase< borrowable::binary::DateTime > | |
| CBinaryTypeBase< borrowable::binary::Decimal< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Double > | |
| CBinaryTypeBase< borrowable::binary::Enum< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Float > | |
| CBinaryTypeBase< borrowable::binary::Geometry< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Int24 > | |
| CBinaryTypeBase< borrowable::binary::Json< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Long > | |
| CBinaryTypeBase< borrowable::binary::LongBlob< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::LongLong > | |
| CBinaryTypeBase< borrowable::binary::MediumBlob< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::NewDecimal< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Null > | |
| CBinaryTypeBase< borrowable::binary::Set< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Short > | |
| CBinaryTypeBase< borrowable::binary::String< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Time > | |
| CBinaryTypeBase< borrowable::binary::Timestamp > | |
| CBinaryTypeBase< borrowable::binary::Tiny > | |
| CBinaryTypeBase< borrowable::binary::TinyBlob< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Varchar< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::VarString< Borrowed > > | |
| CBinaryTypeBase< borrowable::binary::Year > | |
| CDatetimeCodec | |
| CDecodeBufferAccumulator | Generator of decoded Types of a buffer |
| CEncodeBase | CRTP base for the Codec's encode part |
| CEncodeBufferAccumulator | Accumulator of encoded buffers |
| CEncodeSizeAccumulator | Accumulates the sizes of encoded T's |
| CFixedIntCodec | |
| CFloatCodec | |
| CStringCodec | |
| CTimeCodec | |
| ►Nmessage | |
| ►Nclient | |
| ►Nimpl | |
| CBinlogDump | |
| CBinlogDumpGtid | |
| Nserver | |
| ►Nreload_cmds | |
| Npos | |
| Nsession_track | |
| ►Nstatus | |
| Npos | |
| Nwire | |
| CCodec | Codec for a type |
| CCodec< borrowable::binary::Bit< Borrowed > > | |
| CCodec< borrowable::binary::Blob< Borrowed > > | |
| CCodec< borrowable::binary::Date > | |
| CCodec< borrowable::binary::DateTime > | |
| CCodec< borrowable::binary::Decimal< Borrowed > > | |
| CCodec< borrowable::binary::Double > | |
| CCodec< borrowable::binary::Enum< Borrowed > > | |
| CCodec< borrowable::binary::Float > | |
| CCodec< borrowable::binary::Geometry< Borrowed > > | |
| CCodec< borrowable::binary::Int24 > | |
| CCodec< borrowable::binary::Json< Borrowed > > | |
| CCodec< borrowable::binary::Long > | |
| CCodec< borrowable::binary::LongBlob< Borrowed > > | |
| CCodec< borrowable::binary::LongLong > | |
| CCodec< borrowable::binary::MediumBlob< Borrowed > > | |
| CCodec< borrowable::binary::NewDecimal< Borrowed > > | |
| CCodec< borrowable::binary::Null > | |
| CCodec< borrowable::binary::Set< Borrowed > > | |
| CCodec< borrowable::binary::Short > | |
| CCodec< borrowable::binary::String< Borrowed > > | |
| CCodec< borrowable::binary::Time > | |
| CCodec< borrowable::binary::Timestamp > | |
| CCodec< borrowable::binary::Tiny > | |
| CCodec< borrowable::binary::TinyBlob< Borrowed > > | |
| CCodec< borrowable::binary::Varchar< Borrowed > > | |
| CCodec< borrowable::binary::VarString< Borrowed > > | |
| CCodec< borrowable::binary::Year > | |
| CCodec< borrowable::message::client::AuthMethodData< Borrowed > > | Codec for client::AuthMethodData message |
| CCodec< borrowable::message::client::BinlogDump< Borrowed > > | Codec for client side dump-binlog message |
| CCodec< borrowable::message::client::BinlogDumpGtid< Borrowed > > | Codec for client side dump-binlog-with-gtid message |
| CCodec< borrowable::message::client::ChangeUser< Borrowed > > | Codec for client side change-user message |
| CCodec< borrowable::message::client::Clone > | Codec for client's Clone command |
| CCodec< borrowable::message::client::Debug > | Codec for client's Debug command |
| CCodec< borrowable::message::client::Greeting< Borrowed > > | Codec for client side greeting message |
| CCodec< borrowable::message::client::InitSchema< Borrowed > > | Codec for client's InitSchema command |
| CCodec< borrowable::message::client::Kill > | Codec for client's Kill command |
| CCodec< borrowable::message::client::ListFields< Borrowed > > | Codec for client's ListFields command |
| CCodec< borrowable::message::client::Ping > | Codec for client's Ping command |
| CCodec< borrowable::message::client::Query< Borrowed > > | Codec for client's Query command |
| CCodec< borrowable::message::client::Quit > | Codec for client's Quit command |
| CCodec< borrowable::message::client::RegisterReplica< Borrowed > > | Codec for client side register-replica message |
| CCodec< borrowable::message::client::Reload > | Codec for client's Reload command |
| CCodec< borrowable::message::client::ResetConnection > | Codec for client's ResetConnection command |
| CCodec< borrowable::message::client::SendFile< Borrowed > > | Codec for client::SendFile message |
| CCodec< borrowable::message::client::SetOption > | Codec for client's SetOption command |
| CCodec< borrowable::message::client::Statistics > | Codec for client's Statistics command |
| CCodec< borrowable::message::client::StmtClose > | Codec for client's Close Statement command |
| CCodec< borrowable::message::client::StmtExecute< Borrowed > > | Codec for client's Execute Statement command |
| CCodec< borrowable::message::client::StmtFetch > | Codec for client's Fetch Cursor command |
| CCodec< borrowable::message::client::StmtParamAppendData< Borrowed > > | Codec for client's append data Statement command |
| CCodec< borrowable::message::client::StmtPrepare< Borrowed > > | Codec for client's Prepared Statement command |
| CCodec< borrowable::message::client::StmtReset > | Codec for client's Reset Statement command |
| CCodec< borrowable::message::server::AuthMethodData< Borrowed > > | Codec for server::AuthMethodData message |
| CCodec< borrowable::message::server::AuthMethodSwitch< Borrowed > > | Codec for server::AuthMethodSwitch message |
| CCodec< borrowable::message::server::ColumnCount > | Codec for ColumnCount message |
| CCodec< borrowable::message::server::ColumnMeta< Borrowed > > | Codec of ColumnMeta |
| CCodec< borrowable::message::server::Eof< Borrowed > > | Codec for server-side Eof message |
| CCodec< borrowable::message::server::Error< Borrowed > > | Codec for Error message |
| CCodec< borrowable::message::server::Greeting< Borrowed > > | Codec for server Greeting message |
| CCodec< borrowable::message::server::Ok< Borrowed > > | Codec for server-side Ok message |
| CCodec< borrowable::message::server::Row< Borrowed > > | Codec for a Row from the server |
| CCodec< borrowable::message::server::SendFileRequest< Borrowed > > | Codec for server's SendFileRequest response |
| CCodec< borrowable::message::server::Statistics< Borrowed > > | Codec for server::Statistics message |
| CCodec< borrowable::message::server::StmtPrepareOk > | Codec for server::StmtPrepareOk message |
| CCodec< borrowable::message::server::StmtRow< Borrowed > > | Codec for a StmtRow from the server |
| CCodec< borrowable::session_track::Field< Borrowed > > | Codec for session-track's Field |
| CCodec< borrowable::session_track::Gtid< Borrowed > > | Codec for session_track::Gtid |
| CCodec< borrowable::session_track::Schema< Borrowed > > | Codec for session_track::Schema |
| CCodec< borrowable::session_track::SystemVariable< Borrowed > > | Codec for session_track::SystemVariable |
| CCodec< borrowable::session_track::TransactionCharacteristics< Borrowed > > | Codec for session_track::TransactionCharacteristics |
| CCodec< borrowable::session_track::TransactionState > | Codec for session_track::TransactionState |
| CCodec< borrowable::wire::FixedInt< IntSize > > | Codec of a FixedInt |
| CCodec< borrowable::wire::Null > | Codec for a NULL value in the Resultset |
| CCodec< borrowable::wire::NulTermString< Borrowed > > | Codec for 0-terminated string |
| CCodec< borrowable::wire::String< Borrowed > > | Codec for wire::String |
| CCodec< borrowable::wire::VarInt > | Codec for variable length integers |
| CCodec< borrowable::wire::VarString< Borrowed > > | Codec for string with known length |
| CCodec< clone::client::Ack > | |
| CCodec< clone::client::Attach > | |
| CCodec< clone::client::Execute > | |
| CCodec< clone::client::Exit > | |
| CCodec< clone::client::Init > | Codec for clone::client::Init message |
| CCodec< clone::client::Reinit > | |
| CCodec< clone::server::Complete > | |
| CCodec< clone::server::Error > | |
| CCodec< frame::CompressedHeader > | Codec of Compressed Header |
| CCodec< frame::Frame< PayloadType > > | Codec for a Frame |
| CCodec< frame::Header > | Codec of a Frame Header |
| CCodec< session_track::State > | Codec for session_track::State |
| CCodec< void > | Codec for ignorable bytes |
| CCodecSimpleCommand | CRTP base for client-side commands that are encoded as a single byte |
| ►Nclient_authentication | |
| Cassertion | Class to initiate authentication(aka assertion in FIDO terminology) on client side by generating a signed signature by FIDO device which needs to be sent to server to be verified |
| ►Nclient_registration | |
| Cregistration | This class is used to perform registration step on client side |
| ►Ncomponents | |
| CDestination_keyring_services | |
| CKeyring_component_load | |
| CKeyring_migrate | |
| CKeyring_services | |
| CSource_keyring_services | |
| ►Nconnection_pool | |
| Noptions | |
| Nconsts | |
| ►Ncontainer | |
| ►CAtomics_array | Array of std::atomic elements of type T |
| CIterator | Iterator helper class to iterate over the array, from 0 to the array size |
| ►CIntegrals_lockfree_queue | Lock-free, fixed-size bounded, multiple-producer (MP), multiple-consumer (MC), circular FIFO queue for integral elements |
| CIterator | Iterator helper class to iterate over the queue staring at the virtual index pointed to by the head, up until the virtual index pointed to by the tail |
| CInterleaved_indexing | Indexing provider that interleaves sequentially stored array elements in order to keep them from being pulled to the same cache line, in order to avoid false sharing and cache misses |
| CPadded_indexing | Indexing provider that pads each of the array elements to the size of the CPU cache line, in order to avoid false sharing and cache misses |
| ►NCounter | Sharded atomic counter |
| CShard | Counter shard |
| CShards | |
| ►Ncs | |
| ►Napply | |
| ►Ninstruments | |
| CApplier_metrics | This class contains metrics related to event and transaction scheduling activities in the replica MTA |
| CApplier_metrics_interface | This abstract class is an interface for classes that contain replication applier data as counters and wait times |
| CApplier_metrics_stub | Class that intends to be a dummy end point for applier metrics |
| CDummy_worker_metrics | Class that intends to be a dummy end point for worker metrics |
| CMta_worker_metrics | This class contains metrics transaction execution in replica MTA workers |
| CWorker_metrics | Abstract class for classes that contain metrics related to transaction execution in applier workers |
| ►CCommit_order_queue | Queue to maintain the ordered sequence of workers waiting for commit |
| CIterator | Iterator helper class to iterate over the Commit_order_queue following the underlying commit order |
| CNode | Queue element, holding the needed information to manage the commit ordering |
| ►Nindex | |
| CLocked_sidno_set | Set that keeps track of TSID locks taken in the current scope |
| ►Nutil | |
| CColumnFilter | When iterating the table fields for sometimes you want to skip some columns |
| CColumnFilterFactory | This class allows the developer to create a filter instance given a type |
| CColumnFilterInboundFunctionalIndexes | One use case for filtering relates to hidden generated columns |
| CColumnFilterInboundGipk | Class used when we want a column view over a table in a context where the replicated table contains a GIPK on the replica, but not on the source |
| CColumnFilterOutboundFunctionalIndexes | |
| CReplicatedColumnsView | Since it's not mandatory that all fields in a TABLE object are replicated, this class extends Table_columns_view container and adds logic to filter out not needed columns |
| CReplicatedColumnsViewFactory | This class allows the creation of different types of column view instances and also adds different filters depending on context |
| CReplicatedColumnsViewWithGipkOnSource | Class used when we want a column view over a table in a context where the replicated table contains a GIPK on the source, but not on the replica |
| ►Ndblwr | |
| ►Nrecv | |
| CDBLWR | Redo recovery configuration |
| CPage | Page recovered from the doublewrite buffer |
| CPage_entry | A record from reduced doublewrite buffer |
| CPages | Pages recovered from the doublewrite buffer |
| Nv1 | |
| CBuffer | IO buffer in UNIV_PAGE_SIZE units and aligned on UNIV_PAGE_SIZE |
| CFile | |
| CMode | |
| CReduced_entry | When –innodb-doublewrite=DETECT_ONLY, page contents are not written to the dblwr buffer |
| ►Ndd | The version of the current data dictionary table definitions |
| Nanonymous_namespace{dd.cc} | |
| Nanonymous_namespace{sdi.cc} | |
| Nanonymous_namespace{tablespace_impl.cc} | |
| ►Nbootstrap | |
| CDD_bootstrap_ctx | |
| ►Ncache | |
| ►CCache_element | Implementation of a dictionary client |
| CKey_wrapper | Helper class to represent a key instance |
| CType_selector | |
| ►CDictionary_client | |
| CAuto_releaser | Class to help releasing and deleting objects |
| CElement_map | Implementation of a map between a key type and an element type |
| CFree_list | Template for management of a free list based on a std::vector |
| CLocal_multi_map | Implementation of a local set of maps for a given object type |
| ►CMulti_map_base | Implementation of a set of maps for a given object type |
| CType_selector | |
| ►CObject_registry | Object registry containing several maps |
| CType_selector | |
| COpen_dictionary_tables_error_handler | |
| ►CShared_dictionary_cache | |
| CType_selector | |
| ►CShared_multi_map | Implementation of a shared set of maps for a given object type |
| CAutolocker | |
| CSPI_lru_cache | Inherit from an instantiation of the template to allow forward-declaring in Dictionary_client |
| CSPI_lru_cache_owner_ptr | A smart-pointer for managing an SPI_lru_cache even when it is only forward declared |
| CStorage_adapter | Handling of access to persistent storage |
| CTimestamp_timezone_guard | Class to fetch dd::Objects with GMT time |
| ►Ninfo_schema | |
| CSelect_lex_builder | This class provide framework to build a Query_block using ParseTree nodes |
| CTable_statistics | The class hold dynamic table statistics for a table |
| CTablespace_statistics | The class hold dynamic table statistics for a table |
| Nndbinfo | |
| Nperformance_schema | |
| ►Nsdi | |
| Nanonymous_namespace{sdi.cc} | |
| CImport_target | State and operations for importing an sdi file into the DD |
| Nsdi_file | |
| Nsdi_tablespace | |
| ►Nsdi_utils | |
| CClosure_error_handler | Class template which derives from Internal_error_handler and overrides handle_condition with the CONDITION_HANDLER_CLOS template parameter |
| ►Nsystem_views | |
| CAdministrable_role_authorizations | |
| CApplicable_roles | |
| CCharacter_sets | |
| CCheck_constraints | |
| CCollation_charset_applicability | |
| CCollations | |
| CColumn_statistics | |
| CColumns | |
| CColumns_extensions | The class representing INFORMATION_SCHEMA.COLUMNS_EXTENSIONS system view definition |
| CEnabled_roles | |
| CEvents | |
| CFiles | |
| CInnodb_datafiles | |
| CInnodb_fields | |
| CInnodb_foreign | |
| CInnodb_foreign_cols | |
| CInnodb_tablespaces_brief | |
| CKey_column_usage | |
| CKeywords | |
| CParameters | |
| CPartitions | |
| CReferential_constraints | |
| CResource_groups | The class representing INFORMATION_SCHEMA.RESOURCEGROUPS system view definition |
| CRole_column_grants | |
| CRole_routine_grants | |
| CRole_table_grants | |
| CRoutines | |
| CSchemata | |
| CSchemata_extensions | |
| CShow_statistics | |
| CSt_geometry_columns | |
| CSt_spatial_reference_systems | |
| CSt_units_of_measure | |
| CStatistics | |
| CStatistics_base | |
| CSystem_view | This class represents base class for all INFORMATION_SCHEMA system views defined in sql/dd/impl/system_views/ headers |
| CSystem_view_definition | |
| CSystem_view_definition_impl | |
| CSystem_view_impl | |
| CSystem_view_select_definition_impl | |
| CSystem_view_union_definition_impl | |
| CTable_constraints | |
| CTable_constraints_extensions | The class representing INFORMATION_SCHEMA.TABLE_CONSTRAINTS_EXTENSIONS system view definition |
| CTables | |
| CTables_base | |
| CTables_extensions | The class representing INFORMATION_SCHEMA.TABLES_EXTENSIONS system view definition |
| CTablespaces_extensions | The class representing INFORMATION_SCHEMA.TABLESPACES_EXTENSIONS system view definition |
| CTriggers | |
| CUser_attributes | |
| CView_routine_usage | |
| CView_table_usage | |
| CViews | |
| ►Ntables | |
| CCatalogs | |
| CCharacter_sets | |
| CCheck_constraints | |
| CCollations | |
| CColumn_statistics | |
| CColumn_type_elements | |
| CColumns | |
| CDD_properties | |
| CEvents | |
| CForeign_key_column_usage | |
| CForeign_keys | |
| CIndex_column_usage | |
| CIndex_partitions | |
| CIndex_stats | |
| CIndexes | |
| CParameter_type_elements | |
| CParameters | |
| CResource_groups | |
| CRoutines | |
| CSchemata | |
| CSpatial_reference_systems | |
| CTable_partition_values | |
| CTable_partition_values_pk | |
| CTable_partitions | |
| CTable_stats | |
| CTables | |
| CTablespace_files | |
| CTablespaces | |
| CTriggers | |
| CView_routine_usage | |
| CView_table_usage | |
| ►Nupgrade | |
| ►Nanonymous_namespace{server.cc} | |
| CMySQL_check | |
| CServer_option_guard | |
| CBootstrap_error_handler | Bootstrap thread executes SQL statements |
| CRoutine_event_context_guard | RAII for handling creation context of Events and Stored routines |
| CSyntax_error_handler | This class keeps a count of all the syntax errors that occurred while parsing views, routines, events or triggers |
| CUpgrade_error_counter | Class to keep track of upgrade errors during upgrade after 8.0 GA |
| CAbstract_table | Abstract base class for tables and views |
| CAbstract_table_impl | |
| CCharset | |
| CCharset_impl | |
| CCheck_constraint | |
| CCheck_constraint_impl | |
| CCheck_constraint_name_error_handler | Error handler to convert ER_DUP_ENTRY error to more user friendly error ER_CHECK_CONSTRAINT_DUP_NAME |
| CCheck_constraint_order_comparator | Class used to sort check constraints by name for the same table |
| CCollation | |
| CCollation_impl | |
| ►CCollection | |
| CCollection_const_iterator | |
| CCollection_iterator | |
| CColumn | |
| CColumn_impl | |
| CColumn_statistics | |
| CColumn_statistics_impl | |
| CColumn_type_element | |
| CColumn_type_element_impl | |
| CComposite_4char_key | |
| CComposite_char_key | |
| CComposite_obj_id_3char_key | |
| CComposite_pk | |
| CDD_kill_immunizer | RAII class for immunizing the THD from kill operations |
| CDefiner_reference_range_key | |
| CDictionary | Main interface class enabling users to operate on data dictionary |
| CDictionary_impl | |
| CEntity_element | Class to wrap an entity object |
| CEntity_object | Base class for dictionary objects which has single column integer primary key |
| CEntity_object_impl | |
| CEntity_object_table | This class represents DD table like mysql.schemata, mysql.tables, mysql.tablespaces and more |
| CEntity_object_table_impl | |
| CEntity_registry | Class to represent collections of meta data for entities |
| CEvent | |
| CEvent_impl | |
| CForeign_key | |
| CForeign_key_element | |
| CForeign_key_element_impl | |
| CForeign_key_impl | |
| CForeign_key_name_error_handler | |
| CForeign_key_order_comparator | Class used to sort Foreign key's by name for the same table |
| CForeign_key_parent | |
| CFunction | |
| CFunction_impl | |
| CGlobal_name_key | |
| CIndex | |
| CIndex_element | |
| CIndex_element_impl | |
| CIndex_impl | |
| CIndex_stat | |
| CIndex_stat_impl | |
| CIndex_stat_range_key | |
| CItem_name_key | |
| CObject_key | |
| CObject_table | This class represents all data dictionary table like mysql.tables, mysql.columns and more |
| CObject_table_definition | The purpose of this interface is to enable retrieving the SQL statements necessary to create and populate a DD table |
| CObject_table_definition_impl | |
| CObject_table_impl | |
| COpen_dictionary_tables_ctx | Auxiliary class for opening dictionary tables |
| CParameter | |
| CParameter_impl | |
| CParameter_type_element | |
| CParameter_type_element_impl | |
| CParent_id_range_key | |
| CPartition | |
| CPartition_impl | |
| CPartition_index | |
| CPartition_index_impl | |
| CPartition_index_order_comparator | Used to sort Partition_index objects for the same partition in the same order as Index objects for the table |
| CPartition_order_comparator | Used to compare two partition elements |
| CPartition_value | |
| CPartition_value_impl | |
| CPartition_value_order_comparator | Used to sort Partition_value objects for the same partition first according to list number and then according to the column number |
| CPrimary_id_key | |
| CProcedure | |
| CProcedure_impl | |
| CProperties | Defines an interface for storing key=value pairs, where both key and value may be UTF-8 strings |
| CProperties_impl | Implements the Properties interface |
| CRaw_key | |
| CRaw_new_record | |
| CRaw_record | |
| CRaw_record_set | |
| CRaw_table | |
| CResource_group | |
| CResource_group_impl | |
| CResultType | Template for structs to hold results from functions |
| CRoutine | Abstract base class for functions and procedures |
| CRoutine_impl | |
| CRoutine_name_key | |
| CSchema | |
| CSchema_impl | |
| CSchema_MDL_locker | RAII based class to acquire and release schema meta data locks |
| CSdi_rcontext | Opaque context which keeps reusable resoureces needed during deserialization |
| CSdi_wcontext | Opaque context which keeps reusable resources needed during serialization |
| CSe_private_id_key | |
| CSpatial_reference_system | |
| CSpatial_reference_system_impl | |
| CString_type_alloc | Functor class which allocates memory for String_type |
| CSub_partition_range_key | |
| CSystem_tables | Class used to represent the dictionary tables |
| CSystem_tablespaces | Class used to represent the system tablespaces |
| CSystem_views | Class used to represent the system views |
| CTable | |
| CTable_impl | |
| CTable_reference_range_key | |
| CTable_stat | |
| CTable_stat_impl | |
| CTablespace | |
| CTablespace_file | |
| CTablespace_file_impl | |
| CTablespace_filename_error_handler | |
| CTablespace_impl | |
| CTablespace_table_ref | Represents tables with their id, name, schema id and schema name |
| CTransaction_ro | Implementation of read-only data-dictionary transaction |
| CTrigger | Class representing a Trigger in DD framework |
| CTrigger_impl | |
| CTrigger_order_comparator | Used to sort Triggers of the same table by action timing, event type and action order |
| CUpdate_dictionary_tables_ctx | Class for storing/restoring state during dictionary update operations |
| CView | |
| CView_definer_reference_range_key | |
| CView_impl | |
| CView_routine | |
| CView_routine_impl | |
| CView_table | |
| CView_table_impl | |
| CVoid_key | |
| CWeak_object | Base class for all data dictionary objects |
| CWeak_object_impl_ | |
| Ndd_cache_unittest | |
| ►Ndd_column_statistics_unittest | |
| CColumnStatisticsTest | |
| ►Ndd_fil | Used for collecting the data in boot_tablespaces() |
| CMoved | |
| Ndd_schema_unittest | |
| ►Nddl | The general architecture is that the work is done in two phases, roughly the read and write phase |
| ►CBuilder | For loading indexes |
| CThread_ctx | State of a cluster index reader thread |
| CCompare_key | Compare the keys of an index |
| ►CContext | DDL context/configuration |
| ►CFTS | Full text search context information and state |
| CSequence | Document ID sequence |
| CCopy_ctx | Context for copying cluster index row for the index to being created |
| CCursor | Cursor for reading the data |
| CDup | Structure for reporting duplicate records |
| CFetch_sequence | Fetch the document ID from the table |
| CFile_cursor | For loading a Btree index from a file |
| CFile_reader | Read rows from the temporary file |
| Cfile_t | Information about temporary files used in merge sort |
| ►CFTS | Full text search index builder |
| CDoc_item | Information about temporary files used in merge sort |
| ►CInserter | |
| CHandler | Data structures for building an index |
| ►CParser | For parsing and sorting the documents |
| CHandler | Data structures for building an index |
| CGen_sequence | Generate the next document ID using a monotonic sequence |
| CIndex_defn | Definition of an index being created |
| CIndex_field | Index field definition |
| CInsert | Structure stores information needed for the insertion phase of FTS parallel sort |
| CKey_sort_buffer | Buffer for sorting in main memory |
| CKey_sort_buffer_cursor | For loading an index from a sorted buffer |
| CLoad_cursor | |
| ►CLoader | Build indexes on a table by reading a clustered index, creating a temporary file containing index entries, merge sorting these index entries and inserting sorted index entries to indexes |
| CTask | Builder task |
| CTask_queue | Unbounded task queue |
| ►CMerge_cursor | Merge the sorted files |
| CCompare | Comparator |
| ►CMerge_file_sort | Merge the blocks in the file |
| CContext | Context to use for merging the files/runs |
| CCursor | Cursor for merging blocks from the same file |
| COutput_file | For writing out the merged rows |
| CParallel_cursor | Cursor used for parallel reads |
| CRow | Physical row context |
| CRTree_inserter | Class that caches RTree index tuples made from a single cluster index page scan, and then insert into corresponding index tree |
| CSequence | Generate the next autoinc based on a snapshot of the session auto_increment_increment and auto_increment_offset variables |
| CToken | Row fts token for plugin parser |
| CTokenize_ctx | Structure stores information from string tokenization operation |
| CUnique_os_file_descriptor | Captures ownership and manages lifetime of an already opened OS file descriptor |
| ►Nddl_bulk | |
| ►CLoader | |
| CThread_data | |
| Ndetail | |
| Ndict_name | Innodb data dictionary name |
| ►NEvent_tracking_implementation | |
| CEvent_tracking_authentication_implementation | Implementation helper class for authentication events |
| CEvent_tracking_command_implementation | Implementation helper class for command events |
| CEvent_tracking_connection_implementation | Implementation helper class for connection events |
| CEvent_tracking_general_implementation | Implementation helper class for general events |
| CEvent_tracking_global_variable_implementation | Implementation helper class for global_variable events |
| CEvent_tracking_lifecycle_implementation | Implementation helper class for lifecycle events |
| CEvent_tracking_message_implementation | Implementation helper class for message events |
| CEvent_tracking_parse_implementation | Implementation helper class for parse events |
| CEvent_tracking_query_implementation | Implementation helper class for query events |
| CEvent_tracking_stored_program_implementation | Implementation helper class for stored_program events |
| CEvent_tracking_table_access_implementation | Implementation helper class for table_access events |
| ►Nfil | |
| ►Ndetail | |
| ►COpen_files_limit | |
| CDynamic_procedures | |
| ►Nfile | |
| CBlock | Blocks for doing IO, used in the transparent compression and encryption code |
| Nfile_info | |
| ►Ngis | |
| ►Nsrs | |
| ►Nwkt_parser | |
| CAuthority | |
| CAxis | |
| CDatum | |
| CGeographic_cs | |
| CPrime_meridian | |
| CProjected_cs | |
| CProjection | |
| CProjection_parameter | |
| CSpheroid | |
| CTowgs84 | |
| CTwin_axes | |
| CUnit | |
| CAlbers_equal_area_srs | An Albers Equal Area projection, alias Albers (EPSG 9822) |
| CAmerican_polyconic_srs | An American Polyconic projection, alias Polyconic (EPSG 9818) |
| CBonne_south_orientated_srs | A Bonne (South Orientated) projection (EPSG 9828) |
| CCassini_soldner_srs | A Cassini-Soldner projection, alias Cassini (EPSG 9806) |
| CColombia_urban_srs | A Colombia Urban projection(EPSG 1052) |
| CEquidistant_cylindrical_spherical_srs | An Equidistant Cylindrical (Spherical) projection (EPSG 1029) |
| CEquidistant_cylindrical_srs | An Equidistant Cylindrical projection (EPSG 1028) |
| CGeographic_srs | A geographic (longitude-latitude) spatial reference system |
| CGuam_projection_srs | A Guam Projection projection (EPSG 9831) |
| CHotine_oblique_mercator_variant_a_srs | A Hotine Oblique Mercator (variant A) projection, alias Rectified skew orthomorphic (EPSG 9812) |
| CHotine_oblique_mercator_variant_b_srs | A Hotine Oblique Mercator (variant B) projection, alias Rectified skew orthomorphic (EPSG 9815) |
| CHyperbolic_cassini_soldner_srs | A Hyperbolic Cassini-Soldner projection (EPSG 9833) |
| CKrovak_modified_north_orientated_srs | A Krovak Modified (North Orientated) projection (EPSG 1043) |
| CKrovak_modified_srs | A Krovak Modified projection (EPSG 1042) |
| CKrovak_north_orientated_srs | A Krovak (North Orientated) projection (EPSG 1041) |
| CKrovak_srs | A Krovak projection (EPSG 9819) |
| CLaborde_oblique_mercator_srs | A Laborde Oblique Mercator projection (EPSG 9813) |
| CLambert_azimuthal_equal_area_spherical_srs | A Lambert Azimuthal Equal Area (Spherical) projection (EPSG 1027) |
| CLambert_azimuthal_equal_area_srs | A Lambert Azimuthal Equal Area projection, alias Lambert Equal Area or LAEA (EPSG 9820) |
| CLambert_conic_conformal_1sp_srs | A Lambert Conic Conformal (1SP) projection, alias Lambert Conic Conformal or LCC (EPSG 9801) |
| CLambert_conic_conformal_2sp_belgium_srs | A Lambert Conic Conformal (2SP Belgium) projection (EPSG 9803) |
| CLambert_conic_conformal_2sp_michigan_srs | A Lambert Conic Conformal (2SP Michigan) projection (EPSG 1051) |
| CLambert_conic_conformal_2sp_srs | A Lambert Conic Conformal (2SP) projection, alias Lambert Conic Conformal or LCC (EPSG 9802) |
| CLambert_conic_conformal_west_orientated_srs | A Lambert Conic Conformal (West Orientated) projection (EPSG 9826) |
| CLambert_conic_near_conformal_srs | A Lambert Conic Near-Conformal projection (EPSG 9817) |
| CLambert_cylindrical_equal_area_spherical_srs | A Lambert Cylindrical Equal Area (Spherical) projection (EPSG 9834) |
| CLambert_cylindrical_equal_area_srs | A Lambert Cylindrical Equal Area projection (EPSG 9835) |
| CMercator_variant_a_srs | A Mercator (variant A) projection, alias Mercator (EPSG 9804) |
| CMercator_variant_b_srs | A Mercator (variant B) projection, alias Mercator (EPSG 9805) |
| CModified_azimuthal_equidistant_srs | A Modified Azimuthal Equidistant projection (EPSG 9832) |
| CNew_zealand_map_grid_srs | A New Zealand Map Grid projection (EPSG 9811) |
| COblique_stereographic_srs | An Oblique stereographic projection, alias Double stereographic (EPSG 9809) |
| CPolar_stereographic_variant_a_srs | A Polar Stereographic (variant A) projection (EPSG 9810) |
| CPolar_stereographic_variant_b_srs | A Polar Stereographic (variant B) projection (EPSG 9829) |
| CPolar_stereographic_variant_c_srs | A Polar Stereographic (variant C) projection (EPSG 9830) |
| CPopular_visualisation_pseudo_mercator_srs | A Popular Visualisation Pseudo Mercator projection (EPSG 1024) |
| CProjected_srs | A projected spatial reference system |
| CSpatial_reference_system | Superclass for all spatial reference systems |
| CTransverse_mercator_south_orientated_srs | A Transverse Mercator (South Orientated) projection, alias Gauss-Conform (EPSG 9808) |
| CTransverse_mercator_srs | A Transverse Mercator projection, alias Gauss-Boaga, Gauss-Krüger or TM (EPSG 9807) |
| CTransverse_mercator_zoned_grid_system_srs | A Transverse Mercator Zoned Grid System projection (EPSG 9824) |
| CTunisia_mining_grid_srs | A Tunisia Mining Grid projection (EPSG 9816) |
| CUnknown_projected_srs | A projected SRS of an unknown projection type |
| CArea | Area functor that calls boost::geometry::area with the correct parameter types |
| CBox | A 2d box with sides parallel to the coordinate system grid |
| CBuffer | Buffer functor that calls boost::geometry::buffer with correct geometry type and strategy combination |
| CBufferStrategies | |
| CCartesian_box | A Cartesian 2d box |
| CCartesian_geometrycollection | A Cartesian 2d geometry collection |
| CCartesian_linearring | A Cartesian 2d linear ring |
| CCartesian_linestring | A Cartesian 2d linestring |
| CCartesian_multilinestring | A Cartesian 2d multilinestring |
| CCartesian_multipoint | A Cartesian 2d multipoint |
| CCartesian_multipolygon | A Cartesian 2d multipolygon |
| CCartesian_point | A Cartesian 2d point |
| CCartesian_polygon | A Cartesian 2d polygon |
| CCoordinate_range_visitor | A visitor that checks if coordinates are within range for a spatial reference system |
| CCovered_by | Covered_by functor that calls Boost.Geometry with the correct parameter types |
| CCrosses | Crosses functor that calls Boost.Geometry with the correct parameter types |
| CCurve | An abstract 2d curve |
| CDifference | Difference functor that calls Boost.Geometry with the correct parameter types |
| CDisjoint | Disjoint functor that calls Boost.Geometry with the correct parameter types |
| CDistance | Distance functor that calls Boost.Geometry with the correct parameter types |
| CDistance_sphere | Functor that calls Boost.Geometry with the correct parameter types |
| CEquals | Equals functor that calls Boost.Geometry with the correct parameter types |
| CFrechet_distance | Frechet_distance functor that calls Boost.Geometry with the correct parameter types |
| CFunctor | The base class of all functors that takes two geometry arguments |
| CGeographic_box | A Geographic 2d box |
| CGeographic_geometrycollection | A geographic (ellipsoidal) 2d geometry collection |
| CGeographic_linearring | A geographic (ellipsoidal) 2d linear ring |
| CGeographic_linestring | A geographic (ellipsoidal) 2d linestring |
| CGeographic_multilinestring | A geographic (ellipsoidal) 2d multilinestring |
| CGeographic_multipoint | A geographic (ellipsoidal) 2d multipoint |
| CGeographic_multipolygon | A geographic (ellipsoidal) 2d multipolygon |
| CGeographic_point | A geographic (ellipsoidal) 2d point |
| CGeographic_polygon | A geographic (ellipsoidal) 2d polygon |
| CGeometry | Abstract superclass for all geometric objects |
| CGeometry_visitor | Abstract visitor class to be used on class Geometry and descendants |
| CGeometrycollection | A collection of geometries |
| CHausdorff_distance | HausdorffDistance functor that calls Boost.Geometry with the correct parameter types |
| CIntersection | Intersection functor that calls Boost.Geometry with the correct parameter types |
| CIntersects | Intersects functor that calls Boost.Geometry with the correct parameter types |
| Cinvalid_buffer_argument_exception | Invalid buffer strategies exception |
| Cinvalid_buffer_result_exception | Invalid buffer result exception |
| Cinvalid_geometry_exception | Invalid geometry exception |
| CIs_simple | Is_simple functor calls boost::geometry::is_simple with the correct parameter types |
| CIs_valid | |
| Clatitude_out_of_range_exception | Latitude out of range exception |
| CLength | Length functor that calls Boost.Geometry with the correct parameter types |
| CLine_interpolate_point | Line interpolate functor that calls boost::geometry::line_interpolate with the correct parameter types |
| CLinearring | A ring-shaped linestring |
| CLinestring | A string of connected line segments |
| Clongitude_out_of_range_exception | Longitude out of range exception |
| CLongitude_range_normalizer | |
| CMulticurve | An abstract collection of curves |
| CMultilinestring | A collection of linestrings |
| CMultipoint | A collection of points |
| CMultipolygon | A collection of polygons |
| CMultisurface | An abstract collection of surfaces |
| CNop_visitor | A visitor that implements the entire interface and does nothing |
| Cnot_implemented_exception | Function/parameter combination not implemented exception |
| Cnull_value_exception | NULL value exception |
| COverlaps | Overlaps functor that calls Boost.Geometry with the correct parameter types |
| CPoint | A 2d point |
| CPolygon | A polygon consisting of an outer ring and zero or more interior rings defining holes in the polygon |
| CRing_flip_visitor | A visitor that flips polygon rings so that exterior rings are in a counter-clockwise direction and interior rings in a clockwise direction |
| CSimplify | Simplify functor that calls Boost.Geometry with the correct parameter types |
| CSurface | An abstract 2d surface |
| CSymDifference | SymDifference functor that calls Boost.Geometry with the correct parameter types |
| Ctoo_large_polygon_exception | Too large polygon exception |
| CTouches | Touches functor that calls Boost.Geometry with the correct parameter types |
| CTransform | Transform functor that calls Boost.Geometry with the correct parameter types |
| CUnary_functor | The base class of all functors that take one geometry argument |
| CUnion | Union functor that calls Boost.Geometry with the correct parameter types |
| CUnit | |
| CWithin | Within functor that calls Boost.Geometry with the correct parameter types |
| CWkb_parser | |
| CWkb_size_visitor | A visitor that computes the size of a WKB representation of a geometry |
| CWkb_visitor | A visitor that serializes the geometry to little-endian WKB and appends it to a string |
| Nglobal_grants_check_all_empty_spc | |
| ►Ngr | |
| Nflow_control_metrics_service | |
| ►Nperfschema | |
| CAbstract_Pfs_table | |
| CPerfschema_module | |
| CPfs_table_communication_information | |
| CPfs_table_replication_group_configuration_version | |
| CPfs_table_replication_group_member_actions | |
| CPosition | |
| CRegistry_guard | |
| CReplication_group_communication_information | A row in the replication_group_communication_information table |
| CReplication_group_communication_information_table_handle | A structure to define a handle for table in plugin/component code |
| CReplication_group_configuration_version | A row in the replication_group_configuration_version table |
| CReplication_group_configuration_version_table_handle | A structure to define a handle for table in plugin/component code |
| CReplication_group_member_actions | A row in the replication_group_member_actions table |
| CReplication_group_member_actions_table_handle | A structure to define a handle for table in plugin/component code |
| Nstatus_service | |
| CCertified_gtid | Class that aggregates important information about already certified gtid |
| CGtid_generator | This class is responsible for generating GTIDs in the Certifier |
| CGtid_generator_for_sidno | Class that is responsible for holding available GTIDs and assigning GTID blocks to specific group members |
| ►Nhardware | |
| CCombination_step_executor | The body of unrolled loop used to combine partial results from each slice into the final hash of whole chunk, which in i-th iteration takes the crc of i-th slice and "rolls it forward" by virtually processing as many zeros as there are from the end of the i-th slice to the end of the chunk |
| Ccrc32_impl | The collection of functions implementing hardware accelerated updating of CRC32-C hash by processing a few (1,2,4 or 8) bytes of input |
| CLoop | A helper template to statically unroll a loop with a fixed number of iterations, where the iteration number itself is constexpr |
| CLoop< 0 > | |
| CUpdate_step_executor | The body of unrolled loop used to process slices in parallel, which in i-th iteration processes 8 bytes from the i-th slice of data, where each slice has slice_len bytes |
| Cuse_pclmul | Implementation of polynomial_mul_rev<w>(rev_u) function which uses hardware accelerated polynomial multiplication to compute rev(w*u), where rev_u=rev(u) |
| ►Cuse_unrolled_loop_poly_mul | Implementation of polynomial_mul_rev<w>(rev_u) function which uses a simple loop over i: if(w>>i&1)result^=rev_u<<(32-i), which is equivalent to w * flip_at_32(rev_u), which in turn is equivalent to rev(rev(w) * rev_u), |
| CPolynomial_mul_rev_step_executor | |
| ►Nhash_join_buffer | |
| ►Nanonymous_namespace{hash_join_buffer.cc} | |
| CKeyEquals | |
| CKeyHasher | |
| ►CHashJoinRowBuffer | |
| CHashMap | |
| ►Nhelper | |
| Ncontainer | |
| ►Nhistograms | |
| ►Nequi_height | |
| CBucket | Equi-height bucket |
| CBackground_error_handler | Custom error handling for histogram updates from the background thread |
| CEqui_height | |
| CError_context | Error context to validate given JSON object which represents a histogram |
| CHistogram | Histogram base class |
| CHistogram_comparator | Histogram comparator |
| CHistogram_psi_key_alloc | |
| CHistogramSetting | A simple struct containing the settings for a histogram to be built |
| CSingleton | |
| CSingletonBucket | |
| CValue_map | Value_map class |
| CValue_map_base | The abstract base class for all Value_map types |
| ►Nhttp | |
| ►Nbase | |
| ►Ndetails | |
| Cowned_buffer | |
| Cref_buffer | |
| Cref_buffers | |
| Nimpl | |
| ►Nmethod | |
| NPos | |
| Nstatus_code | |
| CConnection | |
| CConnectionInterface | |
| CConnectionStatusCallbacks | |
| CHeaders | Headers of a HTTP response/request |
| CIOBuffer | |
| CRequest | |
| CRequestHandler | |
| CUri | |
| ►Nclient | |
| ►Nanonymous_namespace{error_code.cc} | |
| CErrorCategory | |
| ►Nimpl | |
| CConfigSchema | |
| CConnection | |
| ►CClient | |
| CCallbacksPrivateImpl | |
| CEndpoint | |
| CStatistics | |
| CConnection | |
| CConsoleRawOut | |
| CConsoleSocketOut | |
| CPayloadCallback | |
| ►CRequest | |
| CHolder | |
| ►Ncno | |
| ►Nanonymous_namespace{error_code.cc} | |
| CErrorCategory | |
| ►CBufferSequence | |
| CIterator | |
| CCnoInterface | |
| CSequence | |
| ►Nserver | |
| Nanonymous_namespace{server.cc} | |
| CBind | |
| CRequestHandlerInterface | |
| CServer | |
| CServerConnection | |
| ►CServerRequest | HTTP request and response |
| CHolder | |
| CHttpServerContext | |
| NHttpMethod | |
| NHttpStatusCode | |
| ►Nhypergraph | |
| CHyperedge | |
| CHypergraph | |
| CNeighborhoodCache | |
| CNode | |
| ►Nib | |
| Cerror | The class error is used to emit error messages |
| Cerror_or_warn | Emit an error message if the given predicate is true, otherwise emit a warning message |
| Cfatal | The class fatal is used to emit an error message and stop the server by crashing it |
| Cfatal_or_error | Emit a fatal message if the given predicate is true, otherwise emit a error message |
| Chex | This is a wrapper class, used to print any unsigned integer type in hexadecimal format |
| Cinfo | The class info is used to emit informational log messages |
| Clogger | The class logger is the base class of all the error log related classes |
| CTester | This class contains implementations of the commands that can be executed at server side by passing them via the innodb_interpreter system variable |
| CThrottler | Allows to monitor an event processing times, allowing to throttle the processing to one per throttle_delay_sec |
| CTimer | For measuring time elapsed |
| Cwarn | The class warn is used to emit warnings |
| ►Nibt | |
| CTablespace | Session Temporary tablespace |
| CTablespace_pool | Pool of session temporary tablespaces |
| ►Nimpl | |
| ►CHttpServerComponentImpl | |
| CRouterData | |
| ►Ninnobase | |
| Ncomponent_services | |
| Nencryption | |
| ►Njson_binary | |
| CValue | Class used for reading JSON values that are stored in the binary format |
| ►Nkeyring_common | |
| ►Naes_encryption | |
| CAes_operation_context | |
| ►Ncache | |
| CDatacache | |
| ►Nconfig | |
| CConfig_reader | |
| ►Ndata | |
| CData | Sensitive data storage |
| CData_extension | Data wrapper to include backend specific extensions |
| ►Ndata_file | |
| CFile_reader | |
| CFile_writer | |
| ►Niterator | |
| CIterator | |
| ►Njson_data | |
| CJson_data_extension | |
| CJson_reader | Base Json_reader |
| CJson_writer | |
| ►Nmeta | |
| ►CMetadata | Common metadata |
| CHash | |
| ►Noperations | |
| CKeyring_operations | Keyring operations A class to perform operations on keyring |
| ►Nservice_definition | |
| CKeyring_aes_service_impl | |
| CKeyring_generator_service_impl | |
| CKeyring_keys_metadata_iterator_service_impl | |
| CKeyring_load_service_impl | |
| CKeyring_metadata_query_service_impl | |
| CKeyring_reader_service_impl | |
| CKeyring_writer_service_impl | |
| CLog_builtins_keyring | |
| ►Nservice_implementation | |
| CComponent_callbacks | |
| Nutils | |
| ►Nkeyring_file | |
| ►Nbackend | |
| CKeyring_file_backend | |
| ►Nconfig | |
| CConfig_pod | |
| ►Nkeyring_lockable | |
| ►Nkeyring_common | |
| Nservice_definition | |
| Cmy_h_keyring_keys_metadata_iterator_server | Wrapper over my_h_keyring_keys_metadata_iterator to associate RWlock |
| Cmy_h_keyring_reader_object_server | Error messages |
| Nkeyring_operations_helper | |
| ►Nkeyring_proxy | |
| CCallback | Class that stores callback function reference as well as the result of the callback function call (invoke method) |
| CKeyring_proxy_imp | A class that implements proxy keyring component services and calls keyring plugin APIs underneath |
| ►Nlob | Provides the large objects (LOB) module |
| ►Nbulk | |
| Cdata_page_t | |
| Cfirst_page_t | An adapter class for handling blobs in bulk load |
| Cindex_entry_t | This is the bulk version in the namespace lob::bulk |
| Cnode_page_t | |
| CBaseInserter | This struct can hold BLOB routines/functions, and state variables, that are common for compressed and uncompressed BLOB |
| Cbasic_page_t | |
| CBeing_modified | This is used to take action when we enter and exit a scope |
| Cblob_dir_t | The in-memory blob directory |
| Cblob_page_info_t | Information about data stored in one BLOB page |
| CBtrContext | The B-tree context under which the LOB operation is done |
| Cdata_page_t | The LOB data page carrying the user data |
| CDeleteContext | The context information when the delete operation on LOB is taking place |
| CDeleter | |
| Cfirst_page_t | The first page of an uncompressed LOB |
| Cfrag_node_t | The fragment node represents one fragment |
| Cindex_entry_mem_t | An in-memory copy of an index_entry_t data |
| Cindex_entry_t | An index entry pointing to an LOB page |
| CInsertContext | The context for a LOB operation |
| CInserter | Insert or write an uncompressed BLOB |
| Cnode_page_t | The node page (also can be called as the index page) contains a list of index_entry_t objects |
| Cplist_base_node_t | The base node of page list |
| Cplist_node_t | The node of page list |
| CReadContext | The context information for reading a single BLOB |
| CReader | Fetch uncompressed BLOB |
| Cref_mem_t | In memory representation of the LOB reference |
| Cref_t | The struct 'lob::ref_t' represents an external field reference |
| Cundo_data_t | Undo information about LOB data alone without including LOB index |
| Cundo_seq_t | Container to hold a sequence of undo log records containing modification of BLOBs |
| Cundo_vers_t | The list of modifications to be applied on LOBs to get older versions |
| Cz_data_page_t | The data page holding the zlob |
| Cz_first_page_t | The first page of an zlob |
| Cz_frag_entry_t | An entry representing one fragment page |
| Cz_frag_node_page_t | A frag nodes page containing an array of z_frag_entry_t objects |
| Cz_frag_page_t | The fragment page |
| Cz_index_entry_mem_t | In-memory copy of the information from z_index_entry_t |
| Cz_index_entry_t | An index entry pointing to one zlib stream |
| Cz_index_page_t | An index page containing an array of z_index_entry_t objects |
| CzInserter | Insert or write the compressed BLOB as a single zlib stream |
| CzReader | Fetch compressed BLOB |
| ►Nlocal | |
| Nsocket_option | |
| Cbasic_endpoint | Endpoint of Unix domain sockets (AF_UNIX) |
| Cdatagram_protocol | |
| Cseqpacket_protocol | |
| Cstream_protocol | |
| ►Nlock | Provides atomic access in shared-exclusive modes |
| ►CShared_spin_lock | |
| CGuard | Sentry class for Shared_spin_lock to deliver RAII pattern usability |
| ►Nlocksys | |
| CConflicting | |
| CGlobal_exclusive_latch_guard | A RAII helper which latches global_latch in exclusive mode during constructor, and unlatches it during destruction, preventing any other threads from activity within lock_sys for it's entire scope |
| CGlobal_exclusive_try_latch | A RAII helper which tries to exclusively latch the global_lach in constructor and unlatches it, if needed, during destruction, preventing any other threads from activity within lock_sys for it's entire scope, if owns_lock() |
| CGlobal_shared_latch_guard | A RAII helper which latches global_latch in shared mode during constructor, and unlatches it during destruction, preventing any other thread from acquiring exclusive latch |
| ►CLatches | The class which handles the logic of latching of lock_sys queues themselves |
| CPage_shards | |
| CTable_shards | |
| CUnique_sharded_rw_lock | A helper wrapper around Shared_rw_lock which simplifies: |
| CShard_latch_guard | A RAII wrapper class which combines Global_shared_latch_guard and Shard_naked_latch_guard to s-latch the global lock_sys latch and latch the mutex protecting the specified shard for the duration of its scope |
| CShard_latches_guard | A RAII wrapper class which s-latches the global lock_sys shard, and mutexes protecting specified shards for the duration of its scope |
| CShard_naked_latch_guard | A RAII helper which latches the mutex protecting given shard during constructor, and unlatches it during destruction |
| CShard_naked_latches_guard | A RAII helper which latches the mutexes protecting specified shards for the duration of its scope |
| CTrx_locks_cache | An object which can be passed to consecutive calls to rec_lock_has_to_wait(trx, mode, lock, is_supremum, trx_locks_cache) for the same trx and heap_no (which is implicitly the bit common to all lock objects passed) which can be used by this function to cache some partial results |
| CUnsafe_global_latch_manipulator | |
| Nlog_files | |
| NLog_files_write_impl | |
| ►Nlog_pre_8_0_30 | |
| CCheckpoint_header | Meta data stored in one of two checkpoint headers |
| ►Nmanifest | |
| CManifest_reader | |
| ►NMatcher | |
| COne | Matches one character in a list of possible candidates |
| COne< Arg > | |
| CRange | Matches a Range of characters |
| CSor | Matches Rules left-to-right with OR |
| CSor<> | |
| ►Nmaterialize_iterator | |
| COperand | An operand (query block) to be materialized by MaterializeIterator |
| Nmdl_unittest | |
| ►Nmeb | |
| CBlock | Encapsulates a log block of size QUEUE_BLOCK_SIZE, enqueued by the producer, dequeued by the consumer and written into the redo log archive file |
| CDynamic_procedures | This component's UDFs.mysql |
| CGuardian | |
| CQueue | This template class implements a queue that, |
| ►Nmemory | |
| Ntraits | |
| CAligned_atomic | Templated class that encapsulates an std::atomic within a byte buffer that is padded to the processor cache-line size |
| CAligned_atomic_accessor | Template that may access Aligned_atomic internals |
| Cis_allocator | Struct that allows for checking if T fulfills the Allocator named requirements |
| CPFS_allocator | Allocator class for instrumenting allocated memory with Performance Schema keys |
| CRef_ptr | Class that holds the pointer to a variable in a static and non-destructible way |
| CUnique_ptr | Smart pointer to hold a unique pointer to a heap allocated memory of type T, constructed using a specific allocator |
| ►Nmetadata_cache | |
| CAcceptorUpdateHandlerInterface | Abstract class that provides interface for listener on whether the listening sockets acceptors state should be updated |
| CClusterStateListenerInterface | Abstract class that provides interface for listener on cluster status changes |
| CClusterStateNotifierInterface | Abstract class that provides interface for adding and removing observers on cluster status changes |
| CClusterTopology | Represents a cluster (a GR group or AR members) and its metadata servers |
| CLogSuppressor | |
| CManagedCluster | Represents a cluster (a GR group or AR members) |
| CManagedInstance | Class ManagedInstance represents a server managed by the topology |
| Cmetadata_error | Class that represents all the exceptions that are thrown while fetching the metadata |
| ►CMetadataCacheAPI | |
| CInstData | |
| ►CMetadataCacheAPIBase | |
| CRefreshStatus | |
| CMetadataCacheMySQLSessionConfig | Metadata MySQL session configuration |
| CMetadataCacheTTLConfig | Metadata TTL configuration |
| CMetadataRefreshListenerInterface | Abstract class that provides interface for listener on metadata refresh |
| CRouterAttributes | |
| Nmfa_consts | |
| ►Nminimal_chassis | |
| Crwlock_scoped_lock | Locks RW-lock and releases lock on scope exit |
| ►Nmock | |
| Cha_mock | The MOCK storage engine is used for testing MySQL server functionality related to secondary storage engines |
| Nmy_testing | |
| Nmycrc32 | |
| ►Nmysql | |
| ►Nabi_helpers | |
| ►Ndetail | |
| CArray_base | Base class for specific implementations of standard-layout classes for arrays |
| CArray_view | Ownership-agnostic array class, which is both trivial and standard-layout |
| CField | A type code and a value that is either a 64 bit integer, a boolean, or a bounded-length string |
| CPacket_builder | Class to help constructing a Packet, by pushing values one by one |
| ►Nallocators | |
| CAllocator | Allocator using a Memory_resource to do the allocator |
| CMemory_resource | Polymorphism-free memory resource class with custom allocator and deallocator functions |
| ►Nbinlog | |
| ►Nevent | The namespace contains classes representing events that can occur in a replication stream |
| ►Ncodecs | |
| ►Nbinary | |
| CBase_codec | This is the abstract and base class for binary log BINARY codecs |
| CHeartbeat | Binary codec for the heartbeat log event |
| CTransaction_payload | Binary codec for the transaction payload log event |
| CCodec | This is the abstract and base class for binary log codecs |
| CFactory | |
| ►Ncompression | |
| CCompressor | Abstract base class for compressors |
| CDecompressor | Abstract base class for decompressors |
| CFactory | |
| CNone_comp | Compressor subclass that only copies input to output without compressing it |
| CNone_dec | Decompressor subclass that only copies input to output without decompressing it |
| CPayload_event_buffer_istream | Stream class that yields a stream of byte buffers, each holding the raw decompressed data of one event contained in a Transaction_payload_log_event |
| CZstd_comp | Compressor class that uses the ZSTD library |
| CZstd_dec | Decompressor class that uses the ZSTD library |
| Ndebug | |
| CAppend_block_event | This event is created to contain the file data |
| CBegin_load_query_event | Event for the first block of file to be loaded, its only difference from Append_block event is that this event creates or truncates existing file before writing data |
| CBinary_log_event | This is the abstract base class for binary log events |
| CDelete_file_event | DELETE_FILE_EVENT occurs when the LOAD DATA failed on the master |
| CDelete_rows_event | Log row deletions |
| CEvent_reader | Event_reader class purpose is to avoid out-of-buffer reads when deserializing binary log events and increase robustness when dealing with corrupted event buffers |
| CExecute_load_query_event | Event responsible for LOAD DATA execution, it similar to Query_event but before executing the query it substitutes original filename in LOAD DATA query with name of temporary file |
| CFormat_description_event | For binlog version 4 |
| CGtid_event | GTID stands for Global Transaction IDentifier It is composed of two parts: |
| Cgtid_info | Structure to hold the members declared in the class Gtid_log_event those member are objects of classes defined in server(rpl_gtid.h) |
| CHeartbeat_event | Replication event to ensure to replica that source is alive |
| CHeartbeat_event_v2 | Replication event to ensure to replica that source is alive |
| CIgnorable_event | Base class for ignorable log events |
| CIncident_event | Class representing an incident, an occurrence out of the ordinary, that happened on the master |
| CIntvar_event | An Intvar_event will be created just before a Query_event, if the query uses one of the variables LAST_INSERT_ID or INSERT_ID |
| CLog_event_basic_info | Holds basic information about an event: common-header fields, query, etc |
| CLog_event_footer | The footer, in the current version of the MySQL server, only contains the checksum algorithm descriptor |
| CLog_event_header | The Common-Header always has the same form and length within one version of MySQL |
| CLog_event_type_helper | Event type helpers, enclosed in the structure |
| CPrevious_gtids_event | |
| CQuery_event | A Query_event is created for each query that modifies the database, unless the query is logged row-based |
| CRand_event | Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0 |
| CRotate_event | When a binary log file exceeds a size limit, a ROTATE_EVENT is written at the end of the file that points to the next file in the sequence |
| ►CRows_event | Common base class for all row-containing binary log events |
| CExtra_row_info | |
| CRows_query_event | Rows query event type, which is a subclass of the Ignorable_event, to record the original query for the rows events in RBR |
| CStop_event | A stop event is written to the log files under these circumstances: |
| CTable_id | Each table share has a table id, it is mainly used for row based replication |
| ►CTable_map_event | In row-based mode, every row operation event is preceded by a Table_map_event which maps a table definition to a number |
| ►COptional_metadata_fields | Metadata_fields organizes m_optional_metadata into a structured format which is easy to access |
| CDefault_charset | |
| CTransaction_boundary_parser | This is the base class for verifying transaction boundaries |
| CTransaction_context_event | This class is used to combine the information of the ongoing transaction including the write set and other information of the thread executing the transaction |
| CTransaction_payload_event | Event that encloses all the events of a transaction |
| CUnknown_event | An unknown event should never occur |
| CUpdate_rows_event | Log row updates with a before image |
| CUser_var_event | Written every time a statement uses a user variable; precedes other events for the statement |
| CView_change_event | This class is used to add view change markers in the binary log when a member of the group enters or leaves the group |
| CWrite_rows_event | Log row insertions |
| ►CXA_prepare_event | An XA_prepare event is generated for a XA prepared transaction |
| CMY_XID | |
| CXid_event | An XID event is generated for a commit of a transaction that modifies one or more tables of an XA-capable storage engine |
| ►Ncollation | |
| CName | Normalizes character set/collation names |
| ►Ncollation_internals | |
| CCollations | Helper class: implementation of character set/collation library |
| ►Ncontainers | |
| ►Nbuffers | |
| ►Nmanaged_buffer_sequence | |
| ►Nunittest | |
| CAccessor | |
| CBuffer_sequence_view | Sequence of memory buffers |
| CBuffer_view | Non-owning view of a memory buffer with a fixed size |
| CGrow_calculator | Description of a heuristic to determine how much memory to allocate |
| CGrow_constraint | Description of a heuristic to determine how much memory to allocate |
| CManaged_buffer | Owned, growable, contiguous memory buffer |
| CManaged_buffer_sequence | Owned, non-contiguous, growable memory buffer |
| CPreallocated_managed_buffer | |
| CRw_buffer | Non-owning read/write memory buffer manager with a fixed size |
| CRw_buffer_sequence | Non-owning manager for a fixed sequence of memory buffers, which is split into a read part and a write part, with a movable split position |
| ►Ngtid | |
| Ninternal | |
| CGno_interval | This class represents a range of transaction identifiers |
| CGtid | Represents a MySQL Global Transaction Identifier |
| CGtid_set | This class represents a set of transaction identifiers |
| ►CTag | Representation of the GTID tag |
| CHash | Structure to compute hash function of a given Tag object |
| CTag_plain | Tag representation so that: |
| ►CTsid | Represents Transaction Source Identifier which is composed of source UUID and transaction tag |
| CHash | Structure to compute hash function of a given Tag object |
| CTsid_plain | TSID representation so that: |
| CUuid | Uuid is a trivial and of standard layout The structure contains the following components |
| CUuid_hash | |
| Nmath | |
| ►Nserialization | |
| Ndetail | |
| CArchive | Interface for archives (file archive, byte vector archive, string archive etc.), available only to instances implementing Serializable interface and Archive interface |
| CArchive_binary | Binary archive implementation based on vector of bytes |
| CArchive_binary_field_max_size_calculator | Helper structure created for partial specialization of get_max_size function of Archive_binary, default version |
| CArchive_binary_field_max_size_calculator< std::string, S > | Helper structure created for partial specialization of get_max_size function of Archive_binary, version for std::string fields |
| CArchive_binary_field_max_size_calculator< T, 0 > | Helper structure created for partial specialization of get_max_size function of Archive_binary, specialization for defined size equal to 0 |
| CArchive_text | Archive implementation based on stringstream |
| CByte_count_helper | Structure that contains methods to count the number of bytes needed to encode a specific field |
| CByte_count_helper< 0 > | Specialization of Byte_count_helper for 0 field_size |
| CField_definition | Field definition provided by classes implementing Serializable interface |
| CField_definition_tag | Used to distinguish between Serializable and Field_definition types |
| CField_wrapper | Wrapper for fields to hold field reference and user-defined, compile-time field size |
| CField_wrapper< const Field_type, defined_field_size > | Wrapper for fields to hold field reference and defined by the user compile time size of the field |
| Cis_std_array | |
| Cis_std_array< std::array< T, N > > | |
| CPrimitive_type_codec | This class is to provide functionality to encode/decode the primitive types into/out of defined stream, without boundary check |
| CRead_archive_binary | Binary, read only archive implementation based on vector of bytes |
| CSerializable | Interface for serializable data structures |
| CSerializable_size_calculator | |
| CSerializable_size_calculator< Serializer_type, std::tuple< Args... > > | Helper struct used to determine Serializable tuple max declared size |
| CSerializable_size_calculator_helper | |
| CSerializable_size_calculator_helper< Serializer_type, Field_definition< T, S > > | Helper struct used to determine Field_definition declared max size |
| CSerializable_tag | Used to distinguish between Serializable and Field_definition types |
| CSerialization_error | Error used internally in serialization framework |
| CSerializer | Interface for serializer |
| CSerializer_array_tag | Helper tag for array types to help compiler pick the correct method |
| CSerializer_default | Basic serializer that is implementing Serializer interface |
| CSerializer_enum_tag | Helper tag for enum types to help compiler pick the correct method |
| CSerializer_map_tag | Helper tag for map types to help compiler pick the correct method |
| CSerializer_serializable_tag | Helper tag for serializable types to help compiler pick the correct method |
| CSerializer_set_tag | Helper tag for set types to help compiler pick the correct method |
| CSerializer_vector_list_tag | Helper tag for vector types to help compiler pick the correct method |
| CWrite_archive_binary | Binary, write only archive implementation based on vector of bytes |
| ►Nutils | |
| Ninternal | |
| CError | Error representation used internally in case final error code is unknown and error situation handling needs to be done by the caller |
| CIs_specialization | Helper struct used to determine at compile time whether a given type T is a template specialization of the Primary |
| CIs_specialization< Primary< Args... >, Primary > | Helper struct used to determine at compile time whether a given type T is a template specialization of the Primary |
| Ccondition_variable | Condition_variable is a C++ STL conditional variable (std::condition_variable) implementation using the instrumented MySQL conditional variable component API |
| Cmutex | Mutex is a C++ STL mutex (std::mutex) implementation using the instrumented MySQL mutex component API |
| ►NMysql | |
| ►NTools | |
| ►NCheck | |
| CProgram | This class is object wrapper to mysql_check function |
| Nmysql_cond_v1_native | |
| Nmysql_current_thread_reader_all_empty_spc | |
| Nmysql_dynamic_privilege_register_all_empty_spc | |
| ►Nmysql_harness | |
| Nanonymous_namespace{random_generator.cc} | |
| Nanonymous_namespace{string_utils.cc} | |
| ►Ndetail | |
| Rrange | |
| ►Nimpl | |
| CDeleter_SSL | |
| ►Nloader | |
| Noptions | |
| ►Nlogging | |
| Noptions | Option name used in config file (and later in configuration object) to specify log level |
| CDomainLogger | |
| CFileHandler | Handler that writes to a file |
| CHandler | Base class for log message handler |
| CLogger | Logger class |
| CNullHandler | Handler to write to a null device such as /dev/null (unix) or NUL (windows) |
| CRecord | Log record containing information collected by the logging system |
| CRegistry | |
| CStreamHandler | Handler to write to an output stream |
| ►Nposix | |
| ►Naccess_rights | |
| CAllowPermissionVerifier | Allows permissions |
| CDenyPermissionVerifier | Denies permissions |
| ►Nutility | |
| ►CRange | Class to turn C array into range |
| Citerator | |
| CRangeReverse | Class for creating a reverse range from another range |
| Cbad_option | Exception thrown for option problems |
| Cbad_option_value | Exception thrown for option value problems |
| Cbad_section | Exception thrown for section problems |
| CBasePluginConfig | Retrieve and manage plugin configuration |
| CBoolOption | |
| ►CBuiltinPlugins | Singleton class implementing registry of the built-in MySQLRouter plugins |
| CPluginInfo | Stores the information about a single built-in plugin |
| CConfig | Configuration |
| CConfigBuilder | Builder for MySQL Router config files |
| CConfigSection | Configuration section |
| Cdecryption_error | |
| ►CDIM | |
| CRWLockedUniquePtr | |
| ►CDirectory | Class representing a directory in a file system |
| ►CDirectoryIterator | Directory iterator for iterating over directory entries |
| ►CState | |
| Cfree_dealloc | |
| CDurationOption | |
| ►CDynamicConfig | Respresents the current Router configuration |
| CSectionConfig | |
| CDynamicLibrary | A DynamicLibrary |
| CDynamicLoader | Loader for DynamicLibrary |
| ►CDynamicState | DynamicState represents a MySQLRouter dynamic state object |
| CPimpl | |
| CEventStateTracker | EventStateTracker singleton object keeps track of the current known state of selected event |
| CFakeRandomGenerator | |
| CFloatingPointOption | |
| CIntOption | |
| Cinvalid_master_keyfile | |
| CKeyring | Keyring interface |
| CKeyringFile | KeyringFile class |
| CKeyringMemory | KeyringMemory class |
| ►CLoader | |
| CPluginInfo | Holds plugin's API call information |
| CLoaderConfig | Configuration file handler for the loader |
| ►CLogReopen | |
| CThreadState | |
| CLogReopenComponent | Component that manages the reopening of logfiles |
| CMasterKeyFile | |
| ►CMPMCQueueMS2Lock | Unbounded multi-producer multi-consumer queue |
| CNode | |
| ►CMPSCQueueDV | Unbounded multi-producer single-consumer queue |
| CNode | |
| Cmysql_router_thread_handle | |
| CMySQLRouterThread | MySQLRouterThread provides higher level interface to managing threads |
| Coption_empty | Exception that gets thrown when the configuration option is present but it is empty value |
| Coption_not_present | Exception that gets thrown when the configuration option is missing |
| CPath | Class representing a path in a file system |
| CPluginFuncEnv | PluginFuncEnv object |
| CPluginThreads | |
| CProcessLauncher | |
| CProcessStateComponent | Manages the state of the process |
| CRandomGenerator | |
| CRandomGeneratorInterface | |
| CRange | Convenience class for handling iterator range |
| CSectionConfigExposer | Base class for a plugin specific specializations |
| CShutdownPending | |
| CSignalHandler | |
| CSocketOperations | This class provides a "real" (not mock) implementation |
| ►CSocketOperationsBase | Base class to allow multiple SocketOperations implementations (at least one "real" and one mock for testing purposes) |
| CLocalHostnameResolutionError | Exception thrown by get_local_hostname() on error |
| CSpawnedProcess | Alive, spawned process |
| CStringOption | |
| Csyntax_error | Exception thrown for syntax errors |
| CTCPAddress | Defines an IP address with port number |
| CUniquePtr | |
| CWaitingQueueAdaptor | Provide waiting pop and push operator to thread-safe queues |
| Nmysql_mutex_v1_native | |
| ►Nmysql_query_attributes | |
| Citerator | Iterator over the THD::bind_parameter_values collection |
| Nmysql_service_component_status_var_service_spc | |
| Nmysql_service_component_sys_var_service_spc | |
| Nmysql_service_mysql_system_variable_spc | |
| Nmysql_service_simple_error_log_noop_spc | |
| Nmysql_service_simple_error_log_spc | |
| Nmysql_string_spc | |
| Nmysql_thd_security_context_all_empty_spc | |
| Nmysql_udf_metadata_all_empty_spc | |
| ►Nmysqld | |
| Nruntime | |
| Nmysqld_funcs_unit_test | |
| ►Nmysqlrouter | |
| ►Nanonymous_namespace{cluster_metadata.cc} | |
| CConfigurationDefaults | |
| ►Nimpl | |
| COption | Gettable, settable option for mysql_option's |
| COption< Opt, const char * > | Gettable, settable option for 'const char *' based mysql_option's |
| COption< Opt, std::nullptr_t > | |
| CAutoCleaner | Automatic cleanup on scope exit utility class |
| CClusterInfo | |
| CClusterMetadata | |
| CClusterMetadataAR | |
| CClusterMetadataGR | |
| CClusterMetadataGRInClusterSet | |
| CClusterMetadataGRV2 | |
| ►CConfigGenerator | |
| CExistingConfigOptions | |
| ►COptions | |
| CEndpoint | |
| CTLS_filenames | |
| CUndoCreateAccountList | |
| CInstanceAttributes | |
| CLogFilter | |
| CMetadataSchemaVersion | |
| CMetadataUpgradeInProgressException | |
| CMySQLClientThreadToken | Thread Token for libmysqlclient API users |
| CMysqlError | |
| ►CMySQLSession | |
| CError | |
| CMYSQL_RES_Deleter | |
| CResultRow | |
| CTransaction | |
| CSQLLogFilter | A SQLLogFilter allows to replace substrings defined by a set of hardcoded regular expressions with '***' |
| ►Csqlstring | |
| Csqlstringformat | |
| CSSLOptions | SSL connection related options |
| CSysUserOperations | This class provides implementations of SysUserOperationsBase methods |
| CSysUserOperationsBase | Base class to allow multiple SysUserOperations implementations |
| CTargetCluster | |
| CURI | Parse and create URIs according to RFC3986 |
| CURIError | Exception when URI was not valid |
| CURIParser | |
| CUserCredentials | |
| ►NMysqlx | |
| ►NConnection | |
| CCapabilities | Capabilities |
| CCapabilitiesGet | Get supported connection capabilities and their current state |
| CCapabilitiesSet | Set connection capabilities atomically |
| CCapability | Capability |
| CClose | Announce to the server that the client wants to close the connection |
| CCompression | |
| ►NCrud | Basic CRUD operations |
| CCollection | |
| CColumn | |
| CCreateView | CreateView create view based on indicated Mysqlx::Crud::Find message |
| CDelete | Delete documents/rows from a Collection/Table |
| CDropView | DropView removing existing view |
| CFind | Find Documents/Rows in a Collection/Table |
| ►CInsert | Insert documents/rows into a collection/table |
| CTypedRow | Set of fields to insert as a one row |
| CLimit | |
| CLimitExpr | LimitExpr, in comparison to Limit, is able to specify that row_count and offset are placeholders |
| CModifyView | ModifyView modify existing view based on indicated Mysqlx::Crud::Find message |
| COrder | Sort order |
| CProjection | |
| CUpdate | Update documents/rows in a collection/table |
| CUpdateOperation | |
| ►NCursor | Handling of Cursors |
| CClose | Close cursor |
| CFetch | Fetch next portion of data from a cursor |
| ►COpen | Open a cursor |
| COneOfMessage | |
| ►NDatatypes | Data types |
| CAny | A helper to allow all field types |
| CArray | An Array |
| ►CObject | An object |
| CObjectField | |
| ►CScalar | |
| COctets | Opaque octet sequence, with an optional content_type See Mysqlx::Resultset::ContentType_BYTES for list of known values |
| CString | String with a charset/collation |
| ►NExpect | Expect operations |
| CClose | Close a Expect block |
| ►COpen | Open an Expect block and set/unset the conditions that have to be fulfilled |
| CCondition | |
| ►NExpr | Expressions |
| CArray | An array of expressions |
| CColumnIdentifier | Column identifier |
| CDocumentPathItem | Document path item |
| CExpr | The "root" of the expression tree |
| CFunctionCall | Function call: func(a, b, "1", 3) |
| CIdentifier | Identifier: name, schame.name |
| ►CObject | An object (with expression values) |
| CObjectField | |
| COperator | Operator: <<(a, b) |
| ►NNotice | A notice |
| CFrame | Common frame for all notices |
| CGroupReplicationStateChanged | Notify clients about group replication state changes |
| CServerHello | Notify clients about connection to X Protocol server |
| CSessionStateChanged | Notify clients about changes to the internal session state |
| CSessionVariableChanged | Notify clients about changes to the current session variables |
| CWarning | Server-side warnings and notes |
| ►NPrepare | Handling of prepared statments |
| CDeallocate | Deallocate already-prepared statement |
| CExecute | Execute already-prepared statement |
| ►CPrepare | Prepare a new statement |
| COneOfMessage | |
| ►NResultset | Resultsets |
| CColumnMetaData | Meta data of a column |
| CFetchDone | All resultsets are finished |
| CFetchDoneMoreOutParams | Resultsets are finished, OUT paramset is next: |
| CFetchDoneMoreResultsets | Resultset and out-params are finished, but more resultsets available |
| CFetchSuspended | Cursor is opened; still, the execution of PrepFetch or PrepExecute ended |
| CRow | Row in a Resultset |
| ►NSession | Messages to manage sessions |
| CAuthenticateContinue | Send by client or server after an Mysqlx::Session::AuthenticateStart to exchange more authentication data |
| CAuthenticateOk | Sent by the server after successful authentication |
| CAuthenticateStart | The initial message send from the client to the server to start the authentication process |
| CClose | Close the current session |
| CReset | Reset the current session |
| ►NSql | Messages of the MySQL Package |
| CStmtExecute | |
| CStmtExecuteOk | Statement executed successfully |
| CClientMessages | IDs of messages that can be sent from client to the server |
| CError | Generic Error message |
| COk | Generic Ok message |
| Coption | |
| CServerMessages | IDs of messages that can be sent from server to client |
| Nmysys_my_time | (end of defgroup MY_TIME) |
| Nmysys_priv | |
| Nmyu | |
| ►Nnet | |
| ►Nimpl | |
| Nepoll | |
| ►Nfile | |
| Cfile_control_option | |
| Cfile_control_option< Name, void > | |
| Npoll | |
| Nresolver | |
| ►Nsocket | |
| CSocketService | |
| CSocketServiceBase | |
| ►CCallstack | Callstack of a thread |
| CContext | |
| CIterator | Forward-iterator over stack frames |
| CDispatcher | Function object for net::dispatch(), net::post(), net::defer() |
| Cdynamic_buffer_base | |
| Cis_buffer_sequence | |
| Cis_buffer_sequence< T, BufferType, std::void_t< buffer_sequence_requirements< T, BufferType > > > | |
| Cis_const_buffer_sequence | |
| Cis_dynamic_buffer | |
| Cis_dynamic_buffer< T, decltype(dynamic_buffer_requirements< T >())> | |
| Cis_executor | |
| Cis_executor< T, decltype(executor_requirements< T >())> | |
| Cis_mutable_buffer_sequence | |
| Cuses_executor | |
| Cuses_executor< T, Executor, std::void_t< typename T::executor_type > > | |
| ►Nip | |
| Caddress | |
| ►Caddress_v4 | |
| Cbytes_type | |
| ►Caddress_v6 | IPv6 address with scope_id |
| Cbytes_type | |
| Cbad_address_cast | |
| Cbasic_address_iterator | |
| Cbasic_address_iterator< address_v4 > | |
| Cbasic_address_iterator< address_v6 > | |
| Cbasic_address_range | |
| Cbasic_address_range< address_v4 > | |
| Cbasic_address_range< address_v6 > | |
| Cbasic_endpoint | |
| Cbasic_resolver | |
| Cbasic_resolver_entry | Endpoint of IPv4/IPv6 based connection |
| Cbasic_resolver_results | |
| Cnetwork_v4 | |
| Cnetwork_v6 | |
| Cresolver_base | |
| Ctcp | TCP protocol |
| Cudp | |
| ►Nsocket_option | |
| Coption_base | Base-class of socket options |
| ►Ntls | |
| CAsyncAction | |
| CFlexibleBuffer | |
| CFlexibleInputBuffer | |
| CFlexibleOutputBuffer | |
| CLowerLayerHandshakeCompletionToken | |
| CLowerLayerReadCompletionToken | |
| CLowerLayerWriteCompletionToken | |
| CNOP_token | |
| ►COperation | |
| CAnalyzeOperation | |
| CSslHandshakeClientOperation | |
| CSslIoCompletionToken | |
| CSslReadOperation | |
| CSslWriteOperation | |
| ►CSyncAction | |
| CUnexpected | |
| ►CTlsBase | |
| CFree | |
| CTlsStream | |
| Cassociated_allocator | |
| Cassociated_allocator_impl | |
| Cassociated_allocator_impl< T, ProtoAllocator, std::void_t< typename T::allocator_type > > | |
| Cassociated_executor | |
| Cassociated_executor_impl | |
| Cassociated_executor_impl< T, Executor, std::void_t< typename T::executor_type > > | |
| Casync_completion | |
| Casync_result | |
| Cbasic_datagram_socket | |
| Cbasic_socket | |
| Cbasic_socket_acceptor | |
| ►Cbasic_socket_impl | |
| CIoControl | |
| Cbasic_socket_impl_base | Template-less base-class of basic_socket_impl |
| Cbasic_stream_socket | |
| ►Cbasic_waitable_timer | |
| CId | |
| Cconst_buffer | |
| Cconsuming_buffers | |
| Cdynamic_string_buffer | |
| Cdynamic_vector_buffer | |
| ►Cexecution_context | |
| Cservice | |
| CServicePtr | |
| Cexecutor_arg_t | |
| Cexecutor_binder | |
| Cexecutor_work_guard | |
| Cfd_event | |
| CInterfaceFlag | Flags of the network interface |
| ►Cio_context | |
| Casync_op | Base class of async operation |
| Casync_op_impl | Async operation with callback |
| CAsyncOps | |
| ►CDeferredWork | Queued work from io_context::executor_type::dispatch()/post()/defer() |
| CBasicCallable | |
| CCallable | |
| Cexecutor_type | |
| Cmonitor | |
| ►Ctimer_queue | |
| Cpending_timer | |
| Cpending_timer_op | |
| Ctimer_queue_base | |
| CIoServiceBase | |
| Cis_const_buffer_sequence | |
| Cis_dynamic_buffer | |
| Cis_executor | |
| Cis_executor< io_context::executor_type > | |
| Cis_mutable_buffer_sequence | |
| ►Clinux_epoll_io_service | |
| ►CFdInterest | |
| Clocked_bucket | |
| Cmutable_buffer | |
| CNetworkInterfaceEntry | Entry in the network interface result |
| CNetworkInterfaceNetworks | Networks of a network interface |
| CNetworkInterfaceResolver | |
| CNetworkInterfaceResults | Results of a NetworkInterfaceResolver::query() |
| ►Cpoll_io_service | Io_service based on the poll() system-call |
| CFdInterests | |
| Cprepared_buffers | |
| Cservice_already_exists | |
| ►Csocket_base | |
| Clinger | Socket option for SO_LINGER |
| Cmsg_hdr | |
| Cstrand | |
| ►Csystem_context | |
| C__tag | |
| Csystem_executor | |
| Ctransfer_all | |
| Ctransfer_at_least | |
| Ctransfer_exactly | |
| Cuses_executor | |
| Cwait_traits | |
| ►Noci | |
| ►Nssl | |
| CASN1_TIME_deleter | |
| CBIO_deleter | |
| CEVP_MD_CTX_deleter | |
| CEVP_PKEY_deleter | |
| CKey_Content | |
| CX509_deleter | |
| COCI_config_file | |
| CSigning_Key | |
| ►Nopenssl | |
| ►CDigestCtx | |
| CDeleter | |
| CDigestFunc | |
| ►Nopt_explain_json_namespace | |
| Ccontext | Base class for all intermediate tree nodes |
| Cduplication_weedout_ctx | Context class to represent JOIN_TABs in duplication weedout sequence |
| Cjoin_ctx | Node class for the CTX_JOIN context |
| Cjoin_tab_ctx | Node class for the CTX_QEP_TAB context |
| Cjoinable_ctx | Base for CTX_QEP_TAB, CTX_DUPLICATES_WEEDOUT and CTX_MATERIALIZATION nodes |
| Cmaterialize_ctx | Context class to group materialized JOIN_TABs to "materialized" array |
| Cmessage_ctx | Node class for CTX_MESSAGE |
| Csetop_ctx | Node class for UNION, EXCEPT, INTERSECT, UNARY (query expression) |
| Csetop_result_ctx | Node class for the CTX_UNION_RESULT |
| Csimple_sort_ctx | Base class for CTX_ORDER_BY, CTX_GROUP_BY and node class for CTX_DISTINCT |
| Csimple_sort_with_subqueries_ctx | Node class for "simple" CTX_ORDER_BY and CTX_GROUP_BY |
| Csort_ctx | Node class for CTX_SIMPLE_ORDER_BY, CTX_SIMPLE_GROUP_BY and CTX_SIMPLE_DISTINCT |
| Csort_with_subqueries_ctx | |
| Csubquery_ctx | Node class to wrap a subquery node tree |
| Ctable_base_ctx | |
| Ctable_with_where_and_derived | Common part of CTX_QEP_TAB and CTX_MESSAGE nodes |
| Cunit_ctx | Helper base class to host HAVING, ORDER BY and GROUP BY subquery nodes |
| Cwindow_ctx | When the query has window functions, an outer node named "windowing" is added: query_block: { select_id: 1, windowing: { windows: [ ... list of all windows' details ... ], nested_loop: [ ... ] |
| Nopt_range | Shared sentinel node for all trees |
| ►Noptions | |
| CMysql_connection | |
| COptions | Command line options container |
| ►Noptions_parser | |
| Cresult | Struct for storing the parsing result |
| ►Npack_rows | |
| CColumn | A class that represents a field, which also holds a cached value of the field's data type |
| CTable | This struct is primarily used for holding the extracted columns in a hash join or BKA join, or the input columns in a streaming aggregation operation |
| CTableCollection | A structure that contains a list of input tables for a hash join operation, BKA join operation or a streaming aggregation operation, and some pre-computed properties for the tables |
| Npfs_plugin_column_bigint_v1_all_empty | |
| Npfs_plugin_column_string_v2_all_empty | |
| Npfs_plugin_column_text_v1_all_empty | |
| Npfs_plugin_table_v1_all_empty | |
| Nportable | |
| Npriority_queue_unittest | |
| Nprotobuf_replication_asynchronous_connection_failover | |
| Npsi_memory_v2_empty | |
| ►Nraii | |
| CSentry | Generic sentry class that invokes some callable object of type F upon disposal of an instance of this class |
| CTargeted_stringstream | Like std::stringstream, copying to a given target string at destruction |
| CThread_stage_guard | RAII guard that sets a thread stage, and restores the previous stage when going out of scope |
| Nrapidjson | |
| ►Nreference_caching | |
| Ncache | |
| Nchannel | |
| Nchannel_ignore_list | |
| Nservice_notification | |
| Ccache_imp | |
| CCache_malloced | |
| Cchannel_imp | |
| CCompare_service_name_entry | |
| CService_name_entry | |
| Cservice_names_set | |
| ►Nregexp | |
| CRegexp_engine | This class exposes high-level regular expression operations to the facade |
| CRegexp_facade | This class handles |
| CUErrorCodeHash | |
| Nregexp_engine_unittest | |
| ►Nresource_blocker | |
| CBlocker | |
| CResource | Represents a "Resource" which can be either "used" by a number of threads, or "blocked" by a number of threads |
| CUser | |
| ►Nresourcegroups | |
| Nplatform | |
| CRange | |
| CResource_group | Class that represents an abstraction of the Resource Group |
| CResource_group_ctx | |
| CResource_group_mgr | This is a singleton class that provides various functionalities related to Resource group management, more importantly the managing and the mapping of resource group names to the corresponding in-memory resource group object |
| CSql_cmd_alter_resource_group | Sql_cmd_alter_resource_group represents ALTER RESOURCE GROUP statement |
| CSql_cmd_create_resource_group | Sql_cmd_create_resource_group represents CREATE RESOURCE GROUP statement |
| CSql_cmd_drop_resource_group | Sql_cmd_drop_resource_group represents DROP RESOURCE GROUP statement |
| CSql_cmd_set_resource_group | Sql_cmd_set_resource_group represents SET RESOURCE GROUP statement |
| CThread_resource_control | Class that abstracts the resource control that can be applied to threads |
| Nrewriter_messages | |
| ►NRoles | |
| CRole_activation | |
| ►Nrouter | |
| Noptions | |
| ►Nrouting | |
| Nimpl | |
| Noptions | |
| ►Nrpl | |
| CRelay_log_sanitizer | Class used to recover relay log files |
| ►Nrules_table_service | |
| CCursor | Writable cursor that allows reading and updating of rows in a persistent table |
| Nsdi_unittest | Namespace from dd_sdi-t unit-test |
| ►Nserver_mock | |
| CAcceptor | |
| CAsyncNotice | |
| ►CDukHeap | Memory heap of duk contexts |
| CHeapDeleter | |
| CDukHeapPool | |
| CDuktapeRuntimeError | |
| ►CDuktapeStatementReader | |
| CPimpl | |
| ►CDuktapeStatementReaderFactory | |
| CFailedStatementReader | |
| CMySQLClassicProtocol | |
| CMySQLServerMock | Main class |
| CMySQLServerMockSession | |
| CMySQLServerMockSessionClassic | |
| CMySQLServerMockSessionX | |
| CMySQLXProtocol | |
| ►CProtocolBase | |
| CSSL_Deleter | |
| CResultsetResponse | Keeps result data for single SQL statement that returns resultset |
| ►CStatementReaderBase | |
| Chandshake_data | |
| CXProtocolDecoder | |
| CXProtocolEncoder | |
| ►Nservices | |
| CArray_ptr | A very limited smart pointer to protect against stack unwinding in case an STL class throws an exception |
| CCondition_handler | This class may inherited and passed to parse() in order to handle conditions raised by the server |
| CDigest | |
| CLex_str | A very limited smart pointer to protect against stack unwinding in case an STL class throws an exception |
| CLiteral_visitor | |
| CSession | |
| ►Nsha2_password | |
| CCaching_sha2_password | Class to handle caching_sha2_authentication Provides methods for: |
| CGenerate_digest | Interface for cryptographic digest generation |
| CGenerate_scramble | Scramble generator Responsible for generating scramble of following format: XOR(SHA2(m_src), SHA2(SHA2(SHA2(m_src)), m_rnd)) |
| CSHA256_digest | SHA256 digest generator |
| Csha2_cache_entry | |
| CSHA2_password_cache | Password cache used for caching_sha2_authentication |
| CValidate_scramble | Scramble validator Expects scramble to be: XOR(SHA2(m_src), SHA2(SHA2(SHA2(m_src)), m_rnd)) Validates it against: SHA2(SHA2(m_src)) and random string |
| Nsoftware | |
| ►Nsrv | |
| Cdynamic_procedure_data_t | Type and data for tracking registered UDFs |
| CDynamic_procedures | |
| Nssl_wrapper_service | |
| ►Nstd | |
| Chash< dd::String_type > | Specialize std::hash for dd::String_type so that it can be used with unordered_ containers |
| Chash< Gcs_xcom_synode > | |
| Cis_error_code_enum< cert_errc > | |
| Cis_error_code_enum< classic_protocol::codec_errc > | |
| Cis_error_code_enum< ConfigFilePathValidatorErrc > | |
| Cis_error_code_enum< DestinationsErrc > | |
| Cis_error_code_enum< http::client::FailureCode > | |
| Cis_error_code_enum< HttpAuthErrc > | |
| Cis_error_code_enum< McfErrc > | |
| Cis_error_code_enum< metadata_cache::metadata_errc > | |
| Cis_error_code_enum< mysql_harness::DynamicLoaderErrc > | |
| Cis_error_code_enum< net::io_service_errc > | |
| Cis_error_code_enum< net::ip::resolver_errc > | |
| Cis_error_code_enum< net::socket_errc > | |
| Cis_error_code_enum< net::stream_errc > | |
| Cis_error_code_enum< TlsCertErrc > | |
| Cis_error_code_enum< TlsErrc > | |
| ►Nstdx | |
| Nbase | |
| ►Nfilesystem | |
| Nimpl | |
| Cpath | |
| ►Nimpl | |
| Chas_element_type | |
| Chas_element_type< T, std::void_t< typename T::element_type > > | |
| Chas_reference | |
| Chas_reference< T, std::void_t< typename T::reference > > | |
| Chas_value_type | |
| Chas_value_type< T, std::void_t< typename std::remove_cvref_t< T >::value_type > > | |
| Cindirectly_readable_traits_array | |
| Cindirectly_readable_traits_array< T, true > | |
| Cindirectly_readable_traits_member_element_type | |
| Cindirectly_readable_traits_member_element_type< T, true > | |
| Cindirectly_readable_traits_member_value_type | |
| Cindirectly_readable_traits_member_value_type< T, true > | |
| Cindirectly_readable_traits_pointer | |
| Cindirectly_readable_traits_pointer< T, true > | |
| Cis_to_stream_writable | |
| Cis_to_stream_writable< S, T, std::void_t< decltype(std::declval< S & >()<< std::declval< T >())> > | |
| Citer_reference | |
| Citer_reference< T, false > | |
| Citer_reference< T, true > | |
| ►Nio | |
| Nimpl | |
| Cfile_handle | |
| Cflag | |
| Cpath_handle | |
| ►Nranges | |
| Nviews | |
| ►Cenumerate_view | Enumerate_view over a range |
| Citerator | |
| Nthis_process | |
| C__is_scoped_enum_helper | |
| C__is_scoped_enum_helper< T, true > | |
| Cexpected | |
| Cexpected< T, E > | |
| Cflags | Type-safe flags type |
| Cindirectly_readable_traits | |
| Cindirectly_readable_traits< const T > | |
| Cindirectly_readable_traits< T *, std::enable_if_t< std::is_object_v< T > > > | |
| Cindirectly_readable_traits< T, std::enable_if_t< impl::has_element_type< T >::value > > | |
| Cindirectly_readable_traits< T, std::enable_if_t< impl::has_value_type< T >::value > > | |
| Cindirectly_readable_traits< T, std::enable_if_t< std::is_array_v< T > > > | |
| Cis_flags | |
| Cis_flags< classic_protocol::message::client::impl::BinlogDump::Flags > | |
| Cis_flags< classic_protocol::message::client::impl::BinlogDumpGtid::Flags > | |
| Cis_flags< StmtClassifier > | |
| Cis_flags< TlsVerifyOpts > | |
| Cis_scoped_enum | |
| Ctype_identity | |
| Cunexpect_t | |
| Cunexpected | |
| ►Nsysd | |
| CNotifyGlobals | Class wrapping the "globals" as static members so that they can only be accessed from the friend-declared notify functions |
| Ntable_access_all_empty_spc | |
| Ntable_cache_unittest | |
| ►Ntemptable | |
| CAllocation_scheme | |
| ►CAllocator | Custom memory allocator |
| Crebind | |
| CAllocatorState | Shared state between all instances of a given allocator |
| CBlock | Memory-block abstraction whose purpose is to serve as a building block for custom memory-allocator implementations |
| CCell | A cell is the intersection of a row and a column |
| CCell_calculator | Utility to perform calculations for a cell |
| CChunk | Chunk is an abstraction with the purpose of representing a smallest logical memory-unit within the Block |
| CColumn | A column class that describes the metadata of a column |
| CCursor | A cursor for iterating over an Index |
| CExponential_policy | |
| CHandler | Temptable engine handler |
| CHash_duplicates | |
| CHash_unique | |
| CHeader | Header is an abstraction with the purpose of holding and maintaining the Block metadata |
| CIndex | Index interface |
| CIndexed_cells | Indexed cells represent one or more cells that are covered by an index |
| CIndexed_cells_equal_to | Indexed cells comparator (a == b) |
| CIndexed_cells_hash | Indexed cells hasher |
| CIndexed_cells_less | Indexed cells comparator (a < b) |
| CIndexed_column | |
| CKey_value_store | Key-value store, a convenience wrapper class which models a thread-safe dictionary type |
| CKey_value_store_logger | Default Key_value_store logging facility which turns to no-op in non-debug builds |
| CKey_value_store_logger< T, true > | Key_value_store logging facility debug builds only |
| CKey_value_store_stats | This is a small convenience POD-like type which describes what kind of details we are interested in when monitoring the behavior of Key_value_store |
| CLargest_lock_free_type_selector | Largest lock-free type selector, a helper utility very much similar to Lock_free_type_selector with the difference being that it tries hard not to fail |
| CLargest_lock_free_type_selector< T, typename std::enable_if< std::is_integral< T >::value >::type > | Template-specialization for integral types |
| CLargest_lock_free_type_selector< T, typename std::enable_if< std::is_pointer< T >::value >::type > | Template-specialization for pointer types |
| CLock_free_pool | Lock-free pool which consists of POOL_SIZE Lock_free_type elements |
| ►CLock_free_shared_block_pool | Lock-free pool of POOL_SIZE Block elements |
| CL1_dcache_aligned_block | In the event of inability to express ourselves with something like std::array<alignas<N> Block> we have to fallback to this method |
| CLock_free_type | Representation of an atomic type which is guaranteed to be always-lock-free |
| CLock_free_type< T, Alignment::L1_DCACHE_SIZE, TypeSelector > | |
| CLock_free_type_selector | Lock-free type selector, a helper utility which evaluates during the compile-time whether the given type T has a property of being always-lock-free for given platform |
| CLock_free_type_selector< T, typename std::enable_if< std::is_class< T >::value and std::is_trivially_copyable< T >::value >::type > | Template-specialization for trivially-copyable classes/structs |
| CLock_free_type_selector< T, typename std::enable_if< std::is_pointer< T >::value >::type > | Template-specialization for pointer types |
| CLock_free_type_selector< T, typename std::enable_if< std::is_same< T, bool >::value >::type > | Template-specialization for boolean types |
| CLock_free_type_selector< T, typename std::enable_if< std::is_same< T, char >::value or std::is_same< T, unsigned char >::value >::type > | Template-specialization for char types |
| CLock_free_type_selector< T, typename std::enable_if< std::is_same< T, int >::value or std::is_same< T, unsigned int >::value >::type > | Template-specialization for int types |
| CLock_free_type_selector< T, typename std::enable_if< std::is_same< T, long >::value or std::is_same< T, unsigned long >::value >::type > | Template-specialization for long types |
| CLock_free_type_selector< T, typename std::enable_if< std::is_same< T, long long >::value or std::is_same< T, unsigned long long >::value >::type > | Template-specialization for long long types |
| CLock_free_type_selector< T, typename std::enable_if< std::is_same< T, short >::value or std::is_same< T, unsigned short >::value >::type > | Template-specialization for short types |
| CMemory | Primary-template (functor) class for memory-utils |
| CMemory< Source::MMAP_FILE > | Template specialization for MMAP-based allocation/deallocation |
| CMemory< Source::RAM > | Template specialization for RAM-based allocation/deallocation |
| ►CMemoryMonitor | |
| CMMAP | |
| CRAM | |
| CPrefer_RAM_over_MMAP_policy | |
| CRow | A row representation |
| ►CSharded_key_value_store | Sharded key-value store, a convenience wrapper class around Key_value_store that creates N_SHARDS instances of Key_value_store and exposes a simple interface to further manipulate with them |
| CL1_dcache_aligned_kv_store | In the event of inability to express ourselves with something like std::array<alignas<N> Key_value_store<...>> we have to fallback to this method |
| CSharded_key_value_store_logger | Default Sharded_key_value_store logging facility which turns to no-op in non-debug builds |
| CSharded_key_value_store_logger< T, true > | Sharded_key_value_store logging facility debug builds only |
| ►CStorage | Storage container |
| CIterator | Iterator over a Storage object |
| ►CTable | |
| CIndex_entry | Index entry for storing index pointer as well as allocated memory size |
| CTableResourceMonitor | |
| CTree | |
| Ntemptable_aggregate_iterator | |
| ►Nterminology_use_previous | In respect to the organization of modules, this really belongs in terminology_use_previous.h |
| Ccompatible_name_t | Encapsulates a <name, version> pair, holding an instrumentation name, and the version before which it was in use by the server |
| ►Ntest_trace | |
| CLogger | |
| Cst_trace_data | State information maintained by the test trace plugin for each traced connection |
| ►Ntls | |
| CTlsKeylogDumper | |
| CTlsMessageDumper | |
| Ntrx_coordinator | |
| Nudf_registration_all_empty_spc | |
| ►Nundo | |
| CInject_failure_once | Inject a failure in the undo truncation debug compiled code at various places so that it fails the first time it hits and succeeds after that |
| Cspace_id_account | The currently used undo space IDs for an undo space number along with a boolean showing whether the undo space number is in use |
| CTablespace | An undo::Tablespace object is used to easily convert between undo_space_id and undo_space_num and to create the automatic file_name and space name |
| CTablespaces | List of undo tablespaces, each containing a list of rollback segments |
| CTruncate | Track an UNDO tablespace marked for truncate |
| ►Nut | This file contains a set of libraries providing overloads for regular dynamic allocation routines which allow for opt-in memory instrumentation through performance schema memory engine (PFS) |
| ►Ndetail | |
| CAligned_alloc | Aligned allocation routines |
| CAligned_alloc_ | Small wrapper which utilizes SFINAE to dispatch the call to appropriate aligned allocator implementation |
| CAligned_alloc_impl | |
| CAligned_alloc_metadata | Memory layout representation of metadata segment guaranteed by the inner workings of Aligned_alloc_impl |
| CAligned_alloc_pfs | Aligned allocation routines which are instrumented through PFS (performance-schema) |
| CAligned_array_deleter | |
| CAligned_deleter | |
| CAlloc | Allocation routines for non-extended alignment types, as opposed to Aligned_alloc for example |
| CAlloc_ | Small wrapper which utilizes SFINAE to dispatch the call to appropriate allocator implementation |
| CAlloc_arr | Specialization of allocation routines for non-extended alignment types but which in comparison to Alloc are providing support for arrays |
| CAlloc_fn | Simple wrapping type around malloc, calloc and friends |
| CAlloc_pfs | Allocation routines for non-extended alignment types, as opposed to Aligned_alloc_pfs for example, but which are instrumented through PFS (performance-schema) |
| Callocator_base | |
| Callocator_base_pfs | |
| Callocator_traits | Simple allocator traits |
| CArray_deleter | |
| CDeleter | |
| CLarge_alloc_ | Small wrapper which utilizes SFINAE to dispatch the call to appropriate aligned allocator implementation |
| CLarge_page_alloc | Allocation routines which are purposed for allocating memory through the means of what is known as large (huge) pages |
| CLarge_page_alloc_pfs | Allocation routines which are purposed for allocating memory through the means of what is known as large (huge) pages |
| CPage_alloc | Allocation routines which are purposed for allocating system page-aligned memory |
| CPage_alloc_ | Small wrapper which utilizes SFINAE to dispatch the call to appropriate aligned allocator implementation |
| CPage_alloc_metadata | Helper struct implementing the type which represents the metadata for all types of page-aligned allocations, be it regular pages or huge-pages |
| CPage_alloc_metadata_pfs | Helper struct implementing the type which represents the metadata for all types of PFS-aware page-aligned allocations, be it regular pages or huge-pages |
| CPage_alloc_pfs | Allocation routines which are purposed for allocating system page-aligned memory |
| CPFS_metadata | Memory layout representation of PFS metadata segment that is used by the allocator variants which also want to trace the memory consumption through PFS (PSI) interface |
| Cselect_alloc_impl | Simple utility metafunction which selects appropriate allocator variant (implementation) depending on the input parameter(s) |
| Cselect_alloc_impl< true > | |
| Cselect_large_page_alloc_impl | Simple utility metafunction which selects appropriate allocator variant (implementation) depending on the input parameter(s) |
| Cselect_large_page_alloc_impl< true > | |
| Cselect_malloc_impl | Simple utility metafunction which selects appropriate allocator variant (implementation) depending on the input parameter(s) |
| Cselect_malloc_impl< false, false > | |
| Cselect_malloc_impl< false, true > | |
| Cselect_malloc_impl< true, Array_specialization > | |
| Cselect_page_alloc_impl | Simple utility meta-function which selects appropriate allocator variant (implementation) depending on the input parameter(s) |
| Cselect_page_alloc_impl< true > | |
| Caligned_array_pointer | Lightweight convenience wrapper which manages a dynamically allocated array of over-aligned types |
| Caligned_pointer | Lightweight convenience wrapper which manages dynamically allocated over-aligned type |
| Callocation_low_level_info | Can be used to extract pointer and size of the allocation provided by the OS |
| ►Callocator | Allocator that allows std::* containers to manage their memory through ut::malloc* and ut::free library functions |
| Crebind | |
| Cbool_scope_guard_t | A RAII-style class, which sets a given boolean to true in constructor, and to false in destructor, effectively making sure that it is true for the duration of the object lifetime/scope |
| CCacheline_aligned | A utility wrapper class, which aligns T to cacheline boundary |
| CCacheline_padded | A utility wrapper class, which adds padding at the end of the wrapped structure, so that the next object after it is guaranteed to be in the next cache line |
| CCount | Light-weight and type-safe wrapper which serves a purpose of being able to select proper ut::new_arr* overload |
| Cfallback_to_normal_page_t | |
| Cfast_modulo_t | Allows to execute x % mod for a specified mod in a fast way, without using a slow operation of division |
| CGuarded | |
| CLocation | |
| ►Cmt_fast_modulo_t | A class that allows to atomically set new modulo value for fast modulo computations |
| Cdata_t | |
| CNon_copyable | A utility class which, if inherited from, prevents the descendant class from being copied, moved, or assigned |
| CObject_cache | A class to manage objects of type T |
| CPSI_memory_key_t | Light-weight and type-safe wrapper around the PSI_memory_key that eliminates the possibility of introducing silent bugs through the course of implicit conversions and makes them show up as compile-time errors |
| CSeq_lock | A class that allows to read value of variable of some type T atomically and allows the value to be changed, all using lock-free operations |
| CSharded_bitset | A Sharded_bitset<SHARDS_COUNT>(n) is like a bitset<n> in that it represents a vector of n bits, which can be set(pos) or reset(pos) for 0<=pos<n |
| ►CStateful_latching_rules | This is a generic mechanism for verifying correctness of latching rules for state transitions and querying for state of a system |
| Cedge_t | The type for a possible transition from one state to another while holding at least a given set of latches |
| CTodo_counter | A counter which tracks number of things left to do, which can be incremented or decremented, and lets one await the value drop to zero |
| ►NVt100 | |
| Nanonymous_namespace{vt100.h} | |
| ►Nxa | |
| Nextractor | |
| Nrecovery | |
| CTransaction_cache | Class responsible for managing a cache of Transaction_ctx objects associated with XA transactions |
| CXID_extractor | Processes a string and extracts XIDs of the form X'...',X'...',0-9 |
| Nxcl |
1.9.2