 |
MySQL 8.0.41
Source Code Documentation
|
|
MySQL 8.0.41
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{check_stack.cc} | |
| Nanonymous_namespace{classic_connect.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{columns_extensions.cc} | |
| Nanonymous_namespace{common_subexpression_elimination.cc} | |
| ►Nanonymous_namespace{config_generator.cc} | |
| Caccount_exists | |
| CChangeRouterAccountPlugin | |
| CConfigSectionPrinter | |
| Cpassword_too_weak | |
| ►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{dest_metadata_cache.cc} | |
| 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{explain_access_path.cc} | |
| 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 |
| CMockShare | |
| Nanonymous_namespace{ha_myisammrg.cc} | |
| ►Nanonymous_namespace{handler.cc} | |
| CStorage_engine_identifier | |
| ►Nanonymous_namespace{http_auth_backend_plugin.cc} | |
| CHtpasswdPluginConfig | |
| CHttpAuthBackendFactory | |
| CPluginConfig | |
| Nanonymous_namespace{init.cc} | |
| ►Nanonymous_namespace{interesting_orders.cc} | |
| CDFSMStateEqual | |
| CDFSMStateHash | |
| ►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} | |
| ►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 |
| CKeypartForRef | |
| CPossibleIndexMerge | Represents a candidate index merge, ie |
| CPossibleRangeScan | |
| Nanonymous_namespace{json_binary.cc} | |
| ►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} | |
| CStream | A simple input stream class for the JSON path parser |
| Nanonymous_namespace{keepalive.cc} | |
| ►Nanonymous_namespace{locked_tables_list.cc} | |
| CMDL_ticket_same_lock_eq | |
| CMDL_ticket_same_lock_hash | |
| Nanonymous_namespace{logger_plugin.cc} | |
| 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{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_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{recovery.cc} | |
| Nanonymous_namespace{registry.cc} | |
| ►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{rewriter.cc} | |
| CRefresh_callback_args | |
| Nanonymous_namespace{router_app.cc} | |
| Nanonymous_namespace{rpl_group_replication.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_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} | |
| CExecute_sql_statement | Execute one SQL statement in an isolated context |
| 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} | |
| 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_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{window_iterators.cc} | |
| ►Nauth_kerberos_context | |
| CKerberos | |
| ►Nauth_ldap_client_kerberos_context | Kerberos class is built around kerberos library |
| CKerberos | |
| NBackup_comp_constants | |
| ►NBase64Alphabet | |
| Ndetail | |
| CBase64 | |
| CBase64Url | |
| CBcrypt | |
| CCrypt | |
| CMcf | Base64 alphabet for MCF |
| CUuencode | |
| ►Nbinary_log | 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 | |
| ►Ngtids | |
| 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 |
| CUuid_comparator | |
| ►Ntransaction | |
| ►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 |
| 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) |
| CHash_Uuid | |
| 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 | Struct to pass basic information about a event: type, query, is it ignorable |
| 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_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_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 |
| CUuid | This is a POD |
| 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 |
| 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 | |
| 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 |
| ►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 | |
| ►Nbuf | |
| CBlock_hint | |
| ►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 | |
| 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::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 |
| ►Ncomponents | |
| CDestination_keyring_services | |
| CKeyring_component_load | |
| CKeyring_migrate | |
| CKeyring_services | |
| CSource_keyring_services | |
| 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 | |
| ►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 |
| ►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 |
| ►Nupgrade_57 | |
| CCheck_table_intact | Class to check the system tables we are using from 5.7 are not corrupted before migrating the information to new DD |
| CHandle_old_incorrect_sql_modes_hook | |
| CSystem_table_close_guard | RAII for handling open and close of event and proc tables |
| CTable_upgrade_guard | RAII to handle cleanup after table upgrading |
| CThd_mem_root_guard | THD::mem_root is only switched with the given mem_root and switched back on destruction |
| CTrg_file_data | Structure representing contents of .TRG file |
| CTrigger_loader | Class to handle loading and parsing of Triggers |
| CUpgrade_MDL_guard | RAII to handle MDL locks while upgrading |
| CUpgrade_status | Class to manage a temporary file to maintain the progress of the upgrade |
| 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 |
| Ndetail | |
| Ndict_name | Innodb data dictionary name |
| ►NEventBufferOptionsFlags | Flags that represents different bufferevent options |
| NPos | |
| ►NEventFlags | Flags that represents which I/O events should be monitored |
| NPos | |
| ►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 |
| ►Ngr | |
| ►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 | |
| ►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 | |
| ►Nhistograms | |
| ►Nequi_height | |
| CBucket | Equi-height bucket |
| CEqui_height | |
| CError_context | Error context to validate given JSON object which represents a histogram |
| CHistogram | Histogram base class |
| CHistogram_comparator | Histogram comparator |
| CHistogram_error_handler | RAII class to trap lower-level errors |
| CHistogram_psi_key_alloc | |
| CSingleton | |
| CSingletonBucket | |
| CValue_map | Value_map class |
| CValue_map_base | The abstract base class for all Value_map types |
| ►NHttpMethod | |
| NPos | |
| 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 | |
| ►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 |
| 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 | |
| CQueryBlock | A 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 |
| 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 |
| 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_boost | |
| ►Cthread | |
| Ccontext | |
| Cthread_group | |
| Nmy_testing | |
| Nmycrc32 | |
| ►Nmysql | |
| 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 | |
| ►NBase | |
| ►NOptions | |
| CAbstract_enum_option | Abstract option to handle enum option values |
| CAbstract_integer_number_option | Abstract option to handle integer number option values |
| CAbstract_number_option | Abstract option to handle numeric option values |
| CAbstract_option | Abstract base with common option functionalities |
| CAbstract_options_provider | Common abstract class for options providers |
| CAbstract_string_option | Abstract option to handle options accepting string value argument |
| CAbstract_value_option | Abstract option to handle options accepting value argument |
| CBool_option | Boolean option with value specified as argument |
| CChar_array_option | Option class to get string parameter value and set to char* type object |
| CComposite_options_provider | Provider that aggregates options from other providers |
| CDebug_options | Options provider providing debugging options |
| CDisabled_option | Disabled option |
| CEnum_option | Enum value option |
| CHelp_options | Options provider providing –help option and handling usage printing |
| CI_option | Common interface for all program option objects |
| CI_option_changed_listener | Interface for listeners on some of option changes |
| CI_options_provider | Interface for basic options providers functionality |
| ►CMysql_connection_options | Options provider providing options to specify connection to MySQL server |
| CSsl_options | Options provider enclosing options related to SSL settings of connection to MySQL server |
| CNumber_option | Template class for all number options |
| CNumber_option< double > | Double precision floating-point number option |
| CNumber_option< int32 > | 32-bit signed number option |
| CNumber_option< int64 > | 64-bit signed number option |
| CNumber_option< uint32 > | 32-bit unsigned number option |
| CNumber_option< uint64 > | 64-bit unsigned number option |
| CPassword_option | String value option to handle passwords |
| CSimple_option | Simple boolean option |
| CString_option | String value option |
| CAbstract_connection_program | Base class for all programs that use connection to MySQL database server |
| CAbstract_program | Base class for all MySQL client tools |
| CI_connection_factory | Interface for classes that are capable of creating connection to MySQL database server |
| CMessage_data | Structure to represent message from server sent after executing query |
| ►CMysql_query_runner | Helper class to run SQL query on existing MySQL database server connection, receive all data and all errors, warnings and notes returned during query execution |
| ►CRow | |
| CIterator | |
| CStore_result_helper | |
| CShow_variable_query_extractor | Extracts the value of server variable |
| CWarning_data | |
| ►NCheck | |
| CProgram | This class is object wrapper to mysql_check function |
| ►NDump | |
| ►NDetail | |
| CPattern_matcher | |
| CAbstract_chain_element | |
| ►CAbstract_connection_provider | |
| CMessage_handler_wrapper | |
| CAbstract_crawler | |
| CAbstract_data_formatter_wrapper | Implementation of common logic for classes that directs execution of dump tasks to Data Formatters |
| CAbstract_data_object | Base class for all main DB objects |
| CAbstract_database_dump_task | Abstract class for defining single database definition dump task |
| CAbstract_dump_task | Base class for most individual dump process tasks, not suitable for lightweight dump tasks (e.g |
| CAbstract_mysql_chain_element_extension | |
| CAbstract_object_reader_wrapper | Implementation of common logic for classes that directs execution of dump tasks to Object Readers |
| CAbstract_output_writer_wrapper | Implementation of common logic for classes that directs execution of dump tasks to Data Formatters |
| CAbstract_plain_sql_object | Abstract object carrying its definition in SQL formatted string only |
| CAbstract_plain_sql_object_dump_task | Abstract task for dumping object carrying its definition in SQL formatted string only |
| CAbstract_progress_reporter | |
| ►CAbstract_progress_watcher | Gathers information about progress of current dump progress and format messages on progress.Also it should expose API for receiving processed progress information: collected objects and rows information along with time elapsed, ETA |
| CProgress_data | |
| CAbstract_simple_dump_task | Base class for all individual dump process tasks |
| CAbstract_table_dump_task | Abstract class for defining single DB table dump task |
| CChain_data | |
| CColumn_statistic | |
| CComposite_message_handler | |
| CCompression_lz4_writer | Wrapper to another Output Writer, compresses formatted data stream with LZ4 |
| CCompression_zlib_writer | Wrapper to another Output Writer, compresses formatted data stream with zlib |
| CDatabase | |
| CDatabase_end_dump_task | |
| CDatabase_start_dump_task | |
| CDump_end_dump_task | |
| CDump_start_dump_task | |
| CEvent_scheduler_event | |
| CField | |
| CFile_writer | Writes formatted data to specified file |
| CI_chain_element | Interface for all objects that can process data in any part of dump process |
| CI_chain_maker | |
| CI_connection_provider | |
| CI_crawler | |
| CI_data_formatter | |
| CI_data_formatter_wrapper | Represents class that directs execution of dump tasks to Data Formatters |
| CI_data_object | |
| CI_dump_task | Interface for all individual dump process tasks |
| CI_object_reader | |
| CI_object_reader_wrapper | Represents class that directs execution of dump tasks to Object Readers |
| CI_output_writer | |
| CI_output_writer_wrapper | Represents class that directs execution of dump tasks to Output Writers |
| CI_progress_reporter | |
| CI_progress_watcher | |
| CItem_processing_data | Data structure for objects that are processed in any chain |
| CMysql_chain_element_options | |
| CMysql_crawler | Searches DB objects using connection to MYSQL server |
| CMysql_field | |
| CMysql_function | |
| ►CMysql_object_reader | Parses any DB object(excluding rows and privileges for DB objects) data using connection to MySQL server |
| CRows_fetching_context | |
| CMysql_object_reader_options | |
| CMysqldump_tool_chain_maker | Chain maker implemented in Mysql_dump application, constructs chain based on command line options that are compatible with these available in previous implementation |
| CMysqldump_tool_chain_maker_options | |
| CObject_filter | |
| CObject_queue | Wrapper to another Object Reader, adds all objects to read on queue |
| CPrivilege | |
| CProgram | |
| CRow | Represents single data row |
| CRow_group_dump_task | Represents single data row |
| CSimple_id_generator | |
| CSingle_transaction_connection_provider | |
| CSql_formatter | Prints object data in SQL format |
| CSql_formatter_options | |
| CStandard_progress_watcher | |
| CStandard_writer | Writes formatted data to standard output or error stream |
| CStored_procedure | |
| CTable | |
| CTable_deferred_indexes_dump_task | Represents task for deferred creation secondary indexes for single DB table |
| CTable_definition_dump_task | Represents single DB table DDL creation task |
| CTable_rows_dump_task | Represents task for extracting rows of single DB table |
| CTables_definition_ready_dump_task | Represents task for additional work once all Table_definition_dump_task are processed |
| CThread_specific_connection_provider | |
| CTrigger | |
| CView | |
| ►NUpgrade | |
| CProgram | |
| Nmysql_cond_v1_native | |
| ►Nmysql_harness | |
| Nanonymous_namespace{random_generator.cc} | |
| Nanonymous_namespace{string_utils.cc} | |
| ►Ndetail | |
| CJoin | |
| CJoin< Container, const char * > | |
| CJoin< Container, std::string > | |
| ►Nimpl | |
| CDeleter_SSL | |
| ►Nlogging | |
| 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 | |
| ►CDirectory | Class representing a directory in a file system |
| ►CDirectoryIterator | Directory iterator for iterating over directory entries |
| ►CState | |
| Cfree_dealloc | |
| CDurationOption | |
| 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 |
| 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_simple_error_log_spc | |
| ►Nmysqld | |
| Nruntime | |
| Nmysqld_funcs_unit_test | |
| ►Nmysqlns | |
| ►Nbuffer | |
| ►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 |
| Nmath | |
| ►Nresource | |
| CAllocator | Allocator using a Memory_resource to do the allocator |
| CMemory_resource | Polymorphism-free memory resource class with custom allocator and deallocator functions |
| ►Nstring | |
| Ninternal | |
| ►Nmysqlrouter | |
| Nanonymous_namespace{cluster_metadata.cc} | |
| ►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 | |
| CClusterMetadataGRV1 | |
| CClusterMetadataGRV2 | |
| ►CConfigGenerator | |
| CExistingConfigOptions | |
| ►COptions | |
| CEndpoint | |
| CTLS_filenames | |
| CUndoCreateAccountList | |
| CLogFilter | |
| CMetadataSchemaVersion | |
| CMetadataUpgradeInProgressException | |
| CMySQLClientThreadToken | Thread Token for libmysqlclient API users |
| CMysqlError | |
| ►CMySQLSession | |
| CError | |
| CLoggingStrategy | |
| CLoggingStrategyDebugLogger | |
| CLoggingStrategyNone | |
| 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 |
| 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_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 | |
| Ccache_imp | |
| CCache_malloced | |
| Cchannel_imp | |
| 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 | |
| ►Nrouting | |
| Nimpl | |
| ►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_default_constructible< std::unique_ptr< T, void(*)(T *)> > | |
| 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< 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 | |
| Cassign_base | |
| Cassign_base< member_policy::copy > | |
| Cassign_base< member_policy::copy|member_policy::move > | |
| Cassign_base< member_policy::move > | |
| Cassign_base< member_policy::none > | |
| Cctor_base | |
| Cctor_base< member_policy::copy > | |
| Cctor_base< member_policy::move > | |
| Cctor_base< member_policy::move|member_policy::copy > | |
| Cctor_base< member_policy::none > | |
| Cdefault_ctor_base | |
| Cdefault_ctor_base< false > | |
| Cstorage_t | |
| Cstorage_t< void, E > | Specialized storage for <void, E> |
| ►Ndetail | |
| Cextent_size | |
| Cextent_size< Extent, Offset, dynamic_extent > | |
| Chas_data | |
| Chas_data< C, std::void_t< decltype(std::data(std::declval< C >()))> > | |
| Chas_size | |
| Chas_size< C, std::void_t< decltype(std::size(std::declval< C >()))> > | |
| Cis_array_convertible | |
| Cis_compatible_element | |
| Cis_compatible_element< C, E, std::void_t< decltype(std::data(std::declval< C >()))> > | |
| Cis_compatible_range | |
| Cis_contiguous_range | |
| Cis_sized_range | |
| Cis_span | |
| Cis_span_impl | |
| Cis_span_impl< span< T, Extend > > | |
| Cis_std_array | |
| Cis_std_array_impl | |
| Cis_std_array_impl< std::array< T, Extend > > | |
| Citerator | |
| Cspan_size | |
| Cspan_size< T, dynamic_extent > | |
| ►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 stdx::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 | |
| CExpectedImpl | |
| CExpectedImpl< void, E > | |
| CExpectedImplBase | |
| 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_expected_impl | |
| Cis_expected_impl< expected< T, E > > | |
| Cis_flags | |
| Cis_flags< classic_protocol::message::client::impl::BinlogDump::Flags > | |
| Cis_flags< classic_protocol::message::client::impl::BinlogDumpGtid::Flags > | |
| Cis_flags< StmtClassifier > | |
| Cis_scoped_enum | |
| Cremove_cvref | |
| Cspan | |
| 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 |
| ►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 | |
| CPrefer_RAM_over_MMAP_policy_obeying_per_table_limit | |
| 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 |
| NTlsVerifyOpts | |
| Ntrx_coordinator | |
| ►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 |
| 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 |
| ►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 
